rtlwil.pas

传奇3 ei3 / 1.45 / 3G 版本 wil 资源编辑器源代码!

unit RtlWil;

interface
uses Windows , Classes, SysUtils, Graphics;

type  tagINSERT  = record
            inType : BYTE;
end;

type  PWILFILEHEADER = ^tagWILFILEHEADER;
      tagWILFILEHEADER = packed record
            shComp  :WORD;
            szTitle :array[1..20] of char;
            shVer   :WORD;
            nImageCount:integer;
end;

type  PWILFILEIMAGEINFO =^tagWILFILEIMAGEINFO;
      tagWILFILEIMAGEINFO = packed record
            shWidth :WORD;
            shHeight:WORD;
            shPX    :WORD;
            shPY    :WORD;
            bShadow :CHAR;
            shShadowPX:WORD;
            shShadowPY:WORD;
            dwImageLength:DWORD;
end;

type  PWIXFILEIMAGEINFO = ^tagWIXFILEIMAGEINFO;
      tagWIXFILEIMAGEINFO = packed record
            szTitle :array[1..20] of CHAR;
            nIndexCount:INTEGER;
end;

type  PtagColor = ^TtagColor;
      TtagColor = packed record
            B : BYTE;
            G : BYTE;
            R : BYTE;
end;

type  Ptag24BitHeader = ^tag24BitHeader;
      tag24BitHeader = packed record
            bfType  : WORD;   //$4D42
            bfSize  : DWORD;
            Rvd1    : WORD;
            Rvd2    : WORD;
            bfOffset: DWORD;
            biSize  : DWORD;  //$28
            biWidth : DWORD;
            biHeight: DWORD;
            biPlanes : WORD;  //01
            biBitCount: WORD; //$18
            biCom   : DWORD;
            biSizeOfCom:DWORD;
            biX     :DWORD;
            biY     :DWORD;
            biClrUsed:DWORD;
            biClrImportant:DWORD;  //biWidth*biHeight*3
end;

type
      TAARRAY   = array of array of DWORD;
      TARRAY    = array of WORD;

const sizeWILINFO = sizeof(tagWILFILEIMAGEINFO);
      sizeWILHEADER = sizeof(tagWILFILEHEADER);
      sizeWIXHEADER = sizeof(tagWIXFILEIMAGEINFO);
      sizeColor     = sizeof(TtagColor);
      sizeBit24Bmp  = sizeof(tag24BitHeader);
      EI3 = 1;
      GT3 = 2;

Type
  TWIL =  class;
  TWIL =  class(TPersistent)
  private
    G3          : boolean;
    G3Sign      : DWORD;
    POffsetIndex: DWORD;
    PWIL        : DWORD;
    FSize       : DWORD;
    FImageCount : integer;
    procedure  ImageClean(tWidth,tHigh:integer;Mask:WORD);
    function   GetCount:integer;
    function   GetOffset(Index:integer):DWORD;
    function   GetImageInfo(Index:integer):PWILFILEIMAGEINFO;
    function   CreatBitMap(Index:integer):tbitmap;
    function   CreateSaveBitMap(Index:integer):tbitmap;
    procedure  Adjust;
    procedure  AdjustEx(adT:Byte);
    function   ImageAdjst(var pDstc:Pointer;pRst:Pointer;adSize:DWORD;adType:Byte):DWORD;
    procedure  SetOffset(Index:integer;Offset:DWORD);
    procedure  SetWilSize(nSize:DWORD);
    function   Bit24To16Bit(Pcolor:PtagColor):WORD;
    function   GetImageDataBuf(Index:integer):DWORD;
    function   InsertImage(InIndex,InCount:integer;BufOffset:array of DWORD;BufImage:Pointer;SizeOfBufImage:DWORD):boolean;
    function   LoadFileToMem(var fP:Pointer;const fstr:string):DWORD;
    procedure  Bit16To24Bit(dscolor:PtagColor;rscolor:WORD);
    function   ImageFromCompMemToResMem(nX,nY,nXSize,nYSize:integer;pwSrc:array of WORD;nDstXSize,nDstYSize:integer;MaskColor:WORD):boolean;
  public
    Image       : TARRAY;
    destructor Destroy; override;
    procedure  Clear;
    procedure  ImageSaveToBmp(Index:integer;const fBmp:string);
    function   ImportFromSeq(ImpIndex,ImpCount:Integer;const fseq:string):boolean;
    function   GetNextValidImageIndex(CurrentIndex:integer):integer;
    function   GetPrevValidImageIndex(CurrentIndex:integer):INTEGER;
    function   Modify(Index:integer;tmp:PWILFILEIMAGEINFO):boolean;
    function   LoadFromFile(const fWix:string):BYTE;
    function   SaveToFile(const fWix:string;Edt:BYTE):boolean;
    function   ImageSaveToSeq(IndexBegin,ImageS:integer;const fSeq:string):boolean;
    property   Count:integer read GetCount;
    property   OffsetOfImage[Index:integer]:DWORD read GetOffset;
    property   InfoOfImage[Index:integer]:PWILFILEIMAGEINFO read GetImageInfo;
    property   OffsetOfImageColorBuf[Index:integer]:DWORD read GetImageDataBuf;
    property   IndexOfBitMap[Index:integer]:tbitmap read CreatBitMap;
end;

var
  Value:array [0..10] of WORD =
  (9836,1079,16189,10179,9576,7618,5363,66,1713,9212,7568);

implementation

function TWIL.ImageAdjst(var pDstc:Pointer;pRst:Pointer;adSize:DWORD;adType:Byte):DWORD;
var dwWord:DWORD;
begin
 ReSult:=0;
 dwWord:=PDWORD(DWORD(pRst)+sizeWILINFO)^;
       GetMem(pDstc,adSize);
       CopyMemory(pDstc,pRst,adSize);
       ReSult:=adSize;
{ case adType of
  GT3:
   begin
    if dwWord = 0 then
      begin      //GT3---->GT3
       GetMem(pDstc,adSize);
       CopyMemory(pDstc,pRst,adSize);
       ReSult:=adSize;
      end
    else        // EI3---->GT3
      begin
       GetMem(pDstc,adSize+4);
       CopyMemory(pDstc,pRst,sizeWILINFO);
       PDWORD(DWORD(pDstc)+sizeWILINFO)^:=0;
       CopyMemory(Pointer(DWORD(pDstc)+4+sizeWILINFO),Pointer(DWORD(pRst)+sizeWILINFO),adSize - sizeWILINFO);
       ReSult:=adSize+4;
      end;
   end;
  EI3:
   begin
    if dwWord = 0 then
      begin    //GT3---->EI3
       GetMem(pDstc,adSize-4);
       CopyMemory(pDstc,pRst,sizeWILINFO);
       CopyMemory(Pointer(DWORD(pDstc)+sizeWILINFO),Pointer(DWORD(pRst)+sizeWILINFO+4),adSize - sizeWILINFO - 4);
       ReSult:= adSize - 4;
      end
    else      //EI3---->EI3
      begin
       GetMem(pDstc,adSize);
       CopyMemory(pDstc,pRst,adSize);
       ReSult:=adSize;
      end;
   end;
 end;}
end;

function  TWIL.InsertImage(InIndex,InCount:integer;BufOffset:array of DWORD;BufImage:Pointer;SizeOfBufImage:DWORD):boolean;
var nPWIL,nImageIndex:DWORD;
    i,nAddIndex:integer;
begin
 ReSult:=False;
 try
 if ((InIndex >=0) and (InIndex<=FImageCount)) then
  begin
    GetMem(Pointer(nPWIL),FSize + SizeOfBufImage);
    CopyMemory(Pointer(nPWIL),Pointer(PWIL),FSize);
    CopyMemory(Pointer(nPWIL+FSize),BufImage,SizeOfBufImage);
    freemem(Pointer(PWIL));
    PWIL:=nPWIL;
    for i:=0 to InCount - 1 do
     begin
       if BufOffset[i]<>0 then BufOffset[i]:=BufOffset[i] + FSize;
     end;
    FSize:=FSize + SizeOfBufImage;
    nAddIndex:= (InIndex + InCount - 1) - (FImageCount - 1);
    if nAddIndex < 0 then nAddIndex:=0;
    GetMem(Pointer(nImageIndex),(FImageCount + nAddIndex)*sizeof(DWORD));
    CopyMemory(Pointer(nImageIndex),Pointer(POffsetIndex),FImageCount*sizeof(DWORD));
    FImageCount:=FImageCount+nAddIndex;
    freemem(Pointer(POffsetIndex));
    CopyMemory(Pointer(nImageIndex+InIndex*sizeof(DWORD)),@BufOffset[0],InCount*sizeof(DWORD));
    POffsetIndex:=nImageIndex;
    Adjust;
    ReSult:=TRUE;
  end;
  except end;
end;

function TWIL.LoadFileToMem(var fP:Pointer;const fstr:string):DWORD;
var hfstr,hMap:Cardinal;
    hMem:Pointer;
begin
  ReSult:=0;
  hfstr:=CreateFile(
        pchar(fstr),
        GENERIC_READ ,
        FILE_SHARE_WRITE or FILE_SHARE_READ,
        0,
        OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL,
        0
        );
  if hfstr<>INVALID_HANDLE_VALUE then
    begin
      hMap:=CreateFileMapping(hfstr,nil,PAGE_READONLY,0,0,nil);
      if hMap<>0 then
        begin
         hMem:=MapViewOfFile(hMap,FILE_MAP_READ,0,0,0);
         if hMem<>nil then
           begin
             ReSult:=GetFileSize(hfstr,0);
             GetMem(fP,ReSult);
             CopyMemory(fP,hMem,ReSult);
             UnmapViewOfFile(hMem);
           end;
         CloseHandle(hMap);
        end;
      CloseHandle(hfstr);
    end;
end;

function TWIL.ImportFromSeq(ImpIndex,ImpCount:Integer;const fseq:string):boolean;
var buffseq:Pointer;
    fseqSize,num_images,ac_cp_images,cp_size,I:DWORD;
    n_Index,tmp_Index:array of DWORD;
begin
  ReSult:=False;
  try
  fseqSize:=LoadFileToMem(buffseq,fseq);
  if fseqSize > 0 then
   begin
     num_images:=PDWORD(DWORD(buffseq)+sizeof(DWORD))^;
     if ((num_images > 0) and (num_images>=ImpCount)) then
      begin
       SetLength(tmp_Index,num_images);
       CopyMemory(@tmp_Index[0],Pointer(DWORD(buffseq)+2*sizeof(DWORD)),num_images*sizeof(DWORD));
       if num_images <= ImpCount then
        begin
          ac_cp_images:=num_images;
          cp_size:=fseqSize;
        end
       else
        begin
          ac_cp_images:=ImpCount;
          cp_size:=0;
          for I:= ImpCount to (num_images - 1) do
           begin
            if tmp_Index[I]<>0 then
             begin
               cp_size:=tmp_Index[I];
               Break;
             end;
           end;
          if cp_size=0 then cp_size:=fseqSize;
        end;
       SetLength(n_Index,ac_cp_images);
       ZeroMemory(@n_Index[0],ac_cp_images*sizeof(DWORD));
       CopyMemory(@n_Index[0],@tmp_Index[0],ac_cp_images*sizeof(DWORD));
       ReSult:=InsertImage(ImpIndex,ImpCount,n_Index,buffseq,cp_size);
       SetLength(n_Index,0);
       SetLength(tmp_Index,0);
      end;
     freemem(buffseq);
   end;
  except end;
end;

function TWIL.ImageSaveToSeq(IndexBegin,ImageS:integer;const fSeq:string):boolean;
var RS,PosBegin,OffsetBegin,OffsetEnd,NextOffset:DWORD;
    seqHeader:array of DWORD;
    i,j,IndexOfNext,EndIndex:integer;
    ValidPos:Integer;
    bfSize:DWORD;
    seqImageBuf,hMem:Pointer;
    hseq,hMap:Cardinal;
begin
  ReSult:=FALSE;
  if ((IndexBegin>=0) and (IndexBegin < FImageCount) and (ImageS>=1)) then
   begin
     SetLength(seqHeader,ImageS+2);
     if G3 then seqHeader[0]:=5201314 else seqHeader[0]:=5203344;
     seqHeader[1]:=ImageS;
     PosBegin:=(ImageS + 2)*sizeof(DWORD);
     j:=2;
     ValidPos:=0;
     OffsetBegin:=0;
     for i:=IndexBegin to (IndexBegin + ImageS - 1) do
      begin
        seqHeader[j]:=OffsetOfImage[i];
        if ValidPos = 0 then
         begin
           if seqHeader[j]<>0 then
            begin
              ValidPos:=J;
              OffsetBegin:=seqHeader[j];
              OffsetEnd:=seqHeader[j];
              EndIndex:=i;
              seqHeader[j]:=PosBegin;
            end;
         end
        else
         begin
           if seqHeader[j]<>0 then
            begin
              OffsetEnd:=seqHeader[j];
              EndIndex:=i;
              seqHeader[j]:=seqHeader[j] - OffsetBegin + seqHeader[ValidPos];
            end;
         end;
        Inc(J);
      end;
     if ValidPos <> 0 then
      begin
        if OffsetBegin=OffsetEnd then      //只有单独一个文件
         begin
           IndexOfNext:=GetNextValidImageIndex(IndexBegin);
           if IndexOfNext=IndexBegin then  // 位于文件末,或者是最后一个有形图像
            begin
              bfSize:= FSize - OffsetOfImage[IndexBegin];
            end
           else
            begin
              bfSize:= OffsetOfImage[IndexOfNext] - OffsetOfImage[IndexBegin];
            end;
         end
        else //多于一个文件
         begin
           IndexOfNext:=GetNextValidImageIndex(OffsetEnd);
           if IndexOfNext = OffsetEnd then //文末
             begin
               bfSize := FSize - OffsetOfImage[IndexBegin];
             end
           else
             begin
               bfSize:= OffsetOfImage[IndexOfNext] - OffsetOfImage[IndexBegin];
             end;
         end;
//        bfSize:=bfSize + sizeof(DWORD)*(ImageS+2);
        GetMem(seqImageBuf,bfSize);
        CopyMemory(seqImageBuf,Pointer({OffsetOfImage[IndexBegin]}OffsetBegin + PWIL),bfSize);
        hseq:=CreateFile(
          pchar(fSeq),
          GENERIC_READ or GENERIC_WRITE,
          FILE_SHARE_WRITE or FILE_SHARE_READ,