src/game/renders/opengl/r_textures.pas

   1 (* Copyright (C)  Doom 2D: Forever Developers
   2  *
   3  * This program is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, version 3 of the License ONLY.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  14  *)
  15 {$INCLUDE ../../../shared/a_modes.inc}
  16 unit r_textures;
  17
  18 interface
  19
  20   uses
  21     {$IFDEF USE_GLES1}
  22       GLES11,
  23     {$ELSE}
  24       GL, GLEXT,
  25     {$ENDIF}
  26     g_base,  // TRectHW
  27     utils,
  28     r_atlas
  29   ;
  30
  31   type
  32     TGLAtlas = class;
  33
  34     TGLAtlasNode = class (TAtlasNode)
  35       private
  36         mBase: TGLAtlas;
  37
  38       public
  39         constructor Create (base: TGLAtlas);
  40         destructor Destroy; override;
  41
  42         function GetID (): GLuint;
  43
  44         property base: TGLAtlas read mBase;
  45         property id: GLuint read GetID;
  46     end;
  47
  48     TGLAtlas = class (TAtlas)
  49       private
  50         mID: GLuint;
  51
  52       public
  53         constructor Create (ww, hh: Integer; id: GLuint);
  54         destructor Destroy; override;
  55
  56         function CreateNode (): TGLAtlasNode; override;
  57         function Alloc (ww, hh: Integer): TGLAtlasNode; overload;
  58
  59         property id: GLuint read mID write mID default 0;
  60     end;
  61
  62     TGLTexture = class
  63       private
  64         mWidth: Integer;
  65         mHeight: Integer;
  66         mCols: Integer;
  67         mTile: array of TGLAtlasNode;
  68
  69       public
  70         destructor Destroy; override;
  71
  72         function GetTile (col, line: Integer): TGLAtlasNode;
  73
  74         function GetLines (): Integer; inline;
  75
  76         property width: Integer read mWidth;
  77         property height: Integer read mHeight;
  78         property cols: Integer read mCols;
  79         property lines: Integer read GetLines;
  80     end;
  81
  82     TGLMultiTexture = class
  83       private
  84         mTexture: array of TGLTexture;
  85         mBackanim: Boolean;
  86
  87       public
  88         destructor Destroy; override;
  89
  90         function GetWidth (): Integer; inline;
  91         function GetHeight (): Integer; inline;
  92         function GetCount (): Integer; inline;
  93         function GetTexture (i: Integer): TGLTexture; {inline;}
  94
  95         property width: Integer read GetWidth;
  96         property height: Integer read GetHeight;
  97         property count: Integer read GetCount;
  98         property backAnim: Boolean read mBackanim; (* this property must be located at TAnimState? *)
  99     end;
 100
 101     TGLTextureArray = array of TGLTexture;
 102
 103     TRectArray = array of TRectWH;
 104
 105   procedure r_Textures_Initialize;
 106   procedure r_Textures_Finalize;
 107
 108   function r_Textures_LoadFromFile (const filename: AnsiString; log: Boolean = True): TGLTexture;
 109   function r_Textures_LoadMultiFromFile (const filename: AnsiString; log: Boolean = True): TGLMultiTexture;
 110   function r_Textures_LoadMultiFromFileAndInfo (const filename: AnsiString; w, h, count: Integer; backanim: Boolean; log: Boolean = True): TGLMultiTexture;
 111   function r_Textures_LoadStreamFromFile (const filename: AnsiString; w, h, count: Integer; st: TGLTextureArray; rs: TRectArray; log: Boolean = True): Boolean;
 112
 113 implementation
 114
 115   uses
 116     SysUtils, Classes,
 117     e_log, e_res, WADReader, Config,
 118     Imaging, ImagingTypes, ImagingUtility
 119   ;
 120
 121   var
 122     maxTileSize: Integer;
 123     atl: array of TGLAtlas;
 124
 125   (* --------- TGLAtlasNode --------- *)
 126
 127   constructor TGLAtlasNode.Create (base: TGLAtlas);
 128   begin
 129     ASSERT(base <> nil);
 130     inherited Create();
 131     self.mBase := base;
 132   end;
 133
 134   destructor TGLAtlasNode.Destroy;
 135   begin
 136     inherited;
 137   end;
 138
 139   function TGLAtlasNode.GetID (): GLuint;
 140   begin
 141     result := self.base.id
 142   end;
 143
 144   procedure r_Textures_UpdateNode (n: TGLAtlasNode; data: Pointer; x, y, w, h: Integer);
 145   begin
 146     ASSERT(n <> nil);
 147     // ASSERT(n.leaf);
 148     ASSERT(n.base <> nil);
 149     ASSERT(data <> nil);
 150     ASSERT(x >= 0);
 151     ASSERT(y >= 0);
 152     ASSERT(n.l + x + w - 1 <= n.r);
 153     ASSERT(n.t + y + h - 1 <= n.b);
 154     ASSERT(n.id > 0);
 155     glBindTexture(GL_TEXTURE_2D, n.id);
 156     glTexSubImage2D(GL_TEXTURE_2D, 0, n.l + x, n.t + y, w, h, GL_RGBA, GL_UNSIGNED_BYTE, data);
 157     glBindTexture(GL_TEXTURE_2D, 0);
 158   end;
 159
 160   (* --------- TGLAtlas --------- *)
 161
 162   constructor TGLAtlas.Create (ww, hh: Integer; id: GLuint);
 163   begin
 164     ASSERT(ww > 0);
 165     ASSERT(hh > 0);
 166     inherited Create(ww, hh);
 167     self.mID := id;
 168   end;
 169
 170   destructor TGLAtlas.Destroy;
 171   begin
 172     inherited;
 173   end;
 174
 175   function TGLAtlas.CreateNode (): TGLAtlasNode;
 176   begin
 177     result := TGLAtlasNode.Create(self);
 178   end;
 179
 180   function TGLAtlas.Alloc (ww, hh: Integer): TGLAtlasNode;
 181   begin
 182     result := TGLAtlasNode(inherited Alloc(ww, hh));
 183   end;
 184
 185   function r_Textures_AllocHWTexture (w, h: Integer): GLuint;
 186     var id: GLuint;
 187   begin
 188     glGenTextures(1, @id);
 189     if id <> 0 then
 190     begin
 191       glBindTexture(GL_TEXTURE_2D, id);
 192       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 193       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 194       glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, nil);
 195       glBindTexture(GL_TEXTURE_2D, 0);
 196     end;
 197     result := id
 198   end;
 199
 200   function r_Textures_AllocAtlas (): TGLAtlas;
 201     var i: Integer; id: GLuint;
 202   begin
 203     result := nil;
 204     id := r_Textures_AllocHWTexture(maxTileSize, maxTileSize);
 205     if id <> 0 then
 206     begin
 207       i := Length(atl);
 208       SetLength(atl, i + 1);
 209       atl[i] := TGLAtlas.Create(maxTileSize, maxTileSize, id);
 210       result := atl[i];
 211     end;
 212   end;
 213
 214   function r_Textures_AllocNode (w, h: Integer): TGLAtlasNode;
 215     var i: Integer; n: TGLAtlasNode; a: TGLAtlas;
 216   begin
 217     n := nil;
 218     if atl <> nil then
 219     begin
 220       i := High(atl);
 221       while (i >= 0) and (n = nil) do
 222       begin
 223         n := atl[i].Alloc(w, h);
 224         Dec(i);
 225       end;
 226     end;
 227     if n = nil then
 228     begin
 229       a := r_Textures_AllocAtlas();
 230       if a <> nil then
 231         n := a.Alloc(w, h);
 232     end;
 233     result := n
 234   end;
 235
 236   (* --------- TGLTexture --------- *)
 237
 238   destructor TGLTexture.Destroy;
 239     var i: Integer;
 240   begin
 241     if self.mTile <> nil then
 242     begin
 243       for i := 0 to High(self.mTile) do
 244       begin
 245         if self.mTile[i] <> nil then
 246         begin
 247           self.mTile[i].Dealloc;
 248           self.mTile[i] := nil;
 249         end;
 250       end;
 251       self.mTile := nil;
 252     end;
 253     inherited;
 254   end;
 255
 256   function TGLTexture.GetLines (): Integer;
 257   begin
 258     ASSERT(self.mTile <> nil);
 259     result := Length(self.mTile) div self.mCols
 260   end;
 261
 262   function TGLTexture.GetTile (col, line: Integer): TGLAtlasNode;
 263     var i: Integer;
 264   begin
 265     ASSERT(col >= 0);
 266     ASSERT(col <= mCols);
 267     ASSERT(self.mTile <> nil);
 268     i := line * mCols + col;
 269     ASSERT(i >= 0);
 270     ASSERT(i < Length(mTile));
 271     result := mTile[i];
 272     ASSERT(result <> nil)
 273   end;
 274
 275   function r_Textures_Alloc (w, h: Integer): TGLTexture;
 276     var x, y, mw, mh, cols, lines: Integer; t: TGLTexture;
 277   begin
 278     ASSERT(w > 0);
 279     ASSERT(h > 0);
 280     cols := (w + maxTileSize - 1) div maxTileSize;
 281     lines := (h + maxTileSize - 1) div maxTileSize;
 282     t := TGLTexture.Create;
 283     t.mWidth := w;
 284     t.mHeight := h;
 285     t.mCols := cols;
 286     // t.mLines := lines;
 287     SetLength(t.mTile, cols * lines);
 288     for y := 0 to lines - 1 do
 289     begin
 290       mh := Min(maxTileSize, h - y * maxTileSize);
 291       ASSERT(mh > 0);
 292       for x := 0 to cols - 1 do
 293       begin
 294         mw := Min(maxTileSize, w - x * maxTileSize);
 295         ASSERT(mw > 0);
 296         t.mTile[y * cols + x] := r_Textures_AllocNode(mw, mh);
 297       end
 298     end;
 299     result := t;
 300   end;
 301
 302   (* --------- TGLMultiTexture --------- *)
 303
 304   destructor TGLMultiTexture.Destroy;
 305     var i: Integer;
 306   begin
 307     for i := 0 to self.count - 1 do
 308       self.mTexture[i].Free;
 309     self.mTexture := nil;
 310     inherited;
 311   end;
 312
 313   function TGLMultiTexture.GetWidth (): Integer;
 314   begin
 315     result := self.mTexture[0].width
 316   end;
 317
 318   function TGLMultiTexture.GetHeight (): Integer;
 319   begin
 320     result := self.mTexture[0].height
 321   end;
 322
 323   function TGLMultiTexture.GetCount (): Integer;
 324   begin
 325     result := Length(self.mTexture)
 326   end;
 327
 328   function TGLMultiTexture.GetTexture (i: Integer): TGLTexture;
 329   begin
 330     ASSERT(i >= 0);
 331     ASSERT(i < self.count);
 332     result := self.mTexture[i];
 333     ASSERT(result <> nil);
 334   end;
 335
 336   (* --------- Init / Fin --------- *)
 337
 338   function r_Textures_GetMaxHardwareSize (): Integer;
 339     var size: GLint = 0;
 340   begin
 341     glGetIntegerv(GL_MAX_TEXTURE_SIZE, @size);
 342     if size < 64 then size := 64;
 343     //if size > 512 then size := 512;
 344     //size := 64; // !!!
 345     result := size;
 346   end;
 347
 348   procedure r_Textures_Initialize;
 349   begin
 350     maxTileSize := r_Textures_GetMaxHardwareSize();
 351   end;
 352
 353   procedure r_Textures_Finalize;
 354     var i: Integer;
 355   begin
 356     if atl <> nil then
 357     begin
 358       for i := 0 to High(atl) do
 359       begin
 360         glDeleteTextures(1, @atl[i].id);
 361         atl[i].id := 0;
 362         atl[i].Free;
 363       end;
 364       atl := nil;
 365     end;
 366   end;
 367
 368   function r_Textures_FixImageData (var img: TImageData): Boolean;
 369   begin
 370     result := false;
 371     if ConvertImage(img, TImageFormat.ifA8R8G8B8) then
 372       if SwapChannels(img, ChannelRed, ChannelBlue) then // wtf
 373         result := true;
 374   end;
 375
 376   function r_Textures_LoadFromImage (var img: TImageData): TGLTexture;
 377     var t: TGLTexture; n: TGLAtlasNode; c: TDynImageDataArray; cw, ch, i, j: LongInt;
 378   begin
 379     // e_logwritefln('r_Textures_CreateFromImage: w=%s h=%s', [img.width, img.height]);
 380     result := nil;
 381     if SplitImage(img, c, maxTileSize, maxTileSize, cw, ch, False) then
 382     begin
 383       t := r_Textures_Alloc(img.width, img.height);
 384       if t <> nil then
 385       begin
 386         ASSERT(cw = t.cols);
 387         ASSERT(ch = t.lines);
 388         for j := 0 to ch - 1 do
 389         begin
 390           for i := 0 to cw - 1 do
 391           begin
 392             n := t.GetTile(i, j);
 393             if n <> nil then
 394               r_Textures_UpdateNode(n, c[j * cw + i].bits, 0, 0, n.width, n.height)
 395           end
 396         end;
 397         result := t
 398       end;
 399       FreeImagesInArray(c);
 400     end;
 401   end;
 402
 403   function r_Textures_LoadFromMemory (data: Pointer; size: LongInt): TGLTexture;
 404     var img: TImageData;
 405   begin
 406     result := nil;
 407     if (data <> nil) and (size > 0) then
 408     begin
 409       InitImage(img);
 410       try
 411         if LoadImageFromMemory(data, size, img) then
 412           if r_Textures_FixImageData(img) then
 413             result := r_Textures_LoadFromImage(img)
 414       except
 415       end;
 416       FreeImage(img);
 417     end;
 418   end;
 419
 420   function r_Textures_LoadFromFile (const filename: AnsiString; log: Boolean = True): TGLTexture;
 421     var wad: TWADFile; wadName, resName: AnsiString; data: Pointer; size: Integer;
 422   begin
 423     result := nil;
 424     wadName := g_ExtractWadName(filename);
 425     wad := TWADFile.Create();
 426     if wad.ReadFile(wadName) then
 427     begin
 428       resName := g_ExtractFilePathName(filename);
 429       if wad.GetResource(resName, data, size, log) then
 430       begin
 431         result := r_Textures_LoadFromMemory(data, size);
 432         FreeMem(data);
 433       end;
 434       wad.Free
 435     end
 436   end;
 437
 438   function r_Textures_LoadMultiFromImageAndInfo (var img: TImageData; w, h, c: Integer; b: Boolean): TGLMultiTexture;
 439     var t: TImageData; a: array of TGLTexture; i: Integer; m: TGLMultiTexture;
 440   begin
 441     ASSERT(w >= 0);
 442     ASSERT(h >= 0);
 443     ASSERT(c >= 1);
 444     result := nil;
 445     SetLength(a, c);
 446     for i := 0 to c - 1 do
 447     begin
 448       InitImage(t);
 449       if NewImage(w, h, img.Format, t) then
 450         if CopyRect(img, w * i, 0, w, h, t, 0, 0) then
 451           a[i] := r_Textures_LoadFromImage(t);
 452       ASSERT(a[i] <> nil);
 453       FreeImage(t);
 454     end;
 455     m := TGLMultiTexture.Create();
 456     m.mTexture := a;
 457     m.mBackanim := b;
 458     ASSERT(m.mTexture <> nil);
 459     result := m;
 460   end;
 461
 462   function r_Textures_LoadMultiFromDataAndInfo (data: Pointer; size: LongInt; w, h, c: Integer; b: Boolean): TGLMultiTexture;
 463     var img: TImageData;
 464   begin
 465     ASSERT(w > 0);
 466     ASSERT(h > 0);
 467     ASSERT(c >= 1);
 468     result := nil;
 469     if (data <> nil) and (size > 0) then
 470     begin
 471       InitImage(img);
 472       try
 473         if LoadImageFromMemory(data, size, img) then
 474           if r_Textures_FixImageData(img) then
 475             result := r_Textures_LoadMultiFromImageAndInfo(img, w, h, c, b)
 476       except
 477       end;
 478       FreeImage(img);
 479     end;
 480   end;
 481
 482   function r_Textures_LoadMultiFromWad (wad: TWADFile): TGLMultiTexture;
 483     var data: Pointer; size: LongInt; TexRes: AnsiString; w, h, c: Integer; b: Boolean; cfg: TConfig; img: TImageData;
 484   begin
 485     ASSERT(wad <> nil);
 486     result := nil;
 487     if wad.GetResource('TEXT/ANIM', data, size) then
 488     begin
 489       cfg := TConfig.CreateMem(data, size);
 490       FreeMem(data);
 491       if cfg <> nil then
 492       begin
 493         TexRes := cfg.ReadStr('', 'resource', '');
 494         w := cfg.ReadInt('', 'framewidth', 0);
 495         h := cfg.ReadInt('', 'frameheight', 0);
 496         c := cfg.ReadInt('', 'framecount', 0);
 497         b := cfg.ReadBool('', 'backanim', false);
 498         if (TexRes <> '') and (w > 0) and (h > 0) and (c > 0) then
 499         begin
 500           if wad.GetResource('TEXTURES/' + TexRes, data, size) then
 501           begin
 502             InitImage(img);
 503             try
 504               if LoadImageFromMemory(data, size, img) then
 505                 if r_Textures_FixImageData(img) then
 506                   result := r_Textures_LoadMultiFromImageAndInfo(img, w, h, c, b)
 507             finally
 508               FreeMem(data);
 509             end;
 510             FreeImage(img);
 511           end
 512         end;
 513         cfg.Free;
 514       end
 515     end;
 516   end;
 517
 518   function r_Textures_LoadMultiFromMemory (data: Pointer; size: LongInt): TGLMultiTexture;
 519     var wad: TWADFile; t: TGLTexture; m: TGLMultiTexture;
 520   begin
 521     result := nil;
 522     if (data <> nil) and (size > 0) then
 523     begin
 524       t := r_Textures_LoadFromMemory(data, size);
 525       if t <> nil then
 526       begin
 527         m := TGLMultiTexture.Create();
 528         SetLength(m.mTexture, 1);
 529         m.mTexture[0] := t;
 530         m.mBackanim := false;
 531         result := m;
 532       end
 533       else if IsWadData(data, size) then
 534       begin
 535         wad := TWADFile.Create();
 536         if wad.ReadMemory(data, size) then
 537         begin
 538           result := r_Textures_LoadMultiFromWad(wad);
 539           wad.Free;
 540         end
 541       end
 542     end
 543   end;
 544
 545   function r_Textures_LoadMultiFromFile (const filename: AnsiString; log: Boolean = True): TGLMultiTexture;
 546     var wad: TWADFile; wadName, resName: AnsiString; data: Pointer; size: Integer; t: TGLTexture;
 547   begin
 548     result := nil;
 549     wadName := g_ExtractWadName(filename);
 550     wad := TWADFile.Create();
 551     if wad.ReadFile(wadName) then
 552     begin
 553       resName := g_ExtractFilePathName(filename);
 554       if wad.GetResource(resName, data, size, log) then
 555       begin
 556         result := r_Textures_LoadMultiFromMemory(data, size);
 557         FreeMem(data);
 558       end;
 559       wad.Free
 560     end
 561   end;
 562
 563   function r_Textures_LoadMultiFromFileAndInfo (const filename: AnsiString; w, h, count: Integer; backanim: Boolean; log: Boolean = True): TGLMultiTexture;
 564     var wad: TWADFile; wadName, resName: AnsiString; data: Pointer; size: Integer;
 565   begin
 566     ASSERT(w > 0);
 567     ASSERT(h > 0);
 568     ASSERT(count >= 1);
 569     result := nil;
 570     wadName := g_ExtractWadName(filename);
 571     wad := TWADFile.Create();
 572     if wad.ReadFile(wadName) then
 573     begin
 574       resName := g_ExtractFilePathName(filename);
 575       if wad.GetResource(resName, data, size, log) then
 576       begin
 577         result := r_Textures_LoadMultiFromDataAndInfo(data, size, w, h, count, backanim);
 578         FreeMem(data);
 579       end;
 580       wad.Free
 581     end
 582   end;
 583
 584   function r_Textures_GetRect (var img: TImageData): TRectWH;
 585     var i, j, w, h: Integer; done: Boolean;
 586
 587     function IsVoid (i, j: Integer): Boolean; inline;
 588     begin
 589       result := GetPixel32(img, i, j).Channels[3] = 0
 590     end;
 591
 592   begin
 593     w := img.Width;
 594     h := img.Height;
 595
 596     (* trace x from right to left *)
 597     done := false; i := 0;
 598     while not done and (i < w) do
 599     begin
 600       j := 0;
 601       while (j < h) and IsVoid(i, j) do inc(j);
 602       done := (j < h) and (IsVoid(i, j) = false);
 603       result.x := i;
 604       inc(i);
 605     end;
 606
 607     (* trace y from up to down *)
 608     done := false; j := 0;
 609     while not done and (j < h) do
 610     begin
 611       i := 0;
 612       while (i < w) and IsVoid(i, j) do inc(i);
 613       done := (i < w) and (IsVoid(i, j) = false);
 614       result.y := j;
 615       inc(j);
 616     end;
 617
 618     (* trace x from right to left *)
 619     done := false; i := w - 1;
 620     while not done and (i >= 0) do
 621     begin
 622       j := 0;
 623       while (j < h) and IsVoid(i, j) do inc(j);
 624       done := (j < h) and (IsVoid(i, j) = false);
 625       result.width := i - result.x + 1;
 626       dec(i);
 627     end;
 628
 629     (* trace y from down to up *)
 630     done := false; j := h - 1;
 631     while not done and (j >= 0) do
 632     begin
 633       i := 0;
 634       while (i < w) and IsVoid(i, j) do inc(i);
 635       done := (i < w) and (IsVoid(i, j) = false);
 636       result.height := j - result.y + 1;
 637       dec(j);
 638     end;
 639   end;
 640
 641   function r_Textures_LoadStreamFromImage (var img: TImageData; w, h, c: Integer; st: TGLTextureArray; rs: TRectArray): Boolean;
 642     var i: Integer; t: TImageData;
 643   begin
 644     ASSERT(w >= 0);
 645     ASSERT(h >= 0);
 646     ASSERT(c >= 1);
 647     ASSERT((st <> nil) and (Length(st) >= c));
 648     ASSERT((rs = nil) or (Length(rs) >= c));
 649     result := true;
 650     for i := 0 to c - 1 do
 651     begin
 652       InitImage(t);
 653       st[i] := nil;
 654       if NewImage(w, h, img.Format, t) then
 655       begin
 656         if CopyRect(img, w * i, 0, w, h, t, 0, 0) then
 657         begin
 658           if rs <> nil then
 659             rs[i] := r_Textures_GetRect(t);
 660           st[i] := r_Textures_LoadFromImage(t);
 661         end;
 662       end;
 663       ASSERT(st[i] <> nil);
 664       FreeImage(t);
 665     end;
 666   end;
 667
 668   function r_Textures_LoadStreamFromMemory (data: Pointer; size: LongInt; w, h, c: Integer; st: TGLTextureArray; rs: TRectArray): Boolean;
 669     var img: TImageData;
 670   begin
 671     ASSERT(w >= 0);
 672     ASSERT(h >= 0);
 673     ASSERT(c >= 1);
 674     ASSERT((st <> nil) and (Length(st) >= c));
 675     ASSERT((rs = nil) or (Length(rs) >= c));
 676     result := false;
 677     if (data <> nil) and (size > 0) then
 678     begin
 679       InitImage(img);
 680       try
 681         if LoadImageFromMemory(data, size, img) then
 682           if r_Textures_FixImageData(img) then
 683             result := r_Textures_LoadStreamFromImage(img, w, h, c, st, rs)
 684       except
 685       end;
 686       FreeImage(img);
 687     end;
 688   end;
 689
 690   function r_Textures_LoadStreamFromFile (const filename: AnsiString; w, h, count: Integer; st: TGLTextureArray; rs: TRectArray; log: Boolean = True): Boolean;
 691     var wad: TWADFile; wadName, resName: AnsiString; data: Pointer; size: Integer;
 692   begin
 693     ASSERT(w > 0);
 694     ASSERT(h > 0);
 695     ASSERT(count >= 1);
 696     ASSERT((st <> nil) and (Length(st) >= count));
 697     ASSERT((rs = nil) or (Length(rs) >= count));
 698     result := false;
 699     wadName := g_ExtractWadName(filename);
 700     wad := TWADFile.Create();
 701     if wad.ReadFile(wadName) then
 702     begin
 703       resName := g_ExtractFilePathName(filename);
 704       if wad.GetResource(resName, data, size, log) then
 705       begin
 706         result := r_Textures_LoadStreamFromMemory(data, size, w, h, count, st, rs);
 707         FreeMem(data);
 708       end;
 709       wad.Free
 710     end
 711   end;
 712
 713 end.