[olympic/studio] Fix array bounds issue

This is necessary because OC array sizes are determined through the presence of the data.

.gitea/workflows/build.yaml

@@ -0,0 +1,19 @@
+name: Build
+run-name: ${{ gitea.actor }} build and test
+on: [push]
+
+jobs:
+  build:
+    runs-on: nostalgia
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v3
+      - run: make purge configure-debug
+      - run: make build
+      - run: make test
+      - run: make purge configure-asan
+      - run: make build
+      - run: make test
+      - run: make purge configure-release
+      - run: make build
+      - run: make test

.gitlab-ci.yml

@@ -1,24 +0,0 @@
-# This file is a template, and might need editing before it works on your project.
-# You can copy and paste this template into a new `.gitlab-ci.yml` file.
-# You should not add this template to an existing `.gitlab-ci.yml` file by using the `include:` keyword.
-#
-# To contribute improvements to CI/CD templates, please follow the Development guide at:
-# https://docs.gitlab.com/ee/development/cicd/templates.html
-# This specific template is located at:
-# https://gitlab.com/gitlab-org/gitlab/-/blob/master/lib/gitlab/ci/templates/C++.gitlab-ci.yml
-
-# use the official gcc image, based on debian
-# can use versions as well, like gcc:5.2
-# see https://hub.docker.com/_/gcc/
-
-image: gcc
-
-build:
-  stage: build
-  variables:
-    OX_NODEBUG: 1
-  before_script:
-     - apt update && apt -y install make cmake ninja-build pkg-config xorg-dev libgtk-3-dev python3 python3-mypy
-  script:
-    - make purge configure-release test install
-    - make purge configure-asan test install

Dockerfile

@@ -31,7 +31,6 @@ RUN dnf install -y clang \
                    python3-pip \
                    libglvnd-devel \
                    gtk3-devel
-RUN pip install conan
 
 ###############################################################################
 # Install devkitARM

deps/buildcore/scripts/setup-build.py

@@ -99,7 +99,9 @@ def main() -> int:
     if platform.system() == 'Windows':
         cmake_cmd.append('-A x64')
 
-    subprocess.run(cmake_cmd)
+    cmake_err = subprocess.run(cmake_cmd).returncode
+    if cmake_err != 0:
+        return cmake_err
 
     util.mkdir_p('dist')
     if int(args.current_build) != 0:

deps/ox/src/ox/oc/write.hpp

@@ -37,7 +37,7 @@ class OrganicClawWriter {
 		explicit OrganicClawWriter(Json::Value json, int unionIdx = -1) noexcept;
 
 		Error field(const char *key, const int8_t *val) noexcept {
-			if (*val) {
+			if (targetValid() && (*val || m_json.isArray())) {
 				value(key) = *val;
 			}
 			++m_fieldIt;
@@ -45,7 +45,7 @@ class OrganicClawWriter {
 		}
 
 		Error field(const char *key, const int16_t *val) noexcept {
-			if (*val) {
+			if (targetValid() && (*val || m_json.isArray())) {
 				value(key) = *val;
 			}
 			++m_fieldIt;
@@ -53,7 +53,7 @@ class OrganicClawWriter {
 		}
 
 		Error field(const char *key, const int32_t *val) noexcept {
-			if (*val) {
+			if (targetValid() && (*val || m_json.isArray())) {
 				value(key) = *val;
 			}
 			++m_fieldIt;
@@ -61,7 +61,7 @@ class OrganicClawWriter {
 		}
 
 		Error field(const char *key, const int64_t *val) noexcept {
-			if (*val) {
+			if (targetValid() && (*val || m_json.isArray())) {
 				value(key) = *val;
 			}
 			++m_fieldIt;
@@ -70,7 +70,7 @@ class OrganicClawWriter {
 
 
 		Error field(const char *key, const uint8_t *val) noexcept {
-			if (*val) {
+			if (targetValid() && (*val || m_json.isArray())) {
 				value(key) = *val;
 			}
 			++m_fieldIt;
@@ -78,7 +78,7 @@ class OrganicClawWriter {
 		}
 
 		Error field(const char *key, const uint16_t *val) noexcept {
-			if (targetValid() && *val) {
+			if (targetValid() && (*val || m_json.isArray())) {
 				value(key) = *val;
 			}
 			++m_fieldIt;
@@ -86,7 +86,7 @@ class OrganicClawWriter {
 		}
 
 		Error field(const char *key, const uint32_t *val) noexcept {
-			if (targetValid() && *val) {
+			if (targetValid() && (*val || m_json.isArray())) {
 				value(key) = *val;
 			}
 			++m_fieldIt;
@@ -94,15 +94,15 @@ class OrganicClawWriter {
 		}
 
 		Error field(const char *key, const uint64_t *val) noexcept {
-			if (targetValid() && *val) {
+			if (targetValid() && (*val || m_json.isArray())) {
 				value(key) = *val;
 			}
 			++m_fieldIt;
 			return OxError(0);
 		}
 
-		Error field(const char *key, const bool *val) noexcept {
+		Error field(char const*key, bool const*val) noexcept {
-			if (targetValid() && *val) {
+			if (targetValid() && (*val || m_json.isArray())) {
 				value(key) = *val;
 			}
 			++m_fieldIt;
@@ -110,10 +110,10 @@ class OrganicClawWriter {
 		}
 
 		template<typename U, bool force = true>
-		Error field(const char*, UnionView<U, force> val) noexcept;
+		Error field(char const*, UnionView<U, force> val) noexcept;
 
 		template<typename T>
-		Error field(const char *key, const HashMap<String, T> *val) noexcept {
+		Error field(char const*key, HashMap<String, T> const*val) noexcept {
 			if (targetValid()) {
 				const auto &keys = val->keys();
 				OrganicClawWriter w;
@@ -132,7 +132,7 @@ class OrganicClawWriter {
 		}
 
 		template<std::size_t L>
-		Error field(const char *key, const BString<L> *val) noexcept {
+		Error field(char const*key, BString<L> const*val) noexcept {
 			if (targetValid() && val->len()) {
 				value(key) = val->c_str();
 			}
@@ -141,7 +141,7 @@ class OrganicClawWriter {
 		}
 
 		template<std::size_t L>
-		Error field(const char *key, const BasicString<L> *val) noexcept {
+		Error field(char const*key, BasicString<L> const*val) noexcept {
 			if (targetValid() && val->len()) {
 				value(key) = val->c_str();
 			}
@@ -199,7 +199,7 @@ Error OrganicClawWriter::field(const char *key, const T *val, std::size_t len) n
 		OrganicClawWriter w((Json::Value(Json::arrayValue)));
 		ModelHandlerInterface<OrganicClawWriter, OpType::Write> handler{&w};
 		for (std::size_t i = 0; i < len; ++i) {
-			oxReturnError(handler.field("", &val[i]));
+			oxReturnError(handler.field({}, &val[i]));
 		}
 		value(key) = w.m_json;
 	}

deps/ox/src/ox/std/error.hpp

@@ -165,21 +165,7 @@ struct [[nodiscard]] Result {
 		return error == 0;
 	}
 
-	constexpr Error copyTo(type &val) const & noexcept {
+	constexpr Error copyTo(type &val) const& noexcept {
-		if (!error) [[likely]] {
-			val = value;
-		}
-		return error;
-	}
-
-	constexpr Error copyTo(type &val) const && noexcept {
-		if (!error) [[likely]] {
-			val = value;
-		}
-		return error;
-	}
-
-	constexpr Error copyTo(type &val) & noexcept {
 		if (!error) [[likely]] {
 			val = value;
 		}
@@ -269,7 +255,7 @@ struct [[nodiscard]] Result {
 	 * @param alt
 	 * @return value of Result or alt
 	 */
-	constexpr T orVal(T &&alt) & noexcept {
+	constexpr T or_value(T &&alt) const& noexcept {
 		if (error) {
 			return std::move(alt);
 		}
@@ -281,7 +267,7 @@ struct [[nodiscard]] Result {
 	 * @param alt
 	 * @return value of Result or alt
 	 */
-	constexpr T orVal(T &&alt) && noexcept {
+	constexpr T or_value(T &&alt) && noexcept {
 		if (error) {
 			return std::move(alt);
 		}
@@ -293,7 +279,7 @@ struct [[nodiscard]] Result {
 	 * @param alt
 	 * @return value of Result or alt
 	 */
-	constexpr T orVal(T const&alt) & noexcept {
+	constexpr T or_value(T const&alt) const& noexcept {
 		if (error) {
 			return alt;
 		}
@@ -305,7 +291,7 @@ struct [[nodiscard]] Result {
 	 * @param alt
 	 * @return value of Result or alt
 	 */
-	constexpr T orVal(T const&alt) && noexcept {
+	constexpr T or_value(T const&alt) && noexcept {
 		if (error) {
 			return alt;
 		}

deps/ox/src/ox/std/optional.hpp

@@ -64,6 +64,54 @@ class Optional {
 			return *m_ptr;
 		}
 
+		/**
+		 * Returns parameter alt if Result contains an error.
+		 * @param alt
+		 * @return value of Result or alt
+		 */
+		constexpr T or_value(T &&alt) const& noexcept {
+			if (!m_ptr) {
+				return std::move(alt);
+			}
+			return *m_ptr;
+		}
+
+		/**
+		 * Returns parameter alt if Result contains an error.
+		 * @param alt
+		 * @return value of Result or alt
+		 */
+		constexpr T or_value(T &&alt) && noexcept {
+			if (!m_ptr) {
+				return std::move(alt);
+			}
+			return std::move(*m_ptr);
+		}
+
+		/**
+		 * Returns parameter alt if Result contains an error.
+		 * @param alt
+		 * @return value of Result or alt
+		 */
+		constexpr T or_value(T const&alt) const& noexcept {
+			if (!m_ptr) {
+				return alt;
+			}
+			return *m_ptr;
+		}
+
+		/**
+		 * Returns parameter alt if Result contains an error.
+		 * @param alt
+		 * @return value of Result or alt
+		 */
+		constexpr T or_value(T const&alt) && noexcept {
+			if (!m_ptr) {
+				return alt;
+			}
+			return std::move(*m_ptr);
+		}
+
 		constexpr T &operator*() & noexcept {
 			return *m_ptr;
 		}

developer-handbook.md

@@ -20,14 +20,6 @@ All components have a platform indicator next to them:
     (-G) - GBA
     (P-) - PC
 
-* GlUtils - OpenGL helpers (P-)
-* Keel - asset management system (PG)
-* Turbine - platform abstraction and user I/O (PG)
-	* gba - GBA implementation (PG)
-	* glfw - GLFW implementation (P-)
-* Studio - where most of the studio code lives as library (P-)
-	* applib - used for per project studio executables
-	* modlib - used for studio modules to interact with studio
 * Nostalgia
   * modules
     * core - graphics system for Nostalgia (PG)
@@ -42,6 +34,15 @@ All components have a platform indicator next to them:
   * studio - makes the games (P-)
   * tools - command line tools (P-)
     * pack - packs a studio project directory into an OxFS file (P-)
+* Olympic
+    * Applib - Library for creating apps as libraries that injects Keel and Studio modules
+    * Keel - asset management system (PG)
+    * Studio - where most of the studio code lives as library (P-)
+        * applib - used for per project studio executables
+        * modlib - used for studio modules to interact with studio
+    * Turbine - platform abstraction and user I/O (PG)
+        * gba - GBA implementation (PG)
+        * glfw - GLFW implementation (P-)
 * deps - project dependencies
   * Ox - Library of things useful for portable bare metal and userland code. Not really that external...
     * clargs - Command Line Args processing (PG)
@@ -54,9 +55,19 @@ All components have a platform indicator next to them:
     * model - Data structure modelling (PG)
 	 * preloader - library for handling preloading of data (PG)
     * std - Standard-ish Library with a lot missing and some things added (PG)
+  * GlUtils - OpenGL helpers (P-)
   * teagba - GBA assembly startup code (mostly pulled from devkitPro under MPL
 	          2.0), and custom GBA hardware interop code (-G)
 
+## Platform Notes
+
+### GBA
+
+#### Graphics
+
+* Background Palette: 256 colors
+* Sprite Palette:     256 colors
+
 ## Code Base Conventions
 
 ### Formatting

sample_project/.nostalgia/type_descriptors/net.drinkingtea.nostalgia.core.TileSheet.SubSheet;4

@@ -0,0 +1,46 @@
+O1;net.drinkingtea.ox.TypeDescriptor;1;{
+	"fieldList" : 
+	[
+		{
+			"fieldName" : "id",
+			"typeId" : "B.int32;0"
+		},
+		{
+			"fieldName" : "name",
+			"typeId" : "net.drinkingtea.ox.BasicString#8#;1"
+		},
+		{
+			"fieldName" : "rows",
+			"typeId" : "B.int32;0"
+		},
+		{
+			"fieldName" : "columns",
+			"typeId" : "B.int32;0"
+		},
+		{
+			"fieldName" : "subsheets",
+			"subscriptLevels" : 1,
+			"subscriptStack" : 
+			[
+				{
+					"subscriptType" : 4
+				}
+			],
+			"typeId" : "net.drinkingtea.nostalgia.core.TileSheet.SubSheet;4"
+		},
+		{
+			"fieldName" : "pixels",
+			"subscriptLevels" : 1,
+			"subscriptStack" : 
+			[
+				{
+					"subscriptType" : 4
+				}
+			],
+			"typeId" : "B.uint8;0"
+		}
+	],
+	"primitiveType" : 5,
+	"typeName" : "net.drinkingtea.nostalgia.core.TileSheet.SubSheet",
+	"typeVersion" : 4
+}

sample_project/.nostalgia/type_descriptors/net.drinkingtea.nostalgia.core.TileSheet;4

@@ -0,0 +1,24 @@
+O1;net.drinkingtea.ox.TypeDescriptor;1;{
+	"fieldList" : 
+	[
+		{
+			"fieldName" : "bpp",
+			"typeId" : "B.int8;0"
+		},
+		{
+			"fieldName" : "idIt",
+			"typeId" : "B.int32;0"
+		},
+		{
+			"fieldName" : "defaultPalette",
+			"typeId" : "net.drinkingtea.ox.FileAddress;1"
+		},
+		{
+			"fieldName" : "subsheet",
+			"typeId" : "net.drinkingtea.nostalgia.core.TileSheet.SubSheet;4"
+		}
+	],
+	"primitiveType" : 5,
+	"typeName" : "net.drinkingtea.nostalgia.core.TileSheet",
+	"typeVersion" : 4
+}

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

@@ -43,6 +43,22 @@ oxModelBegin(Sprite)
 	oxModelField(priority)
 oxModelEnd()
 
+struct BgTile {
+	static constexpr auto TypeName = "net.drinkingtea.nostalgia.core.BgTile";
+	static constexpr auto TypeVersion = 1;
+	unsigned tileIdx = 0;
+	unsigned palBank = 0;
+	unsigned flipX = false;
+	unsigned flipY = false;
+};
+
+oxModelBegin(BgTile)
+	oxModelField(tileIdx)
+	oxModelField(palBank)
+	oxModelField(horizontalFlip)
+	oxModelField(verticalFlip)
+oxModelEnd()
+
 struct TileSheetSetEntrySection {
 	static constexpr auto TypeName = "net.drinkingtea.nostalgia.core.TileSheetSetEntrySection";
 	static constexpr auto TypeVersion = 1;
@@ -86,6 +102,7 @@ oxModelEnd()
 
 ox::Error loadBgPalette(
 		Context &ctx,
+		size_t palBank,
 		ox::FileAddress const&paletteAddr) noexcept;
 
 ox::Error loadSpritePalette(
@@ -101,7 +118,7 @@ ox::Error loadBgTileSheet(
 		Context &ctx,
 		unsigned cbb,
 		ox::FileAddress const&tilesheetAddr,
-		bool loadDefaultPalette = false) noexcept;
+		ox::Optional<unsigned> const&paletteBank = {}) noexcept;
 
 ox::Error loadSpriteTileSheet(
 		Context &ctx,
@@ -112,7 +129,9 @@ ox::Error loadSpriteTileSheet(
 		Context &ctx,
 		TileSheetSet const&set) noexcept;
 
-void setBgTile(Context &ctx, uint_t bgIdx, int column, int row, uint8_t tile) noexcept;
+void setBgTile(Context &ctx, uint_t bgIdx, int column, int row, unsigned tile, unsigned palBank = 0) noexcept;
+
+void setBgTile(Context &ctx, uint_t bgIdx, int column, int row, BgTile const&tile) noexcept;
 
 void clearBg(Context &ctx, uint_t bgIdx) noexcept;
 

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

@@ -61,7 +61,7 @@ struct TileSheetV2 {
 
 using SubSheetId = int32_t;
 
-struct TileSheet {
+struct TileSheetV3 {
 	using SubSheetIdx = ox::Vector<std::size_t, 4>;
 
 	struct SubSheet {
@@ -73,119 +73,20 @@ struct TileSheet {
 		int rows = 0;
 		ox::Vector<SubSheet> subsheets;
 		ox::Vector<uint8_t> pixels;
-
 		constexpr SubSheet() noexcept = default;
-		constexpr SubSheet(SubSheet const&other) noexcept = default;
+		inline SubSheet(
-		SubSheet(SubSheet &&other) noexcept;
-		SubSheet(
 				SubSheetId pId,
 				ox::CRStringView pName,
 				int pColumns,
 				int pRows,
-				int bpp) noexcept;
+				int bpp) noexcept:
-		SubSheet(
+				id(pId),
-				SubSheetId pId,
+				name(pName),
-				ox::CRStringView pName,
+				columns(pColumns),
-				int pColumns,
+				rows(pRows),
-				int pRows,
+				pixels(static_cast<std::size_t>(columns * rows * PixelsPerTile) / (bpp == 4 ? 2u : 1u)) {
-				ox::Vector<uint8_t> pPixels) noexcept;
-
-		constexpr SubSheet &operator=(const SubSheet &other) noexcept = default;
-
-		SubSheet &operator=(SubSheet &&other) noexcept;
-
-		[[nodiscard]]
-		std::size_t idx(ox::Point const&pt) const noexcept;
-
-		/**
-		 * Reads all pixels of this sheet or its children into the given pixel list
-		 * @param pixels
-		 */
-		void readPixelsTo(ox::Vector<uint8_t> *pPixels, int8_t pBpp) const noexcept;
-
-		/**
-		 * Reads all pixels of this sheet or its children into the given pixel list
-		 * @param pixels
-		 */
-		void readPixelsTo(ox::Vector<uint8_t> *pPixels) const noexcept;
-
-		[[nodiscard]]
-		constexpr std::size_t size() const noexcept {
-			return static_cast<std::size_t>(columns) * static_cast<std::size_t>(rows);
 		}
 
-		[[nodiscard]]
-		std::size_t unusedPixels() const noexcept;
-
-		[[nodiscard]]
-		uint8_t getPixel4Bpp(std::size_t idx) const noexcept;
-
-		[[nodiscard]]
-		uint8_t getPixel8Bpp(std::size_t idx) const noexcept;
-
-		[[nodiscard]]
-		uint8_t getPixel(int8_t pBpp, std::size_t idx) const noexcept;
-
-		[[nodiscard]]
-		uint8_t getPixel4Bpp(const ox::Point &pt) const noexcept;
-
-		[[nodiscard]]
-		uint8_t getPixel8Bpp(const ox::Point &pt) const noexcept;
-
-		[[nodiscard]]
-		uint8_t getPixel(int8_t pBpp, const ox::Point &pt) const noexcept;
-
-		constexpr auto walkPixels(int8_t pBpp, auto callback) const noexcept {
-			if (pBpp == 4) {
-				const auto pixelCnt = ox::min<std::size_t>(static_cast<std::size_t>(columns * rows * PixelsPerTile) / 2,
-				                                           pixels.size());
-				//oxAssert(pixels.size() == pixelCnt, "Pixel count does not match rows and columns");
-				for (std::size_t i = 0; i < pixelCnt; ++i) {
-					const auto colorIdx1 = static_cast<uint8_t>(pixels[i] & 0xF);
-					const auto colorIdx2 = static_cast<uint8_t>(pixels[i] >> 4);
-					callback(i * 2 + 0, colorIdx1);
-					callback(i * 2 + 1, colorIdx2);
-				}
-			} else {
-				const auto pixelCnt = ox::min<std::size_t>(
-						static_cast<std::size_t>(columns * rows * PixelsPerTile),
-						pixels.size());
-				for (std::size_t i = 0; i < pixelCnt; ++i) {
-					const auto p = pixels[i];
-					callback(i, p);
-				}
-			}
-		}
-
-		void setPixel(int8_t pBpp, uint64_t idx, uint8_t palIdx) noexcept;
-
-		void setPixel(int8_t pBpp, ox::Point const&pt, uint8_t palIdx) noexcept;
-
-		ox::Error setPixelCount(int8_t pBpp, std::size_t cnt) noexcept;
-
-		/**
-		 * Gets a count of the pixels in this sheet, and not that of its children.
-		 * @param pBpp bits per pixel, need for knowing how to count the pixels
-		 * @return a count of the pixels in this sheet
-		 */
-		[[nodiscard]]
-		unsigned pixelCnt(int8_t pBpp) const noexcept;
-
-		/**
-		 * Gets the offset in tiles of the desired subsheet.
-		 */
-		ox::Result<unsigned> getTileOffset(
-				ox::SpanView<ox::StringView> const&pNamePath,
-				int8_t pBpp,
-				std::size_t pIt = 0,
-				unsigned pCurrentTotal = 0) const noexcept;
-
-		ox::Result<SubSheetId> getIdFor(
-				ox::SpanView<ox::StringView> const&pNamePath,
-				std::size_t pIt = 0) const noexcept;
-
-		ox::Result<ox::StringView> getNameFor(SubSheetId pId) const noexcept;
-
 	};
 
 	static constexpr auto TypeName = "net.drinkingtea.nostalgia.core.TileSheet";
@@ -195,86 +96,185 @@ struct TileSheet {
 	ox::FileAddress defaultPalette;
 	SubSheet subsheet{0, "Root", 1, 1, bpp};
 
+};
+
+struct TileSheet {
+	using SubSheetIdx = ox::Vector<std::size_t, 4>;
+
+	struct SubSheet {
+		static constexpr auto TypeName = "net.drinkingtea.nostalgia.core.TileSheet.SubSheet";
+		static constexpr auto TypeVersion = 4;
+		SubSheetId id = 0;
+		ox::String name;
+		int columns = 0;
+		int rows = 0;
+		ox::Vector<SubSheet> subsheets;
+		ox::Vector<uint8_t> pixels;
+
+		constexpr SubSheet() noexcept = default;
+		inline SubSheet(
+				SubSheetId pId,
+				ox::CRStringView pName,
+				int pColumns,
+				int pRows,
+				int bpp) noexcept:
+				id(pId),
+				name(pName),
+				columns(pColumns),
+				rows(pRows),
+				pixels(static_cast<std::size_t>(columns * rows * PixelsPerTile) / (bpp == 4 ? 2u : 1u)) {
+		}
+		inline SubSheet(
+				SubSheetId pId,
+				ox::CRStringView pName,
+				int pColumns,
+				int pRows,
+				ox::Vector<uint8_t> pPixels) noexcept:
+				id(pId),
+				name(pName),
+				columns(pColumns),
+				rows(pRows),
+				pixels(std::move(pPixels)) {
+		}
+
+		[[nodiscard]]
+		constexpr std::size_t size() const noexcept {
+			return static_cast<std::size_t>(columns) * static_cast<std::size_t>(rows);
+		}
+
+	};
+
+	static constexpr auto TypeName = "net.drinkingtea.nostalgia.core.TileSheet";
+	static constexpr auto TypeVersion = 4;
+	int8_t bpp = 4;
+	SubSheetId idIt = 0;
+	ox::FileAddress defaultPalette;
+	SubSheet subsheet{0, "Root", 1, 1, bpp};
+
 	constexpr TileSheet() noexcept = default;
-	TileSheet(TileSheet const&other) noexcept = default;
-	inline TileSheet(TileSheet &&other) noexcept:
-		bpp(other.bpp),
-		idIt(other.idIt),
-		defaultPalette(std::move(other.defaultPalette)),
-		subsheet(std::move(other.subsheet)) {
-	}
-
-	TileSheet &operator=(TileSheet const&other) noexcept;
-
-	TileSheet &operator=(TileSheet &&other) noexcept;
-
-	[[nodiscard]]
-	SubSheetIdx validateSubSheetIdx(
-			SubSheetIdx const&pIdx,
-			std::size_t pIdxIt,
-			const SubSheet *pSubsheet) noexcept;
-
-	/**
-	 * validateSubSheetIdx takes a SubSheetIdx and moves the index to the
-	 * preceding or parent sheet if the current corresponding sheet does
-	 * not exist.
-	 * @param idx SubSheetIdx to validate and correct
-	 * @return a valid version of idx
-	 */
-	[[nodiscard]]
-	SubSheetIdx validateSubSheetIdx(const SubSheetIdx &idx) noexcept;
-
-	[[nodiscard]]
-	static SubSheet const&getSubSheet(
-			SubSheetIdx const&idx,
-			std::size_t idxIt,
-			const SubSheet *pSubsheet) noexcept;
-
-	[[nodiscard]]
-	static SubSheet &getSubSheet(
-			SubSheetIdx const&idx,
-			std::size_t idxIt,
-			SubSheet *pSubsheet) noexcept;
-
-	[[nodiscard]]
-	const SubSheet &getSubSheet(SubSheetIdx const&idx) const noexcept;
-
-	[[nodiscard]]
-	SubSheet &getSubSheet(SubSheetIdx const&idx) noexcept;
-
-	ox::Error addSubSheet(SubSheetIdx const&idx) noexcept;
-
-	[[nodiscard]]
-	static ox::Error rmSubSheet(
-			SubSheetIdx const&idx,
-			std::size_t idxIt,
-			SubSheet *pSubsheet) noexcept;
-
-	[[nodiscard]]
-	ox::Error rmSubSheet(SubSheetIdx const&idx) noexcept;
-
-	[[nodiscard]]
-	uint8_t getPixel4Bpp(
-			ox::Point const&pt,
-			SubSheetIdx const&subsheetIdx) const noexcept;
-
-	[[nodiscard]]
-	uint8_t getPixel8Bpp(
-			ox::Point const&pt,
-			SubSheetIdx const&subsheetIdx) const noexcept;
-
-	ox::Result<SubSheetId> getIdFor(ox::CRStringView path) const noexcept;
-
-	ox::Result<unsigned> getTileOffset(ox::CRStringView pNamePath) const noexcept;
-
-	ox::Result<ox::StringView> getNameFor(SubSheetId pId) const noexcept;
-
-	[[nodiscard]]
-	ox::Vector<uint8_t> pixels() const noexcept;
 
 };
 
-using TileSheetV3 = TileSheet;
+[[nodiscard]]
+std::size_t idx(TileSheet::SubSheet const&ss, ox::Point const&pt) noexcept;
+
+[[nodiscard]]
+uint8_t getPixel4Bpp(TileSheet::SubSheet const&ss, std::size_t idx) noexcept;
+
+[[nodiscard]]
+uint8_t getPixel8Bpp(TileSheet::SubSheet const&ss, std::size_t idx) noexcept;
+
+[[nodiscard]]
+uint8_t getPixel(TileSheet::SubSheet const&ss, int8_t pBpp, std::size_t idx) noexcept;
+
+[[nodiscard]]
+uint8_t getPixel4Bpp(TileSheet::SubSheet const&ss, ox::Point const&pt) noexcept;
+
+[[nodiscard]]
+uint8_t getPixel8Bpp(TileSheet::SubSheet const&ss, ox::Point const&pt) noexcept;
+
+[[nodiscard]]
+uint8_t getPixel(TileSheet::SubSheet const&ss, int8_t pBpp, ox::Point const&pt) noexcept;
+
+constexpr void walkPixels(TileSheet::SubSheet const&ss, int8_t pBpp, auto callback) noexcept {
+	if (pBpp == 4) {
+		const auto pixelCnt = ox::min<std::size_t>(
+				static_cast<std::size_t>(ss.columns * ss.rows * PixelsPerTile) / 2,
+				ss.pixels.size());
+		//oxAssert(pixels.size() == pixelCnt, "Pixel count does not match rows and columns");
+		for (std::size_t i = 0; i < pixelCnt; ++i) {
+			const auto colorIdx1 = static_cast<uint8_t>(ss.pixels[i] & 0xF);
+			const auto colorIdx2 = static_cast<uint8_t>(ss.pixels[i] >> 4);
+			callback(i * 2 + 0, colorIdx1);
+			callback(i * 2 + 1, colorIdx2);
+		}
+	} else {
+		const auto pixelCnt = ox::min<std::size_t>(
+				static_cast<std::size_t>(ss.columns * ss.rows * PixelsPerTile),
+				ss.pixels.size());
+		for (std::size_t i = 0; i < pixelCnt; ++i) {
+			const auto p = ss.pixels[i];
+			callback(i, p);
+		}
+	}
+}
+
+void setPixel(TileSheet::SubSheet &ss, int8_t pBpp, uint64_t idx, uint8_t palIdx) noexcept;
+
+void setPixel(TileSheet::SubSheet &ss, int8_t pBpp, ox::Point const&pt, uint8_t palIdx) noexcept;
+
+ox::Error setPixelCount(TileSheet::SubSheet &ss, int8_t pBpp, std::size_t cnt) noexcept;
+
+/**
+ * Gets a count of the pixels in this sheet, and not that of its children.
+ * @param pBpp bits per pixel, need for knowing how to count the pixels
+ * @return a count of the pixels in this sheet
+ */
+[[nodiscard]]
+unsigned pixelCnt(TileSheet::SubSheet const&ss, int8_t pBpp) noexcept;
+
+/**
+ * validateSubSheetIdx takes a SubSheetIdx and moves the index to the
+ * preceding or parent sheet if the current corresponding sheet does
+ * not exist.
+ * @param idx SubSheetIdx to validate and correct
+ * @return a valid version of idx
+ */
+[[nodiscard]]
+TileSheet::SubSheetIdx validateSubSheetIdx(TileSheet const&ts, TileSheet::SubSheetIdx const&idx) noexcept;
+
+[[nodiscard]]
+TileSheet::SubSheet const&getSubSheet(
+		TileSheet::SubSheetIdx const&idx,
+		std::size_t idxIt,
+		TileSheet::SubSheet const&pSubsheet) noexcept;
+
+[[nodiscard]]
+TileSheet::SubSheet &getSubSheet(
+		TileSheet::SubSheetIdx const&idx,
+		std::size_t idxIt,
+		TileSheet::SubSheet &pSubsheet) noexcept;
+
+[[nodiscard]]
+TileSheet::SubSheet const&getSubSheet(TileSheet const&ts, TileSheet::SubSheetIdx const&idx) noexcept;
+
+[[nodiscard]]
+TileSheet::SubSheet &getSubSheet(TileSheet &ts, TileSheet::SubSheetIdx const&idx) noexcept;
+
+ox::Error addSubSheet(TileSheet &ts, TileSheet::SubSheetIdx const&idx) noexcept;
+
+ox::Error rmSubSheet(
+		TileSheet &ts,
+		TileSheet::SubSheetIdx const&idx,
+		std::size_t idxIt,
+		TileSheet::SubSheet &pSubsheet) noexcept;
+
+ox::Error rmSubSheet(TileSheet &ts, TileSheet::SubSheetIdx const&idx) noexcept;
+
+[[nodiscard]]
+uint8_t getPixel4Bpp(
+		TileSheet const&ts,
+		ox::Point const&pt,
+		TileSheet::SubSheetIdx const&subsheetIdx) noexcept;
+
+[[nodiscard]]
+uint8_t getPixel8Bpp(
+		TileSheet const&ts,
+		ox::Point const&pt,
+		TileSheet::SubSheetIdx const&subsheetIdx) noexcept;
+
+ox::Result<SubSheetId> getIdFor(TileSheet const&ts, ox::CRStringView path) noexcept;
+
+ox::Result<unsigned> getTileOffset(TileSheet const&ts, ox::CRStringView pNamePath) noexcept;
+
+ox::Result<ox::StringView> getNameFor(TileSheet::SubSheet const&ss, SubSheetId pId) noexcept;
+
+ox::Result<ox::StringView> getNameFor(TileSheet const&ss, SubSheetId pId) noexcept;
+
+[[nodiscard]]
+ox::Vector<uint8_t> pixels(TileSheet &ts) noexcept;
+
+using TileSheetV4 = TileSheet;
 
 struct CompactTileSheet {
 	static constexpr auto TypeName = "net.drinkingtea.nostalgia.core.CompactTileSheet";
@@ -294,9 +294,9 @@ oxModelBegin(TileSheetV1)
 oxModelEnd()
 
 oxModelBegin(TileSheetV2::SubSheet)
-	oxModelField(name);
+	oxModelField(name)
-	oxModelField(rows);
+	oxModelField(rows)
-	oxModelField(columns);
+	oxModelField(columns)
 	oxModelField(subsheets)
 	oxModelField(pixels)
 oxModelEnd()
@@ -308,9 +308,9 @@ oxModelBegin(TileSheetV2)
 oxModelEnd()
 
 oxModelBegin(TileSheetV3::SubSheet)
-	oxModelField(name);
+	oxModelField(name)
-	oxModelField(rows);
+	oxModelField(rows)
-	oxModelField(columns);
+	oxModelField(columns)
 	oxModelField(subsheets)
 	oxModelField(pixels)
 oxModelEnd()
@@ -322,6 +322,22 @@ oxModelBegin(TileSheetV3)
 	oxModelField(subsheet)
 oxModelEnd()
 
+oxModelBegin(TileSheetV4::SubSheet)
+	oxModelField(id)
+	oxModelField(name)
+	oxModelField(rows)
+	oxModelField(columns)
+	oxModelField(subsheets)
+	oxModelField(pixels)
+oxModelEnd()
+
+oxModelBegin(TileSheetV4)
+	oxModelField(bpp)
+	oxModelField(idIt)
+	oxModelField(defaultPalette)
+	oxModelField(subsheet)
+oxModelEnd()
+
 oxModelBegin(CompactTileSheet)
 	oxModelField(bpp)
 	oxModelField(defaultPalette)

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

@@ -158,9 +158,10 @@ ox::Error initGfx(Context&, InitParams const&) noexcept {
 
 ox::Error loadBgPalette(
 		Context &ctx,
+		size_t palBank,
 		ox::FileAddress const&paletteAddr) noexcept {
 	auto &rom = ctx.rom();
-	GbaPaletteTarget const palTarget{.palette = MEM_BG_PALETTE};
+	GbaPaletteTarget const palTarget{.palette = MEM_BG_PALETTE + palBank * 16};
 	oxRequire(palStat, rom.stat(paletteAddr));
 	oxRequire(pal, rom.directAccess(paletteAddr));
 	oxReturnError(ox::readMC(pal, static_cast<std::size_t>(palStat.size), &palTarget));
@@ -189,11 +190,11 @@ static ox::Error loadTileSheetSet(
 		oxRequire(ts, rom.directAccess(entry.tilesheet));
 		unsigned tilesheetBpp{};
 		GbaTileMapTarget target{
-				.bpp = tilesheetBpp,
+			.bpp = tilesheetBpp,
-				.defaultPalette = {},
+			.defaultPalette = {},
-				.tileMap = tileMapTargetMem + tileWriteIdx,
+			.tileMap = tileMapTargetMem + tileWriteIdx,
-				.targetBpp = static_cast<unsigned>(set.bpp),
+			.targetBpp = static_cast<unsigned>(set.bpp),
-				.setEntry = &entry,
+			.setEntry = &entry,
 		};
 		oxReturnError(ox::readMC(ts, static_cast<std::size_t>(tsStat.size), &target));
 		tileWriteIdx += target.tileWriteIdx;
@@ -205,7 +206,7 @@ ox::Error loadBgTileSheet(
 		Context &ctx,
 		unsigned cbb,
 		ox::FileAddress const&tilesheetAddr,
-		bool loadDefaultPalette) noexcept {
+		ox::Optional<unsigned> const&paletteBank) noexcept {
 	auto &rom = ctx.rom();
 	oxRequire(tsStat, rom.stat(tilesheetAddr));
 	oxRequire(ts, rom.directAccess(tilesheetAddr));
@@ -222,8 +223,8 @@ ox::Error loadBgTileSheet(
 			teagba::bgSetBpp(bgCtl, bpp);
 		}
 	});
-	if (loadDefaultPalette && target.defaultPalette) {
+	if (paletteBank.has_value() && target.defaultPalette) {
-		oxReturnError(loadBgPalette(ctx, target.defaultPalette));
+		oxReturnError(loadBgPalette(ctx, *paletteBank, target.defaultPalette));
 	}
 	return {};
 }
@@ -283,9 +284,14 @@ ox::Error loadSpriteTileSheet(
 	return {};
 }
 
-void setBgTile(Context&, uint_t bgIdx, int column, int row, uint8_t tile) noexcept {
+void setBgTile(Context&, uint_t bgIdx, int column, int row, BgTile const&tile) noexcept {
-	const auto tileIdx = static_cast<std::size_t>(row * GbaTileColumns + column);
+	auto const tileIdx = static_cast<std::size_t>(row * GbaTileColumns + column);
-	MEM_BG_MAP[bgIdx][tileIdx] = tile;
+	// see Tonc 9.3
+	MEM_BG_MAP[bgIdx][tileIdx] =
+			static_cast<uint16_t>(tile.tileIdx & 0b1'1111'1111) |
+			static_cast<uint16_t>(tile.flipX << 0xa) |
+			static_cast<uint16_t>(tile.flipY << 0xb) |
+			static_cast<uint16_t>(tile.palBank << 0xc);
 }
 
 void clearBg(Context&, uint_t bgIdx) noexcept {
@@ -311,6 +317,11 @@ void setBgStatus(Context&, unsigned bg, bool status) noexcept {
 	REG_DISPCTL = REG_DISPCTL | ((REG_DISPCTL & ~mask) | mask);
 }
 
+void setBgBpp(Context&, unsigned bgIdx, unsigned bpp) noexcept {
+	auto &bgCtl = regBgCtl(bgIdx);
+	teagba::bgSetBpp(bgCtl, bpp);
+}
+
 void setBgCbb(Context &ctx, unsigned bgIdx, unsigned cbb) noexcept {
 	auto &bgCtl = regBgCtl(bgIdx);
 	const auto &cbbData = ctx.cbbData[cbb];

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

@@ -137,13 +137,20 @@ constexpr ox::Array<char, 128> charMap = {
 	50, // ~
 };
 
+void setBgTile(Context &ctx, uint_t bgIdx, int column, int row, unsigned tile, unsigned palBank) noexcept {
+	setBgTile(ctx, bgIdx, column, row, {
+		.tileIdx = tile,
+		.palBank = palBank,
+	});
+}
+
 ox::Error initConsole(Context &ctx) noexcept {
 	constexpr ox::FileAddress TilesheetAddr = ox::StringLiteral("/TileSheets/Charset.ng");
 	constexpr ox::FileAddress PaletteAddr = ox::StringLiteral("/Palettes/Charset.npal");
 	setBgStatus(ctx, 0b0001);
 	setBgCbb(ctx, 0, 0);
 	oxReturnError(loadBgTileSheet(ctx, 0, TilesheetAddr));
-	return loadBgPalette(ctx, PaletteAddr);
+	return loadBgPalette(ctx, 0, PaletteAddr);
 }
 
 void puts(

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

@@ -18,7 +18,8 @@ class KeelModule: public keel::Module {
 	private:
 		NostalgiaPaletteToPaletteConverter m_nostalgiaPaletteToPaletteConverter;
 		TileSheetV1ToTileSheetV2Converter m_tileSheetV1ToTileSheetV2Converter;
-		TileSheetV2ToTileSheetV3Converter m_tileSheetV2ToTileSheetConverter;
+		TileSheetV2ToTileSheetV3Converter m_tileSheetV2ToTileSheetV3Converter;
+		TileSheetV3ToTileSheetV4Converter m_tileSheetV3ToTileSheetV4Converter;
 		TileSheetToCompactTileSheetConverter m_tileSheetToCompactTileSheetConverter;
 
 	public:
@@ -32,18 +33,20 @@ class KeelModule: public keel::Module {
 			return {
 				keel::generateTypeDesc<TileSheetV1>,
 				keel::generateTypeDesc<TileSheetV2>,
-				keel::generateTypeDesc<TileSheet>,
+				keel::generateTypeDesc<TileSheetV3>,
+				keel::generateTypeDesc<TileSheetV4>,
 				keel::generateTypeDesc<CompactTileSheet>,
 				keel::generateTypeDesc<Palette>,
 			};
 		}
 
 		[[nodiscard]]
-		ox::Vector<const keel::BaseConverter*> converters() const noexcept final {
+		ox::Vector<keel::BaseConverter const*> converters() const noexcept final {
 			return {
 				&m_nostalgiaPaletteToPaletteConverter,
 				&m_tileSheetV1ToTileSheetV2Converter,
-				&m_tileSheetV2ToTileSheetConverter,
+				&m_tileSheetV2ToTileSheetV3Converter,
+				&m_tileSheetV3ToTileSheetV4Converter,
 				&m_tileSheetToCompactTileSheetConverter,
 			};
 		}
@@ -54,11 +57,12 @@ class KeelModule: public keel::Module {
 				// convert tilesheets to CompactTileSheets
 				[](keel::Context &ctx, ox::Buffer &buff) -> ox::Error {
 					oxRequire(hdr, keel::readAssetHeader(buff));
-					const auto typeId = ox::buildTypeId(
+					auto const typeId = ox::buildTypeId(
 							hdr.clawHdr.typeName, hdr.clawHdr.typeVersion, hdr.clawHdr.typeParams);
 					if (typeId == ox::buildTypeId<TileSheetV1>() ||
-						 typeId == ox::buildTypeId<TileSheetV2>() ||
+					    typeId == ox::buildTypeId<TileSheetV2>() ||
-						 typeId == ox::buildTypeId<TileSheet>()) {
+					    typeId == ox::buildTypeId<TileSheetV3>() ||
+					    typeId == ox::buildTypeId<TileSheetV4>()) {
 						oxReturnError(keel::convertBuffToBuff<core::CompactTileSheet>(
 								ctx, buff, ox::ClawFormat::Metal).moveTo(buff));
 					}

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

@@ -53,13 +53,41 @@ ox::Error TileSheetV2ToTileSheetV3Converter::convert(
 	return {};
 }
 
+
+void TileSheetV3ToTileSheetV4Converter::convertSubsheet(
+		TileSheetV3::SubSheet &src,
+		TileSheetV4::SubSheet &dst,
+		SubSheetId &idIt) noexcept {
+	dst.id      = idIt;
+	dst.name    = std::move(src.name);
+	dst.columns = src.columns;
+	dst.rows    = src.rows;
+	dst.pixels  = std::move(src.pixels);
+	++idIt;
+	dst.subsheets.resize(src.subsheets.size());
+	for (auto i = 0u; i < src.subsheets.size(); ++i) {
+		convertSubsheet(src.subsheets[i], dst.subsheets[i], idIt);
+	}
+}
+
+ox::Error TileSheetV3ToTileSheetV4Converter::convert(
+		keel::Context&,
+		TileSheetV3 &src,
+		TileSheetV4 &dst) const noexcept {
+	dst.bpp            = src.bpp;
+	dst.idIt           = src.idIt;
+	dst.defaultPalette = std::move(src.defaultPalette);
+	convertSubsheet(src.subsheet, dst.subsheet, dst.idIt);
+	return {};
+}
+
 ox::Error TileSheetToCompactTileSheetConverter::convert(
 		keel::Context&,
 		TileSheet &src,
 		CompactTileSheet &dst) const noexcept {
 	dst.bpp            = src.bpp;
 	dst.defaultPalette = std::move(src.defaultPalette);
-	dst.pixels         = src.pixels();
+	dst.pixels         = pixels(src);
 	return {};
 }
 

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

@@ -25,11 +25,19 @@ class TileSheetV1ToTileSheetV2Converter: public keel::Converter<TileSheetV1, Til
 };
 
 class TileSheetV2ToTileSheetV3Converter: public keel::Converter<TileSheetV2, TileSheetV3> {
+		static void convertSubsheet(
+				TileSheetV2::SubSheet &src,
+				TileSheetV3::SubSheet &dst,
+				SubSheetId &idIt) noexcept;
+		ox::Error convert(keel::Context&, TileSheetV2 &src, TileSheetV3 &dst) const noexcept final;
+};
+
+class TileSheetV3ToTileSheetV4Converter: public keel::Converter<TileSheetV3, TileSheetV4> {
 	static void convertSubsheet(
-			TileSheetV2::SubSheet &src,
+			TileSheetV3::SubSheet &src,
-			TileSheetV3::SubSheet &dst,
+			TileSheetV4::SubSheet &dst,
 			SubSheetId &idIt) noexcept;
-	ox::Error convert(keel::Context&, TileSheetV2 &src, TileSheetV3 &dst) const noexcept final;
+	ox::Error convert(keel::Context&, TileSheetV3 &src, TileSheetV4 &dst) const noexcept final;
 };
 
 class TileSheetToCompactTileSheetConverter: public keel::Converter<TileSheet, CompactTileSheet> {

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

@@ -24,6 +24,7 @@ class Context {
 		ox::Array<renderer::CBB, 4> cbbs;
 		renderer::SpriteBlockset spriteBlocks;
 		ox::Array<Sprite, 128> spriteStates;
+		ox::Array<GLfloat, 1024> bgPalette;
 		ox::Array<renderer::Background, 4> backgrounds;
 		renderer::Drawer drawer;
 		uint_t spriteCount = 0;

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

@@ -35,7 +35,9 @@ constexpr ox::CStringView bgvshadTmpl = R"glsl(
 	in vec2 vTexCoord;
 	in vec3 vPosition;
 	in float vTileIdx;
+	in float vPalOffset;
 	out vec2 fTexCoord;
+	out float fPalOffset;
 	uniform float vXScale;
 	uniform float vTileHeight;
 	uniform float vBgIdx;
@@ -49,17 +51,19 @@ constexpr ox::CStringView bgvshadTmpl = R"glsl(
 		fTexCoord = vec2(
 			vTexCoord.x,
 			vTexCoord.y * vTileHeight + vTileIdx * vTileHeight);
+		fPalOffset = vPalOffset;
 	})glsl";
 
 constexpr ox::CStringView bgfshadTmpl = R"glsl(
 	{}
 	out vec4 outColor;
+	in float fPalOffset;
 	in vec2 fTexCoord;
 	uniform sampler2D image;
 	uniform vec2 fSrcImgSz;
 	uniform vec4 fPalette[256];
 	void main() {
-		outColor = fPalette[int(texture(image, fTexCoord).rgb.r * 256)];
+		outColor = fPalette[int(texture(image, fTexCoord).rgb.r * 256) + int(fPalOffset)];
 		//outColor = vec4(0.0, 0.7, 1.0, 1.0);
 		if (outColor.a == 0) {
 			discard;
@@ -147,6 +151,9 @@ static void setTileBufferObject(
 		float y,
 		float textureTileIdx,
 		float priority,
+		float palOffset,
+		bool flipX,
+		bool flipY,
 		float *vbo,
 		GLuint *ebo) noexcept {
 	// don't worry, this memcpy gets optimized to something much more ideal
@@ -157,11 +164,15 @@ static void setTileBufferObject(
 	x -= 1.0f;
 	y += 1.0f - ymod;
 	auto const prif = priority * PriorityScale;
+	float const L = flipX ? 1 : 0;
+	float const R = flipX ? 0 : 1;
+	float const T = flipY ? 1 : 0;
+	float const B = flipY ? 0 : 1;
 	ox::Array<float, BgVertexVboLength> const vertices {
-			       x,        y, prif, 0, 1, textureTileIdx, // bottom left
+			       x,        y, prif, L, B, textureTileIdx, palOffset, // bottom left
-			x + xmod,        y, prif, 1, 1, textureTileIdx, // bottom right
+			x + xmod,        y, prif, R, B, textureTileIdx, palOffset, // bottom right
-			x + xmod, y + ymod, prif, 1, 0, textureTileIdx, // top right
+			x + xmod, y + ymod, prif, R, T, textureTileIdx, palOffset, // top right
-			       x, y + ymod, prif, 0, 0, textureTileIdx, // top left
+			       x, y + ymod, prif, L, T, textureTileIdx, palOffset, // top left
 	};
 	memcpy(vbo, vertices.data(), sizeof(vertices));
 	ox::Array<GLuint, BgVertexEboLength> const elms {
@@ -191,6 +202,9 @@ static void initBackgroundBufferObjects(glutils::BufferSet &bs) noexcept {
 				static_cast<float>(y),
 				0,
 				0,
+				0,
+				false,
+				false,
 				vbo,
 				ebo);
 		}
@@ -252,6 +266,11 @@ static void initBackgroundBufferset(
 	glVertexAttribPointer(
 			heightMultAttr, 1, GL_FLOAT, GL_FALSE, BgVertexVboRowLength * sizeof(float),
 			std::bit_cast<void*>(uintptr_t{5 * sizeof(float)}));
+	auto const palBankAttr = static_cast<GLuint>(glGetAttribLocation(shader, "vPalOffset"));
+	glEnableVertexAttribArray(palBankAttr);
+	glVertexAttribPointer(
+			palBankAttr, 1, GL_FLOAT, GL_FALSE, BgVertexVboRowLength * sizeof(float),
+			std::bit_cast<void*>(uintptr_t{6 * sizeof(float)}));
 }
 
 static glutils::GLTexture createTexture(
@@ -337,18 +356,19 @@ static void drawSprites(Context &ctx, ox::Size const&renderSz) noexcept {
 }
 
 static void loadPalette(
+		ox::Array<GLfloat, 1024> &palette,
+		size_t palOffset,
 		GLuint shaderPgrm,
 		Palette const&pal) noexcept {
 	static constexpr std::size_t ColorCnt = 256;
-	ox::Array<GLfloat, ColorCnt * 4> palette{};
+	for (auto i = palOffset; auto const c : pal.colors) {
-	for (auto i = 0u; const auto c : pal.colors) {
 		palette[i++] = redf(c);
 		palette[i++] = greenf(c);
 		palette[i++] = bluef(c);
 		palette[i++] = 255;
 	}
 	// make first color transparent
-	palette[3] = 0;
+	palette[palOffset + 3] = 0;
 	glUseProgram(shaderPgrm);
 	const auto uniformPalette = static_cast<GLint>(glGetUniformLocation(shaderPgrm, "fPalette"));
 	glUniform4fv(uniformPalette, ColorCnt, palette.data());
@@ -488,10 +508,11 @@ static ox::Result<TileSheetData> normalizeTileSheet(
 
 ox::Error loadBgPalette(
 		Context &ctx,
+		size_t palBank,
 		ox::FileAddress const&paletteAddr) noexcept {
 	auto &kctx = keelCtx(ctx.turbineCtx);
 	oxRequire(palette, readObj<Palette>(kctx, paletteAddr));
-	renderer::loadPalette(ctx.bgShader, *palette);
+	renderer::loadPalette(ctx.bgPalette, palBank * 16 * 4, ctx.bgShader, *palette);
 	return {};
 }
 
@@ -500,7 +521,8 @@ ox::Error loadSpritePalette(
 		ox::FileAddress const&paletteAddr) noexcept {
 	auto &kctx = keelCtx(ctx.turbineCtx);
 	oxRequire(palette, readObj<Palette>(kctx, paletteAddr));
-	renderer::loadPalette(ctx.spriteShader, *palette);
+	ox::Array<GLfloat, 1024> pal;
+	renderer::loadPalette(pal, 0, ctx.spriteShader, *palette);
 	return {};
 }
 
@@ -529,14 +551,14 @@ ox::Error loadBgTileSheet(
 		Context &ctx,
 		uint_t cbb,
 		ox::FileAddress const&tilesheetAddr,
-		bool loadDefaultPalette) noexcept {
+		ox::Optional<unsigned> const&paletteBank) noexcept {
 	auto &kctx = keelCtx(ctx.turbineCtx);
 	oxRequire(tilesheet, readObj<CompactTileSheet>(kctx, tilesheetAddr));
 	oxRequire(tsd, normalizeTileSheet(*tilesheet));
 	oxTracef("nostalgia.core.gfx.gl", "loadBgTexture: { cbbIdx: {}, w: {}, h: {} }", cbb, tsd.width, tsd.height);
 	ctx.cbbs[cbb].tex = renderer::createTexture(tsd.width, tsd.height, tsd.pixels.data());
-	if (loadDefaultPalette) {
+	if (paletteBank.has_value() && tilesheet->defaultPalette) {
-		oxReturnError(loadBgPalette(ctx, tilesheet->defaultPalette));
+		oxReturnError(loadBgPalette(ctx, *paletteBank, tilesheet->defaultPalette));
 	}
 	return {};
 }
@@ -578,11 +600,11 @@ void setBgTile(
 		uint_t bgIdx,
 		int column,
 		int row,
-		uint8_t tile) noexcept {
+		BgTile const&tile) noexcept {
 	oxTracef(
 			"nostalgia.core.gfx.setBgTile",
-			"bgIdx: {}, column: {}, row: {}, tile: {}",
+			"bgIdx: {}, column: {}, row: {}, tile: {}, palBank: {}",
-			bgIdx, column, row, tile);
+			bgIdx, column, row, tile.tileIdx, tile.palBank);
 	const auto z = static_cast<uint_t>(bgIdx);
 	const auto y = static_cast<uint_t>(row);
 	const auto x = static_cast<uint_t>(column);
@@ -595,8 +617,11 @@ void setBgTile(
 			static_cast<uint_t>(i * renderer::BgVertexVboRows),
 			static_cast<float>(x),
 			static_cast<float>(y),
-			static_cast<float>(tile),
+			static_cast<float>(tile.tileIdx),
 			bg.priority,
+			static_cast<float>(tile.palBank * 16),
+			tile.flipX,
+			tile.flipY,
 			vbo,
 			ebo);
 	cbb.updated = true;
@@ -628,10 +653,12 @@ bool bgStatus(Context &ctx, uint_t bg) noexcept {
 	return ctx.backgrounds[bg].enabled;
 }
 
-void setBgStatus(Context &ctx, uint_t bg, bool status) noexcept {
+void setBgStatus(Context&ctx, uint_t bg, bool status) noexcept {
 	ctx.backgrounds[bg].enabled = status;
 }
 
+void setBgBpp(Context&, unsigned, unsigned) noexcept {}
+
 void setBgCbb(Context &ctx, uint_t bgIdx, uint_t cbbIdx) noexcept {
 	auto &bg = ctx.backgrounds[bgIdx];
 	bg.cbbIdx = cbbIdx;

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

@@ -18,7 +18,7 @@ constexpr uint64_t TileRows = 128;
 constexpr uint64_t TileColumns = 128;
 constexpr uint64_t TileCount = TileRows * TileColumns;
 constexpr uint64_t BgVertexVboRows = 4;
-constexpr uint64_t BgVertexVboRowLength = 6;
+constexpr uint64_t BgVertexVboRowLength = 7;
 constexpr uint64_t BgVertexVboLength = BgVertexVboRows * BgVertexVboRowLength;
 constexpr uint64_t BgVertexEboLength = 6;
 constexpr uint64_t SpriteVertexVboRows = 4;

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

@@ -10,7 +10,7 @@ AddSubSheetCommand::AddSubSheetCommand(
 		TileSheet &img,
 		TileSheet::SubSheetIdx parentIdx) noexcept:
 		m_img(img), m_parentIdx(std::move(parentIdx)) {
-	auto &parent = m_img.getSubSheet(m_parentIdx);
+	auto &parent = getSubSheet(m_img, m_parentIdx);
 	if (!parent.subsheets.empty()) {
 		auto idx = m_parentIdx;
 		idx.emplace_back(parent.subsheets.size());
@@ -25,7 +25,7 @@ AddSubSheetCommand::AddSubSheetCommand(
 }
 
 void AddSubSheetCommand::redo() noexcept {
-	auto &parent = m_img.getSubSheet(m_parentIdx);
+	auto &parent = getSubSheet(m_img, m_parentIdx);
 	if (m_addedSheets.size() < 2) {
 		auto i = parent.subsheets.size();
 		parent.subsheets.emplace_back(m_img.idIt++, ox::sfmt("Subsheet {}", i), 1, 1, m_img.bpp);
@@ -38,7 +38,7 @@ void AddSubSheetCommand::redo() noexcept {
 }
 
 void AddSubSheetCommand::undo() noexcept {
-	auto &parent = m_img.getSubSheet(m_parentIdx);
+	auto &parent = getSubSheet(m_img, m_parentIdx);
 	if (parent.subsheets.size() == 2) {
 		auto s = parent.subsheets[0];
 		parent.rows = s.rows;
@@ -47,7 +47,7 @@ void AddSubSheetCommand::undo() noexcept {
 		parent.subsheets.clear();
 	} else {
 		for (auto idx = m_addedSheets.rbegin(); idx != m_addedSheets.rend(); ++idx) {
-			oxLogError(m_img.rmSubSheet(*idx));
+			oxLogError(rmSubSheet(m_img, *idx));
 		}
 	}
 }

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

@@ -31,27 +31,27 @@ CutPasteCommand::CutPasteCommand(
 		m_commandId(commandId),
 		m_img(img),
 		m_subSheetIdx(std::move(subSheetIdx)) {
-	const auto &subsheet = m_img.getSubSheet(m_subSheetIdx);
+	const auto &subsheet = getSubSheet(m_img, m_subSheetIdx);
 	for (const auto &p : cb.pixels()) {
 		const auto dstPt = p.pt + dstStart;
 		if (dstPt.x <= dstEnd.x && dstPt.y <= dstEnd.y) {
-			const auto idx = subsheet.idx(dstPt);
+			const auto idx = core::idx(subsheet, dstPt);
-			m_changes.emplace_back(static_cast<uint32_t>(idx), p.colorIdx, subsheet.getPixel(m_img.bpp, idx));
+			m_changes.emplace_back(static_cast<uint32_t>(idx), p.colorIdx, getPixel(subsheet, m_img.bpp, idx));
 		}
 	}
 }
 
 void CutPasteCommand::redo() noexcept {
-	auto &subsheet = m_img.getSubSheet(m_subSheetIdx);
+	auto &subsheet = getSubSheet(m_img, m_subSheetIdx);
 	for (const auto &c : m_changes) {
-		subsheet.setPixel(m_img.bpp, c.idx, static_cast<uint8_t>(c.newPalIdx));
+		setPixel(subsheet, m_img.bpp, c.idx, static_cast<uint8_t>(c.newPalIdx));
 	}
 }
 
 void CutPasteCommand::undo() noexcept {
-	auto &subsheet = m_img.getSubSheet(m_subSheetIdx);
+	auto &subsheet = getSubSheet(m_img, m_subSheetIdx);
 	for (const auto &c : m_changes) {
-		subsheet.setPixel(m_img.bpp, c.idx, static_cast<uint8_t>(c.oldPalIdx));
+		setPixel(subsheet, m_img.bpp, c.idx, static_cast<uint8_t>(c.oldPalIdx));
 	}
 }
 

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

@@ -19,7 +19,7 @@ core::DeleteTilesCommand::DeleteTilesCommand(
 	m_deletedPixels.resize(m_deleteSz);
 	// copy pixels to be erased
 	{
-		auto &s = m_img.getSubSheet(m_idx);
+		auto &s = getSubSheet(m_img, m_idx);
 		auto &p = s.pixels;
 		auto dst = m_deletedPixels.data();
 		auto src = p.data() + m_deletePos;
@@ -29,7 +29,7 @@ core::DeleteTilesCommand::DeleteTilesCommand(
 }
 
 void core::DeleteTilesCommand::redo() noexcept {
-	auto &s = m_img.getSubSheet(m_idx);
+	auto &s = getSubSheet(m_img, m_idx);
 	auto &p = s.pixels;
 	auto srcPos = m_deletePos + m_deleteSz;
 	const auto src = p.data() + srcPos;
@@ -40,7 +40,7 @@ void core::DeleteTilesCommand::redo() noexcept {
 }
 
 void DeleteTilesCommand::undo() noexcept {
-	auto &s = m_img.getSubSheet(m_idx);
+	auto &s = getSubSheet(m_img, m_idx);
 	auto &p = s.pixels;
 	const auto src = p.data() + m_deletePos;
 	const auto dst1 = p.data() + m_deletePos + m_deleteSz;

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

@@ -14,8 +14,8 @@ DrawCommand::DrawCommand(
 		m_img(img),
 		m_subSheetIdx(std::move(subSheetIdx)),
 		m_palIdx(palIdx) {
-	auto &subsheet = m_img.getSubSheet(m_subSheetIdx);
+	auto &subsheet = getSubSheet(m_img, m_subSheetIdx);
-	m_changes.emplace_back(static_cast<uint32_t>(idx), subsheet.getPixel(m_img.bpp, idx));
+	m_changes.emplace_back(static_cast<uint32_t>(idx), getPixel(subsheet, m_img.bpp, idx));
 }
 
 DrawCommand::DrawCommand(
@@ -26,22 +26,22 @@ DrawCommand::DrawCommand(
 		m_img(img),
 		m_subSheetIdx(std::move(subSheetIdx)),
 		m_palIdx(palIdx) {
-	auto &subsheet = m_img.getSubSheet(m_subSheetIdx);
+	auto &subsheet = getSubSheet(m_img, m_subSheetIdx);
 	for (const auto idx : idxList) {
-		m_changes.emplace_back(static_cast<uint32_t>(idx), subsheet.getPixel(m_img.bpp, idx));
+		m_changes.emplace_back(static_cast<uint32_t>(idx), getPixel(subsheet, m_img.bpp, idx));
 	}
 }
 
 bool DrawCommand::append(std::size_t idx) noexcept {
-	auto &subsheet = m_img.getSubSheet(m_subSheetIdx);
+	auto &subsheet = getSubSheet(m_img, m_subSheetIdx);
-	if (m_changes.back().value->idx != idx && subsheet.getPixel(m_img.bpp, idx) != m_palIdx) {
+	if (m_changes.back().value->idx != idx && getPixel(subsheet, m_img.bpp, idx) != m_palIdx) {
 		// duplicate entries are bad
 		auto existing = ox::find_if(m_changes.cbegin(), m_changes.cend(), [idx](const auto &c) {
 			return c.idx == idx;
 		});
 		if (existing == m_changes.cend()) {
-			m_changes.emplace_back(static_cast<uint32_t>(idx), subsheet.getPixel(m_img.bpp, idx));
+			m_changes.emplace_back(static_cast<uint32_t>(idx), getPixel(subsheet, m_img.bpp, idx));
-			subsheet.setPixel(m_img.bpp, idx, static_cast<uint8_t>(m_palIdx));
+			setPixel(subsheet, m_img.bpp, idx, static_cast<uint8_t>(m_palIdx));
 			return true;
 		}
 	}
@@ -57,16 +57,16 @@ bool DrawCommand::append(const ox::Vector<std::size_t> &idxList) noexcept {
 }
 
 void DrawCommand::redo() noexcept {
-	auto &subsheet = m_img.getSubSheet(m_subSheetIdx);
+	auto &subsheet = getSubSheet(m_img, m_subSheetIdx);
 	for (const auto &c : m_changes) {
-		subsheet.setPixel(m_img.bpp, c.idx, static_cast<uint8_t>(m_palIdx));
+		setPixel(subsheet, m_img.bpp, c.idx, static_cast<uint8_t>(m_palIdx));
 	}
 }
 
 void DrawCommand::undo() noexcept {
-	auto &subsheet = m_img.getSubSheet(m_subSheetIdx);
+	auto &subsheet = getSubSheet(m_img, m_subSheetIdx);
 	for (const auto &c : m_changes) {
-		subsheet.setPixel(m_img.bpp, c.idx, static_cast<uint8_t>(c.oldPalIdx));
+		setPixel(subsheet, m_img.bpp, c.idx, static_cast<uint8_t>(c.oldPalIdx));
 	}
 }
 

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

@@ -19,7 +19,7 @@ core::InsertTilesCommand::InsertTilesCommand(
 	m_deletedPixels.resize(m_insertCnt);
 	// copy pixels to be erased
 	{
-		auto &s = m_img.getSubSheet(m_idx);
+		auto &s = getSubSheet(m_img, m_idx);
 		auto &p = s.pixels;
 		auto dst = m_deletedPixels.data();
 		auto src = p.data() + p.size() - m_insertCnt;
@@ -29,7 +29,7 @@ core::InsertTilesCommand::InsertTilesCommand(
 }
 
 void InsertTilesCommand::redo() noexcept {
-	auto &s = m_img.getSubSheet(m_idx);
+	auto &s = getSubSheet(m_img, m_idx);
 	auto &p = s.pixels;
 	auto dstPos = m_insertPos + m_insertCnt;
 	const auto dst = p.data() + dstPos;
@@ -39,7 +39,7 @@ void InsertTilesCommand::redo() noexcept {
 }
 
 void InsertTilesCommand::undo() noexcept {
-	auto &s = m_img.getSubSheet(m_idx);
+	auto &s = getSubSheet(m_img, m_idx);
 	auto &p = s.pixels;
 	const auto srcIdx = m_insertPos + m_insertCnt;
 	const auto src = p.data() + srcIdx;

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

@@ -11,17 +11,17 @@ core::RmSubSheetCommand::RmSubSheetCommand(TileSheet &img, TileSheet::SubSheetId
 		m_idx(std::move(idx)),
 		m_parentIdx(m_idx) {
 	m_parentIdx.pop_back();
-	auto &parent = m_img.getSubSheet(m_parentIdx);
+	auto &parent = getSubSheet(m_img, m_parentIdx);
 	m_sheet = parent.subsheets[*m_idx.back().value];
 }
 
 void RmSubSheetCommand::redo() noexcept {
-	auto &parent = m_img.getSubSheet(m_parentIdx);
+	auto &parent = getSubSheet(m_img, m_parentIdx);
 	oxLogError(parent.subsheets.erase(*m_idx.back().value).error);
 }
 
 void RmSubSheetCommand::undo() noexcept {
-	auto &parent = m_img.getSubSheet(m_parentIdx);
+	auto &parent = getSubSheet(m_img, m_parentIdx);
 	auto i = *m_idx.back().value;
 	parent.subsheets.insert(i, m_sheet);
 }

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

@@ -14,22 +14,22 @@ core::UpdateSubSheetCommand::UpdateSubSheetCommand(
 		int rows) noexcept:
 		m_img(img),
 		m_idx(std::move(idx)),
-		m_sheet(m_img.getSubSheet(m_idx)),
+		m_sheet(getSubSheet(m_img, m_idx)),
 		m_newName(std::move(name)),
 		m_newCols(cols),
 		m_newRows(rows) {
 }
 
 void UpdateSubSheetCommand::redo() noexcept {
-	auto &sheet = m_img.getSubSheet(m_idx);
+	auto &sheet = getSubSheet(m_img, m_idx);
 	sheet.name = m_newName;
 	sheet.columns = m_newCols;
 	sheet.rows = m_newRows;
-	oxLogError(sheet.setPixelCount(m_img.bpp, static_cast<std::size_t>(PixelsPerTile * m_newCols * m_newRows)));
+	oxLogError(setPixelCount(sheet, m_img.bpp, static_cast<std::size_t>(PixelsPerTile * m_newCols * m_newRows)));
 }
 
 void UpdateSubSheetCommand::undo() noexcept {
-	auto &sheet = m_img.getSubSheet(m_idx);
+	auto &sheet = getSubSheet(m_img, m_idx);
 	sheet = m_sheet;
 }
 

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

@@ -191,7 +191,7 @@ void TileSheetEditorImGui::draw(turbine::Context&) noexcept {
 			ImGui::SameLine();
 			if (ImGui::Button("-", btnSize)) {
 				const auto &activeSubsheetIdx = m_model.activeSubSheetIdx();
-				if (activeSubsheetIdx.size() > 0) {
+				if (!activeSubsheetIdx.empty()) {
 					m_model.rmSubsheet(activeSubsheetIdx);
 				}
 			}
@@ -205,12 +205,13 @@ void TileSheetEditorImGui::draw(turbine::Context&) noexcept {
 			}
 			TileSheet::SubSheetIdx path;
 			static constexpr auto flags = ImGuiTableFlags_RowBg | ImGuiTableFlags_NoBordersInBody;
-			if (ImGui::BeginTable("Subsheets", 3, flags)) {
+			if (ImGui::BeginTable("Subsheets", 4, flags)) {
 				ImGui::TableSetupColumn("Subsheet", ImGuiTableColumnFlags_NoHide);
+				ImGui::TableSetupColumn("ID", ImGuiTableColumnFlags_WidthFixed, 25);
 				ImGui::TableSetupColumn("Columns", ImGuiTableColumnFlags_WidthFixed, 50);
 				ImGui::TableSetupColumn("Rows", ImGuiTableColumnFlags_WidthFixed, 50);
 				ImGui::TableHeadersRow();
-				drawSubsheetSelector(&m_view.img().subsheet, &path);
+				drawSubsheetSelector(m_view.img().subsheet, path);
 				ImGui::EndTable();
 			}
 		}
@@ -221,31 +222,34 @@ void TileSheetEditorImGui::draw(turbine::Context&) noexcept {
 	m_exportMenu.draw();
 }
 
-void TileSheetEditorImGui::drawSubsheetSelector(TileSheet::SubSheet *subsheet, TileSheet::SubSheetIdx *path) {
+void TileSheetEditorImGui::drawSubsheetSelector(TileSheet::SubSheet &subsheet, TileSheet::SubSheetIdx &path) {
+	constexpr auto indentReduce = 14;
 	ImGui::TableNextRow(0, 5);
 	using Str = ox::BasicString<100>;
-	auto pathStr = ox::join<Str>("##", *path).value;
+	auto pathStr = ox::join<Str>("##", path).value;
-	auto lbl = ox::sfmt<Str>("{}##{}", subsheet->name, pathStr);
+	auto lbl = ox::sfmt<Str>("{}##{}", subsheet.name, pathStr);
-	const auto rowSelected = *path == m_model.activeSubSheetIdx();
+	const auto rowSelected = path == m_model.activeSubSheetIdx();
 	const auto flags = ImGuiTreeNodeFlags_SpanFullWidth
 	                 | ImGuiTreeNodeFlags_OpenOnArrow
 	                 | ImGuiTreeNodeFlags_DefaultOpen
-	                 | (subsheet->subsheets.empty() ? ImGuiTreeNodeFlags_Leaf : 0)
+	                 | (subsheet.subsheets.empty() ? ImGuiTreeNodeFlags_Leaf : 0)
 	                 | (rowSelected ? ImGuiTreeNodeFlags_Selected : 0);
 	ImGui::TableNextColumn();
 	const auto open = ImGui::TreeNodeEx(lbl.c_str(), flags);
 	ImGui::SameLine();
 	if (ImGui::IsItemClicked()) {
-		m_model.setActiveSubsheet(*path);
+		m_model.setActiveSubsheet(path);
 	}
 	if (ImGui::IsMouseDoubleClicked(0) && ImGui::IsItemHovered()) {
 		showSubsheetEditor();
 	}
-	if (subsheet->subsheets.empty()) {
+	ImGui::TableNextColumn();
+	ImGui::Text("%d", subsheet.id);
+	if (subsheet.subsheets.empty()) {
 		ImGui::TableNextColumn();
-		ImGui::Text("%d", subsheet->columns);
+		ImGui::Text("%d", subsheet.columns);
 		ImGui::TableNextColumn();
-		ImGui::Text("%d", subsheet->rows);
+		ImGui::Text("%d", subsheet.rows);
 	} else {
 		ImGui::TableNextColumn();
 		ImGui::Text("--");
@@ -253,12 +257,14 @@ void TileSheetEditorImGui::drawSubsheetSelector(TileSheet::SubSheet *subsheet, T
 		ImGui::Text("--");
 	}
 	if (open) {
-		for (auto i = 0ul; auto &child : subsheet->subsheets) {
+		for (auto i = 0ul; auto &child : subsheet.subsheets) {
-			path->push_back(i);
+			path.push_back(i);
 			ImGui::PushID(static_cast<int>(i));
-			drawSubsheetSelector(&child, path);
+			ImGui::Indent(-indentReduce);
+			drawSubsheetSelector(child, path);
+			ImGui::Indent(indentReduce);
 			ImGui::PopID();
-			path->pop_back();
+			path.pop_back();
 			++i;
 		}
 		ImGui::TreePop();

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

@@ -83,7 +83,7 @@ class TileSheetEditorImGui: public studio::Editor {
 
 		void draw(turbine::Context&) noexcept override;
 
-		void drawSubsheetSelector(TileSheet::SubSheet*, TileSheet::SubSheetIdx *path);
+		void drawSubsheetSelector(TileSheet::SubSheet&, TileSheet::SubSheetIdx &path);
 
 		[[nodiscard]]
 		static ox::Vec2 clickPos(ImVec2 const&winPos, ox::Vec2 clickPos) noexcept;

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

@@ -47,8 +47,8 @@ void TileSheetEditorModel::cut() {
 	for (int y = m_selectionBounds.y; y <= m_selectionBounds.y2(); ++y) {
 		for (int x = m_selectionBounds.x; x <= m_selectionBounds.x2(); ++x) {
 			auto pt = ox::Point(x, y);
-			const auto idx = s->idx(pt);
+			const auto idx = core::idx(*s, pt);
-			const auto c = s->getPixel(m_img.bpp, idx);
+			const auto c = getPixel(*s, m_img.bpp, idx);
 			pt.x -= m_selectionBounds.x;
 			pt.y -= m_selectionBounds.y;
 			cb->addPixel(pt, c);
@@ -67,8 +67,8 @@ void TileSheetEditorModel::copy() {
 		for (int x = m_selectionBounds.x; x <= m_selectionBounds.x2(); ++x) {
 			auto pt = ox::Point(x, y);
 			const auto s = activeSubSheet();
-			const auto idx = s->idx(pt);
+			const auto idx = core::idx(*s, pt);
-			const auto c = s->getPixel(m_img.bpp, idx);
+			const auto c = getPixel(*s, m_img.bpp, idx);
 			pt.x -= m_selectionBounds.x;
 			pt.y -= m_selectionBounds.y;
 			cb->addPixel(pt, c);
@@ -115,14 +115,14 @@ ox::Error TileSheetEditorModel::setPalette(ox::StringView path) noexcept {
 }
 
 void TileSheetEditorModel::drawCommand(ox::Point const&pt, std::size_t palIdx) noexcept {
-	const auto &activeSubSheet = m_img.getSubSheet(m_activeSubsSheetIdx);
+	const auto &activeSubSheet = getSubSheet(m_img, m_activeSubsSheetIdx);
 	if (pt.x >= activeSubSheet.columns * TileWidth || pt.y >= activeSubSheet.rows * TileHeight) {
 		return;
 	}
-	const auto idx = activeSubSheet.idx(pt);
+	const auto idx = core::idx(activeSubSheet, pt);
 	if (m_ongoingDrawCommand) {
 		m_updated = m_updated || m_ongoingDrawCommand->append(idx);
-	} else if (activeSubSheet.getPixel(m_img.bpp, idx) != palIdx) {
+	} else if (getPixel(activeSubSheet, m_img.bpp, idx) != palIdx) {
 		pushCommand(ox::make<DrawCommand>(m_img, m_activeSubsSheetIdx, idx, static_cast<int>(palIdx)));
 	}
 }
@@ -158,16 +158,16 @@ void TileSheetEditorModel::setActiveSubsheet(TileSheet::SubSheetIdx const&idx) n
 }
 
 void TileSheetEditorModel::fill(ox::Point const&pt, int palIdx) noexcept {
-	const auto &s = m_img.getSubSheet(m_activeSubsSheetIdx);
+	const auto &s = getSubSheet(m_img, m_activeSubsSheetIdx);
 	// build idx list
 	ox::Array<bool, PixelsPerTile> updateMap = {};
-	const auto oldColor = s.getPixel(m_img.bpp, pt);
+	const auto oldColor = getPixel(s, m_img.bpp, pt);
 	if (pt.x >= s.columns * TileWidth || pt.y >= s.rows * TileHeight) {
 		return;
 	}
 	getFillPixels(updateMap.data(), pt, oldColor);
 	ox::Vector<std::size_t> idxList;
-	auto i = s.idx(pt) / PixelsPerTile * PixelsPerTile;
+	auto i = core::idx(s, pt) / PixelsPerTile * PixelsPerTile;
 	for (auto u : updateMap) {
 		if (u) {
 			idxList.emplace_back(i);
@@ -177,7 +177,7 @@ void TileSheetEditorModel::fill(ox::Point const&pt, int palIdx) noexcept {
 	// do updates to sheet
 	if (m_ongoingDrawCommand) {
 		m_updated = m_updated || m_ongoingDrawCommand->append(idxList);
-	} else if (s.getPixel(m_img.bpp, pt) != palIdx) {
+	} else if (getPixel(s, m_img.bpp, pt) != palIdx) {
 		pushCommand(ox::make<DrawCommand>(m_img, m_activeSubsSheetIdx, idxList, palIdx));
 	}
 }
@@ -213,7 +213,7 @@ bool TileSheetEditorModel::updated() const noexcept {
 	return m_updated;
 }
 
-ox::Error TileSheetEditorModel::markUpdatedCmdId(const studio::UndoCommand *cmd) noexcept {
+ox::Error TileSheetEditorModel::markUpdatedCmdId(studio::UndoCommand const*cmd) noexcept {
 	m_updated = true;
 	const auto cmdId = cmd->commandId();
 	if (static_cast<CommandId>(cmdId) == CommandId::PaletteChange) {
@@ -221,7 +221,7 @@ ox::Error TileSheetEditorModel::markUpdatedCmdId(const studio::UndoCommand *cmd)
 		paletteChanged.emit();
 	}
 	auto tsCmd = dynamic_cast<const TileSheetCommand*>(cmd);
-	auto idx = m_img.validateSubSheetIdx(tsCmd->subsheetIdx());
+	auto idx = validateSubSheetIdx(m_img, tsCmd->subsheetIdx());
 	if (idx != m_activeSubsSheetIdx) {
 		setActiveSubsheet(idx);
 	}
@@ -267,16 +267,16 @@ void TileSheetEditorModel::getFillPixels(bool *pixels, ox::Point const&pt, int o
 	const auto tile = tileIdx(pt);
 	// mark pixels to update
 	pixels[idx % PixelsPerTile] = true;
-	if (!pixels[leftIdx % PixelsPerTile] && tile == tileIdx(leftPt) && activeSubSheet.getPixel(m_img.bpp, leftIdx) == oldColor) {
+	if (!pixels[leftIdx % PixelsPerTile] && tile == tileIdx(leftPt) && getPixel(activeSubSheet, m_img.bpp, leftIdx) == oldColor) {
 		getFillPixels(pixels, leftPt, oldColor);
 	}
-	if (!pixels[rightIdx % PixelsPerTile] && tile == tileIdx(rightPt) && activeSubSheet.getPixel(m_img.bpp, rightIdx) == oldColor) {
+	if (!pixels[rightIdx % PixelsPerTile] && tile == tileIdx(rightPt) && getPixel(activeSubSheet, m_img.bpp, rightIdx) == oldColor) {
 		getFillPixels(pixels, rightPt, oldColor);
 	}
-	if (!pixels[topIdx % PixelsPerTile] && tile == tileIdx(topPt) && activeSubSheet.getPixel(m_img.bpp, topIdx) == oldColor) {
+	if (!pixels[topIdx % PixelsPerTile] && tile == tileIdx(topPt) && getPixel(activeSubSheet, m_img.bpp, topIdx) == oldColor) {
 		getFillPixels(pixels, topPt, oldColor);
 	}
-	if (!pixels[bottomIdx % PixelsPerTile] && tile == tileIdx(bottomPt) && activeSubSheet.getPixel(m_img.bpp, bottomIdx) == oldColor) {
+	if (!pixels[bottomIdx % PixelsPerTile] && tile == tileIdx(bottomPt) && getPixel(activeSubSheet, m_img.bpp, bottomIdx) == oldColor) {
 		getFillPixels(pixels, bottomPt, oldColor);
 	}
 }

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

@@ -79,13 +79,13 @@ class TileSheetEditorModel: public ox::SignalHandler {
 
 		[[nodiscard]]
 		const TileSheet::SubSheet *activeSubSheet() const noexcept {
-			auto &activeSubSheet = m_img.getSubSheet(m_activeSubsSheetIdx);
+			auto &activeSubSheet = getSubSheet(m_img, m_activeSubsSheetIdx);
 			return &activeSubSheet;
 		}
 
 		[[nodiscard]]
 		TileSheet::SubSheet *activeSubSheet() noexcept {
-			auto &activeSubSheet = m_img.getSubSheet(m_activeSubsSheetIdx);
+			auto &activeSubSheet = getSubSheet(m_img, m_activeSubsSheetIdx);
 			return &activeSubSheet;
 		}
 
@@ -105,7 +105,7 @@ class TileSheetEditorModel: public ox::SignalHandler {
 		[[nodiscard]]
 		bool updated() const noexcept;
 
-		ox::Error markUpdatedCmdId(const studio::UndoCommand *cmd) noexcept;
+		ox::Error markUpdatedCmdId(studio::UndoCommand const*cmd) noexcept;
 
 		ox::Error markUpdated() noexcept;
 
@@ -118,10 +118,9 @@ class TileSheetEditorModel: public ox::SignalHandler {
 
 		bool pixelSelected(std::size_t idx) const noexcept;
 
-	protected:
+	private:
 		void getFillPixels(bool *pixels, ox::Point const&pt, int oldColor) const noexcept;
 
-	private:
 		void pushCommand(studio::UndoCommand *cmd) noexcept;
 
 };

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

@@ -13,7 +13,7 @@ namespace nostalgia::core {
 
 TileSheetEditorView::TileSheetEditorView(turbine::Context &ctx, ox::StringView path, studio::UndoStack &undoStack):
 	m_model(ctx, path, undoStack),
-	m_pixelsDrawer(&m_model) {
+	m_pixelsDrawer(m_model) {
 	// build shaders
 	oxThrowError(m_pixelsDrawer.buildShader());
 	oxThrowError(m_pixelGridDrawer.buildShader());

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

@@ -9,7 +9,7 @@
 
 namespace nostalgia::core {
 
-TileSheetPixels::TileSheetPixels(TileSheetEditorModel *model) noexcept: m_model(model) {
+TileSheetPixels::TileSheetPixels(TileSheetEditorModel &model) noexcept: m_model(model) {
 }
 
 void TileSheetPixels::setPixelSizeMod(float sm) noexcept {
@@ -94,15 +94,15 @@ void TileSheetPixels::setPixelBufferObject(
 
 void TileSheetPixels::setBufferObjects(ox::Vec2 const&paneSize) noexcept {
 	// set buffer lengths
-	const auto subSheet = m_model->activeSubSheet();
+	const auto subSheet = m_model.activeSubSheet();
-	const auto pal = m_model->pal();
+	const auto pal = m_model.pal();
 	const auto width = subSheet->columns * TileWidth;
 	const auto height = subSheet->rows * TileHeight;
 	const auto pixels = static_cast<unsigned>(width * height);
 	m_bufferSet.vertices.resize(pixels * VertexVboLength);
 	m_bufferSet.elements.resize(pixels * VertexEboLength);
 	// set pixels
-	subSheet->walkPixels(m_model->img().bpp, [&](std::size_t i, uint8_t p) {
+	walkPixels(*subSheet, m_model.img().bpp, [&](std::size_t i, uint8_t p) {
 		auto color = pal->color(p);
 		const auto pt = idxToPt(static_cast<int>(i), subSheet->columns);
 		const auto fx = static_cast<float>(pt.x);
@@ -115,7 +115,7 @@ void TileSheetPixels::setBufferObjects(ox::Vec2 const&paneSize) noexcept {
 		if (i * VertexEboLength + VertexEboLength > m_bufferSet.elements.size()) {
 			return;
 		}
-		if (m_model->pixelSelected(i)) {
+		if (m_model.pixelSelected(i)) {
 			const auto r = red16(color) / 2;
 			const auto g = (green16(color) + 20) / 2;
 			const auto b = (blue16(color) + 31) / 2;

src/nostalgia/modules/core/src/studio/tilesheeteditor/tilesheetpixels.hpp

@@ -43,10 +43,10 @@ class TileSheetPixels {
 		float m_pixelSizeMod = 1;
 		glutils::GLProgram m_shader;
 		glutils::BufferSet m_bufferSet;
-		const class TileSheetEditorModel *m_model = nullptr;
+		const class TileSheetEditorModel &m_model;
 
 	public:
-		explicit TileSheetPixels(class TileSheetEditorModel *model) noexcept;
+		explicit TileSheetPixels(class TileSheetEditorModel &model) noexcept;
 
 		void setPixelSizeMod(float sm) noexcept;
 

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

@@ -10,133 +10,47 @@
 
 namespace nostalgia::core {
 
-TileSheet::SubSheet::SubSheet(SubSheet &&other) noexcept:
+std::size_t idx(TileSheet::SubSheet const&ss, ox::Point const&pt) noexcept {
-	id       (other.id),
+	return ptToIdx(pt, ss.columns);
-	name     (std::move(other.name)),
-	columns  (other.columns),
-	rows     (other.rows),
-	subsheets(std::move(other.subsheets)),
-	pixels   (std::move(other.pixels)) {
-	other.name = "";
-	other.columns = {};
-	other.rows = {};
 }
 
-TileSheet::SubSheet::SubSheet(
+uint8_t getPixel4Bpp(TileSheet::SubSheet const&ss, std::size_t idx) noexcept {
-		SubSheetId pId,
-		ox::CRStringView pName,
-		int pColumns,
-		int pRows,
-		int bpp) noexcept:
-	id(pId),
-	name(pName),
-	columns(pColumns),
-	rows(pRows),
-	pixels(static_cast<std::size_t>(columns * rows * PixelsPerTile) / (bpp == 4 ? 2u : 1u)) {
-}
-
-TileSheet::SubSheet::SubSheet(
-		SubSheetId pId,
-		ox::CRStringView pName,
-		int pColumns,
-		int pRows,
-		ox::Vector<uint8_t> pPixels) noexcept:
-	id(pId),
-	name(pName),
-	columns(pColumns),
-	rows(pRows),
-	pixels(std::move(pPixels)) {
-}
-
-TileSheet::SubSheet &TileSheet::SubSheet::operator=(TileSheet::SubSheet &&other) noexcept {
-	name      = std::move(other.name);
-	columns   = other.columns;
-	rows      = other.rows;
-	subsheets = std::move(other.subsheets);
-	pixels    = std::move(other.pixels);
-	return *this;
-}
-
-std::size_t TileSheet::SubSheet::idx(ox::Point const&pt) const noexcept {
-	return ptToIdx(pt, columns);
-}
-
-void TileSheet::SubSheet::readPixelsTo(ox::Vector<uint8_t> *pPixels, int8_t pBpp) const noexcept {
-	if (!subsheets.empty()) {
-		for (auto &s: subsheets) {
-			s.readPixelsTo(pPixels);
-		}
-	} else {
-		if (pBpp == 4) {
-			for (auto p: this->pixels) {
-				pPixels->emplace_back(static_cast<uint8_t>(p & 0b1111));
-				pPixels->emplace_back(static_cast<uint8_t>(p >> 4));
-			}
-		} else {
-			for (auto p: this->pixels) {
-				pPixels->emplace_back(p);
-			}
-		}
-	}
-}
-
-void TileSheet::SubSheet::readPixelsTo(ox::Vector<uint8_t> *pPixels) const noexcept {
-	if (!subsheets.empty()) {
-		for (auto &s: subsheets) {
-			s.readPixelsTo(pPixels);
-		}
-	} else {
-		for (auto p : this->pixels) {
-			pPixels->emplace_back(p);
-		}
-	}
-}
-
-std::size_t TileSheet::SubSheet::unusedPixels() const noexcept {
-	std::size_t childrenSize = 0;
-	for (auto &c : subsheets) {
-		childrenSize += c.size();
-	}
-	return size() - childrenSize;
-}
-
-uint8_t TileSheet::SubSheet::getPixel4Bpp(std::size_t idx) const noexcept {
 	if (idx & 1) {
-		return this->pixels[idx / 2] >> 4;
+		return ss.pixels[idx / 2] >> 4;
 	} else {
-		return this->pixels[idx / 2] & 0b0000'1111;
+		return ss.pixels[idx / 2] & 0b0000'1111;
 	}
 }
 
-uint8_t TileSheet::SubSheet::getPixel8Bpp(std::size_t idx) const noexcept {
+uint8_t getPixel8Bpp(TileSheet::SubSheet const&ss, std::size_t idx) noexcept {
-	return this->pixels[idx];
+	return ss.pixels[idx];
 }
 
-uint8_t TileSheet::SubSheet::getPixel(int8_t pBpp, std::size_t idx) const noexcept {
+uint8_t getPixel(TileSheet::SubSheet const&ss, int8_t pBpp, std::size_t idx) noexcept {
 	if (pBpp == 4) {
-		return getPixel4Bpp(idx);
+		return getPixel4Bpp(ss, idx);
 	} else {
-		return getPixel8Bpp(idx);
+		return getPixel8Bpp(ss, idx);
 	}
 }
 
-uint8_t TileSheet::SubSheet::getPixel4Bpp(ox::Point const&pt) const noexcept {
+uint8_t getPixel4Bpp(TileSheet::SubSheet const&ss, ox::Point const&pt) noexcept {
-	const auto idx = ptToIdx(pt, columns);
+	const auto idx = ptToIdx(pt, ss.columns);
-	return getPixel4Bpp(idx);
+	return getPixel4Bpp(ss, idx);
 }
 
-uint8_t TileSheet::SubSheet::getPixel8Bpp(ox::Point const&pt) const noexcept {
+uint8_t getPixel8Bpp(TileSheet::SubSheet const&ss, ox::Point const&pt) noexcept {
-	const auto idx = ptToIdx(pt, columns);
+	const auto idx = ptToIdx(pt, ss.columns);
-	return getPixel8Bpp(idx);
+	return getPixel8Bpp(ss, idx);
 }
 
-uint8_t TileSheet::SubSheet::getPixel(int8_t pBpp, ox::Point const&pt) const noexcept {
+uint8_t getPixel(TileSheet::SubSheet const&ss, int8_t pBpp, ox::Point const&pt) noexcept {
-	const auto idx = ptToIdx(pt, columns);
+	const auto idx = ptToIdx(pt, ss.columns);
-	return getPixel(pBpp, idx);
+	return getPixel(ss, pBpp, idx);
 }
 
-void TileSheet::SubSheet::setPixel(int8_t pBpp, uint64_t idx, uint8_t palIdx) noexcept {
+void setPixel(TileSheet::SubSheet &ss, int8_t pBpp, uint64_t idx, uint8_t palIdx) noexcept {
-	auto &pixel = this->pixels[static_cast<std::size_t>(idx / 2)];
+	auto &pixel = ss.pixels[static_cast<std::size_t>(idx / 2)];
 	if (pBpp == 4) {
 		if (idx & 1) {
 			pixel = static_cast<uint8_t>((pixel & 0b0000'1111) | (palIdx << 4));
@@ -148,72 +62,35 @@ void TileSheet::SubSheet::setPixel(int8_t pBpp, uint64_t idx, uint8_t palIdx) no
 	}
 }
 
-void TileSheet::SubSheet::setPixel(int8_t pBpp, ox::Point const&pt, uint8_t palIdx) noexcept {
+void setPixel(TileSheet::SubSheet &ss, int8_t pBpp, ox::Point const&pt, uint8_t palIdx) noexcept {
-	const auto idx = ptToIdx(pt, columns);
+	const auto idx = ptToIdx(pt, ss.columns);
-	setPixel(pBpp, idx, palIdx);
+	setPixel(ss, pBpp, idx, palIdx);
 }
 
-ox::Error TileSheet::SubSheet::setPixelCount(int8_t pBpp, std::size_t cnt) noexcept {
+ox::Error setPixelCount(TileSheet::SubSheet &ss, int8_t pBpp, std::size_t cnt) noexcept {
 	switch (pBpp) {
 		case 4:
-			pixels.resize(cnt / 2);
+			ss.pixels.resize(cnt / 2);
 			return OxError(0);
 		case 8:
-			pixels.resize(cnt);
+			ss.pixels.resize(cnt);
 			return OxError(0);
 		default:
 			return OxError(1, "Invalid pBpp used for TileSheet::SubSheet::setPixelCount");
 	}
 }
 
-unsigned TileSheet::SubSheet::pixelCnt(int8_t pBpp) const noexcept {
+unsigned pixelCnt(TileSheet::SubSheet const&ss, int8_t pBpp) noexcept {
-	const auto pixelsSize = static_cast<unsigned>(pixels.size());
+	const auto pixelsSize = static_cast<unsigned>(ss.pixels.size());
 	return pBpp == 4 ? pixelsSize * 2 : pixelsSize;
 }
 
-ox::Result<unsigned> TileSheet::SubSheet::getTileOffset(
+ox::Result<ox::StringView> getNameFor(TileSheet::SubSheet const&ss, SubSheetId pId) noexcept {
-		ox::SpanView<ox::StringView> const&pNamePath,
+	if (ss.id == pId) {
-		int8_t pBpp,
+		return ox::StringView(ss.name);
-		std::size_t pIt,
-		unsigned pCurrentTotal) const noexcept {
-	// pIt == pNamePath.size() - 1 && 
-	if (name != pNamePath[pIt]) {
-		return OxError(2, "Wrong branch");
 	}
-	if (pIt == pNamePath.size() - 1) {
+	for (const auto &sub : ss.subsheets) {
-		return pCurrentTotal;
+		const auto [name, err] = getNameFor(sub, pId);
-	}
-	for (auto &sub : subsheets) {
-		auto [offset, err] = sub.getTileOffset(
-				pNamePath, pBpp, pIt + 1, pCurrentTotal);
-		if (!err) {
-			return offset;
-		}
-		pCurrentTotal += sub.pixelCnt(pBpp) / PixelsPerTile;
-	}
-	return OxError(1, "SubSheet not found");
-}
-
-ox::Result<SubSheetId> TileSheet::SubSheet::getIdFor(
-		ox::SpanView<ox::StringView> const&pNamePath,
-		std::size_t pIt) const noexcept {
-	for (auto &sub : subsheets) {
-		if (sub.name == pNamePath[pIt]) {
-			if (pIt == pNamePath.size()) {
-				return id;
-			}
-			return getIdFor(pNamePath, pIt + 1);
-		}
-	}
-	return OxError(1, "SubSheet not found");
-}
-
-ox::Result<ox::StringView> TileSheet::SubSheet::getNameFor(SubSheetId pId) const noexcept {
-	if (id == pId) {
-		return ox::StringView(name);
-	}
-	for (const auto &sub : subsheets) {
-		const auto [name, err] = sub.getNameFor(pId);
 		if (!err) {
 			return name;
 		}
@@ -222,138 +99,181 @@ ox::Result<ox::StringView> TileSheet::SubSheet::getNameFor(SubSheetId pId) const
 }
 
 
-TileSheet &TileSheet::operator=(TileSheet const&other) noexcept {
+TileSheet::SubSheetIdx validateSubSheetIdx(
-	if (this != &other) {
+		TileSheet::SubSheetIdx const&pIdx,
-		bpp = other.bpp;
-		idIt = other.idIt;
-		defaultPalette = other.defaultPalette;
-		subsheet = other.subsheet;
-	}
-	return *this;
-}
-
-TileSheet &TileSheet::operator=(TileSheet &&other) noexcept {
-	bpp = other.bpp;
-	idIt = other.idIt;
-	defaultPalette = std::move(other.defaultPalette);
-	subsheet = std::move(other.subsheet);
-	return *this;
-}
-
-TileSheet::SubSheetIdx TileSheet::validateSubSheetIdx(
-		const SubSheetIdx &pIdx,
 		std::size_t pIdxIt,
-		const SubSheet *pSubsheet) noexcept {
+		TileSheet::SubSheet const&pSubsheet) noexcept {
 	if (pIdxIt == pIdx.size()) {
 		return pIdx;
 	}
 	const auto currentIdx = pIdx[pIdxIt];
-	if (pSubsheet->subsheets.size() <= currentIdx) {
+	if (pSubsheet.subsheets.size() <= currentIdx) {
 		auto out = pIdx;
-		if (!pSubsheet->subsheets.empty()) {
+		if (!pSubsheet.subsheets.empty()) {
-			*out.back().value = pSubsheet->subsheets.size() - 1;
+			*out.back().value = pSubsheet.subsheets.size() - 1;
 		} else {
 			out.pop_back();
 		}
 		return out;
 	}
-	return validateSubSheetIdx(pIdx, pIdxIt + 1, &pSubsheet->subsheets[pIdx[pIdxIt]]);
+	return validateSubSheetIdx(pIdx, pIdxIt + 1, pSubsheet.subsheets[pIdx[pIdxIt]]);
 }
 
-TileSheet::SubSheetIdx TileSheet::validateSubSheetIdx(const SubSheetIdx &idx) noexcept {
+TileSheet::SubSheetIdx validateSubSheetIdx(TileSheet const&ts, TileSheet::SubSheetIdx const&idx) noexcept {
-	return validateSubSheetIdx(idx, 0, &subsheet);
+	return validateSubSheetIdx(idx, 0, ts.subsheet);
 }
 
-const TileSheet::SubSheet &TileSheet::getSubSheet(
+const TileSheet::SubSheet &getSubSheet(
 		TileSheet::SubSheetIdx const&idx,
 		std::size_t idxIt,
-		SubSheet const*pSubsheet) noexcept {
+		TileSheet::SubSheet const&pSubsheet) noexcept {
 	if (idxIt == idx.size()) {
-		return *pSubsheet;
+		return pSubsheet;
 	}
 	const auto currentIdx = idx[idxIt];
-	if (pSubsheet->subsheets.size() < currentIdx) {
+	if (pSubsheet.subsheets.size() < currentIdx) {
-		return *pSubsheet;
+		return pSubsheet;
 	}
-	return getSubSheet(idx, idxIt + 1, &pSubsheet->subsheets[currentIdx]);
+	return getSubSheet(idx, idxIt + 1, pSubsheet.subsheets[currentIdx]);
 }
 
-TileSheet::SubSheet &TileSheet::getSubSheet(
+TileSheet::SubSheet &getSubSheet(
 		TileSheet::SubSheetIdx const&idx,
 		std::size_t idxIt,
-		TileSheet::SubSheet *pSubsheet) noexcept {
+		TileSheet::SubSheet &pSubsheet) noexcept {
 	if (idxIt == idx.size()) {
-		return *pSubsheet;
+		return pSubsheet;
 	}
-	return getSubSheet(idx, idxIt + 1, &pSubsheet->subsheets[idx[idxIt]]);
+	return getSubSheet(idx, idxIt + 1, pSubsheet.subsheets[idx[idxIt]]);
 }
 
-const TileSheet::SubSheet &TileSheet::getSubSheet(TileSheet::SubSheetIdx const&idx) const noexcept {
+TileSheet::SubSheet const&getSubSheet(TileSheet const&ts, TileSheet::SubSheetIdx const&idx) noexcept {
-	return getSubSheet(idx, 0, &subsheet);
+	return core::getSubSheet(idx, 0, ts.subsheet);
 }
 
-TileSheet::SubSheet &TileSheet::getSubSheet(TileSheet::SubSheetIdx const&idx) noexcept {
+TileSheet::SubSheet &getSubSheet(TileSheet &ts, TileSheet::SubSheetIdx const&idx) noexcept {
-	return getSubSheet(idx, 0, &subsheet);
+	return core::getSubSheet(idx, 0, ts.subsheet);
 }
 
-ox::Error TileSheet::addSubSheet(TileSheet::SubSheetIdx const&idx) noexcept {
+ox::Error addSubSheet(TileSheet &ts, TileSheet::SubSheetIdx const&idx) noexcept {
-	auto &parent = getSubSheet(idx);
+	auto &parent = getSubSheet(ts, idx);
 	if (parent.subsheets.size() < 2) {
-		parent.subsheets.emplace_back(idIt++, ox::sfmt("Subsheet {}", parent.subsheets.size()), 1, 1, bpp);
+		parent.subsheets.emplace_back(++ts.idIt, ox::sfmt("Subsheet {}", parent.subsheets.size()), 1, 1, ts.bpp);
 	} else {
-		parent.subsheets.emplace_back(idIt++, "Subsheet 0", parent.columns, parent.rows, bpp);
+		parent.subsheets.emplace_back(++ts.idIt, "Subsheet 0", parent.columns, parent.rows, ts.bpp);
-		parent.subsheets.emplace_back(idIt++, "Subsheet 1", 1, 1, bpp);
+		parent.subsheets.emplace_back(++ts.idIt, "Subsheet 1", 1, 1, ts.bpp);
 	}
 	return OxError(0);
 }
 
-ox::Error TileSheet::rmSubSheet(
+ox::Error rmSubSheet(
-		SubSheetIdx const&idx,
+		TileSheet &ts,
+		TileSheet::SubSheetIdx const&idx,
 		std::size_t idxIt,
-		SubSheet *pSubsheet) noexcept {
+		TileSheet::SubSheet &pSubsheet) noexcept {
 	if (idxIt == idx.size() - 1) {
-		return pSubsheet->subsheets.erase(idx[idxIt]).error;
+		return pSubsheet.subsheets.erase(idx[idxIt]).error;
 	}
-	return rmSubSheet(idx, idxIt + 1, &pSubsheet->subsheets[idx[idxIt]]);
+	return rmSubSheet(ts, idx, idxIt + 1, pSubsheet.subsheets[idx[idxIt]]);
 }
 
-ox::Error TileSheet::rmSubSheet(TileSheet::SubSheetIdx const&idx) noexcept {
+ox::Error rmSubSheet(TileSheet &ts, TileSheet::SubSheetIdx const&idx) noexcept {
-	return rmSubSheet(idx, 0, &subsheet);
+	return rmSubSheet(ts, idx, 0, ts.subsheet);
 }
 
-uint8_t TileSheet::getPixel4Bpp(
+uint8_t getPixel4Bpp(
+		TileSheet const&ts,
 		ox::Point const&pt,
-		TileSheet::SubSheetIdx const&subsheetIdx) const noexcept {
+		TileSheet::SubSheetIdx const&subsheetIdx) noexcept {
-	oxAssert(bpp == 4, "TileSheet::getPixel4Bpp: wrong bpp");
+	oxAssert(ts.bpp == 4, "TileSheet::getPixel4Bpp: wrong bpp");
-	auto &s = this->getSubSheet(subsheetIdx);
+	auto &s = getSubSheet(ts, subsheetIdx);
 	const auto idx = ptToIdx(pt, s.columns);
-	return s.getPixel4Bpp(idx);
+	return getPixel4Bpp(s, idx);
 }
 
-uint8_t TileSheet::getPixel8Bpp(
+uint8_t getPixel8Bpp(
+		TileSheet const&ts,
 		ox::Point const&pt,
-		TileSheet::SubSheetIdx const&subsheetIdx) const noexcept {
+		TileSheet::SubSheetIdx const&subsheetIdx) noexcept {
-	oxAssert(bpp == 8, "TileSheet::getPixel8Bpp: wrong bpp");
+	oxAssert(ts.bpp == 8, "TileSheet::getPixel8Bpp: wrong bpp");
-	auto &s = this->getSubSheet(subsheetIdx);
+	auto &s = getSubSheet(ts, subsheetIdx);
 	const auto idx = ptToIdx(pt, s.columns);
-	return s.getPixel8Bpp(idx);
+	return getPixel8Bpp(s, idx);
 }
 
-ox::Result<SubSheetId> TileSheet::getIdFor(ox::CRStringView path) const noexcept {
+static ox::Result<SubSheetId> getIdFor(
-	return subsheet.getIdFor(ox::split<8>(path, '.'));
+		TileSheet::SubSheet const&ss,
+		ox::SpanView<ox::StringView> const&pNamePath,
+		std::size_t pIt = 0) noexcept {
+	for (auto &sub : ss.subsheets) {
+		if (sub.name == pNamePath[pIt]) {
+			if (pIt == pNamePath.size()) {
+				return ss.id;
+			}
+			return getIdFor(ss, pNamePath, pIt + 1);
+		}
+	}
+	return OxError(1, "SubSheet not found");
 }
 
-ox::Result<unsigned> TileSheet::getTileOffset(ox::CRStringView pNamePath) const noexcept {
+ox::Result<SubSheetId> getIdFor(TileSheet const&ts, ox::CRStringView path) noexcept {
-	return subsheet.getTileOffset(ox::split<8>(pNamePath, '.'), bpp);
+	return getIdFor(ts.subsheet, ox::split<8>(path, '.'));
 }
 
-ox::Result<ox::StringView> TileSheet::getNameFor(SubSheetId pId) const noexcept {
+/**
-	return subsheet.getNameFor(pId);
+ * Gets the offset in tiles of the desired subsheet.
+ */
+static ox::Result<unsigned> getTileOffset(
+		TileSheet::SubSheet const&ss,
+		ox::SpanView<ox::StringView> const&pNamePath,
+		int8_t pBpp,
+		std::size_t pIt = 0,
+		unsigned pCurrentTotal = 0) noexcept {
+	// pIt == pNamePath.size() - 1 &&
+	if (ss.name != pNamePath[pIt]) {
+		return OxError(2, "Wrong branch");
+	}
+	if (pIt == pNamePath.size() - 1) {
+		return pCurrentTotal;
+	}
+	for (auto &sub : ss.subsheets) {
+		auto [offset, err] = getTileOffset(
+				sub, pNamePath, pBpp, pIt + 1, pCurrentTotal);
+		if (!err) {
+			return offset;
+		}
+		pCurrentTotal += pixelCnt(sub, pBpp) / PixelsPerTile;
+	}
+	return OxError(1, "SubSheet not found");
 }
 
-ox::Vector<uint8_t> TileSheet::pixels() const noexcept {
+ox::Result<unsigned> getTileOffset(TileSheet const&ts, ox::CRStringView pNamePath) noexcept {
+	return core::getTileOffset(ts.subsheet, ox::split<8>(pNamePath, '.'), ts.bpp);
+}
+
+ox::Result<ox::StringView> getNameFor(TileSheet &ts, SubSheetId pId) noexcept {
+	return core::getNameFor(ts.subsheet, pId);
+}
+
+ox::Result<ox::StringView> getNameFor(TileSheet const&ts, SubSheetId pId) noexcept {
+	return core::getNameFor(ts.subsheet, pId);
+}
+
+static void readPixelsTo(TileSheet::SubSheet &ss, ox::Vector<uint8_t> &pPixels) noexcept {
+	if (!ss.subsheets.empty()) {
+		for (auto &s: ss.subsheets) {
+			readPixelsTo(s, pPixels);
+		}
+	} else {
+		for (auto p : ss.pixels) {
+			pPixels.emplace_back(p);
+		}
+	}
+}
+
+ox::Vector<uint8_t> pixels(TileSheet &ts) noexcept {
 	ox::Vector<uint8_t> out;
-	subsheet.readPixelsTo(&out);
+	readPixelsTo(ts.subsheet, out);
 	return out;
 }
 

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

@@ -42,7 +42,7 @@ struct TileDoc {
 		if (subsheetId > -1) {
 			return subsheetId;
 		}
-		return ts.getIdFor(subsheetPath);
+		return getIdFor(ts, subsheetPath);
 	}
 
 	[[nodiscard]]
@@ -50,7 +50,7 @@ struct TileDoc {
 			core::TileSheet const&ts) const noexcept {
 		// prefer the already present path
 		if (!subsheetPath.len()) {
-			return ts.getNameFor(subsheetId);
+			return core::getNameFor(ts, subsheetId);
 		}
 		return ox::StringView(subsheetPath);
 	}

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

@@ -54,7 +54,7 @@ ox::Error SceneDocToSceneStaticConverter::convert(
 				auto dstTile = dstLayer.tile(tileIdx);
 				dstTile.tileType = srcTile.type;
 				oxRequire(path, srcTile.getSubsheetPath(*ts));
-				oxRequire(mapIdx, ts->getTileOffset(path));
+				oxRequire(mapIdx, getTileOffset(*ts, path));
 				dstTile.tileMapIdx = static_cast<uint16_t>(mapIdx);
 				setLayerAttachments(layerIdx, srcTile, dstTile);
 				++tileIdx;

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

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

src/nostalgia/player/app.cpp

@@ -82,7 +82,8 @@ static ox::Error runTest(turbine::Context &tctx) {
 
 [[maybe_unused]]
 static ox::Error runTileSheetSetTest(turbine::Context &tctx) {
-	// this should make the screen display 'ABCDB'
+	// this should make the screen display 'ABCDB', with the A being upside down
+	// and the first B being backwards
 	constexpr ox::FileAddress PaletteAddr = ox::StringLiteral("/Palettes/Charset.npal");
 	oxRequireM(cctx, core::init(tctx));
 	turbine::setApplicationData(tctx, cctx.get());
@@ -96,14 +97,16 @@ static ox::Error runTileSheetSetTest(turbine::Context &tctx) {
 			{ .tilesheet = ox::StringLiteral("/TileSheets/AB.ng"),      .sections{{.begin = 1, .tiles = 1}} },
 		},
 	};
+	constexpr auto bgPalBank = 1;
 	oxReturnError(core::loadBgTileSheet(*cctx, 0, set));
 	oxReturnError(core::loadSpriteTileSheet(*cctx, set));
-	oxReturnError(core::loadBgPalette(*cctx, PaletteAddr));
+	oxReturnError(core::loadBgPalette(*cctx, bgPalBank, PaletteAddr));
+	oxReturnError(core::loadBgPalette(*cctx, 0, ox::StringLiteral("/Palettes/Chester.npal")));
 	oxReturnError(core::loadSpritePalette(*cctx, PaletteAddr));
 	core::setBgStatus(*cctx, 0, true);
-	core::setBgTile(*cctx, 0, 10, 9, 1);
+	core::setBgTile(*cctx, 0, 10, 9, { .tileIdx = 1, .palBank = bgPalBank, .flipX = 0, .flipY = 1 });
-	core::setBgTile(*cctx, 0, 11, 9, 2);
+	core::setBgTile(*cctx, 0, 11, 9, { .tileIdx = 2, .palBank = bgPalBank, .flipX = 1, .flipY = 0 });
-	core::setBgTile(*cctx, 0, 13, 9, 4);
+	core::setBgTile(*cctx, 0, 13, 9, { .tileIdx = 4, .palBank = bgPalBank, .flipX = 0, .flipY = 0 });
 	core::setSprite(*cctx, 16, {
 		.enabled = true,
 		.x = 12 * 8,

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

@@ -148,7 +148,7 @@ ox::Error convert(keel::Context &ctx, ox::Buffer const&buff, DstType *outObj) no
 }
 
 template<typename DstType>
-ox::Result<ox::Buffer> convertBuffToBuff(keel::Context &ctx, const ox::Buffer &srcBuffer, ox::ClawFormat fmt) noexcept {
+ox::Result<ox::Buffer> convertBuffToBuff(keel::Context &ctx, ox::Buffer 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));

src/olympic/studio/applib/src/CMakeLists.txt

@@ -5,6 +5,7 @@ add_library(
 		filedialogmanager.cpp
 		main.cpp
 		newmenu.cpp
+		newproject.cpp
 		projectexplorer.cpp
 		projecttreemodel.cpp
 		studioapp.cpp

src/olympic/studio/applib/src/newmenu.cpp

@@ -115,12 +115,12 @@ void NewMenu::drawLastPageButtons(turbine::Context &ctx) noexcept {
 }
 
 void NewMenu::finish(turbine::Context &ctx) noexcept {
-	auto const err = m_types[static_cast<std::size_t>(m_selectedType)]->write(ctx, m_itemName);
+	auto const [path, err] = m_types[static_cast<std::size_t>(m_selectedType)]->write(ctx, m_itemName);
 	if (err) {
 		oxLogError(err);
 		return;
 	}
-	finished.emit("");
+	finished.emit(path);
 	m_stage = Stage::Closed;
 }
 

src/olympic/studio/applib/src/newproject.cpp

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2016 - 2023 Gary Talent (gary@drinkingtea.net). All rights reserved.
+ */
+
+#include <imgui.h>
+
+#include <studio/imguiuitl.hpp>
+#include <utility>
+
+#include "filedialogmanager.hpp"
+#include "newproject.hpp"
+
+namespace studio {
+
+NewProject::NewProject(ox::String projectDatadir) noexcept: m_projectDataDir(std::move(projectDatadir)) {
+	setTitle(ox::String("New Project"));
+	setSize({230, 140});
+}
+
+void NewProject::open() noexcept {
+	m_stage = Stage::Opening;
+	m_projectPath = "";
+	m_projectName = "";
+}
+
+void NewProject::close() noexcept {
+	m_stage = Stage::Closed;
+	m_open = false;
+}
+
+bool NewProject::isOpen() const noexcept {
+	return m_open;
+}
+
+void NewProject::draw(turbine::Context &ctx) noexcept {
+	switch (m_stage) {
+		case Stage::Opening:
+			ImGui::OpenPopup(title().c_str());
+			m_stage = Stage::NewItemName;
+			m_open = true;
+			[[fallthrough]];
+		case Stage::NewItemName:
+			drawNewProjectName(ctx);
+			break;
+		case Stage::Closed:
+			m_open = false;
+			break;
+	}
+}
+
+void NewProject::drawNewProjectName(turbine::Context &ctx) noexcept {
+	drawWindow(ctx, &m_open, [this, &ctx] {
+		ImGui::InputText("Name", m_projectName.data(), m_projectName.cap());
+		ImGui::Text("Path: %s", m_projectPath.c_str());
+		if (ImGui::Button("Browse")) {
+			oxLogError(studio::chooseDirectory().moveTo(m_projectPath));
+		}
+		drawLastPageButtons(ctx);
+	});
+}
+
+void NewProject::drawFirstPageButtons() noexcept {
+	ImGui::SetCursorPosX(ImGui::GetCursorPosX() + ImGui::GetContentRegionAvail().x - 130);
+	ImGui::SetCursorPosY(ImGui::GetCursorPosY() + ImGui::GetContentRegionAvail().y - 20);
+	auto const btnSz = ImVec2(60, 20);
+	if (ImGui::Button("Next", btnSz)) {
+		m_stage = Stage::NewItemName;
+	}
+	ImGui::SameLine();
+	if (ImGui::Button("Cancel", btnSz)) {
+		ImGui::CloseCurrentPopup();
+		m_stage = Stage::Closed;
+	}
+}
+
+void NewProject::drawLastPageButtons(turbine::Context&) noexcept {
+	ImGui::SetCursorPosX(ImGui::GetCursorPosX() + ImGui::GetContentRegionAvail().x - 95);
+	ImGui::SetCursorPosY(ImGui::GetCursorPosY() + ImGui::GetContentRegionAvail().y - 20);
+	if (ImGui::Button("Finish")) {
+		finish();
+	}
+	ImGui::SameLine();
+	if (ImGui::Button("Quit")) {
+		ImGui::CloseCurrentPopup();
+		m_stage = Stage::Closed;
+	}
+}
+
+void NewProject::finish() noexcept {
+	auto projectPath = ox::sfmt("{}/{}", m_projectPath, m_projectName);
+	finished.emit(projectPath);
+	m_stage = Stage::Closed;
+}
+
+}

src/olympic/studio/applib/src/newproject.hpp

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2016 - 2023 Gary Talent (gary@drinkingtea.net). All rights reserved.
+ */
+
+#pragma once
+
+#include <ox/claw/claw.hpp>
+#include <ox/event/signal.hpp>
+#include <ox/std/string.hpp>
+
+#include <studio/itemmaker.hpp>
+#include <studio/popup.hpp>
+
+namespace studio {
+
+class NewProject: public studio::Popup {
+	public:
+		enum class Stage {
+			Closed,
+			Opening,
+			NewItemName,
+		};
+
+		// emits path parameter
+		ox::Signal<ox::Error(ox::StringView)> finished;
+
+	private:
+		Stage m_stage = Stage::Closed;
+		ox::String const m_projectDataDir;
+		ox::String m_projectPath;
+		ox::BString<255> m_projectName;
+		ox::Vector<ox::UniquePtr<studio::ItemMaker>> m_types;
+		bool m_open = false;
+
+	public:
+		NewProject(ox::String projectDatadir) noexcept;
+
+		void open() noexcept override;
+
+		void close() noexcept override;
+
+		[[nodiscard]]
+		bool isOpen() const noexcept override;
+
+		void draw(turbine::Context &ctx) noexcept override;
+
+	private:
+		void drawNewProjectName(turbine::Context &ctx) noexcept;
+
+		void drawFirstPageButtons() noexcept;
+
+		void drawLastPageButtons(turbine::Context &ctx) noexcept;
+
+		void finish() noexcept;
+
+};
+
+}

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

@@ -2,6 +2,8 @@
  * Copyright 2016 - 2023 Gary Talent (gary@drinkingtea.net). All rights reserved.
  */
 
+#include <filesystem>
+
 #include <imgui.h>
 
 #include <keel/media.hpp>
@@ -42,15 +44,18 @@ StudioUI::StudioUI(turbine::Context &ctx, ox::StringView projectDataDir) noexcep
 		m_ctx(ctx),
 		m_projectDataDir(projectDataDir),
 		m_projectExplorer(m_ctx),
+		m_newProject(ox::String(projectDataDir)),
 		m_aboutPopup(m_ctx) {
 	m_projectExplorer.fileChosen.connect(this, &StudioUI::openFile);
+	m_newProject.finished.connect(this, &StudioUI::createOpenProject);
+	m_newMenu.finished.connect(this, &StudioUI::openFile);
 	ImGui::GetIO().IniFilename = nullptr;
 	loadModules();
 	// open project and files
 	auto const [config, err] = studio::readConfig<StudioConfig>(keelCtx(m_ctx));
 	m_showProjectExplorer = config.showProjectExplorer;
 	if (!err) {
-		auto const openProjErr = openProject(config.projectPath);
+		auto const openProjErr = openProjectPath(config.projectPath);
 		if (!openProjErr) {
 			for (auto const&f: config.openFiles) {
 				auto openFileErr = openFileActiveTab(f, config.activeTabItemName == f);
@@ -95,10 +100,14 @@ void StudioUI::handleKeyEvent(turbine::Key key, bool down) noexcept {
 				}
 				break;
 			case turbine::Key::Alpha_N:
-				m_newMenu.open();
+				if (turbine::buttonDown(m_ctx, turbine::Key::Mod_Shift)) {
+					m_newProject.open();
+				} else {
+					m_newMenu.open();
+				}
 				break;
 			case turbine::Key::Alpha_O:
-				m_taskRunner.add(*ox::make<FileDialogManager>(this, &StudioUI::openProject));
+				m_taskRunner.add(*ox::make<FileDialogManager>(this, &StudioUI::openProjectPath));
 				break;
 			case turbine::Key::Alpha_Q:
 				turbine::requestShutdown(m_ctx);
@@ -168,8 +177,11 @@ void StudioUI::drawMenu() noexcept {
 			if (ImGui::MenuItem("New...", "Ctrl+N")) {
 				m_newMenu.open();
 			}
+			if (ImGui::MenuItem("New Project...", "Ctrl+Shift+N")) {
+				m_newProject.open();
+			}
 			if (ImGui::MenuItem("Open Project...", "Ctrl+O")) {
-				m_taskRunner.add(*ox::make<FileDialogManager>(this, &StudioUI::openProject));
+				m_taskRunner.add(*ox::make<FileDialogManager>(this, &StudioUI::openProjectPath));
 			}
 			if (ImGui::MenuItem("Save", "Ctrl+S", false, m_activeEditor && m_activeEditor->unsavedChanges())) {
 				m_activeEditor->save();
@@ -317,19 +329,27 @@ void StudioUI::save() noexcept {
 	}
 }
 
-ox::Error StudioUI::openProject(ox::CRStringView path) noexcept {
+ox::Error StudioUI::createOpenProject(ox::CRStringView path) noexcept {
+	std::error_code ec;
+	std::filesystem::create_directories(toStdStringView(path), ec);
+	oxReturnError(OxError(ec.value() != 0, "Could not create project directory"));
+	oxReturnError(openProjectPath(path));
+	return m_project->writeAllTypeDescriptors();
+}
+
+ox::Error StudioUI::openProjectPath(ox::CRStringView path) noexcept {
 	oxRequireM(fs, keel::loadRomFs(path));
 	oxReturnError(keel::setRomFs(keelCtx(m_ctx), std::move(fs)));
-	turbine::setWindowTitle(m_ctx, ox::sfmt("{} - {}", keelCtx(m_ctx).appName, path));
 	m_project = ox::make_unique<studio::Project>(keelCtx(m_ctx), ox::String(path), m_projectDataDir);
-	auto sctx = applicationData<studio::StudioContext>(m_ctx);
+	auto const sctx = applicationData<studio::StudioContext>(m_ctx);
 	sctx->project = m_project.get();
+	turbine::setWindowTitle(m_ctx, ox::sfmt("{} - {}", keelCtx(m_ctx).appName, m_project->projectPath()));
 	m_project->fileAdded.connect(&m_projectExplorer, &ProjectExplorer::refreshProjectTreeModel);
 	m_project->fileDeleted.connect(&m_projectExplorer, &ProjectExplorer::refreshProjectTreeModel);
 	m_openFiles.clear();
 	m_editors.clear();
 	studio::editConfig<StudioConfig>(keelCtx(m_ctx), [&](StudioConfig *config) {
-		config->projectPath = ox::String(path);
+		config->projectPath = ox::String(m_project->projectPath());
 		config->openFiles.clear();
 	});
 	return m_projectExplorer.refreshProjectTreeModel();

src/olympic/studio/applib/src/studioapp.hpp

@@ -14,6 +14,7 @@
 #include <studio/task.hpp>
 #include "aboutpopup.hpp"
 #include "newmenu.hpp"
+#include "newproject.hpp"
 #include "projectexplorer.hpp"
 #include "projecttreemodel.hpp"
 
@@ -36,9 +37,11 @@ class StudioUI: public ox::SignalHandler {
 		studio::BaseEditor *m_activeEditor = nullptr;
 		studio::BaseEditor *m_activeEditorUpdatePending = nullptr;
 		NewMenu m_newMenu;
+		NewProject m_newProject;
 		AboutPopup m_aboutPopup;
-		ox::Array<studio::Popup*, 2> const m_popups = {
+		ox::Array<studio::Popup*, 3> const m_popups = {
 			&m_newMenu,
+			&m_newProject,
 			&m_aboutPopup
 		};
 		bool m_showProjectExplorer = true;
@@ -79,7 +82,9 @@ class StudioUI: public ox::SignalHandler {
 
 		void save() noexcept;
 
-		ox::Error openProject(ox::CRStringView path) noexcept;
+		ox::Error createOpenProject(ox::CRStringView path) noexcept;
+
+		ox::Error openProjectPath(ox::CRStringView path) noexcept;
 
 		ox::Error openFile(ox::CRStringView path) noexcept;
 

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

@@ -24,7 +24,14 @@ class ItemMaker {
 			fileExt(pFileExt) {
 		}
 		virtual ~ItemMaker() noexcept = default;
-		virtual ox::Error write(turbine::Context &ctx, ox::CRStringView pName) const noexcept = 0;
+
+		/**
+		 * Returns path of the file created.
+		 * @param ctx
+		 * @param pName
+		 * @return path of file or error in Result
+		 */
+		virtual ox::Result<ox::String> write(turbine::Context &ctx, ox::CRStringView pName) const noexcept = 0;
 };
 
 template<typename T>
@@ -61,11 +68,12 @@ class ItemMakerT: public ItemMaker {
 			 m_item(std::move(pItem)),
 			 m_fmt(pFmt) {
 		}
-		ox::Error write(turbine::Context &ctx, ox::CRStringView pName) const noexcept override {
+		ox::Result<ox::String> write(turbine::Context &ctx, ox::CRStringView pName) const noexcept override {
 			auto const path = ox::sfmt("/{}/{}.{}", parentDir, pName, fileExt);
 			auto sctx = turbine::applicationData<studio::StudioContext>(ctx);
 			keel::createUuidMapping(keelCtx(ctx), path, ox::UUID::generate().unwrap());
-			return sctx->project->writeObj(path, m_item, m_fmt);
+			oxReturnError(sctx->project->writeObj(path, m_item, m_fmt));
+			return path;
 		}
 };
 

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

@@ -36,11 +36,21 @@ constexpr ox::Result<ox::StringView> fileExt(ox::CRStringView path) noexcept {
 	return substr(path, extStart + 1);
 }
 
+[[nodiscard]]
+constexpr ox::StringView parentDir(ox::StringView path) noexcept {
+	if (path.len() && path[path.len() - 1] == '/') {
+		path = substr(path, 0, path.len() - 1);
+	}
+	auto const extStart = ox::find(path.crbegin(), path.crend(), '/').offset();
+	return substr(path, 0, extStart);
+}
+
 class Project {
 	private:
 		keel::Context &m_ctx;
 		ox::String m_path;
 		ox::String m_projectDataDir;
+		ox::String m_typeDescPath;
 		mutable keel::TypeStore m_typeStore;
 		ox::FileSystem &m_fs;
 		ox::HashMap<ox::String, ox::Vector<ox::String>> m_fileExtFileMap;
@@ -50,6 +60,9 @@ class Project {
 
 		ox::Error create() noexcept;
 
+		[[nodiscard]]
+		ox::String const&projectPath() const noexcept;
+
 		[[nodiscard]]
 		ox::FileSystem *romFs() noexcept;
 
@@ -78,6 +91,8 @@ class Project {
 		[[nodiscard]]
 		ox::Vector<ox::String> const&fileList(ox::CRStringView ext) noexcept;
 
+		ox::Error writeAllTypeDescriptors() noexcept;
+
 	private:
 		void buildFileIndex() noexcept;
 
@@ -108,21 +123,16 @@ template<typename T>
 ox::Error Project::writeObj(ox::CRStringView path, T const&obj, ox::ClawFormat fmt) noexcept {
 	oxRequireM(buff, ox::writeClaw(obj, fmt));
 	// write to FS
+	oxReturnError(mkdir(parentDir(path)));
 	oxReturnError(writeBuff(path, buff));
 	// write type descriptor
 	if (m_typeStore.get<T>().error) {
 		oxReturnError(ox::buildTypeDef(&m_typeStore, &obj));
 	}
-	// write out type store
+	oxRequire(desc, m_typeStore.get<T>());
-	auto const descPath = ox::sfmt("/{}/type_descriptors", m_projectDataDir);
+	auto const descExists = m_fs.stat(ox::sfmt("{}/{}", m_typeDescPath, buildTypeId(*desc))).error != 0;
-	oxReturnError(mkdir(descPath));
+	if (!descExists || ox::defines::Debug) {
-	for (auto const&t : m_typeStore.typeList()) {
+		oxReturnError(writeAllTypeDescriptors());
-		oxRequireM(typeOut, ox::writeClaw(*t, ox::ClawFormat::Organic));
-		// replace garbage last character with new line
-		*typeOut.back().value = '\n';
-		// write to FS
-		auto const typePath = ox::sfmt("/{}/{}", descPath, buildTypeId(*t));
-		oxReturnError(writeBuff(typePath, typeOut));
 	}
 	oxReturnError(keel::setAsset(m_ctx, path, obj));
 	fileUpdated.emit(path);

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

@@ -13,6 +13,11 @@
 
 namespace studio {
 
+static_assert(fileExt("main.c").value == "c");
+static_assert(fileExt("a.b.c").value == "c");
+static_assert(parentDir("/a/b/c") == "/a/b");
+static_assert(parentDir("/a/b/c/") == "/a/b");
+
 static void generateTypes(ox::TypeStore &ts) noexcept {
 	for (auto const mod : keel::modules()) {
 		for (auto gen : mod->types()) {
@@ -25,6 +30,7 @@ Project::Project(keel::Context &ctx, ox::String path, ox::CRStringView projectDa
 	m_ctx(ctx),
 	m_path(std::move(path)),
 	m_projectDataDir(projectDataDir),
+	m_typeDescPath(ox::sfmt("/{}/type_descriptors", m_projectDataDir)),
 	m_typeStore(*m_ctx.rom, ox::sfmt("/{}/type_descriptors", projectDataDir)),
 	m_fs(*m_ctx.rom) {
 	oxTracef("studio", "Project: {}", m_path);
@@ -38,6 +44,10 @@ ox::Error Project::create() noexcept {
 	return OxError(static_cast<ox::ErrorCode>(ec.value()), "PassThroughFS: mkdir failed");
 }
 
+ox::String const&Project::projectPath() const noexcept {
+	return m_path;
+}
+
 ox::FileSystem *Project::romFs() noexcept {
 	return &m_fs;
 }
@@ -60,6 +70,20 @@ ox::Vector<ox::String> const&Project::fileList(ox::CRStringView ext) noexcept {
 	return m_fileExtFileMap[ext];
 }
 
+ox::Error Project::writeAllTypeDescriptors() noexcept {
+	// write all descriptors because we don't know which types T depends on
+	oxReturnError(mkdir(m_typeDescPath));
+	for (auto const &t: m_typeStore.typeList()) {
+		oxRequireM(typeOut, ox::writeClaw(*t, ox::ClawFormat::Organic));
+		// replace garbage last character with new line
+		*typeOut.back().value = '\n';
+		// write to FS
+		auto const typePath = ox::sfmt("{}/{}", m_typeDescPath, buildTypeId(*t));
+		oxReturnError(writeBuff(typePath, typeOut));
+	}
+	return {};
+}
+
 void Project::buildFileIndex() noexcept {
 	auto [files, err] = listFiles();
 	if (err) {

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

@@ -54,6 +54,8 @@ static void handleKeyPress(Context &ctx, int key, bool down) noexcept {
 		map[GLFW_KEY_RIGHT_CONTROL] = Key::Mod_Ctrl;
 		map[GLFW_KEY_LEFT_SUPER]    = Key::Mod_Super;
 		map[GLFW_KEY_RIGHT_SUPER]   = Key::Mod_Super;
+		map[GLFW_KEY_LEFT_SHIFT]    = Key::Mod_Shift;
+		map[GLFW_KEY_RIGHT_SHIFT]   = Key::Mod_Shift;
 		map[GLFW_KEY_ESCAPE]        = Key::Escape;
 		return map;
 	}();