okooooooo/EVEngine
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
5d22975786490b44b5423dcf66e2ef2834447e2e
EVEngine/test/scene_editor_session.cpp
T

259 lines
13 KiB
C++
Raw Blame History

#include "scene/editor/SceneEditorSession.h"
#include "zeroerr/assert.h"
#include "zeroerr/unittest.h"
#include <cmath>
TEST_CASE("scene.editor.session_create_restore_and_undo_share_one_history") {
using namespace eve::editing;
eve::scene_editor::SceneEditorSession session("level");
const auto empty = session.saveJson();
REQUIRE(session.execute("scene.object.create.v1", Value::Object{{"object", "box"}}).ok());
const auto created = session.saveJson();
REQUIRE(created != empty);
REQUIRE(session.undo().ok());
REQUIRE_EQ(session.saveJson(), empty);
REQUIRE(session.redo().ok());
REQUIRE_EQ(session.saveJson(), created);
REQUIRE(session.restoreJson(empty).ok());
REQUIRE_EQ(session.saveJson(), empty);
REQUIRE(session.undo().ok());
REQUIRE_EQ(session.saveJson(), created);
REQUIRE(!session.restoreJson("{broken").ok());
REQUIRE_EQ(session.saveJson(), created);
REQUIRE(session.execute("scene.object.rename.v1", Value::Object{{"object", "box"}, {"name", "Crate"}}).ok());
const auto renamed = session.saveJson();
REQUIRE(!session
.execute("scene.object.update.v1", Value::Object{{"object", "box"},
{"name", "Partial"},
{"parent", "missing"},
{"position", Value::Array{3, 4, 5}}})
.ok());
REQUIRE_EQ(session.saveJson(), renamed);
}
TEST_CASE("scene.editor.physics_placement_commits_selected_objects_as_one_undo_step") {
using namespace eve::editing;
using namespace eve::scene_editor;
SceneEditorSession session("physics-placement");
REQUIRE(session
.execute("scene.object.create.v1",
Value::Object{{"object", "wall"}, {"position", Value::Array{2.0, 0.5, 0.0}}})
.ok());
REQUIRE(session.execute("scene.object.create.v1", Value::Object{{"object", "crate"}}).ok());
const auto before = session.saveJson();
PhysicsPlacementRequest request;
request.objects.push_back({ObjectId("wall"), {}, 0.5, 2.0, 2.0, false});
request.objects.push_back({ObjectId("crate"), {}, 0.5, 0.5, 0.5, true});
REQUIRE(session.beginPhysicsPlacement(std::move(request)).ok());
REQUIRE(session.physicsPlacementActive());
for (int step = 0; step < 90; ++step) REQUIRE(session.updatePhysicsPlacement(4.0, 0.5, 0.0).ok());
REQUIRE_EQ(session.saveJson(), before);
REQUIRE(session.commitPhysicsPlacement().ok());
REQUIRE(!session.physicsPlacementActive());
REQUIRE(session.saveJson() != before);
REQUIRE(session.undo().ok());
REQUIRE_EQ(session.saveJson(), before);
}
TEST_CASE("scene.editor.physics_placement_cancel_is_non_destructive") {
using namespace eve::editing;
using namespace eve::scene_editor;
SceneEditorSession session("physics-placement-cancel");
REQUIRE(session.execute("scene.object.create.v1", Value::Object{{"object", "crate"}}).ok());
const auto before = session.saveJson();
PhysicsPlacementRequest request;
request.objects.push_back({ObjectId("crate"), {}, 0.5, 0.5, 0.5, true});
REQUIRE(session.beginPhysicsPlacement(std::move(request)).ok());
REQUIRE(session.updatePhysicsPlacement(3.0, 0.0, 0.0).ok());
REQUIRE(session.cancelPhysicsPlacement().ok());
REQUIRE_EQ(session.saveJson(), before);
}
TEST_CASE("scene.editor.physics_placement_transform_commits_scale_and_undoes_atomically") {
using namespace eve::editing;
using namespace eve::scene_editor;
SceneEditorSession session("physics-placement-scale");
REQUIRE(session.execute("scene.object.create.v1", Value::Object{{"object", "crate"}}).ok());
const auto before = session.saveJson();
PhysicsPlacementRequest request;
request.primaryObject = ObjectId("crate");
request.objects.push_back({ObjectId("crate"), {}, 0.5, 0.5, 0.5, true});
REQUIRE(session.beginPhysicsPlacement(std::move(request)).ok());
auto frame = session.updatePhysicsPlacementTransform(1.0, 0.0, 0.0, 0.0, 0.0, 0.25, 2.0, 1.5, 0.75);
REQUIRE(frame.ok());
CHECK(std::abs(frame.value().objects[0].transform.scaleX - 2.0) < 0.001);
REQUIRE(session.commitPhysicsPlacement().ok());
REQUIRE(session.saveJson() != before);
REQUIRE(session.undo().ok());
REQUIRE_EQ(session.saveJson(), before);
}
TEST_CASE("scene.editor.physics_placement_auto_hull_cache_is_explicit_and_session_owned") {
using namespace eve::editing;
using namespace eve::scene_editor;
SceneEditorSession session("physics-placement-auto-hull");
REQUIRE(session.execute("scene.object.create.v1", Value::Object{{"object", "mesh"}}).ok());
PhysicsPlacementRequest missing;
auto object = PhysicsPlacementObject{ObjectId("mesh"), {}, 0.5, 0.5, 0.5, true};
object.shape = PhysicsPlacementShape::Auto;
missing.objects.push_back(object);
const auto missingResult = session.beginPhysicsPlacement(std::move(missing));
REQUIRE(missingResult.code() == Status::NotFound);
const std::vector<float> cube = {-0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f,
-0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f};
REQUIRE(session.cachePhysicsPlacementHull(ObjectId("mesh"), cube, 32).ok());
const auto invalidCache = session.cachePhysicsPlacementHull(
ObjectId("mesh"), {0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f}, 32);
REQUIRE(invalidCache.code() == Status::Rejected);
PhysicsPlacementRequest cached;
cached.objects.push_back(object);
REQUIRE(session.beginPhysicsPlacement(std::move(cached)).ok());
REQUIRE(session.cancelPhysicsPlacement().ok());
REQUIRE(session.removePhysicsPlacementHull(ObjectId("mesh")).ok());
const auto missingRemoval = session.removePhysicsPlacementHull(ObjectId("mesh"));
REQUIRE(missingRemoval.code() == Status::NoOp);
}
TEST_CASE("scene.editor.physics_placement_compound_cache_round_trips_and_detects_stale_resources") {
using namespace eve::editing;
using namespace eve::scene_editor;
SceneEditorSession source("physics-placement-compound-cache-source");
PhysicsPlacementCollider left;
left.halfExtentX = 0.25;
left.halfExtentY = 1.0;
left.halfExtentZ = 0.5;
left.localX = -0.75;
PhysicsPlacementCollider right = left;
right.localX = 0.75;
REQUIRE(source.cachePhysicsPlacementCompound(ObjectId("arch"), "mesh-hash-1", {left, right}).ok());
const auto json = source.savePhysicsPlacementColliderCacheJson();
SceneEditorSession restored("physics-placement-compound-cache-restored");
REQUIRE(restored.execute("scene.object.create.v1", Value::Object{{"object", "arch"}}).ok());
REQUIRE(restored.restorePhysicsPlacementColliderCacheJson(json).ok());
PhysicsPlacementObject object{ObjectId("arch"), {}, 1.0, 1.0, 0.5, true};
object.shape = PhysicsPlacementShape::Auto;
object.colliderResourceKey = "mesh-hash-1";
PhysicsPlacementRequest request;
request.objects.push_back(object);
REQUIRE(restored.beginPhysicsPlacement(std::move(request)).ok());
REQUIRE(restored.cancelPhysicsPlacement().ok());
object.colliderResourceKey = "mesh-hash-2";
PhysicsPlacementRequest stale;
stale.objects.push_back(object);
CHECK_EQ(static_cast<int>(restored.beginPhysicsPlacement(std::move(stale)).code()),
static_cast<int>(Status::Conflict));
const auto before = restored.savePhysicsPlacementColliderCacheJson();
CHECK_EQ(static_cast<int>(restored.restorePhysicsPlacementColliderCacheJson("{}").code()),
static_cast<int>(Status::Rejected));
REQUIRE_EQ(restored.savePhysicsPlacementColliderCacheJson(), before);
}
TEST_CASE("scene.editor.physics_placement_detects_scene_changes_before_commit") {
using namespace eve::editing;
using namespace eve::scene_editor;
SceneEditorSession session("physics-placement-conflict");
REQUIRE(session.execute("scene.object.create.v1", Value::Object{{"object", "crate"}}).ok());
PhysicsPlacementRequest request;
request.objects.push_back({ObjectId("crate"), {}, 0.5, 0.5, 0.5, true});
REQUIRE(session.beginPhysicsPlacement(std::move(request)).ok());
REQUIRE(session.execute("scene.object.rename.v1", Value::Object{{"object", "crate"}, {"name", "Changed"}}).ok());
const auto committed = session.commitPhysicsPlacement();
REQUIRE_EQ(static_cast<int>(committed.code()), static_cast<int>(Status::Conflict));
REQUIRE(session.physicsPlacementActive());
REQUIRE(session.cancelPhysicsPlacement().ok());
}
TEST_CASE("scene.editor.physics_placement_converts_mixed_parent_world_preview_back_to_local_trs") {
using namespace eve::editing;
using namespace eve::scene_editor;
SceneEditorSession session("physics-placement-parents");
REQUIRE(session
.execute("scene.object.create.v1",
Value::Object{{"object", "left-parent"}, {"position", Value::Array{10.0, 0.0, 0.0}}})
.ok());
REQUIRE(session
.execute("scene.object.create.v1",
Value::Object{{"object", "right-parent"}, {"position", Value::Array{-10.0, 0.0, 0.0}}})
.ok());
REQUIRE(session
.execute("scene.object.create.v1",
Value::Object{
{"object", "left"}, {"parent", "left-parent"}, {"position", Value::Array{1.0, 0.0, 0.0}}})
.ok());
REQUIRE(session
.execute("scene.object.create.v1", Value::Object{{"object", "right"},
{"parent", "right-parent"},
{"position", Value::Array{2.0, 0.0, 0.0}}})
.ok());
PhysicsPlacementRequest request;
request.primaryObject = ObjectId("left");
request.objects.push_back({ObjectId("left"), {}, 0.5, 0.5, 0.5, true});
request.objects.push_back({ObjectId("right"), {}, 0.5, 0.5, 0.5, true});
REQUIRE(session.beginPhysicsPlacement(std::move(request)).ok());
for (int step = 0; step < 30; ++step) REQUIRE(session.updatePhysicsPlacement(3.5, 0.0, 0.0).ok());
REQUIRE(session.commitPhysicsPlacement().ok());
const auto snapshot = session.snapshot();
const auto* root = snapshot.getIf<Value::Object>();
REQUIRE(root != nullptr);
const auto* objects = root->at("objects").getIf<Value::Array>();
REQUIRE(objects != nullptr);
const auto localX = [&](const std::string& id) {
for (const auto& entry : *objects) {
const auto* fields = entry.getIf<Value::Object>();
if (!fields) continue;
const auto* objectId = fields->at("id").getIf<std::string>();
if (objectId && *objectId == id) {
const auto* transform = fields->at("transform").getIf<Value::Object>();
return *transform->at("x").getIf<double>();
}
}
return -1000.0;
};
CHECK(std::abs(localX("left") - 3.0) < 0.08);
CHECK(std::abs(localX("right") - 4.0) < 0.08);
}
TEST_CASE("scene.editor.physics_placement_selected_parent_uses_its_final_world_for_child_local_trs") {
using namespace eve::editing;
using namespace eve::scene_editor;
SceneEditorSession session("physics-placement-selected-parent");
REQUIRE(session
.execute("scene.object.create.v1",
Value::Object{{"object", "parent"}, {"position", Value::Array{5.0, 0.0, 0.0}}})
.ok());
REQUIRE(session
.execute(
"scene.object.create.v1",
Value::Object{{"object", "child"}, {"parent", "parent"}, {"position", Value::Array{1.0, 0.0, 0.0}}})
.ok());
PhysicsPlacementRequest request;
request.primaryObject = ObjectId("parent");
request.objects.push_back({ObjectId("parent"), {}, 0.4, 0.4, 0.4, true});
request.objects.push_back({ObjectId("child"), {}, 0.4, 0.4, 0.4, true});
REQUIRE(session.beginPhysicsPlacement(std::move(request)).ok());
for (int step = 0; step < 30; ++step) REQUIRE(session.updatePhysicsPlacement(7.5, 0.0, 0.0).ok());
REQUIRE(session.commitPhysicsPlacement().ok());
const auto snapshot = session.snapshot();
const auto* root = snapshot.getIf<Value::Object>();
REQUIRE(root != nullptr);
const auto* objects = root->at("objects").getIf<Value::Array>();
REQUIRE(objects != nullptr);
const auto localX = [&](const std::string& id) {
for (const auto& entry : *objects) {
const auto* fields = entry.getIf<Value::Object>();
if (!fields) continue;
const auto* objectId = fields->at("id").getIf<std::string>();
if (objectId && *objectId == id) {
const auto* transform = fields->at("transform").getIf<Value::Object>();
return *transform->at("x").getIf<double>();
}
}
return -1000.0;
};
CHECK(std::abs(localX("parent") - 7.0) < 0.08);
CHECK(std::abs(localX("child") - 1.0) < 0.08);
}
Reference in new issue View Git Blame Copy Permalink