function LoadTexture(const FileName: string; var W, H: LongWord; var Data: Pointer; var Format: TD3DFormat): boolean;
var
 Bpp: LongWord;
begin
 Result:= LoadBmp(FileName, W, H, Bpp, Data);

 If Result then
 Case Bpp of
   24: Format:= D3DFMT_R8G8B8;
   32: Format:= D3DFMT_X8B8G8R8;
 end;
end;

function TTexture.Load(const FileName: string): boolean;
var
 W, H  : LongWord;
 Format: TD3DFormat;
 pScr  : Pointer;
 LRect : TD3DLockedRect;
begin
 Result:= False;

 If LoadTexture(FileName, W, H, pScr, Format) then
 begin
   If Check(Device.FDevice.CreateTexture(W, H, 0, 0, Format, D3DPOOL_MANAGED, FHandle, nil)) then
   begin
     If Check(FHandle.LockRect(0, LRect, nil, D3DLOCK_DISCARD)) then
     try
       // ?

     finally
       Result:= UnLock;
     end;
   end;

 end;
end;

If Check(FHandle.LockRect(0, LRect, nil, D3DLOCK_DISCARD)) then
try
 Move(pScr^, LRect.pBits^, W * H * 3);
finally
 Result:= UnLock;
end;

For y:= 0 to H - 1 do
  For x:= 0 to W - 1 do
  begin
     PDWORD(DWORD(LRect.pBits) + (Y * DWORD(LRect.Pitch)) + (X * 4))^:= D3DCOLOR_XRGB(255, 0, 0);
     Inc(PDWORD(LRect.pBits)^);
  end;

function TTexture.Load(const FileName: string; Custom: boolean = False): boolean;
var
 X, Y  : LongWord;
 W, H  : LongWord;
 P     : PRGB;
 pScr  : Pointer;
 LRect : TD3DLockedRect;
 Format: TD3DFormat;
begin
 If Custom then
 begin
   Result:= False;

   // Инфо: Bmp. (BGR, FlipH)
   If LoadTexture(FileName, W, H, pScr, Format) then
   try
     If not DXCheck(Device.FDevice.CreateTexture(W, H, 0, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, FHandle, nil)) then Exit;

     If DXCheck(FHandle.LockRect(0, LRect, nil, 0)) then
     try
       P:= pScr;
       For Y:= H - 1 downto 0 do
         For X:= 0 to W - 1 do
         with P^ do
         begin
           PDWORD(DWORD(LRect.pBits) + Y * LRect.Pitch + X * 4)^:= D3DCOLOR_XRGB(B, G, R);
           Inc(P);
         end;
     finally
       Result:= DXCheck(FHandle.UnlockRect(0));
     end;
   finally
     FreeMem(pScr);
   end;
 end else
   Result:= DXCheck(D3DXCreateTextureFromFile(Device.GetHandle, XPChar(FileName), FHandle));
end;

        with P^ do
        begin
          PDWORD(DWORD(LRect.pBits) + Y * LRect.Pitch + X * 4)^:= D3DCOLOR_XRGB(B, G, R);
          Inc(P);
        end;

type
 PRGB = ^TRGB;
 TRGB = record
   R, G, B: byte;
 end;

type
PRGBA = ^TRGBA;
TRGBA = record
  R, G, B, A: byte;
end;

     
      For Y:= H - 1 downto 0 do
      begin
        P:= Pointer(Integer(pScr)+((Y*W*3+3) div 4)*4);//выровняли по 4 байта
        For X:= 0 to W - 1 do
        with P^ do
        begin
          PDWORD(DWORD(LRect.pBits) + Y * LRect.Pitch + X * 4)^:= D3DCOLOR_XRGB(B, G, R);
          Inc(P);
        end;
      end;

     For Y:= H - 1 downto 0 do
     begin
       For X:= 0 to W - 1 do
       with P^ do
       begin
         PDWORD(DWORD(LRect.pBits) + Y * LRect.Pitch + X * 4)^:= D3DCOLOR_XRGB(B, G, R);
         Inc(P);
       end;
       P:= Pointer(((Integer(P)+3) div 4)*4);//выровняли по 4 байта
     end;

// ================================================================================ ====
// структура для хранения спрайта
typedef struct
{
int xsize;
int ysize;

LPDIRECTDRAWSURFACE7 Surf;
}spriteTag;

// ================================================================================ ====
// Загружает спрайт из архива
spriteTag* Pak_LoadSprite (packfile_t *pf, char *filename, int r, int g, int b)
{
char *buf_data;   // Буфер данных

  // Грузим данные в буффер, используя функцию из библиотеки
  /*
unpak.c   Copyright (C) 1998-2000 Vitaly Ovtchinnikov
         and Damir Sagidullin         */

int filesize = PackFileGet (pf, filename, &buf_data);

if (!filesize || !(*buf_data))  // Если ничего не загрузилось
{
 free (buf_data);
 return NULL;
}

// Копируем заголовок
BITMAPFILEHEADER bmpHEAD;
memcpy (&bmpHEAD, buf_data, sizeof(bmpHEAD));

// Проверяем, действительно ли это БМП файл
char *bmpType = (char*)&bmpHEAD.bfType;

if (*bmpType != 'B' || *++bmpType != 'M')  // Если нет
{
 free (buf_data);
 return NULL;
}

// Копируем второй - информацинный заголовок
BITMAPINFOHEADER bmpINFO;
memcpy (&bmpINFO, buf_data + sizeof(bmpHEAD), sizeof(bmpINFO));

if (bmpINFO.biCompression != BI_RGB) // Не сжатое ли изображение
{
 free (buf_data);
 return NULL;
}

// Устраивают ли нас пиксели
if (bmpINFO.biBitCount != 24)
{
 free (buf_data);
 return NULL;
}

// Выделяем место под спрайт
spriteTag *newSprite = new spriteTag;

// Если не удалось выделеть место
if (!newSprite)
{
 free (buf_data);
 return NULL;
}

// сохраним в спрайте размеры картинки
newSprite->xsize = bmpINFO.biWidth;
newSprite->ysize = bmpINFO.biHeight;

// Создаем поверхность
if (DirectDraw7_CreateSurface (&(newSprite->Surf), newSprite->xsize, newSprite->ysize))
{
 free (buf_data);
 delete newSprite;
 return NULL;
}

// Установим прозрачный цвет для поверхности
DirectDraw7_SetColorKey (newSprite->Surf, r, g, b);

// Вычисляем размер изображения, если нужно
int ImageSize = bmpINFO.biSizeImage;
if (!ImageSize)
 ImageSize = ((bmpINFO.biWidth*(bmpINFO.biBitCount/8)+3 & ~3)*bmpINFO.biHeight);

// Теперь займемся копированием точек на поверхность
BYTE *bmpbuf = (BYTE*)(buf_data + sizeof(bmpHEAD) + bmpINFO.biSize);

DDSURFACEDESC2 desc;
ZeroMemory (&desc, sizeof (desc));
desc.dwSize = sizeof (desc);

// Залочим поверхность чтобы с ней можно было работать
HRESULT res = newSprite->Surf->Lock( 0, &desc, DDLOCK_WAIT | DDLOCK_WRITEONLY, 0 );

// Если не получилось, то на выход
if (res != DD_OK)
{
 free (buf_data);
 delete newSprite;
 return false;
}

int BytesRequired = bmpINFO.biWidth * 3;
int BytesGiven = (BytesRequired + 3) & ~3;
BYTE *surfBits = (BYTE*)desc.lpSurface;
BYTE *imageBits = (BYTE*)(&bmpbuf[(bmpINFO.biHeight-1)*BytesGiven]);

for (int i=0; i<bmpINFO.biHeight; i++)
{
 WORD *pixptr = (WORD*)surfBits;
 RGBTRIPLE *triple = (RGBTRIPLE*)imageBits;

 for (int p=0; p<bmpINFO.biWidth; p++)
 {
  BYTE rf = triple->rgbtRed >> 3;
  BYTE gf = triple->rgbtGreen >> 2;
  BYTE bf = triple->rgbtBlue >> 3;

  *pixptr = (WORD)(bf | (gf << 5) | (rf << 11));
  triple++;
  pixptr++;
 }
 surfBits += desc.lPitch;
 imageBits -= BytesGiven;
}

// Разлочим поверхность
newSprite->Surf->Unlock (NULL);

  // вернем готовый спрайт
return newSprite;
}

     For Y:= H - 1 downto 0 do
     begin
       P:= Pointer(Integer(pScr)+((Y*3+3)*W div 4)*4);//выровняли по 4 байта
       For X:= 0 to W - 1 do
       with P^ do
       begin
         PDWORD(DWORD(LRect.pBits) + Y * LRect.Pitch + X * 4)^:= D3DCOLOR_XRGB(B, G, R);
         Inc(P);
       end;
     end;

    For Y:= H - 1 downto 0 do
    begin
      P:= Pointer(Integer(pScr)+((Y*3+3) div 4)*4*W);//выровняли по 4 байта
      For X:= 0 to W - 1 do
      with P^ do
      begin
        PDWORD(DWORD(LRect.pBits) + Y * LRect.Pitch + X * 4)^:= D3DCOLOR_XRGB(B, G, R);
        Inc(P);
      end;
    end;