[jasper] Change macro names to comply with broader conventions

src/nostalgia/modules/core/include/nostalgia/core/gfx.hpp

@@ -32,18 +32,18 @@ struct Sprite {
 	unsigned priority = 0;
 };
 
-oxModelBegin(Sprite)
+OX_MODEL_BEGIN(Sprite)
-	oxModelField(idx)
+	OX_MODEL_FIELD(idx)
-	oxModelField(x)
+	OX_MODEL_FIELD(x)
-	oxModelField(y)
+	OX_MODEL_FIELD(y)
-	oxModelField(enabled)
+	OX_MODEL_FIELD(enabled)
-	oxModelField(tileIdx)
+	OX_MODEL_FIELD(tileIdx)
-	oxModelField(spriteShape)
+	OX_MODEL_FIELD(spriteShape)
-	oxModelField(spriteSize)
+	OX_MODEL_FIELD(spriteSize)
-	oxModelField(flipX)
+	OX_MODEL_FIELD(flipX)
-	oxModelField(bpp)
+	OX_MODEL_FIELD(bpp)
-	oxModelField(priority)
+	OX_MODEL_FIELD(priority)
-oxModelEnd()
+OX_MODEL_END()
 
 struct BgTile {
 	static constexpr auto TypeName = "net.drinkingtea.nostalgia.core.BgTile";
@@ -54,12 +54,12 @@ struct BgTile {
 	unsigned flipY = false;
 };
 
-oxModelBegin(BgTile)
+OX_MODEL_BEGIN(BgTile)
-	oxModelField(tileIdx)
+	OX_MODEL_FIELD(tileIdx)
-	oxModelField(palBank)
+	OX_MODEL_FIELD(palBank)
-	oxModelField(horizontalFlip)
+	OX_MODEL_FIELD(horizontalFlip)
-	oxModelField(verticalFlip)
+	OX_MODEL_FIELD(verticalFlip)
-oxModelEnd()
+OX_MODEL_END()
 
 struct TileSheetSetEntrySection {
 	static constexpr auto TypeName = "net.drinkingtea.nostalgia.core.TileSheetSetEntrySection";
@@ -72,10 +72,10 @@ struct TileSheetSetEntrySection {
 	}
 };
 
-oxModelBegin(TileSheetSetEntrySection)
+OX_MODEL_BEGIN(TileSheetSetEntrySection)
-	oxModelField(begin)
+	OX_MODEL_FIELD(begin)
-	oxModelField(tiles)
+	OX_MODEL_FIELD(tiles)
-oxModelEnd()
+OX_MODEL_END()
 
 struct TileSheetSetEntry {
 	static constexpr auto TypeName = "net.drinkingtea.nostalgia.core.TileSheetSetEntry";
@@ -84,10 +84,10 @@ struct TileSheetSetEntry {
 	ox::Vector<TileSheetSetEntrySection> sections;
 };
 
-oxModelBegin(TileSheetSetEntry)
+OX_MODEL_BEGIN(TileSheetSetEntry)
-	oxModelField(tilesheet)
+	OX_MODEL_FIELD(tilesheet)
-	oxModelField(sections)
+	OX_MODEL_FIELD(sections)
-oxModelEnd()
+OX_MODEL_END()
 
 struct TileSheetSet {
 	static constexpr auto TypeName = "net.drinkingtea.nostalgia.core.TileSheetSet";
@@ -97,10 +97,10 @@ struct TileSheetSet {
 	ox::Vector<TileSheetSetEntry> entries;
 };
 
-oxModelBegin(TileSheetSet)
+OX_MODEL_BEGIN(TileSheetSet)
-	oxModelField(bpp)
+	OX_MODEL_FIELD(bpp)
-	oxModelField(entries)
+	OX_MODEL_FIELD(entries)
-oxModelEnd()
+OX_MODEL_END()
 
 void addEntry(TileSheetSet &set, ox::FileAddress path, int32_t begin = 0, int32_t size = -1) noexcept;
 

src/nostalgia/modules/core/include/nostalgia/core/palette.hpp

@@ -26,12 +26,12 @@ struct PaletteColorV1 {
     constexpr operator Color16() const noexcept { return color16(r, g, b, a); }
 };
 
-oxModelBegin(PaletteColorV1)
+OX_MODEL_BEGIN(PaletteColorV1)
-	oxModelField(r)
+	OX_MODEL_FIELD(r)
-	oxModelField(g)
+	OX_MODEL_FIELD(g)
-	oxModelField(b)
+	OX_MODEL_FIELD(b)
-	oxModelField(a)
+	OX_MODEL_FIELD(a)
-oxModelEnd()
+OX_MODEL_END()
 
 using PaletteColor = PaletteColorV1;
 
@@ -53,10 +53,10 @@ struct PalettePageV1 {
     }
 };
 
-oxModelBegin(PalettePageV1)
+OX_MODEL_BEGIN(PalettePageV1)
-	oxModelField(name)
+	OX_MODEL_FIELD(name)
-	oxModelField(colors)
+	OX_MODEL_FIELD(colors)
-oxModelEnd()
+OX_MODEL_END()
 
 using PalettePage = PalettePageV1;
 
@@ -67,9 +67,9 @@ struct NostalgiaPalette {
 	ox::Vector<Color16> colors = {};
 };
 
-oxModelBegin(NostalgiaPalette)
+OX_MODEL_BEGIN(NostalgiaPalette)
-	oxModelField(colors)
+	OX_MODEL_FIELD(colors)
-oxModelEnd()
+OX_MODEL_END()
 
 
 struct PaletteV1 {
@@ -78,9 +78,9 @@ struct PaletteV1 {
 	ox::Vector<Color16> colors;
 };
 
-oxModelBegin(PaletteV1)
+OX_MODEL_BEGIN(PaletteV1)
-	oxModelField(colors)
+	OX_MODEL_FIELD(colors)
-oxModelEnd()
+OX_MODEL_END()
 
 
 struct PaletteV2 {
@@ -90,9 +90,9 @@ struct PaletteV2 {
 	ox::Vector<ox::Vector<Color16>> pages;
 };
 
-oxModelBegin(PaletteV2)
+OX_MODEL_BEGIN(PaletteV2)
-	oxModelField(pages)
+	OX_MODEL_FIELD(pages)
-oxModelEnd()
+OX_MODEL_END()
 
 
 struct PaletteV3 {
@@ -110,14 +110,14 @@ struct PaletteV3 {
 	ox::Vector<ox::Vector<Color16>> pages;
 };
 
-oxModelBegin(PaletteV3::ColorInfo)
+OX_MODEL_BEGIN(PaletteV3::ColorInfo)
-	oxModelField(name)
+	OX_MODEL_FIELD(name)
-oxModelEnd()
+OX_MODEL_END()
 
-oxModelBegin(PaletteV3)
+OX_MODEL_BEGIN(PaletteV3)
-	oxModelField(colorInfo)
+	OX_MODEL_FIELD(colorInfo)
-	oxModelField(pages)
+	OX_MODEL_FIELD(pages)
-oxModelEnd()
+OX_MODEL_END()
 
 [[nodiscard]]
 constexpr bool valid(PaletteV3 const&p) noexcept {
@@ -144,10 +144,10 @@ struct PaletteV4 {
 	ox::Vector<PalettePageV1> pages;
 };
 
-oxModelBegin(PaletteV4)
+OX_MODEL_BEGIN(PaletteV4)
-	oxModelField(colorNames)
+	OX_MODEL_FIELD(colorNames)
-	oxModelField(pages)
+	OX_MODEL_FIELD(pages)
-oxModelEnd()
+OX_MODEL_END()
 
 [[nodiscard]]
 constexpr bool valid(PaletteV4 const&p) noexcept {
@@ -176,9 +176,9 @@ struct CompactPaletteV1 {
 	ox::Vector<ox::Vector<Color16>> pages{};
 };
 
-oxModelBegin(CompactPaletteV1)
+OX_MODEL_BEGIN(CompactPaletteV1)
-	oxModelField(pages)
+	OX_MODEL_FIELD(pages)
-oxModelEnd()
+OX_MODEL_END()
 
 [[nodiscard]]
 constexpr bool valid(CompactPaletteV1 const&p) noexcept {

src/nostalgia/modules/core/include/nostalgia/core/tilesheet.hpp

@@ -437,65 +437,65 @@ ox::Pair<uint8_t> get2Pixels8Bpp(
 		CompactTileSheet const&ts,
 		size_t idx) noexcept;
 
-oxModelBegin(TileSheetV1)
+OX_MODEL_BEGIN(TileSheetV1)
-	oxModelField(bpp)
+	OX_MODEL_FIELD(bpp)
-	oxModelField(rows)
+	OX_MODEL_FIELD(rows)
-	oxModelField(columns)
+	OX_MODEL_FIELD(columns)
-	oxModelField(defaultPalette)
+	OX_MODEL_FIELD(defaultPalette)
-	oxModelField(pal)
+	OX_MODEL_FIELD(pal)
-	oxModelField(pixels)
+	OX_MODEL_FIELD(pixels)
-oxModelEnd()
+OX_MODEL_END()
 
-oxModelBegin(TileSheetV2::SubSheet)
+OX_MODEL_BEGIN(TileSheetV2::SubSheet)
-	oxModelField(name)
+	OX_MODEL_FIELD(name)
-	oxModelField(rows)
+	OX_MODEL_FIELD(rows)
-	oxModelField(columns)
+	OX_MODEL_FIELD(columns)
-	oxModelField(subsheets)
+	OX_MODEL_FIELD(subsheets)
-	oxModelField(pixels)
+	OX_MODEL_FIELD(pixels)
-oxModelEnd()
+OX_MODEL_END()
 
-oxModelBegin(TileSheetV2)
+OX_MODEL_BEGIN(TileSheetV2)
-	oxModelField(bpp)
+	OX_MODEL_FIELD(bpp)
-	oxModelField(defaultPalette)
+	OX_MODEL_FIELD(defaultPalette)
-	oxModelField(subsheet)
+	OX_MODEL_FIELD(subsheet)
-oxModelEnd()
+OX_MODEL_END()
 
-oxModelBegin(TileSheetV3::SubSheet)
+OX_MODEL_BEGIN(TileSheetV3::SubSheet)
-	oxModelField(name)
+	OX_MODEL_FIELD(name)
-	oxModelField(rows)
+	OX_MODEL_FIELD(rows)
-	oxModelField(columns)
+	OX_MODEL_FIELD(columns)
-	oxModelField(subsheets)
+	OX_MODEL_FIELD(subsheets)
-	oxModelField(pixels)
+	OX_MODEL_FIELD(pixels)
-oxModelEnd()
+OX_MODEL_END()
 
-oxModelBegin(TileSheetV3)
+OX_MODEL_BEGIN(TileSheetV3)
-	oxModelField(bpp)
+	OX_MODEL_FIELD(bpp)
-	oxModelField(idIt)
+	OX_MODEL_FIELD(idIt)
-	oxModelField(defaultPalette)
+	OX_MODEL_FIELD(defaultPalette)
-	oxModelField(subsheet)
+	OX_MODEL_FIELD(subsheet)
-oxModelEnd()
+OX_MODEL_END()
 
-oxModelBegin(TileSheetV4::SubSheet)
+OX_MODEL_BEGIN(TileSheetV4::SubSheet)
-	oxModelField(id)
+	OX_MODEL_FIELD(id)
-	oxModelField(name)
+	OX_MODEL_FIELD(name)
-	oxModelField(rows)
+	OX_MODEL_FIELD(rows)
-	oxModelField(columns)
+	OX_MODEL_FIELD(columns)
-	oxModelField(subsheets)
+	OX_MODEL_FIELD(subsheets)
-	oxModelField(pixels)
+	OX_MODEL_FIELD(pixels)
-oxModelEnd()
+OX_MODEL_END()
 
-oxModelBegin(TileSheetV4)
+OX_MODEL_BEGIN(TileSheetV4)
-	oxModelField(bpp)
+	OX_MODEL_FIELD(bpp)
-	oxModelField(idIt)
+	OX_MODEL_FIELD(idIt)
-	oxModelField(defaultPalette)
+	OX_MODEL_FIELD(defaultPalette)
-	oxModelField(subsheet)
+	OX_MODEL_FIELD(subsheet)
-oxModelEnd()
+OX_MODEL_END()
 
-oxModelBegin(CompactTileSheetV1)
+OX_MODEL_BEGIN(CompactTileSheetV1)
-	oxModelField(bpp)
+	OX_MODEL_FIELD(bpp)
-	oxModelField(defaultPalette)
+	OX_MODEL_FIELD(defaultPalette)
-	oxModelField(pixels)
+	OX_MODEL_FIELD(pixels)
-oxModelEnd()
+OX_MODEL_END()
 
 ox::Vector<uint32_t> resizeTileSheetData(
 		ox::Vector<uint32_t> const&srcPixels,

src/nostalgia/modules/core/src/gba/context.cpp

@@ -21,7 +21,7 @@ ox::Error initGfx(Context &ctx, InitParams const&) noexcept;
 
 ox::Result<ContextUPtr> init(turbine::Context &tctx, InitParams const&params) noexcept {
 	auto ctx = ox::make_unique<Context>(tctx);
-	oxReturnError(initGfx(*ctx, params));
+	OX_RETURN_ERROR(initGfx(*ctx, params));
 	return ContextUPtr(std::move(ctx));
 }
 

src/nostalgia/modules/core/src/gba/gfx.cpp

@@ -70,7 +70,7 @@ static ox::Error loadTileSheetSet(
 	size_t tileWriteIdx = 0;
 	size_t const bppMod = set.bpp == 4;
 	for (auto const&entry : set.entries) {
-		oxRequire(ts, keel::readObj<CompactTileSheet>(keelCtx(ctx), entry.tilesheet));
+		OX_REQUIRE(ts, keel::readObj<CompactTileSheet>(keelCtx(ctx), entry.tilesheet));
 		if (set.bpp != ts->bpp && ts->bpp == 8) {
 			return ox::Error(1, "cannot load an 8 BPP tilesheet into a 4 BPP CBB");
 		}
@@ -138,7 +138,7 @@ ox::Error loadBgTileSheet(
 		}
 	});
 	if (paletteBank.has_value() && ts.defaultPalette) {
-		oxReturnError(loadBgPalette(ctx, *paletteBank, ts.defaultPalette));
+		OX_RETURN_ERROR(loadBgPalette(ctx, *paletteBank, ts.defaultPalette));
 	}
 	return {};
 }
@@ -148,7 +148,7 @@ ox::Error loadBgTileSheet(
 		unsigned const cbb,
 		TileSheetSet const&set) noexcept {
 	auto const bpp = static_cast<unsigned>(set.bpp);
-	oxReturnError(loadTileSheetSet(ctx, MEM_BG_TILES[cbb], set));
+	OX_RETURN_ERROR(loadTileSheetSet(ctx, MEM_BG_TILES[cbb], set));
 	// update bpp of all bgs with the updated cbb
 	ctx.cbbData[cbb].bpp = bpp;
 	teagba::iterateBgCtl([bpp, cbb](volatile BgCtl &bgCtl) {
@@ -178,7 +178,7 @@ ox::Error loadSpriteTileSheet(
 		MEM_SPRITE_TILES[i] = v;
 	}
 	if (loadDefaultPalette && ts.defaultPalette) {
-		oxReturnError(loadSpritePalette(ctx, ts.defaultPalette));
+		OX_RETURN_ERROR(loadSpritePalette(ctx, ts.defaultPalette));
 	}
 	setSpritesBpp(static_cast<unsigned>(ts.bpp));
 	return {};
@@ -188,7 +188,7 @@ ox::Error loadSpriteTileSheet(
 		Context &ctx,
 		TileSheetSet const&set) noexcept {
 	auto const bpp = static_cast<unsigned>(set.bpp);
-	oxReturnError(loadTileSheetSet(ctx, {MEM_SPRITE_TILES, 32 * ox::units::KB}, set));
+	OX_RETURN_ERROR(loadTileSheetSet(ctx, {MEM_SPRITE_TILES, 32 * ox::units::KB}, set));
 	setSpritesBpp(bpp);
 	return {};
 }

src/nostalgia/modules/core/src/gfx.cpp

@@ -22,7 +22,7 @@ ox::Error loadBgPalette(
 		Context &ctx,
 		size_t palBank,
 		ox::StringViewCR palettePath) noexcept {
-	oxRequire(pal, keel::readObj<CompactPalette>(keelCtx(ctx), palettePath));
+	OX_REQUIRE(pal, keel::readObj<CompactPalette>(keelCtx(ctx), palettePath));
 	return loadBgPalette(ctx, palBank, *pal, 0);
 }
 
@@ -30,21 +30,21 @@ ox::Error loadBgPalette(
 		Context &ctx,
 		size_t palBank,
 		ox::FileAddress const&paletteAddr) noexcept {
-	oxRequire(pal, keel::readObj<CompactPalette>(keelCtx(ctx), paletteAddr));
+	OX_REQUIRE(pal, keel::readObj<CompactPalette>(keelCtx(ctx), paletteAddr));
 	return loadBgPalette(ctx, palBank, *pal, 0);
 }
 
 ox::Error loadSpritePalette(
 		Context &ctx,
 		ox::StringViewCR palettePath) noexcept {
-	oxRequire(pal, keel::readObj<CompactPalette>(keelCtx(ctx), palettePath));
+	OX_REQUIRE(pal, keel::readObj<CompactPalette>(keelCtx(ctx), palettePath));
 	return loadSpritePalette(ctx, *pal, 0);
 }
 
 ox::Error loadSpritePalette(
 		Context &ctx,
 		ox::FileAddress const&paletteAddr) noexcept {
-	oxRequire(pal, keel::readObj<CompactPalette>(keelCtx(ctx), paletteAddr));
+	OX_REQUIRE(pal, keel::readObj<CompactPalette>(keelCtx(ctx), paletteAddr));
 	return loadSpritePalette(ctx, *pal, 0);
 }
 
@@ -55,7 +55,7 @@ ox::Error loadBgTileSheet(
 		size_t dstTileIdx,
 		size_t srcTileIdx,
 		size_t tileCnt) noexcept {
-	oxRequire(ts, keel::readObj<CompactTileSheet>(keelCtx(ctx), tsAddr));
+	OX_REQUIRE(ts, keel::readObj<CompactTileSheet>(keelCtx(ctx), tsAddr));
 	return loadBgTileSheet(ctx, cbb, *ts, dstTileIdx, srcTileIdx, tileCnt);
 }
 
@@ -66,7 +66,7 @@ ox::Error loadBgTileSheet(
 		size_t dstTileIdx,
 		size_t srcTileIdx,
 		size_t tileCnt) noexcept {
-	oxRequire(ts, keel::readObj<CompactTileSheet>(keelCtx(ctx), tsPath));
+	OX_REQUIRE(ts, keel::readObj<CompactTileSheet>(keelCtx(ctx), tsPath));
 	return loadBgTileSheet(ctx, cbb, *ts, dstTileIdx, srcTileIdx, tileCnt);
 }
 
@@ -75,7 +75,7 @@ ox::Error loadBgTileSheet(
 		unsigned cbb,
 		ox::StringViewCR tilesheetPath,
 		ox::Optional<unsigned> const&paletteBank) noexcept {
-	oxRequire(ts, keel::readObj<CompactTileSheet>(keelCtx(ctx), tilesheetPath));
+	OX_REQUIRE(ts, keel::readObj<CompactTileSheet>(keelCtx(ctx), tilesheetPath));
 	return loadBgTileSheet(ctx, cbb, *ts, paletteBank);
 }
 
@@ -84,7 +84,7 @@ ox::Error loadBgTileSheet(
 		unsigned cbb,
 		ox::FileAddress const&tilesheetAddr,
 		ox::Optional<unsigned> const&paletteBank) noexcept {
-	oxRequire(ts, keel::readObj<CompactTileSheet>(keelCtx(ctx), tilesheetAddr));
+	OX_REQUIRE(ts, keel::readObj<CompactTileSheet>(keelCtx(ctx), tilesheetAddr));
 	return loadBgTileSheet(ctx, cbb, *ts, paletteBank);
 }
 
@@ -92,7 +92,7 @@ ox::Error loadSpriteTileSheet(
 		Context &ctx,
 		ox::StringViewCR tilesheetPath,
 		bool loadDefaultPalette) noexcept {
-	oxRequire(ts, readObj<CompactTileSheet>(keelCtx(ctx), tilesheetPath));
+	OX_REQUIRE(ts, readObj<CompactTileSheet>(keelCtx(ctx), tilesheetPath));
 	return loadSpriteTileSheet(ctx, *ts, loadDefaultPalette);
 }
 
@@ -100,7 +100,7 @@ ox::Error loadSpriteTileSheet(
 		Context &ctx,
 		ox::FileAddress const&tilesheetAddr,
 		bool loadDefaultPalette) noexcept {
-	oxRequire(ts, readObj<CompactTileSheet>(keelCtx(ctx), tilesheetAddr));
+	OX_REQUIRE(ts, readObj<CompactTileSheet>(keelCtx(ctx), tilesheetAddr));
 	return loadSpriteTileSheet(ctx, *ts, loadDefaultPalette);
 }
 
@@ -247,7 +247,7 @@ ox::Error initConsole(Context &ctx) noexcept {
 	constexpr ox::FileAddress PaletteAddr = ox::StringLiteral("/Palettes/Charset.npal");
 	setBgStatus(ctx, 0b0001);
 	setBgCbb(ctx, 0, 0);
-	oxReturnError(loadBgTileSheet(ctx, 0, TilesheetAddr));
+	OX_RETURN_ERROR(loadBgTileSheet(ctx, 0, TilesheetAddr));
 	return loadBgPalette(ctx, 0, PaletteAddr);
 }
 

src/nostalgia/modules/core/src/keel/keelmodule.cpp

@@ -72,7 +72,7 @@ static class: public keel::Module {
 					    typeId == ox::ModelTypeId_v<TileSheetV2> ||
 					    typeId == ox::ModelTypeId_v<TileSheetV3> ||
 					    typeId == ox::ModelTypeId_v<TileSheetV4>) {
-						oxReturnError(keel::convertBuffToBuff<CompactTileSheet>(
+						OX_RETURN_ERROR(keel::convertBuffToBuff<CompactTileSheet>(
 								ctx, buff, ox::ClawFormat::Metal).moveTo(buff));
 						return true;
 					}
@@ -84,7 +84,7 @@ static class: public keel::Module {
 					    typeId == ox::ModelTypeId_v<PaletteV2> ||
 					    typeId == ox::ModelTypeId_v<PaletteV3> ||
 					    typeId == ox::ModelTypeId_v<PaletteV4>) {
-						oxReturnError(keel::convertBuffToBuff<CompactPalette>(
+						OX_RETURN_ERROR(keel::convertBuffToBuff<CompactPalette>(
 								ctx, buff, ox::ClawFormat::Metal).moveTo(buff));
 						return true;
 					}

src/nostalgia/modules/core/src/opengl/context.cpp

@@ -25,7 +25,7 @@ Context::~Context() noexcept {
 
 ox::Result<ContextUPtr> init(turbine::Context &tctx, InitParams const&params) noexcept {
 	auto ctx = ox::make_unique<Context>(tctx, params);
-	oxReturnError(initGfx(*ctx, params));
+	OX_RETURN_ERROR(initGfx(*ctx, params));
 	return ContextUPtr(ctx.release());
 }
 

src/nostalgia/modules/core/src/opengl/gfx.cpp

@@ -464,8 +464,8 @@ ox::Error initGfx(
 	const auto bgFshad = ox::sfmt(renderer::bgfshadTmpl, gl::GlslVersion);
 	const auto spriteVshad = ox::sfmt(renderer::spritevshadTmpl, gl::GlslVersion);
 	const auto spriteFshad = ox::sfmt(renderer::spritefshadTmpl, gl::GlslVersion);
-	oxReturnError(glutils::buildShaderProgram(bgVshad, bgFshad).moveTo(ctx.bgShader));
+	OX_RETURN_ERROR(glutils::buildShaderProgram(bgVshad, bgFshad).moveTo(ctx.bgShader));
-	oxReturnError(
+	OX_RETURN_ERROR(
 			glutils::buildShaderProgram(spriteVshad, spriteFshad).moveTo(ctx.spriteShader));
 	for (auto &cbb : ctx.cbbs) {
 		initBackgroundBufferset(ctx.bgShader, cbb);
@@ -538,8 +538,8 @@ static ox::Result<TileSheetData> buildSetTsd(
 	TileSheetData setTsd;
 	setTsd.width = TileWidth;
 	for (auto const&entry : set.entries) {
-		oxRequire(tilesheet, readObj<CompactTileSheet>(kctx, entry.tilesheet));
+		OX_REQUIRE(tilesheet, readObj<CompactTileSheet>(kctx, entry.tilesheet));
-		oxRequire(tsd, normalizeTileSheet(*tilesheet));
+		OX_REQUIRE(tsd, normalizeTileSheet(*tilesheet));
 		for (auto const&s : entry.sections) {
 			auto const size = s.tiles * PixelsPerTile;
 			for (auto i = 0; i < size; ++i) {
@@ -604,9 +604,9 @@ ox::Error loadBgTileSheet(
 		ox::Optional<unsigned> const&paletteBank) noexcept {
 	auto const bytesPerTile = static_cast<uint64_t>(PixelsPerTile / (1 + (ts.bpp == 4)));
 	auto const tiles = ts.pixels.size() / bytesPerTile;
-	oxReturnError(loadBgTileSheet(ctx, cbb, ts, 0, 0, tiles));
+	OX_RETURN_ERROR(loadBgTileSheet(ctx, cbb, ts, 0, 0, tiles));
 	if (paletteBank.has_value() && ts.defaultPalette) {
-		oxReturnError(loadBgPalette(ctx, *paletteBank, ts.defaultPalette));
+		OX_RETURN_ERROR(loadBgPalette(ctx, *paletteBank, ts.defaultPalette));
 	}
 	return {};
 }
@@ -615,7 +615,7 @@ ox::Error loadBgTileSheet(
 		Context &ctx,
 		unsigned cbb,
 		TileSheetSet const&set) noexcept {
-	oxRequire(setTsd, buildSetTsd(ctx, set));
+	OX_REQUIRE(setTsd, buildSetTsd(ctx, set));
 	ctx.cbbs[cbb].tex = renderer::createTexture(setTsd.width, setTsd.height, setTsd.pixels.data());
 	return {};
 }
@@ -624,11 +624,11 @@ ox::Error loadSpriteTileSheet(
 		Context &ctx,
 		CompactTileSheet const&ts,
 		bool loadDefaultPalette) noexcept {
-	oxRequire(tsd, normalizeTileSheet(ts));
+	OX_REQUIRE(tsd, normalizeTileSheet(ts));
 	oxTracef("nostalgia.core.gfx.gl", "loadSpriteTexture: { w: {}, h: {} }", tsd.width, tsd.height);
 	ctx.spriteBlocks.tex = renderer::createTexture(tsd.width, tsd.height, tsd.pixels.data());
 	if (loadDefaultPalette) {
-		oxReturnError(loadSpritePalette(ctx, ts.defaultPalette));
+		OX_RETURN_ERROR(loadSpritePalette(ctx, ts.defaultPalette));
 	}
 	return {};
 }
@@ -636,7 +636,7 @@ ox::Error loadSpriteTileSheet(
 ox::Error loadSpriteTileSheet(
 		Context &ctx,
 		TileSheetSet const&set) noexcept {
-	oxRequire(setTsd, buildSetTsd(ctx, set));
+	OX_REQUIRE(setTsd, buildSetTsd(ctx, set));
 	ctx.spriteBlocks.tex = renderer::createTexture(setTsd.width, setTsd.height, setTsd.pixels.data());
 	return {};
 }

src/nostalgia/modules/core/src/studio/paletteeditor/commands/addcolorcommand.cpp

@@ -25,9 +25,9 @@ ox::Error AddColorCommand::redo() noexcept {
 }
 
 ox::Error AddColorCommand::undo() noexcept {
-	oxReturnError(m_pal.colorNames.erase(m_idx));
+	OX_RETURN_ERROR(m_pal.colorNames.erase(m_idx));
 	for (auto &page : m_pal.pages) {
-		oxReturnError(page.colors.erase(m_idx));
+		OX_RETURN_ERROR(page.colors.erase(m_idx));
 	}
 	return {};
 }

src/nostalgia/modules/core/src/studio/paletteeditor/commands/removecolorcommand.cpp

@@ -25,9 +25,9 @@ int RemoveColorCommand::commandId() const noexcept {
 
 ox::Error RemoveColorCommand::redo() noexcept {
 	m_colorInfo = std::move(m_pal.colorNames[m_idx]);
-	oxReturnError(m_pal.colorNames.erase(m_idx));
+	OX_RETURN_ERROR(m_pal.colorNames.erase(m_idx));
 	for (auto &page : m_pal.pages) {
-		oxReturnError(page.colors.erase(m_idx));
+		OX_RETURN_ERROR(page.colors.erase(m_idx));
 	}
 	return {};
 }

src/nostalgia/modules/core/src/studio/tilesheeteditor/commands/addsubsheetcommand.cpp

@@ -49,7 +49,7 @@ ox::Error AddSubSheetCommand::undo() noexcept {
 		--m_img.idIt;
 	} else {
 		for (auto idx = m_addedSheets.rbegin(); idx != m_addedSheets.rend(); ++idx) {
-			oxReturnError(rmSubSheet(m_img, *idx));
+			OX_RETURN_ERROR(rmSubSheet(m_img, *idx));
 			--m_img.idIt;
 		}
 	}

src/nostalgia/modules/core/src/studio/tilesheeteditor/commands/cutpastecommand.hpp

@@ -10,14 +10,14 @@
 
 namespace nostalgia::core {
 
-oxModelFwdDecl(class TileSheetClipboard);
+OX_MODEL_FWD_DECL(class TileSheetClipboard);
 
 class TileSheetClipboard: public turbine::ClipboardObject<TileSheetClipboard> {
 	public:
 		static constexpr auto TypeName = "net.drinkingtea.nostalgia.core.studio.TileSheetClipboard";
 		static constexpr auto TypeVersion = 1;
 
-		oxModelFriend(TileSheetClipboard);
+		OX_MODEL_FRIEND(TileSheetClipboard);
 
 		struct Pixel {
 			static constexpr auto TypeName = "net.drinkingtea.nostalgia.core.studio.TileSheetClipboard.Pixel";
@@ -36,14 +36,14 @@ class TileSheetClipboard: public turbine::ClipboardObject<TileSheetClipboard> {
 		ox::Vector<Pixel> const&pixels() const noexcept;
 };
 
-oxModelBegin(TileSheetClipboard::Pixel)
+OX_MODEL_BEGIN(TileSheetClipboard::Pixel)
-	oxModelField(colorIdx)
+	OX_MODEL_FIELD(colorIdx)
-	oxModelField(pt)
+	OX_MODEL_FIELD(pt)
-oxModelEnd()
+OX_MODEL_END()
 
-oxModelBegin(TileSheetClipboard)
+OX_MODEL_BEGIN(TileSheetClipboard)
-	oxModelFieldRename(m_pixels, pixels)
+	OX_MODEL_FIELD_RENAME(m_pixels, pixels)
-oxModelEnd()
+OX_MODEL_END()
 
 class CutPasteCommand: public TileSheetCommand {
 	private:

src/nostalgia/modules/core/src/studio/tilesheeteditor/commands/rmsubsheetcommand.cpp

@@ -16,7 +16,7 @@ core::RmSubSheetCommand::RmSubSheetCommand(TileSheet &img, TileSheet::SubSheetId
 ox::Error RmSubSheetCommand::redo() noexcept {
 	auto &parent = getSubSheet(m_img, m_parentIdx);
 	m_sheet = std::move(parent.subsheets[*m_idx.back().value]);
-	oxReturnError(parent.subsheets.erase(*m_idx.back().value).error);
+	OX_RETURN_ERROR(parent.subsheets.erase(*m_idx.back().value).error);
 	return {};
 }
 

src/nostalgia/modules/core/src/studio/tilesheeteditor/tilesheeteditor-imgui.cpp

@@ -21,9 +21,9 @@ struct TileSheetEditorConfig {
 	TileSheet::SubSheetIdx activeSubsheet{};
 };
 
-oxModelBegin(TileSheetEditorConfig)
+OX_MODEL_BEGIN(TileSheetEditorConfig)
-	oxModelFieldRename(activeSubsheet, active_subsheet)
+	OX_MODEL_FIELD_RENAME(activeSubsheet, active_subsheet)
-oxModelEnd()
+OX_MODEL_END()
 
 static ox::Vector<uint32_t> normalizePixelSizes(
 		ox::Vector<uint8_t> const&inPixels,
@@ -346,7 +346,7 @@ void TileSheetEditorImGui::showSubsheetEditor() noexcept {
 }
 
 ox::Error TileSheetEditorImGui::exportSubhseetToPng(int const scale) const noexcept {
-	oxRequire(path, studio::saveFile({{"PNG", "png"}}));
+	OX_REQUIRE(path, studio::saveFile({{"PNG", "png"}}));
 	// subsheet to png
 	auto const&img = m_model.img();
 	auto const&s = m_model.activeSubSheet();

src/nostalgia/modules/core/src/studio/tilesheeteditor/tilesheeteditormodel.cpp

@@ -132,7 +132,7 @@ ox::StringView TileSheetEditorModel::palPath() const noexcept {
 }
 
 ox::Error TileSheetEditorModel::setPalette(ox::StringView path) noexcept {
-	oxRequire(uuid, keelCtx(m_tctx).pathToUuid.at(path));
+	OX_REQUIRE(uuid, keelCtx(m_tctx).pathToUuid.at(path));
 	pushCommand(ox::make<PaletteChangeCommand>(activeSubSheetIdx(), m_img, uuid->toString()));
 	return {};
 }
@@ -250,7 +250,7 @@ ox::Error TileSheetEditorModel::markUpdatedCmdId(studio::UndoCommand const*cmd)
 	m_updated = true;
 	const auto cmdId = cmd->commandId();
 	if (static_cast<CommandId>(cmdId) == CommandId::PaletteChange) {
-		oxReturnError(readObj<Palette>(keelCtx(m_tctx), m_img.defaultPalette).moveTo(m_pal));
+		OX_RETURN_ERROR(readObj<Palette>(keelCtx(m_tctx), m_img.defaultPalette).moveTo(m_pal));
 		m_palettePage = ox::min<size_t>(m_pal->pages.size(), 0);
 		paletteChanged.emit();
 	}

src/nostalgia/modules/core/src/studio/tilesheeteditor/tilesheeteditorview.cpp

@@ -16,8 +16,8 @@ TileSheetEditorView::TileSheetEditorView(studio::StudioContext &sctx, ox::String
 	m_pixelsDrawer(m_model) {
 	glBindVertexArray(0);
 	// build shaders
-	oxThrowError(m_pixelsDrawer.buildShader());
+	OX_THROW_ERROR(m_pixelsDrawer.buildShader());
-	oxThrowError(m_pixelGridDrawer.buildShader());
+	OX_THROW_ERROR(m_pixelGridDrawer.buildShader());
 	m_model.activeSubsheetChanged.connect(this, &TileSheetEditorView::setActiveSubsheet);
 }
 

src/nostalgia/modules/core/src/tilesheet.cpp

@@ -162,7 +162,7 @@ unsigned pixelCnt(TileSheet::SubSheet const&ss, int8_t pBpp) noexcept {
 
 ox::Error resizeSubsheet(TileSheet::SubSheet &ss, int8_t pBpp, ox::Size const&sz) noexcept {
 	ox::Vector<uint8_t> out;
-	oxReturnError(setPixelCount(out, pBpp, static_cast<size_t>(sz.width * sz.height) * PixelsPerTile));
+	OX_RETURN_ERROR(setPixelCount(out, pBpp, static_cast<size_t>(sz.width * sz.height) * PixelsPerTile));
 	auto const w = ox::min<int32_t>(ss.columns, sz.width) * TileWidth;
 	auto const h = ox::min<int32_t>(ss.rows, sz.height) * TileHeight;
 	for (auto x = 0; x < w; ++x) {

src/nostalgia/modules/core/test/tests.cpp

@@ -16,8 +16,8 @@ static std::map<ox::StringView, ox::Error(*)()> tests = {
 		"readWriteTileSheet",
 		[]() -> ox::Error {
 			core::TileSheet in;
-			oxRequire(buff, ox::writeMC(in));
+			OX_REQUIRE(buff, ox::writeMC(in));
-			oxRequire(out, ox::readMC<core::TileSheet>(buff));
+			OX_REQUIRE(out, ox::readMC<core::TileSheet>(buff));
 			oxAssert(in.subsheet.name == out.subsheet.name, "subsheet.name serialization broken");
 			return {};
 		}

src/nostalgia/modules/scene/include/nostalgia/scene/scenestatic.hpp

@@ -57,12 +57,12 @@ struct TileDoc {
 
 };
 
-oxModelBegin(TileDoc)
+OX_MODEL_BEGIN(TileDoc)
-	oxModelFieldRename(subsheetId, subsheet_id)
+	OX_MODEL_FIELD_RENAME(subsheetId, subsheet_id)
-	oxModelFieldRename(subsheetPath, subsheet_path)
+	OX_MODEL_FIELD_RENAME(subsheetPath, subsheet_path)
-	oxModelField(type)
+	OX_MODEL_FIELD(type)
-	oxModelFieldRename(layerAttachments, layer_attachments)
+	OX_MODEL_FIELD_RENAME(layerAttachments, layer_attachments)
-oxModelEnd()
+OX_MODEL_END()
 
 struct SceneDoc {
 
@@ -95,11 +95,11 @@ struct SceneDoc {
 	}
 };
 
-oxModelBegin(SceneDoc)
+OX_MODEL_BEGIN(SceneDoc)
-	oxModelField(tilesheet)
+	OX_MODEL_FIELD(tilesheet)
-	oxModelField(palettes)
+	OX_MODEL_FIELD(palettes)
-	oxModelField(tiles)
+	OX_MODEL_FIELD(tiles)
-oxModelEnd()
+OX_MODEL_END()
 
 
 constexpr void setTopEdge(uint8_t &layerAttachments, unsigned val) noexcept {
@@ -215,14 +215,14 @@ struct SceneStatic {
 
 };
 
-oxModelBegin(SceneStatic)
+OX_MODEL_BEGIN(SceneStatic)
-	oxModelField(tilesheet)
+	OX_MODEL_FIELD(tilesheet)
-	oxModelField(palettes)
+	OX_MODEL_FIELD(palettes)
-	oxModelField(columns)
+	OX_MODEL_FIELD(columns)
-	oxModelField(rows)
+	OX_MODEL_FIELD(rows)
-	oxModelField(tileMapIdx)
+	OX_MODEL_FIELD(tileMapIdx)
-	oxModelField(tileType)
+	OX_MODEL_FIELD(tileType)
-	oxModelField(layerAttachments)
+	OX_MODEL_FIELD(layerAttachments)
-oxModelEnd()
+OX_MODEL_END()
 
 }

src/nostalgia/modules/scene/src/keel/typeconv.cpp

@@ -37,7 +37,7 @@ ox::Error SceneDocToSceneStaticConverter::convert(
 		keel::Context &ctx,
 		SceneDoc &src,
 		SceneStatic &dst) const noexcept {
-	oxRequire(ts, keel::readObj<core::TileSheet>(ctx, src.tilesheet));
+	OX_REQUIRE(ts, keel::readObj<core::TileSheet>(ctx, src.tilesheet));
 	const auto layerCnt = src.tiles.size();
 	dst.setLayerCnt(layerCnt);
 	dst.tilesheet = ox::FileAddress(src.tilesheet);
@@ -53,8 +53,8 @@ ox::Error SceneDocToSceneStaticConverter::convert(
 			for (const auto &srcTile : row) {
 				auto dstTile = dstLayer.tile(tileIdx);
 				dstTile.tileType = srcTile.type;
-				oxRequire(path, srcTile.getSubsheetPath(*ts));
+				OX_REQUIRE(path, srcTile.getSubsheetPath(*ts));
-				oxRequire(mapIdx, getTileOffset(*ts, path));
+				OX_REQUIRE(mapIdx, getTileOffset(*ts, path));
 				dstTile.tileMapIdx = static_cast<uint16_t>(mapIdx);
 				setLayerAttachments(layerIdx, srcTile, dstTile);
 				++tileIdx;

src/nostalgia/modules/scene/src/scene.cpp

@@ -17,8 +17,8 @@ ox::Error Scene::setupDisplay(core::Context &ctx) const noexcept {
 		return ox::Error(1, "Scene has no palettes");
 	}
 	auto const&palette = m_sceneStatic.palettes[0];
-	oxReturnError(core::loadBgTileSheet(ctx, 0, m_sceneStatic.tilesheet));
+	OX_RETURN_ERROR(core::loadBgTileSheet(ctx, 0, m_sceneStatic.tilesheet));
-	oxReturnError(core::loadBgPalette(ctx, 0, palette));
+	OX_RETURN_ERROR(core::loadBgPalette(ctx, 0, palette));
 	// disable all backgrounds
 	core::setBgStatus(ctx, 0);
 	for (auto layerNo = 0u; auto const&layer : m_sceneStatic.tileMapIdx) {

src/nostalgia/modules/scene/src/studio/sceneeditor-imgui.cpp

@@ -48,7 +48,7 @@ void SceneEditorImGui::onActivated() noexcept {
 
 ox::Error SceneEditorImGui::saveItem() noexcept {
 	const auto sctx = applicationData<studio::StudioContext>(m_ctx);
-	oxReturnError(sctx->project->writeObj(itemPath(), m_editor.scene()));
+	OX_RETURN_ERROR(sctx->project->writeObj(itemPath(), m_editor.scene()));
 	return {};
 }
 

src/olympic/keel/include/keel/asset.hpp

@@ -16,8 +16,8 @@ constexpr auto K1HdrSz = 40;
 ox::Result<ox::UUID> readUuidHeader(ox::BufferView buff) noexcept;
 
 ox::Error writeUuidHeader(ox::Writer_c auto &writer, ox::UUID const&uuid) noexcept {
-	oxReturnError(write(writer, "K1;"));
+	OX_RETURN_ERROR(write(writer, "K1;"));
-	oxReturnError(uuid.toString(writer));
+	OX_RETURN_ERROR(uuid.toString(writer));
 	return writer.put(';');
 }
 
@@ -29,8 +29,8 @@ ox::Result<T> readAsset(ox::BufferView buff) noexcept {
 		offset = K1HdrSz; // the size of K1 headers
 	}
 	auto out = ox::readClaw<T>(buff + offset);
-	oxReturnError(out);
+	OX_RETURN_ERROR(out);
-	oxReturnError(ensureValid(out.value));
+	OX_RETURN_ERROR(ensureValid(out.value));
 	return out;
 }
 

src/olympic/keel/include/keel/assetmanager.hpp

@@ -205,7 +205,7 @@ class AssetManager {
 				AssetTypeManager(Loader loader) noexcept: m_loader(loader) {}
 
 				ox::Result<AssetRef<T>> getAsset(ox::StringView const assetId) const noexcept {
-					oxRequire(out, m_cache.at(assetId));
+					OX_REQUIRE(out, m_cache.at(assetId));
 					if (!out || !*out) {
 						return ox::Error(1, "asset is null");
 					}
@@ -214,7 +214,7 @@ class AssetManager {
 
 				ox::Result<AssetRef<T>> loadAsset(ox::StringView const assetId) noexcept {
 					auto &p = m_cache[assetId];
-					oxRequireM(obj, m_loader(assetId));
+					OX_REQUIRE_M(obj, m_loader(assetId));
 					if (!p) {
 						p = ox::make_unique<AssetContainer<T>>(std::move(obj));
 					} else {
@@ -226,7 +226,7 @@ class AssetManager {
 
 				ox::Error reloadAsset(ox::StringView const assetId) noexcept {
 					auto &p = m_cache[assetId];
-					oxRequireM(obj, m_loader(assetId));
+					OX_REQUIRE_M(obj, m_loader(assetId));
 					if (!p) {
 						p = ox::make_unique<AssetContainer<T>>(std::move(obj));
 					} else {
@@ -274,7 +274,7 @@ class AssetManager {
 
 		template<typename T>
 		ox::Result<AssetRef<T>> getAsset(ox::StringView assetId) noexcept {
-			oxRequire(m, getTypeManager<T>());
+			OX_REQUIRE(m, getTypeManager<T>());
 			return m->getAsset(assetId);
 		}
 
@@ -285,8 +285,8 @@ class AssetManager {
 
 		template<typename T>
 		ox::Result<AssetRef<T>> loadAsset(ox::StringView assetId) noexcept {
-			oxRequire(m, getTypeManager<T>());
+			OX_REQUIRE(m, getTypeManager<T>());
-			oxRequire(out, m->loadAsset(assetId));
+			OX_REQUIRE(out, m->loadAsset(assetId));
 			m_fileUpdated[assetId].connect(m, &AssetTypeManager<T>::reloadAsset);
 			return out;
 		}

src/olympic/keel/include/keel/media.hpp

@@ -25,9 +25,9 @@ struct PreloadPtr {
 	uint64_t preloadAddr = 0;
 };
 
-oxModelBegin(PreloadPtr)
+OX_MODEL_BEGIN(PreloadPtr)
-	oxModelField(preloadAddr)
+	OX_MODEL_FIELD(preloadAddr)
-oxModelEnd()
+OX_MODEL_END()
 
 ox::Result<std::size_t> getPreloadAddr(keel::Context &ctx, ox::FileAddress const&addr) noexcept;
 ox::Result<std::size_t> getPreloadAddr(keel::Context &ctx, ox::StringViewCR path) noexcept;
@@ -63,14 +63,14 @@ namespace detail {
 template<typename T>
 constexpr auto makeLoader(Context &ctx) {
 	return [&ctx](ox::StringView assetId) -> ox::Result<T> {
-		oxRequire(p, ctx.uuidToPath.at(assetId));
+		OX_REQUIRE(p, ctx.uuidToPath.at(assetId));
-		oxRequire(buff, ctx.rom->read(*p));
+		OX_REQUIRE(buff, ctx.rom->read(*p));
 		auto [obj, err] = readAsset<T>(buff);
 		if (err) {
 			if (err != ox::Error_ClawTypeVersionMismatch && err != ox::Error_ClawTypeMismatch) {
 				return err;
 			}
-			oxReturnError(convert<T>(ctx, buff, &obj));
+			OX_RETURN_ERROR(convert<T>(ctx, buff, &obj));
 		}
 		return std::move(obj);
 	};
@@ -97,7 +97,7 @@ ox::Result<keel::AssetRef<T>> readObjFile(
 		auto [cached, err] = ctx.assetManager.getAsset<T>(assetId);
 		if (err) {
 			ctx.assetManager.initTypeManager<T>(detail::makeLoader<T>, ctx);
-			oxReturnError(ctx.assetManager.loadAsset<T>(assetId).moveTo(cached));
+			OX_RETURN_ERROR(ctx.assetManager.loadAsset<T>(assetId).moveTo(cached));
 		}
 		return cached;
 	}
@@ -110,7 +110,7 @@ ox::Result<keel::AssetRef<T>> readObjNoCache(
 		keel::Context &ctx,
 		ox::StringViewCR assetId) noexcept {
 	if constexpr(ox::preloadable<T>::value) {
-		oxRequire(addr, getPreloadAddr(ctx, assetId));
+		OX_REQUIRE(addr, getPreloadAddr(ctx, assetId));
 		return keel::AssetRef<T>(std::bit_cast<T const*>(uintptr_t{addr}));
 	} else {
 		return ox::Error(1);
@@ -139,11 +139,11 @@ ox::Result<keel::AssetRef<T>> readObj(
 		ox::FileAddress const&file,
 		[[maybe_unused]] bool forceLoad = false) noexcept {
 #ifndef OX_BARE_METAL
-	oxRequire(assetId, file.getPath());
+	OX_REQUIRE(assetId, file.getPath());
 	return readObj<T>(ctx, ox::StringView(assetId), forceLoad);
 #else
 	if constexpr(ox::preloadable<T>::value) {
-		oxRequire(addr, getPreloadAddr(ctx, file));
+		OX_REQUIRE(addr, getPreloadAddr(ctx, file));
 		return keel::AssetRef<T>(std::bit_cast<T const*>(uintptr_t{addr}));
 	} else {
 		return ox::Error(1);
@@ -157,7 +157,7 @@ ox::Error writeObj(
 		ox::FileAddress const&file,
 		T const&obj,
 		ox::ClawFormat fmt = ox::ClawFormat::Metal) noexcept {
-	oxRequire(objBuff, ox::writeClaw(obj, fmt));
+	OX_REQUIRE(objBuff, ox::writeClaw(obj, fmt));
 	return ctx.rom->write(file, objBuff.data(), objBuff.size());
 }
 

src/olympic/keel/include/keel/pack.hpp

@@ -20,11 +20,11 @@ struct ManifestEntry {
 	ox::String type;
 };
 
-oxModelBegin(ManifestEntry)
+OX_MODEL_BEGIN(ManifestEntry)
-	oxModelField(inode)
+	OX_MODEL_FIELD(inode)
-	oxModelField(preloaded)
+	OX_MODEL_FIELD(preloaded)
-	oxModelField(type)
+	OX_MODEL_FIELD(type)
-oxModelEnd()
+OX_MODEL_END()
 
 struct Manifest {
 	static constexpr auto TypeName = "net.drinkingtea.keel.Manifest";
@@ -32,9 +32,9 @@ struct Manifest {
 	ox::HashMap<ox::String, ManifestEntry> files;
 };
 
-oxModelBegin(Manifest)
+OX_MODEL_BEGIN(Manifest)
-	oxModelField(files)
+	OX_MODEL_FIELD(files)
-oxModelEnd()
+OX_MODEL_END()
 
 
 class Context;
@@ -113,24 +113,24 @@ ox::Error preloadObj(
 		ox::Preloader<PlatSpec> &pl,
 		ox::StringView const path) noexcept {
 	// load file
-	oxRequireM(buff, romFs.read(path));
+	OX_REQUIRE_M(buff, romFs.read(path));
-	oxRequireM(obj, keel::readAsset(ts, buff));
+	OX_REQUIRE_M(obj, keel::readAsset(ts, buff));
 	if (obj.type()->preloadable) {
 		// preload
 		auto const size = ox::sizeOf<GbaPlatSpec>(&obj);
 		auto const alignment = ox::alignOf<GbaPlatSpec>(obj);
-		oxRequire(a, pl.startAlloc(size, alignment));
+		OX_REQUIRE(a, pl.startAlloc(size, alignment));
 		auto const err = ox::preload<GbaPlatSpec, ox::ModelObject>(&pl, &obj);
-		oxReturnError(pl.endAlloc());
+		OX_RETURN_ERROR(pl.endAlloc());
-		oxReturnError(err);
+		OX_RETURN_ERROR(err);
 		keel::PreloadPtr const p{.preloadAddr = a};
-		oxReturnError(ox::writeMC(p).moveTo(buff));
+		OX_RETURN_ERROR(ox::writeMC(p).moveTo(buff));
 		oxOutf("preloaded {} as a {} @ {} to {}\n", path, obj.type()->typeName, a, a + size);
 	} else {
 		// strip the Claw header (it is not needed after preloading) and write back out to dest fs
-		oxReturnError(ox::writeMC(obj).moveTo(buff));
+		OX_RETURN_ERROR(ox::writeMC(obj).moveTo(buff));
 	}
-	oxReturnError(romFs.write(path, buff.data(), buff.size()));
+	OX_RETURN_ERROR(romFs.write(path, buff.data(), buff.size()));
 	return {};
 }
 
@@ -145,13 +145,13 @@ ox::Error preloadDir(
 		ox::StringViewCR path) noexcept {
 	// copy
 	oxTracef("pack.preload", "path: {}", path);
-	oxRequire(fileList, romFs.ls(path));
+	OX_REQUIRE(fileList, romFs.ls(path));
 	for (auto const&name : fileList) {
 		auto const filePath = ox::sfmt("{}{}", path, name);
-		oxRequire(stat, romFs.stat(filePath));
+		OX_REQUIRE(stat, romFs.stat(filePath));
 		if (stat.fileType == ox::FileType::Directory) {
 			auto const dir = ox::sfmt("{}{}/", path, name);
-			oxReturnError(preloadDir(manifest, ts, romFs, pl, dir));
+			OX_RETURN_ERROR(preloadDir(manifest, ts, romFs, pl, dir));
 		} else {
 			auto const err = preloadObj(ts, romFs, pl, filePath);
 			if (err) {
@@ -177,14 +177,14 @@ ox::Error appendBinary(ox::Buffer &binBuff, ox::SpanView<char> const&fsBuff, ox:
 	static_assert(mediaHdr.bytes() == hdrSize);
 	static_assert(preloadHdr.bytes() == hdrSize);
 	ox::BufferWriter w(&binBuff);
-	oxReturnError(padbin(w, hdrSize));
+	OX_RETURN_ERROR(padbin(w, hdrSize));
-	oxReturnError(w.write(mediaHdr.data(), mediaHdr.bytes()));
+	OX_RETURN_ERROR(w.write(mediaHdr.data(), mediaHdr.bytes()));
-	oxReturnError(w.write(fsBuff.data(), fsBuff.size()));
+	OX_RETURN_ERROR(w.write(fsBuff.data(), fsBuff.size()));
-	oxReturnError(padbin(w, hdrSize));
+	OX_RETURN_ERROR(padbin(w, hdrSize));
-	oxReturnError(w.write(preloadHdr.data(), preloadHdr.bytes()));
+	OX_RETURN_ERROR(w.write(preloadHdr.data(), preloadHdr.bytes()));
-	oxReturnError(pl.offsetPtrs(binBuff.size()));
+	OX_RETURN_ERROR(pl.offsetPtrs(binBuff.size()));
 	auto const&plBuff = pl.buff();
-	oxReturnError(w.write(plBuff.data(), plBuff.size()));
+	OX_RETURN_ERROR(w.write(plBuff.data(), plBuff.size()));
 	return {};
 }
 

src/olympic/keel/include/keel/typeconv.hpp

@@ -110,15 +110,15 @@ class Converter: public BaseConverter {
 		ox::Result<ox::UPtr<Wrap>> convertPtrToPtr(
 				keel::Context &ctx, Wrap &src) const noexcept final {
 			auto dst = makeWrap<DstType>();
-			oxReturnError(convert(ctx, wrapCast<SrcType>(src), wrapCast<DstType>(*dst)));
+			OX_RETURN_ERROR(convert(ctx, wrapCast<SrcType>(src), wrapCast<DstType>(*dst)));
 			return {std::move(dst)};
 		}
 
 		ox::Result<ox::UPtr<Wrap>> convertBuffToPtr(
 				keel::Context &ctx, ox::BufferView const&srcBuff) const noexcept final {
-			oxRequireM(src, readAsset<SrcType>(srcBuff));
+			OX_REQUIRE_M(src, readAsset<SrcType>(srcBuff));
 			auto dst = makeWrap<DstType>();
-			oxReturnError(convert(ctx, src, wrapCast<DstType>(*dst)));
+			OX_RETURN_ERROR(convert(ctx, src, wrapCast<DstType>(*dst)));
 			return {std::move(dst)};
 		}
 
@@ -137,7 +137,7 @@ template<typename DstType>
 ox::Result<DstType> convert(keel::Context &ctx, ox::BufferView const&srcBuffer) noexcept {
 	static constexpr auto DstTypeName = ox::requireModelTypeName<DstType>();
 	static constexpr auto DstTypeVersion = ox::requireModelTypeVersion<DstType>();
-	oxRequire(out, convert(ctx, srcBuffer, DstTypeName, DstTypeVersion));
+	OX_REQUIRE(out, convert(ctx, srcBuffer, DstTypeName, DstTypeVersion));
 	return std::move(wrapCast<DstType>(out));
 }
 
@@ -145,7 +145,7 @@ template<typename DstType>
 ox::Error convert(keel::Context &ctx, ox::BufferView const&buff, DstType *outObj) noexcept {
 	static constexpr auto DstTypeName = ox::requireModelTypeName<DstType>();
 	static constexpr auto DstTypeVersion = ox::requireModelTypeVersion<DstType>();
-	oxRequire(outPtr, convert(ctx, buff, DstTypeName, DstTypeVersion));
+	OX_REQUIRE(outPtr, convert(ctx, buff, DstTypeName, DstTypeVersion));
 	*outObj = std::move(wrapCast<DstType>(*outPtr));
 	return {};
 }
@@ -155,14 +155,14 @@ ox::Result<ox::Buffer> convertBuffToBuff(
 		keel::Context &ctx, ox::BufferView const&srcBuffer, ox::ClawFormat fmt) noexcept {
 	static constexpr auto DstTypeName = ox::requireModelTypeName<DstType>();
 	static constexpr auto DstTypeVersion = ox::requireModelTypeVersion<DstType>();
-	oxRequire(out, convert(ctx, srcBuffer, DstTypeName, DstTypeVersion));
+	OX_REQUIRE(out, convert(ctx, srcBuffer, DstTypeName, DstTypeVersion));
 	return ox::writeClaw<DstType>(wrapCast<DstType>(*out), fmt);
 }
 
 template<typename From, typename To, ox::ClawFormat fmt = ox::ClawFormat::Metal>
 ox::Result<bool> transformRule(keel::Context &ctx, ox::Buffer &buff, ox::StringView typeId) noexcept {
 	if (typeId == ox::ModelTypeId_v<From>) {
-		oxReturnError(keel::convertBuffToBuff<To>(ctx, buff, fmt).moveTo(buff));
+		OX_RETURN_ERROR(keel::convertBuffToBuff<To>(ctx, buff, fmt).moveTo(buff));
 		return true;
 	}
 	return false;

src/olympic/keel/src/asset.cpp

@@ -43,7 +43,7 @@ ox::Result<AssetHdr> readAssetHeader(ox::BufferView buff) noexcept {
 		return ox::Error(1, "Buffer too small for expected data");
 	}
 	buff += offset;
-	oxReturnError(ox::readClawHeader(buff).moveTo(out.value.clawHdr));
+	OX_RETURN_ERROR(ox::readClawHeader(buff).moveTo(out.value.clawHdr));
 	return out;
 }
 

src/olympic/keel/src/keel.cpp

@@ -30,7 +30,7 @@ ox::Error init(
 
 ox::Result<ox::UPtr<Context>> init(ox::UPtr<ox::FileSystem> &&fs, ox::StringViewCR appName) noexcept {
 	auto ctx = ox::make_unique<Context>();
-	oxReturnError(keel::init(*ctx, std::move(fs), appName));
+	OX_RETURN_ERROR(keel::init(*ctx, std::move(fs), appName));
 	return ctx;
 }
 

src/olympic/keel/src/media.cpp

@@ -48,19 +48,19 @@ void createUuidMapping(Context &ctx, ox::StringView filePath, ox::UUID const&uui
 }
 
 static ox::Error buildUuidMap(Context &ctx, ox::StringViewCR path) noexcept {
-	oxRequire(files, ctx.rom->ls(path));
+	OX_REQUIRE(files, ctx.rom->ls(path));
 	for (auto const&f : files) {
-		oxRequireM(filePath, ox::join("/", ox::Array<ox::StringView, 2>{path, f}));
+		OX_REQUIRE_M(filePath, ox::join("/", ox::Array<ox::StringView, 2>{path, f}));
-		oxRequire(stat, ctx.rom->stat(filePath));
+		OX_REQUIRE(stat, ctx.rom->stat(filePath));
 		if (stat.fileType == ox::FileType::NormalFile) {
-			oxRequire(data, ctx.rom->read(filePath));
+			OX_REQUIRE(data, ctx.rom->read(filePath));
 			auto const [hdr, err] = readAssetHeader(data);
 			if (!err) {
 				createUuidMapping(ctx, filePath, hdr.uuid);
 			}
 		} else if (stat.fileType == ox::FileType::Directory) {
 			if (!beginsWith(f, ".")) {
-				oxReturnError(buildUuidMap(ctx, filePath));
+				OX_RETURN_ERROR(buildUuidMap(ctx, filePath));
 			}
 		}
 	}
@@ -76,7 +76,7 @@ ox::Error buildUuidMap(Context &ctx) noexcept {
 
 ox::Result<ox::UUID> pathToUuid(Context &ctx, ox::StringViewCR path) noexcept {
 #ifndef OX_BARE_METAL
-	oxRequire(out, ctx.pathToUuid.at(path));
+	OX_REQUIRE(out, ctx.pathToUuid.at(path));
 	return *out;
 #else
 	return ox::Error(1, "UUID to path conversion not supported on this platform");
@@ -84,7 +84,7 @@ ox::Result<ox::UUID> pathToUuid(Context &ctx, ox::StringViewCR path) noexcept {
 }
 
 ox::Result<ox::UUID> getUuid(Context &ctx, ox::FileAddress const&fileAddr) noexcept {
-	oxRequire(path, fileAddr.getPath());
+	OX_REQUIRE(path, fileAddr.getPath());
 	return getUuid(ctx, path);
 }
 
@@ -98,11 +98,11 @@ ox::Result<ox::UUID> getUuid(Context &ctx, ox::StringView path) noexcept {
 }
 
 ox::Result<ox::CStringView> getPath(Context &ctx, ox::FileAddress const&fileAddr) noexcept {
-	oxRequire(path, fileAddr.getPath());
+	OX_REQUIRE(path, fileAddr.getPath());
 	if (beginsWith(path, "uuid://")) {
 		auto const uuid = substr(path, 7);
 #ifndef OX_BARE_METAL
-		oxRequireM(out, ctx.uuidToPath.at(uuid));
+		OX_REQUIRE_M(out, ctx.uuidToPath.at(uuid));
 		return ox::CStringView{*out};
 #else
 		return ox::Error(1, "UUID to path conversion not supported on this platform");
@@ -116,7 +116,7 @@ ox::Result<ox::CStringView> getPath(Context &ctx, ox::CStringView fileId) noexce
 	if (beginsWith(fileId, "uuid://")) {
 		auto const uuid = substr(fileId, 7);
 #ifndef OX_BARE_METAL
-		oxRequireM(out, ctx.uuidToPath.at(uuid));
+		OX_REQUIRE_M(out, ctx.uuidToPath.at(uuid));
 		return ox::CStringView{*out};
 #else
 		return ox::Error(1, "UUID to path conversion not supported on this platform");
@@ -129,7 +129,7 @@ ox::Result<ox::CStringView> getPath(Context &ctx, ox::CStringView fileId) noexce
 ox::Result<ox::CStringView> uuidUrlToPath(Context &ctx, ox::StringView uuid) noexcept {
 	uuid = substr(uuid, 7);
 #ifndef OX_BARE_METAL
-	oxRequireM(out, ctx.uuidToPath.at(uuid));
+	OX_REQUIRE_M(out, ctx.uuidToPath.at(uuid));
 	return ox::CStringView(*out);
 #else
 	return ox::Error(1, "UUID to path conversion not supported on this platform");
@@ -138,7 +138,7 @@ ox::Result<ox::CStringView> uuidUrlToPath(Context &ctx, ox::StringView uuid) noe
 
 ox::Result<ox::CStringView> uuidToPath(Context &ctx, ox::StringViewCR uuid) noexcept {
 #ifndef OX_BARE_METAL
-	oxRequireM(out, ctx.uuidToPath.at(uuid));
+	OX_REQUIRE_M(out, ctx.uuidToPath.at(uuid));
 	return ox::CStringView(*out);
 #else
 	return ox::Error(1, "UUID to path conversion not supported on this platform");
@@ -147,7 +147,7 @@ ox::Result<ox::CStringView> uuidToPath(Context &ctx, ox::StringViewCR uuid) noex
 
 ox::Result<ox::CStringView> uuidToPath(Context &ctx, ox::UUID const&uuid) noexcept {
 #ifndef OX_BARE_METAL
-	oxRequireM(out, ctx.uuidToPath.at(uuid.toString()));
+	OX_REQUIRE_M(out, ctx.uuidToPath.at(uuid.toString()));
 	return ox::CStringView(*out);
 #else
 	return ox::Error(1, "UUID to path conversion not supported on this platform");
@@ -158,7 +158,7 @@ ox::Error reloadAsset(keel::Context &ctx, ox::StringView assetId) noexcept {
 	ox::UUIDStr uuidStr;
 	if (beginsWith(assetId, "uuid://")) {
 		assetId = substr(assetId, 7);
-		oxRequire(p, keel::uuidToPath(ctx, assetId));
+		OX_REQUIRE(p, keel::uuidToPath(ctx, assetId));
 	} else {
 		auto const [uuid, uuidErr] =  getUuid(ctx, assetId);
 		if (!uuidErr) {
@@ -207,18 +207,18 @@ void unloadRom(char*) noexcept {
 }
 
 ox::Result<std::size_t> getPreloadAddr(keel::Context &ctx, ox::StringViewCR path) noexcept {
-	oxRequire(stat, ctx.rom->stat(path));
+	OX_REQUIRE(stat, ctx.rom->stat(path));
-	oxRequire(buff, static_cast<ox::MemFS&>(*ctx.rom).directAccess(path));
+	OX_REQUIRE(buff, static_cast<ox::MemFS&>(*ctx.rom).directAccess(path));
 	PreloadPtr p;
-	oxReturnError(ox::readMC({buff, static_cast<std::size_t>(stat.size)}, p));
+	OX_RETURN_ERROR(ox::readMC({buff, static_cast<std::size_t>(stat.size)}, p));
 	return static_cast<std::size_t>(p.preloadAddr) + ctx.preloadSectionOffset;
 }
 
 ox::Result<std::size_t> getPreloadAddr(keel::Context &ctx, ox::FileAddress const&addr) noexcept {
-	oxRequire(stat, ctx.rom->stat(addr));
+	OX_REQUIRE(stat, ctx.rom->stat(addr));
-	oxRequire(buff, static_cast<ox::MemFS&>(*ctx.rom).directAccess(addr));
+	OX_REQUIRE(buff, static_cast<ox::MemFS&>(*ctx.rom).directAccess(addr));
 	PreloadPtr p;
-	oxReturnError(ox::readMC({buff, static_cast<std::size_t>(stat.size)}, p));
+	OX_RETURN_ERROR(ox::readMC({buff, static_cast<std::size_t>(stat.size)}, p));
 	return static_cast<std::size_t>(p.preloadAddr) + ctx.preloadSectionOffset;
 }
 
@@ -241,7 +241,7 @@ ox::Error setRomFs(Context &ctx, ox::UPtr<ox::FileSystem> &&fs) noexcept {
 ox::Result<ox::UniquePtr<ox::FileSystem>> loadRomFs(ox::StringViewCR path) noexcept {
 	auto const lastDot = ox::lastIndexOf(path, '.');
 	if (!lastDot.error && substr(path, lastDot.value) == ".oxfs") {
-		oxRequire(rom, loadRom(path));
+		OX_REQUIRE(rom, loadRom(path));
 		return {ox::make_unique<ox::FileSystem32>(rom, 32 * ox::units::MB, unloadRom)};
 	} else {
 #ifdef OX_HAS_PASSTHROUGHFS

src/olympic/keel/src/pack-applib.cpp

@@ -43,7 +43,7 @@ static ox::Result<ox::Buffer> readFileBuff(ox::StringView path) noexcept {
 static ox::Error generateTypes(ox::TypeStore &ts) noexcept {
 	for (auto const mod : keel::modules()) {
 		for (auto gen : mod->types()) {
-			oxReturnError(gen(ts));
+			OX_RETURN_ERROR(gen(ts));
 		}
 	}
 	return {};
@@ -55,29 +55,29 @@ static ox::Error pack(
 		ox::StringView argManifest,
 		ox::StringView projectDataDir) noexcept {
 	ox::Buffer dstBuff(32 * ox::units::MB);
-	oxReturnError(ox::FileSystem32::format(dstBuff.data(), dstBuff.size()));
+	OX_RETURN_ERROR(ox::FileSystem32::format(dstBuff.data(), dstBuff.size()));
 	ox::FileSystem32 dst(dstBuff);
-	oxRequire(ctx, keel::init(ox::make_unique<ox::PassThroughFS>(argSrc), "keel-pack"));
+	OX_REQUIRE(ctx, keel::init(ox::make_unique<ox::PassThroughFS>(argSrc), "keel-pack"));
 	keel::TypeStore ts(*ctx->rom, ox::sfmt("{}/type_descriptors", projectDataDir));
-	oxReturnError(generateTypes(ts));
+	OX_RETURN_ERROR(generateTypes(ts));
 	keel::Manifest manifest;
-	oxReturnError(keel::pack(manifest, *ctx, ts, dst));
+	OX_RETURN_ERROR(keel::pack(manifest, *ctx, ts, dst));
-	oxRequireM(pl, keel::GbaPreloader::make());
+	OX_REQUIRE_M(pl, keel::GbaPreloader::make());
-	oxReturnError(preload(manifest, ts, dst, *pl));
+	OX_RETURN_ERROR(preload(manifest, ts, dst, *pl));
-	oxReturnError(dst.resize());
+	OX_RETURN_ERROR(dst.resize());
 	// resize buffer
-	oxRequire(dstSize, dst.size());
+	OX_REQUIRE(dstSize, dst.size());
 	dstBuff.resize(dstSize);
 	// concatenate ROM segments
-	oxRequireM(romBuff, readFileBuff(argRomBin));
+	OX_REQUIRE_M(romBuff, readFileBuff(argRomBin));
 	oxOutf("Input exe size: {} bytes\n", romBuff.size());
 	oxOutf("Dest FS size: {} bytes\n", dstSize);
 	oxOutf("Preload buff size: {} bytes\n", pl->buff().size());
-	oxReturnError(appendBinary(romBuff, dstBuff, *pl));
+	OX_RETURN_ERROR(appendBinary(romBuff, dstBuff, *pl));
 	oxOutf("Final ROM buff size: {} bytes\n", romBuff.size());
-	oxReturnError(writeFileBuff(argRomBin, romBuff));
+	OX_RETURN_ERROR(writeFileBuff(argRomBin, romBuff));
-	oxRequire(manifestJson, ox::writeOCString(manifest));
+	OX_REQUIRE(manifestJson, ox::writeOCString(manifest));
-	oxReturnError(writeFileBuff(argManifest, {manifestJson.data(), manifestJson.len()}));
+	OX_RETURN_ERROR(writeFileBuff(argManifest, {manifestJson.data(), manifestJson.len()}));
 	return {};
 }
 

src/olympic/keel/src/pack.cpp

@@ -15,19 +15,19 @@ static ox::Error pathToInode(
 		ox::FileSystem &dest,
 		ox::ModelObject &obj) noexcept {
 	auto &o = obj;
-	oxRequire(typeVal, o.at("type"));
+	OX_REQUIRE(typeVal, o.at("type"));
 	auto const type = static_cast<ox::FileAddressType>(typeVal->get<int8_t>());
-	oxRequire(dataVal, o.at("data"));
+	OX_REQUIRE(dataVal, o.at("data"));
 	auto &data = dataVal->get<ox::ModelUnion>();
 	ox::String path;
 	switch (type) {
 		case ox::FileAddressType::Path: {
-			oxRequire(pathVal, data.at("path"));
+			OX_REQUIRE(pathVal, data.at("path"));
 			path = pathVal->get<ox::String>();
 			break;
 		}
 		case ox::FileAddressType::ConstPath: {
-			oxRequire(pathVal, data.at("constPath"));
+			OX_REQUIRE(pathVal, data.at("constPath"));
 			path = pathVal->get<ox::String>();
 			break;
 		}
@@ -37,10 +37,10 @@ static ox::Error pathToInode(
 	}
 	if (beginsWith(path, "uuid://")) {
 		auto const uuid = ox::substr(path, 7);
-		oxReturnError(keel::uuidToPath(ctx, uuid).to<ox::String>().moveTo(path));
+		OX_RETURN_ERROR(keel::uuidToPath(ctx, uuid).to<ox::String>().moveTo(path));
 	}
-	oxRequire(s, dest.stat(path));
+	OX_REQUIRE(s, dest.stat(path));
-	oxReturnError(typeVal->set(static_cast<int8_t>(ox::FileAddressType::Inode)));
+	OX_RETURN_ERROR(typeVal->set(static_cast<int8_t>(ox::FileAddressType::Inode)));
 	oxOutf("\tpath to inode: {} => {}\n", path, s.inode);
 	return data.set(2, s.inode);
 }
@@ -69,7 +69,7 @@ static ox::Error transformFileAddressesVec(
 		ox::FileSystem &dest,
 		ox::ModelValueVector &v) noexcept {
 	for (auto &f : v) {
-		oxReturnError(transformFileAddresses(ctx, dest, f));
+		OX_RETURN_ERROR(transformFileAddresses(ctx, dest, f));
 	}
 	return {};
 }
@@ -87,7 +87,7 @@ static ox::Error transformFileAddressesObj(
 	}
 	for (auto &f : obj) {
 		auto &v = f->value;
-		oxReturnError(transformFileAddresses(ctx, dest, v));
+		OX_RETURN_ERROR(transformFileAddresses(ctx, dest, v));
 	}
 	return {};
 }
@@ -96,12 +96,12 @@ static ox::Error performPackTransforms(
 		ManifestEntry &entry,
 		Context &ctx,
 		ox::Buffer &clawData) noexcept {
-	oxRequireM(typeId, readAssetTypeId(clawData));
+	OX_REQUIRE_M(typeId, readAssetTypeId(clawData));
 	for (auto const tr : packTransforms(ctx)) {
 		bool changed{};
-		oxReturnError(tr(ctx, clawData, typeId).moveTo(changed));
+		OX_RETURN_ERROR(tr(ctx, clawData, typeId).moveTo(changed));
 		if (changed) {
-			oxReturnError(readAssetTypeId(clawData).moveTo(typeId));
+			OX_RETURN_ERROR(readAssetTypeId(clawData).moveTo(typeId));
 		}
 	}
 	entry.type = ox::String{typeId};
@@ -115,17 +115,17 @@ static ox::Error doTransformations(
 		ox::FileSystem &dest,
 		ox::StringViewCR filePath) noexcept {
 	// load file
-	oxRequire(s, dest.stat(filePath));
+	OX_REQUIRE(s, dest.stat(filePath));
 	// do transformations
-	oxRequireM(buff, dest.read(s.inode));
+	OX_REQUIRE_M(buff, dest.read(s.inode));
-	oxReturnError(keel::performPackTransforms(manifest.files[filePath], ctx, buff));
+	OX_RETURN_ERROR(keel::performPackTransforms(manifest.files[filePath], ctx, buff));
 	// transform FileAddresses
-	oxRequireM(obj, keel::readAsset(ts, buff));
+	OX_REQUIRE_M(obj, keel::readAsset(ts, buff));
 	oxOutf("transforming {}\n", filePath);
-	oxReturnError(transformFileAddressesObj(ctx, dest, obj));
+	OX_RETURN_ERROR(transformFileAddressesObj(ctx, dest, obj));
-	oxReturnError(ox::writeClaw(obj).moveTo(buff));
+	OX_RETURN_ERROR(ox::writeClaw(obj).moveTo(buff));
 	// write file to dest
-	oxReturnError(dest.write(s.inode, buff));
+	OX_RETURN_ERROR(dest.write(s.inode, buff));
 	return {};
 }
 
@@ -139,13 +139,13 @@ static ox::Error transformClaw(
 		ox::StringViewCR path) noexcept {
 	// copy
 	oxTracef("pack.transformClaw", "path: {}", path);
-	oxRequire(fileList, dest.ls(path));
+	OX_REQUIRE(fileList, dest.ls(path));
 	for (auto const&name : fileList) {
 		auto const filePath = ox::sfmt("{}{}", path, name);
-		oxRequire(stat, dest.stat(filePath));
+		OX_REQUIRE(stat, dest.stat(filePath));
 		if (stat.fileType == ox::FileType::Directory) {
 			auto const dir = ox::sfmt("{}{}/", path, name);
-			oxReturnError(transformClaw(manifest, ctx, ts, dest, dir));
+			OX_RETURN_ERROR(transformClaw(manifest, ctx, ts, dest, dir));
 		} else {
 			auto const err = doTransformations(manifest, ctx, ts, dest, filePath);
 			if (err) {
@@ -166,28 +166,28 @@ static ox::Error copy(
 	oxOutf("{}copying directory: {}\n", logPrefix, path);
 	auto const childLogPrefix = ox::sfmt("{}\t", logPrefix);
 	// copy
-	oxRequire(fileList, src.ls(path));
+	OX_REQUIRE(fileList, src.ls(path));
 	for (auto const&name : fileList) {
 		auto const currentFile = ox::sfmt("{}{}", path, name);
 		if (beginsWith(name, ".")) {
 			continue;
 		}
-		oxRequire(srcStat, src.stat(currentFile));
+		OX_REQUIRE(srcStat, src.stat(currentFile));
 		if (srcStat.fileType == ox::FileType::Directory) {
-			oxReturnError(dest.mkdir(currentFile, true));
+			OX_RETURN_ERROR(dest.mkdir(currentFile, true));
-			oxReturnError(copy(manifest, src, dest, currentFile + '/', childLogPrefix));
+			OX_RETURN_ERROR(copy(manifest, src, dest, currentFile + '/', childLogPrefix));
 		} else {
 			// load file
 			oxOutf("{}copying file: {}...", childLogPrefix, currentFile);
 			ox::StringView status = "failed";
-			oxDefer [&status] {
+			OX_DEFER [&status] {
 				oxOutf(" {}\n", status);
 			};
-			oxRequireM(buff, src.read(currentFile));
+			OX_REQUIRE_M(buff, src.read(currentFile));
 			// write file to dest
-			oxReturnError(dest.write(currentFile, buff));
+			OX_RETURN_ERROR(dest.write(currentFile, buff));
 			status = "OK";
-			oxRequire(dstStat, dest.stat(currentFile));
+			OX_REQUIRE(dstStat, dest.stat(currentFile));
 			manifest.files[currentFile] = {
 				.inode = dstStat.inode,
 				.type = ox::String{keel::readAssetTypeId(buff).or_value({})},
@@ -202,9 +202,9 @@ ox::Error pack(
 		keel::Context &ctx,
 		ox::TypeStore &ts,
 		ox::FileSystem &dest) noexcept {
-	oxReturnError(copy(manifest, *ctx.rom, dest, "/"));
+	OX_RETURN_ERROR(copy(manifest, *ctx.rom, dest, "/"));
 	oxOut("Doing transforms\n");
-	oxReturnError(transformClaw(manifest, ctx, ts, dest, "/"));
+	OX_RETURN_ERROR(transformClaw(manifest, ctx, ts, dest, "/"));
 	return {};
 }
 

src/olympic/keel/src/typeconv.cpp

@@ -55,7 +55,7 @@ ox::Result<ox::UPtr<Wrap>> convert(
 		ox::BufferView const&srcBuffer,
 		ox::StringViewCR dstTypeName,
 		int dstTypeVersion) noexcept {
-	oxRequire(hdr, readAssetHeader(srcBuffer));
+	OX_REQUIRE(hdr, readAssetHeader(srcBuffer));
 	return convert(
 			ctx,
 			converters(ctx),

src/olympic/keel/src/typestore.cpp

@@ -13,9 +13,9 @@ TypeStore::TypeStore(ox::FileSystem &fs, ox::StringView descPath) noexcept:
 
 ox::Result<ox::UPtr<ox::DescriptorType>> TypeStore::loadDescriptor(ox::StringView const typeId) noexcept {
 	auto const path = ox::sfmt("{}/{}", m_descPath, typeId);
-	oxRequire(buff, m_fs.read(path));
+	OX_REQUIRE(buff, m_fs.read(path));
 	auto dt = ox::make_unique<ox::DescriptorType>();
-	oxReturnError(ox::readClaw<ox::DescriptorType>(buff, *dt));
+	OX_RETURN_ERROR(ox::readClaw<ox::DescriptorType>(buff, *dt));
 	return dt;
 }
 

src/olympic/keel/test/tests.cpp

@@ -15,10 +15,10 @@ static std::map<ox::StringView, ox::Error(*)()> tests = {
 		[]() -> ox::Error {
 			constexpr ox::StringView uuidStr = "8d814442-f46e-4cc3-8edc-ca3c01cc86db";
 			constexpr ox::StringView hdr = "K1;8d814442-f46e-4cc3-8edc-ca3c01cc86db;";
-			oxRequire(uuid, ox::UUID::fromString(uuidStr));
+			OX_REQUIRE(uuid, ox::UUID::fromString(uuidStr));
 			ox::Array<char, hdr.len()> buff;
 			ox::CharBuffWriter bw(buff);
-			oxReturnError(keel::writeUuidHeader(bw, uuid));
+			OX_RETURN_ERROR(keel::writeUuidHeader(bw, uuid));
 			oxExpect(ox::StringView(buff.data(), buff.size()), hdr);
 			return {};
 		}

src/olympic/studio/applib/src/main.cpp

@@ -37,7 +37,7 @@ static ox::Error runApp(
 		ox::StringViewCR appName,
 		ox::StringViewCR projectDataDir,
 		ox::UPtr<ox::FileSystem> &&fs) noexcept {
-	oxRequireM(ctx, turbine::init(std::move(fs), appName));
+	OX_REQUIRE_M(ctx, turbine::init(std::move(fs), appName));
 	turbine::setWindowTitle(*ctx, keelCtx(*ctx).appName);
 	turbine::setKeyEventHandler(*ctx, keyEventHandler);
 	turbine::setRefreshWithin(*ctx, 0);

src/olympic/studio/applib/src/projectexplorer.cpp

@@ -16,16 +16,16 @@ static ox::Result<ox::UniquePtr<ProjectTreeModel>> buildProjectTreeModel(
 		ox::StringView path,
 		ProjectTreeModel *parent) noexcept {
 	auto const fs = explorer.romFs();
-	oxRequire(stat, fs->stat(path));
+	OX_REQUIRE(stat, fs->stat(path));
 	auto out = ox::make_unique<ProjectTreeModel>(explorer, ox::String(name), parent);
 	if (stat.fileType == ox::FileType::Directory) {
-		oxRequireM(children, fs->ls(path));
+		OX_REQUIRE_M(children, fs->ls(path));
 		std::sort(children.begin(), children.end());
 		ox::Vector<ox::UniquePtr<ProjectTreeModel>> outChildren;
 		for (auto const&childName : children) {
 			if (childName[0] != '.') {
 				auto const childPath = ox::sfmt("{}/{}", path, childName);
-				oxRequireM(child, buildProjectTreeModel(explorer, childName, childPath, out.get()));
+				OX_REQUIRE_M(child, buildProjectTreeModel(explorer, childName, childPath, out.get()));
 				outChildren.emplace_back(std::move(child));
 			}
 		}
@@ -52,7 +52,7 @@ void ProjectExplorer::setModel(ox::UPtr<ProjectTreeModel> &&model) noexcept {
 }
 
 ox::Error ProjectExplorer::refreshProjectTreeModel(ox::StringViewCR) noexcept {
-	oxRequireM(model, buildProjectTreeModel(*this, "Project", "/", nullptr));
+	OX_REQUIRE_M(model, buildProjectTreeModel(*this, "Project", "/", nullptr));
 	setModel(std::move(model));
 	return ox::Error(0);
 }

src/olympic/studio/applib/src/studioapp.cpp

@@ -36,12 +36,12 @@ struct StudioConfig {
 	bool showProjectExplorer = true;
 };
 
-oxModelBegin(StudioConfig)
+OX_MODEL_BEGIN(StudioConfig)
-	oxModelFieldRename(activeTabItemName, active_tab_item_name)
+	OX_MODEL_FIELD_RENAME(activeTabItemName, active_tab_item_name)
-	oxModelFieldRename(projectPath, project_path)
+	OX_MODEL_FIELD_RENAME(projectPath, project_path)
-	oxModelFieldRename(openFiles, open_files)
+	OX_MODEL_FIELD_RENAME(openFiles, open_files)
-	oxModelFieldRename(showProjectExplorer, show_project_explorer)
+	OX_MODEL_FIELD_RENAME(showProjectExplorer, show_project_explorer)
-oxModelEnd()
+OX_MODEL_END()
 
 StudioUI::StudioUI(turbine::Context &ctx, ox::StringParam projectDataDir) noexcept:
 		m_sctx(*this, ctx),
@@ -222,7 +222,7 @@ void StudioUI::drawTabs() noexcept {
 				m_activeEditor = nullptr;
 			}
 			try {
-				oxThrowError(m_editors.erase(it).moveTo(it));
+				OX_THROW_ERROR(m_editors.erase(it).moveTo(it));
 			} catch (ox::Exception const&ex) {
 				oxErrf("Editor tab deletion failed: {} ({}:{})\n", ex.what(), ex.file, ex.line);
 			} catch (std::exception const&ex) {
@@ -323,15 +323,15 @@ void StudioUI::handleKeyInput() noexcept {
 ox::Error StudioUI::createOpenProject(ox::StringViewCR path) noexcept {
 	std::error_code ec;
 	std::filesystem::create_directories(toStdStringView(path), ec);
-	oxReturnError(ox::Error(ec.value() != 0, "Could not create project directory"));
+	OX_RETURN_ERROR(ox::Error(ec.value() != 0, "Could not create project directory"));
-	oxReturnError(openProjectPath(path));
+	OX_RETURN_ERROR(openProjectPath(path));
 	return m_project->writeTypeStore();
 }
 
 ox::Error StudioUI::openProjectPath(ox::StringParam path) noexcept {
-	oxRequireM(fs, keel::loadRomFs(path.view()));
+	OX_REQUIRE_M(fs, keel::loadRomFs(path.view()));
-	oxReturnError(keel::setRomFs(keelCtx(m_ctx), std::move(fs)));
+	OX_RETURN_ERROR(keel::setRomFs(keelCtx(m_ctx), std::move(fs)));
-	oxReturnError(
+	OX_RETURN_ERROR(
 			ox::make_unique_catch<studio::Project>(keelCtx(m_ctx), std::move(path), m_projectDataDir)
 			        .moveTo(m_project));
 	auto const sctx = applicationData<studio::StudioContext>(m_ctx);
@@ -366,7 +366,7 @@ ox::Error StudioUI::openFileActiveTab(ox::StringViewCR path, bool makeActiveTab)
 		}
 		return {};
 	}
-	oxRequire(ext, studio::fileExt(path));
+	OX_REQUIRE(ext, studio::fileExt(path));
 	// create Editor
 	BaseEditor *editor = nullptr;
 	auto const err = m_editorMakers.contains(ext) ?

src/olympic/studio/modlib/include/studio/configio.hpp

@@ -60,7 +60,7 @@ ox::Error writeConfig(keel::Context &ctx, ox::StringViewCR name, T const&data) n
 		//oxErrf("Could not create config directory: {} - {}\n", path, toStr(err));
 		return err;
 	}
-	oxRequireM(buff, ox::writeOC(data));
+	OX_REQUIRE_M(buff, ox::writeOC(data));
 	*buff.back().value = '\n';
 	if (auto const err = fs.write(path, buff.data(), buff.size())) {
 		//oxErrf("Could not read config file: {} - {}\n", path, toStr(err));

src/olympic/studio/modlib/include/studio/imguiutil.hpp

@@ -35,7 +35,7 @@ ox::Result<T> getDragDropPayload(ox::CStringViewCR name) noexcept {
 }
 
 ox::Error setDragDropPayload(ox::CStringViewCR name, auto const&obj) noexcept {
-	oxRequire(buff, ox::writeClaw(obj, ox::ClawFormat::Metal));
+	OX_REQUIRE(buff, ox::writeClaw(obj, ox::ClawFormat::Metal));
 	ImGui::SetDragDropPayload(name.c_str(), buff.data(), buff.size());
 	return {};
 }
@@ -223,7 +223,7 @@ bool ListBox(
  * @param selIdx
  * @return true if new value selected, false otherwise
  */
-bool ListBox(ox::CStringViewCR name, ox::Span<const ox::String> const&list, size_t &selIdx) noexcept;
+bool ListBox(ox::CStringViewCR name, ox::SpanView<ox::String> const&list, size_t &selIdx) noexcept;
 
 class FilePicker {
 	private:

src/olympic/studio/modlib/include/studio/itemmaker.hpp

@@ -79,7 +79,7 @@ class ItemMakerT: public ItemMaker {
 		ox::Result<ox::String> write(studio::StudioContext &sctx, ox::StringView const pName) const noexcept override {
 			auto const path = itemPath(pName);
 			createUuidMapping(keelCtx(sctx.tctx), path, ox::UUID::generate().unwrap());
-			oxReturnError(sctx.project->writeObj(path, m_item, m_fmt));
+			OX_RETURN_ERROR(sctx.project->writeObj(path, m_item, m_fmt));
 			return path;
 		}
 };

src/olympic/studio/modlib/include/studio/project.hpp

@@ -130,39 +130,39 @@ class Project {
 
 template<typename T>
 ox::Error Project::writeObj(ox::StringViewCR path, T const&obj, ox::ClawFormat fmt) noexcept {
-	oxRequireM(buff, ox::writeClaw(obj, fmt));
+	OX_REQUIRE_M(buff, ox::writeClaw(obj, fmt));
 	if (fmt == ox::ClawFormat::Organic) {
 		buff.pop_back();
 	}
 	// write to FS
-	oxReturnError(mkdir(parentDir(path)));
+	OX_RETURN_ERROR(mkdir(parentDir(path)));
-	oxReturnError(writeBuff(path, buff));
+	OX_RETURN_ERROR(writeBuff(path, buff));
 	// write type descriptor
 	if (m_typeStore.get<T>().error) {
-		oxReturnError(ox::buildTypeDef(m_typeStore, obj));
+		OX_RETURN_ERROR(ox::buildTypeDef(m_typeStore, obj));
 	}
-	oxRequire(desc, m_typeStore.get<T>());
+	OX_REQUIRE(desc, m_typeStore.get<T>());
 	auto const descPath = ox::sfmt("{}/{}", m_typeDescPath, buildTypeId(*desc));
 	auto const descExists = m_fs.exists(descPath);
 	if (!descExists) {
-		oxReturnError(writeTypeStore());
+		OX_RETURN_ERROR(writeTypeStore());
 	}
-	oxReturnError(keel::reloadAsset(m_ctx, path));
+	OX_RETURN_ERROR(keel::reloadAsset(m_ctx, path));
-	oxRequire(uuid, pathToUuid(m_ctx, path));
+	OX_REQUIRE(uuid, pathToUuid(m_ctx, path));
 	fileUpdated.emit(path, uuid);
 	return {};
 }
 
 template<typename T>
 ox::Error Project::writeObj(ox::StringViewCR path, T const&obj) noexcept {
-	oxRequire(ext, fileExt(path));
+	OX_REQUIRE(ext, fileExt(path));
 	auto const fmt = m_typeFmt[ext].or_value(ox::ClawFormat::Metal);
 	return writeObj(path, obj, fmt);
 }
 
 template<typename T>
 ox::Result<T> Project::loadObj(ox::StringViewCR path) const noexcept {
-	oxRequire(buff, loadBuff(path));
+	OX_REQUIRE(buff, loadBuff(path));
 	if constexpr(ox::is_same_v<T, ox::ModelObject>) {
 		return keel::readAsset(m_typeStore, buff);
 	} else {
@@ -180,7 +180,7 @@ ox::Error Project::subscribe(ProjectEvent e, ox::SignalHandler *tgt, Functor &&s
 			break;
 		case ProjectEvent::FileRecognized:
 		{
-			oxRequire(files, listFiles());
+			OX_REQUIRE(files, listFiles());
 			for (auto const&f : files) {
 				slot(f);
 			}

src/olympic/studio/modlib/include/studio/selectiontracker.hpp

@@ -33,7 +33,7 @@ constexpr auto iterateSelection(studio::Selection const&sel, auto const&cb) {
 	for (auto x = sel.a.x; x <= sel.b.x; ++x) {
 		for (auto y = sel.a.y; y <= sel.b.y; ++y) {
 			if constexpr(retErr) {
-				oxReturnError(cb(x, y));
+				OX_RETURN_ERROR(cb(x, y));
 			} else {
 				cb(x, y);
 			}
@@ -49,7 +49,7 @@ constexpr auto iterateSelectionRows(studio::Selection const&sel, auto const&cb)
 	for (auto y = sel.a.y; y <= sel.b.y; ++y) {
 		for (auto x = sel.a.x; x <= sel.b.x; ++x) {
 			if constexpr(retErr) {
-				oxReturnError(cb(x, y));
+				OX_RETURN_ERROR(cb(x, y));
 			} else {
 				cb(x, y);
 			}

src/olympic/studio/modlib/src/imguiutil.cpp

@@ -155,7 +155,7 @@ bool ListBox(
 	return out;
 }
 
-bool ListBox(ox::CStringViewCR name, ox::Span<const ox::String> const&list, size_t &selIdx) noexcept {
+bool ListBox(ox::CStringViewCR name, ox::SpanView<ox::String> const&list, size_t &selIdx) noexcept {
 	return ListBox(name, [list](size_t i) -> ox::CStringView {
 		return list[i];
 	}, list.size(), selIdx);

src/olympic/studio/modlib/src/project.cpp

@@ -36,7 +36,7 @@ Project::Project(keel::Context &ctx, ox::String path, ox::StringViewCR projectDa
 	oxTracef("studio", "Project: {}", m_path);
 	generateTypes(m_typeStore);
 	if (ox::defines::Debug) {
-		oxThrowError(writeTypeStore());
+		OX_THROW_ERROR(writeTypeStore());
 	}
 	buildFileIndex();
 }
@@ -58,7 +58,7 @@ ox::FileSystem &Project::romFs() noexcept {
 ox::Error Project::mkdir(ox::StringViewCR path) const noexcept {
 	auto const [stat, err] = m_fs.stat(path);
 	if (err) {
-		oxReturnError(m_fs.mkdir(path, true));
+		OX_RETURN_ERROR(m_fs.mkdir(path, true));
 		fileUpdated.emit(path, {});
 	}
 	return stat.fileType == ox::FileType::Directory ?
@@ -79,12 +79,12 @@ ox::Vector<ox::String> const&Project::fileList(ox::StringViewCR ext) noexcept {
 
 ox::Error Project::writeTypeStore() noexcept {
 	// write all descriptors because we don't know which types T depends on
-	oxReturnError(mkdir(m_typeDescPath));
+	OX_RETURN_ERROR(mkdir(m_typeDescPath));
 	for (auto const &t: m_typeStore.typeList()) {
-		oxRequire(typeOut, ox::writeClaw(*t, ox::ClawFormat::Organic));
+		OX_REQUIRE(typeOut, ox::writeClaw(*t, ox::ClawFormat::Organic));
 		// write to FS
 		auto const typePath = ox::sfmt("{}/{}", m_typeDescPath, buildTypeId(*t));
-		oxReturnError(writeBuff(typePath, {typeOut.data(), typeOut.size() - 1}));
+		OX_RETURN_ERROR(writeBuff(typePath, {typeOut.data(), typeOut.size() - 1}));
 	}
 	return {};
 }
@@ -119,11 +119,11 @@ ox::Error Project::writeBuff(ox::StringViewCR path, ox::BufferView const&buff) n
 	ox::BufferWriter writer(&outBuff);
 	auto const [uuid, err] = pathToUuid(m_ctx, path);
 	if (!err) {
-		oxReturnError(keel::writeUuidHeader(writer, uuid));
+		OX_RETURN_ERROR(keel::writeUuidHeader(writer, uuid));
 	}
-	oxReturnError(writer.write(buff.data(), buff.size()));
+	OX_RETURN_ERROR(writer.write(buff.data(), buff.size()));
 	auto const newFile = m_fs.stat(path).error != 0;
-	oxReturnError(m_fs.write(path, outBuff.data(), outBuff.size(), ox::FileType::NormalFile));
+	OX_RETURN_ERROR(m_fs.write(path, outBuff.data(), outBuff.size(), ox::FileType::NormalFile));
 	if (newFile) {
 		fileAdded.emit(path);
 		indexFile(path);
@@ -138,16 +138,16 @@ ox::Result<ox::Buffer> Project::loadBuff(ox::StringViewCR path) const noexcept {
 }
 
 ox::Error Project::lsProcDir(ox::Vector<ox::String> *paths, ox::StringViewCR path) const noexcept {
-	oxRequire(files, m_fs.ls(path));
+	OX_REQUIRE(files, m_fs.ls(path));
 	for (auto const&name : files) {
 		auto fullPath = ox::sfmt("{}/{}", path, name);
-		oxRequire(stat, m_fs.stat(ox::StringView(fullPath)));
+		OX_REQUIRE(stat, m_fs.stat(ox::StringView(fullPath)));
 		switch (stat.fileType) {
 			case ox::FileType::NormalFile:
 				paths->emplace_back(std::move(fullPath));
 				break;
 			case ox::FileType::Directory:
-				oxReturnError(lsProcDir(paths, fullPath));
+				OX_RETURN_ERROR(lsProcDir(paths, fullPath));
 				break;
 			case ox::FileType::None:
 				break;
@@ -158,7 +158,7 @@ ox::Error Project::lsProcDir(ox::Vector<ox::String> *paths, ox::StringViewCR pat
 
 ox::Result<ox::Vector<ox::String>> Project::listFiles(ox::StringViewCR path) const noexcept {
 	ox::Vector<ox::String> paths;
-	oxReturnError(lsProcDir(&paths, path));
+	OX_RETURN_ERROR(lsProcDir(&paths, path));
 	return paths;
 }
 

src/olympic/studio/modlib/src/undostack.cpp

@@ -10,7 +10,7 @@ ox::Error UndoStack::push(ox::UPtr<UndoCommand> &&cmd) noexcept {
 	for (auto const i = m_stackIdx; i < m_stack.size();) {
 		std::ignore = m_stack.erase(i);
 	}
-	oxReturnError(cmd->redo());
+	OX_RETURN_ERROR(cmd->redo());
 	redoTriggered.emit(cmd.get());
 	changeTriggered.emit(cmd.get());
 	if (m_stack.empty() || !(*m_stack.back().value)->mergeWith(*cmd)) {
@@ -27,7 +27,7 @@ ox::Error UndoStack::push(ox::UPtr<UndoCommand> &&cmd) noexcept {
 ox::Error UndoStack::redo() noexcept {
 	if (m_stackIdx < m_stack.size()) {
 		auto &c = m_stack[m_stackIdx];
-		oxReturnError(c->redo());
+		OX_RETURN_ERROR(c->redo());
 		++m_stackIdx;
 		redoTriggered.emit(c.get());
 		changeTriggered.emit(c.get());
@@ -38,7 +38,7 @@ ox::Error UndoStack::redo() noexcept {
 ox::Error UndoStack::undo() noexcept {
 	if (m_stackIdx) {
 		auto &c = m_stack[--m_stackIdx];
-		oxReturnError(c->undo());
+		OX_RETURN_ERROR(c->undo());
 		undoTriggered.emit(c.get());
 		changeTriggered.emit(c.get());
 	}

src/olympic/turbine/include/turbine/clipboard.hpp

@@ -38,7 +38,7 @@ ox::Result<BaseClipboardObject*> getClipboardData(Context &ctx, ox::StringView t
 
 template<typename T>
 ox::Result<T*> getClipboardObject(Context &ctx) noexcept {
-	oxRequire(p, getClipboardData(ctx, ox::ModelTypeId_v<T>));
+	OX_REQUIRE(p, getClipboardData(ctx, ox::ModelTypeId_v<T>));
 	return dynamic_cast<T*>(p);
 }
 

src/olympic/turbine/src/gba/turbine.cpp

@@ -61,11 +61,11 @@ OX_ALLOW_UNSAFE_BUFFERS_END
 ox::Result<ContextUPtr> init(
 		ox::UPtr<ox::FileSystem> &&fs, ox::StringViewCR appName) noexcept {
 	auto ctx = ox::make_unique<Context>();
-	oxReturnError(keel::init(ctx->keelCtx, std::move(fs), appName));
+	OX_RETURN_ERROR(keel::init(ctx->keelCtx, std::move(fs), appName));
 #ifdef OX_BARE_METAL
-	oxReturnError(findPreloadSection().moveTo(ctx->keelCtx.preloadSectionOffset));
+	OX_RETURN_ERROR(findPreloadSection().moveTo(ctx->keelCtx.preloadSectionOffset));
 #endif
-	oxReturnError(initGfx(*ctx));
+	OX_RETURN_ERROR(initGfx(*ctx));
 	initTimer();
 	initIrq();
 	return ox::UPtr<turbine::Context, ContextDeleter>(std::move(ctx));

src/olympic/turbine/src/glfw/turbine.cpp

@@ -43,12 +43,12 @@ static void draw(GLFWwindow *window, int, int) noexcept {
 ox::Result<ContextUPtr> init(
 		ox::UPtr<ox::FileSystem> &&fs, ox::StringViewCR appName) noexcept {
 	auto ctx = ox::make_unique<Context>();
-	oxReturnError(keel::init(ctx->keelCtx, std::move(fs), appName));
+	OX_RETURN_ERROR(keel::init(ctx->keelCtx, std::move(fs), appName));
 	using namespace std::chrono;
 	ctx->startTime = static_cast<TimeMs>(
 			duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count());
 	glfwInit();
-	oxReturnError(initGfx(*ctx));
+	OX_RETURN_ERROR(initGfx(*ctx));
 	glfwSetWindowSizeCallback(ctx->window, draw);
 	return ox::UPtr<Context, ContextDeleter>(ctx.release());
 }

src/olympic/turbine/src/turbine.cpp

@@ -9,7 +9,7 @@
 namespace turbine {
 
 ox::Result<ContextUPtr> init(ox::StringViewCR fsPath, ox::StringViewCR appName) noexcept {
-	oxRequireM(fs, keel::loadRomFs(fsPath));
+	OX_REQUIRE_M(fs, keel::loadRomFs(fsPath));
 	return init(std::move(fs), appName);
 }