root/trunk/Mask.cpp

///////////////////////////////////////////////////////////
//                        TexGen                         //
//          утилита для подготовки текстур рельефа       //
//               для игры Проклятые Земли                //
//           Copyright (C) 2007-2008 Gipat Group         //
//              Распространяется на условиях             //
//    Gipat Group's opened EI-editor-utility license     //
//                      версии 1.0                       //
//                                                       //
//                  www.gipatgroup.org                   //
///////////////////////////////////////////////////////////

//К работе над данным файлом приложили руки, ноги.... короче аффтары:
// 1) Снайпер (sniper-rifle@rambler.ru)

////////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------------
#include <VCL.h>

#include "Mask.h"
//---------------------------------------------------------------------------
void CTileMask::LoadMask(AnsiString FN)
{
  if(FileExists(FN))
  {
    int h = FileOpen(FN,fmOpenRead);
    if(h)
    {
      Clear();
      BufLen = FileSeek(h,0,SEEK_END);
      FileSeek(h,0,SEEK_SET);
      buf = new byte[BufLen];
      FileRead(h,buf,BufLen);
      FileClose(h);
      //Теперь проверяем файл %)
      AnsiString Head="**";
      memcpy(&Head[1],buf,2);      // Заголовок 2 байта - "TM"
      if(Head == "TM")             // Bce OK, файл нашего типа
      {
        byte Version;
        memcpy(&Version,buf+2,1);
        //switch - будет потом наверное если надо)))
        if(Version == MaskVersion) // Версия совпала %)
        {
          memcpy(&W,buf+3,4);
          memcpy(&H,buf+7,4);
          Uncompress();
        }
        else Clear();     // {
      }                   //   Зачищаем последствия неудачной загрузки
      else Clear();       // }
    }
  }
}
//---------------------------------------------------------------------------
void CTileMask::SaveMask(AnsiString FN)
{
  int h = FileCreate(FN, fmOpenWrite);
  if(h)
  {
    Compress();
    //Normalize(); // А то мало ли что %) //Маразм =(
    FileWrite(h,buf,BufLen);
    FileClose(h);
  }
}
//---------------------------------------------------------------------------
void CTileMask::GetPoint(int X, int Y, byte *dwDest)
{
  byte A, B, C, D;
  memcpy(&A,buf+HeadLen+Y*W*3+X*3+0,1);
  memcpy(&B,buf+HeadLen+Y*W*3+X*3+1,1);
  memcpy(&C,buf+HeadLen+Y*W*3+X*3+2,1);
  D = 0;
  //Считали - теперь формируем А, B, C и D
  if(A & 0x40)
  {
    A -= 0x40;
    D += 0x01;
  }
  if(A & 0x80)
  {
    A -= 0x80;
    D += 0x02;
  }
  if(B & 0x40)
  {
    B -= 0x40;
    D += 0x04;
  }
  if(B & 0x80)
  {
    B -= 0x80;
    D += 0x08;
  }
  if(C & 0x40)
  {
    C -= 0x40;
    D += 0x10;
  }
  if(C & 0x80)
  {
    C -= 0x80;
    D += 0x20;
  }
  // Заполнили - теперь возвращаем результат

  memcpy(dwDest+0,&A,1);
  memcpy(dwDest+1,&B,1);
  memcpy(dwDest+2,&C,1);
  memcpy(dwDest+3,&D,1);
  //Готово! %)
}
//---------------------------------------------------------------------------
void CTileMask::SetPoint(int X, int Y, byte *dwSrc)
{
  byte A, B, C, D;
  memcpy(&A,dwSrc+0,1);
  memcpy(&B,dwSrc+1,1);
  memcpy(&C,dwSrc+2,1);
  memcpy(&D,dwSrc+3,1);
  //Теперь перегоняем инфу из D в A,B и C.
  A += (D & 0x01)?0x40:0;
  A += (D & 0x02)?0x80:0;
  B += (D & 0x04)?0x40:0;
  B += (D & 0x08)?0x80:0;
  C += (D & 0x10)?0x40:0;
  C += (D & 0x20)?0x80:0;
  //Перегоняем в буфер %)
  memcpy(buf+HeadLen+Y*W*3+X*3+0,&A,1);
  memcpy(buf+HeadLen+Y*W*3+X*3+1,&B,1);
  memcpy(buf+HeadLen+Y*W*3+X*3+2,&C,1);
  //Я тут подумал - а фигли я вы@#$!аюсь? Экономлю, понимаешь ли, 1 байт, запутываю код, теряю скорость

  //Ответ прост: комары тут кусают, и спать пора. Вот и фигею помаленьку %)))
}
//---------------------------------------------------------------------------
void CTileMask::NewMask(int szW, int szH, bool F)
{
  AnsiString Header="TM";
  Clear();
  W = szW;
  H = szH;
  BufLen = HeadLen+W*H*3;
  buf = new byte[BufLen];
  memcpy(buf,&Header[1],2);
  memcpy(buf+2,&MaskVersion,1);
  memcpy(buf+3,&W,4);
  memcpy(buf+7,&H,4);
  if(F)
  {
    //А теперь заполняем массив "4х16"
    byte A=16,B=16,C=16,D=15, *dwTmp = new byte[4];
    memcpy(dwTmp  , &A, 1);
    memcpy(dwTmp+1, &B, 1);
    memcpy(dwTmp+2, &C, 1);
    memcpy(dwTmp+3, &D, 1);
    for(int X=0; X<W;X++)
      for(int Y=0;Y<H;Y++)
      {
        SetPoint(X,Y,dwTmp);
      }
    Uncompress();
    //Прошу любить и жаловать %)
    delete [] dwTmp;
  }
}
//---------------------------------------------------------------------------
void CTileMask::NormalizeW(int X, int Y)
{
  byte A,B,C,D, *dwTmp=new byte[4];
  GetPointW(X,Y,dwTmp);
  A = dwTmp[0];
  B = dwTmp[1];
  C = dwTmp[2];
  D = dwTmp[3];
  while(A+B+C+D>=63)
  {
    if(A>0)A--;
    if(B>0)B--;
    if(C>0)C--;
    if(D>0)D--;
  }
  dwTmp[0]=A;
  dwTmp[1]=B;
  dwTmp[2]=C;
  dwTmp[3]=D;
  SetPointW(X,Y,dwTmp);
  delete [] dwTmp;
}
//---------------------------------------------------------------------------
void CTileMask::Uncompress()
{
  ClearW();//Потрём данные, если они каким-то чудом остались целы
  if(BufLen>0)
  {
    byte *dwTmp=new byte[4];
    Buf2Len = W*H*4;
    WorkData = new byte[Buf2Len];
    for(int X=0; X<W; X++)
      for(int Y=0; Y<H; Y++)
      {
        GetPoint(X,Y,dwTmp);
        SetPointW(X,Y,dwTmp);
      }
    int A=W,B=H;
    W=A;H=B;
    delete [] dwTmp;
  }
}
//---------------------------------------------------------------------------
void CTileMask::Compress()
{
  int A=W,B=H;
  Clear();
  if(Buf2Len>0)
  {
    byte *dwTmp=new byte[4];
    W=A;
    H=B;
    NewMask(W,H,false);
    for(int X=0; X<W; X++)
      for(int Y=0; Y<H; Y++)
      {
        GetPointW(X,Y,dwTmp);
        SetPoint(X,Y,dwTmp);
      }
    delete [] dwTmp;
  }
}
//---------------------------------------------------------------------------
void CTileMask::GetPointW(int X, int Y, byte *dwDest)
{
  memcpy(dwDest,WorkData+Y*W*4+X*4,4);
}
//---------------------------------------------------------------------------
void CTileMask::SetPointW(int X, int Y, byte *dwSrc)
{
  memcpy(WorkData+Y*W*4+X*4,dwSrc,4);
}
//---------------------------------------------------------------------------
int CTileMask::CheckSumW(int X, int Y)
{
//Проверяем сумму мощностей материалов в точке, чтобы не было глюков.
//Нормальная сумма равна 64.
  byte *dwTmp=new byte[4];
  GetPointW(X,Y,dwTmp);
  int Rez = dwTmp[0]+dwTmp[1]+dwTmp[2]+dwTmp[3];
  delete [] dwTmp;
  return Rez;
}