Relintai/broken_seals_2d
1
0
Fork 0
mirror of https://github.com/Relintai/broken_seals_2d.git synced 2025-02-18 02:54:20 +01:00
Code Issues Packages Projects Releases Wiki Activity

Remove unneeded 3d character skeleton scripts.

Browse Source
This commit is contained in:
Relintai 2022-02-20 22:16:51 +01:00
parent 9eca3ec0d8
commit 5631fd22d7
2 changed files with 0 additions and 513 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

356
game/player/CharacterSkeletonGD.gd
View File

@ -1,356 +0,0 @@
tool
extends CharacterSkeleton3D
# Copyright Péter Magyar relintai@gmail.com
# MIT License, functionality from this class needs to be protable to the entity spell system
# Copyright (c) 2019-2021 Péter Magyar
# 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.
var job_script = preload("res://player/CharacterSkeletonMeshJob.gd")
export(bool) var refresh_in_editor : bool = false setget editor_build
export(bool) var automatic_build : bool = false
export(bool) var use_lod : bool = true
export(NodePath) var mesh_instance_path : NodePath
var mesh_instance : MeshInstance = null
export(NodePath) var skeleton_path : NodePath
var skeleton : Skeleton
export(Array, ModelVisual) var viss : Array
var meshes : Array
var _current_lod_level : int = 0
var _generating : bool = false
var _mesh_job : ThreadPoolJob = null
var _material_cache : ESSMaterialCache = null
var bone_names = {
0: "root",
1: "pelvis",
2: "spine",
3: "spine_1",
4: "spine_2",
5: "neck",
6: "head",
7: "left_clavicle",
8: "left_upper_arm",
9: "left_forearm",
10: "left_hand",
11: "left_thunb_base",
12: "left_thumb_end",
13: "left_fingers_base",
14: "left_fingers_end",
15: "right_clavicle",
16: "right_upper_arm",
17: "right_forearm",
18: "right_hand",
19: "right_thumb_base",
20: "right_thumb_head",
21: "right_fingers_base",
22: "right_fingers_head",
23: "left_thigh",
24: "left_calf",
25: "left_foot",
26: "right_thigh",
27: "right_calf",
28: "right_foot",
}
var _textures : Array
var _texture : Texture
var _editor_built : bool = false
var sheathed : bool = true
func _enter_tree():
_mesh_job = job_script.new()
_mesh_job.use_lod = use_lod
_mesh_job.connect("finished", self, "job_finished")
meshes.resize(3)
skeleton = get_node(skeleton_path) as Skeleton
mesh_instance = get_node(mesh_instance_path) as MeshInstance
set_process(false)
if Engine.editor_hint:
return
# if not Engine.is_editor_hint():
for iv in viss:
add_model_visual(iv as ModelVisual)
call_deferred("sheath", sheathed)
if automatic_build:
call_deferred("build_model")
func _build_model():
if _generating:
return
_generating = true
if Engine.is_editor_hint() and not refresh_in_editor:
set_process(false)
return
if not automatic_build:
set_process(false)
return
build()
set_process(false)
model_dirty = false
func build():
setup_build_mesh()
sort_layers()
var data : Array = Array()
for skele_point in range(ESS.skeletons_bones_index_get(entity_type).count(',') + 1):
var bone_name : String = get_bone_name(skele_point)
if bone_name == "":
print("Bone name error")
continue
var bone_idx : int = skeleton.find_bone(bone_name)
var abi_dict : Dictionary = Dictionary()
for abti in range(bone_additional_mesh_transform_count):
var obi : int = bone_additional_mesh_transform_bone_index_get(abti)
var bin = get_bone_name(obi)
var bi : int = skeleton.find_bone(bin)
abi_dict[bi] = bone_additional_mesh_transform_transform_get(abti) * bone_additional_mesh_transform_user_transform_get(abti)
var ddict : Dictionary = Dictionary()
for j in range(get_model_entry_count(skele_point)):
var entry : SkeletonModelEntry = get_model_entry(skele_point, j)
for k in range(entry.entry.size):
if entry.entry.get_mesh(k):
ddict["bone_name"] = bone_name
ddict["bone_idx"] = bone_idx
var global_pose = skeleton.get_bone_global_pose(bone_idx)
ddict["transform"] = skeleton.get_bone_global_pose(bone_idx)
if abi_dict.has(bone_idx):
global_pose *= abi_dict[bone_idx]
# for abti in range(bone_model_additional_mesh_transform_count):
# var bin = get_bone_name(bone_model_additional_mesh_transform_bone_index_get(abti))
# var bi : int = skeleton.find_bone(bin)
#
# if bone_idx == bi:
# global_pose *= bone_model_additional_mesh_transform_bone_transform_get(abti)
# break
#
ddict["transform"] = global_pose
ddict["mesh"] = entry.entry.get_mesh(k)
var texture_layer_array : Array = Array()
texture_layer_array.resize(ESS.texture_layers.count(",") + 1)
var texture_used : bool = false
for j in range(get_model_entry_count(skele_point)):
var entry : SkeletonModelEntry = get_model_entry(skele_point, j)
var layer : int = entry.entry.override_layer
if texture_layer_array.size() <= layer || texture_layer_array[layer]:
continue
for k in range(entry.entry.size):
if entry.entry.get_texture(k):
texture_layer_array[layer] = entry.entry.get_texture(k)
texture_used = true
break
if texture_used:
ddict["textures"] = texture_layer_array
if !ddict.empty():
data.append(ddict)
_mesh_job.data = data
_material_cache= ESS.material_cache_get(data.hash())
if _material_cache.material_get_num() == 0:
#lock just in case
_material_cache.mutex_lock()
if _material_cache.material_get_num() == 0:
#this has to be done on the main thread!
_material_cache.initial_setup_default()
_material_cache.mutex_unlock()
_mesh_job.material_cache = _material_cache
finish_build_mesh()
ThreadPool.add_job(_mesh_job)
# _mesh_job.execute()
func setup_build_mesh() -> void:
if mesh_instance != null:
mesh_instance.hide()
if get_animation_tree() != null:
get_animation_tree().active = false
if get_animation_player() != null:
get_animation_player().play("rest")
get_animation_player().seek(0, true)
func finish_build_mesh() -> void:
mesh_instance.mesh = null
# mesh_instance.mesh = meshes[_current_lod_level]
if get_animation_tree() != null:
get_animation_tree().active = true
if mesh_instance != null:
mesh_instance.show()
_generating = false
func job_finished():
meshes = _mesh_job.meshes
mesh_instance.mesh = meshes[_current_lod_level]
if !mesh_instance.is_software_skinning_enabled():
mesh_instance.initialize_skinning(true, true)
func clear_mesh() -> void:
meshes.clear()
meshes.resize(3)
if mesh_instance != null:
mesh_instance.mesh = null
func editor_build(val : bool) -> void:
if not is_inside_tree():
return
skeleton = get_node(skeleton_path) as Skeleton
mesh_instance = get_node(mesh_instance_path) as MeshInstance
if val:
_editor_built = true
build()
else:
clear_mesh()
_editor_built = false
refresh_in_editor = val
func get_bone_name(skele_point : int) -> String:
if bone_names.has(skele_point):
return bone_names[skele_point]
return ""
func _common_attach_point_index_get(point):
if point == EntityEnums.COMMON_SKELETON_POINT_LEFT_HAND:
return 0
elif point == EntityEnums.COMMON_SKELETON_POINT_ROOT:
return 3
elif point == EntityEnums.COMMON_SKELETON_POINT_SPINE_2:
return 6
elif point == EntityEnums.COMMON_SKELETON_POINT_RIGHT_HAND:
return 1
elif point == EntityEnums.COMMON_SKELETON_POINT_BACK:
return 6
elif point == EntityEnums.COMMON_SKELETON_POINT_RIGHT_HIP:
return 4
elif point == EntityEnums.COMMON_SKELETON_POINT_WEAPON_LEFT:
return 7
elif point == EntityEnums.COMMON_SKELETON_POINT_WEAPON_LEFT_BACK:
return 9
elif point == EntityEnums.COMMON_SKELETON_POINT_WEAPON_RIGHT:
return 8
elif point == EntityEnums.COMMON_SKELETON_POINT_WEAPON_RIGHT_BACK:
return 10
elif point == EntityEnums.COMMON_SKELETON_POINT_WEAPON_LEFT_SHIELD:
return 11
return 3
func set_lod_level(level : int) -> void:
if _current_lod_level == level:
return
if meshes.size() == 0:
return
if level < 0:
return
if level >= meshes.size():
level = meshes.size() - 1
_current_lod_level = level
mesh_instance.mesh = meshes[_current_lod_level]
if !mesh_instance.is_software_skinning_enabled():
mesh_instance.initialize_skinning(true, true)
func toggle_sheath():
sheathed = not sheathed
sheath(sheathed)
func sheath(on : bool) -> void:
var pos = 0
if not on:
pos = 1
attach_point_node_get(7).set_node_position(pos)
attach_point_node_get(8).set_node_position(pos)
attach_point_node_get(9).set_node_position(pos)
attach_point_node_get(10).set_node_position(pos)
attach_point_node_get(11).set_node_position(pos)

157
game/player/CharacterSkeletonMeshJob.gd
View File

@ -1,157 +0,0 @@
tool
extends ThreadPoolJob
# Copyright Péter Magyar relintai@gmail.com
# MIT License, functionality from this class needs to be protable to the entity spell system
# Copyright (c) 2019-2021 Péter Magyar
# 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.
export(bool) var use_lod : bool = true
var meshes : Array
var _generating : bool = false
var _textures : Array
var material_cache : ESSMaterialCache = null
var materials : Array = Array()
var data : Array
signal finished
func _execute():
prepare_textures()
meshes.clear()
var mm : MeshMerger = MeshMerger.new()
mm.format = ArrayMesh.ARRAY_FORMAT_VERTEX | ArrayMesh.ARRAY_FORMAT_COLOR | ArrayMesh.ARRAY_FORMAT_BONES | ArrayMesh.ARRAY_FORMAT_INDEX | ArrayMesh.ARRAY_FORMAT_NORMAL | ArrayMesh.ARRAY_FORMAT_TEX_UV | ArrayMesh.ARRAY_FORMAT_WEIGHTS
var bones : PoolIntArray = PoolIntArray()
bones.resize(4)
bones[0] = 1
bones[1] = 0
bones[2] = 0
bones[3] = 0
var bonew : PoolRealArray = PoolRealArray()
bonew.resize(4)
bonew[0] = 1
bonew[1] = 0
bonew[2] = 0
bonew[3] = 0
for ddict in data:
var bone_name : String = ddict["bone_name"]
var bone_idx : int = ddict["bone_idx"]
var texture : Texture = ddict["texture"]
#var atlas_texture : AtlasTexture = ddict["atlas_texture"]
var transform : Transform = ddict["transform"]
var mesh : MeshDataResource = ddict["mesh"]
var rect : Rect2 = material_cache.texture_get_uv_rect(texture)
bones[0] = bone_idx
mm.add_mesh_data_resource_bone(mesh, bones, bonew, transform, rect)
var arr : Array = mm.build_mesh()
var mesh : ArrayMesh = ArrayMesh.new()
mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arr)
mesh.surface_set_material(0, material_cache.material_lod_get(0))
meshes.append(mesh)
if use_lod:
arr = MeshUtils.merge_mesh_array(arr)
var meshl2 : ArrayMesh = ArrayMesh.new()
meshl2.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arr)
meshl2.surface_set_material(0, material_cache.material_lod_get(1))
meshes.append(meshl2)
var texture : Texture = null
var ml : Material = material_cache.material_lod_get(0)
if ml is SpatialMaterial:
var spml : SpatialMaterial = ml
texture = spml.get_texture(SpatialMaterial.TEXTURE_ALBEDO)
elif ml is ShaderMaterial:
var sm : ShaderMaterial = ml
texture = sm.get_shader_param("texture_albedo")
arr = MeshUtils.bake_mesh_array_uv(arr, texture)
arr[VisualServer.ARRAY_TEX_UV] = null
var meshl3 : ArrayMesh = ArrayMesh.new()
meshl3.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arr)
meshl3.surface_set_material(0, material_cache.material_lod_get(2))
meshes.append(meshl3)
emit_signal("finished")
# call_deferred("emit_signal", "finished")
complete = true
func prepare_textures() -> void:
if !material_cache.initialized:
material_cache.mutex_lock()
#got initialized before we got the lock
#No need to have the lock anymore
if material_cache.initialized:
material_cache.mutex_unlock()
var lmerger : TextureLayerMerger = TextureLayerMerger.new()
for i in range(data.size()):
var ddict : Dictionary = data[i]
var textures : Array = ddict["textures"]
var texture : Texture = null
var tcount : int = 0
for j in range(textures.size()):
if textures[j]:
tcount += 1
if tcount > 1:
for j in range(textures.size() - 1, -1, -1):
if textures[j]:
lmerger.add_texture(textures[j])
break
lmerger.merge()
texture = lmerger.get_result_as_texture()
lmerger.clear()
else:
for j in range(textures.size() - 1, -1, -1):
if textures[j]:
texture = textures[j]
break
ddict["texture"] = texture
if texture != null:
if !material_cache.initialized:
material_cache.texture_add(texture)
data[i] = ddict
if !material_cache.initialized:
material_cache.refresh_rects()
material_cache.mutex_unlock()