[jasper] Change macro names to comply with broader conventions

src/jasper/modules/core/include/jasper/core/bootfile.hpp

@@ -18,10 +18,10 @@ struct Bootfile {
 	ox::Vector<ox::String> args;
 };
 
-oxModelBegin(Bootfile)
+OX_MODEL_BEGIN(Bootfile)
-	oxModelField(app)
+	OX_MODEL_FIELD(app)
-	oxModelField(args)
+	OX_MODEL_FIELD(args)
-oxModelEnd()
+OX_MODEL_END()
 
 
 }

src/jasper/modules/world/include/jasper/world/worlddoc.hpp

@@ -33,10 +33,10 @@ struct DocObjRef {
 	ObjectId worldObjectId{};
 };
 
-oxModelBegin(DocObjRef)
+OX_MODEL_BEGIN(DocObjRef)
-	oxModelFieldRename(worldObjectSetId, world_object_set_id)
+	OX_MODEL_FIELD_RENAME(worldObjectSetId, world_object_set_id)
-	oxModelFieldRename(worldObjectId, world_object_id)
+	OX_MODEL_FIELD_RENAME(worldObjectId, world_object_id)
-oxModelEnd()
+OX_MODEL_END()
 
 struct TileDoc {
 	constexpr static auto TypeName = "net.drinkingtea.jasper.world.TileDoc";
@@ -50,15 +50,15 @@ struct TileDoc {
 	uint8_t rightLayerAttachment{};
 };
 
-oxModelBegin(TileDoc)
+OX_MODEL_BEGIN(TileDoc)
-	oxModelField(obj)
+	OX_MODEL_FIELD(obj)
-	oxModelField(type)
+	OX_MODEL_FIELD(type)
-	oxModelFieldRename(palBank, pal_bank)
+	OX_MODEL_FIELD_RENAME(palBank, pal_bank)
-	oxModelFieldRename(topLayerAttachment, top_layer_attachment)
+	OX_MODEL_FIELD_RENAME(topLayerAttachment, top_layer_attachment)
-	oxModelFieldRename(bottomLayerAttachment, bottom_layer_attachment)
+	OX_MODEL_FIELD_RENAME(bottomLayerAttachment, bottom_layer_attachment)
-	oxModelFieldRename(leftLayerAttachment, left_layer_attachment)
+	OX_MODEL_FIELD_RENAME(leftLayerAttachment, left_layer_attachment)
-	oxModelFieldRename(rightLayerAttachment, right_layer_attachment)
+	OX_MODEL_FIELD_RENAME(rightLayerAttachment, right_layer_attachment)
-oxModelEnd()
+OX_MODEL_END()
 
 
 struct ObjectSetEntry {
@@ -68,10 +68,10 @@ struct ObjectSetEntry {
 	uint64_t id{};
 };
 
-oxModelBegin(ObjectSetEntry)
+OX_MODEL_BEGIN(ObjectSetEntry)
-	oxModelField(path)
+	OX_MODEL_FIELD(path)
-	oxModelField(id)
+	OX_MODEL_FIELD(id)
-oxModelEnd()
+OX_MODEL_END()
 
 
 struct WorldDoc {
@@ -92,7 +92,7 @@ constexpr ox::Result<ox::String> objectSetPath(WorldDoc const&wd, uint64_t setId
 	auto const obj = ox::find_if(wd.objSets.begin(), wd.objSets.end(), [setId](ObjectSetEntry const&e) {
 		return e.id == setId;
 	});
-	oxReturnError(ox::Error(obj == wd.objSets.end(), "Obj set not found"));
+	OX_RETURN_ERROR(ox::Error(obj == wd.objSets.end(), "Obj set not found"));
 	return obj->path;
 }
 
@@ -101,17 +101,17 @@ constexpr ox::Result<uint64_t> objectSetId(WorldDoc const&wd, ox::StringView set
 	auto const obj = ox::find_if(wd.objSets.begin(), wd.objSets.end(), [setPath](ObjectSetEntry const&e) {
 		return e.path == setPath;
 	});
-	oxReturnError(ox::Error(obj == wd.objSets.end(), "Obj set not found"));
+	OX_RETURN_ERROR(ox::Error(obj == wd.objSets.end(), "Obj set not found"));
 	return obj->id;
 }
 
-oxModelBegin(WorldDoc)
+OX_MODEL_BEGIN(WorldDoc)
-	oxModelFieldRename(objSets, object_sets)
+	OX_MODEL_FIELD_RENAME(objSets, object_sets)
-	oxModelFieldRename(objSetIdIdx, object_set_id_idx)
+	OX_MODEL_FIELD_RENAME(objSetIdIdx, object_set_id_idx)
-	oxModelField(columns)
+	OX_MODEL_FIELD(columns)
-	oxModelField(rows)
+	OX_MODEL_FIELD(rows)
-	oxModelField(tiles)
+	OX_MODEL_FIELD(tiles)
-oxModelEnd()
+OX_MODEL_END()
 
 [[nodiscard]]
 constexpr bool valid(WorldDoc const&doc) noexcept {

src/jasper/modules/world/include/jasper/world/worldobject.hpp

@@ -39,18 +39,18 @@ struct WorldObject {
 	uint8_t ext3{};
 };
 
-oxModelBegin(WorldObject)
+OX_MODEL_BEGIN(WorldObject)
-	oxModelField(id)
+	OX_MODEL_FIELD(id)
-	oxModelField(name)
+	OX_MODEL_FIELD(name)
-	oxModelFieldRename(intervalMs, interval_ms)
+	OX_MODEL_FIELD_RENAME(intervalMs, interval_ms)
-	oxModelFieldRename(palBank, pal_bank)
+	OX_MODEL_FIELD_RENAME(palBank, pal_bank)
-	oxModelFieldRename(subsheetId, subsheet_id)
+	OX_MODEL_FIELD_RENAME(subsheetId, subsheet_id)
-	oxModelFieldRename(collisionMap, collision_map)
+	OX_MODEL_FIELD_RENAME(collisionMap, collision_map)
-	oxModelFieldRename(objectType, object_type)
+	OX_MODEL_FIELD_RENAME(objectType, object_type)
-	oxModelField(ext1)
+	OX_MODEL_FIELD(ext1)
-	oxModelField(ext2)
+	OX_MODEL_FIELD(ext2)
-	oxModelField(ext3)
+	OX_MODEL_FIELD(ext3)
-oxModelEnd()
+OX_MODEL_END()
 
 enum class TerrainType: uint8_t {
 	NormalLand,
@@ -73,12 +73,12 @@ struct WorldObjectSet {
 	ox::Vector<WorldObject> objects;
 };
 
-oxModelBegin(WorldObjectSet)
+OX_MODEL_BEGIN(WorldObjectSet)
-	oxModelFieldRename(objIdIdx, obj_id_idx)
+	OX_MODEL_FIELD_RENAME(objIdIdx, obj_id_idx)
-	oxModelField(tilesheet)
+	OX_MODEL_FIELD(tilesheet)
-	oxModelField(palettes)
+	OX_MODEL_FIELD(palettes)
-	oxModelField(objects)
+	OX_MODEL_FIELD(objects)
-oxModelEnd()
+OX_MODEL_END()
 
 ox::Error loadObjectSet(WorldObjectSet const&os) noexcept;
 

src/jasper/modules/world/include/jasper/world/worldstatic.hpp

@@ -65,12 +65,12 @@ struct TileStatic {
 	uint8_t layerAttachments{};
 };
 
-oxModelBegin(TileStatic)
+OX_MODEL_BEGIN(TileStatic)
-	oxModelField(tileIdx)
+	OX_MODEL_FIELD(tileIdx)
-	oxModelField(palBank)
+	OX_MODEL_FIELD(palBank)
-	oxModelField(tileType)
+	OX_MODEL_FIELD(tileType)
-	oxModelField(layerAttachments)
+	OX_MODEL_FIELD(layerAttachments)
-oxModelEnd()
+OX_MODEL_END()
 
 
 struct BgLayer {
@@ -80,10 +80,10 @@ struct BgLayer {
 	ox::Vector<TileStatic> tiles;
 };
 
-oxModelBegin(BgLayer)
+OX_MODEL_BEGIN(BgLayer)
-	oxModelField(cbb)
+	OX_MODEL_FIELD(cbb)
-	oxModelField(tiles)
+	OX_MODEL_FIELD(tiles)
-oxModelEnd()
+OX_MODEL_END()
 
 
 struct WorldStatic {
@@ -97,13 +97,13 @@ struct WorldStatic {
 	ox::Array<BgLayer, 3> map;
 };
 
-oxModelBegin(WorldStatic)
+OX_MODEL_BEGIN(WorldStatic)
-	oxModelField(tilesheets)
+	OX_MODEL_FIELD(tilesheets)
-	oxModelField(palettes)
+	OX_MODEL_FIELD(palettes)
-	oxModelField(columns)
+	OX_MODEL_FIELD(columns)
-	oxModelField(rows)
+	OX_MODEL_FIELD(rows)
-	oxModelField(map)
+	OX_MODEL_FIELD(map)
-oxModelEnd()
+OX_MODEL_END()
 
 void loadTile(ObjectCache const&objCache, TileStatic &dst, TileDoc const&src) noexcept;
 

src/jasper/modules/world/src/keel/typeconv.cpp

@@ -15,7 +15,7 @@ ox::Error WorldDocToWorldStaticConverter::convert(
 		keel::Context &kctx,
 		WorldDoc &src,
 		WorldStatic &dst) const noexcept {
-	oxRequire(oc, buildObjCache(kctx, src));
+	OX_REQUIRE(oc, buildObjCache(kctx, src));
 	return loadWorldStatic(oc, src).moveTo(dst);
 }
 

src/jasper/modules/world/src/objectcache.cpp

@@ -26,7 +26,7 @@ ox::Error ObjectCache::indexSet(
 		.setId = setId,
 		.objects = {},
 	});
-	oxRequire(ts, readObj<ncore::TileSheet>(kctx, objSet.tilesheet));
+	OX_REQUIRE(ts, readObj<ncore::TileSheet>(kctx, objSet.tilesheet));
 	for (auto const&obj : objSet.objects) {
 		set.objects.emplace_back(Obj{
 			.id = obj.id,
@@ -41,7 +41,7 @@ ox::Error ObjectCache::indexSet(
 	addTileSheet(objSet.tilesheet, static_cast<int32_t>(tileCnt));
 	for (auto const&pal : objSet.palettes) {
 		m_palettes.emplace_back(pal);
-		oxRequire(p, readObj<ncore::Palette>(kctx, pal));
+		OX_REQUIRE(p, readObj<ncore::Palette>(kctx, pal));
 		m_palBank += largestPage(*p);
 	}
 	return {};
@@ -82,8 +82,8 @@ void ObjectCache::addTileSheet(ox::FileAddress path, int32_t tiles) noexcept {
 ox::Result<ObjectCache> buildObjCache(keel::Context &kctx, WorldDoc const&doc) noexcept {
 	ObjectCache cache;
 	for (auto &set : doc.objSets) {
-		oxRequire(s, readObj<WorldObjectSet>(kctx, set.path));
+		OX_REQUIRE(s, readObj<WorldObjectSet>(kctx, set.path));
-		oxReturnError(cache.indexSet(kctx, set.id, *s));
+		OX_RETURN_ERROR(cache.indexSet(kctx, set.id, *s));
 	}
 	return cache;
 }

src/jasper/modules/world/src/studio/worldeditor/commands/editsize.cpp

@@ -21,14 +21,14 @@ EditWorldSizeCommand::EditWorldSizeCommand(
 ox::Error EditWorldSizeCommand::redo() noexcept {
 	m_oldMap = m_doc.tiles;
 	resize(m_doc, m_newSize);
-	oxReturnError(loadWorldStatic(m_objCache, m_doc).moveTo(m_worldStatic));
+	OX_RETURN_ERROR(loadWorldStatic(m_objCache, m_doc).moveTo(m_worldStatic));
 	return {};
 }
 
 ox::Error EditWorldSizeCommand::undo() noexcept {
 	resize(m_doc, m_oldSize);
 	m_doc.tiles = std::move(m_oldMap);
-	oxReturnError(loadWorldStatic(m_objCache, m_doc).moveTo(m_worldStatic));
+	OX_RETURN_ERROR(loadWorldStatic(m_objCache, m_doc).moveTo(m_worldStatic));
 	return {};
 }
 

src/jasper/modules/world/src/studio/worldeditor/tileclipboard.hpp

@@ -36,7 +36,7 @@ class TileClipboard : public turbine::ClipboardObject<TileClipboard> {
 		}
 };
 
-oxModelBegin(TileClipboard)
+OX_MODEL_BEGIN(TileClipboard)
-oxModelEnd()
+OX_MODEL_END()
 
 }

src/jasper/modules/world/src/studio/worldeditor/worldeditor-imgui.cpp

@@ -30,9 +30,9 @@ struct WorldEditorConfig {
 	bool animateBg{};
 };
 
-oxModelBegin(WorldEditorConfig)
+OX_MODEL_BEGIN(WorldEditorConfig)
-	oxModelField(animateBg);
+	OX_MODEL_FIELD(animateBg);
-oxModelEnd()
+OX_MODEL_END()
 
 
 struct WorldTileDragDrop {
@@ -42,10 +42,10 @@ struct WorldTileDragDrop {
 	ObjectId objId{};
 };
 
-oxModelBegin(WorldTileDragDrop)
+OX_MODEL_BEGIN(WorldTileDragDrop)
-	oxModelField(setId)
+	OX_MODEL_FIELD(setId)
-	oxModelField(objId)
+	OX_MODEL_FIELD(objId)
-oxModelEnd()
+OX_MODEL_END()
 
 
 static WorldDoc makeValid(WorldDoc doc) noexcept {
@@ -84,7 +84,7 @@ WorldEditorImGui::WorldEditorImGui(studio::StudioContext &sctx, ox::StringView p
 		m_objCache(buildObjCache(keelCtx(m_sctx), m_doc).unwrapThrow()),
 		m_worldStatic(loadWorldStatic(m_objCache, m_doc)),
 		m_view(m_sctx, m_worldStatic) {
-	oxThrowError(loadObjectSets());
+	OX_THROW_ERROR(loadObjectSets());
 	m_objSetPicker.filePicked.connect(this, &WorldEditorImGui::addObjSet);
 	m_sctx.project->fileUpdated.connect(this, &WorldEditorImGui::handleDepUpdate);
 	studio::Editor::undoStack()->changeTriggered.connect(this, &WorldEditorImGui::undoStackChanged);
@@ -353,7 +353,7 @@ void WorldEditorImGui::handleMouseSelection(float fbPaneScale) noexcept {
 }
 
 ox::Error WorldEditorImGui::handleDrop(float fbPaneScale) noexcept {
-	oxRequire(objId, ig::getDragDropPayload<WorldTileDragDrop>("WorldTile"));
+	OX_REQUIRE(objId, ig::getDragDropPayload<WorldTileDragDrop>("WorldTile"));
 	auto const&io = ImGui::GetIO();
 	auto const fbPos = world::fbPos(ox::Vec2{io.MousePos});
 	auto const viewSz = m_view.drawSize();
@@ -389,12 +389,12 @@ ox::Error WorldEditorImGui::handleDrop(float fbPaneScale) noexcept {
 				m_objCache,
 				std::move(mods));
 	}
-	oxReturnError(loadWorldStatic(m_objCache, m_doc).moveTo(m_worldStatic));
+	OX_RETURN_ERROR(loadWorldStatic(m_objCache, m_doc).moveTo(m_worldStatic));
 	return {};
 }
 
 ox::Error WorldEditorImGui::addObjSet(ox::StringView path) noexcept {
-	oxRequire(uuid, getUuid(keelCtx(m_sctx), path));
+	OX_REQUIRE(uuid, getUuid(keelCtx(m_sctx), path));
 	std::ignore = pushCommand<AddObjectSet>(m_doc, uuid);
 	return {};
 }
@@ -415,9 +415,9 @@ ox::Error WorldEditorImGui::handleDepUpdate(ox::StringView, ox::UUID const&uuid)
 	auto const depUpdated = ox::any_of(m_doc.objSets.begin(), m_doc.objSets.end(), objSetMatches)
 	                     || ox::any_of(m_dependencies.pairs().begin(), m_dependencies.pairs().end(), depMatches);
 	if (depUpdated) {
-		oxReturnError(buildObjCache(kctx, m_doc).moveTo(m_objCache));
+		OX_RETURN_ERROR(buildObjCache(kctx, m_doc).moveTo(m_objCache));
-		oxReturnError(loadWorldStatic(m_objCache, m_doc).moveTo(m_worldStatic));
+		OX_RETURN_ERROR(loadWorldStatic(m_objCache, m_doc).moveTo(m_worldStatic));
-		oxReturnError(loadObjectSets());
+		OX_RETURN_ERROR(loadObjectSets());
 	}
 	return {};
 }
@@ -427,7 +427,7 @@ ox::Error WorldEditorImGui::loadObjectSets() noexcept {
 	m_dependencies.clear();
 	auto &kctx = keelCtx(m_sctx);
 	for (auto const&set : m_doc.objSets) {
-		oxRequireM(os, readObj<WorldObjectSet>(kctx, set.path));
+		OX_REQUIRE_M(os, readObj<WorldObjectSet>(kctx, set.path));
 		oxLogError(addDependency(os->tilesheet));
 		for (auto const&pal : os->palettes) {
 			oxLogError(addDependency(pal));
@@ -438,7 +438,7 @@ ox::Error WorldEditorImGui::loadObjectSets() noexcept {
 }
 
 ox::Error WorldEditorImGui::undoStackChanged(studio::UndoCommand const*) {
-	oxReturnError(m_view.setupWorld());
+	OX_RETURN_ERROR(m_view.setupWorld());
 	return {};
 }
 
@@ -460,7 +460,7 @@ ox::Result<ox::UUID> WorldEditorImGui::assetId() const noexcept {
 
 ox::Error WorldEditorImGui::addDependency(ox::FileAddress const&fileAddr) noexcept {
 	auto &kctx = keelCtx(m_sctx);
-	oxRequire(uuid, getUuid(kctx, fileAddr));
+	OX_REQUIRE(uuid, getUuid(kctx, fileAddr));
 	m_dependencies[uuid] = true;
 	return {};
 }

src/jasper/modules/world/src/studio/worldeditor/worldeditorview.cpp

@@ -18,7 +18,7 @@ WorldEditorView::WorldEditorView(studio::StudioContext &sctx, WorldStatic const&
 ox::Error WorldEditorView::setupWorld() noexcept {
 	glutils::resizeInitFrameBuffer(m_frameBuffer, ncore::gl::drawSize(m_scale));
 	if (m_columns != m_worldStatic.columns || m_rows != m_worldStatic.rows) {
-		oxReturnError(m_highlighter.setup({m_worldStatic.columns, m_worldStatic.rows}));
+		OX_RETURN_ERROR(m_highlighter.setup({m_worldStatic.columns, m_worldStatic.rows}));
 		m_columns = m_worldStatic.columns;
 		m_rows = m_worldStatic.rows;
 		m_selection.reset();

src/jasper/modules/world/src/studio/worldobjectseteditor/collisionmapview.cpp

@@ -30,9 +30,9 @@ ox::Error CollisionView::setup(
 	m_subsheetTilesHeight = h;
 	m_sheetTileStart = tile;
 	ncore::setBgStatus(*m_nctx, 0, true);
-	oxReturnError(ncore::loadBgTileSheet(*m_nctx, 0, tsAddr));
+	OX_RETURN_ERROR(ncore::loadBgTileSheet(*m_nctx, 0, tsAddr));
-	oxReturnError(ncore::loadBgPalette(*m_nctx, 0, palAddr));
+	OX_RETURN_ERROR(ncore::loadBgPalette(*m_nctx, 0, palAddr));
-	oxReturnError(m_highlighter.setup({w / 2, h / 2}));
+	OX_RETURN_ERROR(m_highlighter.setup({w / 2, h / 2}));
 	buildGlBuffers(colMap);
 	return {};
 }

src/jasper/modules/world/src/studio/worldobjectseteditor/commands/addobject.cpp

@@ -27,7 +27,7 @@ ox::Error AddObject::redo() noexcept {
 
 ox::Error AddObject::undo() noexcept {
 	m_obj = std::move(m_doc.objects[m_insertIdx]);
-	oxReturnError(m_doc.objects.erase(m_insertIdx));
+	OX_RETURN_ERROR(m_doc.objects.erase(m_insertIdx));
 	--m_doc.objIdIdx;
 	return {};
 }

src/jasper/modules/world/src/world.cpp

@@ -19,11 +19,11 @@ ox::Error World::setupDisplay() noexcept {
 		return ox::Error(1, "World has no palettes");
 	}
 	for (auto i = 0u; auto const&palAddr : m_worldStatic.palettes) {
-		oxRequire(pal, readObj<ncore::CompactPalette>(keelCtx(m_nctx), palAddr));
+		OX_REQUIRE(pal, readObj<ncore::CompactPalette>(keelCtx(m_nctx), palAddr));
-		oxReturnError(ncore::loadBgPalette(m_nctx, i, *pal));
+		OX_RETURN_ERROR(ncore::loadBgPalette(m_nctx, i, *pal));
 		++i;
 	}
-	oxReturnError(ncore::loadBgTileSheet(m_nctx, 0, m_worldStatic.tilesheets));
+	OX_RETURN_ERROR(ncore::loadBgTileSheet(m_nctx, 0, m_worldStatic.tilesheets));
 	ncore::setBgStatus(m_nctx, 0); // disable all backgrounds
 	for (auto layerNo = 0u; auto const&layer : m_worldStatic.map) {
 		setupLayer(layerNo, layer.cbb);

src/jasper/player/app.cpp

@@ -23,14 +23,14 @@ ox::Error run(
 		[[maybe_unused]] ox::StringView projectDataDir,
 		ox::SpanView<ox::CString> args) noexcept {
 	auto const fsPath = args.size() > 1 ? args[1] : ".";
-	oxRequireM(tctx, turbine::init(fsPath, project));
+	OX_REQUIRE_M(tctx, turbine::init(fsPath, project));
-	oxRequire(bootfile, keel::readObj<jasper::core::Bootfile>(keelCtx(*tctx), "/Bootfile"));
+	OX_REQUIRE(bootfile, keel::readObj<jasper::core::Bootfile>(keelCtx(*tctx), "/Bootfile"));
 	oxOut("Jasper Player\n");
-	oxRequire(nctx, ncore::init(*tctx));
+	OX_REQUIRE(nctx, ncore::init(*tctx));
 	auto const&worldPath = *bootfile->args.at(0).unwrap();
-	oxRequire(worldStatic, readObj<world::WorldStatic>(keelCtx(*tctx), worldPath));
+	OX_REQUIRE(worldStatic, readObj<world::WorldStatic>(keelCtx(*tctx), worldPath));
 	world::World world(*nctx, *worldStatic);
-	oxReturnError(world.setupDisplay());
+	OX_RETURN_ERROR(world.setupDisplay());
 	turbine::setApplicationData(*tctx, &world);
 	setUpdateHandler(*tctx, [](turbine::Context &tctx) -> int {
 		auto &world = *applicationData<world::World>(tctx);
@@ -40,7 +40,7 @@ ox::Error run(
 		}
 		return 0;
 	});
-	oxReturnError(turbine::run(*tctx));
+	OX_RETURN_ERROR(turbine::run(*tctx));
 	oxOut("Exiting...\n");
 	return {};
 }