新增程序化立方体与可碎墙验收:Model::CreateCube 五层链路 + WallFracture 碎片刚体群(命中碎裂/径向飞散/寿命清理)

This commit is contained in:
2026-10-08 22:28:49 +08:00
parent ed7cb417bd
commit d2701a3d9b
9 changed files with 415 additions and 0 deletions
+276
View File
@@ -0,0 +1,276 @@
//
// WallFracture.cpp:侧线A 验收脚本——可碎墙 + 碎片刚体群 + 寿命清理。
//
// WallFracture(挂墙实体:Static Box 刚体 + MeshRenderer 立方体):
// OnCollisionEnter(Dynamic 体以足够速度命中)→ 触发一次:
// 藏墙(MeshRenderer/RigidBody.active = false,PhysicsWorld 对账
// 自然消化:不渲染 + body 销毁)→ 按网格把墙体积切成 N 个碎片
// 实体(共享一份程序化立方体模型 + Dynamic Box 刚体),初速记入
// 待办表
// OnUpdate:碎片簿记——body 建好(下一帧 Step 对账,同 Bullet
// OnCreate 施速的时序契约)即统一施加径向初速(命中点→碎片方向 +
// 向上偏置);寿命到期统一 Destroy;总量上限防泄漏
//
// 碎片不挂脚本:单一 WallFracture 集中管理全部碎片的施速/寿命/
// 清理(一帧 spawn 几十个实体,每颗一个脚本实例纯属浪费——
// Unity 也用同一个 Explosion 脚本管一片 Fragments)。
//
// 覆盖的引擎设施:
// - Spawn()/Destroy():帧内即时创建 / 帧尾延迟销毁
// - 组件运行时装配:MeshRenderer(程序化 CreateCube 资产)+
// RigidBody(下一帧对账建 body;active=false 对账销毁)
// - OnCollisionEnter:命中点/法线 + 对方实线速度查询
// - SetLinearVelocity:body 建好后的初速注入
//
// 验收步骤:编辑器摆一堵墙(MeshRenderer = procedural://cube +
// RigidBody Static Box + 挂 WallFracture,缩放即墙尺寸)→ 场景里
// 任意实体挂 TestShoot → Play → RMB 飞行瞄准墙体 → 左键射击:
// 墙消失,碎片群从命中点径向飞散、翻滚、落地堆积,若干秒后清空。
//
#include <Engine/Scripting/Script.h>
#include <Engine/Core/Application.h>
#include <Engine/Core/Types.h>
#include <Engine/Assets/AssetManager.h> // CreateCube(门面只前向声明)
#include <Engine/Physics/PhysicsWorld.h>
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
#include <random>
using namespace Engine; // u32/f32/Entity 等基础类型 + 门面(同 TestShoot)
namespace {
// bits(PhysicsWorld 键)→ 实体(还原位模式;用前自行 valid 校验)
ECS::Entity EntityFromBits(u32 bits) {
return static_cast<ECS::Entity>(bits);
}
// 实体句柄 → bits(EntityBits() 只覆盖自身绑定实体,碎片簿记
// 需要任意实体的同款换算)
u32 BitsOf(const ECS::EntityHandle& e) {
return static_cast<u32>(
entt::to_integral(static_cast<entt::entity>(e)));
}
// ---- 可碎墙(挂墙实体;触发后自管一整批碎片)----
class WallFracture final : public Engine::Scripting::ScriptBehavior {
public:
const char* Name() const override { return "WallFracture"; }
void DeclareParams(Engine::Scripting::ParamBuilder& pb) override {
// 碎片网格:每轴切几刀(总碎片 = x*y*z;占位档位 = 每碎片
// 一实体,网格 6*4*1=24 起步,中等规模才考虑 instanced draw)
pb.Field("GridX", &m_GridX, 6);
pb.Field("GridY", &m_GridY, 4);
pb.Field("GridZ", &m_GridZ, 1);
pb.Field("BurstSpeed", &m_BurstSpeed, 4.5f); // 径向初速 m/s
pb.Field("UpBias", &m_UpBias, 2.0f); // 向上偏置 m/s
pb.Field("Lifetime", &m_Lifetime, 6.0f); // 碎片寿命(秒)
pb.Field("MaxFragments", &m_MaxFragments, 96); // 活碎片上限
pb.Field("MinImpactSpeed", &m_MinImpactSpeed, 2.0f); // 触发阈值
}
void OnCollisionEnter(u32 other, const glm::vec3& point,
const glm::vec3& normal) override {
(void)normal; // 法线留给将来定向喷射
if (m_Fired) return;
// 触发条件:对方是活的 Dynamic 刚体且速度够快(过滤
// 静止贴靠/角色轻碰——子弹/抛体必中)
auto& scene = App().GetScene();
const ECS::Entity otherE = EntityFromBits(other);
if (!scene.GetRegistry().valid(otherE)) return;
const auto* otherRb =
scene.GetRegistry().try_get<Engine::ECS::RigidBodyComponent>(
otherE);
if (!otherRb ||
otherRb->type !=
Engine::ECS::RigidBodyComponent::BodyType::Dynamic) {
return;
}
const f32 speed = glm::length(
App().GetPhysics().GetLinearVelocity(other));
if (speed < m_MinImpactSpeed) return;
Fire(point);
}
void OnUpdate(f32 dt) override {
ApplyPendingVelocities();
AgeAndCleanup(dt);
}
private:
// ---- 触发碎裂:藏墙 + 切网格 + spawn 碎片群 ----
void Fire(const glm::vec3& hitPoint) {
m_Fired = true;
// 藏墙:渲染/拾取跳过 + body 对账销毁(组件级 active,
// 与 Unity Renderer.enabled + Rigidbody 摘除同语义)
if (auto* mr = TryGetComponent<
Engine::ECS::MeshRendererComponent>()) {
mr->active = false;
}
if (auto* rb = TryGetComponent<
Engine::ECS::RigidBodyComponent>()) {
rb->active = false;
}
// 墙几何:立方体模型半边长 0.5(单位体),墙尺寸 =
// Transform 世界缩放;碎片尺寸 = 墙尺寸 / 网格
const auto& wall = Transform();
const glm::vec3 wallPos = wall.GetWorldPosition();
const glm::quat wallRot = wall.GetWorldRotationQuat();
const glm::vec3 wallSize = wall.GetWorldScale();
const glm::ivec3 grid{m_GridX, m_GridY, m_GridZ};
const glm::vec3 fragSize = wallSize /
glm::vec3{std::max(1, m_GridX), std::max(1, m_GridY),
std::max(1, m_GridZ)};
// 共享一份程序化立方体(缓存去重:同参数全场景一把 mesh)
const Engine::ModelRef brick =
App().GetAssets().CreateCube(0.5f, 140, 92, 72);
for (int i = 0; i < grid.x; ++i) {
for (int j = 0; j < grid.y; ++j) {
for (int k = 0; k < grid.z; ++k) {
// 单元中心(墙局部)→ 世界(墙旋转/平移搬运;
// 加单元内抖动避免完美网格的假感)
const glm::vec3 cell{
(i + 0.5f) * fragSize.x - wallSize.x * 0.5f,
(j + 0.5f) * fragSize.y - wallSize.y * 0.5f,
(k + 0.5f) * fragSize.z - wallSize.z * 0.5f};
const glm::vec3 jitter{
Rand(-0.2f, 0.2f) * fragSize.x,
Rand(-0.2f, 0.2f) * fragSize.y,
Rand(-0.2f, 0.2f) * fragSize.z};
const glm::vec3 pos =
wallPos + wallRot * (cell + jitter);
auto frag = Spawn("fragment");
auto& tr = frag.GetComponent<
Engine::ECS::TransformComponent>();
tr.SetPosition(pos);
// 随机小倾角:落地堆积不齐整,视觉更像碎块
tr.SetRotationQuat(glm::quat(glm::vec3{
glm::radians(Rand(-30.0f, 30.0f)),
glm::radians(Rand(-180.0f, 180.0f)),
glm::radians(Rand(-30.0f, 30.0f))}));
tr.SetScale(fragSize);
auto& fmr =
frag.AddComponent<
Engine::ECS::MeshRendererComponent>();
fmr.model = brick;
// Dynamic Box:boxHalfExtents 默认 0.5(单位体)
// × Transform 缩放 = 恰好碎片尺寸,无需改字段
auto& frb =
frag.AddComponent<
Engine::ECS::RigidBodyComponent>();
frb.type =
Engine::ECS::RigidBodyComponent::BodyType::Dynamic;
frb.collider =
Engine::ECS::RigidBodyComponent::ColliderType::Box;
frb.mass = 0.4f;
frb.friction = 0.7f;
frb.restitution = 0.05f;
// 初速待办:body 下一帧建好,OnUpdate 统一施加
//(同 Bullet OnCreate 施速的时序契约)
glm::vec3 dir = pos - hitPoint;
const f32 len = glm::length(dir);
if (len < 1e-3f) {
dir = glm::vec3{Rand(-1.0f, 1.0f), 0.6f,
Rand(-1.0f, 1.0f)};
} else {
dir /= len;
}
const glm::vec3 vel =
dir * m_BurstSpeed * Rand(0.6f, 1.3f) +
glm::vec3{0.0f, m_UpBias * Rand(0.5f, 1.0f),
0.0f};
// 总量上限:超限立即回收最老碎片(防泄漏的
// 兜底闸;寿命清理才是常态回收)
const u32 bits = BitsOf(frag);
if (m_Fragments.size() >=
static_cast<size_t>(m_MaxFragments)) {
Destroy(EntityFromBits(m_Fragments.front().bits));
m_Fragments.erase(m_Fragments.begin());
}
m_Fragments.push_back({bits, vel, 0.0f});
}
}
}
}
// ---- 施速待办:body 建好(bodyValid)即注入,勿重复 ----
void ApplyPendingVelocities() {
auto& registry = App().GetScene().GetRegistry();
for (auto it = m_Fragments.begin();
it != m_Fragments.end();) {
if (it->applied) { ++it; continue; }
const ECS::Entity e = EntityFromBits(it->bits);
if (!registry.valid(e)) { // 实体没了(外部销毁)
it = m_Fragments.erase(it);
continue;
}
const auto* rb = registry.try_get<
Engine::ECS::RigidBodyComponent>(e);
if (rb && rb->bodyValid) {
App().GetPhysics().SetLinearVelocity(it->bits,
it->velocity);
it->applied = true;
}
++it; // body 未建:留待下一帧(对账晚一帧必到)
}
}
// ---- 寿命清理:到期 Destroy(延迟队列,遍历安全)----
void AgeAndCleanup(f32 dt) {
auto& registry = App().GetScene().GetRegistry();
for (auto it = m_Fragments.begin();
it != m_Fragments.end();) {
it->age += dt;
if (it->age < m_Lifetime) { ++it; continue; }
const ECS::Entity e = EntityFromBits(it->bits);
if (registry.valid(e)) {
Destroy(e);
}
it = m_Fragments.erase(it);
}
}
static f32 Rand(f32 lo, f32 hi) {
thread_local std::mt19937 rng{std::random_device{}()};
return std::uniform_real_distribution<f32>(lo, hi)(rng);
}
struct Fragment {
u32 bits = 0; // PhysicsWorld 键(实体位模式)
glm::vec3 velocity{0.0f};// 待施初速(body 建好后注入)
f32 age = 0.0f; // 存活秒数(寿命清理用)
bool applied = false; // 初速已注入
};
int m_GridX = 6;
int m_GridY = 4;
int m_GridZ = 1;
f32 m_BurstSpeed = 4.5f;
f32 m_UpBias = 2.0f;
f32 m_Lifetime = 6.0f;
int m_MaxFragments = 96;
f32 m_MinImpactSpeed = 2.0f;
bool m_Fired = false; // 一次性触发保护
std::vector<Fragment> m_Fragments; // 活碎片簿记
};
} // namespace
ENGINE_REGISTER_SCRIPT(WallFracture)