work for 2025-04-25 (5/5)

/******************************************************************************/

//"gdi_maze_game_2025-04-25\include\sound_stuff.hpp":

// This file should not be included on its own,

// but rather as part of "public_stuff.hpp"!

//

// (Most of this is lifted straight from kit_sdl2, so if some

// things here are inconsisent with the rest, that's why!)

//

// ALSO, DO NOT USE THIS AS REFERENCE IN A FUTURE PROJECT,

// BECAUSE IT'S A HACKY MESS!

#ifndef _SOUND_STUFF_HPP

#define _SOUND_STUFF_HPP

#ifdef SOUND_STUFF_USED

#include <windows.h>

//#define AUDIODATA_FILELOAD_USED

#define AUDIODATA_SAVEAUDIO_USED

#define AUDIODATA_CONVERTFORMAT_USED

#define GET_AUDIO_BITSIZE(x) (x & (0xFF ))

#define GET_AUDIO_ISFLOAT(x) (x & (1<< 8))

#define GET_AUDIO_ISBIGENDIAN(x) (x & (1<<12))

#define GET_AUDIO_ISSIGNED(x) (x & (1<<15))

#define GET_AUDIO_BYTESIZE(x) (GET_AUDIO_BITSIZE(x)/8)

enum AudioSampleFormatEnum {

SMPFMT_U8 = 0x0008, //unsigned 8-bit samples

SMPFMT_S8 = 0x8008, // signed 8-bit samples

SMPFMT_U16LSB = 0x0010, //unsigned 16-bit samples

SMPFMT_S16LSB = 0x8010, // signed 16-bit samples

SMPFMT_S32LSB = 0x8020, // signed 32-bit samples

SMPFMT_F32LSB = 0x8120, //32-bit floating point samples

SMPFMT_U16MSB = 0x1010, //same as LSB, except with big-endian byte order

SMPFMT_S16MSB = 0x9010, //same as LSB, except with big-endian byte order

SMPFMT_S32MSB = 0x9020, //same as LSB, except with big-endian byte order

SMPFMT_F32MSB = 0x9120, //same as LSB, except with big-endian byte order

SMPFMT_S24LSB = 0x8018, // signed 24-bit samples

SMPFMT_F64LSB = 0x8140, //64-bit floating point samples

SMPFMT_S24MSB = 0x9018, //same as LSB, except with big-endian byte order

SMPFMT_F64MSB = 0x9140, //same as LSB, except with big-endian byte order

//aliases

SMPFMT_U16 = SMPFMT_U16LSB,

SMPFMT_S16 = SMPFMT_S16LSB,

SMPFMT_S24 = SMPFMT_S24LSB,

SMPFMT_S32 = SMPFMT_S32LSB,

SMPFMT_F32 = SMPFMT_F32LSB,

SMPFMT_F64 = SMPFMT_F64LSB,

//may also be used as a wildcard

//(as in this may be associated with a value != 0xFFFF)

SMPFMT_UKNOWN = 0xFFFF,

};

/******************************************************************************/

struct AudioDataHeader;

// The pointer this returns MUST have been allocated with mem_alloc()

// Also, ->samples must not be a separate allocation! samples must be contiguous

// and on the same memory block as the header itself!

//

// (Basically, header_ptr->samples = (u8*)header_ptr+header_ptr->headerSize)

typedef AudioDataHeader* (*AudioDataLoaderCallback)(const char* filePath);

typedef bool (*AudioDataSaverCallback)(const char* filePath,

AudioDataHeader& header_in);

// File signature = "kPxM" (no null terminator)

#define KPM_FILE_SIG (0x4D78506B)

// This struct is identical to a ".kpm" file as it contains the same header data

struct AudioDataHeader { //72B (0x48B)

u32 magic; // (0x00) = KPM_FILE_SIG = 0x4D78506B = "kPxM"

u16 format; // (0x04) = one of AudioSampleFormatEnum if fmt_version == 1

u16 headerSize; // (0x06) = must be >=sizeof(AudioDataHeader)

u64 dataSize; // (0x08) = size of audio data, in bytes

u64 loopStart; // (0x10) = which sample to loop back to

u64 loopEnd; // (0x18) = which sample to jump back to loopStart on

u64 numSamples; // (0x20) = # of sample frames in audio data

u32 sampleRate; // (0x28) = the audio data's sample rate, in Hz

u32 bitRate; // (0x2C) = the audio's bit rate (per second)

u16 loopCount; // (0x30) = # of times to loop audio (0 = no loop, 0xFFFF = inf loop)

u16 channels; // (0x32) = # of interlaced channels in the audio data

u8 _reserved; // (0x34)

u8 fmt_version; // (0x35) = 0=kit_w32, 1=kit_sdl2

u8 mode; // (0x36) = 0 for normal PCM or float data types

u8 metadata_type; // (0x37) = 0 for no metadata

void* samples; // (0x38) = the audio's sample data (appears as nullptr in file)

void* userdata; // (0x40) = user-defined (also appears nullptr in file)

// (0x48) = (start of sample data, assuming a .kpm file)

// Only useful #ifdef _DEBUG

void printHeader(const char* name = nullptr);

};

class AudioData {

bool _allocate_hdr(u16 headerSize, u64 dataSize);

public:

AudioDataHeader* hdr = nullptr;

StereoF32 volume = {1.0f, 1.0f};

// Create with everything zeroed out, except headerSize, dataSize, and samples

AudioData(u16 headerSize, u64 dataSize){ _allocate_hdr(headerSize,dataSize); }

// Create with zeroed out sample data

AudioData(AudioSampleFormatEnum format,

u64 numSamples, u16 channels, u32 sampleRate);

#ifdef AUDIODATA_FILELOAD_USED

// Create from an audio file of a specific file format

AudioData(const char* filePath, AudioDataLoaderCallback callback);

#endif

~AudioData();

inline void printHeader(const char* name = nullptr)

{ if(hdr != nullptr) hdr->printHeader(name); }

#ifdef AUDIODATA_SAVEAUDIO_USED

// (This will overwrite any file named filePath! make sure to check

// with fileio_exists() unless you intend to overwrite the previous file)

bool saveAudio(const char* filePath, AudioDataSaverCallback callback);

#endif

#ifdef AUDIODATA_CONVERTFORMAT_USED

// The conversion method used is slightly inaccurate for a number of reasons.

// This function only serves as a convenience, where accuracy isn't

// needed beyond sounding more or less the same.

//

// (This will return early if hdr->format == format,

// since no conversion would be necessary)

bool convertFormat(AudioSampleFormatEnum format);

#endif

};

/******************************************************************************/

struct SoundEngineTrack { //88B

const AudioDataHeader* audio;

// Time at the point of audio being queued, in seconds

f64 timestamp;

f64 position;

f64 spd_old;

f64 spd_new;

f64 spdDelta;

StereoF32 vol_old;

StereoF32 vol_new;

StereoF32 volDelta;

StereoF32 volMaster;

u16 loops;

bool stopping;

char _padding[5];

};

// WARNING: IF A CURRENTLY PLAYING AUDIO CLIP IS DESTROYED BEFORE

// SOUNDENGINE, AN ACCESS VIOLATION MIGHT OCCUR IF ACTIVELY MIXING!

class SoundEngine {

SoundEngineTrack _tracks[64];

CRITICAL_SECTION _lock;

u16 _tracks_len = 64;

u8 _padding;

public:

// (ALL TRACKS MUST BE FULLY STOPPED BEFORE CHANGING SAMPLERATE,

// AS SAMPLERATE IS USED TO CALCULATE SOME AUDIO CLIP INFO!)

bool stopIfVolumeIsZero = true;

f32 sampleRate = (f32)sample_rate; // The *device*'s sample rate

StereoF32 volumeMaster = {1.0f, 1.0f};

// (Only the left channel of volumeMaster

// is used if the source audio is mono)

SoundEngine(u16 numTracks = 64, f32 _sampleRate = (f32)sample_rate);

~SoundEngine();

bool isTrackPlaying(u16 track);

u16 getActiveTracks();

inline u16 getTrackCount(){ return _tracks_len; }

// Sets the volume multiplier of a given track,

// or all active tracks if track == 0xFFFF

//

// When forced == true, the volume state is set instantly, instead of

// being interpolated over the course of the next call to mixTracks()

bool setVolume(f32 volumeL, f32 volumeR,

u16 track = 0xFFFF, bool forced = false);

// Sets the speed multiplier of a given track,

// or all active tracks if track == 0xFFFF

//

// Forced has the same behavior as setVolume

bool setSpeed(f64 speedNew,

u16 track = 0xFFFF, bool forced = false);

// Sets the change in volume over time for a given track.

// or all active tracks if track == 0xFFFF

//

// DeltaSeconds is the time it will take for the volume

// to go from 0.0x -> 1.0x (or vice versa)

bool setVolumeDelta(f32 deltaSecondsL, f32 deltaSecondsR,

u16 track = 0xFFFF);

// Same behavior as setVolumeDelta, except applied to the speed multiplier

bool setSpeedDelta(f64 deltaSeconds,

u16 track = 0xFFFF);

// Returns the track the audio was queued into,

// or 0xFFFF if no empty track was found,

// or 0xFFFE on error

u16 play(const AudioData& audio, // (only f32 or StereoF32 samples allowed!)

f32 volumeL = 1.0f, f32 volumeR = 1.0f, f64 speed = 1.0);

// (Make sure to stop all tracks before freeing any instances of AudioData,

// as to avoid any issues related to dangling pointers and whatnot)

//

// (Also, unless forced is set to true, this function

// won't work if stopIfVolumeIsZero is false!)

bool stop(u16 track = 0xFFFF, bool forced = false);

// Returns false if timeout is reached, true otherwise

//

// Set timeoutSeconds to 0 to wait indefinitely

bool waitForTrack(f64 timeoutSeconds = 0, u16 track = 0xFFFF);

// buffer_len is in elements, not bytes

//

// Returns referenceTimestamp, or 0.0 on error

f64 mixTracks(StereoF32* buffer, size_t buffer_len,

f64 referenceTimestamp = timeGetSeconds());

};

#endif /* SOUND_STUFF_USED */

#endif /* _SOUND_STUFF_HPP */

/******************************************************************************/

//"gdi_maze_game_2025-04-25\include\win32\audio.hpp":

#ifndef _WIN32_AUDIO_HPP

#define _WIN32_AUDIO_HPP

#include <public_stuff.hpp>

#include <windows.h>

#include <mmsystem.h>

#define timeGetDevCaps _Winmm_func.timeGetDevCaps_

#define timeBeginPeriod _Winmm_func.timeBeginPeriod_

#define waveOutGetNumDevs _Winmm_func.waveOutGetNumDevs_

#define waveOutGetDevCapsA _Winmm_func.waveOutGetDevCapsA_

#define waveOutGetVolume _Winmm_func.waveOutGetVolume_

#define waveOutSetVolume _Winmm_func.waveOutSetVolume_

#define waveOutGetErrorTextA _Winmm_func.waveOutGetErrorTextA_

#define waveOutOpen _Winmm_func.waveOutOpen_

#define waveOutClose _Winmm_func.waveOutClose_

#define waveOutPrepareHeader _Winmm_func.waveOutPrepareHeader_

#define waveOutUnprepareHeader _Winmm_func.waveOutUnprepareHeader_

#define waveOutWrite _Winmm_func.waveOutWrite_

#define waveOutPause _Winmm_func.waveOutPause_

#define waveOutRestart _Winmm_func.waveOutRestart_

#define waveOutReset _Winmm_func.waveOutReset_

#define waveOutBreakLoop _Winmm_func.waveOutBreakLoop_

#define waveOutGetPosition _Winmm_func.waveOutGetPosition_

#define waveOutGetPitch _Winmm_func.waveOutGetPitch_

#define waveOutSetPitch _Winmm_func.waveOutSetPitch_

#define waveOutGetPlaybackRate _Winmm_func.waveOutGetPlaybackRate_

#define waveOutSetPlaybackRate _Winmm_func.waveOutSetPlaybackRate_

#define waveOutGetID _Winmm_func.waveOutGetID_

#define waveOutMessage _Winmm_func.waveOutMessage_

union _Winmm_func_t {

FARPROC ptrs[1];

struct {

// Idk why these first two are in WinMM at all, but whatever

MMRESULT (WINAPI *timeGetDevCaps_)(LPTIMECAPS, UINT);

MMRESULT (WINAPI *timeBeginPeriod_)(UINT);

//UINT (WINAPI *waveOutGetNumDevs_)(void);

MMRESULT (WINAPI *waveOutGetDevCapsA_)(UINT_PTR, LPWAVEOUTCAPSA, UINT);

//MMRESULT (WINAPI *waveOutGetVolume_)(HWAVEOUT, LPDWORD);

MMRESULT (WINAPI *waveOutSetVolume_)(HWAVEOUT, DWORD);

//MMRESULT (WINAPI *waveOutGetErrorTextA_)(MMRESULT, LPSTR, UINT);

MMRESULT (WINAPI *waveOutOpen_)(LPHWAVEOUT, UINT, LPCWAVEFORMATEX, DWORD_PTR, DWORD_PTR, DWORD);

//MMRESULT (WINAPI *waveOutClose_)(HWAVEOUT);

MMRESULT (WINAPI *waveOutPrepareHeader_)(HWAVEOUT, LPWAVEHDR, UINT);

//MMRESULT (WINAPI *waveOutUnprepareHeader_)(HWAVEOUT, LPWAVEHDR, UINT);

MMRESULT (WINAPI *waveOutWrite_)(HWAVEOUT, LPWAVEHDR, UINT);

MMRESULT (WINAPI *waveOutPause_)(HWAVEOUT);

//MMRESULT (WINAPI *waveOutRestart_)(HWAVEOUT);

//MMRESULT (WINAPI *waveOutReset_)(HWAVEOUT);

//MMRESULT (WINAPI *waveOutBreakLoop_)(HWAVEOUT);

//MMRESULT (WINAPI *waveOutGetPosition_)(HWAVEOUT, LPMMTIME, UINT);

//MMRESULT (WINAPI *waveOutGetPitch_)(HWAVEOUT, LPDWORD);

//MMRESULT (WINAPI *waveOutSetPitch_)(HWAVEOUT, DWORD);

//MMRESULT (WINAPI *waveOutGetPlaybackRate_)(HWAVEOUT, LPDWORD);

//MMRESULT (WINAPI *waveOutSetPlaybackRate_)(HWAVEOUT, DWORD);

//MMRESULT (WINAPI *waveOutGetID_)(HWAVEOUT, LPUINT);

//MMRESULT (WINAPI *waveOutMessage_)(HWAVEOUT, UINT, DWORD_PTR, DWORD_PTR);

};

extern _Winmm_func_t _Winmm_func;

extern char _Winmm_names_a[];

extern char _Winmm_names_b[];

/******************************************************************************/

// Stereo audio samples as two 16-bit signed ints

struct StereoS16 { s16 l,r; };

int WaveOutInit();

void WaveOutQuit();

#endif /* _WIN32_AUDIO_HPP */

/******************************************************************************/

//"gdi_maze_game_2025-04-25\include\win32\input.hpp":

#ifndef _WIN32_INPUT_HPP

#define _WIN32_INPUT_HPP

#include <windows.h>

#include <public_stuff.hpp>

int InputInit();

void InputQuit();

union Event; // Forward declaration

// Returns false if queue is full

bool AddToEventQueue(Event& event);

// Returns a EVENT_NULL event if queue is empty

Event RemoveFromEventQueue();

#endif /* _WIN32_INPUT_HPP */

/******************************************************************************/

//"gdi_maze_game_2025-04-25\include\win32\video.hpp":

#ifndef _WIN32_VIDEO_HPP

#define _WIN32_VIDEO_HPP

#include <windows.h>

#define RegisterClassA _User32_func.RegisterClassA_

#define CreateWindowExA _User32_func.CreateWindowExA_

#define DefWindowProcA _User32_func.DefWindowProcA_

#define InvalidateRect _User32_func.InvalidateRect_

#define UpdateWindow _User32_func.UpdateWindow_

#define BeginPaint _User32_func.BeginPaint_

#define EndPaint _User32_func.EndPaint_

#define PeekMessageA _User32_func.PeekMessageA_

#define DispatchMessageA _User32_func.DispatchMessageA_

#define DestroyWindow _User32_func.DestroyWindow_

#define ReleaseDC _User32_func.ReleaseDC_

#define GetDC _User32_func.GetDC_

#define PostQuitMessage _User32_func.PostQuitMessage_

#define MessageBoxA _User32_func.MessageBoxA_

#define TranslateMessage _User32_func.TranslateMessage_

#define GetWindowLongA _User32_func.GetWindowLongA_

#define AdjustWindowRectEx _User32_func.AdjustWindowRectEx_

#define LoadCursorA _User32_func.LoadCursorA_

#define MapVirtualKeyA _User32_func.MapVirtualKeyA_

#define GetCursorPos _User32_func.GetCursorPos_

#define ScreenToClient _User32_func.ScreenToClient_

#define ShowCursor _User32_func.ShowCursor_

#define ClipCursor _User32_func.ClipCursor_

#define GetClientRect _User32_func.GetClientRect_

#define ClientToScreen _User32_func.ClientToScreen_

#define SetCapture _User32_func.SetCapture_

#define ReleaseCapture _User32_func.ReleaseCapture_

#define SetCursorPos _User32_func.SetCursorPos_

#define RegisterRawInputDevices _User32_func.RegisterRawInputDevices_

#define GetRawInputData _User32_func.GetRawInputData_

union _User32_func_t {

FARPROC ptrs[1];

struct {

ATOM (WINAPI *RegisterClassA_)(CONST WNDCLASSA*);

HWND (WINAPI *CreateWindowExA_)(DWORD, LPCSTR, LPCSTR, DWORD, int, int, int, int, HWND, HMENU, HINSTANCE, LPVOID);

LRESULT (WINAPI *DefWindowProcA_)(HWND, UINT, WPARAM, LPARAM);

WINBOOL (WINAPI *InvalidateRect_)(HWND, CONST RECT*, WINBOOL);

WINBOOL (WINAPI *UpdateWindow_)(HWND);

HDC (WINAPI *BeginPaint_)(HWND, LPPAINTSTRUCT);

WINBOOL (WINAPI *EndPaint_)(HWND, CONST PAINTSTRUCT*);

WINBOOL (WINAPI *PeekMessageA_)(LPMSG, HWND, UINT, UINT, UINT);

LRESULT (WINAPI *DispatchMessageA_)(CONST MSG*);

WINBOOL (WINAPI *DestroyWindow_)(HWND);

//int (WINAPI *ReleaseDC_)(HWND, HDC);

//HDC (WINAPI *GetDC_)(HWND);

VOID (WINAPI *PostQuitMessage_)(int);

int (WINAPI *MessageBoxA_)(HWND, LPCSTR, LPCSTR, UINT);

WINBOOL (WINAPI *TranslateMessage_)(CONST MSG*);

LONG (WINAPI *GetWindowLongA_)(HWND, int);

WINBOOL (WINAPI *AdjustWindowRectEx_)(LPRECT, DWORD, WINBOOL, DWORD);

HCURSOR (WINAPI *LoadCursorA_)(HINSTANCE, LPCSTR);

UINT (WINAPI *MapVirtualKeyA_)(UINT, UINT);

//WINBOOL (WINAPI *GetCursorPos_)(LPPOINT);

WINBOOL (WINAPI *ScreenToClient_)(HWND, LPPOINT);

int (WINAPI *ShowCursor_)(WINBOOL);

WINBOOL (WINAPI *ClipCursor_)(CONST RECT*);

WINBOOL (WINAPI *GetClientRect_)(HWND, LPRECT);

WINBOOL (WINAPI *ClientToScreen_)(HWND, LPPOINT);

HWND (WINAPI *SetCapture_)(HWND);

WINBOOL (WINAPI *ReleaseCapture_)(VOID);

WINBOOL (WINAPI *SetCursorPos_)(int, int);

WINBOOL (WINAPI *RegisterRawInputDevices_)(PCRAWINPUTDEVICE, UINT, UINT);

UINT (WINAPI *GetRawInputData_)(HRAWINPUT, UINT, LPVOID, PUINT, UINT);

};

extern _User32_func_t _User32_func;

extern char _User32_names_a[];

/******************************************************************************/

#define CreateCompatibleDC _Gdi32_func.CreateCompatibleDC_

#define CreateDIBSection _Gdi32_func.CreateDIBSection_

#define SelectObject _Gdi32_func.SelectObject_

#define DeleteObject _Gdi32_func.DeleteObject_

#define BitBlt _Gdi32_func.BitBlt_

#define DeleteDC _Gdi32_func.DeleteDC_

#define StretchBlt _Gdi32_func.StretchBlt_

#define CreateCompatibleBitmap _Gdi32_func.CreateCompatibleBitmap_

#define SetStretchBltMode _Gdi32_func.SetStretchBltMode_

#define SetDIBColorTable _Gdi32_func.SetDIBColorTable_

#define CreateSolidBrush _Gdi32_func.CreateSolidBrush_

union _Gdi32_func_t {

FARPROC ptrs[1];

struct {

HDC (WINAPI *CreateCompatibleDC_)(HDC);

HBITMAP (WINAPI *CreateDIBSection_)(HDC, CONST BITMAPINFO*, UINT, VOID**, HANDLE, DWORD);

HGDIOBJ (WINAPI *SelectObject_)(HDC, HGDIOBJ);

WINBOOL (WINAPI *DeleteObject_)(HGDIOBJ);

WINBOOL (WINAPI *BitBlt_)(HDC, int, int, int, int, HDC, int, int, DWORD);

WINBOOL (WINAPI *DeleteDC_)(HDC);

WINBOOL (WINAPI *StretchBlt_)(HDC, int, int, int, int, HDC, int, int, int, int, DWORD);

HBITMAP (WINAPI *CreateCompatibleBitmap_)(HDC, int, int);

int (WINAPI *SetStretchBltMode_)(HDC, int);

UINT (WINAPI *SetDIBColorTable_)(HDC, UINT, UINT, CONST RGBQUAD*);

HBRUSH (WINAPI *CreateSolidBrush_)(COLORREF);

};

extern _Gdi32_func_t _Gdi32_func;

extern char _Gdi32_names_a[];

/******************************************************************************/

int WindowInit(HINSTANCE hThisInst);

void WindowQuit();

#endif /* _WIN32_VIDEO_HPP */

/******************************************************************************/

//"gdi_maze_game_2025-04-25\src\draw_raycast_scene.hpp":

#ifndef _DRAW_RAYCAST_SCENE_HPP

#define _DRAW_RAYCAST_SCENE_HPP

#include <public_stuff.hpp>

// This assumes point has a length of 1

static inline Fpoint2d create_2d_vector(f32 angleRads,

f32 magnitude)

{

return {cosf(angleRads)*magnitude, sinf(angleRads)*magnitude};

}

void fill_scanlines(u32 y, u32 len, Color8 color,

Color8* dst = pixels);

#define RAYCAST_TEX_SIZE 32

#define RAYCAST_TEX_SIZE_TOTAL (8 + RAYCAST_TEX_SIZE*RAYCAST_TEX_SIZE)

void draw_raycast_scene(const s32* map, Point2d map_size,

Fpoint3d pos, // (pos.z is the angle, in radians)

const Color8 tiles[][RAYCAST_TEX_SIZE_TOTAL],

Color8 colorCeiling = 0xC0, Color8 colorFloor = 0x90,

u32 renderDistance = 100, f32 fov = 90.0f,

Color8* dst = pixels);

#endif /* _DRAW_RAYCAST_SCENE_HPP */

/******************************************************************************/

//"gdi_maze_game_2025-04-25\src\generate_maze.hpp":

#ifndef _GENERATE_MAZE_HPP

#define _GENERATE_MAZE_HPP

#include <public_stuff.hpp>

#define START_X 1

#define START_Y 1

// w & h must be odd, otherwise the south-eastern edges will be carved!

bool generate_maze(s32* map, u32 w, u32 h, s32 fillValue = 1);

#endif /* _GENERATE_MAZE_HPP */

/******************************************************************************/

//"gdi_maze_game_2025-04-25\src\map_and_textures.hpp":

//22050Hz, s16, mono

#define FOOTSTEP0_HERTZ 22050

#define FOOTSTEP0_FORMAT SMPFMT_S16

#define FOOTSTEP0_CHANNELS 1#define TEX_SIZE RAYCAST_TEX_SIZE

Color8 textures[8][8 + TEX_SIZE*TEX_SIZE] = {

// Mario-style brick wall

{ 32, 32, 0x0E, 0,0,0,0,0, // 1032 Bytes

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x00, 0x00, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x00, 0x00, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x00, 0x00, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x00, 0x00, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x00, 0x00, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x00, 0x00, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x00, 0x00,

},

// Smiley face

{ 32, 32, 0x00, 0,0,0,0,0, // 1032 Bytes

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x07, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

},

// Random junk

{ 32, 32, 0xCB, 0,0,0,0,0, // 1032 Bytes

0xA1, 0x1F, 0xA1, 0x89, 0xA1, 0xA1, 0xCB, 0xBD, 0x99, 0x43, 0x27, 0x5F, 0xCB, 0x1A, 0xDE, 0xE9, 0x96, 0xAE, 0xC2, 0x43, 0x5D, 0x08, 0xF8, 0xF8, 0x23, 0xE3, 0x18, 0x18, 0x18, 0x1F, 0xE3, 0xE3,

0x1F, 0x12, 0xB5, 0xA1, 0xA1, 0xA1, 0xCB, 0xDB, 0x43, 0xAF, 0x1B, 0x55, 0x5F, 0x55, 0xDE, 0xE9, 0x96, 0xAE, 0x43, 0x5D, 0x43, 0x18, 0x18, 0x18, 0x18, 0x18, 0xE3, 0xF8, 0x18, 0x1F, 0xF7, 0xB5,

0x1F, 0x12, 0x99, 0xB5, 0xB5, 0xDB, 0xDB, 0xA1, 0x43, 0xBD, 0x55, 0x27, 0x5F, 0x27, 0x55, 0x55, 0x55, 0x55, 0x55, 0x5D, 0x08, 0xF8, 0xCB, 0xDB, 0xCB, 0xCB, 0xF8, 0x06, 0x18, 0xA1, 0x7D, 0x7D,

0xCB, 0x12, 0xCB, 0xDB, 0xDB, 0xB5, 0xCB, 0x43, 0x3F, 0x55, 0x1B, 0x27, 0x5F, 0x12, 0x27, 0x12, 0x43, 0x60, 0xBB, 0x5D, 0x55, 0x55, 0x4A, 0xDB, 0xCB, 0xB3, 0xF8, 0x0C, 0x7D, 0x7D, 0x1F, 0x0C,

0x20, 0x12, 0xCB, 0xDB, 0xCB, 0x89, 0xCB, 0x43, 0x55, 0xB5, 0x1B, 0x27, 0x5F, 0x99, 0x18, 0x43, 0xCB, 0x60, 0x08, 0x5D, 0x76, 0x55, 0x76, 0xDB, 0x0C, 0x0C, 0x7D, 0x7D, 0x18, 0x83, 0x0C, 0xB5,

0x20, 0x12, 0x3C, 0x3C, 0xDB, 0x89, 0xCB, 0xAB, 0x55, 0x5E, 0x1B, 0xCB, 0x5F, 0x18, 0x43, 0x27, 0xBB, 0x60, 0x08, 0x5D, 0xB5, 0x55, 0x0C, 0x0C, 0x7D, 0x7D, 0x06, 0x83, 0x83, 0x1F, 0x0C, 0x91,

0xBD, 0x20, 0xBD, 0xBD, 0xDB, 0xCB, 0x89, 0x55, 0x4A, 0x48, 0x1B, 0xA1, 0x5F, 0xCB, 0x43, 0x27, 0xBB, 0x60, 0xF8, 0x5D, 0x80, 0x55, 0x7D, 0x7D, 0xDB, 0x83, 0x83, 0x83, 0x18, 0x1F, 0x91, 0xCB,

0x05, 0x20, 0xCB, 0xCB, 0xFC, 0xDB, 0x55, 0xCB, 0x4A, 0x43, 0x48, 0x48, 0x7D, 0x7D, 0x43, 0x27, 0x0A, 0x60, 0x5D, 0x0C, 0x7D, 0x7D, 0xC5, 0x83, 0x83, 0x83, 0x91, 0xA1, 0x1F, 0xF8, 0x18, 0x18,

0x0B, 0xB5, 0x20, 0x05, 0x05, 0xDB, 0x55, 0xBD, 0x4A, 0x43, 0xB1, 0x7D, 0x5F, 0x48, 0x7D, 0x7D, 0x27, 0x24, 0x7D, 0x7D, 0xDF, 0x83, 0x83, 0x5E, 0x83, 0xCB, 0x18, 0x0C, 0x1F, 0xF8, 0x0C, 0x0C,

0x22, 0xB5, 0x20, 0xD6, 0xD6, 0xD6, 0x55, 0xD6, 0x4A, 0x7D, 0x7D, 0x1B, 0x43, 0x5F, 0x43, 0x48, 0x7D, 0x7D, 0x60, 0x83, 0x83, 0x24, 0x83, 0x83, 0x06, 0xCB, 0xCB, 0x3B, 0x3B, 0x3B, 0x3B, 0x3B,

0x0B, 0xB5, 0x22, 0x20, 0x6F, 0xCB, 0x55, 0x4A, 0x7D, 0x27, 0x43, 0x27, 0x43, 0x5F, 0x43, 0x27, 0x47, 0x27, 0x83, 0x27, 0x27, 0x83, 0x55, 0x3B, 0x3B, 0x3B, 0x3B, 0x1F, 0x18, 0xF8, 0x75, 0xAE,

0xE3, 0xB5, 0x5E, 0x20, 0xA1, 0xCB, 0x55, 0x7D, 0x5E, 0xA7, 0xD2, 0x43, 0x18, 0x71, 0x6E, 0x27, 0x27, 0x83, 0x60, 0x3B, 0x83, 0x3B, 0x55, 0x06, 0xF1, 0x0C, 0x24, 0x24, 0x18, 0xE3, 0xAE, 0x91,

0x52, 0x52, 0x52, 0xCB, 0x20, 0x7D, 0x7D, 0x6A, 0x6A, 0x6A, 0x6A, 0x6A, 0x1D, 0x71, 0x2F, 0x6E, 0x6E, 0x83, 0x60, 0xCB, 0x83, 0x36, 0x06, 0x6B, 0x6B, 0x6B, 0x6B, 0x6B, 0x6B, 0x6B, 0x91, 0xCB,

0x6A, 0x6A, 0x6A, 0x6A, 0x7D, 0x52, 0x52, 0x55, 0x52, 0xCB, 0x27, 0x27, 0x6A, 0x71, 0x6A, 0x3B, 0x83, 0x6E, 0x6B, 0x83, 0x75, 0x6B, 0x6B, 0x55, 0x0C, 0x27, 0x1F, 0x18, 0xAE, 0x3B, 0x6B, 0x6B,

0xA1, 0xCB, 0xE3, 0x7D, 0x53, 0x53, 0xE3, 0x55, 0x4A, 0x52, 0x52, 0x52, 0x71, 0x5F, 0x6A, 0x83, 0x4A, 0x60, 0x60, 0x83, 0x75, 0x4A, 0x4A, 0x4A, 0x55, 0x4A, 0x4A, 0x4A, 0x3B, 0x1D, 0xE3, 0xCB,

0xC4, 0xC4, 0xC4, 0xE3, 0x7D, 0x22, 0x53, 0x55, 0x27, 0x4A, 0x10, 0x3C, 0x71, 0x5F, 0x51, 0x6A, 0x18, 0x60, 0x83, 0x75, 0x75, 0x75, 0x3B, 0x3B, 0x27, 0x55, 0x18, 0xAE, 0x4A, 0x4A, 0x4A, 0x4A,

0xBD, 0xBD, 0xBD, 0xE3, 0x7D, 0x22, 0x14, 0x56, 0x53, 0x53, 0x53, 0x39, 0x73, 0x5F, 0x7C, 0x7C, 0x77, 0x83, 0x75, 0xEB, 0x43, 0x45, 0xDB, 0x27, 0x27, 0x1F, 0x55, 0xD2, 0xD2, 0x4A, 0x4A, 0x4A,

0x6B, 0xA1, 0xCB, 0xBD, 0xE3, 0x7D, 0x56, 0x04, 0xD3, 0x27, 0x7C, 0x7C, 0x7C, 0x7C, 0x75, 0x60, 0x7C, 0x83, 0x5D, 0x43, 0x43, 0x43, 0x27, 0x20, 0x1F, 0x4A, 0x55, 0x4A, 0x4A, 0x35, 0xDB, 0x7D,

0xE3, 0x6B, 0x6B, 0xAE, 0xAE, 0x56, 0x7D, 0x7C, 0x7C, 0x7C, 0x2F, 0x73, 0x5F, 0x42, 0x74, 0x55, 0x83, 0x7C, 0x5D, 0x31, 0x12, 0x43, 0x43, 0x4A, 0x4A, 0x18, 0x27, 0x55, 0x20, 0x7D, 0x7D, 0xE3,

0xAE, 0xA1, 0xE3, 0x6B, 0x6B, 0x14, 0x7C, 0x7D, 0x3E, 0x39, 0x27, 0x73, 0x5F, 0x74, 0x2F, 0x83, 0x60, 0x7C, 0x5D, 0x31, 0xD2, 0x43, 0x4A, 0x1F, 0x18, 0x27, 0xE3, 0xD2, 0x7D, 0x55, 0xD2, 0xDB,

0xCB, 0xA1, 0xCB, 0x56, 0x14, 0x6B, 0x7C, 0x7D, 0xCB, 0x3E, 0x43, 0x74, 0x5F, 0x74, 0x4A, 0x83, 0x6B, 0x7C, 0x6B, 0x6B, 0x31, 0x00, 0x4A, 0x43, 0x18, 0x27, 0x12, 0x7D, 0xE3, 0x67, 0x55, 0x55,

0xF5, 0xCB, 0x56, 0xCB, 0x14, 0x7C, 0x0B, 0x23, 0x7F, 0x6B, 0x6B, 0x43, 0x74, 0x6B, 0x6B, 0x83, 0x60, 0x4A, 0x55, 0x5D, 0x6B, 0x6B, 0x43, 0x1F, 0x43, 0x7D, 0x7D, 0x89, 0x12, 0x12, 0xBD, 0xCB,

0xCB, 0x56, 0xA1, 0xCB, 0x14, 0x7D, 0x23, 0xFD, 0x7F, 0x43, 0x43, 0x6B, 0x6B, 0x2F, 0x27, 0x83, 0x60, 0x27, 0x43, 0x5D, 0x55, 0x31, 0x6B, 0x7D, 0x7D, 0x43, 0x18, 0x89, 0x18, 0x18, 0x12, 0xBD,

0x56, 0xBD, 0x45, 0x14, 0xFD, 0x7D, 0x23, 0x7F, 0xB5, 0x27, 0x04, 0x42, 0x5F, 0xC6, 0x2F, 0x83, 0x60, 0x43, 0x24, 0x5D, 0x18, 0x7D, 0x7D, 0x43, 0x6B, 0x6B, 0x43, 0x89, 0xBB, 0x06, 0xBB, 0x12,

0xCB, 0xCB, 0xBD, 0x16, 0x0B, 0x7D, 0x3A, 0x7F, 0xC5, 0x27, 0xCB, 0x42, 0x5F, 0xE3, 0x2F, 0x83, 0x60, 0x2F, 0x43, 0x5D, 0x7D, 0x43, 0x55, 0x27, 0xA1, 0x43, 0x6B, 0x6B, 0xE3, 0x05, 0xCB, 0x6B,

0xC5, 0xFD, 0xFD, 0x16, 0x23, 0xCB, 0x7D, 0x7F, 0x27, 0xBD, 0x42, 0x40, 0x5F, 0xDB, 0x2F, 0x83, 0xFF, 0x60, 0x7D, 0x7D, 0x5D, 0x18, 0x30, 0x55, 0xEB, 0xEB, 0xEB, 0x89, 0x6B, 0x6B, 0x6B, 0xE3,

0xFD, 0xCB, 0xCB, 0x16, 0x23, 0x3A, 0x7F, 0xE3, 0x27, 0x27, 0x42, 0x5F, 0x27, 0x27, 0xDB, 0x83, 0x7D, 0x7D, 0x27, 0x0C, 0x5D, 0x2F, 0x30, 0x27, 0x55, 0x55, 0xEB, 0xEB, 0x1D, 0x1D, 0x1D, 0xDE,

0xCB, 0x05, 0x05, 0x24, 0x3A, 0xCB, 0x7F, 0x24, 0xCB, 0xFD, 0x42, 0x5F, 0x18, 0x24, 0x27, 0x83, 0x12, 0x60, 0xAE, 0x0C, 0x5D, 0x18, 0x27, 0xDB, 0x27, 0x99, 0x55, 0x89, 0xF7, 0xFD, 0x1D, 0x1D,

0xAB, 0xCB, 0x0B, 0x3A, 0x24, 0x24, 0x7F, 0xFD, 0xFD, 0x42, 0x40, 0x5F, 0x18, 0x7D, 0x7D, 0x83, 0xDB, 0x60, 0xE3, 0x0C, 0x5C, 0xDB, 0x27, 0x04, 0x27, 0x22, 0x99, 0x55, 0xCB, 0xF7, 0x05, 0x1D,

0xF6, 0x0B, 0xF6, 0x3A, 0x16, 0x7F, 0x7D, 0xAE, 0xE3, 0x42, 0x40, 0x7D, 0x7D, 0x18, 0x24, 0x83, 0x1F, 0x60, 0xDB, 0x5C, 0x18, 0x9C, 0x1F, 0x27, 0x27, 0xFD, 0x99, 0x4A, 0x55, 0xF7, 0x05, 0xFD,

0xFD, 0x0B, 0x3A, 0xFD, 0x16, 0x7F, 0x05, 0x7D, 0xE3, 0x42, 0x7D, 0x60, 0xBD, 0x18, 0x24, 0x83, 0x27, 0x60, 0x12, 0x5C, 0x18, 0xE3, 0x1F, 0x18, 0x27, 0xDB, 0xCB, 0xB5, 0xB5, 0x55, 0xB5, 0xB5,

0x59, 0x3A, 0xCB, 0xCB, 0xAB, 0x7F, 0xCB, 0x7D, 0x7D, 0x7D, 0xA1, 0x60, 0xA1, 0x18, 0xBD, 0x83, 0x27, 0x60, 0x5C, 0x04, 0x18, 0x9C, 0x1F, 0x04, 0x27, 0x27, 0xB5, 0x99, 0x4A, 0x22, 0x55, 0x05,

},

{}, // (This is filled with the xor texture!)

// Finish point tile

{ 32, 32, 0x00, 0,0,0,0,0, // 1032 Bytes

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0xFE, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0xFE, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00,

0x00, 0x00, 0xFE, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00,

0x00, 0x00, 0x00, 0xFE, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xFE, 0xFE, 0xFE, 0x00, 0xFE, 0xFE, 0x00, 0x00, 0xFE, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xFE, 0x00, 0xFE, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFE, 0xFE, 0xFE, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xFE, 0x00, 0xFE, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xFE, 0x00, 0xFE, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFE, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFE, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

},

};

/******************************************************************************/

#define MAP_MAX 81

s32 map[MAP_MAX*MAP_MAX];

/******************************************************************************/

//"gdi_maze_game_2025-04-25\src\win32\_WindowProc.hpp":

#ifndef _WIN32__WINDOWPROC_HPP

#define _WIN32__WINDOWPROC_HPP

#include <win32/video.hpp>

#include <win32/input.hpp>

#include <windowsx.h>

#include <public_stuff.hpp>

//assumes window is without a menu

static inline Point2d CalculateWindowSize(u32 innerWidth, u32 innerHeight,

u32 flags, u32 flagsEx)

{

RECT winSize;

winSize.left = 0;

winSize.top = 0;

winSize.right = innerWidth;

winSize.bottom = innerHeight;

AdjustWindowRectEx(&winSize, flags, false, flagsEx);

Point2d winSizeAdjusted;

winSizeAdjusted.x = winSize.right - winSize.left;

winSizeAdjusted.y = winSize.bottom - winSize.top;

return winSizeAdjusted;

}

static inline Rect2d ConvertToKitRect(RECT& rectIn){

Rect2d rectOut;

rectOut.x = rectIn.left;

rectOut.y = rectIn.top;

rectOut.w = rectIn.right - rectIn.left;

rectOut.h = rectIn.bottom - rectIn.top;

return rectOut;

}

static inline RECT ConvertFromKitRect(Rect2d& rectIn){

RECT rectOut;

rectOut.left = rectIn.x;

rectOut.top = rectIn.y;

rectOut.right = rectIn.x + rectIn.w;

rectOut.bottom = rectIn.y + rectIn.h;

return rectOut;

}

union KEY_Params {

struct {

u32 repeatCount : 16; // 0 -> 15

u32 scanCode : 8; //16 -> 23

u32 extendedKey : 1; //24

u32 _reserved : 4; //25 -> 28

u32 altKeyDown : 1; //29

u32 prevUnpressed : 1; //30

u32 currUnpressed : 1; //31

};

u32 value;

KEY_Params(u32 _value) : value(_value) {}

};

// This event handler is used for KEY_CHAR, KEY_UP, and KEY_DOWN events

static inline void HANDLE_KEY_CHARUPDOWN(Event& event,

bool charEvent,u8 virtualKeyCode,

KEY_Params& params, u16 kmods)

{

if(charEvent){

event.type = EVENT_KEY_CHAR;

} else {

if(params.currUnpressed) event.type = EVENT_KEY_UP;

else event.type = EVENT_KEY_DOWN;

}

event.key.kmods = kmods;

event.key.pkey = params.scanCode;

event.key.vkey = virtualKeyCode;

event.key.pressed = !params.currUnpressed;

event.key.repeat = params.repeatCount>0; //modified to act as a boolean

event.key.ischar = charEvent;

}

union MOUSE_ButtonStates {

// The positions of these bits are the same as

// the bitmasks in Event_Mouse_ButtonEnum

struct {

u8 left : 1;

u8 middle : 1;

u8 right : 1;

u8 x1 : 1;

u8 x2 : 1;

u8 ctrl : 1; // 'Is the control key currently pressed?'

u8 shift : 1; // 'Is the shift key currently pressed?'

u8 _unused : 1;

};

u8 value;

MOUSE_ButtonStates() : value(0) {}

MOUSE_ButtonStates(u8 _value) : value(_value) {}

};

extern Point2d win_size;

extern MOUSE_ButtonStates mbutton_states;

// Converts window coords to canvas coords

static inline void ConvertCoordinates(f32& x, f32& y){

x = (x/(win_size.x-1)) * ((f32)CANVAS_W-1.0f);

y = (y/(win_size.y-1)) * ((f32)CANVAS_H-1.0f);

}

static inline void HANDLE_MOUSE_MOVED(Event& event, u8 buttonStates,

Point2d& previous, Point2d& current)

{

event.type = EVENT_MOUSE_MOVED;

event.mouse.x = current.x;

event.mouse.y = current.y;

ConvertCoordinates(event.mouse.x, event.mouse.y);

Fpoint2d _previous = { (f32)previous.x, (f32)previous.y };

Fpoint2d _current = { (f32)current.x, (f32)current.y };

ConvertCoordinates(_previous.x, _previous.y);

ConvertCoordinates(_current.x, _current.y);

event.mouse.dx = _current.x - _previous.x;

event.mouse.dy = _current.y - _previous.y;

event.mouse.button = buttonStates;

event.mouse.pressed = buttonStates!=0;

}

// Same event handler is used for both MOUSE_HWHEEL and MOUSE_VWHEEL events

static inline void HANDLE_MOUSE_HVWHEEL(Event& event,

bool verticalScroll, s16 scrollAmount,

u8 buttonStates, Point2d& mousePos)

{

if(verticalScroll){

event.type = EVENT_MOUSE_VWHEEL;

event.mouse.dy = (f32)scrollAmount/WHEEL_DELTA;

} else {

event.type = EVENT_MOUSE_HWHEEL;

event.mouse.dx = (f32)scrollAmount/WHEEL_DELTA;

}

event.mouse.x = mousePos.x;

event.mouse.y = mousePos.y;

ConvertCoordinates(event.mouse.x, event.mouse.y);

event.mouse.button = buttonStates;

event.mouse.pressed = buttonStates!=0;

}

// Same event handler is used for both MOUSE_UP and MOUSE_DOWN events

static inline void HANDLE_MOUSE_UPDOWN(Event& event, Point2d& clickPosition,

u8 buttonStates, bool pressed, bool doubleClick)

{

if(pressed) event.type = EVENT_MOUSE_DOWN;

else event.type = EVENT_MOUSE_UP;

event.mouse.x = clickPosition.x;

event.mouse.y = clickPosition.y;

ConvertCoordinates(event.mouse.x, event.mouse.y);

event.mouse.button = buttonStates;

event.mouse.pressed = pressed;

event.mouse.dblClick = doubleClick;

}

static void add_event(Event& evt);

// flag_which must be one of the "DOWN" flags (Ex.: RI_MOUSE_BUTTON_1_DOWN)

// (Also, timestamp is assumed to have already been set inside evt!)

static void send_raw_mbutton_press(Event& evt, u16 flags,

u16 flag_which, u8 button_which);

// This doesn't handle a single mouse event,

// but rather all of the mouse events when the cursor is trapped

static inline void HANDLE_MOUSE_RAWINPUT(Event& evt,

u16 flags, f32 deltaWheel,

f32 deltaX, f32 deltaY)

{

QueryPerformanceCounter((LARGE_INTEGER*)&evt.common.timestamp);

evt.mouse.button = mbutton_states.value;

send_raw_mbutton_press(evt, flags, RI_MOUSE_BUTTON_1_DOWN, MBUTTON_LEFT );

send_raw_mbutton_press(evt, flags, RI_MOUSE_BUTTON_2_DOWN, MBUTTON_MIDDLE);

send_raw_mbutton_press(evt, flags, RI_MOUSE_BUTTON_3_DOWN, MBUTTON_RIGHT );

send_raw_mbutton_press(evt, flags, RI_MOUSE_BUTTON_4_DOWN, MBUTTON_X1 );

send_raw_mbutton_press(evt, flags, RI_MOUSE_BUTTON_5_DOWN, MBUTTON_X2 );

evt.mouse.pressed = evt.mouse.button!=0;

if(flags&RI_MOUSE_WHEEL){

evt.type = EVENT_MOUSE_VWHEEL;

evt.mouse.dy = deltaWheel;

_add_event_func: add_event(evt);

} else if(flags&RI_MOUSE_HWHEEL){

evt.type = EVENT_MOUSE_HWHEEL;

evt.mouse.dx = deltaWheel;

goto _add_event_func;

}

if(deltaX != 0.0f || deltaY != 0.0f){

evt.type = EVENT_MOUSE_MOVED;

evt.mouse.dx = deltaX;

evt.mouse.dy = deltaY;

add_event(evt);

}

#endif /* _WIN32__WINDOWPROC_HPP */