Squashed 'deps/nostalgia/' content from commit 9cb6bd4a

git-subtree-dir: deps/nostalgia
git-subtree-split: 9cb6bd4a32e9f39a858f72443ff5c6d40489fe22

src/nostalgia/modules/scene/CMakeLists.txt

@@ -0,0 +1,13 @@
+add_subdirectory(src)
+
+target_include_directories(
+	NostalgiaScene PUBLIC
+		include
+)
+
+install(
+	DIRECTORY
+		include/nostalgia
+	DESTINATION
+		include
+)

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

@@ -0,0 +1,13 @@
+/*
+ * Copyright 2016 - 2023 Gary Talent (gary@drinkingtea.net). All rights reserved.
+ */
+
+#pragma once
+
+#include <keel/module.hpp>
+
+namespace nostalgia::scene {
+
+const keel::Module *keelModule() noexcept;
+
+}

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

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2016 - 2023 Gary Talent (gary@drinkingtea.net). All rights reserved.
+ */
+
+#pragma once
+
+#include <nostalgia/core/context.hpp>
+
+#include "scenestatic.hpp"
+
+namespace nostalgia::scene {
+
+class Scene {
+	private:
+		SceneStatic const&m_sceneStatic;
+
+	public:
+		explicit Scene(SceneStatic const&sceneStatic) noexcept;
+
+		ox::Error setupDisplay(core::Context &ctx) const noexcept;
+
+	private:
+		void setupLayer(core::Context&, ox::Vector<uint16_t> const&layer, unsigned layerNo) const noexcept;
+
+};
+
+}

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

@@ -0,0 +1,228 @@
+/*
+ * Copyright 2016 - 2023 Gary Talent (gary@drinkingtea.net). All rights reserved.
+ */
+
+#pragma once
+
+#include <ox/fs/fs.hpp>
+#include <ox/std/error.hpp>
+#include <ox/std/size.hpp>
+#include <ox/std/types.hpp>
+#include <ox/std/vector.hpp>
+
+#include <nostalgia/core/tilesheet.hpp>
+
+namespace nostalgia::scene {
+
+struct SpriteDoc {
+
+	constexpr static auto TypeName = "net.drinkingtea.nostalgia.scene.SpriteDoc";
+	constexpr static auto TypeVersion = 1;
+	constexpr static auto Preloadable = true;
+
+	ox::String tilesheetPath;
+	ox::Vector<core::SubSheetId> subsheetId;
+
+};
+
+struct TileDoc {
+
+	constexpr static auto TypeName = "net.drinkingtea.nostalgia.scene.TileDoc";
+	constexpr static auto TypeVersion = 1;
+	constexpr static auto Preloadable = true;
+
+	core::SubSheetId subsheetId = -1;
+	ox::String subsheetPath;
+	uint8_t type = 0;
+	ox::Array<uint8_t, 4> layerAttachments;
+
+	[[nodiscard]]
+	constexpr ox::Result<core::SubSheetId> getSubsheetId(core::TileSheet const&ts) const noexcept {
+		// prefer the already present ID
+		if (subsheetId > -1) {
+			return subsheetId;
+		}
+		return ts.getIdFor(subsheetPath);
+	}
+
+	[[nodiscard]]
+	constexpr ox::Result<ox::StringView> getSubsheetPath(
+			core::TileSheet const&ts) const noexcept {
+		// prefer the already present path
+		if (!subsheetPath.len()) {
+			return ts.getNameFor(subsheetId);
+		}
+		return ox::StringView(subsheetPath);
+	}
+
+};
+
+oxModelBegin(TileDoc)
+	oxModelFieldRename(subsheet_id, subsheetId)
+	oxModelFieldRename(subsheet_path, subsheetPath)
+	oxModelField(type)
+	oxModelFieldRename(layer_attachments, layerAttachments)
+oxModelEnd()
+
+struct SceneDoc {
+
+	using TileMapRow = ox::Vector<TileDoc>;
+	using TileMapLayer = ox::Vector<TileMapRow>;
+	using TileMap = ox::Vector<TileMapLayer>;
+
+	constexpr static auto TypeName = "net.drinkingtea.nostalgia.scene.SceneDoc";
+	constexpr static auto TypeVersion = 1;
+	constexpr static auto Preloadable = true;
+
+	ox::String tilesheet; // path
+	ox::Vector<ox::String> palettes; // paths
+	TileMap tiles;
+
+	[[nodiscard]]
+	constexpr ox::Size size(std::size_t layerIdx) const noexcept {
+		const auto &layer = this->tiles[layerIdx];
+		const auto rowCnt = static_cast<int>(layer.size());
+		if (!rowCnt) {
+			return {};
+		}
+		auto colCnt = layer[0].size();
+		// find shortest row (they should all be the same, but you know this data
+		// could come from a file)
+		for (auto const&row : layer) {
+			colCnt = ox::min(colCnt, row.size());
+		}
+		return {static_cast<int>(colCnt), rowCnt};
+	}
+};
+
+oxModelBegin(SceneDoc)
+	oxModelField(tilesheet)
+	oxModelField(palettes)
+	oxModelField(tiles)
+oxModelEnd()
+
+
+constexpr void setTopEdge(uint8_t &layerAttachments, unsigned val) noexcept {
+	const auto val8 = static_cast<uint8_t>(val);
+	layerAttachments = (layerAttachments & 0b11111100) | val8;
+}
+constexpr void setBottomEdge(uint8_t &layerAttachments, unsigned val) noexcept {
+	const auto val8 = static_cast<uint8_t>(val);
+	layerAttachments = (layerAttachments & 0b11110011) | static_cast<uint8_t>(val8 << 2);
+}
+constexpr void setLeftEdge(uint8_t &layerAttachments, unsigned val) noexcept {
+	const auto val8 = static_cast<uint8_t>(val);
+	layerAttachments = (layerAttachments & 0b11001111) | static_cast<uint8_t>(val8 << 4);
+}
+constexpr void setRightEdge(uint8_t &layerAttachments, unsigned val) noexcept {
+	const auto val8 = static_cast<uint8_t>(val);
+	layerAttachments = (layerAttachments & 0b00111111) | static_cast<uint8_t>(val8 << 6);
+}
+
+[[nodiscard]]
+constexpr unsigned topEdge(uint8_t layerAttachments) noexcept {
+	return layerAttachments & 0b11;
+}
+[[nodiscard]]
+constexpr unsigned bottomEdge(uint8_t layerAttachments) noexcept {
+	return (layerAttachments >> 2) & 0b11;
+}
+[[nodiscard]]
+constexpr unsigned leftEdge(uint8_t layerAttachments) noexcept {
+	return (layerAttachments >> 4) & 0b11;
+}
+[[nodiscard]]
+constexpr unsigned rightEdge(uint8_t layerAttachments) noexcept {
+	return (layerAttachments >> 6) & 0b11;
+}
+
+
+struct SceneStatic {
+
+	constexpr static auto TypeName = "net.drinkingtea.nostalgia.scene.SceneStatic";
+	constexpr static auto TypeVersion = 1;
+	constexpr static auto Preloadable = true;
+
+	struct Tile {
+		uint16_t &tileMapIdx;
+		uint8_t &tileType;
+		uint8_t &layerAttachments;
+		constexpr Tile(uint16_t &pTileMapIdx, uint8_t &pTileType, uint8_t &pLayerAttachments) noexcept:
+			tileMapIdx(pTileMapIdx),
+			tileType(pTileType),
+			layerAttachments(pLayerAttachments) {
+		}
+	};
+	struct Layer {
+		uint16_t &columns;
+		uint16_t &rows;
+		ox::Vector<uint16_t> &tileMapIdx;
+		ox::Vector<uint8_t> &tileType;
+		ox::Vector<uint8_t> &layerAttachments;
+		constexpr Layer(
+				uint16_t &pColumns,
+				uint16_t &pRows,
+				ox::Vector<uint16_t> &pTileMapIdx,
+				ox::Vector<uint8_t> &pTileType,
+				ox::Vector<uint8_t> &pLayerAttachments) noexcept:
+			columns(pColumns),
+			rows(pRows),
+			tileMapIdx(pTileMapIdx),
+			tileType(pTileType),
+			layerAttachments(pLayerAttachments) {
+		}
+		[[nodiscard]]
+		constexpr Tile tile(std::size_t i) noexcept {
+			return {tileMapIdx[i], tileType[i], layerAttachments[i]};
+		}
+		constexpr auto setDimensions(ox::Size dim) noexcept {
+			columns = static_cast<uint16_t>(dim.width);
+			rows = static_cast<uint16_t>(dim.height);
+			const auto tileCnt = static_cast<unsigned>(columns * rows);
+			tileMapIdx.resize(tileCnt);
+			tileType.resize(tileCnt);
+			layerAttachments.resize(tileCnt);
+		}
+	};
+
+	ox::FileAddress tilesheet;
+	ox::Vector<ox::FileAddress> palettes;
+	// tile layer data
+	ox::Vector<uint16_t> columns;
+	ox::Vector<uint16_t> rows;
+	ox::Vector<ox::Vector<uint16_t>> tileMapIdx;
+	ox::Vector<ox::Vector<uint8_t>>  tileType;
+	ox::Vector<ox::Vector<uint8_t>>  layerAttachments;
+
+	[[nodiscard]]
+	constexpr Layer layer(std::size_t i) noexcept {
+		return {
+			columns[i],
+			rows[i],
+			tileMapIdx[i],
+			tileType[i],
+			layerAttachments[i],
+		};
+	}
+
+	constexpr auto setLayerCnt(std::size_t layerCnt) noexcept {
+		this->layerAttachments.resize(layerCnt);
+		this->columns.resize(layerCnt);
+		this->rows.resize(layerCnt);
+		this->tileMapIdx.resize(layerCnt);
+		this->tileType.resize(layerCnt);
+	}
+
+};
+
+oxModelBegin(SceneStatic)
+	oxModelField(tilesheet)
+	oxModelField(palettes)
+	oxModelField(columns)
+	oxModelField(rows)
+	oxModelField(tileMapIdx)
+	oxModelField(tileType)
+	oxModelField(layerAttachments)
+oxModelEnd()
+
+}

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

@@ -0,0 +1,13 @@
+/*
+ * Copyright 2016 - 2023 Gary Talent (gary@drinkingtea.net). All rights reserved.
+ */
+
+#pragma once
+
+#include <studio/studio.hpp>
+
+namespace nostalgia::scene {
+
+const studio::Module *studioModule() noexcept;
+
+}

src/nostalgia/modules/scene/src/CMakeLists.txt

@@ -0,0 +1,29 @@
+
+add_library(
+	NostalgiaScene
+		scene.cpp
+		scenestatic.cpp
+)
+
+target_include_directories(
+	NostalgiaScene PUBLIC
+		../include
+)
+
+target_link_libraries(
+	NostalgiaScene PUBLIC
+		NostalgiaCore
+)
+
+add_subdirectory(keel)
+if(NOSTALGIA_BUILD_STUDIO)
+	add_subdirectory(studio)
+endif()
+
+install(
+	TARGETS
+		NostalgiaScene
+	DESTINATION
+		LIBRARY DESTINATION lib
+		ARCHIVE DESTINATION lib
+)

src/nostalgia/modules/scene/src/keel/CMakeLists.txt

@@ -0,0 +1,17 @@
+add_library(
+	NostalgiaScene-Keel
+		keelmodule.cpp
+		typeconv.cpp
+)
+
+target_link_libraries(
+	NostalgiaScene-Keel PUBLIC
+		Keel
+		NostalgiaScene
+)
+install(
+	TARGETS
+		NostalgiaScene-Keel
+	LIBRARY DESTINATION
+		${NOSTALGIA_DIST_MODULE}
+)

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

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2016 - 2023 Gary Talent (gary@drinkingtea.net). All rights reserved.
+ */
+
+#include <keel/module.hpp>
+
+#include <nostalgia/scene/scenestatic.hpp>
+
+#include "typeconv.hpp"
+
+namespace nostalgia::scene {
+
+class SceneModule: public keel::Module {
+	private:
+		SceneDocToSceneStaticConverter m_sceneDocToSceneStaticConverter;
+
+	public:
+		[[nodiscard]]
+		ox::String id() const noexcept override {
+			return ox::String("net.drinkingtea.nostalgia.scene");
+		}
+
+		[[nodiscard]]
+		ox::Vector<keel::TypeDescGenerator> types() const noexcept override {
+			return {
+				keel::generateTypeDesc<SceneDoc>,
+				keel::generateTypeDesc<SceneStatic>,
+			};
+		}
+
+		[[nodiscard]]
+		ox::Vector<const keel::BaseConverter*> converters() const noexcept override {
+			return {
+				&m_sceneDocToSceneStaticConverter,
+			};
+		}
+
+		[[nodiscard]]
+		ox::Vector<keel::PackTransform> packTransforms() const noexcept override {
+			return {
+				keel::transformRule<SceneDoc, SceneStatic>,
+			};
+		}
+
+};
+
+static const SceneModule mod;
+const keel::Module *keelModule() noexcept {
+	return &mod;
+}
+
+}

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

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2016 - 2023 Gary Talent (gary@drinkingtea.net). All rights reserved.
+ */
+
+#include <nostalgia/core/gfx.hpp>
+#include <keel/media.hpp>
+
+#include "typeconv.hpp"
+
+namespace nostalgia::scene {
+
+[[nodiscard]]
+constexpr unsigned adjustLayerAttachment(unsigned layer, unsigned attachment) noexcept {
+	if (attachment == 0) {
+		return layer;
+	} else {
+		return attachment - 1;
+	}
+}
+
+constexpr void setLayerAttachments(unsigned layer, TileDoc const&srcTile, SceneStatic::Tile &dstTile) noexcept {
+	setTopEdge(
+			dstTile.layerAttachments,
+			adjustLayerAttachment(layer, srcTile.layerAttachments[0]));
+	setBottomEdge(
+			dstTile.layerAttachments,
+			adjustLayerAttachment(layer, srcTile.layerAttachments[1]));
+	setLeftEdge(
+			dstTile.layerAttachments,
+			adjustLayerAttachment(layer, srcTile.layerAttachments[2]));
+	setRightEdge(
+			dstTile.layerAttachments,
+			adjustLayerAttachment(layer, srcTile.layerAttachments[3]));
+}
+
+ox::Error SceneDocToSceneStaticConverter::convert(
+		keel::Context &ctx,
+		SceneDoc &src,
+		SceneStatic &dst) const noexcept {
+	oxRequire(ts, keel::readObj<core::TileSheet>(ctx, src.tilesheet));
+	const auto layerCnt = src.tiles.size();
+	dst.setLayerCnt(layerCnt);
+	dst.tilesheet = ox::FileAddress(src.tilesheet);
+	dst.palettes.reserve(src.palettes.size());
+	for (const auto &pal : src.palettes) {
+		dst.palettes.emplace_back(pal);
+	}
+	for (auto layerIdx = 0u; const auto &layer : src.tiles) {
+		const auto layerDim = src.size(layerIdx);
+		auto dstLayer = dst.layer(layerIdx);
+		dstLayer.setDimensions(layerDim);
+		for (auto tileIdx = 0u; const auto &row : layer) {
+			for (const auto &srcTile : row) {
+				auto dstTile = dstLayer.tile(tileIdx);
+				dstTile.tileType = srcTile.type;
+				oxRequire(path, srcTile.getSubsheetPath(*ts));
+				oxRequire(mapIdx, ts->getTileOffset(path));
+				dstTile.tileMapIdx = static_cast<uint16_t>(mapIdx);
+				setLayerAttachments(layerIdx, srcTile, dstTile);
+				++tileIdx;
+			}
+		}
+		++layerIdx;
+	}
+	return {};
+}
+
+}

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

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2016 - 2023 Gary Talent (gary@drinkingtea.net). All rights reserved.
+ */
+
+#pragma once
+
+#include <keel/typeconv.hpp>
+
+#include <nostalgia/scene/scenestatic.hpp>
+
+namespace nostalgia::scene {
+
+class SceneDocToSceneStaticConverter: public keel::Converter<SceneDoc, SceneStatic> {
+	ox::Error convert(keel::Context&, SceneDoc &src, SceneStatic &dst) const noexcept final;
+};
+
+}

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

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2016 - 2023 Gary Talent (gary@drinkingtea.net). All rights reserved.
+ */
+
+#include <nostalgia/core/gfx.hpp>
+
+#include <nostalgia/scene/scene.hpp>
+
+namespace nostalgia::scene {
+
+Scene::Scene(SceneStatic const&sceneStatic) noexcept:
+	m_sceneStatic(sceneStatic) {
+}
+
+ox::Error Scene::setupDisplay(core::Context &ctx) const noexcept {
+	if (m_sceneStatic.palettes.empty()) {
+		return OxError(1, "Scene has no palettes");
+	}
+	auto const&palette = m_sceneStatic.palettes[0];
+	oxReturnError(core::loadBgTileSheet(ctx, 0, m_sceneStatic.tilesheet));
+	oxReturnError(core::loadBgPalette(ctx, palette));
+	// disable all backgrounds
+	core::setBgStatus(ctx, 0);
+	for (auto layerNo = 0u; auto const&layer : m_sceneStatic.tileMapIdx) {
+		setupLayer(ctx, layer, layerNo);
+		++layerNo;
+	}
+	return {};
+}
+
+void Scene::setupLayer(
+		core::Context &ctx,
+		ox::Vector<uint16_t> const&layer,
+		unsigned layerNo) const noexcept {
+	core::setBgStatus(ctx, layerNo, true);
+	core::setBgCbb(ctx, layerNo, 0);
+	auto x = 0;
+	auto y = 0;
+	const auto width = m_sceneStatic.rows[layerNo];
+	for (auto const&tile : layer) {
+		const auto tile8 = static_cast<uint8_t>(tile);
+		core::setBgTile(ctx, layerNo, x, y, tile8);
+		core::setBgTile(ctx, layerNo, x + 1, y, tile8 + 1);
+		core::setBgTile(ctx, layerNo, x, y + 1, tile8 + 2);
+		core::setBgTile(ctx, layerNo, x + 1, y + 1, tile8 + 3);
+		x += 2;
+		if (x >= width * 2) {
+			x = 0;
+			y += 2;
+		}
+	}
+}
+
+}

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

@@ -0,0 +1,11 @@
+/*
+ * Copyright 2016 - 2023 Gary Talent (gary@drinkingtea.net). All rights reserved.
+ */
+
+#include <nostalgia/scene/scenestatic.hpp>
+
+namespace nostalgia::scene {
+
+
+
+}

src/nostalgia/modules/scene/src/studio/CMakeLists.txt

@@ -0,0 +1,20 @@
+add_library(
+	NostalgiaScene-Studio
+		studiomodule.cpp
+		sceneeditor-imgui.cpp
+		sceneeditor.cpp
+		sceneeditorview.cpp
+)
+
+target_link_libraries(
+	NostalgiaScene-Studio PUBLIC
+		NostalgiaScene
+		Studio
+)
+
+install(
+	TARGETS
+		NostalgiaScene-Studio
+	LIBRARY DESTINATION
+		${NOSTALGIA_DIST_MODULE}
+)

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

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2016 - 2023 Gary Talent (gary@drinkingtea.net). All rights reserved.
+ */
+
+#include <imgui.h>
+
+#include <keel/media.hpp>
+
+#include "sceneeditor-imgui.hpp"
+
+namespace nostalgia::scene {
+
+SceneEditorImGui::SceneEditorImGui(turbine::Context &ctx, ox::StringView path):
+	Editor(path),
+	m_ctx(ctx),
+	m_editor(m_ctx, path),
+	m_view(m_ctx, m_editor.scene()) {
+	setRequiresConstantRefresh(false);
+}
+
+void SceneEditorImGui::draw(turbine::Context&) noexcept {
+	auto const paneSize = ImGui::GetContentRegionAvail();
+	m_view.draw(ox::Size{static_cast<int>(paneSize.x), static_cast<int>(paneSize.y)});
+	auto &fb = m_view.framebuffer();
+	auto const srcH = static_cast<float>(fb.height) / static_cast<float>(fb.width);
+	auto const dstH = paneSize.y / paneSize.x;
+	float xScale{}, yScale{};
+	if (dstH > srcH) {
+		// crop off width
+		xScale = srcH / dstH;
+		yScale = 1;
+	} else {
+		auto const srcW = static_cast<float>(fb.width) / static_cast<float>(fb.height);
+		auto const dstW = (paneSize.x / paneSize.y);
+		xScale = 1;
+		yScale = srcW / dstW;
+	}
+	uintptr_t const buffId = fb.color.id;
+	ImGui::Image(
+		std::bit_cast<void*>(buffId),
+		paneSize,
+		ImVec2(0, 1),
+		ImVec2(xScale, 1 - yScale));
+}
+
+void SceneEditorImGui::onActivated() noexcept {
+	oxLogError(m_view.setupScene());
+}
+
+ox::Error SceneEditorImGui::saveItem() noexcept {
+	const auto sctx = applicationData<studio::StudioContext>(m_ctx);
+	oxReturnError(sctx->project->writeObj(itemPath(), m_editor.scene()));
+	oxReturnError(keelCtx(m_ctx).assetManager.setAsset(itemPath(), m_editor.scene()));
+	return {};
+}
+
+}

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

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2016 - 2023 Gary Talent (gary@drinkingtea.net). All rights reserved.
+ */
+
+#pragma once
+
+#include <studio/studio.hpp>
+
+#include <turbine/context.hpp>
+
+#include "sceneeditor.hpp"
+#include "sceneeditorview.hpp"
+
+namespace nostalgia::scene {
+
+class SceneEditorImGui: public studio::Editor {
+
+	private:
+		turbine::Context &m_ctx;
+		SceneEditor m_editor;
+		SceneEditorView m_view;
+
+	public:
+		SceneEditorImGui(turbine::Context &ctx, ox::StringView path);
+
+		void draw(turbine::Context&) noexcept final;
+
+		void onActivated() noexcept override;
+
+	protected:
+		ox::Error saveItem() noexcept final;
+
+};
+
+}

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

@@ -0,0 +1,16 @@
+/*
+ * Copyright 2016 - 2023 Gary Talent (gary@drinkingtea.net). All rights reserved.
+ */
+
+#include <keel/keel.hpp>
+
+#include "sceneeditor.hpp"
+
+namespace nostalgia::scene {
+
+SceneEditor::SceneEditor(turbine::Context &ctx, ox::CRStringView path):
+	m_ctx(ctx),
+	m_scene(*keel::readObj<SceneStatic>(keelCtx(m_ctx), path).unwrapThrow()) {
+}
+
+}

src/nostalgia/modules/scene/src/studio/sceneeditor.hpp

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2016 - 2023 Gary Talent (gary@drinkingtea.net). All rights reserved.
+ */
+
+#pragma once
+
+#include <turbine/context.hpp>
+
+#include <nostalgia/scene/scene.hpp>
+
+namespace nostalgia::scene {
+
+class SceneEditor {
+
+	private:
+		turbine::Context &m_ctx;
+		ox::String m_itemName;
+		ox::String m_itemPath;
+		SceneStatic m_scene;
+
+	public:
+		SceneEditor(turbine::Context &ctx, ox::CRStringView path);
+
+		[[nodiscard]]
+		SceneStatic const&scene() const noexcept {
+			return m_scene;
+		}
+
+	protected:
+		ox::Error saveItem() noexcept;
+
+};
+
+}

src/nostalgia/modules/scene/src/studio/sceneeditorview.cpp

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2016 - 2023 Gary Talent (gary@drinkingtea.net). All rights reserved.
+ */
+
+#include <nostalgia/core/gfx.hpp>
+
+#include "sceneeditorview.hpp"
+
+namespace nostalgia::scene {
+
+SceneEditorView::SceneEditorView(turbine::Context &tctx, SceneStatic const&sceneStatic):
+	m_cctx(core::init(tctx, {.glInstallDrawer = false}).unwrapThrow()),
+	m_sceneStatic(sceneStatic),
+	m_scene(m_sceneStatic) {
+}
+
+ox::Error SceneEditorView::setupScene() noexcept {
+	glutils::resizeInitFrameBuffer(m_frameBuffer, core::gl::drawSize(m_scale));
+	return m_scene.setupDisplay(*m_cctx);
+}
+
+void SceneEditorView::draw(ox::Size const&targetSz) noexcept {
+	auto const scaleSz = targetSz / core::gl::drawSize(1);
+	if (m_scaleSz != scaleSz) [[unlikely]] {
+		m_scale = ox::max(1, ox::max(scaleSz.width, scaleSz.height));
+		glutils::resizeInitFrameBuffer(m_frameBuffer, core::gl::drawSize(m_scale));
+	}
+	glutils::FrameBufferBind const frameBufferBind(m_frameBuffer);
+	core::gl::draw(*m_cctx, m_scale);
+}
+
+glutils::FrameBuffer const&SceneEditorView::framebuffer() const noexcept {
+	return m_frameBuffer;
+}
+
+}

src/nostalgia/modules/scene/src/studio/sceneeditorview.hpp

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2016 - 2023 Gary Talent (gary@drinkingtea.net). All rights reserved.
+ */
+
+#pragma once
+
+#include <glutils/glutils.hpp>
+
+#include <nostalgia/core/context.hpp>
+#include <nostalgia/core/gfx.hpp>
+#include <nostalgia/scene/scene.hpp>
+
+namespace nostalgia::scene {
+
+class SceneEditorView {
+
+	private:
+		core::ContextUPtr m_cctx;
+		SceneStatic const&m_sceneStatic;
+		Scene m_scene;
+		glutils::FrameBuffer m_frameBuffer;
+		int m_scale = 1;
+		ox::Size m_scaleSz = core::gl::drawSize(m_scale);
+
+	public:
+		SceneEditorView(turbine::Context &ctx, SceneStatic const&sceneStatic);
+
+		ox::Error setupScene() noexcept;
+
+		void draw(ox::Size const&targetSz) noexcept;
+
+		[[nodiscard]]
+		glutils::FrameBuffer const&framebuffer() const noexcept;
+
+};
+
+}

src/nostalgia/modules/scene/src/studio/studiomodule.cpp

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2016 - 2023 Gary Talent (gary@drinkingtea.net). All rights reserved.
+ */
+
+#include <studio/studio.hpp>
+
+#include "sceneeditor-imgui.hpp"
+
+namespace nostalgia::scene {
+
+constexpr ox::StringLiteral FileExt_nscn("nscn");
+
+class StudioModule: public studio::Module {
+	public:
+		ox::Vector<studio::EditorMaker> editors(turbine::Context &ctx) const noexcept override {
+			return {
+				 studio::editorMaker<SceneEditorImGui>(ctx, FileExt_nscn),
+			};
+		}
+		ox::Vector<ox::UPtr<studio::ItemMaker>> itemMakers(turbine::Context&) const noexcept override {
+			ox::Vector<ox::UPtr<studio::ItemMaker>> out;
+			return out;
+		}
+};
+
+static StudioModule const mod;
+const studio::Module *studioModule() noexcept {
+	return &mod;
+}
+
+}