#include "PaletteManager.h"
#include "Texture.h"
#include "Game.h"
#include "LOD.h"

#include "mm7_data.h"




PaletteManager *pPaletteManager = new PaletteManager;




//----- (0048A643) --------------------------------------------------------
bool __fastcall HSV2RGB(float *a1, float *a2, float *a3, float a4, float a5, float a6)
{
  float *v6; // ebx@1
  float *v7; // edi@1
  float *v8; // esi@1
  double v9; // st7@5
  signed __int64 v10; // qax@5
  double v11; // st7@5
  double v12; // st5@5
  int v13; // eax@6
  int v14; // eax@7
  int v15; // eax@8
  int v16; // eax@9
  float v17; // eax@11
  float a3a; // [sp+1Ch] [bp+8h]@14
  float a4b; // [sp+20h] [bp+Ch]@5
  float a4c; // [sp+20h] [bp+Ch]@5
  float a4a; // [sp+20h] [bp+Ch]@5

  v6 = a3;
  v7 = a2;
  v8 = a1;
  if ( a5 == 0.0 )
  {
    *a3 = a6;
    *a2 = a6;
    *a1 = a6;
    goto LABEL_20;
  }
  if ( a4 == 360.0 )
    a4 = 0.0;
  v9 = a4 * 0.01666666666666667;
  a4b = v9;
  floor(v9);
  v10 = (signed __int64)v9;
  a4c = a4b - (double)(signed int)(signed __int64)v9;
  v11 = (1.0 - a5) * a6;
  v12 = (1.0 - a4c * a5) * a6;
  a4a = (1.0 - (1.0 - a4c) * a5) * a6;
  if ( (int)v10 )
  {
    v13 = v10 - 1;
    if ( v13 )
    {
      v14 = v13 - 1;
      if ( v14 )
      {
        v15 = v14 - 1;
        if ( v15 )
        {
          v16 = v15 - 1;
          if ( v16 )
          {
            if ( v16 != 1 )
              goto LABEL_20;
            *v8 = a6;
            v17 = v12;
            *v7 = v11;
            goto LABEL_12;
          }
          *(int *)v8 = LODWORD(a4a);
          *v7 = v11;
        }
        else
        {
          *v8 = v11;
          a3a = v12;
          *(int *)v7 = LODWORD(a3a);
        }
        v17 = a6;
      }
      else
      {
        *v8 = v11;
        *(int *)v7 = LODWORD(a6);
        v17 = a4a;
      }
LABEL_12:
      *(int *)v6 = LODWORD(v17);
      goto LABEL_20;
    }
    *v8 = v12;
    *v7 = a6;
  }
  else
  {
    *v8 = a6;
    *(int *)v7 = LODWORD(a4a);
  }
  *a3 = v11;
LABEL_20:
  if ( *v8 > 1.0 )
    *v8 = 1.0;
  if ( *v7 > 1.0 )
    *v7 = 1.0;
  if ( *v6 > 1.0 )
    *v6 = 1.0;
  if ( *v8 < 0.0 )
    *v8 = 0.0;
  if ( *v7 < 0.0 )
    *v7 = 0.0;
  if ( *v6 < 0.0 )
    *v6 = 0.0;
  return 1;
}

//----- (0048A7AA) --------------------------------------------------------
void __fastcall RGB2HSV(float *a1, float *a2, float a3, float a4, float a5, float *a6)
{
  double v6; // st7@2
  double v7; // st6@7
  double v8; // st5@12
  double v9; // st7@15
  double v10; // st7@17
  double v11; // st7@21
  __int16 v12; // fps@21
  unsigned __int8 v13; // c0@21
  unsigned __int8 v14; // c2@21
  float a6a; // [sp+14h] [bp+14h]@16

  if ( a3 <= (double)a4 )
    v6 = a4;
  else
    v6 = a3;
  if ( v6 < a5 )
    v6 = a5;
  if ( a3 <= (double)a4 )
    v7 = a3;
  else
    v7 = a4;
  if ( v7 > a5 )
    v7 = a5;
  *a6 = v6;
  if ( v6 == 0.0 )
    v8 = 0.0;
  else
    v8 = (v6 - v7) / v6;
  *a2 = v8;
  if ( v8 == 0.0 )
  {
    v9 = 0.0;
LABEL_23:
    *a1 = v9;
    return;
  }
  a6a = v6 - v7;
  if ( a3 == v6 )
  {
    v10 = (a4 - a5) / a6a;
  }
  else
  {
    if ( a4 == v6 )
      v10 = (a5 - a3) / a6a + 2.0;
    else
      v10 = (a3 - a4) / a6a + 4.0;
  }
  //*a1 = v10;
  //v11 = *a1 * 60.0;
  //UNDEF(v12);
  *a1 = v10 * 60.0;
  if (*a1 < 0)
  {
    *a1 += 360.0;
  }
}



//----- (0048A8A3) --------------------------------------------------------
int PaletteManager::LockAll()
{
  int *v1; // edx@1
  signed int v2; // eax@1

  v1 = &this->pPaletteIDs[1];
  v2 = 1;
  do
  {
    if ( *v1 )
      this->_num_locked = v2 + 1;
    ++v2;
    ++v1;
  }
  while ( v2 < 50 );
  return this->_num_locked;
}

//----- (0048A8CC) --------------------------------------------------------
int PaletteManager::LockTestAll()
{
  char *v1; // edx@1
  signed int v2; // eax@1

  v1 = (char *)&this->pPaletteIDs[1];
  v2 = 1;
  do
  {
    if ( *(int *)v1 )
      this->_pal_lock_test = v2 + 1;
    ++v2;
    v1 += 4;
  }
  while ( v2 < 50 );
  return this->_pal_lock_test;
}


//----- (0048A8F5) --------------------------------------------------------
void PaletteManager::SetColorChannelInfo(int uNumRBits, int uNumGBits, int uNumBBits)
{
  PaletteManager *v4; // esi@1
  int v5; // edi@1
  int v6; // eax@1
  int v7; // ebx@1

  v4 = this;
  this->uNumTargetRBits = uNumRBits;
  this->uNumTargetGBits = uNumGBits;
  v5 = this->uNumTargetGBits;
  this->uNumTargetBBits = uNumBBits;
  v6 = MakeColorMaskFromBitDepth(uNumRBits);
  v7 = v4->uNumTargetBBits;
  v4->uTargetRMask = v6 << (v5 + v4->uNumTargetBBits);
  v4->uTargetGMask = MakeColorMaskFromBitDepth(v5) << v7;
  v4->uTargetBMask = MakeColorMaskFromBitDepth(v7);
}


//----- (00489BE0) --------------------------------------------------------
int PaletteManager::CalcPalettes_LUT(int a2)
{
  PaletteManager *v2; // esi@1
  char *v3; // edi@1
  signed int v4; // ebx@4
  float v5; // ST08_4@5
  float v6; // ST04_4@5
  float v7; // ST00_4@5
  int v8; // eax@7
  float *v9; // edx@8
  float *v10; // ST0C_4@8
  float *v11; // ecx@8
  int v12; // ebx@8
  int v13; // eax@8
  float v14; // ebx@8
  float v15; // ST08_4@8
  float v16; // ST04_4@8
  float v17; // ST00_4@8
  unsigned __int8 v18; // sf@8
  unsigned __int8 v19; // of@8
  int v20; // eax@10
  double v21; // st5@11
  float v22; // ST0C_4@13
  unsigned int v23; // eax@13
  __int16 v24; // bx@16
  int v25; // eax@16
  double v26; // st7@20
  float v27; // ST0C_4@22
  unsigned int v28; // eax@22
  __int16 v29; // bx@25
  __int16 *v30; // eax@25
  int v31; // eax@27
  double v32; // st5@28
  float v33; // ST0C_4@30
  float v34; // ST08_4@30
  unsigned int v35; // ebx@30
  signed __int64 v36; // qax@33
  signed int v37; // edx@33
  char v38; // cl@33
  unsigned int v39; // ebx@33
  signed int v40; // edi@33
  unsigned int v41; // ecx@33
  unsigned int v42; // ecx@35
  int v43; // eax@39
  signed int v44; // edx@39
  unsigned __int8 v45; // al@40
  double v46; // st6@43
  signed int v47; // eax@43
  int v48; // eax@45
  double v49; // st6@47
  float v50; // ST08_4@49
  unsigned int v51; // ebx@49
  int v52; // edi@55
  int v53; // ebx@55
  signed __int64 v54; // qax@55
  double v55; // st7@56
  unsigned int v56; // ecx@57
  unsigned int v57; // ecx@59
  //int v58; // edx@61
  unsigned int v59; // ecx@61
  unsigned int v60; // eax@63
  char v61; // cl@63
  int result; // eax@63
  float v63[256]; // [sp+1Ch] [bp-C38h]@5
  float v64[256]; // [sp+41Ch] [bp-838h]@5
  int a6[256]; // [sp+81Ch] [bp-438h]@5
  int v66; // [sp+C1Ch] [bp-38h]@43
  float v67; // [sp+C20h] [bp-34h]@43
  float v68; // [sp+C24h] [bp-30h]@43
  PaletteManager *v69; // [sp+C28h] [bp-2Ch]@9
  float v70; // [sp+C2Ch] [bp-28h]@43
  double v71; // [sp+C30h] [bp-24h]@10
  int v72; // [sp+C38h] [bp-1Ch]@9
  int v73; // [sp+C3Ch] [bp-18h]@9
  int i; // [sp+C40h] [bp-14h]@7
  float v75; // [sp+C44h] [bp-10h]@5
  float a2a; // [sp+C48h] [bp-Ch]@13
  float a1; // [sp+C4Ch] [bp-8h]@13
  float a3; // [sp+C50h] [bp-4h]@13
  signed int v79; // [sp+C5Ch] [bp+8h]@33
  signed int v80; // [sp+C5Ch] [bp+8h]@43
  int v81; // [sp+C5Ch] [bp+8h]@57

  v2 = this;
  v3 = (char *)this + 768 * a2;
  if ( this->field_267AD3 || this->field_267AD4 || this->field_267AD5 )
  {
    v8 = 0;
    i = 0;
    do
    {
      v9 = (float *)((char *)v63 + v8);
      v10 = (float *)((char *)a6 + v8);
      v11 = (float *)((char *)v64 + v8);
      v12 = v2->field_267AD4;
      LODWORD(v75) = v2->field_267AD5 + (unsigned __int8)v3[2];
      v13 = v12 + (unsigned __int8)v3[1];
      LODWORD(v14) = (unsigned __int8)*v3;
      v15 = (double)SLODWORD(v75) * 0.00196078431372549;
      LODWORD(v75) = v13;
      LODWORD(v75) = LODWORD(v14) + v2->field_267AD3;
      v16 = (double)v13 * 0.00196078431372549;
      v17 = (double)SLODWORD(v75) * 0.00196078431372549;
      RGB2HSV(v11, v9, v17, v16, v15, v10);
      v3 += 3;
      v8 = i + 4;
      v19 = __OFSUB__(i + 4, 1024);
      v18 = i - 1020 < 0;
      i += 4;
    }
    while ( v18 ^ v19 );
  }
  else
  {
    v4 = 0;
    do
    {
      LODWORD(v75) = (unsigned __int8)v3[2];
      v5 = (double)SLODWORD(v75) * 0.00392156862745098;
      LODWORD(v75) = (unsigned __int8)v3[1];
      v6 = (double)SLODWORD(v75) * 0.00392156862745098;
      LODWORD(v75) = (unsigned __int8)*v3;
      v7 = (double)SLODWORD(v75) * 0.00392156862745098;
      RGB2HSV(&v64[v4], &v63[v4], v7, v6, v5, (float *)&a6[v4]);
      ++v4;
      v3 += 3;
    }
    while ( v4 < 256 );
  }
  v69 = (PaletteManager *)((char *)v2 + 16384 * a2);
  v72 = 0;
  v73 = (int)v69->pPalette1;
  do
  {
    v20 = 0;
    i = 0;
    v71 = 1.0 - (double)v72 * 0.03225806451612903;
    do
    {
      v21 = *(float *)((char *)a6 + v20) * v71;
      if ( v21 < 0.0 )
        v21 = 0.0;
      v22 = v21;
      HSV2RGB(&a1, &a2a, &a3, *(float *)((char *)v64 + v20), *(float *)((char *)v63 + v20), v22);
      v23 = v2->uNumTargetGBits;
      if ( v23 == 6 )
      {
        a1 = a1 * 31.0;
        a2a = a2a * 62.0;
        a3 = a3 * 31.0;
      }
      else
      {
        a1 = a1 * 31.0;
        a2a = a2a * 31.0;
        a3 = a3 * 31.0;
      }
      v24 = (unsigned __int64)(signed __int64)a3 | ((unsigned __int16)(signed __int64)a2a << v2->uNumTargetBBits) | (unsigned __int16)((unsigned __int16)(signed __int64)a1 << (v2->uNumTargetBBits + v23));
      v25 = v73;
      v73 += 2;
      *(short *)v25 = v24;
      v20 = i + 4;
      v19 = __OFSUB__(i + 4, 1024);
      v18 = i - 1020 < 0;
      i += 4;
    }
    while ( v18 ^ v19 );
    ++v72;
  }
  while ( v72 < 32 );
  v72 = 0;
  v73 = (int)v69->field_199600_palettes;
  do
  {
    i = 0;
    v71 = 1.0 - (double)v72 * 0.03225806451612903;
    do
    {
      v26 = *(float *)&a6[i] * v71;
      if ( v26 < 0.0 )
        v26 = 0.0;
      v27 = v26;
      HSV2RGB(&a1, &a2a, &a3, 1.0, 1.0, v27);
      v28 = v2->uNumTargetGBits;
      if ( v28 == 6 )
      {
        a1 = a1 * 31.0;
        a2a = a2a * 62.0;
        a3 = a3 * 31.0;
      }
      else
      {
        a1 = a1 * 31.0;
        a2a = a2a * 31.0;
        a3 = a3 * 31.0;
      }
      v29 = (unsigned __int64)(signed __int64)a3 | ((unsigned __int16)(signed __int64)a2a << v2->uNumTargetBBits) | (unsigned __int16)((unsigned __int16)(signed __int64)a1 << (v2->uNumTargetBBits + v28));
      v30 = (__int16 *)v73;
      ++i;
      v73 += 2;
      v19 = __OFSUB__(i, 256);
      v18 = i - 256 < 0;
      *v30 = v29;
    }
    while ( v18 ^ v19 );
    ++v72;
  }
  while ( v72 < 32 );
  v73 = (int)((char *)v2 + 512 * (a2 + 4875));
  v31 = 0;
  i = 0;
  do
  {
    v32 = (*(float *)((char *)a6 + v31) - 0.8) * 0.8387096774193549 + 0.8;
    if ( v32 < 0.0 )
      v32 = 0.0;
    v33 = v32;
    v34 = *(float *)((char *)v63 + v31) * 0.7034339229968783;
    HSV2RGB(&a1, &a2a, &a3, *(float *)((char *)v64 + v31), v34, v33);
    v35 = v2->uNumTargetGBits;
    if ( v35 == 6 )
    {
      a1 = a1 * 31.0;
      a2a = a2a * 62.0;
      a3 = a3 * 31.0;
    }
    else
    {
      a1 = a1 * 31.0;
      a2a = a2a * 31.0;
      a3 = a3 * 31.0;
    }
    v36 = (signed __int64)((a1 + a2a + a3) * 0.3333333333333333 * 8.0);
    v37 = (signed int)v36 >> (8 - v2->uNumTargetRBits);
    v38 = 8 - v35;
    v39 = v2->uNumTargetBBits;
    v40 = (signed int)v36 >> v38;
    v41 = v2->uNumTargetRBits;
    v79 = (signed int)v36 >> (8 - v39);
    if ( v37 > (1 << v41) - 1 )
      v37 = (1 << v41) - 1;
    v42 = v2->uNumTargetGBits;
    if ( v40 > (1 << v42) - 1 )
      v40 = (1 << v42) - 1;
    if ( v79 > (1 << v39) - 1 )
      v79 = (1 << v39) - 1;
    v43 = v73;
    v44 = v37 << (v39 + v2->uNumTargetGBits);
    v73 += 2;
    *(short *)v43 = v79 | ((short)v40 << v39) | (unsigned __int16)v44;
    v31 = i + 4;
    v19 = __OFSUB__(i + 4, 1024);
    v18 = i - 1020 < 0;
    i += 4;
  }
  while ( v18 ^ v19 );
  v45 = v2->field_267AD0;
  if ( v45 || v2->field_267AD1 || v2->field_267AD2 )
  {
    v46 = (double)v45;
    v80 = v2->field_267AD1;
    v47 = v2->field_267AD2;
    v70 = v46 * 0.00392156862745098;
    *((float *)&v71 + 1) = (double)v80 * 0.00392156862745098;
    v75 = (double)v47 * 0.00392156862745098;
    RGB2HSV(&v68, &v67, v70, *((float *)&v71 + 1), v75, (float *)&v66);
  }
  v72 = 0;
  v73 = (int)v69->field_D1600;


  do
  {
    v48 = 0;
    for ( i = 0; ; v48 = i )
    {
      v49 = *(float *)((char *)v63 + v48);
      if ( v49 < 0.0 )
        v49 = 0.0;
      v50 = v49;
      HSV2RGB(&a1, &a2a, &a3, *(float *)((char *)v64 + v48), v50, *(float *)((char *)a6 + v48));
      v51 = v2->uNumTargetGBits;
      if ( v51 == 6 )
      {
        a1 = a1 * 31.0;
        a2a = a2a * 62.0;
        a3 = a3 * 31.0;
      }
      else
      {
        a1 = a1 * 31.0;
        a2a = a2a * 31.0;
        a3 = a3 * 31.0;
      }
      if ( v2->field_267AD0 || v2->field_267AD1 || v2->field_267AD2 )
      {
        v55 = (double)v72 * 0.03225806451612903;
        v52 = (signed __int64)((double)(1 << v2->uNumTargetRBits) * v70 * v55 + a1 * (1.0 - v55));
        v53 = (signed __int64)((double)(1 << v51) * *((float *)&v71 + 1) * v55 + a2a * (1.0 - v55));
        v54 = (signed __int64)((double)(1 << v2->uNumTargetBBits) * v75 * v55 + a3 * (1.0 - v55));
      }
      else
      {
        v52 = (signed __int64)a1;
        v53 = (signed __int64)a2a;
        v54 = (signed __int64)a3;
      }
      v56 = v2->uNumTargetRBits;
      v81 = v54;
      if ( v52 > (1 << v56) - 1 )
        v52 = (1 << v56) - 1;
      v57 = v2->uNumTargetGBits;
      if ( v53 > (1 << v57) - 1 )
        v53 = (1 << v57) - 1;
      HIDWORD(v54) = v2->uNumTargetBBits;
      v59 = v2->uNumTargetBBits;
      if ( (signed int)v54 > (1 << v59) - 1 )
        v81 = (1 << v59) - 1;
      v60 = v2->uNumTargetGBits;
      i += 4;
      v61 = uNumTargetBBits + v60;
      result = v73;
      v73 += 2;
      v19 = __OFSUB__(i, 1024);
      v18 = i - 1024 < 0;
      *(short *)result = v81 | ((short)v53 << uNumTargetBBits) | (v52 << v61);
      if ( !(v18 ^ v19) )
        break;
    }
    ++v72;
  }
  while ( v72 <  32 );
  return result;
}


//----- (0048A300) --------------------------------------------------------
PaletteManager::PaletteManager():
  uNumTargetRBits(0), uNumTargetGBits(0),uNumTargetBBits(0)
{
  for (uint i = 0; i < 256; ++i)
  {
    pBaseColors[0][i][0] = i;
    pBaseColors[0][i][1] = i;
    pBaseColors[0][i][2] = i;
  }

  CalcPalettes_LUT(0);
  memset(pPaletteIDs, 0, sizeof(pPaletteIDs));
}

//----- (0048A336) --------------------------------------------------------
// make grayscale palette at 0, clear all palettes ids that aren't locked
int PaletteManager::ResetNonLocked()
{
  PaletteManager *v1; // esi@1
  signed int v2; // ecx@1
  int v3; // eax@1
  signed int result; // eax@3
  void *v5; // edi@4
  int v6; // ecx@4

  v1 = this;
  v2 = 0;
  v3 = (int)&v1->pBaseColors[0][0][1];
  do
  {
    *(char *)(v3 + 1) = v2;
    *(char *)v3 = v2;
    *(char *)(v3 - 1) = v2++;
    v3 += 3;
  }
  while ( v2 < 256 );
  CalcPalettes_LUT(0);
  result = v1->_num_locked;
  if ( result < 50 )
  {
    v5 = &v1->pPaletteIDs[result];
    v6 = 50 - result;
    result = 0;
    memset(v5, 0, 4 * v6);
  }
  return result;
}

//----- (0048A379) --------------------------------------------------------
// make grayscale palette at 0, clear all palettes ids that aren't in "lock_test"
int PaletteManager::ResetNonTestLocked()
{
  PaletteManager *v1; // esi@1
  signed int v2; // ecx@1
  int v3; // eax@1
  signed int result; // eax@3
  void *v5; // edi@4
  int v6; // ecx@4

  v1 = this;
  v2 = 0;
  v3 = (int)&v1->pBaseColors[0][0][1];
  do
  {
    *(char *)(v3 + 1) = v2;
    *(char *)v3 = v2;
    *(char *)(v3 - 1) = v2++;
    v3 += 3;
  }
  while ( v2 < 256 );
  CalcPalettes_LUT(0);
  result = v1->_pal_lock_test;
  if ( result < 50 )
  {
    v5 = &v1->pPaletteIDs[result];
    v6 = 50 - result;
    result = 0;
    memset(v5, 0, 4 * v6);
  }
  return result;
}

//----- (0048A3BC) --------------------------------------------------------
int PaletteManager::LoadPalette(unsigned int uPaletteID)
{
  unsigned int *v2; // ecx@1
  signed int result; // eax@1
  signed int v4; // esi@6
  double v5; // st7@7
  double v6; // st7@12
  double v7; // st6@17
  signed __int64 v8; // qax@17
  double v9; // st6@17
  char v10[768]; // [sp+18h] [bp-388h]@6
  //char v11; // [sp+19h] [bp-387h]@17
  //char v12[766]; // [sp+1Ah] [bp-386h]@17
  char Source[32]; // [sp+360h] [bp-40h]@4
  PaletteManager *v15; // [sp+380h] [bp-20h]@1
  float v16; // [sp+384h] [bp-1Ch]@7
  int v17; // [sp+388h] [bp-18h]@6
  float v18; // [sp+38Ch] [bp-14h]@7
  float a2a; // [sp+390h] [bp-10h]@7
  float a1; // [sp+394h] [bp-Ch]@7
  int a6; // [sp+398h] [bp-8h]@7
  int a3; // [sp+39Ch] [bp-4h]@7

  v15 = this;
  v2 = (unsigned int *)&this->pPaletteIDs[1];
  result = 1;
  while ( *v2 != uPaletteID )
  {
    ++result;
    ++v2;
    if ( result >= 50 )
    {
      sprintf(Source, "pal%03i", uPaletteID);

      Texture tex; // [sp+318h] [bp-88h]@4
      //Texture::Texture(&tex);

      if ( pBitmaps_LOD->LoadTextureFromLOD(&tex, Source, TEXTURE_24BIT_PALETTE) == 1 )
      {
        v4 = 0;
        v17 = 1 - (int)&v10;
        do
        {
          LODWORD(a1) = tex.pPalette24[v4];
          a1 = (double)SLODWORD(a1) * 0.0039215689;
          LODWORD(a2a) = (unsigned __int8)*(&v10 + v4 + v17 + (unsigned int)tex.pPalette24);
          a2a = (double)SLODWORD(a2a) * 0.0039215689;
          a3 = tex.pPalette24[v4 + 2];
          *(float *)&a3 = (double)a3 * 0.0039215689;
          RGB2HSV(&v16, &v18, a1, a2a, *(float *)&a3, (float *)&a6);
          v5 = *(float *)&a6 * 1.1;
          if ( v5 >= 0.0 && v5 >= 1.0 )
          {
            v5 = 1.0;
          }
          else
          {
            if ( v5 < 0.0 )
              v5 = 0.0;
          }
          *(float *)&a6 = v5;
          v6 = v18 * 0.64999998;
          if ( v6 >= 0.0 && v6 >= 1.0 )
          {
            v6 = 1.0;
          }
          else
          {
            if ( v6 < 0.0 )
              v6 = 0.0;
          }
          v18 = v6;
          HSV2RGB(&a1, &a2a, (float *)&a3, v16, v18, *(float *)&a6);
          v7 = a2a * 255.0;
          v10[v4] = (signed __int64)(a1 * 255.0);
          v8 = (signed __int64)v7;
          v9 = *(float *)&a3 * 255.0;
          v10[v4 + 1] = v8;
          v10[v4 + 2] = (signed __int64)v9;
          v4 += 3;
        }
        while ( v4 < 768 );
        tex.Release();
        result = v15->MakePaletteLUT(uPaletteID, v10);
      }
      else
      {
        result = 0;
      }
      return result;
    }
  }
  return result;
}
// 48A3BC: using guessed type char var_386[766];

//----- (0048A5A4) --------------------------------------------------------
int PaletteManager::MakePaletteLUT(int a2, char *entries)
{
  PaletteManager *v3; // edi@1
  signed int result; // eax@1
  int *v5; // ecx@1
  int v6; // eax@4
  int v7; // esi@4
  int v8; // eax@9
  signed int v9; // ecx@9
  int v10; // edx@9

  v3 = this;
  result = 0;
  v5 = this->pPaletteIDs;
  while ( *v5 != a2 )
  {
    ++result;
    ++v5;
    if ( result >= 50 )
    {
      v6 = (int)&v3->pPaletteIDs[1];
      v7 = 1;
      while ( *(int *)v6 )
      {
        ++v7;
        v6 += 4;
        if ( v7 >= 50 )
          return 0;
      }
      v8 = (int)((char *)v3 + 768 * v7);
      v9 = 768;
      v10 = (int)(entries - v8);
      do
      {
        *(char *)v8 = *(char *)(v10 + v8);
        ++v8;
        --v9;
      }
      while ( v9 );
      v3->pPaletteIDs[v7] = a2;
      CalcPalettes_LUT(v7);
      return v7;
    }
  }
  return result;
}

//----- (0048A614) --------------------------------------------------------
void PaletteManager::RecalculateAll()
{
  CalcPalettes_LUT(0);

  for (uint i = 1; i < 50; ++i)
    if (pPaletteIDs[i])
      CalcPalettes_LUT(i);
}


//----- (0047BE67) --------------------------------------------------------
unsigned __int16 *PaletteManager::Get(int a1)
{
  return (unsigned __int16 *)pPaletteManager->field_199600_palettes[a1];
}

//----- (0047BE72) --------------------------------------------------------
unsigned __int16 *PaletteManager::Get_Mist_or_Red_LUT(int a1, int a2, char a3)
{
  int v3; // eax@4

  if ( a3 & 2 || byte_4D864C && BYTE2(pGame->uFlags) & 4 )
    v3 = 32 * a1 + a2 + 3275;
  else
    v3 = 32 * a1 + a2 + 1675;
  return (unsigned __int16 *)((char *)&pPaletteManager + 512 * v3);
}
// 4D864C: using guessed type char byte_4D864C;


//----- (0041F50D) --------------------------------------------------------
unsigned __int16 *PaletteManager::Get_Dark_or_Red_LUT(int a1, int a2, char a3)
{
  int v3; // eax@4

  if ( a3 & 2 || byte_4D864C && BYTE2(pGame->uFlags) & 4 )
    v3 = 32 * a1 + a2 + 3275;
  else
    v3 = 32 * a1 + a2 + 75;
  return (unsigned __int16 *)((char *)&pPaletteManager + 512 * v3);
}
// 4D864C: using guessed type char byte_4D864C;


//----- (0047C30E) --------------------------------------------------------
unsigned __int16 *PaletteManager::_47C30E_get_palette(int a1, char a2)
{
  char *result; // eax@4

  if ( a2 & 2 || byte_4D864C && BYTE2(pGame->uFlags) & 4 )
    result = (char *)pPaletteManager->field_199600_palettes[a1];
  else
    result = (char *)pPaletteManager->field_D1600[a1];
  return (unsigned __int16 *)result;
}


//----- (0047C33F) --------------------------------------------------------
unsigned __int16 *PaletteManager::_47C33F_get_palette(int a1, char a2)
{
  unsigned __int16 *result; // eax@4

  if ( a2 & 2 || byte_4D864C && BYTE2(pGame->uFlags) & 4 )
    result = (unsigned __int16 *)pPaletteManager->field_199600_palettes[a1];
  else
    result = (unsigned __int16 *)pPaletteManager->pPalette1[a1];
  return result;
}
// 4D864C: using guessed type char byte_4D864C;