work for 2024-12-13 (1/2)

/******************************************************************************/
/******************************************************************************/
//"2024-12-13\iso_game\callbacks.cpp":
#include <include_all.hpp>

using namespace kit;





void cb_music_fade_in(void* userdata_a, void* userdata_b);
void cb_music_fade_out(void* userdata_a, void* userdata_b);

AudioDevice* audio = nullptr;
bool  audioIsReady = false;

SoundEngine* sfx = nullptr;

s32         music_index      = -1;
Stereo_f32  music_vol        = {1.0f, 1.0f};
Xmp*        music            = nullptr;
Stereo_s16* music_buffer_src = nullptr;
Stereo_f32* music_buffer_dst = nullptr;
AudioFade   music_fade       = {cb_music_fade_in, cb_music_fade_out};





struct music_id_t { u32 name_index, pos = 0; }; //8B

#define MUSIC_NAME_musicbox1_v1      0

#define MUSIC_NAME_PREFIX "dat/music/"

static const char* music_names[] = {
  MUSIC_NAME_PREFIX "musicbox1_v1.xm",
};

#define MUSIC_IDS_LEN (sizeof(music_ids)/sizeof(music_id_t))

static music_id_t music_ids[] = {
  {MUSIC_NAME_musicbox1_v1, 0},
  {MUSIC_NAME_musicbox1_v1, 2},
  {MUSIC_NAME_musicbox1_v1, 6},
};





bool music_playing = false;

void cb_music_fade_in(void* userdata_a, void* userdata_b){
  u32 sampleRate = (u32)(u64)userdata_a; //lol
  (void)userdata_b;

  if(!sampleRate  ||  !music  ||  music_index < 0){
    music_fade.fadeIn = false;
    return;
  }

  if((u32)music_index >= MUSIC_IDS_LEN){ kit_LogError("music_index >= MUSIC_IDS_LEN"); return; }

  music_id_t id = music_ids[music_index];
  const char* name = music_names[id.name_index];

  if(name == nullptr){ kit_LogError("music name = nullptr"); return; }
  if(!fileio::exists(name)){ kit_LogError("music module \"%s\" doesn't exist", name); return; }

  s32 result = music->moduleLoad(name);
  if(result){ kit_LogError("failed to load music module \"%s\": code = %i", name, result); return; }

  result = music->playerStart(sampleRate);
  if(result){ kit_LogError("failed to start music player: code = %i", result); return; }

  music->setPlayerPosition(id.pos);

  music_playing = true;

}





void cb_music_fade_out(void* userdata_a, void* userdata_b){
  (void)userdata_a;
  (void)userdata_b;

  if(!music) return;

  music->moduleStop();
  music->moduleRelease();
  music->playerEnd();

  if(music_index >= 0) music_fade.fadeIn = true;

  music_playing = false;

}





#define src music_buffer_src
#define dst music_buffer_dst

#define EQ_1f(_stereo_smp) \
  ((_stereo_smp).l==1.0f && (_stereo_smp).r==1.0f)

#define EQ_smp(_stereo_smp_a, _stereo_smp_b) \
  ((_stereo_smp_a).l==(_stereo_smp_b).l && (_stereo_smp_a).r==(_stereo_smp_b).r)

Stereo_f32 music_vol_old = music_vol;

static s32 cb_music_thread(void* userdata){
  s32 result = 0;

  u32 dst_len  = (u32)(u64)userdata; //lol
  u32 dst_size = dst_len*sizeof(Stereo_f32);
  u32 src_size = dst_len*sizeof(Stereo_s16);


  if(!music || !src || !dst){
    result = -KIT_XMP_ERROR_STATE; _err:
    if(dst) memory::set(dst, 0, dst_size);
    return result;

  }


  f32       t     = 0.0f;
  const f32 t_inc = 1.0f/dst_len;

  if(music_playing){
    result = music->playBuffer(src, src_size, true);
    if(result) goto _err;

    if(EQ_1f(music_vol_old) && EQ_1f(music_vol)){ //no need to multiply at all
      for(u32 i=0; i<dst_len; ++i){
        dst[i].l = ((f32)src[i].l/32768);
        dst[i].r = ((f32)src[i].r/32768);
      }

    } else if(EQ_smp(music_vol_old, music_vol)){ //no need to interpolate
      for(u32 i=0; i<dst_len; ++i){
        dst[i].l = ((f32)src[i].l/32768) * music_vol.l;
        dst[i].r = ((f32)src[i].r/32768) * music_vol.r;
      }

    } else { //must interpolate between old and new
      for(u32 i=0; i<dst_len; ++i){
        dst[i].l = ((f32)src[i].l/32768) * LERP2(music_vol.l, music_vol_old.l, t);
        dst[i].r = ((f32)src[i].r/32768) * LERP2(music_vol.r, music_vol_old.r, t);
        t += t_inc;
      }

    }

  } else {
    memory::set(dst, 0, dst_size);

  }


  if(music_index < 0) music_fade.fadeIn = false;
  music_fade.applyFade(&dst->l, dst_len*2, 2);

  music_vol_old = music_vol;

  return result;

}

#undef src
#undef dst





s32 cb_audio(void* _dst, const AudioDeviceInfo& info){
  //music_buffer_src is the first thing to be freed in the 'audio cleanup'
   //portion of main(), so if it == nullptr, that means audio is in
   //the middle of being uninitialized
   //(that, or music_buffer_src simply hasn't been set yet,
   // in which case it should exit early anyway)
  if(!audioIsReady  ||  music_buffer_src == nullptr) return 0;

  Stereo_f32* dst     = (Stereo_f32*)_dst;
  u16         dst_len = info.sampleFrames;

  //process music in a separate thread...
  Thread music_thread(cb_music_thread, (void*)(u64)dst_len, true, 0, "music");

  //mix whatever sound effects that may be actively playing
  if(sfx) sfx->mixTracks(dst, dst_len, info.timeStartMS);

  s32 result = music_thread.waitUntilDone();
  if(result && result != -999) kit_LogError("music thread returned %i", result);

  for(u16 i=0; i<dst_len; ++i){
    //...before mixing its output into dst
     //(+= instead of =, since sfx has already mixed its own output into dst)
    dst[i].l += music_buffer_dst[i].l;
    dst[i].r += music_buffer_dst[i].r;

    //finally, clamp the samples so that they aren't out of bounds
    dst[i].l = CLAMP(dst[i].l, -1.0f, 1.0f);
    dst[i].r = CLAMP(dst[i].r, -1.0f, 1.0f);

  }

  return 0;

}
/******************************************************************************/
/******************************************************************************/
//"2024-12-13\iso_game\main.cpp":
#include <include_all.hpp>

#include <windows.h>

#include <unistd.h> //for getcwd()
#include <cstdlib> //for std::srand & std::rand

#if RAND_MAX > 32767
#error "RAND_MAX > 32767; frand should be altered to accomodate"
#endif


using namespace kit;


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


Window*        wndw = nullptr;
Renderer*      rndr = nullptr;
BFont_Texture* text = nullptr;
BFont_Texture* textColored[16] = {0};


/****************************** "callbacks.cpp" *******************************/


s32 cb_audio(void* _dst, const AudioDeviceInfo& info);

extern AudioDevice* audio;
extern bool  audioIsReady;

extern SoundEngine* sfx;

extern Xmp*        music;
extern Stereo_s16* music_buffer_src; //xmp fills this
extern Stereo_f32* music_buffer_dst; //dst=src, before applying music_fade
extern AudioFade   music_fade;


/****************************** "utils_core.cpp" ******************************/


void tile_init();

extern Texture* tImg;


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


//just in case you plan on manipulating music_index directly
 //to feed it into music_play or something
static s32 music_index_old = music_index;

void music_play(s32 index){
  index = MAX(index, -1);
  if(!audio  ||  index == music_index_old) return;
  audio->lock();

  music_fade.fadeIn = false;
  music_fade.fadeOutCalled = false;
  music_index_old = music_index = index;

  audio->unlock();

}



static u32 sampleRate = 0;

void music_setFadeDelta(f32 fadeTimeSeconds){
  if(!sampleRate) return; //just in case
  music_fade.setDelta(sampleRate, fadeTimeSeconds);

}



//assumes RAND_MAX is 32767
#define GET_FRAND_VALUE(cast) ( (cast)(std::rand()<<15|std::rand())/0x3FFFFFFF )

f64 frand  (){  return GET_FRAND_VALUE(f64);              } // 0.0f -> 1.0f
f64 frand2 (){  return GET_FRAND_VALUE(f64)*2.0f - 1.0f;  } //-1.0f -> 1.0f
f32 frandf (){  return GET_FRAND_VALUE(f32);              } // 0.0f -> 1.0f
f32 frandf2(){  return GET_FRAND_VALUE(f32)*2.0f - 1.0f;  } //-1.0f -> 1.0f


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





#define PREVENT_RUNNING_WHILE_ZIPPED 1

int user_main(int argc, char** argv);

int main(int argc, char** argv){  int returnStatus = -1;  try {
  u64 timeDelta, timeStartAudio, timeStartAll = time::getMS();

#if PREVENT_RUNNING_WHILE_ZIPPED == 1
  //this should hopefully prevent people from executing the program
   //before it's unzipped (in most cases, at least)
  #define EXTRACT_MSG "This program must be ran normally, after being unzipped"
  char cwd[256];
  getcwd(cwd, sizeof(cwd));
  cwd[255] = 0; //just in case
  u32 lastChar = strnLen(cwd)-1;
  if(cwd[lastChar]=='/' || cwd[lastChar]=='\\') cwd[lastChar] = 0;

  //first check
  //checks if the program's current working directory is
   //"C:\Users\<name>\AppData" (specific to windows)
  #if defined(_WIN32)
  {
    u32 i = 0,  backSlashCount = 0;
    bool foundUsers = false;

    if((cwd[0]|32) == 'c') //(x|32 makes the char x lowercase)
    for(; i<256; ++i){ _start:

      if(cwd[i] == '\0') break;
      if(cwd[i] == '\\') ++backSlashCount;

      if(backSlashCount == 1){
        if(!strnCmp("Users", &cwd[++i], 5)) foundUsers = true;
        goto _start; //++i should only occur once this iteration

      }

      if(foundUsers  &&  backSlashCount == 3){
        if(!strnCmp("AppData", &cwd[++i], 7)) throw EXTRACT_MSG;
        break;

      }

    }

  }
  #endif /* defined(_WIN32) */

  //second check
  //all this does is it clips the executable name from the
   //full path (argv[0]) to compare it to the current working directory
  //(this should work even if argv[0] is something else,
   //since you're supposed to run this program normally anyway)
  if(argc > 0){
    char*  path     = argv[0];
    size_t path_len = strnLen(path);
    s32    i        = path_len-1;
    bool   fwdSlash = false;

    if(path_len < 256)
    for(; i>=0; --i){
      fwdSlash = path[i]=='/';
      if(fwdSlash  ||  path[i] == '\\'){ path[i] = 0; break; }
    }

    if(i >= 0){
      //throw if the paths are different
      if(strnCmp(path, cwd)) throw EXTRACT_MSG;
      //put slash back in case user wants to reference argv[0] too
      path[i] = (fwdSlash) ? '/' : '\\';
    }

  }
#endif /* PREVENT_RUNNING_WHILE_ZIPPED == 1 */

  initSubsystems(KINIT_EVERYTHING);

/********************************* AUDIO INIT *********************************/

  AudioDeviceInfo audio_info = audiofunc::getDefaultDevInfo();
  audio_info.sampleFormat = SMPFMT_F32;
  audio_info.numChannels  = 2;
  audio_info.zeroBuffer   = true;
  audio_info.callback     = cb_audio;
  audio_info.userdata     = nullptr;

  //(libxmp can only take sample rates between 8kHz and 48kHz)
  audio_info.sampleRate = CLAMP(audio_info.sampleRate, 8000, 48000);
  //actually, for some reason setting audio_info's sampleRate to be lower
   //than 15701 causes _audio.pause() to hang indefinitely (for me at least)
  //tbd: figure out why this happens
  audio_info.sampleRate = MAX(audio_info.sampleRate, 15701);
  sampleRate = audio_info.sampleRate;

  AudioDevice _audio(nullptr, audio_info, false);  audio = &_audio;
  _audio.play(); //begin fading in audio
  timeStartAudio = time::getMS();

  SoundEngine _sfx(SFX_TRACKS, sampleRate);  sfx = &_sfx;

  Xmp _music;  music = &_music;

  //65536 elements specifically is chosen, so that even if the number
   //of sample frames given to the audio callback changes somehow,
   //there will always be enough space for copying (sample frame count is u16)
  //(src = 262,144 Bytes, dst = 524,288 Bytes)
  music_buffer_src = (Stereo_s16*)memory::alloc2(65536*sizeof(Stereo_s16));
  music_buffer_dst = (Stereo_f32*)memory::alloc2(65536*sizeof(Stereo_f32));

  music_fade.userdata_a = (void*)(u64)sampleRate;
  music_setFadeDelta(); //set fade to its default

  //...

/********************************* VIDEO INIT *********************************/

  audioIsReady = true;

{ //<- closes at the end of video cleanup

  Window _wndw(WIN_TITLE, WIN_W, WIN_H, WIN_FLAGS|WINFLAG_HIDDEN);  wndw=&_wndw;

  Renderer _rndr(_wndw);  rndr = &_rndr;

  #define GRAY(_hexvalue) 0xFF##_hexvalue##_hexvalue##_hexvalue
  BFont_Texture _text(_rndr, nullptr, nullptr, GRAY(FF), 16384);  text = &_text;

  const clrs::ABGR textColored_colors[TEXTCOLORED_LEN] = {
    0xFF000000, //gray0 (  0)
    0xFF555555, //gray1 ( 85)
    0xFFAAAAAA, //gray2 (170)
    0xFFFFFFFF, //gray3 (255)
    0xFF000080, //redLo
    0xFF0000FF, //redHi
    0xFF008000, //greenLo
    0xFF00FF00, //greenHi
    0xFF800000, //blueLo
    0xFFFF0000, //blueHi
    0xFF808000, //cyanLo
    0xFFFFFF00, //cyanHi
    0xFF800080, //magentaLo
    0xFFFF00FF, //magentaHi
    0xFF008080, //yellowLo
    0xFF00FFFF, //yellowHi
  };

  for(u32 i=0; i<TEXTCOLORED_LEN; ++i){
    textColored[i] = new BFont_Texture(_rndr, nullptr, nullptr,
                                       textColored_colors[i], 1024);
  }

  Texture _tImg(*rndr, "dat/img/tiles.png", SurfaceLoadPNG);  tImg = &_tImg;
  tile_init();

  //...

/********************************* USER MAIN **********************************/

  timeDelta = time::getMS()-timeStartAll;
  kit_LogInfo("Initialized in %llums", timeDelta);

  //audio's actual fade DELAY is 90ms, whereas the fade in after that is 10ms.
   //so 95 should put the audio at about halfway through the fade in
  timeDelta = time::getMS()-timeStartAudio;
  time::sleep((u32)MAX((s64)(95-timeDelta), 1));

  //_wndw.setVisibility(true); //this is generally done by the user
  std::srand((u32)time::getTicks());
  returnStatus = user_main(argc, argv);
  _wndw.setVisibility(false);

  _audio.pause(); //begin fading out audio

/******************************* VIDEO CLEANUP ********************************/

{

  //...

}

  for(u32 i=0; i<TEXTCOLORED_LEN; ++i) NULLDELETE(textColored[i],BFont_Texture);

} //garbage collect video init stuff

/******************************* AUDIO CLEANUP ********************************/

  //audio's actual fadeout is 10ms, so waiting ~12ms total should be enough
  while(_audio.isPlaying()) time::sleep(4);
  _audio.lock(); //just in case

  memory::free(&music_buffer_src);
  memory::free(&music_buffer_dst);

{

  //...

}

  _audio.unlock();

/************************** CATCH EXCEPTION OR EXIT ***************************/

} catch(const char* errorText){
  #ifdef _DEBUG
    kit_LogError("FATAL EXCEPTION OCCURRED: \"%s\"\n", errorText);
  #else
    MessageBeep(MB_ICONERROR);
    showMsgBox(errorText, "FATAL EXCEPTION OCCURRED!", MSGBOX_ERROR);
  #endif /* _DEBUG */
  //redundant, as quitSubsystems already does this when given KINIT_EVERYTHING
  //freeThreadErrors();

}

  //can't error, and is also safe to call even if no subsystems are active!
  quitSubsystems(KINIT_EVERYTHING);

  //a nonzero value indicates a memory leak!
  if(memory::getNumAllocations())
    kit_LogWarn("# OF ALLOCATIONS = %llu", memory::getNumAllocations());

  return returnStatus;

}
/******************************************************************************/
/******************************************************************************/
//"2024-12-13\iso_game\user_main.cpp":
#include <include_all.hpp>

#include <unistd.h> //for getcwd()

//begone, unused parameter warning
#define UM_RETURN(_val) { (void)argc, (void)argv; return (_val); }

#ifdef _DEBUG
  #define kit_logEvent(_type) kit_LogInfo("event = %s", getEventText(_type))
#else
  #define kit_logEvent(_type) kit_LogInfo("event = 0x%08X", (_type))
#endif

using namespace kit;



#define VOL 0.20f
#define SPD 1.2
AudioData* pushSound = nullptr;

u32            plr_which;
shape::point3d plr;
shape::point3d box;

shape::point cursorPos;

bool fullscreen = false;

#define LMIN -1
#define LMAX 10
s32 l = LMAX;

s32 handleEvents(){
  bool run = true;

  Event evt;
  while(pollEvent(&evt))
  switch(evt.type){
    case KEVENT_QUIT: run = false; break;

    case KEVENT_KEY_DOWN: {
      if(evt.key.repeat) break;
      switch(evt.key.vkey){
        case VKEY_a: {
          if(plr.x==-5) break;
          else if(plr.x==-4&&(plr.z==box.z)) break;
          --plr.x; plr_which = TILE_ID_PLAYER_BACK;
          if(box==plr){ --box.x; sfx->play(*pushSound, VOL, VOL, SPD); }
        } break;
        case VKEY_d: {
          if((plr.x+((box.x==1)&&plr.z==box.z))==1) break;
          ++plr.x; plr_which = TILE_ID_PLAYER_RIGHT;
          if(box==plr){ ++box.x; sfx->play(*pushSound, VOL, VOL, SPD); }
        } break;
        case VKEY_s: {
          if(plr.z==-3) break;
          else if(plr.z==-2&&(plr.x==box.x)) break;
          --plr.z; plr_which = TILE_ID_PLAYER_LEFT;
          if(box==plr){ --box.z; sfx->play(*pushSound, VOL, VOL, SPD); }
        } break;
        case VKEY_w: {
          if((plr.z+((box.z==4)&&plr.x==box.x))==4) break;
          ++plr.z; plr_which = TILE_ID_PLAYER_BACK;
          if(box==plr){ ++box.z; sfx->play(*pushSound, VOL, VOL, SPD); }
        } break;
        case VKEY_RETURN: {
          return -1;
        } break;
        case VKEY_F11: {
          wndw->setFullscreen((fullscreen^=1));
        } break;
      }
    } break;

    case KEVENT_WIN_MFOCUS_GAINED: showCursor(0); break;
    case KEVENT_WIN_MFOCUS_LOST  : showCursor(1); break;

    case KEVENT_MOUSE_MOVED: {
      shape::point winPos(evt.mouse.x, evt.mouse.y);
      cursorPos = shape::point(winPos);
      winPos.x += WIN_W/4;
      winPos.y += WIN_H/4;
      tile_camera = rndr->coordsWindowToLogical(winPos);
      //kit_LogInfo("%f, %f", tile_camera.x, tile_camera.y);
    } break;

    case KEVENT_MOUSE_WHEEL: {
      l = CLAMP(l+evt.mouse.dy, LMIN, LMAX);
    } break;

    default: kit_logEvent(evt.type);
  }

  return run;

}





int user_main(int argc, char** argv){
  music_play(1);
  wndw->setMinSize(WIN_W/2, WIN_H/2);
  rndr->setLogicalSize(WIN_W/2, WIN_H/2);
  wndw->setVisibility(true);

  AudioData _pushSound("dat/sfx/push_1_v1.wav", AudioDataLoadWAV);
  _pushSound.convertFormat(SMPFMT_F32);
  pushSound = &_pushSound;

  _start:
  plr_which = TILE_ID_PLAYER_RIGHT;
  plr = {-2,0,0};
  box = { 0,0,1};


  while(true){
    s32 result = handleEvents();
    if(!result) break;
    if(result==-1) goto _start;

    rndr->setDrawColor(0xff808080);
    rndr->clear();


    for(s32 y=-1; y<MIN(l,3); ++y)
    for(s32 z= 4; z>=-4; --z)
    {
      draw_tile(-5, y, z, TILE_ID_BLOCK_R, 1.0f);
    }

    for(s32 y= 3; y<MIN(l,LMAX); ++y)
    for(s32 z= 0; z>=-4; --z)
    {
      draw_tile(-5, y, z, TILE_ID_BLOCK_Y, 1.0f);
    }

    for(s32 y=-1; y<MIN(l,2); ++y)
    for(s32 x=-4; x<  4; ++x)
    {
      draw_tile(x, y, 4, TILE_ID_BLOCK_B, 1.0f);
    }

    for(s32 y=-1; y<MIN(l,1); ++y)
    for(s32 x=-4; x<  4; ++x)
    for(s32 z= 3; z>=-4; --z)
    {
      draw_tile(x, y, z, TILE_ID_BLOCK_G, 1.0f);
    }

    if(l >= 2){
      bool in_front = isInFront(box, plr);
      if(!in_front) draw_tile(plr.x, plr.y, plr.z, plr_which);
      draw_tile(box.x, box.y, box.z, TILE_ID_BOXSMALL);
      if(in_front) draw_tile(plr.x, plr.y, plr.z, plr_which);
    }

    for(s32 y=-1; y<MIN(l,1); ++y)
    for(s32 z= 3; z>=-4; --z)
    {
      draw_tile(3, y, z, TILE_ID_BLOCK_Y, 1.0f);
    }

    for(s32 y= 1; y<MIN(l,3); ++y)
    for(s32 z= 3; z>=-4; --z)
    {
      draw_tile(3, y, z, TILE_ID_BLOCK_Y, 0.5f);
    }


    text->scale = {2,2};
    text->draw(0,0, "%2i,%2i,%2i, (%i)", 0, plr.x, plr.y, plr.z, l+1);
    text->scale = {1,1};
    text->draw(0,-1, "(controls: wasd, enter, scroll)");

    rndr->setDrawColor(0xffff00ff);
    rndr->drawPoint(cursorPos.x, cursorPos.y);

    rndr->present();
    time::sleep(33);
  }

  UM_RETURN(0);

}
/******************************************************************************/
/******************************************************************************/
//"2024-12-13\iso_game\utils_tile.cpp":
#include <include_all.hpp>


using namespace kit;





shape::fpoint tile_camera = {0, 0};

Texture* tImg = nullptr;
Vertex   tile_verts[4];
s32      tile_indices[6];

void tile_init(){ //inits all but tImg itself
  static bool isInit = false;
  if(isInit) return;

  clrs::ABGR color = 0xFFFFFFFF;
  tile_verts[0].c = color;
  tile_verts[1].c = color;
  tile_verts[2].c = color;
  tile_verts[3].c = color;

  tile_verts[0].uv = {0,0};
  tile_verts[1].uv = {1,0};
  tile_verts[2].uv = {0,1};
  tile_verts[3].uv = {1,1};

  tile_indices[0] = 0;
  tile_indices[1] = 1;
  tile_indices[2] = 2;
  tile_indices[3] = 3;
  tile_indices[4] = 1;
  tile_indices[5] = 2;

  isInit = true;

}





static inline void _draw_tile(s32 x, s32 y, s32 z, u32 which, f32 alpha){
  tile_verts[0].x  = 16*x + tile_camera.x;
  tile_verts[0].y  =  8*x + tile_camera.y;

  tile_verts[0].y -= 16*y;

  tile_verts[0].x += 16*z;
  tile_verts[0].y -=  8*z;


  tile_verts[1].x = tile_verts[0].x + 32;
  tile_verts[1].y = tile_verts[0].y;

  tile_verts[2].x = tile_verts[0].x;
  tile_verts[2].y = tile_verts[0].y + 32;

  tile_verts[3].x = tile_verts[1].x;
  tile_verts[3].y = tile_verts[2].y;


  u8 alpha_u8 = 255*alpha;

  tile_verts[0].c.a = alpha_u8;
  tile_verts[1].c.a = alpha_u8;
  tile_verts[2].c.a = alpha_u8;
  tile_verts[3].c.a = alpha_u8;


  tile_verts[0].u = 0.0625f * which;
  tile_verts[1].u = tile_verts[0].u + 0.0625f;
  tile_verts[2].u = tile_verts[0].u;
  tile_verts[3].u = tile_verts[1].u;


  rndr->renderGeometry(tile_verts, 4, tImg, tile_indices, 6);

}

void draw_tile(s32 x, s32 y, s32 z, u32 which, f32 alpha){
  _draw_tile(x, y, z, which, alpha);
}



//void draw_tiles
/******************************************************************************/
/******************************************************************************/
//"2024-12-13\kit_xmp\kit_Xmp.cpp":
/* notes/tbd:

use references where possible

*/

#include <kit/misc.hpp>
#include <kit/Xmp.hpp>

#define LIBXMP_STATIC
#include <libxmp-lite/xmp.h>

#define CTX_PTR ((xmp_context)_ctx)


namespace kit {

extern size_t numAllocations; //from kit namespace; relates to memory functions





#define KIT_OPAQUE_PRESENT (0x80000000)
#define KIT_CLASSTYPE_XMP (0x1001 | KIT_OPAQUE_PRESENT)

Xmp::Xmp(){
  if(_valid) return;
  _type = KIT_CLASSTYPE_XMP;

  _initModule = false;
  _initPlayer = false;

  _ctx = xmp_create_context();

  //the documentation doesn't even mention that xmp_create_context
   //can error, but it wouldn't hurt to have a check here just in case
  if(_ctx == nullptr)
    throw "Xmp::Xmp(): failed to create internal libxmp context";

  ++numAllocations;

  _valid = true;
  _constructing = false;

}





Xmp::~Xmp(){
  if(!_valid) return;
  _valid = false;

  if(_ctx != nullptr){
    if(_initPlayer){
      xmp_end_player(CTX_PTR);
      _initPlayer = false;
      --numAllocations;
    }

    if(_initModule){
      xmp_stop_module(CTX_PTR);
      xmp_release_module(CTX_PTR);
      _initModule = false;
      --numAllocations;
    }

    xmp_free_context(CTX_PTR);
    _ctx = nullptr;
    --numAllocations;

  }

}





}; /* namespace kit */
/******************************************************************************/
/******************************************************************************/
//"2024-12-13\kit_xmp\kit_Xmp_getModuleInfo.cpp":
#include <kit/misc.hpp>
#include <kit/Xmp.hpp>

#define LIBXMP_STATIC
#include <libxmp-lite/xmp.h>

#define CTX_PTR ((xmp_context)_ctx)


namespace kit {





s32 Xmp::getModuleInfo(Xmp_moduleInfo* minfo_out){
  if(!_valid || !_initModule) return -KIT_XMP_ERROR_STATE;

  if(minfo_out == nullptr) return -KIT_XMP_ERROR_INVALID;

  xmp_get_module_info(CTX_PTR, (xmp_module_info*)minfo_out);

  return 0;

}





}; /* namespace kit */
/******************************************************************************/
/******************************************************************************/
//"2024-12-13\kit_xmp\kit_Xmp_getTestInfo.cpp":
#include <kit/misc.hpp>
#include <kit/Xmp.hpp>

#define LIBXMP_STATIC
#include <libxmp-lite/xmp.h>

#define CTX_PTR ((xmp_context)_ctx)


namespace kit {





s32 Xmp::_test_from_memory(const void* data, u31 size, Xmp_testInfo* tinfo_out){
  if(!_valid) return -KIT_XMP_ERROR_STATE;

  if(size.s) return -KIT_XMP_ERROR_INVALID;

  //tinfo_out can apparently be nullptr, so i'm not checking for it here
  return xmp_test_module_from_memory(data, size.v, (xmp_test_info*)tinfo_out);

}





s32 Xmp::getTestInfo(const char* filePath, Xmp_testInfo* tinfo_out){
  if(!_valid) return -KIT_XMP_ERROR_STATE;

  if(filePath == nullptr) return -KIT_XMP_ERROR_INVALID;
  if(!fileio::exists(filePath)) return -KIT_XMP_ERROR_LOAD;

  try {
    BinaryData file(filePath);
    return _test_from_memory(file.getData(), file.getSize(), tinfo_out);

  } catch(const char* errorText){
    //a catch clause is added, since BinaryData can throw
    return -KIT_XMP_ERROR_LOAD;

  }

}





}; /* namespace kit */
/******************************************************************************/
/******************************************************************************/
//"2024-12-13\kit_xmp\kit_Xmp_module.cpp":
#include <kit/misc.hpp>
#include <kit/Xmp.hpp>

#define LIBXMP_STATIC
#include <libxmp-lite/xmp.h>

#define CTX_PTR ((xmp_context)_ctx)


namespace kit {

extern size_t numAllocations; //from kit namespace; relates to memory functions





s32 Xmp::_module_from_memory(const void* data, u31 size){
  if(!_valid) return -KIT_XMP_ERROR_STATE;

  if(size.s) return -KIT_XMP_ERROR_INVALID; //module size > KIT_S32_MAX

  moduleRelease();

  int err = xmp_load_module_from_memory(CTX_PTR, data, size.v);
  if(err) return err;

  _initModule = true;

  ++numAllocations;

  return 0;

}





s32 Xmp::moduleLoad(const char* filePath){
  if(!_valid) return -KIT_XMP_ERROR_STATE;

  if(filePath == nullptr) return -KIT_XMP_ERROR_INVALID;
  if(!fileio::exists(filePath)) return -KIT_XMP_ERROR_LOAD;

  try {
    BinaryData file(filePath);
    return _module_from_memory(file.getData(), file.getSize());

  } catch(const char* errorText){
    //a catch clause is added, since BinaryData can throw
    return -KIT_XMP_ERROR_LOAD;

  }

}





bool Xmp::moduleRelease(){
  if(!_valid || !_initModule) return false;

  xmp_stop_module(CTX_PTR);
  xmp_release_module(CTX_PTR);

  _initModule = false;

  --numAllocations;

  return true;

}





s32 Xmp::moduleStop(){
  if(!_valid || !_initModule) return -KIT_XMP_ERROR_STATE;

  xmp_stop_module(CTX_PTR);

  return 0;

}





s32 Xmp::moduleRestart(){
  if(!_valid || !_initModule) return -KIT_XMP_ERROR_STATE;

  xmp_restart_module(CTX_PTR);

  return 0;

}





}; /* namespace kit */