Stowage/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2025-12-07 22:00:10 +00:00
Code Issues Projects Releases Packages Wiki Activity

GLTF: Use const Vector internally instead of TypedArray copies

Browse source
This commit is contained in:
Aaron Franke 2025-11-25 11:45:25 -08:00
parent 7ed0b61676
commit 342088ca31
No known key found for this signature in database
GPG key ID: 40A1750B977E56BF
9 changed files with 532 additions and 215 deletions
Download patch file Download diff file Expand all files Collapse all files

38
misc/extension_api_validation/4.5-stable.expected
View file

@ -136,3 +136,41 @@ GH-109302
Validate extension JSON: Error: Field 'classes/OpenXRExtensionWrapper/methods/_set_instance_create_info_and_get_next_pointer/arguments': size changed value in new API, from 1 to 2. Validate extension JSON: Error: Field 'classes/OpenXRExtensionWrapper/methods/_set_instance_create_info_and_get_next_pointer/arguments': size changed value in new API, from 1 to 2.
Validate extension JSON: Error: Field 'classes/OpenXRExtensionWrapper/methods/_set_instance_create_info_and_get_next_pointer/arguments/0': type changed value in new API, from "void*" to "int". Validate extension JSON: Error: Field 'classes/OpenXRExtensionWrapper/methods/_set_instance_create_info_and_get_next_pointer/arguments/0': type changed value in new API, from "void*" to "int".
Validate extension JSON: JSON file: Field was added in a way that breaks compatibility 'classes/OpenXRExtensionWrapper/methods/_get_requested_extensions': arguments Validate extension JSON: JSON file: Field was added in a way that breaks compatibility 'classes/OpenXRExtensionWrapper/methods/_get_requested_extensions': arguments
GH-113172
---------
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_accessors': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_additional_data': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_animation_player': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_animation_players_count': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_animations': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_base_path': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_buffer_views': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_buffers': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_cameras': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_create_animations': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_glb_data': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_handle_binary_image': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_images': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_import_as_skeleton_bones': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_json': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_lights': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_major_version': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_materials': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_meshes': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_minor_version': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_node_index': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_nodes': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_root_nodes': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_scene_name': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_scene_node': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_skeletons': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_skins': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_texture_samplers': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_textures': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_unique_animation_names': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_unique_names': is_const changed value in new API, from false to true.
Validate extension JSON: Error: Field 'classes/GLTFState/methods/get_use_named_skin_binds': is_const changed value in new API, from false to true.
GLTFState getters made const. Compatibility methods registered.

48
modules/gltf/doc_classes/GLTFState.xml
View file

@ -39,12 +39,12 @@
The [param parent_node_index] parameter is the index of the parent [GLTFNode] in the state. If [code]-1[/code], the node will be a root node, otherwise the new node will be added to the parent's list of children. The index will also be written to the [member GLTFNode.parent] property of the new node. The [param parent_node_index] parameter is the index of the parent [GLTFNode] in the state. If [code]-1[/code], the node will be a root node, otherwise the new node will be added to the parent's list of children. The index will also be written to the [member GLTFNode.parent] property of the new node.
</description> </description>
</method> </method>
<method name="get_accessors"> <method name="get_accessors" qualifiers="const">
<return type="GLTFAccessor[]" /> <return type="GLTFAccessor[]" />
<description> <description>
</description> </description>
</method> </method>
<method name="get_additional_data"> <method name="get_additional_data" qualifiers="const">
<return type="Variant" /> <return type="Variant" />
<param index="0" name="extension_name" type="StringName" /> <param index="0" name="extension_name" type="StringName" />
<description> <description>
@ -52,67 +52,67 @@
The argument should be the [GLTFDocumentExtension] name (does not have to match the extension name in the glTF file), and the return value can be anything you set. If nothing was set, the return value is [code]null[/code]. The argument should be the [GLTFDocumentExtension] name (does not have to match the extension name in the glTF file), and the return value can be anything you set. If nothing was set, the return value is [code]null[/code].
</description> </description>
</method> </method>
<method name="get_animation_player"> <method name="get_animation_player" qualifiers="const">
<return type="AnimationPlayer" /> <return type="AnimationPlayer" />
<param index="0" name="idx" type="int" /> <param index="0" name="anim_player_index" type="int" />
<description> <description>
Returns the [AnimationPlayer] node with the given index. These nodes are only used during the export process when converting Godot [AnimationPlayer] nodes to glTF animations. Returns the [AnimationPlayer] node with the given index. These nodes are only used during the export process when converting Godot [AnimationPlayer] nodes to glTF animations.
</description> </description>
</method> </method>
<method name="get_animation_players_count"> <method name="get_animation_players_count" qualifiers="const">
<return type="int" /> <return type="int" />
<param index="0" name="idx" type="int" /> <param index="0" name="anim_player_index" type="int" />
<description> <description>
Returns the number of [AnimationPlayer] nodes in this [GLTFState]. These nodes are only used during the export process when converting Godot [AnimationPlayer] nodes to glTF animations. Returns the number of [AnimationPlayer] nodes in this [GLTFState]. These nodes are only used during the export process when converting Godot [AnimationPlayer] nodes to glTF animations.
</description> </description>
</method> </method>
<method name="get_animations"> <method name="get_animations" qualifiers="const">
<return type="GLTFAnimation[]" /> <return type="GLTFAnimation[]" />
<description> <description>
Returns an array of all [GLTFAnimation]s in the glTF file. When importing, these will be generated as animations in an [AnimationPlayer] node. When exporting, these will be generated from Godot [AnimationPlayer] nodes. Returns an array of all [GLTFAnimation]s in the glTF file. When importing, these will be generated as animations in an [AnimationPlayer] node. When exporting, these will be generated from Godot [AnimationPlayer] nodes.
</description> </description>
</method> </method>
<method name="get_buffer_views"> <method name="get_buffer_views" qualifiers="const">
<return type="GLTFBufferView[]" /> <return type="GLTFBufferView[]" />
<description> <description>
</description> </description>
</method> </method>
<method name="get_cameras"> <method name="get_cameras" qualifiers="const">
<return type="GLTFCamera[]" /> <return type="GLTFCamera[]" />
<description> <description>
Returns an array of all [GLTFCamera]s in the glTF file. These are the cameras that the [member GLTFNode.camera] index refers to. Returns an array of all [GLTFCamera]s in the glTF file. These are the cameras that the [member GLTFNode.camera] index refers to.
</description> </description>
</method> </method>
<method name="get_handle_binary_image" deprecated="Use [member handle_binary_image_mode] instead."> <method name="get_handle_binary_image" qualifiers="const" deprecated="Use [member handle_binary_image_mode] instead.">
<return type="int" /> <return type="int" />
<description> <description>
Deprecated untyped alias for [member handle_binary_image_mode]. When importing a glTF file with unimported raw binary images embedded inside of binary blob buffers, in data URIs, or separate files not imported by Godot, this controls how the images are handled. Deprecated untyped alias for [member handle_binary_image_mode]. When importing a glTF file with unimported raw binary images embedded inside of binary blob buffers, in data URIs, or separate files not imported by Godot, this controls how the images are handled.
</description> </description>
</method> </method>
<method name="get_images"> <method name="get_images" qualifiers="const">
<return type="Texture2D[]" /> <return type="Texture2D[]" />
<description> <description>
Gets the images of the glTF file as an array of [Texture2D]s. These are the images that the [member GLTFTexture.src_image] index refers to. Gets the images of the glTF file as an array of [Texture2D]s. These are the images that the [member GLTFTexture.src_image] index refers to.
</description> </description>
</method> </method>
<method name="get_lights"> <method name="get_lights" qualifiers="const">
<return type="GLTFLight[]" /> <return type="GLTFLight[]" />
<description> <description>
Returns an array of all [GLTFLight]s in the glTF file. These are the lights that the [member GLTFNode.light] index refers to. Returns an array of all [GLTFLight]s in the glTF file. These are the lights that the [member GLTFNode.light] index refers to.
</description> </description>
</method> </method>
<method name="get_materials"> <method name="get_materials" qualifiers="const">
<return type="Material[]" /> <return type="Material[]" />
<description> <description>
</description> </description>
</method> </method>
<method name="get_meshes"> <method name="get_meshes" qualifiers="const">
<return type="GLTFMesh[]" /> <return type="GLTFMesh[]" />
<description> <description>
Returns an array of all [GLTFMesh]es in the glTF file. These are the meshes that the [member GLTFNode.mesh] index refers to. Returns an array of all [GLTFMesh]es in the glTF file. These are the meshes that the [member GLTFNode.mesh] index refers to.
</description> </description>
</method> </method>
<method name="get_node_index"> <method name="get_node_index" qualifiers="const">
<return type="int" /> <return type="int" />
<param index="0" name="scene_node" type="Node" /> <param index="0" name="scene_node" type="Node" />
<description> <description>
@ -120,50 +120,50 @@
[b]Note:[/b] Not every Godot scene node will have a corresponding [GLTFNode], and not every [GLTFNode] will have a scene node generated. If there is no [GLTFNode] index for this scene node, [code]-1[/code] is returned. [b]Note:[/b] Not every Godot scene node will have a corresponding [GLTFNode], and not every [GLTFNode] will have a scene node generated. If there is no [GLTFNode] index for this scene node, [code]-1[/code] is returned.
</description> </description>
</method> </method>
<method name="get_nodes"> <method name="get_nodes" qualifiers="const">
<return type="GLTFNode[]" /> <return type="GLTFNode[]" />
<description> <description>
Returns an array of all [GLTFNode]s in the glTF file. These are the nodes that [member GLTFNode.children] and [member root_nodes] refer to. This includes nodes that may not be generated in the Godot scene, or nodes that may generate multiple Godot scene nodes. Returns an array of all [GLTFNode]s in the glTF file. These are the nodes that [member GLTFNode.children] and [member root_nodes] refer to. This includes nodes that may not be generated in the Godot scene, or nodes that may generate multiple Godot scene nodes.
</description> </description>
</method> </method>
<method name="get_scene_node"> <method name="get_scene_node" qualifiers="const">
<return type="Node" /> <return type="Node" />
<param index="0" name="idx" type="int" /> <param index="0" name="gltf_node_index" type="int" />
<description> <description>
Returns the Godot scene node that corresponds to the same index as the [GLTFNode] it was generated from. This is the inverse of [method get_node_index]. Useful during the import process. Returns the Godot scene node that corresponds to the same index as the [GLTFNode] it was generated from. This is the inverse of [method get_node_index]. Useful during the import process.
[b]Note:[/b] Not every [GLTFNode] will have a scene node generated, and not every generated scene node will have a corresponding [GLTFNode]. If there is no scene node for this [GLTFNode] index, [code]null[/code] is returned. [b]Note:[/b] Not every [GLTFNode] will have a scene node generated, and not every generated scene node will have a corresponding [GLTFNode]. If there is no scene node for this [GLTFNode] index, [code]null[/code] is returned.
</description> </description>
</method> </method>
<method name="get_skeletons"> <method name="get_skeletons" qualifiers="const">
<return type="GLTFSkeleton[]" /> <return type="GLTFSkeleton[]" />
<description> <description>
Returns an array of all [GLTFSkeleton]s in the glTF file. These are the skeletons that the [member GLTFNode.skeleton] index refers to. Returns an array of all [GLTFSkeleton]s in the glTF file. These are the skeletons that the [member GLTFNode.skeleton] index refers to.
</description> </description>
</method> </method>
<method name="get_skins"> <method name="get_skins" qualifiers="const">
<return type="GLTFSkin[]" /> <return type="GLTFSkin[]" />
<description> <description>
Returns an array of all [GLTFSkin]s in the glTF file. These are the skins that the [member GLTFNode.skin] index refers to. Returns an array of all [GLTFSkin]s in the glTF file. These are the skins that the [member GLTFNode.skin] index refers to.
</description> </description>
</method> </method>
<method name="get_texture_samplers"> <method name="get_texture_samplers" qualifiers="const">
<return type="GLTFTextureSampler[]" /> <return type="GLTFTextureSampler[]" />
<description> <description>
Retrieves the array of texture samplers that are used by the textures contained in the glTF. Retrieves the array of texture samplers that are used by the textures contained in the glTF.
</description> </description>
</method> </method>
<method name="get_textures"> <method name="get_textures" qualifiers="const">
<return type="GLTFTexture[]" /> <return type="GLTFTexture[]" />
<description> <description>
</description> </description>
</method> </method>
<method name="get_unique_animation_names"> <method name="get_unique_animation_names" qualifiers="const">
<return type="String[]" /> <return type="String[]" />
<description> <description>
Returns an array of unique animation names. This is only used during the import process. Returns an array of unique animation names. This is only used during the import process.
</description> </description>
</method> </method>
<method name="get_unique_names"> <method name="get_unique_names" qualifiers="const">
<return type="String[]" /> <return type="String[]" />
<description> <description>
Returns an array of unique node names. This is used in both the import process and export process. Returns an array of unique node names. This is used in both the import process and export process.

54
modules/gltf/extensions/physics/gltf_document_extension_physics.cpp
View file

@ -145,16 +145,16 @@ Error GLTFDocumentExtensionPhysics::parse_node_extensions(Ref<GLTFState> p_state
return OK; return OK;
} }
bool _will_gltf_shape_become_subnode(Ref<GLTFState> p_state, const Ref<GLTFNode> p_gltf_node, GLTFNodeIndex p_gltf_node_index) { bool _will_gltf_shape_become_subnode(const Ref<GLTFState> &p_state, const Ref<GLTFNode> &p_gltf_node, GLTFNodeIndex p_gltf_node_index) {
if (p_gltf_node->has_additional_data(StringName("GLTFPhysicsBody"))) { if (p_gltf_node->has_additional_data(StringName("GLTFPhysicsBody"))) {
return true; return true;
} }
const TypedArray<GLTFNode> state_gltf_nodes = p_state->get_nodes(); const Vector<Ref<GLTFNode>> &state_gltf_nodes = p_state->get_nodes();
const GLTFNodeIndex parent_index = p_gltf_node->get_parent(); const GLTFNodeIndex parent_index = p_gltf_node->get_parent();
if (parent_index == -1 || parent_index >= state_gltf_nodes.size()) { if (parent_index == -1 || parent_index >= state_gltf_nodes.size()) {
return true; return true;
} }
const Ref<GLTFNode> parent_gltf_node = state_gltf_nodes[parent_index]; const Ref<GLTFNode> &parent_gltf_node = state_gltf_nodes[parent_index];
const Variant parent_body_maybe = parent_gltf_node->get_additional_data(StringName("GLTFPhysicsBody")); const Variant parent_body_maybe = parent_gltf_node->get_additional_data(StringName("GLTFPhysicsBody"));
if (parent_body_maybe.get_type() != Variant::NIL) { if (parent_body_maybe.get_type() != Variant::NIL) {
Ref<GLTFPhysicsBody> parent_body = parent_body_maybe; Ref<GLTFPhysicsBody> parent_body = parent_body_maybe;
@ -181,10 +181,10 @@ bool _will_gltf_shape_become_subnode(Ref<GLTFState> p_state, const Ref<GLTFNode>
return true; return true;
} }
NodePath _get_scene_node_path_for_shape_index(Ref<GLTFState> p_state, const GLTFNodeIndex p_shape_index) { NodePath _get_scene_node_path_for_shape_index(const Ref<GLTFState> &p_state, const GLTFNodeIndex p_shape_index) {
TypedArray<GLTFNode> state_gltf_nodes = p_state->get_nodes(); const Vector<Ref<GLTFNode>> &state_gltf_nodes = p_state->get_nodes();
for (GLTFNodeIndex node_index = 0; node_index < state_gltf_nodes.size(); node_index++) { for (GLTFNodeIndex node_index = 0; node_index < state_gltf_nodes.size(); node_index++) {
const Ref<GLTFNode> gltf_node = state_gltf_nodes[node_index]; const Ref<GLTFNode> &gltf_node = state_gltf_nodes[node_index];
ERR_CONTINUE(gltf_node.is_null()); ERR_CONTINUE(gltf_node.is_null());
// Check if this node has a shape index and if it matches the one we are looking for. // Check if this node has a shape index and if it matches the one we are looking for.
Variant shape_index_maybe = gltf_node->get_additional_data(StringName("GLTFPhysicsColliderShapeIndex")); Variant shape_index_maybe = gltf_node->get_additional_data(StringName("GLTFPhysicsColliderShapeIndex"));
@ -247,9 +247,9 @@ Ref<GLTFObjectModelProperty> GLTFDocumentExtensionPhysics::import_object_model_p
} else if (p_split_json_pointer[0] == "nodes" && p_split_json_pointer[2] == "extensions" && p_split_json_pointer[4] == "motion") { } else if (p_split_json_pointer[0] == "nodes" && p_split_json_pointer[2] == "extensions" && p_split_json_pointer[4] == "motion") {
if (p_split_json_pointer[3] == "OMI_physics_body" || p_split_json_pointer[3] == "KHR_physics_rigid_bodies") { if (p_split_json_pointer[3] == "OMI_physics_body" || p_split_json_pointer[3] == "KHR_physics_rigid_bodies") {
const GLTFNodeIndex node_index = p_split_json_pointer[1].to_int(); const GLTFNodeIndex node_index = p_split_json_pointer[1].to_int();
const TypedArray<GLTFNode> all_gltf_nodes = p_state->get_nodes(); const Vector<Ref<GLTFNode>> &all_gltf_nodes = p_state->get_nodes();
ERR_FAIL_INDEX_V_MSG(node_index, all_gltf_nodes.size(), ret, "GLTF Physics: The node index " + itos(node_index) + " is not in the state nodes (size: " + itos(all_gltf_nodes.size()) + ")."); ERR_FAIL_INDEX_V_MSG(node_index, all_gltf_nodes.size(), ret, "GLTF Physics: The node index " + itos(node_index) + " is not in the state nodes (size: " + itos(all_gltf_nodes.size()) + ").");
const Ref<GLTFNode> gltf_node = all_gltf_nodes[node_index]; const Ref<GLTFNode> &gltf_node = all_gltf_nodes[node_index];
NodePath node_path; NodePath node_path;
if (p_partial_paths.is_empty()) { if (p_partial_paths.is_empty()) {
node_path = gltf_node->get_scene_node_path(p_state); node_path = gltf_node->get_scene_node_path(p_state);
@ -283,7 +283,7 @@ Ref<GLTFObjectModelProperty> GLTFDocumentExtensionPhysics::import_object_model_p
return ret; return ret;
} }
void _setup_shape_mesh_resource_from_index_if_needed(Ref<GLTFState> p_state, Ref<GLTFPhysicsShape> p_gltf_shape) { void _setup_shape_mesh_resource_from_index_if_needed(const Ref<GLTFState> &p_state, const Ref<GLTFPhysicsShape> &p_gltf_shape) {
GLTFMeshIndex shape_mesh_index = p_gltf_shape->get_mesh_index(); GLTFMeshIndex shape_mesh_index = p_gltf_shape->get_mesh_index();
if (shape_mesh_index == -1) { if (shape_mesh_index == -1) {
return; // No mesh for this shape. return; // No mesh for this shape.
@ -292,9 +292,9 @@ void _setup_shape_mesh_resource_from_index_if_needed(Ref<GLTFState> p_state, Ref
if (importer_mesh.is_valid()) { if (importer_mesh.is_valid()) {
return; // The mesh resource is already set up. return; // The mesh resource is already set up.
} }
TypedArray<GLTFMesh> state_meshes = p_state->get_meshes(); const Vector<Ref<GLTFMesh>> &state_meshes = p_state->get_meshes();
ERR_FAIL_INDEX_MSG(shape_mesh_index, state_meshes.size(), "glTF Physics: When importing '" + p_state->get_scene_name() + "', the shape mesh index " + itos(shape_mesh_index) + " is not in the state meshes (size: " + itos(state_meshes.size()) + ")."); ERR_FAIL_INDEX_MSG(shape_mesh_index, state_meshes.size(), "glTF Physics: When importing '" + p_state->get_scene_name() + "', the shape mesh index " + itos(shape_mesh_index) + " is not in the state meshes (size: " + itos(state_meshes.size()) + ").");
Ref<GLTFMesh> gltf_mesh = state_meshes[shape_mesh_index]; const Ref<GLTFMesh> &gltf_mesh = state_meshes[shape_mesh_index];
ERR_FAIL_COND(gltf_mesh.is_null()); ERR_FAIL_COND(gltf_mesh.is_null());
importer_mesh = gltf_mesh->get_mesh(); importer_mesh = gltf_mesh->get_mesh();
ERR_FAIL_COND(importer_mesh.is_null()); ERR_FAIL_COND(importer_mesh.is_null());
@ -346,7 +346,7 @@ CollisionObject3D *_get_ancestor_collision_object(Node *p_scene_parent) {
return nullptr; return nullptr;
} }
Node3D *_generate_shape_node_and_body_if_needed(Ref<GLTFState> p_state, Ref<GLTFNode> p_gltf_node, Ref<GLTFPhysicsShape> p_physics_shape, CollisionObject3D *p_col_object, bool p_is_trigger) { Node3D *_generate_shape_node_and_body_if_needed(const Ref<GLTFState> &p_state, const Ref<GLTFNode> &p_gltf_node, const Ref<GLTFPhysicsShape> &p_physics_shape, CollisionObject3D *p_col_object, bool p_is_trigger) {
// If we need to generate a body node, do so. // If we need to generate a body node, do so.
CollisionObject3D *body_node = nullptr; CollisionObject3D *body_node = nullptr;
if (p_is_trigger || p_physics_shape->get_is_trigger()) { if (p_is_trigger || p_physics_shape->get_is_trigger()) {
@ -372,7 +372,7 @@ Node3D *_generate_shape_node_and_body_if_needed(Ref<GLTFState> p_state, Ref<GLTF
} }
// Either add the child to the parent, or return the child if there is no parent. // Either add the child to the parent, or return the child if there is no parent.
Node3D *_add_physics_node_to_given_node(Node3D *p_current_node, Node3D *p_child, Ref<GLTFNode> p_gltf_node) { Node3D *_add_physics_node_to_given_node(Node3D *p_current_node, Node3D *p_child, const Ref<GLTFNode> &p_gltf_node) {
if (!p_current_node) { if (!p_current_node) {
return p_child; return p_child;
} }
@ -389,10 +389,10 @@ Node3D *_add_physics_node_to_given_node(Node3D *p_current_node, Node3D *p_child,
return p_current_node; return p_current_node;
} }
Array _get_ancestor_compound_trigger_nodes(Ref<GLTFState> p_state, TypedArray<GLTFNode> p_state_nodes, CollisionObject3D *p_ancestor_col_obj) { Array _get_ancestor_compound_trigger_nodes(const Ref<GLTFState> &p_state, const Vector<Ref<GLTFNode>> &p_state_nodes, CollisionObject3D *p_ancestor_col_obj) {
GLTFNodeIndex ancestor_index = p_state->get_node_index(p_ancestor_col_obj); GLTFNodeIndex ancestor_index = p_state->get_node_index(p_ancestor_col_obj);
ERR_FAIL_INDEX_V(ancestor_index, p_state_nodes.size(), Array()); ERR_FAIL_INDEX_V(ancestor_index, p_state_nodes.size(), Array());
Ref<GLTFNode> ancestor_gltf_node = p_state_nodes[ancestor_index]; const Ref<GLTFNode> &ancestor_gltf_node = p_state_nodes[ancestor_index];
Variant compound_trigger_nodes = ancestor_gltf_node->get_additional_data(StringName("GLTFPhysicsCompoundTriggerNodes")); Variant compound_trigger_nodes = ancestor_gltf_node->get_additional_data(StringName("GLTFPhysicsCompoundTriggerNodes"));
if (compound_trigger_nodes.is_array()) { if (compound_trigger_nodes.is_array()) {
return compound_trigger_nodes; return compound_trigger_nodes;
@ -439,7 +439,7 @@ Node3D *GLTFDocumentExtensionPhysics::generate_scene_node(Ref<GLTFState> p_state
ancestor_col_obj = _get_ancestor_collision_object(p_scene_parent); ancestor_col_obj = _get_ancestor_collision_object(p_scene_parent);
if (Object::cast_to<Area3D>(ancestor_col_obj) && gltf_physics_trigger_shape.is_valid()) { if (Object::cast_to<Area3D>(ancestor_col_obj) && gltf_physics_trigger_shape.is_valid()) {
// At this point, we found an ancestor Area3D node. But do we want to use it for this trigger shape? // At this point, we found an ancestor Area3D node. But do we want to use it for this trigger shape?
TypedArray<GLTFNode> state_nodes = p_state->get_nodes(); const Vector<Ref<GLTFNode>> &state_nodes = p_state->get_nodes();
GLTFNodeIndex self_index = state_nodes.find(p_gltf_node); GLTFNodeIndex self_index = state_nodes.find(p_gltf_node);
Array compound_trigger_nodes = _get_ancestor_compound_trigger_nodes(p_state, state_nodes, ancestor_col_obj); Array compound_trigger_nodes = _get_ancestor_compound_trigger_nodes(p_state, state_nodes, ancestor_col_obj);
// Check if the ancestor specifies compound trigger nodes, and if this node is in there. // Check if the ancestor specifies compound trigger nodes, and if this node is in there.
@ -497,13 +497,13 @@ bool _are_all_faces_equal(const Vector<Face3> &p_a, const Vector<Face3> &p_b) {
return true; return true;
} }
GLTFMeshIndex _get_or_insert_mesh_in_state(Ref<GLTFState> p_state, Ref<ImporterMesh> p_mesh) { GLTFMeshIndex _get_or_insert_mesh_in_state(const Ref<GLTFState> &p_state, const Ref<ImporterMesh> &p_mesh) {
ERR_FAIL_COND_V(p_mesh.is_null(), -1); ERR_FAIL_COND_V(p_mesh.is_null(), -1);
TypedArray<GLTFMesh> state_meshes = p_state->get_meshes(); Vector<Ref<GLTFMesh>> state_meshes = p_state->get_meshes();
Vector<Face3> mesh_faces = p_mesh->get_faces(); Vector<Face3> mesh_faces = p_mesh->get_faces();
// De-duplication: If the state already has the mesh we need, use that one. // De-duplication: If the state already has the mesh we need, use that one.
for (GLTFMeshIndex i = 0; i < state_meshes.size(); i++) { for (GLTFMeshIndex i = 0; i < state_meshes.size(); i++) {
Ref<GLTFMesh> state_gltf_mesh = state_meshes[i]; const Ref<GLTFMesh> &state_gltf_mesh = state_meshes[i];
ERR_CONTINUE(state_gltf_mesh.is_null()); ERR_CONTINUE(state_gltf_mesh.is_null());
Ref<ImporterMesh> state_importer_mesh = state_gltf_mesh->get_mesh(); Ref<ImporterMesh> state_importer_mesh = state_gltf_mesh->get_mesh();
ERR_CONTINUE(state_importer_mesh.is_null()); ERR_CONTINUE(state_importer_mesh.is_null());
@ -540,7 +540,7 @@ void GLTFDocumentExtensionPhysics::convert_scene_node(Ref<GLTFState> p_state, Re
if (cast_to<Area3D>(ancestor_col_obj)) { if (cast_to<Area3D>(ancestor_col_obj)) {
p_gltf_node->set_additional_data(StringName("GLTFPhysicsTriggerShape"), gltf_shape); p_gltf_node->set_additional_data(StringName("GLTFPhysicsTriggerShape"), gltf_shape);
// Write explicit member shape nodes to the ancestor compound trigger node. // Write explicit member shape nodes to the ancestor compound trigger node.
TypedArray<GLTFNode> state_nodes = p_state->get_nodes(); const Vector<Ref<GLTFNode>> &state_nodes = p_state->get_nodes();
GLTFNodeIndex self_index = state_nodes.size(); // The current p_gltf_node will be inserted next. GLTFNodeIndex self_index = state_nodes.size(); // The current p_gltf_node will be inserted next.
Array compound_trigger_nodes = _get_ancestor_compound_trigger_nodes(p_state, p_state->get_nodes(), ancestor_col_obj); Array compound_trigger_nodes = _get_ancestor_compound_trigger_nodes(p_state, p_state->get_nodes(), ancestor_col_obj);
compound_trigger_nodes.push_back(double(self_index)); compound_trigger_nodes.push_back(double(self_index));
@ -553,7 +553,7 @@ void GLTFDocumentExtensionPhysics::convert_scene_node(Ref<GLTFState> p_state, Re
} }
} }
Array _get_or_create_state_shapes_in_state(Ref<GLTFState> p_state) { Array _get_or_create_state_shapes_in_state(const Ref<GLTFState> &p_state) {
Dictionary state_json = p_state->get_json(); Dictionary state_json = p_state->get_json();
Dictionary state_extensions; Dictionary state_extensions;
if (state_json.has("extensions")) { if (state_json.has("extensions")) {
@ -577,7 +577,7 @@ Array _get_or_create_state_shapes_in_state(Ref<GLTFState> p_state) {
return state_shapes; return state_shapes;
} }
GLTFShapeIndex _export_node_shape(Ref<GLTFState> p_state, Ref<GLTFPhysicsShape> p_physics_shape) { GLTFShapeIndex _export_node_shape(const Ref<GLTFState> &p_state, const Ref<GLTFPhysicsShape> &p_physics_shape) {
Array state_shapes = _get_or_create_state_shapes_in_state(p_state); Array state_shapes = _get_or_create_state_shapes_in_state(p_state);
GLTFShapeIndex size = state_shapes.size(); GLTFShapeIndex size = state_shapes.size();
Dictionary shape_property; Dictionary shape_property;
@ -597,14 +597,14 @@ GLTFShapeIndex _export_node_shape(Ref<GLTFState> p_state, Ref<GLTFPhysicsShape>
Error GLTFDocumentExtensionPhysics::export_preserialize(Ref<GLTFState> p_state) { Error GLTFDocumentExtensionPhysics::export_preserialize(Ref<GLTFState> p_state) {
// Note: Need to do _export_node_shape before exporting animations, so export_node is too late. // Note: Need to do _export_node_shape before exporting animations, so export_node is too late.
TypedArray<GLTFNode> state_gltf_nodes = p_state->get_nodes(); const Vector<Ref<GLTFNode>> &state_gltf_nodes = p_state->get_nodes();
for (Ref<GLTFNode> gltf_node : state_gltf_nodes) { for (Ref<GLTFNode> gltf_node : state_gltf_nodes) {
Ref<GLTFPhysicsShape> collider_shape = gltf_node->get_additional_data(StringName("GLTFPhysicsColliderShape")); const Ref<GLTFPhysicsShape> collider_shape = gltf_node->get_additional_data(StringName("GLTFPhysicsColliderShape"));
if (collider_shape.is_valid()) { if (collider_shape.is_valid()) {
GLTFShapeIndex collider_shape_index = _export_node_shape(p_state, collider_shape); GLTFShapeIndex collider_shape_index = _export_node_shape(p_state, collider_shape);
gltf_node->set_additional_data(StringName("GLTFPhysicsColliderShapeIndex"), collider_shape_index); gltf_node->set_additional_data(StringName("GLTFPhysicsColliderShapeIndex"), collider_shape_index);
} }
Ref<GLTFPhysicsShape> trigger_shape = gltf_node->get_additional_data(StringName("GLTFPhysicsTriggerShape")); const Ref<GLTFPhysicsShape> trigger_shape = gltf_node->get_additional_data(StringName("GLTFPhysicsTriggerShape"));
if (trigger_shape.is_valid()) { if (trigger_shape.is_valid()) {
GLTFShapeIndex trigger_shape_index = _export_node_shape(p_state, trigger_shape); GLTFShapeIndex trigger_shape_index = _export_node_shape(p_state, trigger_shape);
gltf_node->set_additional_data(StringName("GLTFPhysicsTriggerShapeIndex"), trigger_shape_index); gltf_node->set_additional_data(StringName("GLTFPhysicsTriggerShapeIndex"), trigger_shape_index);
@ -661,9 +661,9 @@ Ref<GLTFObjectModelProperty> GLTFDocumentExtensionPhysics::export_object_model_p
split_json_pointer.append("extensions"); split_json_pointer.append("extensions");
split_json_pointer.append("OMI_physics_shape"); split_json_pointer.append("OMI_physics_shape");
split_json_pointer.append("shapes"); split_json_pointer.append("shapes");
TypedArray<GLTFNode> state_gltf_nodes = p_state->get_nodes(); const Vector<Ref<GLTFNode>> &state_gltf_nodes = p_state->get_nodes();
ERR_FAIL_INDEX_V(p_gltf_node_index, state_gltf_nodes.size(), ret); ERR_FAIL_INDEX_V(p_gltf_node_index, state_gltf_nodes.size(), ret);
Ref<GLTFNode> gltf_node = state_gltf_nodes[p_gltf_node_index]; const Ref<GLTFNode> &gltf_node = state_gltf_nodes[p_gltf_node_index];
Variant shape_index_maybe = gltf_node->get_additional_data(StringName("GLTFPhysicsColliderShapeIndex")); Variant shape_index_maybe = gltf_node->get_additional_data(StringName("GLTFPhysicsColliderShapeIndex"));
String shape_type; String shape_type;
if (shape_index_maybe.get_type() == Variant::INT) { if (shape_index_maybe.get_type() == Variant::INT) {

212
modules/gltf/gltf_state.compat.inc Normal file
View file

@ -0,0 +1,212 @@
/**************************************************************************/
/* gltf_state.compat.inc */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef DISABLE_DEPRECATED
// Non-const getters for compatibility.
int32_t GLTFState::_get_handle_binary_image_bind_compat_113172() {
return get_handle_binary_image();
}
Dictionary GLTFState::_get_json_bind_compat_113172() {
return get_json();
}
int GLTFState::_get_major_version_bind_compat_113172() {
return get_major_version();
}
int GLTFState::_get_minor_version_bind_compat_113172() {
return get_minor_version();
}
Vector<uint8_t> GLTFState::_get_glb_data_bind_compat_113172() {
return get_glb_data();
}
bool GLTFState::_get_use_named_skin_binds_bind_compat_113172() {
return get_use_named_skin_binds();
}
bool GLTFState::_get_discard_meshes_and_materials_bind_compat_113172() {
return get_discard_meshes_and_materials();
}
TypedArray<GLTFNode> GLTFState::_get_nodes_bind_compat_113172() {
return get_nodes_bind();
}
TypedArray<PackedByteArray> GLTFState::_get_buffers_bind_compat_113172() {
return get_buffers_bind();
}
TypedArray<GLTFBufferView> GLTFState::_get_buffer_views_bind_compat_113172() {
return get_buffer_views_bind();
}
TypedArray<GLTFAccessor> GLTFState::_get_accessors_bind_compat_113172() {
return get_accessors_bind();
}
TypedArray<GLTFMesh> GLTFState::_get_meshes_bind_compat_113172() {
return get_meshes_bind();
}
TypedArray<Material> GLTFState::_get_materials_bind_compat_113172() {
return get_materials_bind();
}
String GLTFState::_get_scene_name_bind_compat_113172() {
return get_scene_name();
}
String GLTFState::_get_base_path_bind_compat_113172() {
return get_base_path();
}
String GLTFState::_get_extract_path_bind_compat_113172() {
return get_extract_path();
}
String GLTFState::_get_extract_prefix_bind_compat_113172() {
return get_extract_prefix();
}
PackedInt32Array GLTFState::_get_root_nodes_bind_compat_113172() {
return get_root_nodes();
}
TypedArray<GLTFTexture> GLTFState::_get_textures_bind_compat_113172() {
return get_textures_bind();
}
TypedArray<GLTFTextureSampler> GLTFState::_get_texture_samplers_bind_compat_113172() {
return get_texture_samplers_bind();
}
TypedArray<Texture2D> GLTFState::_get_images_bind_compat_113172() {
return get_images_bind();
}
TypedArray<GLTFSkin> GLTFState::_get_skins_bind_compat_113172() {
return get_skins_bind();
}
TypedArray<GLTFCamera> GLTFState::_get_cameras_bind_compat_113172() {
return get_cameras_bind();
}
TypedArray<GLTFLight> GLTFState::_get_lights_bind_compat_113172() {
return get_lights_bind();
}
TypedArray<String> GLTFState::_get_unique_names_bind_compat_113172() {
return get_unique_names_bind();
}
TypedArray<String> GLTFState::_get_unique_animation_names_bind_compat_113172() {
return get_unique_animation_names_bind();
}
TypedArray<GLTFSkeleton> GLTFState::_get_skeletons_bind_compat_113172() {
return get_skeletons_bind();
}
bool GLTFState::_get_create_animations_bind_compat_113172() {
return get_create_animations();
}
bool GLTFState::_get_import_as_skeleton_bones_bind_compat_113172() {
return get_import_as_skeleton_bones();
}
TypedArray<GLTFAnimation> GLTFState::_get_animations_bind_compat_113172() {
return get_animations_bind();
}
Node *GLTFState::_get_scene_node_bind_compat_113172(GLTFNodeIndex p_gltf_node_index) {
return get_scene_node(p_gltf_node_index);
}
GLTFNodeIndex GLTFState::_get_node_index_bind_compat_113172(Node *p_node) {
return get_node_index(p_node);
}
int GLTFState::_get_animation_players_count_bind_compat_113172(int p_anim_player_index) {
return get_animation_players_count(p_anim_player_index);
}
AnimationPlayer *GLTFState::_get_animation_player_bind_compat_113172(int p_anim_player_index) {
return get_animation_player(p_anim_player_index);
}
Variant GLTFState::_get_additional_data_bind_compat_113172(const StringName &p_extension_name) {
return get_additional_data(p_extension_name);
}
void GLTFState::_bind_compatibility_methods() {
ClassDB::bind_compatibility_method(D_METHOD("get_handle_binary_image"), &GLTFState::_get_handle_binary_image_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_json"), &GLTFState::_get_json_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_major_version"), &GLTFState::_get_major_version_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_minor_version"), &GLTFState::_get_minor_version_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_glb_data"), &GLTFState::_get_glb_data_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_use_named_skin_binds"), &GLTFState::_get_use_named_skin_binds_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_discard_meshes_and_materials"), &GLTFState::_get_discard_meshes_and_materials_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_nodes"), &GLTFState::_get_nodes_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_buffers"), &GLTFState::_get_buffers_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_buffer_views"), &GLTFState::_get_buffer_views_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_accessors"), &GLTFState::_get_accessors_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_meshes"), &GLTFState::_get_meshes_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_materials"), &GLTFState::_get_materials_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_scene_name"), &GLTFState::_get_scene_name_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_base_path"), &GLTFState::_get_base_path_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_extract_path"), &GLTFState::_get_extract_path_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_extract_prefix"), &GLTFState::_get_extract_prefix_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_root_nodes"), &GLTFState::_get_root_nodes_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_textures"), &GLTFState::_get_textures_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_texture_samplers"), &GLTFState::_get_texture_samplers_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_images"), &GLTFState::_get_images_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_skins"), &GLTFState::_get_skins_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_cameras"), &GLTFState::_get_cameras_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_lights"), &GLTFState::_get_lights_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_unique_names"), &GLTFState::_get_unique_names_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_unique_animation_names"), &GLTFState::_get_unique_animation_names_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_skeletons"), &GLTFState::_get_skeletons_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_create_animations"), &GLTFState::_get_create_animations_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_import_as_skeleton_bones"), &GLTFState::_get_import_as_skeleton_bones_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_animations"), &GLTFState::_get_animations_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_scene_node", "idx"), &GLTFState::_get_scene_node_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_node_index", "node"), &GLTFState::_get_node_index_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_animation_players_count", "idx"), &GLTFState::_get_animation_players_count_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_animation_player", "idx"), &GLTFState::_get_animation_player_bind_compat_113172);
ClassDB::bind_compatibility_method(D_METHOD("get_additional_data", "extension_name"), &GLTFState::_get_additional_data_bind_compat_113172);
}
#endif // DISABLE_DEPRECATED

181
modules/gltf/gltf_state.cpp
View file

@ -29,6 +29,7 @@
/**************************************************************************/ /**************************************************************************/
#include "gltf_state.h" #include "gltf_state.h"
#include "gltf_state.compat.inc"
#include "gltf_template_convert.h" #include "gltf_template_convert.h"
@ -49,20 +50,20 @@ void GLTFState::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_glb_data", "glb_data"), &GLTFState::set_glb_data); ClassDB::bind_method(D_METHOD("set_glb_data", "glb_data"), &GLTFState::set_glb_data);
ClassDB::bind_method(D_METHOD("get_use_named_skin_binds"), &GLTFState::get_use_named_skin_binds); ClassDB::bind_method(D_METHOD("get_use_named_skin_binds"), &GLTFState::get_use_named_skin_binds);
ClassDB::bind_method(D_METHOD("set_use_named_skin_binds", "use_named_skin_binds"), &GLTFState::set_use_named_skin_binds); ClassDB::bind_method(D_METHOD("set_use_named_skin_binds", "use_named_skin_binds"), &GLTFState::set_use_named_skin_binds);
ClassDB::bind_method(D_METHOD("get_nodes"), &GLTFState::get_nodes); ClassDB::bind_method(D_METHOD("get_nodes"), &GLTFState::get_nodes_bind);
ClassDB::bind_method(D_METHOD("set_nodes", "nodes"), &GLTFState::set_nodes); ClassDB::bind_method(D_METHOD("set_nodes", "nodes"), &GLTFState::set_nodes_bind);
ClassDB::bind_method(D_METHOD("get_buffers"), &GLTFState::get_buffers); ClassDB::bind_method(D_METHOD("get_buffers"), &GLTFState::get_buffers_bind);
ClassDB::bind_method(D_METHOD("set_buffers", "buffers"), &GLTFState::set_buffers); ClassDB::bind_method(D_METHOD("set_buffers", "buffers"), &GLTFState::set_buffers_bind);
ClassDB::bind_method(D_METHOD("get_buffer_views"), &GLTFState::get_buffer_views); ClassDB::bind_method(D_METHOD("get_buffer_views"), &GLTFState::get_buffer_views_bind);
ClassDB::bind_method(D_METHOD("set_buffer_views", "buffer_views"), &GLTFState::set_buffer_views); ClassDB::bind_method(D_METHOD("set_buffer_views", "buffer_views"), &GLTFState::set_buffer_views_bind);
ClassDB::bind_method(D_METHOD("get_accessors"), &GLTFState::get_accessors); ClassDB::bind_method(D_METHOD("get_accessors"), &GLTFState::get_accessors_bind);
ClassDB::bind_method(D_METHOD("set_accessors", "accessors"), &GLTFState::set_accessors); ClassDB::bind_method(D_METHOD("set_accessors", "accessors"), &GLTFState::set_accessors_bind);
ClassDB::bind_method(D_METHOD("get_meshes"), &GLTFState::get_meshes); ClassDB::bind_method(D_METHOD("get_meshes"), &GLTFState::get_meshes_bind);
ClassDB::bind_method(D_METHOD("set_meshes", "meshes"), &GLTFState::set_meshes); ClassDB::bind_method(D_METHOD("set_meshes", "meshes"), &GLTFState::set_meshes_bind);
ClassDB::bind_method(D_METHOD("get_animation_players_count", "idx"), &GLTFState::get_animation_players_count); ClassDB::bind_method(D_METHOD("get_animation_players_count", "anim_player_index"), &GLTFState::get_animation_players_count);
ClassDB::bind_method(D_METHOD("get_animation_player", "idx"), &GLTFState::get_animation_player); ClassDB::bind_method(D_METHOD("get_animation_player", "anim_player_index"), &GLTFState::get_animation_player);
ClassDB::bind_method(D_METHOD("get_materials"), &GLTFState::get_materials); ClassDB::bind_method(D_METHOD("get_materials"), &GLTFState::get_materials_bind);
ClassDB::bind_method(D_METHOD("set_materials", "materials"), &GLTFState::set_materials); ClassDB::bind_method(D_METHOD("set_materials", "materials"), &GLTFState::set_materials_bind);
ClassDB::bind_method(D_METHOD("get_scene_name"), &GLTFState::get_scene_name); ClassDB::bind_method(D_METHOD("get_scene_name"), &GLTFState::get_scene_name);
ClassDB::bind_method(D_METHOD("set_scene_name", "scene_name"), &GLTFState::set_scene_name); ClassDB::bind_method(D_METHOD("set_scene_name", "scene_name"), &GLTFState::set_scene_name);
ClassDB::bind_method(D_METHOD("get_base_path"), &GLTFState::get_base_path); ClassDB::bind_method(D_METHOD("get_base_path"), &GLTFState::get_base_path);
@ -71,31 +72,31 @@ void GLTFState::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_filename", "filename"), &GLTFState::set_filename); ClassDB::bind_method(D_METHOD("set_filename", "filename"), &GLTFState::set_filename);
ClassDB::bind_method(D_METHOD("get_root_nodes"), &GLTFState::get_root_nodes); ClassDB::bind_method(D_METHOD("get_root_nodes"), &GLTFState::get_root_nodes);
ClassDB::bind_method(D_METHOD("set_root_nodes", "root_nodes"), &GLTFState::set_root_nodes); ClassDB::bind_method(D_METHOD("set_root_nodes", "root_nodes"), &GLTFState::set_root_nodes);
ClassDB::bind_method(D_METHOD("get_textures"), &GLTFState::get_textures); ClassDB::bind_method(D_METHOD("get_textures"), &GLTFState::get_textures_bind);
ClassDB::bind_method(D_METHOD("set_textures", "textures"), &GLTFState::set_textures); ClassDB::bind_method(D_METHOD("set_textures", "textures"), &GLTFState::set_textures_bind);
ClassDB::bind_method(D_METHOD("get_texture_samplers"), &GLTFState::get_texture_samplers); ClassDB::bind_method(D_METHOD("get_texture_samplers"), &GLTFState::get_texture_samplers_bind);
ClassDB::bind_method(D_METHOD("set_texture_samplers", "texture_samplers"), &GLTFState::set_texture_samplers); ClassDB::bind_method(D_METHOD("set_texture_samplers", "texture_samplers"), &GLTFState::set_texture_samplers_bind);
ClassDB::bind_method(D_METHOD("get_images"), &GLTFState::get_images); ClassDB::bind_method(D_METHOD("get_images"), &GLTFState::get_images_bind);
ClassDB::bind_method(D_METHOD("set_images", "images"), &GLTFState::set_images); ClassDB::bind_method(D_METHOD("set_images", "images"), &GLTFState::set_images_bind);
ClassDB::bind_method(D_METHOD("get_skins"), &GLTFState::get_skins); ClassDB::bind_method(D_METHOD("get_skins"), &GLTFState::get_skins_bind);
ClassDB::bind_method(D_METHOD("set_skins", "skins"), &GLTFState::set_skins); ClassDB::bind_method(D_METHOD("set_skins", "skins"), &GLTFState::set_skins_bind);
ClassDB::bind_method(D_METHOD("get_cameras"), &GLTFState::get_cameras); ClassDB::bind_method(D_METHOD("get_cameras"), &GLTFState::get_cameras_bind);
ClassDB::bind_method(D_METHOD("set_cameras", "cameras"), &GLTFState::set_cameras); ClassDB::bind_method(D_METHOD("set_cameras", "cameras"), &GLTFState::set_cameras_bind);
ClassDB::bind_method(D_METHOD("get_lights"), &GLTFState::get_lights); ClassDB::bind_method(D_METHOD("get_lights"), &GLTFState::get_lights_bind);
ClassDB::bind_method(D_METHOD("set_lights", "lights"), &GLTFState::set_lights); ClassDB::bind_method(D_METHOD("set_lights", "lights"), &GLTFState::set_lights_bind);
ClassDB::bind_method(D_METHOD("get_unique_names"), &GLTFState::get_unique_names); ClassDB::bind_method(D_METHOD("get_unique_names"), &GLTFState::get_unique_names_bind);
ClassDB::bind_method(D_METHOD("set_unique_names", "unique_names"), &GLTFState::set_unique_names); ClassDB::bind_method(D_METHOD("set_unique_names", "unique_names"), &GLTFState::set_unique_names_bind);
ClassDB::bind_method(D_METHOD("get_unique_animation_names"), &GLTFState::get_unique_animation_names); ClassDB::bind_method(D_METHOD("get_unique_animation_names"), &GLTFState::get_unique_animation_names_bind);
ClassDB::bind_method(D_METHOD("set_unique_animation_names", "unique_animation_names"), &GLTFState::set_unique_animation_names); ClassDB::bind_method(D_METHOD("set_unique_animation_names", "unique_animation_names"), &GLTFState::set_unique_animation_names_bind);
ClassDB::bind_method(D_METHOD("get_skeletons"), &GLTFState::get_skeletons); ClassDB::bind_method(D_METHOD("get_skeletons"), &GLTFState::get_skeletons_bind);
ClassDB::bind_method(D_METHOD("set_skeletons", "skeletons"), &GLTFState::set_skeletons); ClassDB::bind_method(D_METHOD("set_skeletons", "skeletons"), &GLTFState::set_skeletons_bind);
ClassDB::bind_method(D_METHOD("get_create_animations"), &GLTFState::get_create_animations); ClassDB::bind_method(D_METHOD("get_create_animations"), &GLTFState::get_create_animations);
ClassDB::bind_method(D_METHOD("set_create_animations", "create_animations"), &GLTFState::set_create_animations); ClassDB::bind_method(D_METHOD("set_create_animations", "create_animations"), &GLTFState::set_create_animations);
ClassDB::bind_method(D_METHOD("get_import_as_skeleton_bones"), &GLTFState::get_import_as_skeleton_bones); ClassDB::bind_method(D_METHOD("get_import_as_skeleton_bones"), &GLTFState::get_import_as_skeleton_bones);
ClassDB::bind_method(D_METHOD("set_import_as_skeleton_bones", "import_as_skeleton_bones"), &GLTFState::set_import_as_skeleton_bones); ClassDB::bind_method(D_METHOD("set_import_as_skeleton_bones", "import_as_skeleton_bones"), &GLTFState::set_import_as_skeleton_bones);
ClassDB::bind_method(D_METHOD("get_animations"), &GLTFState::get_animations); ClassDB::bind_method(D_METHOD("get_animations"), &GLTFState::get_animations_bind);
ClassDB::bind_method(D_METHOD("set_animations", "animations"), &GLTFState::set_animations); ClassDB::bind_method(D_METHOD("set_animations", "animations"), &GLTFState::set_animations_bind);
ClassDB::bind_method(D_METHOD("get_scene_node", "idx"), &GLTFState::get_scene_node); ClassDB::bind_method(D_METHOD("get_scene_node", "gltf_node_index"), &GLTFState::get_scene_node);
ClassDB::bind_method(D_METHOD("get_node_index", "scene_node"), &GLTFState::get_node_index); ClassDB::bind_method(D_METHOD("get_node_index", "scene_node"), &GLTFState::get_node_index);
ClassDB::bind_method(D_METHOD("get_additional_data", "extension_name"), &GLTFState::get_additional_data); ClassDB::bind_method(D_METHOD("get_additional_data", "extension_name"), &GLTFState::get_additional_data);
ClassDB::bind_method(D_METHOD("set_additional_data", "extension_name", "additional_data"), &GLTFState::set_additional_data); ClassDB::bind_method(D_METHOD("set_additional_data", "extension_name", "additional_data"), &GLTFState::set_additional_data);
@ -140,6 +141,7 @@ void GLTFState::_bind_methods() {
BIND_ENUM_CONSTANT(HANDLE_BINARY_IMAGE_MODE_EMBED_AS_BASISU); BIND_ENUM_CONSTANT(HANDLE_BINARY_IMAGE_MODE_EMBED_AS_BASISU);
BIND_ENUM_CONSTANT(HANDLE_BINARY_IMAGE_MODE_EMBED_AS_UNCOMPRESSED); BIND_ENUM_CONSTANT(HANDLE_BINARY_IMAGE_MODE_EMBED_AS_UNCOMPRESSED);
#ifndef DISABLE_DEPRECATED
// Deprecated non-type-safe versions for backward compatibility, remove in Godot 5.0. // Deprecated non-type-safe versions for backward compatibility, remove in Godot 5.0.
ClassDB::bind_method(D_METHOD("get_handle_binary_image"), &GLTFState::get_handle_binary_image); ClassDB::bind_method(D_METHOD("get_handle_binary_image"), &GLTFState::get_handle_binary_image);
ClassDB::bind_method(D_METHOD("set_handle_binary_image", "method"), &GLTFState::set_handle_binary_image); ClassDB::bind_method(D_METHOD("set_handle_binary_image", "method"), &GLTFState::set_handle_binary_image);
@ -148,6 +150,7 @@ void GLTFState::_bind_methods() {
BIND_CONSTANT(HANDLE_BINARY_EXTRACT_TEXTURES); BIND_CONSTANT(HANDLE_BINARY_EXTRACT_TEXTURES);
BIND_CONSTANT(HANDLE_BINARY_EMBED_AS_BASISU); BIND_CONSTANT(HANDLE_BINARY_EMBED_AS_BASISU);
BIND_CONSTANT(HANDLE_BINARY_EMBED_AS_UNCOMPRESSED); BIND_CONSTANT(HANDLE_BINARY_EMBED_AS_UNCOMPRESSED);
#endif // DISABLE_DEPRECATED
} }
void GLTFState::add_used_extension(const String &p_extension_name, bool p_required) { void GLTFState::add_used_extension(const String &p_extension_name, bool p_required) {
@ -161,7 +164,7 @@ void GLTFState::add_used_extension(const String &p_extension_name, bool p_requir
} }
} }
Dictionary GLTFState::get_json() { Dictionary GLTFState::get_json() const {
return Dictionary(json); return Dictionary(json);
} }
@ -169,7 +172,7 @@ void GLTFState::set_json(const Dictionary &p_json) {
json = Dictionary(p_json); json = Dictionary(p_json);
} }
int GLTFState::get_major_version() { int GLTFState::get_major_version() const {
return major_version; return major_version;
} }
@ -177,7 +180,7 @@ void GLTFState::set_major_version(int p_major_version) {
major_version = p_major_version; major_version = p_major_version;
} }
int GLTFState::get_minor_version() { int GLTFState::get_minor_version() const {
return minor_version; return minor_version;
} }
@ -193,7 +196,7 @@ void GLTFState::set_copyright(const String &p_copyright) {
copyright = p_copyright; copyright = p_copyright;
} }
Vector<uint8_t> GLTFState::get_glb_data() { Vector<uint8_t> GLTFState::get_glb_data() const {
return Vector<uint8_t>(glb_data); return Vector<uint8_t>(glb_data);
} }
@ -201,7 +204,7 @@ void GLTFState::set_glb_data(const Vector<uint8_t> &p_glb_data) {
glb_data = Vector<uint8_t>(p_glb_data); glb_data = Vector<uint8_t>(p_glb_data);
} }
bool GLTFState::get_use_named_skin_binds() { bool GLTFState::get_use_named_skin_binds() const {
return use_named_skin_binds; return use_named_skin_binds;
} }
@ -209,55 +212,55 @@ void GLTFState::set_use_named_skin_binds(bool p_use_named_skin_binds) {
use_named_skin_binds = p_use_named_skin_binds; use_named_skin_binds = p_use_named_skin_binds;
} }
TypedArray<GLTFNode> GLTFState::get_nodes() { TypedArray<GLTFNode> GLTFState::get_nodes_bind() const {
return GLTFTemplateConvert::to_array(nodes); return GLTFTemplateConvert::to_array(nodes);
} }
void GLTFState::set_nodes(const TypedArray<GLTFNode> &p_nodes) { void GLTFState::set_nodes_bind(const TypedArray<GLTFNode> &p_nodes) {
GLTFTemplateConvert::set_from_array(nodes, p_nodes); GLTFTemplateConvert::set_from_array(nodes, p_nodes);
} }
TypedArray<PackedByteArray> GLTFState::get_buffers() { TypedArray<PackedByteArray> GLTFState::get_buffers_bind() const {
return GLTFTemplateConvert::to_array(buffers); return GLTFTemplateConvert::to_array(buffers);
} }
void GLTFState::set_buffers(const TypedArray<PackedByteArray> &p_buffers) { void GLTFState::set_buffers_bind(const TypedArray<PackedByteArray> &p_buffers) {
GLTFTemplateConvert::set_from_array(buffers, p_buffers); GLTFTemplateConvert::set_from_array(buffers, p_buffers);
} }
TypedArray<GLTFBufferView> GLTFState::get_buffer_views() { TypedArray<GLTFBufferView> GLTFState::get_buffer_views_bind() const {
return GLTFTemplateConvert::to_array(buffer_views); return GLTFTemplateConvert::to_array(buffer_views);
} }
void GLTFState::set_buffer_views(const TypedArray<GLTFBufferView> &p_buffer_views) { void GLTFState::set_buffer_views_bind(const TypedArray<GLTFBufferView> &p_buffer_views) {
GLTFTemplateConvert::set_from_array(buffer_views, p_buffer_views); GLTFTemplateConvert::set_from_array(buffer_views, p_buffer_views);
} }
TypedArray<GLTFAccessor> GLTFState::get_accessors() { TypedArray<GLTFAccessor> GLTFState::get_accessors_bind() const {
return GLTFTemplateConvert::to_array(accessors); return GLTFTemplateConvert::to_array(accessors);
} }
void GLTFState::set_accessors(const TypedArray<GLTFAccessor> &p_accessors) { void GLTFState::set_accessors_bind(const TypedArray<GLTFAccessor> &p_accessors) {
GLTFTemplateConvert::set_from_array(accessors, p_accessors); GLTFTemplateConvert::set_from_array(accessors, p_accessors);
} }
TypedArray<GLTFMesh> GLTFState::get_meshes() { TypedArray<GLTFMesh> GLTFState::get_meshes_bind() const {
return GLTFTemplateConvert::to_array(meshes); return GLTFTemplateConvert::to_array(meshes);
} }
void GLTFState::set_meshes(const TypedArray<GLTFMesh> &p_meshes) { void GLTFState::set_meshes_bind(const TypedArray<GLTFMesh> &p_meshes) {
GLTFTemplateConvert::set_from_array(meshes, p_meshes); GLTFTemplateConvert::set_from_array(meshes, p_meshes);
} }
TypedArray<Material> GLTFState::get_materials() { TypedArray<Material> GLTFState::get_materials_bind() const {
return GLTFTemplateConvert::to_array(materials); return GLTFTemplateConvert::to_array(materials);
} }
void GLTFState::set_materials(const TypedArray<Material> &p_materials) { void GLTFState::set_materials_bind(const TypedArray<Material> &p_materials) {
GLTFTemplateConvert::set_from_array(materials, p_materials); GLTFTemplateConvert::set_from_array(materials, p_materials);
} }
String GLTFState::get_scene_name() { String GLTFState::get_scene_name() const {
return scene_name; return scene_name;
} }
@ -265,7 +268,7 @@ void GLTFState::set_scene_name(const String &p_scene_name) {
scene_name = p_scene_name; scene_name = p_scene_name;
} }
PackedInt32Array GLTFState::get_root_nodes() { PackedInt32Array GLTFState::get_root_nodes() const {
return root_nodes; return root_nodes;
} }
@ -273,79 +276,79 @@ void GLTFState::set_root_nodes(const PackedInt32Array &p_root_nodes) {
root_nodes = PackedInt32Array(p_root_nodes); root_nodes = PackedInt32Array(p_root_nodes);
} }
TypedArray<GLTFTexture> GLTFState::get_textures() { TypedArray<GLTFTexture> GLTFState::get_textures_bind() const {
return GLTFTemplateConvert::to_array(textures); return GLTFTemplateConvert::to_array(textures);
} }
void GLTFState::set_textures(const TypedArray<GLTFTexture> &p_textures) { void GLTFState::set_textures_bind(const TypedArray<GLTFTexture> &p_textures) {
GLTFTemplateConvert::set_from_array(textures, p_textures); GLTFTemplateConvert::set_from_array(textures, p_textures);
} }
TypedArray<GLTFTextureSampler> GLTFState::get_texture_samplers() { TypedArray<GLTFTextureSampler> GLTFState::get_texture_samplers_bind() const {
return GLTFTemplateConvert::to_array(texture_samplers); return GLTFTemplateConvert::to_array(texture_samplers);
} }
void GLTFState::set_texture_samplers(const TypedArray<GLTFTextureSampler> &p_texture_samplers) { void GLTFState::set_texture_samplers_bind(const TypedArray<GLTFTextureSampler> &p_texture_samplers) {
GLTFTemplateConvert::set_from_array(texture_samplers, p_texture_samplers); GLTFTemplateConvert::set_from_array(texture_samplers, p_texture_samplers);
} }
TypedArray<Texture2D> GLTFState::get_images() { TypedArray<Texture2D> GLTFState::get_images_bind() const {
return GLTFTemplateConvert::to_array(images); return GLTFTemplateConvert::to_array(images);
} }
void GLTFState::set_images(const TypedArray<Texture2D> &p_images) { void GLTFState::set_images_bind(const TypedArray<Texture2D> &p_images) {
GLTFTemplateConvert::set_from_array(images, p_images); GLTFTemplateConvert::set_from_array(images, p_images);
} }
TypedArray<GLTFSkin> GLTFState::get_skins() { TypedArray<GLTFSkin> GLTFState::get_skins_bind() const {
return GLTFTemplateConvert::to_array(skins); return GLTFTemplateConvert::to_array(skins);
} }
void GLTFState::set_skins(const TypedArray<GLTFSkin> &p_skins) { void GLTFState::set_skins_bind(const TypedArray<GLTFSkin> &p_skins) {
GLTFTemplateConvert::set_from_array(skins, p_skins); GLTFTemplateConvert::set_from_array(skins, p_skins);
} }
TypedArray<GLTFCamera> GLTFState::get_cameras() { TypedArray<GLTFCamera> GLTFState::get_cameras_bind() const {
return GLTFTemplateConvert::to_array(cameras); return GLTFTemplateConvert::to_array(cameras);
} }
void GLTFState::set_cameras(const TypedArray<GLTFCamera> &p_cameras) { void GLTFState::set_cameras_bind(const TypedArray<GLTFCamera> &p_cameras) {
GLTFTemplateConvert::set_from_array(cameras, p_cameras); GLTFTemplateConvert::set_from_array(cameras, p_cameras);
} }
TypedArray<GLTFLight> GLTFState::get_lights() { TypedArray<GLTFLight> GLTFState::get_lights_bind() const {
return GLTFTemplateConvert::to_array(lights); return GLTFTemplateConvert::to_array(lights);
} }
void GLTFState::set_lights(const TypedArray<GLTFLight> &p_lights) { void GLTFState::set_lights_bind(const TypedArray<GLTFLight> &p_lights) {
GLTFTemplateConvert::set_from_array(lights, p_lights); GLTFTemplateConvert::set_from_array(lights, p_lights);
} }
TypedArray<String> GLTFState::get_unique_names() { TypedArray<String> GLTFState::get_unique_names_bind() const {
return GLTFTemplateConvert::to_array(unique_names); return GLTFTemplateConvert::to_array(unique_names);
} }
void GLTFState::set_unique_names(const TypedArray<String> &p_unique_names) { void GLTFState::set_unique_names_bind(const TypedArray<String> &p_unique_names) {
GLTFTemplateConvert::set_from_array(unique_names, p_unique_names); GLTFTemplateConvert::set_from_array(unique_names, p_unique_names);
} }
TypedArray<String> GLTFState::get_unique_animation_names() { TypedArray<String> GLTFState::get_unique_animation_names_bind() const {
return GLTFTemplateConvert::to_array(unique_animation_names); return GLTFTemplateConvert::to_array(unique_animation_names);
} }
void GLTFState::set_unique_animation_names(const TypedArray<String> &p_unique_animation_names) { void GLTFState::set_unique_animation_names_bind(const TypedArray<String> &p_unique_animation_names) {
GLTFTemplateConvert::set_from_array(unique_animation_names, p_unique_animation_names); GLTFTemplateConvert::set_from_array(unique_animation_names, p_unique_animation_names);
} }
TypedArray<GLTFSkeleton> GLTFState::get_skeletons() { TypedArray<GLTFSkeleton> GLTFState::get_skeletons_bind() const {
return GLTFTemplateConvert::to_array(skeletons); return GLTFTemplateConvert::to_array(skeletons);
} }
void GLTFState::set_skeletons(const TypedArray<GLTFSkeleton> &p_skeletons) { void GLTFState::set_skeletons_bind(const TypedArray<GLTFSkeleton> &p_skeletons) {
GLTFTemplateConvert::set_from_array(skeletons, p_skeletons); GLTFTemplateConvert::set_from_array(skeletons, p_skeletons);
} }
bool GLTFState::get_create_animations() { bool GLTFState::get_create_animations() const {
return create_animations; return create_animations;
} }
@ -353,7 +356,7 @@ void GLTFState::set_create_animations(bool p_create_animations) {
create_animations = p_create_animations; create_animations = p_create_animations;
} }
bool GLTFState::get_import_as_skeleton_bones() { bool GLTFState::get_import_as_skeleton_bones() const {
return import_as_skeleton_bones; return import_as_skeleton_bones;
} }
@ -361,22 +364,22 @@ void GLTFState::set_import_as_skeleton_bones(bool p_import_as_skeleton_bones) {
import_as_skeleton_bones = p_import_as_skeleton_bones; import_as_skeleton_bones = p_import_as_skeleton_bones;
} }
TypedArray<GLTFAnimation> GLTFState::get_animations() { TypedArray<GLTFAnimation> GLTFState::get_animations_bind() const {
return GLTFTemplateConvert::to_array(animations); return GLTFTemplateConvert::to_array(animations);
} }
void GLTFState::set_animations(const TypedArray<GLTFAnimation> &p_animations) { void GLTFState::set_animations_bind(const TypedArray<GLTFAnimation> &p_animations) {
GLTFTemplateConvert::set_from_array(animations, p_animations); GLTFTemplateConvert::set_from_array(animations, p_animations);
} }
Node *GLTFState::get_scene_node(GLTFNodeIndex idx) { Node *GLTFState::get_scene_node(GLTFNodeIndex p_gltf_node_index) const {
if (!scene_nodes.has(idx)) { if (!scene_nodes.has(p_gltf_node_index)) {
return nullptr; return nullptr;
} }
return scene_nodes[idx]; return scene_nodes[p_gltf_node_index];
} }
GLTFNodeIndex GLTFState::get_node_index(Node *p_node) { GLTFNodeIndex GLTFState::get_node_index(Node *p_node) const {
for (KeyValue<GLTFNodeIndex, Node *> x : scene_nodes) { for (KeyValue<GLTFNodeIndex, Node *> x : scene_nodes) {
if (x.value == p_node) { if (x.value == p_node) {
return x.key; return x.key;
@ -385,24 +388,24 @@ GLTFNodeIndex GLTFState::get_node_index(Node *p_node) {
return -1; return -1;
} }
int GLTFState::get_animation_players_count(int idx) { int GLTFState::get_animation_players_count(int p_anim_player_index) const {
return animation_players.size(); return animation_players.size();
} }
AnimationPlayer *GLTFState::get_animation_player(int idx) { AnimationPlayer *GLTFState::get_animation_player(int p_anim_player_index) const {
ERR_FAIL_INDEX_V(idx, animation_players.size(), nullptr); ERR_FAIL_INDEX_V(p_anim_player_index, animation_players.size(), nullptr);
return animation_players[idx]; return animation_players[p_anim_player_index];
} }
void GLTFState::set_discard_meshes_and_materials(bool p_discard_meshes_and_materials) { void GLTFState::set_discard_meshes_and_materials(bool p_discard_meshes_and_materials) {
discard_meshes_and_materials = p_discard_meshes_and_materials; discard_meshes_and_materials = p_discard_meshes_and_materials;
} }
bool GLTFState::get_discard_meshes_and_materials() { bool GLTFState::get_discard_meshes_and_materials() const {
return discard_meshes_and_materials; return discard_meshes_and_materials;
} }
String GLTFState::get_base_path() { String GLTFState::get_base_path() const {
return base_path; return base_path;
} }
@ -413,7 +416,7 @@ void GLTFState::set_base_path(const String &p_base_path) {
} }
} }
String GLTFState::get_extract_path() { String GLTFState::get_extract_path() const {
return extract_path; return extract_path;
} }
@ -421,7 +424,7 @@ void GLTFState::set_extract_path(const String &p_extract_path) {
extract_path = p_extract_path; extract_path = p_extract_path;
} }
String GLTFState::get_extract_prefix() { String GLTFState::get_extract_prefix() const {
return extract_prefix; return extract_prefix;
} }
@ -440,7 +443,7 @@ void GLTFState::set_filename(const String &p_filename) {
} }
} }
Variant GLTFState::get_additional_data(const StringName &p_extension_name) { Variant GLTFState::get_additional_data(const StringName &p_extension_name) const {
return additional_data[p_extension_name]; return additional_data[p_extension_name];
} }

186
modules/gltf/gltf_state.h
View file

@ -121,6 +121,46 @@ protected:
protected: protected:
static void _bind_methods(); static void _bind_methods();
#ifndef DISABLE_DEPRECATED
// Non-const getters for compatibility.
int32_t _get_handle_binary_image_bind_compat_113172();
Dictionary _get_json_bind_compat_113172();
int _get_major_version_bind_compat_113172();
int _get_minor_version_bind_compat_113172();
Vector<uint8_t> _get_glb_data_bind_compat_113172();
bool _get_use_named_skin_binds_bind_compat_113172();
bool _get_discard_meshes_and_materials_bind_compat_113172();
TypedArray<GLTFNode> _get_nodes_bind_compat_113172();
TypedArray<PackedByteArray> _get_buffers_bind_compat_113172();
TypedArray<GLTFBufferView> _get_buffer_views_bind_compat_113172();
TypedArray<GLTFAccessor> _get_accessors_bind_compat_113172();
TypedArray<GLTFMesh> _get_meshes_bind_compat_113172();
TypedArray<Material> _get_materials_bind_compat_113172();
String _get_scene_name_bind_compat_113172();
String _get_base_path_bind_compat_113172();
String _get_extract_path_bind_compat_113172();
String _get_extract_prefix_bind_compat_113172();
PackedInt32Array _get_root_nodes_bind_compat_113172();
TypedArray<GLTFTexture> _get_textures_bind_compat_113172();
TypedArray<GLTFTextureSampler> _get_texture_samplers_bind_compat_113172();
TypedArray<Texture2D> _get_images_bind_compat_113172();
TypedArray<GLTFSkin> _get_skins_bind_compat_113172();
TypedArray<GLTFCamera> _get_cameras_bind_compat_113172();
TypedArray<GLTFLight> _get_lights_bind_compat_113172();
TypedArray<String> _get_unique_names_bind_compat_113172();
TypedArray<String> _get_unique_animation_names_bind_compat_113172();
TypedArray<GLTFSkeleton> _get_skeletons_bind_compat_113172();
bool _get_create_animations_bind_compat_113172();
bool _get_import_as_skeleton_bones_bind_compat_113172();
TypedArray<GLTFAnimation> _get_animations_bind_compat_113172();
Node *_get_scene_node_bind_compat_113172(GLTFNodeIndex p_gltf_node_index);
GLTFNodeIndex _get_node_index_bind_compat_113172(Node *p_node);
int _get_animation_players_count_bind_compat_113172(int p_anim_player_index);
AnimationPlayer *_get_animation_player_bind_compat_113172(int p_anim_player_index);
Variant _get_additional_data_bind_compat_113172(const StringName &p_extension_name);
static void _bind_compatibility_methods();
#endif // DISABLE_DEPRECATED
public: public:
double get_bake_fps() const { double get_bake_fps() const {
return bake_fps; return bake_fps;
@ -134,131 +174,155 @@ public:
GLTFBufferViewIndex append_data_to_buffers(const Vector<uint8_t> &p_data, const bool p_deduplication); GLTFBufferViewIndex append_data_to_buffers(const Vector<uint8_t> &p_data, const bool p_deduplication);
GLTFNodeIndex append_gltf_node(Ref<GLTFNode> p_gltf_node, Node *p_godot_scene_node, GLTFNodeIndex p_parent_node_index); GLTFNodeIndex append_gltf_node(Ref<GLTFNode> p_gltf_node, Node *p_godot_scene_node, GLTFNodeIndex p_parent_node_index);
// Deprecated, use HandleBinaryImageMode instead.
enum GLTFHandleBinary { enum GLTFHandleBinary {
HANDLE_BINARY_DISCARD_TEXTURES = 0, HANDLE_BINARY_DISCARD_TEXTURES = 0,
HANDLE_BINARY_EXTRACT_TEXTURES, HANDLE_BINARY_EXTRACT_TEXTURES,
HANDLE_BINARY_EMBED_AS_BASISU, HANDLE_BINARY_EMBED_AS_BASISU,
HANDLE_BINARY_EMBED_AS_UNCOMPRESSED, // If this value changes from 3, ResourceImporterScene::pre_import must be changed as well. HANDLE_BINARY_EMBED_AS_UNCOMPRESSED, // If this value changes from 3, ResourceImporterScene::pre_import must be changed as well.
}; };
int32_t get_handle_binary_image() { int32_t get_handle_binary_image() const {
return handle_binary_image_mode; return handle_binary_image_mode;
} }
void set_handle_binary_image(int32_t p_handle_binary_image) { void set_handle_binary_image(int32_t p_handle_binary_image) {
handle_binary_image_mode = (HandleBinaryImageMode)p_handle_binary_image; handle_binary_image_mode = (HandleBinaryImageMode)p_handle_binary_image;
} }
HandleBinaryImageMode get_handle_binary_image_mode() { return handle_binary_image_mode; } HandleBinaryImageMode get_handle_binary_image_mode() const { return handle_binary_image_mode; }
void set_handle_binary_image_mode(HandleBinaryImageMode p_handle_binary_image) { handle_binary_image_mode = p_handle_binary_image; } void set_handle_binary_image_mode(HandleBinaryImageMode p_handle_binary_image) { handle_binary_image_mode = p_handle_binary_image; }
Dictionary get_json(); Dictionary get_json() const;
void set_json(const Dictionary &p_json); void set_json(const Dictionary &p_json);
int get_major_version(); int get_major_version() const;
void set_major_version(int p_major_version); void set_major_version(int p_major_version);
int get_minor_version(); int get_minor_version() const;
void set_minor_version(int p_minor_version); void set_minor_version(int p_minor_version);
String get_copyright() const; String get_copyright() const;
void set_copyright(const String &p_copyright); void set_copyright(const String &p_copyright);
Vector<uint8_t> get_glb_data(); Vector<uint8_t> get_glb_data() const;
void set_glb_data(const Vector<uint8_t> &p_glb_data); void set_glb_data(const Vector<uint8_t> &p_glb_data);
bool get_use_named_skin_binds(); bool get_use_named_skin_binds() const;
void set_use_named_skin_binds(bool p_use_named_skin_binds); void set_use_named_skin_binds(bool p_use_named_skin_binds);
bool get_discard_textures(); bool get_discard_meshes_and_materials() const;
void set_discard_textures(bool p_discard_textures);
bool get_embed_as_basisu();
void set_embed_as_basisu(bool p_embed_as_basisu);
bool get_extract_textures();
void set_extract_textures(bool p_extract_textures);
bool get_discard_meshes_and_materials();
void set_discard_meshes_and_materials(bool p_discard_meshes_and_materials); void set_discard_meshes_and_materials(bool p_discard_meshes_and_materials);
TypedArray<GLTFNode> get_nodes(); const Vector<Ref<GLTFNode>> &get_nodes() const { return nodes; }
void set_nodes(const TypedArray<GLTFNode> &p_nodes); void set_nodes(const Vector<Ref<GLTFNode>> &p_nodes) { nodes = p_nodes; }
TypedArray<GLTFNode> get_nodes_bind() const;
void set_nodes_bind(const TypedArray<GLTFNode> &p_nodes);
TypedArray<PackedByteArray> get_buffers(); const Vector<PackedByteArray> &get_buffers() const { return buffers; }
void set_buffers(const TypedArray<PackedByteArray> &p_buffers); void set_buffers(const Vector<PackedByteArray> &p_buffers) { buffers = p_buffers; }
TypedArray<PackedByteArray> get_buffers_bind() const;
void set_buffers_bind(const TypedArray<PackedByteArray> &p_buffers);
TypedArray<GLTFBufferView> get_buffer_views(); const Vector<Ref<GLTFBufferView>> &get_buffer_views() const { return buffer_views; }
void set_buffer_views(const TypedArray<GLTFBufferView> &p_buffer_views); void set_buffer_views(const Vector<Ref<GLTFBufferView>> &p_buffer_views) { buffer_views = p_buffer_views; }
TypedArray<GLTFBufferView> get_buffer_views_bind() const;
void set_buffer_views_bind(const TypedArray<GLTFBufferView> &p_buffer_views);
TypedArray<GLTFAccessor> get_accessors(); const Vector<Ref<GLTFAccessor>> &get_accessors() const { return accessors; }
void set_accessors(const TypedArray<GLTFAccessor> &p_accessors); void set_accessors(const Vector<Ref<GLTFAccessor>> &p_accessors) { accessors = p_accessors; }
TypedArray<GLTFAccessor> get_accessors_bind() const;
void set_accessors_bind(const TypedArray<GLTFAccessor> &p_accessors);
TypedArray<GLTFMesh> get_meshes(); const Vector<Ref<GLTFMesh>> &get_meshes() const { return meshes; }
void set_meshes(const TypedArray<GLTFMesh> &p_meshes); void set_meshes(const Vector<Ref<GLTFMesh>> &p_meshes) { meshes = p_meshes; }
TypedArray<GLTFMesh> get_meshes_bind() const;
void set_meshes_bind(const TypedArray<GLTFMesh> &p_meshes);
TypedArray<Material> get_materials(); const Vector<Ref<Material>> &get_materials() const { return materials; }
void set_materials(const TypedArray<Material> &p_materials); void set_materials(const Vector<Ref<Material>> &p_materials) { materials = p_materials; }
TypedArray<Material> get_materials_bind() const;
void set_materials_bind(const TypedArray<Material> &p_materials);
String get_scene_name(); String get_scene_name() const;
void set_scene_name(const String &p_scene_name); void set_scene_name(const String &p_scene_name);
String get_base_path(); String get_base_path() const;
void set_base_path(const String &p_base_path); void set_base_path(const String &p_base_path);
String get_extract_path(); String get_extract_path() const;
void set_extract_path(const String &p_extract_path); void set_extract_path(const String &p_extract_path);
String get_extract_prefix(); String get_extract_prefix() const;
void set_extract_prefix(const String &p_extract_prefix); void set_extract_prefix(const String &p_extract_prefix);
String get_filename() const; String get_filename() const;
void set_filename(const String &p_filename); void set_filename(const String &p_filename);
PackedInt32Array get_root_nodes(); PackedInt32Array get_root_nodes() const;
void set_root_nodes(const PackedInt32Array &p_root_nodes); void set_root_nodes(const PackedInt32Array &p_root_nodes);
TypedArray<GLTFTexture> get_textures(); const Vector<Ref<GLTFTexture>> &get_textures() const { return textures; }
void set_textures(const TypedArray<GLTFTexture> &p_textures); void set_textures(const Vector<Ref<GLTFTexture>> &p_textures) { textures = p_textures; }
TypedArray<GLTFTexture> get_textures_bind() const;
void set_textures_bind(const TypedArray<GLTFTexture> &p_textures);
TypedArray<GLTFTextureSampler> get_texture_samplers(); const Vector<Ref<GLTFTextureSampler>> &get_texture_samplers() const { return texture_samplers; }
void set_texture_samplers(const TypedArray<GLTFTextureSampler> &p_texture_samplers); void set_texture_samplers(const Vector<Ref<GLTFTextureSampler>> &p_texture_samplers) { texture_samplers = p_texture_samplers; }
TypedArray<GLTFTextureSampler> get_texture_samplers_bind() const;
void set_texture_samplers_bind(const TypedArray<GLTFTextureSampler> &p_texture_samplers);
TypedArray<Texture2D> get_images(); const Vector<Ref<Texture2D>> &get_images() const { return images; }
void set_images(const TypedArray<Texture2D> &p_images); void set_images(const Vector<Ref<Texture2D>> &p_images) { images = p_images; }
TypedArray<Texture2D> get_images_bind() const;
void set_images_bind(const TypedArray<Texture2D> &p_images);
TypedArray<GLTFSkin> get_skins(); const Vector<Ref<GLTFSkin>> &get_skins() const { return skins; }
void set_skins(const TypedArray<GLTFSkin> &p_skins); void set_skins(const Vector<Ref<GLTFSkin>> &p_skins) { skins = p_skins; }
TypedArray<GLTFSkin> get_skins_bind() const;
void set_skins_bind(const TypedArray<GLTFSkin> &p_skins);
TypedArray<GLTFCamera> get_cameras(); const Vector<Ref<GLTFCamera>> &get_cameras() const { return cameras; }
void set_cameras(const TypedArray<GLTFCamera> &p_cameras); void set_cameras(const Vector<Ref<GLTFCamera>> &p_cameras) { cameras = p_cameras; }
TypedArray<GLTFCamera> get_cameras_bind() const;
void set_cameras_bind(const TypedArray<GLTFCamera> &p_cameras);
TypedArray<GLTFLight> get_lights(); const Vector<Ref<GLTFLight>> &get_lights() const { return lights; }
void set_lights(const TypedArray<GLTFLight> &p_lights); void set_lights(const Vector<Ref<GLTFLight>> &p_lights) { lights = p_lights; }
TypedArray<GLTFLight> get_lights_bind() const;
void set_lights_bind(const TypedArray<GLTFLight> &p_lights);
TypedArray<String> get_unique_names(); const HashSet<String> &get_unique_names() const { return unique_names; }
void set_unique_names(const TypedArray<String> &p_unique_names); void set_unique_names(const HashSet<String> &p_unique_names) { unique_names = p_unique_names; }
TypedArray<String> get_unique_names_bind() const;
void set_unique_names_bind(const TypedArray<String> &p_unique_names);
TypedArray<String> get_unique_animation_names(); const HashSet<String> &get_unique_animation_names() const { return unique_animation_names; }
void set_unique_animation_names(const TypedArray<String> &p_unique_names); void set_unique_animation_names(const HashSet<String> &p_unique_animation_names) { unique_animation_names = p_unique_animation_names; }
TypedArray<String> get_unique_animation_names_bind() const;
void set_unique_animation_names_bind(const TypedArray<String> &p_unique_names);
TypedArray<GLTFSkeleton> get_skeletons(); const Vector<Ref<GLTFSkeleton>> &get_skeletons() const { return skeletons; }
void set_skeletons(const TypedArray<GLTFSkeleton> &p_skeletons); void set_skeletons(const Vector<Ref<GLTFSkeleton>> &p_skeletons) { skeletons = p_skeletons; }
TypedArray<GLTFSkeleton> get_skeletons_bind() const;
void set_skeletons_bind(const TypedArray<GLTFSkeleton> &p_skeletons);
bool get_create_animations(); bool get_create_animations() const;
void set_create_animations(bool p_create_animations); void set_create_animations(bool p_create_animations);
bool get_import_as_skeleton_bones(); bool get_import_as_skeleton_bones() const;
void set_import_as_skeleton_bones(bool p_import_as_skeleton_bones); void set_import_as_skeleton_bones(bool p_import_as_skeleton_bones);
TypedArray<GLTFAnimation> get_animations(); const Vector<Ref<GLTFAnimation>> &get_animations() const { return animations; }
void set_animations(const TypedArray<GLTFAnimation> &p_animations); void set_animations(const Vector<Ref<GLTFAnimation>> &p_animations) { animations = p_animations; }
TypedArray<GLTFAnimation> get_animations_bind() const;
void set_animations_bind(const TypedArray<GLTFAnimation> &p_animations);
Node *get_scene_node(GLTFNodeIndex idx); Node *get_scene_node(GLTFNodeIndex p_gltf_node_index) const;
GLTFNodeIndex get_node_index(Node *p_node); GLTFNodeIndex get_node_index(Node *p_node) const;
int get_animation_players_count(int idx); int get_animation_players_count(int p_anim_player_index) const;
AnimationPlayer *get_animation_player(int idx); AnimationPlayer *get_animation_player(int p_anim_player_index) const;
Variant get_additional_data(const StringName &p_extension_name); Variant get_additional_data(const StringName &p_extension_name) const;
void set_additional_data(const StringName &p_extension_name, Variant p_additional_data); void set_additional_data(const StringName &p_extension_name, Variant p_additional_data);
}; };

14
modules/gltf/structures/gltf_accessor.cpp
View file

@ -550,7 +550,7 @@ bool GLTFAccessor::is_equal_exact(const Ref<GLTFAccessor> &p_other) const {
// Private decode functions. // Private decode functions.
PackedInt64Array GLTFAccessor::_decode_sparse_indices(const Ref<GLTFState> &p_gltf_state, const TypedArray<GLTFBufferView> &p_buffer_views) const { PackedInt64Array GLTFAccessor::_decode_sparse_indices(const Ref<GLTFState> &p_gltf_state, const Vector<Ref<GLTFBufferView>> &p_buffer_views) const {
const int64_t bytes_per_component = _get_bytes_per_component(sparse_indices_component_type); const int64_t bytes_per_component = _get_bytes_per_component(sparse_indices_component_type);
PackedInt64Array numbers; PackedInt64Array numbers;
ERR_FAIL_INDEX_V(sparse_indices_buffer_view, p_buffer_views.size(), numbers); ERR_FAIL_INDEX_V(sparse_indices_buffer_view, p_buffer_views.size(), numbers);
@ -589,7 +589,7 @@ PackedInt64Array GLTFAccessor::_decode_sparse_indices(const Ref<GLTFState> &p_gl
} }
template <typename T> template <typename T>
Vector<T> GLTFAccessor::_decode_raw_numbers(const Ref<GLTFState> &p_gltf_state, const TypedArray<GLTFBufferView> &p_buffer_views, bool p_sparse_values) const { Vector<T> GLTFAccessor::_decode_raw_numbers(const Ref<GLTFState> &p_gltf_state, const Vector<Ref<GLTFBufferView>> &p_buffer_views, bool p_sparse_values) const {
const int64_t bytes_per_component = _get_bytes_per_component(component_type); const int64_t bytes_per_component = _get_bytes_per_component(component_type);
const int64_t bytes_per_vector = _get_bytes_per_vector(); const int64_t bytes_per_vector = _get_bytes_per_vector();
const int64_t vector_size = _get_vector_size(); const int64_t vector_size = _get_vector_size();
@ -732,7 +732,7 @@ Vector<T> GLTFAccessor::_decode_raw_numbers(const Ref<GLTFState> &p_gltf_state,
template <typename T> template <typename T>
Vector<T> GLTFAccessor::_decode_as_numbers(const Ref<GLTFState> &p_gltf_state) const { Vector<T> GLTFAccessor::_decode_as_numbers(const Ref<GLTFState> &p_gltf_state) const {
const TypedArray<GLTFBufferView> &p_buffer_views = p_gltf_state->get_buffer_views(); const Vector<Ref<GLTFBufferView>> &p_buffer_views = p_gltf_state->get_buffer_views();
Vector<T> ret_numbers = _decode_raw_numbers<T>(p_gltf_state, p_buffer_views, false); Vector<T> ret_numbers = _decode_raw_numbers<T>(p_gltf_state, p_buffer_views, false);
if (sparse_count == 0) { if (sparse_count == 0) {
return ret_numbers; return ret_numbers;
@ -1440,10 +1440,10 @@ GLTFAccessorIndex GLTFAccessor::store_accessor_data_into_state(const Ref<GLTFSta
ERR_FAIL_COND_V_MSG(buffer_view_index == -1, -1, "glTF export: Accessor failed to write new buffer view into glTF state."); ERR_FAIL_COND_V_MSG(buffer_view_index == -1, -1, "glTF export: Accessor failed to write new buffer view into glTF state.");
set_buffer_view(buffer_view_index); set_buffer_view(buffer_view_index);
// Add the new accessor to the state, but check for duplicates first. // Add the new accessor to the state, but check for duplicates first.
TypedArray<GLTFAccessor> state_accessors = p_gltf_state->get_accessors(); Vector<Ref<GLTFAccessor>> state_accessors = p_gltf_state->get_accessors();
const GLTFAccessorIndex accessor_count = state_accessors.size(); const GLTFAccessorIndex accessor_count = state_accessors.size();
for (GLTFAccessorIndex i = 0; i < accessor_count; i++) { for (GLTFAccessorIndex i = 0; i < accessor_count; i++) {
Ref<GLTFAccessor> existing_accessor = state_accessors[i]; const Ref<GLTFAccessor> &existing_accessor = state_accessors[i];
if (is_equal_exact(existing_accessor)) { if (is_equal_exact(existing_accessor)) {
// An identical accessor already exists in the state, so just return the index. // An identical accessor already exists in the state, so just return the index.
return i; return i;
@ -1675,10 +1675,10 @@ GLTFAccessorIndex GLTFAccessor::encode_new_sparse_accessor_from_vec3s(const Ref<
const PackedFloat64Array filtered_numbers = accessor->_filter_numbers(dense_values); const PackedFloat64Array filtered_numbers = accessor->_filter_numbers(dense_values);
accessor->_calculate_min_and_max(filtered_numbers); accessor->_calculate_min_and_max(filtered_numbers);
// Add the new accessor to the state, but check for duplicates first. // Add the new accessor to the state, but check for duplicates first.
TypedArray<GLTFAccessor> state_accessors = p_gltf_state->get_accessors(); Vector<Ref<GLTFAccessor>> state_accessors = p_gltf_state->get_accessors();
const GLTFAccessorIndex accessor_count = state_accessors.size(); const GLTFAccessorIndex accessor_count = state_accessors.size();
for (GLTFAccessorIndex i = 0; i < accessor_count; i++) { for (GLTFAccessorIndex i = 0; i < accessor_count; i++) {
Ref<GLTFAccessor> existing_accessor = state_accessors[i]; const Ref<GLTFAccessor> &existing_accessor = state_accessors[i];
if (accessor->is_equal_exact(existing_accessor)) { if (accessor->is_equal_exact(existing_accessor)) {
// An identical accessor already exists in the state, so just return the index. // An identical accessor already exists in the state, so just return the index.
return i; return i;

4
modules/gltf/structures/gltf_accessor.h
View file

@ -95,9 +95,9 @@ private:
int64_t _get_bytes_per_vector() const; int64_t _get_bytes_per_vector() const;
// Private decode functions. // Private decode functions.
PackedInt64Array _decode_sparse_indices(const Ref<GLTFState> &p_gltf_state, const TypedArray<GLTFBufferView> &p_buffer_views) const; PackedInt64Array _decode_sparse_indices(const Ref<GLTFState> &p_gltf_state, const Vector<Ref<GLTFBufferView>> &p_buffer_views) const;
template <typename T> template <typename T>
Vector<T> _decode_raw_numbers(const Ref<GLTFState> &p_gltf_state, const TypedArray<GLTFBufferView> &p_buffer_views, bool p_sparse_values) const; Vector<T> _decode_raw_numbers(const Ref<GLTFState> &p_gltf_state, const Vector<Ref<GLTFBufferView>> &p_buffer_views, bool p_sparse_values) const;
template <typename T> template <typename T>
Vector<T> _decode_as_numbers(const Ref<GLTFState> &p_gltf_state) const; Vector<T> _decode_as_numbers(const Ref<GLTFState> &p_gltf_state) const;

10
modules/gltf/structures/gltf_buffer_view.cpp
View file

@ -110,7 +110,7 @@ void GLTFBufferView::set_vertex_attributes(bool p_attributes) {
Vector<uint8_t> GLTFBufferView::load_buffer_view_data(const Ref<GLTFState> p_gltf_state) const { Vector<uint8_t> GLTFBufferView::load_buffer_view_data(const Ref<GLTFState> p_gltf_state) const {
ERR_FAIL_COND_V(p_gltf_state.is_null(), Vector<uint8_t>()); ERR_FAIL_COND_V(p_gltf_state.is_null(), Vector<uint8_t>());
const TypedArray<Vector<uint8_t>> &buffers = p_gltf_state->get_buffers(); const Vector<PackedByteArray> &buffers = p_gltf_state->get_buffers();
ERR_FAIL_INDEX_V(buffer, buffers.size(), Vector<uint8_t>()); ERR_FAIL_INDEX_V(buffer, buffers.size(), Vector<uint8_t>());
const PackedByteArray &buffer_data = buffers[buffer]; const PackedByteArray &buffer_data = buffers[buffer];
const int64_t byte_end = byte_offset + byte_length; const int64_t byte_end = byte_offset + byte_length;
@ -127,11 +127,11 @@ GLTFBufferViewIndex GLTFBufferView::write_new_buffer_view_into_state(const Ref<G
ERR_FAIL_COND_V_MSG(p_byte_stride < 4 || p_byte_stride % 4 != 0, -1, "glTF export: Vertex attributes using TARGET_ARRAY_BUFFER must have a byte stride that is a multiple of 4 as required by section 3.6.2.4 of the glTF specification."); ERR_FAIL_COND_V_MSG(p_byte_stride < 4 || p_byte_stride % 4 != 0, -1, "glTF export: Vertex attributes using TARGET_ARRAY_BUFFER must have a byte stride that is a multiple of 4 as required by section 3.6.2.4 of the glTF specification.");
} }
// Check for duplicate buffer views before adding a new one. // Check for duplicate buffer views before adding a new one.
TypedArray<GLTFBufferView> state_buffer_views = p_gltf_state->get_buffer_views(); Vector<Ref<GLTFBufferView>> state_buffer_views = p_gltf_state->get_buffer_views();
const int buffer_view_index = state_buffer_views.size(); const int buffer_view_index = state_buffer_views.size();
if (p_deduplicate) { if (p_deduplicate) {
for (int i = 0; i < buffer_view_index; i++) { for (int i = 0; i < buffer_view_index; i++) {
const Ref<GLTFBufferView> existing_buffer_view = state_buffer_views[i]; const Ref<GLTFBufferView> &existing_buffer_view = state_buffer_views[i];
if (existing_buffer_view->get_byte_offset() % p_alignment == 0 && if (existing_buffer_view->get_byte_offset() % p_alignment == 0 &&
existing_buffer_view->get_byte_length() == p_input_data.size() && existing_buffer_view->get_byte_length() == p_input_data.size() &&
existing_buffer_view->get_byte_stride() == p_byte_stride && existing_buffer_view->get_byte_stride() == p_byte_stride &&
@ -145,7 +145,7 @@ GLTFBufferViewIndex GLTFBufferView::write_new_buffer_view_into_state(const Ref<G
} }
} }
// Write the data into the buffer at the specified index. // Write the data into the buffer at the specified index.
TypedArray<PackedByteArray> state_buffers = p_gltf_state->get_buffers(); Vector<PackedByteArray> state_buffers = p_gltf_state->get_buffers();
if (state_buffers.size() <= p_buffer_index) { if (state_buffers.size() <= p_buffer_index) {
state_buffers.resize(p_buffer_index + 1); state_buffers.resize(p_buffer_index + 1);
} }
@ -160,7 +160,7 @@ GLTFBufferViewIndex GLTFBufferView::write_new_buffer_view_into_state(const Ref<G
state_buffer.resize(byte_offset + input_data_size); state_buffer.resize(byte_offset + input_data_size);
uint8_t *buffer_ptr = state_buffer.ptrw(); uint8_t *buffer_ptr = state_buffer.ptrw();
memcpy(buffer_ptr + byte_offset, p_input_data.ptr(), input_data_size); memcpy(buffer_ptr + byte_offset, p_input_data.ptr(), input_data_size);
state_buffers[p_buffer_index] = state_buffer; state_buffers.set(p_buffer_index, state_buffer);
p_gltf_state->set_buffers(state_buffers); p_gltf_state->set_buffers(state_buffers);
// Create a new GLTFBufferView that references the new buffer. // Create a new GLTFBufferView that references the new buffer.
Ref<GLTFBufferView> buffer_view; Ref<GLTFBufferView> buffer_view;