Prefab và transform cha–con

Prefab

Prefab là mẫu để tạo entity: một hàm dựng có tên, gắn component vào entity vừa tạo. Viết hàm dựng một lần, rồi spawn bao nhiêu lần cũng được, kể cả tìm theo tên.

#include <njin.h>
 
namespace {
struct health {
  njin::i32 hp = 3;
};
struct enemy {};
struct orbit {
  njin::f32 speed = 180.0f; // độ mỗi giây
};
 
njin::texture_handle atlas{};
njin::prefab_handle sword{};
 
// Hàm dựng: entity đã có transform (vị trí spawn) và scene_owned.
void build_sword(njin::context &ctx, entt::entity e) {
  njin::world(ctx).emplace<njin::sprite>(
      e, njin::sprite{.texture = atlas, .source = {{64, 0}, {16, 32}}, .layer = 11});
}
 
void build_goblin(njin::context &ctx, entt::entity e) {
  entt::registry &reg = njin::world(ctx);
  reg.emplace<enemy>(e);
  reg.emplace<health>(e, health{.hp = 3});
  reg.emplace<njin::sprite>(e, njin::sprite{.texture = atlas,
                                            .source = {{0, 0}, {32, 32}},
                                            .layer = 10});
  // Kiếm là con của goblin: đi theo, xoay theo, và bị hủy cùng goblin.
  const entt::entity blade = njin::prefab_spawn_child(ctx, sword, e, {.pos = {14, 2}});
  reg.emplace<orbit>(blade);
}
 
void startup(njin::context &ctx) {
  atlas = njin::texture_load(ctx, "assets/atlas.png");
  sword = njin::prefab_register(ctx, {.name = "sword", .build = build_sword});
  njin::prefab_register(ctx, {.name = "goblin", .build = build_goblin});
 
  // Tìm theo tên: tiện khi tên đọc từ file màn chơi.
  for (njin::i32 i = 0; i < 5; i++)
    njin::prefab_spawn(ctx, "goblin", {.pos = {100.0f + 120.0f * (njin::f32)i, 300}});
}
 
// Xoay kiếm quanh tay: sửa `local` của child_of, không sửa transform.
void spin(njin::context &ctx) {
  const njin::f32 dt = njin::delta(ctx);
  for (auto [e, link, o] : njin::world(ctx).view<njin::child_of, orbit>().each())
    link.local.rot += o.speed * dt;
}
 
void setup(njin::context &ctx) {
  njin::ecs_register(ctx, njin::phase_startup, startup);
  njin::ecs_register(ctx, njin::phase_update, spin);
}
} // namespace
 
njin::mod_desc prefabs_module() { return {.name = "prefabs", .setup = setup}; }

njin::prefab_spawn() làm lần lượt:

1. tạo entity;
2. gắn njin::transform bằng tham số at;
3. gắn njin::scene_owned trỏ tới scene đang chạy (nếu có, và nếu prefab_desc::scene_owned không bị tắt), nên rời scene là entity tự mất;
4. gọi hàm dựng.

Muốn khác đi một chút (máu nhiều hơn, màu khác) thì sửa trên entity trả về:

const entt::entity boss = njin::prefab_spawn(ctx, "goblin", {.pos = {500, 300}, .scale = 3});
njin::world(ctx).get<health>(boss).hp = 50;

Hàm	Việc làm
njin::prefab_register()	Đăng ký prefab. Tên đã có thì trả về cái cũ
njin::prefab_find()	Tìm theo tên
njin::prefab_spawn()	Tạo entity từ prefab (handle hoặc tên)
njin::prefab_spawn_child()	Tạo entity từ prefab và gắn làm con của entity khác

Transform cha–con

Gắn njin::child_of vào một entity để nó đi theo entity cha: vũ khí trong tay, bánh xe, cái bóng dưới chân, emitter lửa ở đuôi tên lửa.

reg.emplace<njin::child_of>(gun, njin::child_of{.parent = player, .local = {.pos = {12, -4}}});

Mỗi frame, trong phase_post_update, module hierarchy của engine ghi đè transform của con bằng transform của cha kết hợp với local (xem njin::transform_combine()):

Của con	Được tính
pos	cha.pos + xoay(local.pos × cha.scale, cha.rot)
rot	cha.rot + local.rot
scale	cha.scale × local.scale

Vì vậy:

• Di chuyển con bằng local, không phải bằng transform của nó (sẽ bị ghi đè).
• Cha có thể là con của entity khác; engine tính từ gốc xuống.
• Khi cha bị hủy, con bị hủy theo. Đặt destroy_with_parent = false để con ở lại, tách ra tại vị trí cuối cùng.
• System trong phase_update đọc transform của con sẽ thấy giá trị của frame trước. Cần chính xác ngay thì tự tính bằng njin::transform_combine().
• Gắn một entity đang đứng sẵn trong thế giới vào cha mà không làm nó nhảy chỗ: dùng njin::transform_relative() để tính local.

Lật hướng (sprite.flip_x) không tự lật con. Khi nhân vật quay trái, đổi dấu local.pos.x của vũ khí.