vram.hpp

#pragma once

#include <cstddef>
#include <cstdint>

#include <array>

namespace ioram
{

struct keyinput {
	uint16_t a : 1;
	uint16_t b : 1;
	uint16_t select : 1;
	uint16_t start : 1;
	uint16_t right : 1;
	uint16_t left : 1;
	uint16_t up : 1;
	uint16_t down : 1;
	uint16_t r : 1;
	uint16_t l : 1;
	uint16_t _ : 5;
} __attribute__((packed));
static_assert(sizeof(keyinput) == sizeof(uint16_t));

} // namespace ioram

namespace vram
{

template <typename Base, size_t address>
struct memmap {
	static inline auto begin() {
		return reinterpret_cast<typename Base::element volatile*>(address);
	}

	constexpr auto& operator[] (size_t i) const {
		return begin()[i];
	}
};

struct disp_control {
	enum VideoMode : uint16_t
		{ Reg4     = 0 // Reg: 0 1 2 3, Aff:
		, Reg2Aff1 = 1 // Reg: 0 1      Aff: 2
		, Aff2     = 2 // Reg:          Aff: 2 3
		, Bits16NoPageFlip = 3
		, Bits8PageFlip    = 4
		, Bits16PageFlip   = 5
	};
	uint16_t mode : 3;

	uint16_t isGbc : 1;
	uint16_t pageSelect : 1;

	uint16_t oamInHbl : 1;
	uint16_t oamOneDim : 1;

	uint16_t screenBlank : 1;

	uint16_t bg0Enabled : 1;
	uint16_t bg1Enabled : 1;
	uint16_t bg2Enabled : 1;
	uint16_t bg3Enabled : 1;
	uint16_t objEnabled : 1;

	uint16_t win0Enabled : 1;
	uint16_t win1Enabled : 1;
	uint16_t winObjEnabled : 1;
} __attribute__((packed));
static_assert(sizeof(disp_control) == sizeof(uint16_t));

struct disp_status {
	uint16_t vblankFlag : 1;
	uint16_t hblankFlag : 1;
	uint16_t vcountFlag : 1;

	uint16_t vblankIrqEnabled : 1;
	uint16_t hblankIrqEnabled : 1;
	uint16_t vcountIrqEnabled : 1;

	uint16_t _ : 2;

	uint16_t vcountIrqAt : 8;

} __attribute__((packed));
static_assert(sizeof(disp_status) == sizeof(uint16_t));

struct bg_control {
	uint16_t priority : 2;
	uint16_t charBlockBase : 2;

	uint16_t _ : 2;

	uint16_t mosaicEnabled : 1;

	enum PalMode : uint16_t
		{ Bits4 = 0
		, Bits8 = 1

		, Color16  = 0
		, Color256 = 1
	};
	uint16_t palMode : 1;

	uint16_t screenBlockBase : 5;
	uint16_t affineWrapEnabled : 1;

	enum MapSize : uint16_t
		{ Reg32x32 = 0
		, Reg64x32 = 1
		, Reg32x64 = 2
		, Reg64x64 = 3

		, Aff16x16 = 0
		, Aff32x32 = 1
		, Aff64x64 = 2
		, Aff128x128 = 3
	};
	uint16_t mapSize : 2;
} __attribute__((packed));
static_assert(sizeof(bg_control) == sizeof(uint16_t));

struct win_horz {
	uint16_t right : 8;
	uint16_t left : 8;
} __attribute__((packed));
static_assert(sizeof(win_horz) == sizeof(uint16_t));

struct win_vert {
	uint16_t bottom : 8;
	uint16_t top : 8;
} __attribute__((packed));
static_assert(sizeof(win_vert) == sizeof(uint16_t));

struct win_in {
	uint16_t win0_bg0 : 1;
	uint16_t win0_bg1 : 1;
	uint16_t win0_bg2 : 1;
	uint16_t win0_bg3 : 1;
	uint16_t win0_obj : 1;
	uint16_t win0_colorEffect : 1;
	uint16_t _ : 2;

	uint16_t win1_bg0 : 1;
	uint16_t win1_bg1 : 1;
	uint16_t win1_bg2 : 1;
	uint16_t win1_bg3 : 1;
	uint16_t win1_obj : 1;
	uint16_t win1_colorEffect : 1;
	uint16_t __ : 2;
} __attribute__((packed));
static_assert(sizeof(win_in) == sizeof(uint16_t));

struct win_out_obj {
	uint16_t out_bg0 : 1;
	uint16_t out_bg1 : 1;
	uint16_t out_bg2 : 1;
	uint16_t out_bg3 : 1;
	uint16_t out_obj : 1;
	uint16_t out_colorEffect : 1;
	uint16_t _ : 2;

	uint16_t obj_bg0 : 1;
	uint16_t obj_bg1 : 1;
	uint16_t obj_bg2 : 1;
	uint16_t obj_bg3 : 1;
	uint16_t obj_obj : 1;
	uint16_t obj_colorEffect : 1;
	uint16_t __ : 2;
} __attribute__((packed));
static_assert(sizeof(win_out_obj) == sizeof(uint16_t));

struct blend_control {
	uint16_t top_bg0 : 1;
	uint16_t top_bg1 : 1;
	uint16_t top_bg2 : 1;
	uint16_t top_bg3 : 1;
	uint16_t top_obj : 1;
	uint16_t top_backdrop : 1; // Color 0

	enum Mode : uint16_t
		{ Off = 0
		, Alpha = 1
		, White = 2
		, Black = 3
	};
	uint16_t mode : 2;

	uint16_t bot_bg0 : 1;
	uint16_t bot_bg1 : 1;
	uint16_t bot_bg2 : 1;
	uint16_t bot_bg3 : 1;
	uint16_t bot_obj : 1;
	uint16_t bot_backdrop : 1; // Color 0
} __attribute__((packed));
static_assert(sizeof(blend_control) == sizeof(uint16_t));

struct blend_alpha {
	uint16_t topWeight : 5;
	uint16_t _ : 3;
	uint16_t bottomWeight : 5;
	uint16_t __ : 3;
} __attribute__((packed));
static_assert(sizeof(blend_alpha) == sizeof(uint16_t));

struct dma_control {
	uint32_t count : 16;

	uint32_t _ : 5;

	enum Adjust : uint32_t
		{ Increment = 0
		, Decrement = 1
		, None      = 2
		, Reload    = 3
	};
	uint32_t destAdjust   : 2;
	uint32_t sourceAdjust : 2;

	uint32_t repeatAtBlank : 1;

	enum ChunkSize : uint32_t
		{ Bits16 = 0
		, Bits32 = 1
	};
	uint32_t chunkSize : 1;

	uint32_t __ : 1;

	enum Timing : uint32_t
		{ Immediate = 0
		, Vblank    = 1
		, Hblank    = 2

		, Dma1FifoRefill = 3
		, Dma2FifoRefill = 3
		, Dma3AtRefresh  = 3
	};
	uint32_t timing : 2;

	uint32_t irqNotify : 1;
	uint32_t enabled   : 1;
} __attribute__((packed));
static_assert(sizeof(dma_control) == sizeof(uint32_t));

struct screen_entry {
	uint8_t buf[4];

	constexpr screen_entry() : buf{} {}

	constexpr screen_entry(std::initializer_list<uint8_t> indices)
		: buf
			{ indices.begin()[0], indices.begin()[1]
			, indices.begin()[2], indices.begin()[3]
		}
	{}

	constexpr operator uint32_t() const {
		return (buf[0] <<  0) | (buf[1] <<  8)
			 | (buf[2] << 16) | (buf[3] << 24);
	}
} __attribute__((packed));
static_assert(sizeof(screen_entry) == 4);

struct screen_blocks {
	using element = uint32_t[0x200];
	using storage = std::array<element, 0x20>;
};

struct char_entry {
	uint32_t buf[16];

public:
	constexpr char_entry() : buf{} {}

	constexpr char_entry(std::initializer_list<uint32_t> lines)
		: buf
			{ lines.begin()[ 0], lines.begin()[ 1], lines.begin()[ 2], lines.begin()[ 3]
			, lines.begin()[ 4], lines.begin()[ 5], lines.begin()[ 6], lines.begin()[ 7]
			, lines.begin()[ 8], lines.begin()[ 9], lines.begin()[10], lines.begin()[11]
			, lines.begin()[12], lines.begin()[13], lines.begin()[14], lines.begin()[15]
		}
	{}

	void operator= (char_entry const& rhs) volatile {
		std::copy(rhs.buf, rhs.buf + 16, buf);
	}
};

struct char_blocks {
	using element = char_entry[0x100];
	using storage = std::array<element, 0x4>;
};


struct affine {

using P_elem = int16_t;
using dx_elem = int32_t;

using P = std::array<vram::affine::P_elem, 4>;
using dx = std::array<vram::affine::dx_elem, 2>;

};

using rgb15 = uint16_t;

constexpr static rgb15 make_rgb15(uint16_t r, uint16_t g, uint16_t b) {
	return ((r & 0x1f) << (5 * 0))
	     | ((g & 0x1f) << (5 * 1))
	     | ((b & 0x1f) << (5 * 2));
}

struct pal_bank {
	using element = uint16_t;
	using storage = std::array<element, 0x100>;
};

struct timer_control {
	enum Freq : uint16_t
		{ One = 0
		, SixtyFour = 1
		, TwoFiftySix = 2
		, TenTwentyFour = 3
	};
	uint16_t freq : 2;
	uint16_t cascade : 1;
	uint16_t _ : 3;
	uint16_t raiseIrq : 1;
	uint16_t enabled : 1;
	uint16_t __ : 8;
} __attribute__((packed));
static_assert(sizeof(timer_control) == 2);

using ISR = void(*)(void);

struct interrupt_mask {
	uint16_t vblank : 1;
	uint16_t hblank : 1;
	uint16_t vcount : 1;
	uint16_t timer0 : 1;
	uint16_t timer1 : 1;
	uint16_t timer2 : 1;
	uint16_t timer3 : 1;
	uint16_t serialComm : 1;
	uint16_t dma0 : 1;
	uint16_t dma1 : 1;
	uint16_t dma2 : 1;
	uint16_t dma3 : 1;
	uint16_t keypad : 1;
	uint16_t gamePak : 1;
	uint16_t _ : 2;
} __attribute__((packed));
static_assert(sizeof(interrupt_mask) == 2);

struct interrupt_master {
	uint32_t enabled : 1;
	uint32_t _ : 31;
} __attribute__((packed));
static_assert(sizeof(interrupt_master) == 4);

} // namespace vram

struct RenderParams {
	vram::win_horz win0Horz;
	vram::affine::P_elem Pa;
	vram::affine::dx dx;
	uint16_t blendFade : 5;
	uint32_t _ : 27;
} __attribute__((packed, aligned(4)));
static_assert(sizeof(RenderParams) == 16);