slapin/godot-flecs-character-module
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update indentation

Browse Source
This commit is contained in:
Sergey Lapin
2023-09-15 22:14:02 +03:00
parent e8a1b7e828
commit b9be14800d
6 changed files with 327 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
src/modules/.clang-format
View File

@@ -60,7 +60,7 @@ BreakBeforeBraces: Custom
# BreakConstructorInitializersBeforeComma: false # BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: AfterColon BreakConstructorInitializers: AfterColon
# BreakStringLiterals: true # BreakStringLiterals: true
ColumnLimit: 0 ColumnLimit: 79
# CommentPragmas: '^ IWYU pragma:' # CommentPragmas: '^ IWYU pragma:'
# CompactNamespaces: false # CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: true ConstructorInitializerAllOnOneLineOrOnePerLine: true
@@ -80,15 +80,23 @@ Cpp11BracedListStyle: false
# - BOOST_FOREACH # - BOOST_FOREACH
# IfMacros: # IfMacros:
# - KJ_IF_MAYBE # - KJ_IF_MAYBE
# IncludeBlocks: Preserve IncludeBlocks: Preserve
IncludeCategories: IncludeCategories:
- Regex: '".*"' - Regex: '^<([A-Za-z0-9\/-_])+>'
Priority: 1 Priority: -6
- Regex: '^<[\w]+>'
Priority: -6
- Regex: '^<(core|scene)/.*\.h>'
Priority: -5
- Regex: '^<.*\.h>' - Regex: '^<.*\.h>'
Priority: 2 Priority: -2
- Regex: '^<.*' - Regex: '^<.*'
Priority: 3 Priority: -2
# IncludeIsMainRegex: '(Test)?$' - Regex: '".*"'
Priority: -1
- Regex: '.*'
Priority: 1
IncludeIsMainRegex: '(Test)?$'
# IncludeIsMainSourceRegex: '' # IncludeIsMainSourceRegex: ''
# IndentAccessModifiers: false # IndentAccessModifiers: false
IndentCaseLabels: true IndentCaseLabels: true

4
src/modules/character/animation_system.h
View File

@@ -21,7 +21,7 @@ enum SpecialProperty {
struct TrackNodeCache { struct TrackNodeCache {
NodePath path; NodePath path;
uint32_t id; uint32_t id;
RES resource; Ref<Resource> resource;
#if 0 #if 0
Node *node; Node *node;
Spatial *spatial; Spatial *spatial;
@@ -170,7 +170,9 @@ struct AnimationPlayerData {
AnimationMethodCallMode method_call_mode; AnimationMethodCallMode method_call_mode;
bool processing; bool processing;
bool active; bool active;
#if 0
NodePath root; NodePath root;
#endif
bool playing; bool playing;
}; };
/* public functions */ /* public functions */

143
src/modules/character/character.cpp
View File

@@ -1,10 +1,9 @@
#include "character.h" /* vim: set tabstop=8:softtabstop=8:shiftwidth=8:noexpandtab */
#include "animation_system.h" #include <cassert>
#include "skeleton-prep.h" #include <cstdint>
#include <core/engine.h> #include <core/engine.h>
#include <core/rid.h> #include <core/rid.h>
#include <core/variant_parser.h> #include <core/variant_parser.h>
#include <flecs.h>
#include <scene/3d/collision_shape.h> #include <scene/3d/collision_shape.h>
#include <scene/3d/mesh_instance.h> #include <scene/3d/mesh_instance.h>
#include <scene/animation/animation_player.h> #include <scene/animation/animation_player.h>
@@ -15,7 +14,12 @@
#include <scene/resources/skin.h> #include <scene/resources/skin.h>
#include <servers/physics_server.h> #include <servers/physics_server.h>
#include <servers/visual_server.h> #include <servers/visual_server.h>
#include <cassert>
#include <flecs.h>
#include "animation_system.h"
#include "skeleton-prep.h"
#include "character.h"
namespace ECS { namespace ECS {
Skeleton::Skeleton() Skeleton::Skeleton()
@@ -25,9 +29,7 @@ Skeleton::Skeleton()
dirty = true; dirty = true;
process_order_dirty = true; process_order_dirty = true;
} }
Skeleton::~Skeleton() Skeleton::~Skeleton() {}
{
}
} //namespace ECS } //namespace ECS
ECS::RigidBody::RigidBody(RID rid, enum type type) ECS::RigidBody::RigidBody(RID rid, enum type type)
@@ -36,9 +38,7 @@ ECS::RigidBody::RigidBody(RID rid, enum type type)
this->type = type; this->type = type;
} }
ECS::RigidBody::~RigidBody() ECS::RigidBody::~RigidBody() {}
{
}
ECS::CShape::CShape(RID body, const Transform &offset, Ref<Shape> shape) ECS::CShape::CShape(RID body, const Transform &offset, Ref<Shape> shape)
{ {
@@ -48,10 +48,7 @@ ECS::CShape::CShape(RID body, const Transform &offset, Ref<Shape> shape)
ps->body_add_shape(body, shape->get_rid(), offset, false); ps->body_add_shape(body, shape->get_rid(), offset, false);
} }
ECS::CShape::~CShape() ECS::CShape::~CShape() { shape = Ref<Shape>(nullptr); }
{
shape = Ref<Shape>(nullptr);
}
ECS::CharacterSlot::CharacterSlot(Ref<ArrayMesh> mesh, Ref<Skin> skin) ECS::CharacterSlot::CharacterSlot(Ref<ArrayMesh> mesh, Ref<Skin> skin)
{ {
@@ -62,7 +59,8 @@ ECS::CharacterSlot::CharacterSlot(Ref<ArrayMesh> mesh, Ref<Skin> skin)
this->bound = false; this->bound = false;
} }
ECS::BoneComponent::BoneComponent(int index, int parent_index, const Transform &rest) ECS::BoneComponent::BoneComponent(
int index, int parent_index, const Transform &rest)
{ {
this->index = index; this->index = index;
this->parent_index = parent_index; this->parent_index = parent_index;
@@ -94,11 +92,13 @@ int Character::create_character(int id)
List<StringName> anim_list; List<StringName> anim_list;
scene_data[id].animations.get_key_list(&anim_list); scene_data[id].animations.get_key_list(&anim_list);
List<StringName>::Element *e = anim_list.front(); List<StringName>::Element *e = anim_list.front();
ECS::AnimationPlayerData *player = root.get_mut<ECS::AnimationPlayerData>(); ECS::AnimationPlayerData *player =
root.get_mut<ECS::AnimationPlayerData>();
while (e) { while (e) {
ECS::add_animation(player, e->get(), ECS::add_animation(
scene_data[id].animations[e->get()]); player, e->get(), scene_data[id].animations[e->get()]);
flecs::log::trace("added animation %s", String(e->get()).ascii().get_data()); flecs::log::trace("added animation %s",
String(e->get()).ascii().get_data());
e = e->next(); e = e->next();
} }
root.modified<ECS::AnimationPlayerData>(); root.modified<ECS::AnimationPlayerData>();
@@ -110,9 +110,9 @@ int Character::create_character(int id)
root.modified<ECS::MetaData>(); root.modified<ECS::MetaData>();
print_line("body created for root"); print_line("body created for root");
for (i = 0; i < scene_data[id].shapes.size(); i++) { for (i = 0; i < scene_data[id].shapes.size(); i++) {
ecs.entity() ecs.entity().child_of(root).emplace<ECS::CShape>(body,
.child_of(root) scene_data[id].shapes[i].offset,
.emplace<ECS::CShape>(body, scene_data[id].shapes[i].offset, scene_data[id].shapes[i].shape); scene_data[id].shapes[i].shape);
} }
for (i = 0; i < scene_data[id].bones.size(); i++) { for (i = 0; i < scene_data[id].bones.size(); i++) {
int index = i, parent_index = scene_data[id].bones[i].parent; int index = i, parent_index = scene_data[id].bones[i].parent;
@@ -124,9 +124,14 @@ int Character::create_character(int id)
} }
for (i = 0; i < scene_data[id].meshes.size(); i++) { for (i = 0; i < scene_data[id].meshes.size(); i++) {
// flecs::log::trace("creating slot -"); // flecs::log::trace("creating slot -");
flecs::entity entity = ecs.entity(scene_data[id].meshes[i].slot_name.ascii().get_data()) flecs::entity entity =
ecs.entity(scene_data[id]
.meshes[i]
.slot_name.ascii()
.get_data())
.child_of(root) .child_of(root)
.emplace<ECS::CharacterSlot>(scene_data[id].meshes[i].mesh, .emplace<ECS::CharacterSlot>(
scene_data[id].meshes[i].mesh,
scene_data[id].meshes[i].skin); scene_data[id].meshes[i].skin);
} }
// print_line("character created"); // print_line("character created");
@@ -232,8 +237,10 @@ void Character::set_scene(int id, const Ref<PackedScene> &scene)
List<StringName>::Element *e = anim_list.front(); List<StringName>::Element *e = anim_list.front();
while (e) { while (e) {
StringName anim_name = e->get(); StringName anim_name = e->get();
Ref<Animation> animation = anim->get_animation(anim_name); Ref<Animation> animation =
scene_data[id].animations[anim_name] = animation; anim->get_animation(anim_name);
scene_data[id].animations[anim_name] =
animation;
e = e->next(); e = e->next();
} }
} }
@@ -242,20 +249,28 @@ void Character::set_scene(int id, const Ref<PackedScene> &scene)
int bone_count = skel->get_bone_count(); int bone_count = skel->get_bone_count();
scene_data[id].bones.resize(bone_count); scene_data[id].bones.resize(bone_count);
for (i = 0; i < bone_count; i++) { for (i = 0; i < bone_count; i++) {
scene_data[id].bones.write[i].name = skel->get_bone_name(i); scene_data[id].bones.write[i].name =
skel->get_bone_name(i);
scene_data[id].bones.write[i].index = i; scene_data[id].bones.write[i].index = i;
scene_data[id].bones.write[i].parent = skel->get_bone_parent(i); scene_data[id].bones.write[i].parent =
scene_data[id].bones.write[i].rest = skel->get_bone_rest(i); skel->get_bone_parent(i);
// print_line("added bone: " + scene_data[id].bones.write[i].name + " " + itos(i)); scene_data[id].bones.write[i].rest =
skel->get_bone_rest(i);
// print_line("added
//bone: " + scene_data[id].bones.write[i].name
//+ " " + itos(i));
} }
} }
for (i = 0; i < tmp->get_child_count(); i++) for (i = 0; i < tmp->get_child_count(); i++)
queue.push_back(tmp->get_child(i)); queue.push_back(tmp->get_child(i));
} }
memdelete(node); memdelete(node);
print_line("meshes loaded: " + itos(id) + " " + itos(scene_data[id].meshes.size())); print_line("meshes loaded: " + itos(id) + " " +
print_line("shapes loaded: " + itos(id) + " " + itos(scene_data[id].shapes.size())); itos(scene_data[id].meshes.size()));
print_line("animations loaded: " + itos(id) + " " + itos(scene_data[id].animations.size())); print_line("shapes loaded: " + itos(id) + " " +
itos(scene_data[id].shapes.size()));
print_line("animations loaded: " + itos(id) + " " +
itos(scene_data[id].animations.size()));
} }
Ref<PackedScene> Character::get_scene(int id) const Ref<PackedScene> Character::get_scene(int id) const
{ {
@@ -272,15 +287,18 @@ Character::Character()
void Character::_bind_methods() void Character::_bind_methods()
{ {
ClassDB::bind_method(D_METHOD("__initialize"), &Character::initialize); ClassDB::bind_method(D_METHOD("__initialize"), &Character::initialize);
ClassDB::bind_method(D_METHOD("create_character", "id"), &Character::create_character); ClassDB::bind_method(D_METHOD("create_character", "id"),
ClassDB::bind_method(D_METHOD("destroy_character", "id"), &Character::destroy_character); &Character::create_character);
ClassDB::bind_method(D_METHOD("destroy_character", "id"),
&Character::destroy_character);
ClassDB::bind_method(D_METHOD("_progress"), &Character::progress); ClassDB::bind_method(D_METHOD("_progress"), &Character::progress);
} }
void Character::init_bone() void Character::init_bone()
{ {
ecs.component<ECS::BoneComponent>() ecs.component<ECS::BoneComponent>()
.on_add([](flecs::entity e, ECS::BoneComponent &s) { .on_add([](flecs::entity e, ECS::BoneComponent &s) {
// flecs::log::trace("added bonecomponent %s", e.name().c_str()); // flecs::log::trace("added bonecomponent %s",
// e.name().c_str());
flecs::entity parent = e.parent(); flecs::entity parent = e.parent();
parent.add<ECS::Dirty>(); parent.add<ECS::Dirty>();
if (parent.has<ECS::Bound>()) { if (parent.has<ECS::Bound>()) {
@@ -306,13 +324,16 @@ void Character::init_bone()
skel->dirty = true; skel->dirty = true;
String out; String out;
VariantWriter::write_to_string(s.rest, out); VariantWriter::write_to_string(s.rest, out);
// flecs::log::trace("bonecomponent set %s (%d) [%s]", e.name().c_str(), skel->bone_count, out.ascii().get_data()); // flecs::log::trace("bonecomponent set %s (%d) [%s]",
// e.name().c_str(), skel->bone_count,
// out.ascii().get_data());
parent.remove<ECS::SkeletonOrderPrepared>(); parent.remove<ECS::SkeletonOrderPrepared>();
parent.add<ECS::Dirty>(); parent.add<ECS::Dirty>();
}); });
ecs.component<ECS::BonePose>() ecs.component<ECS::BonePose>()
.on_add([](flecs::entity e, ECS::BonePose &s) { .on_add([](flecs::entity e, ECS::BonePose &s) {
// flecs::log::trace("added bonepose %s", e.name().c_str()); // flecs::log::trace("added
//bonepose %s", e.name().c_str());
}) })
.on_set([](flecs::entity e, ECS::BonePose &s) { .on_set([](flecs::entity e, ECS::BonePose &s) {
#if 0 #if 0
@@ -330,7 +351,8 @@ void Character::init_bone()
.with<ECS::Bound>() .with<ECS::Bound>()
.parent() .parent()
.kind(flecs::OnUpdate) .kind(flecs::OnUpdate)
.each([this](flecs::entity e, ECS::BonePose &s, const ECS::Dirty &d) { .each([this](flecs::entity e, ECS::BonePose &s,
const ECS::Dirty &d) {
flecs::entity parent = e.parent(); flecs::entity parent = e.parent();
/* Don't update unbound skeleton */ /* Don't update unbound skeleton */
if (!parent.has<ECS::Bound>()) { if (!parent.has<ECS::Bound>()) {
@@ -342,7 +364,8 @@ void Character::init_bone()
skel->dirty = true; skel->dirty = true;
String out; String out;
VariantWriter::write_to_string(s.pose, out); VariantWriter::write_to_string(s.pose, out);
// flecs::log::trace("set bonepose %s %d %s", e.name().c_str(), s.index, out.ascii().get_data()); // flecs::log::trace("set bonepose %s %d %s",
// e.name().c_str(), s.index, out.ascii().get_data());
parent.modified<ECS::Skeleton>(); parent.modified<ECS::Skeleton>();
parent.add<ECS::Dirty>(); parent.add<ECS::Dirty>();
parent.remove<ECS::SkeletonTransformReady>(); parent.remove<ECS::SkeletonTransformReady>();
@@ -351,8 +374,8 @@ void Character::init_bone()
} }
void Character::animation_system_init() void Character::animation_system_init()
{ {
ecs.component<ECS::AnimationPlayerData>() ecs.component<ECS::AnimationPlayerData>().on_set(
.on_set([](flecs::entity e, ECS::AnimationPlayerData &s) { [](flecs::entity e, ECS::AnimationPlayerData &s) {
flecs::log::trace("created animation player"); flecs::log::trace("created animation player");
}); });
ecs.system<ECS::AnimationPlayerData>("UpdateAnimation") ecs.system<ECS::AnimationPlayerData>("UpdateAnimation")
@@ -360,7 +383,9 @@ void Character::animation_system_init()
.each([](flecs::entity e, ECS::AnimationPlayerData &player) { .each([](flecs::entity e, ECS::AnimationPlayerData &player) {
if (!player.playing) if (!player.playing)
ECS::play(&player, "stand1-loop"); ECS::play(&player, "stand1-loop");
ECS::advance(&player, SceneTree::get_singleton()->get_physics_process_time()); ECS::advance(&player,
SceneTree::get_singleton()
->get_physics_process_time());
}); });
} }
void Character::initialize() void Character::initialize()
@@ -370,25 +395,28 @@ void Character::initialize()
SceneTree *st = SceneTree::get_singleton(); SceneTree *st = SceneTree::get_singleton();
ecs.import <skeleton_prep>(); ecs.import <skeleton_prep>();
init_skeleton(); init_skeleton();
ecs.component<ECS::MetaData>() ecs.component<ECS::MetaData>().on_add([](flecs::entity e,
.on_add([](flecs::entity e, ECS::MetaData &s) { ECS::MetaData &s) {
flecs::log::trace("added metadata %s", e.name().c_str()); flecs::log::trace("added metadata %s", e.name().c_str());
}); });
init_bone(); init_bone();
init_slot(); init_slot();
ecs.component<ECS::AnimationTree>() ecs.component<ECS::AnimationTree>().on_add(
.on_add([](flecs::entity e, ECS::AnimationTree &s) { [](flecs::entity e, ECS::AnimationTree &s) {
flecs::log::trace("animationtree slot %s", e.name().c_str()); flecs::log::trace(
"animationtree slot %s", e.name().c_str());
}); });
ecs.component<ECS::RigidBody>() ecs.component<ECS::RigidBody>().on_add([](flecs::entity e,
.on_add([](flecs::entity e, ECS::RigidBody &s) { ECS::RigidBody &s) {
flecs::log::trace("added rigidbody %s", e.name().c_str()); flecs::log::trace("added rigidbody %s", e.name().c_str());
}); });
const String path = "res://characters/"; const String path = "res://characters/";
Ref<PackedScene> scene1 = ResourceLoader::load(path + "male-base.tscn", "PackedScene", true, &err); Ref<PackedScene> scene1 = ResourceLoader::load(
path + "male-base.tscn", "PackedScene", true, &err);
if (err == OK && scene1.is_valid()) if (err == OK && scene1.is_valid())
set_scene(0, scene1); set_scene(0, scene1);
Ref<PackedScene> scene2 = ResourceLoader::load(path + "female-base.tscn", "PackedScene", true, &err); Ref<PackedScene> scene2 = ResourceLoader::load(
path + "female-base.tscn", "PackedScene", true, &err);
if (err == OK && scene2.is_valid()) if (err == OK && scene2.is_valid())
set_scene(1, scene2); set_scene(1, scene2);
initialized = true; initialized = true;
@@ -401,9 +429,12 @@ void Character::initialize()
return; return;
if (!root.has<ECS::BonePose>()) if (!root.has<ECS::BonePose>())
return; return;
float delta = SceneTree::get_singleton()->get_physics_process_time(); float delta = SceneTree::get_singleton()
struct ECS::BonePose *bp = root.get_mut<ECS::BonePose>(); ->get_physics_process_time();
// bp->pose.basis = bp->pose.basis.rotated(Vector3(0, 1, 0), 0.016f); struct ECS::BonePose *bp =
root.get_mut<ECS::BonePose>();
// bp->pose.basis =
//bp->pose.basis.rotated(Vector3(0, 1, 0), 0.016f);
bp->pose.origin += Vector3(0.2f * delta, 0.0f, 0.0f); bp->pose.origin += Vector3(0.2f * delta, 0.0f, 0.0f);
root.modified<ECS::BonePose>(); root.modified<ECS::BonePose>();
}); });

143
src/modules/character/character_skeleton.cpp
View File

@@ -1,25 +1,27 @@
#include <cassert>
#include "character.h"
#include <core/reference.h> #include <core/reference.h>
#include <core/variant_parser.h> #include <core/variant_parser.h>
#include <flecs.h>
#include <scene/main/scene_tree.h> #include <scene/main/scene_tree.h>
#include <scene/main/viewport.h> #include <scene/main/viewport.h>
#include <scene/resources/skin.h> #include <scene/resources/skin.h>
#include <servers/visual_server.h> #include <servers/visual_server.h>
#include <cassert>
#include <flecs.h>
#include "character.h"
void Character::init_skeleton() void Character::init_skeleton()
{ {
VisualServer *vs = VS::get_singleton(); VisualServer *vs = VS::get_singleton();
ecs.component<ECS::Skeleton>() ecs.component<ECS::Skeleton>()
.on_add([](flecs::entity e, ECS::Skeleton &s) { .on_add([](flecs::entity e, ECS::Skeleton &s) {
// flecs::log::trace("added skeleton %s", e.name().c_str()); // flecs::log::trace("added
//skeleton %s", e.name().c_str());
if (e.has<ECS::SkeletonOrderPrepared>()) if (e.has<ECS::SkeletonOrderPrepared>())
e.remove<ECS::SkeletonOrderPrepared>(); e.remove<ECS::SkeletonOrderPrepared>();
}) })
.on_set([](flecs::entity e, ECS::Skeleton &s) { .on_set([](flecs::entity e, ECS::Skeleton &s) {
// flecs::log::trace("on set: set skeleton %s", e.name().c_str()); // flecs::log::trace("on set: set
//skeleton %s", e.name().c_str());
// s.process_order_dirty = true; // s.process_order_dirty = true;
e.add<ECS::Dirty>(); e.add<ECS::Dirty>();
}); });
@@ -38,15 +40,21 @@ void Character::init_skeleton()
.kind(flecs::PreUpdate) .kind(flecs::PreUpdate)
.each([](flecs::entity e, ECS::Skeleton &sk) { .each([](flecs::entity e, ECS::Skeleton &sk) {
if (sk.process_order_dirty) { if (sk.process_order_dirty) {
flecs::log::trace("skeletons: %d dirty: sorting bones", sk.bone_count); flecs::log::trace(
"skeletons: %d dirty: sorting bones",
sk.bone_count);
int i; int i;
struct ECS::Skeleton::bone_data *bonesptr = sk.bones.ptrw(); struct ECS::Skeleton::bone_data *bonesptr =
sk.bones.ptrw();
int len = sk.bones.size(); int len = sk.bones.size();
sk.process_order.resize(len); sk.process_order.resize(len);
int *order = sk.process_order.ptrw(); int *order = sk.process_order.ptrw();
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
if (bonesptr[i].parent >= len) { if (bonesptr[i].parent >= len) {
flecs::log::err("Bone %d has bad parent %d", i, bonesptr[i].parent); flecs::log::err(
"Bone %d has bad "
"parent %d",
i, bonesptr[i].parent);
bonesptr[i].parent = -1; bonesptr[i].parent = -1;
} }
order[i] = i; order[i] = i;
@@ -57,14 +65,23 @@ void Character::init_skeleton()
// fucking bubblesort // fucking bubblesort
bool swapped = false; bool swapped = false;
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
int parent_idx = bonesptr[order[i]].parent; int parent_idx =
bonesptr[order[i]]
.parent;
if (parent_idx < 0) if (parent_idx < 0)
continue; continue;
int parent_order = bonesptr[parent_idx].sort_index; int parent_order =
bonesptr[parent_idx]
.sort_index;
if (parent_order > i) { if (parent_order > i) {
bonesptr[order[i]].sort_index = parent_order; bonesptr[order[i]]
bonesptr[parent_idx].sort_index = i; .sort_index =
SWAP(order[i], order[parent_order]); parent_order;
bonesptr[parent_idx]
.sort_index =
i;
SWAP(order[i],
order[parent_order]);
swapped = true; swapped = true;
} }
} }
@@ -73,9 +90,12 @@ void Character::init_skeleton()
pass_count++; pass_count++;
} }
if (pass_count >= len * len) if (pass_count >= len * len)
flecs::log::err("Skeleton parenthood graph is cyclic"); flecs::log::err("Skeleton parenthood "
"graph is cyclic");
sk.process_order_dirty = false; sk.process_order_dirty = false;
flecs::log::trace("skeletons: %d dirty: sorting bones done", sk.bone_count); flecs::log::trace("skeletons: %d dirty: "
"sorting bones done",
sk.bone_count);
} }
e.add<ECS::SkeletonOrderPrepared>(); e.add<ECS::SkeletonOrderPrepared>();
}); });
@@ -87,61 +107,98 @@ void Character::init_skeleton()
.each([](flecs::entity e, ECS::Skeleton &sk) { .each([](flecs::entity e, ECS::Skeleton &sk) {
int i; int i;
VisualServer *vs = VS::get_singleton(); VisualServer *vs = VS::get_singleton();
// flecs::log::trace("skeletons: %d dirty: update try", sk.bone_count); // flecs::log::trace("skeletons: %d dirty: update try",
// sk.bone_count);
if (sk.process_order_dirty) if (sk.process_order_dirty)
return; return;
// flecs::log::trace("skeletons: %d dirty: update", sk.bone_count); // flecs::log::trace("skeletons:
struct ECS::Skeleton::bone_data *bonesptr = sk.bones.ptrw(); //%d dirty: update", sk.bone_count);
struct ECS::Skeleton::bone_data *bonesptr =
sk.bones.ptrw();
int len = sk.bones.size(); int len = sk.bones.size();
const int *order = sk.process_order.ptr(); const int *order = sk.process_order.ptr();
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
struct ECS::Skeleton::bone_data &b = bonesptr[order[i]]; struct ECS::Skeleton::bone_data &b =
bonesptr[order[i]];
if (b.disable_rest) { if (b.disable_rest) {
if (b.enabled) { if (b.enabled) {
Transform pose = b.pose; Transform pose = b.pose;
if (b.custom_pose_enable) if (b.custom_pose_enable)
pose = b.custom_pose * pose; pose = b.custom_pose *
pose;
if (b.parent >= 0) { if (b.parent >= 0) {
b.pose_global = bonesptr[b.parent].pose_global * pose; b.pose_global =
b.pose_global_no_override = bonesptr[b.parent].pose_global_no_override * pose; bonesptr[b.parent]
.pose_global *
pose;
b.pose_global_no_override =
bonesptr[b.parent]
.pose_global_no_override *
pose;
} else { } else {
b.pose_global = pose; b.pose_global = pose;
b.pose_global_no_override = pose; b.pose_global_no_override =
pose;
} }
} else { } else {
if (b.parent >= 0) { if (b.parent >= 0) {
b.pose_global = bonesptr[b.parent].pose_global; b.pose_global =
b.pose_global_no_override = bonesptr[b.parent].pose_global_no_override; bonesptr[b.parent]
.pose_global;
b.pose_global_no_override =
bonesptr[b.parent]
.pose_global_no_override;
} else { } else {
b.pose_global = Transform(); b.pose_global =
b.pose_global_no_override = Transform(); Transform();
b.pose_global_no_override =
Transform();
} }
} }
} else { } else {
if (b.enabled) { if (b.enabled) {
Transform pose = b.pose; Transform pose = b.pose;
if (b.custom_pose_enable) if (b.custom_pose_enable)
pose = b.custom_pose * pose; pose = b.custom_pose *
pose;
if (b.parent >= 0) { if (b.parent >= 0) {
b.pose_global = bonesptr[b.parent].pose_global * (b.rest * pose); b.pose_global =
b.pose_global_no_override = bonesptr[b.parent].pose_global_no_override * (b.rest * pose); bonesptr[b.parent]
.pose_global *
(b.rest *
pose);
b.pose_global_no_override =
bonesptr[b.parent]
.pose_global_no_override *
(b.rest *
pose);
} else { } else {
b.pose_global = b.rest * pose; b.pose_global =
b.pose_global_no_override = b.rest * pose; b.rest * pose;
b.pose_global_no_override =
b.rest * pose;
} }
} else { } else {
if (b.parent >= 0) { if (b.parent >= 0) {
b.pose_global = bonesptr[b.parent].pose_global * b.rest; b.pose_global =
b.pose_global_no_override = bonesptr[b.parent].pose_global_no_override * b.rest; bonesptr[b.parent]
.pose_global *
b.rest;
b.pose_global_no_override =
bonesptr[b.parent]
.pose_global_no_override *
b.rest;
} else { } else {
b.pose_global = b.rest; b.pose_global = b.rest;
b.pose_global_no_override = b.rest; b.pose_global_no_override =
b.rest;
} }
} }
} }
} }
// flecs::log::trace("transform should be ready"); // flecs::log::trace("transform should be
// ready");
e.add<ECS::SkeletonTransformReady>(); e.add<ECS::SkeletonTransformReady>();
assert(sk.skin_bone_indices_ptrs); assert(sk.skin_bone_indices_ptrs);
uint32_t bind_count = sk.skin->get_bind_count(); uint32_t bind_count = sk.skin->get_bind_count();
@@ -150,8 +207,11 @@ void Character::init_skeleton()
if (!e.has<ECS::Bound>()) if (!e.has<ECS::Bound>())
return; return;
for (i = 0; i < (int)bind_count; i++) { for (i = 0; i < (int)bind_count; i++) {
uint32_t bone_index = sk.skin_bone_indices_ptrs[i]; uint32_t bone_index =
Transform xform = bonesptr[bone_index].pose_global * sk.skin->get_bind_pose(i); sk.skin_bone_indices_ptrs[i];
Transform xform =
bonesptr[bone_index].pose_global *
sk.skin->get_bind_pose(i);
#if 0 #if 0
if (i == 0) { if (i == 0) {
String out; String out;
@@ -161,8 +221,9 @@ void Character::init_skeleton()
out.ascii().get_data()); out.ascii().get_data());
} }
#endif #endif
vs->skeleton_bone_set_transform(sk.skeleton, vs->skeleton_bone_set_transform(sk.skeleton, i,
i, bonesptr[bone_index].pose_global * sk.skin->get_bind_pose(i)); bonesptr[bone_index].pose_global *
sk.skin->get_bind_pose(i));
} }
sk.dirty = false; sk.dirty = false;
e.remove<ECS::Dirty>(); e.remove<ECS::Dirty>();

154
src/modules/character/character_slot.cpp
View File

@@ -1,11 +1,13 @@
#include "character.h" #include <cassert>
#include <core/reference.h> #include <core/reference.h>
#include <flecs.h>
#include <scene/main/scene_tree.h> #include <scene/main/scene_tree.h>
#include <scene/main/viewport.h> #include <scene/main/viewport.h>
#include <scene/resources/skin.h> #include <scene/resources/skin.h>
#include <servers/visual_server.h> #include <servers/visual_server.h>
#include <cassert>
#include <flecs.h>
#include "character.h"
void Character::init_slot() void Character::init_slot()
{ {
@@ -18,18 +20,23 @@ void Character::init_slot()
.on_remove([vs](flecs::entity e, ECS::CharacterSlot &s) { .on_remove([vs](flecs::entity e, ECS::CharacterSlot &s) {
if (s.instance.is_valid()) { if (s.instance.is_valid()) {
vs->instance_set_scenario(s.instance, RID()); vs->instance_set_scenario(s.instance, RID());
vs->instance_attach_skeleton(s.instance, RID()); vs->instance_attach_skeleton(
s.instance, RID());
vs->instance_set_base(s.instance, RID()); vs->instance_set_base(s.instance, RID());
vs->free(s.instance); vs->free(s.instance);
s.instance = RID(); s.instance = RID();
// print_line("mesh instance slot removed " + s.name); // print_line("mesh
//instance slot removed " + s.name);
} }
// flecs::log::trace("removed slot %s", e.name().c_str()); // flecs::log::trace("removed slot
//%s", e.name().c_str());
}) })
.on_set([st](flecs::entity e, ECS::CharacterSlot &s) { .on_set([st](flecs::entity e, ECS::CharacterSlot &s) {
// flecs::log::trace("set slot %s", e.name().c_str()); // flecs::log::trace("set slot
//%s", e.name().c_str());
if (s.mesh.is_null() || !s.mesh.is_valid()) if (s.mesh.is_null() || !s.mesh.is_valid())
flecs::log::err("invalid mesh %s", e.name().c_str()); flecs::log::err(
"invalid mesh %s", e.name().c_str());
}); });
ecs.system<ECS::CharacterSlot>("UpdateSlot") ecs.system<ECS::CharacterSlot>("UpdateSlot")
.without<ECS::Bound>() .without<ECS::Bound>()
@@ -40,11 +47,16 @@ void Character::init_slot()
assert(e.parent().has<ECS::Skeleton>()); assert(e.parent().has<ECS::Skeleton>());
if (!slot.instance.is_valid()) { if (!slot.instance.is_valid()) {
slot.name = e.name().c_str(); slot.name = e.name().c_str();
RID scenario = st->get_root()->get_world()->get_scenario(); RID scenario = st->get_root()
->get_world()
->get_scenario();
slot.instance = vs->instance_create(); slot.instance = vs->instance_create();
vs->instance_set_scenario(slot.instance, scenario); vs->instance_set_scenario(
vs->instance_set_base(slot.instance, slot.mesh->get_rid()); slot.instance, scenario);
// flecs::log::trace("created instance for %s", e.name().c_str()); vs->instance_set_base(
slot.instance, slot.mesh->get_rid());
// flecs::log::trace("created
//instance for %s", e.name().c_str());
} }
}); });
ecs.system<ECS::CharacterSlot>("AttachToSkeleton") ecs.system<ECS::CharacterSlot>("AttachToSkeleton")
@@ -58,21 +70,28 @@ void Character::init_slot()
assert(parent.has<ECS::Skeleton>()); assert(parent.has<ECS::Skeleton>());
assert(!e.has<ECS::Bound>()); assert(!e.has<ECS::Bound>());
assert(slot.instance.is_valid()); assert(slot.instance.is_valid());
const ECS::Skeleton *skel = parent.get<ECS::Skeleton>(); const ECS::Skeleton *skel =
parent.get<ECS::Skeleton>();
assert(skel->skeleton.is_valid()); assert(skel->skeleton.is_valid());
// flecs::log::trace("binding slot for %s", e.name().c_str()); // flecs::log::trace("binding slot
//for %s", e.name().c_str());
if (skel->skeleton.is_valid()) if (skel->skeleton.is_valid())
slot.skeleton = skel->skeleton; slot.skeleton = skel->skeleton;
if (slot.skin.is_null() && !skel->skin.is_null()) if (slot.skin.is_null() && !skel->skin.is_null())
slot.skin_internal = skel->skin; slot.skin_internal = skel->skin;
if (skel->skeleton.is_valid() && !skel->skin.is_null()) { if (skel->skeleton.is_valid() &&
uint32_t bind_count = skel->skin->get_bind_count(); !skel->skin.is_null()) {
vs->skeleton_allocate(skel->skeleton, bind_count); uint32_t bind_count =
vs->instance_attach_skeleton(slot.instance, skel->skeleton); skel->skin->get_bind_count();
vs->skeleton_allocate(
skel->skeleton, bind_count);
vs->instance_attach_skeleton(
slot.instance, skel->skeleton);
slot.bound = true; slot.bound = true;
e.add<ECS::Bound>(); e.add<ECS::Bound>();
parent.add<ECS::Bound>(); parent.add<ECS::Bound>();
// flecs::log::trace("bound slot for %s", e.name().c_str()); // flecs::log::trace("bound
//slot for %s", e.name().c_str());
} }
}); });
ecs.system<ECS::CharacterSlot>("BindSlotsToSkeleton") ecs.system<ECS::CharacterSlot>("BindSlotsToSkeleton")
@@ -87,63 +106,108 @@ void Character::init_slot()
assert(!e.has<ECS::Bound>()); assert(!e.has<ECS::Bound>());
assert(!e.has<ECS::Skinned>()); assert(!e.has<ECS::Skinned>());
ECS::Skeleton *skel = parent.get_mut<ECS::Skeleton>(); ECS::Skeleton *skel = parent.get_mut<ECS::Skeleton>();
if (skel->skin.is_null() && slot.skin_internal.is_null()) { if (skel->skin.is_null() &&
const struct ECS::Skeleton::bone_data *bonesptr = skel->bones.ptr(); slot.skin_internal.is_null()) {
const struct ECS::Skeleton::bone_data
*bonesptr = skel->bones.ptr();
const int *order = skel->process_order.ptr(); const int *order = skel->process_order.ptr();
// flecs::log::trace("binding slot for %s", e.name().c_str()); // flecs::log::trace("binding
//slot for %s", e.name().c_str());
slot.skin_internal.instance(); slot.skin_internal.instance();
slot.skin_internal->set_bind_count(skel->bones.size()); slot.skin_internal->set_bind_count(
skel->bones.size());
int len = skel->bones.size(); int len = skel->bones.size();
// flecs::log::trace("creating skin for %s", e.name().c_str()); // flecs::log::trace("creating
//skin for %s", e.name().c_str());
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
const struct ECS::Skeleton::bone_data &b = bonesptr[order[i]]; const struct ECS::Skeleton::bone_data
&b = bonesptr[order[i]];
if (b.parent >= 0) if (b.parent >= 0)
slot.skin_internal->set_bind_pose(order[i], slot.skin_internal->get_bind_pose(b.parent) * b.rest); slot.skin_internal->set_bind_pose(
order[i],
slot.skin_internal->get_bind_pose(
b.parent) *
b.rest);
else else
slot.skin_internal->set_bind_pose(order[i], b.rest); slot.skin_internal
->set_bind_pose(
order[i],
b.rest);
} }
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
slot.skin_internal->set_bind_bone(i, i); slot.skin_internal->set_bind_bone(
slot.skin_internal->set_bind_pose(i, slot.skin_internal->get_bind_pose(i).affine_inverse()); i, i);
slot.skin_internal->set_bind_pose(i,
slot.skin_internal
->get_bind_pose(i)
.affine_inverse());
} }
skel->skin = slot.skin_internal; skel->skin = slot.skin_internal;
// flecs::log::trace("created skin for %s: %d", e.name().c_str(), len); // flecs::log::trace("created
//skin for %s: %d", e.name().c_str(), len);
assert(skel->skeleton.is_valid()); assert(skel->skeleton.is_valid());
skel->skin = slot.skin_internal; skel->skin = slot.skin_internal;
uint32_t bind_count = skel->skin->get_bind_count(); uint32_t bind_count =
skel->skin->get_bind_count();
assert(bind_count > 0); assert(bind_count > 0);
skel->skin_bone_indices.resize(bind_count); skel->skin_bone_indices.resize(bind_count);
skel->skin_bone_indices_ptrs = skel->skin_bone_indices.ptrw(); skel->skin_bone_indices_ptrs =
skel->skin_bone_indices.ptrw();
for (i = 0; i < bind_count; i++) { for (i = 0; i < bind_count; i++) {
StringName bind_name = skel->skin->get_bind_name(i); StringName bind_name =
skel->skin->get_bind_name(i);
if (bind_name != StringName()) { if (bind_name != StringName()) {
int j; int j;
bool found = false; bool found = false;
for (j = 0; j < len; j++) { for (j = 0; j < len; j++) {
if (bonesptr[j].name == bind_name) { if (bonesptr[j].name ==
skel->skin_bone_indices_ptrs[i] = j; bind_name) {
skel->skin_bone_indices_ptrs
[i] =
j;
found = true; found = true;
break; break;
} }
} }
if (!found) { if (!found) {
skel->skin_bone_indices_ptrs[i] = 0; skel->skin_bone_indices_ptrs
flecs::log::err("no bind name %s in skeleton", String(bind_name).ascii().get_data()); [i] = 0;
flecs::log::err(
"no bind name "
"%s in "
"skeleton",
String(bind_name)
.ascii()
.get_data());
} }
} else if (skel->skin->get_bind_bone(i) >= 0) { } else if (skel->skin->get_bind_bone(
uint32_t bind_index = skel->skin->get_bind_bone(i); i) >= 0) {
uint32_t bind_index =
skel->skin
->get_bind_bone(
i);
if (bind_index >= len) { if (bind_index >= len) {
skel->skin_bone_indices_ptrs[i] = 0; skel->skin_bone_indices_ptrs
flecs::log::err("bind %d bad index %d", i, bind_index); [i] = 0;
flecs::log::err(
"bind %d bad "
"index %d",
i, bind_index);
} else } else
skel->skin_bone_indices_ptrs[i] = bind_index; skel->skin_bone_indices_ptrs
[i] =
bind_index;
} else { } else {
flecs::log::err("no bind name for %d", i); flecs::log::err(
skel->skin_bone_indices_ptrs[i] = 0; "no bind name for %d",
i);
skel->skin_bone_indices_ptrs
[i] = 0;
} }
} }
e.add<ECS::Skinned>(); e.add<ECS::Skinned>();
} else if (!skel->skin.is_null() && slot.skin_internal.is_null()) { } else if (!skel->skin.is_null() &&
slot.skin_internal.is_null()) {
slot.skin_internal = skel->skin; slot.skin_internal = skel->skin;
e.add<ECS::Skinned>(); e.add<ECS::Skinned>();
} }

8
src/modules/character/register_types.cpp
View File

@@ -1,6 +1,7 @@
#include "register_types.h"
#include "character.h"
#include <core/engine.h> #include <core/engine.h>
#include "character.h"
#include "register_types.h"
void register_character_types() void register_character_types()
{ {
@@ -30,7 +31,8 @@ void register_character_types()
#endif #endif
ClassDB::register_class<Character>(); ClassDB::register_class<Character>();
Character::get_singleton(); Character::get_singleton();
Engine::get_singleton()->add_singleton(Engine::Singleton("Character", Character::get_singleton())); Engine::get_singleton()->add_singleton(
Engine::Singleton("Character", Character::get_singleton()));
} }
void unregister_character_types() void unregister_character_types()