Mercurial > mm7

comparison LOD.cpp @ 0:9c0607679772

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
init
author Ritor1
date Sat, 12 Jan 2013 09:45:18 +0600
parents
children fe0d9a98213f
comparison
equal deleted inserted replaced
-1:000000000000 0:9c0607679772
1 #include "LOD.h"
2 #include "Render.h"
3 #include "Allocator.h"
4 #include "PaletteManager.h"
5 #include "Viewport.h"
6 #include "Log.h"
7
8 #include "mm7_data.h"
9
10
11
12
13
14
15
16 LODFile_IconsBitmaps *pEvents_LOD;
17 LODFile_IconsBitmaps *pIcons_LOD;
18 LODFile_Sprites *pSprites_LOD;
19 LODFile_IconsBitmaps *pBitmaps_LOD;
20
21 LODWriteableFile *pNew_LOD;
22 LODWriteableFile *pGames_LOD;
23
24
25
26
27 int _6A0CA4_lod_binary_search; // weak
28 int _6A0CA8_lod_unused; // weak
29
30
31
32
33
34 //----- (004355F7) --------------------------------------------------------
35 void LODFile_IconsBitmaps::_4355F7()
36 {
37 LODFile_IconsBitmaps *v1; // esi@1
38 int v2; // edi@2
39 Texture *v3; // ebp@3
40 struct IDirect3DTexture2 **v4; // eax@4
41 struct IDirect3DTexture2 *v5; // eax@5
42 struct IDirectDrawSurface **v6; // eax@7
43 struct IDirectDrawSurface *v7; // eax@8
44 int v8; // eax@11
45
46 v1 = this;
47 if ( this->uTexturePacksCount )
48 {
49 v2 = this->uNumLoadedFiles - 1;
50 if ( v2 >= this->uNumPrevLoadedFiles )
51 {
52 v3 = &this->pTextures[v2];
53 do
54 {
55 v3->Release();
56 v4 = v1->pHardwareTextures;
57 if ( v4 )
58 {
59 v5 = v4[v2];
60 if ( v5 )
61 {
62 v5->Release();
63 v1->pHardwareTextures[v2] = 0;
64 }
65 }
66 v6 = v1->pHardwareSurfaces;
67 if ( v6 )
68 {
69 v7 = v6[v2];
70 if ( v7 )
71 {
72 v7->Release();
73 v1->pHardwareSurfaces[v2] = 0;
74 }
75 }
76 --v2;
77 --v3;
78 }
79 while ( v2 >= v1->uNumPrevLoadedFiles );
80 }
81 v8 = v1->uNumPrevLoadedFiles;
82 v1->uNumPrevLoadedFiles = 0;
83 v1->uNumLoadedFiles = v8;
84 v1->uTexturePacksCount = 0;
85 }
86 }
87
88 //----- (004114F2) --------------------------------------------------------
89 void LODFile_IconsBitmaps::_4114F2()
90 {
91 LODFile_IconsBitmaps *v1; // esi@1
92 int *pTexturePacksCount; // eax@1
93 int v3; // ecx@1
94 int v4; // ecx@2
95 int v5; // edi@3
96 Texture *v6; // ebx@4
97 struct IDirect3DTexture2 **v7; // eax@5
98 struct IDirect3DTexture2 *v8; // eax@6
99 struct IDirectDrawSurface **v9; // eax@8
100 struct IDirectDrawSurface *v10; // eax@9
101 int v11; // eax@12
102
103 v1 = this;
104 pTexturePacksCount = &this->uTexturePacksCount;
105 v3 = this->uTexturePacksCount;
106 if ( v3 )
107 {
108 v4 = v3 - 1;
109 *pTexturePacksCount = v4;
110 if ( !v4 )
111 {
112 v5 = v1->uNumLoadedFiles - 1;
113 if ( v5 >= v1->uNumPrevLoadedFiles )
114 {
115 v6 = &v1->pTextures[v5];
116 do
117 {
118 v6->Release();
119 v7 = v1->pHardwareTextures;
120 if ( v7 )
121 {
122 v8 = v7[v5];
123 if ( v8 )
124 {
125 v8->Release();
126 v1->pHardwareTextures[v5] = 0;
127 }
128 }
129 v9 = v1->pHardwareSurfaces;
130 if ( v9 )
131 {
132 v10 = v9[v5];
133 if ( v10 )
134 {
135 v10->Release();
136 v1->pHardwareSurfaces[v5] = 0;
137 }
138 }
139 --v5;
140 --v6;
141 }
142 while ( v5 >= v1->uNumPrevLoadedFiles );
143 }
144 v11 = v1->uNumPrevLoadedFiles;
145 v1->uNumPrevLoadedFiles = 0;
146 v1->uNumLoadedFiles = v11;
147 }
148 }
149 }
150
151 //----- (004AC67E) --------------------------------------------------------
152 int LODFile_Sprites::LoadSpriteFromFile(LODSprite *pSpriteHeader, const char *pContainer)
153 {
154 FILE *v3; // eax@1
155 FILE *v4; // ebx@1
156 int result; // eax@2
157 LODSprite *v6; // esi@3
158 LODSprite_stru0 *v7; // eax@3
159 size_t v8; // ST10_4@3
160 int *v9; // ebx@3
161 int v10; // eax@3
162 void *v11; // eax@5
163 LODSprite_stru0 *v12; // eax@6
164 void *v13; // ecx@6
165 LODSprite_stru0 *i; // edx@6
166 FILE *File; // [sp+4h] [bp-4h]@1
167 void *DstBufa; // [sp+10h] [bp+8h]@4
168 int Sizea; // [sp+14h] [bp+Ch]@3
169
170 v3 = FindContainer(pContainer, 0);
171 v4 = v3;
172 File = v3;
173 if ( v3 )
174 {
175 v6 = pSpriteHeader;
176 fread(pSpriteHeader, 1u, 0x20u, v3);
177 strcpy(pSpriteHeader->pName, pContainer);
178 Sizea = pSpriteHeader->uSpriteSize;
179 v7 = (LODSprite_stru0 *)pAllocator->AllocNamedChunk(v6->pSpriteLines, 8 * v6->uHeight, v6->pName);
180 v8 = 8 * pSpriteHeader->uHeight;
181 pSpriteHeader->pSpriteLines = v7;
182 fread(v7, 1u, v8, v4);
183 v9 = &pSpriteHeader->uDecompressedSize;
184 v10 = pSpriteHeader->uDecompressedSize;
185 if ( v10 )
186 {
187 pSpriteHeader->pDecompressedBytes = pAllocator->AllocNamedChunk(
188 pSpriteHeader->pDecompressedBytes,
189 v10,
190 pSpriteHeader->pName);
191 DstBufa = pAllocator->AllocNamedChunk(0, Sizea, pSpriteHeader->pName);
192 fread(DstBufa, 1u, Sizea, File);
193 zlib::MemUnzip(v6->pDecompressedBytes, (unsigned int *)&v6->uDecompressedSize, DstBufa, v6->uSpriteSize);
194 v6->uSpriteSize = *v9;
195 pAllocator->FreeChunk(DstBufa);
196 }
197 else
198 {
199 v11 = pAllocator->AllocNamedChunk(pSpriteHeader->pDecompressedBytes, Sizea, pSpriteHeader->pName);
200 pSpriteHeader->pDecompressedBytes = v11;
201 fread(v11, 1u, Sizea, File);
202 }
203 v12 = v6->pSpriteLines;
204 v13 = v6->pDecompressedBytes;
205 for ( i = &v12[v6->uHeight]; v12 < i; i = &v6->pSpriteLines[v6->uHeight] )
206 {
207 v12->ptr_4 = (char *)v12->ptr_4 + (unsigned int)v13;
208 ++v12;
209 }
210 result = 1;
211 }
212 else
213 {
214 result = -1;
215 }
216 return result;
217 }
218
219 //----- (004AC795) --------------------------------------------------------
220 bool LODFile_Sprites::LoadSprites(const char *pFilename)
221 {
222 if (LoadHeader(pFilename, 1))
223 return false;
224 else
225 return LoadSubIndices("sprites08") == 0;
226 }
227
228 //----- (004AC7C0) --------------------------------------------------------
229 int LODFile_Sprites::LoadSprite(const char *pContainerName, unsigned int uPaletteID)
230 { signed int v3; // edi@1
231 LODFile_Sprites *v4; // esi@1
232 unsigned int v5; // eax@6
233 signed int v6; // ecx@10
234 Sprite *v7; // eax@11
235 FILE *v8; // eax@12
236 Sprite *v10; // edx@21
237 int v11; // eax@21
238 int v12; // eax@22
239 unsigned __int8 v13; // zf@23
240 unsigned __int8 v14; // sf@23
241 LODSprite DstBuf; // [sp+Ch] [bp-3Ch]@12
242 char *Str1; // [sp+34h] [bp-14h]@24
243 LODSprite *v17; // [sp+38h] [bp-10h]@3
244 int v18; // [sp+44h] [bp-4h]@12
245
246 auto a3 = uPaletteID;
247 v3 = 0;
248 v4 = this;
249 if ( pRenderer->pRenderD3D )
250 {
251 if ( (signed int)this->uNumLoadedSprites > 0 )
252 {
253 v17 = 0;
254 while ( _strcmpi(*(const char **)&v17->pName[(unsigned int)v4->pHardwareSprites], pContainerName) )
255 {
256 ++v17;
257 ++v3;
258 if ( v3 >= (signed int)v4->uNumLoadedSprites )
259 goto LABEL_6;
260 }
261 return v3;
262 }
263 }
264 else
265 {
266 if ( (signed int)this->uNumLoadedSprites > 0 )
267 {
268 v17 = this->pSpriteHeaders;
269 while ( _strcmpi(v17->pName, pContainerName) )
270 {
271 ++v17;
272 ++v3;
273 if ( v3 >= (signed int)v4->uNumLoadedSprites )
274 goto LABEL_6;
275 }
276 return v3;
277 }
278 }
279 LABEL_6:
280 v5 = v4->uNumLoadedSprites;
281 if ( v5 == 1500 )
282 return -1;
283 if ( pRenderer->pRenderD3D && v4->field_ECAC )
284 {
285 if ( !v4->pHardwareSprites )
286 {
287 v4->pHardwareSprites = (Sprite *)pAllocator->AllocNamedChunk(0, 0xEA60u, "hardSprites");
288 v6 = 0;
289 do
290 {
291 v7 = &v4->pHardwareSprites[v6];
292 ++v6;
293 v7->pName = 0;
294 v7->pTextureSurface = 0;
295 v7->pTexture = 0;
296 }
297 while ( v6 < 1500 );
298 }
299 DstBuf.uHeight = 0;
300 DstBuf.uPaletteId = 0;
301 DstBuf.word_1A = 0;
302 DstBuf.pSpriteLines = 0;
303 DstBuf.pDecompressedBytes = 0;
304 v18 = 0;
305 v8 = FindContainer(pContainerName, 0);
306 if ( !v8 )
307 {
308 v18 = -1;
309 //LODSprite::dtor(&DstBuf);
310 return -1;
311 }
312 fread(&DstBuf, 1u, 0x20u, v8);
313 v10 = v4->pHardwareSprites;
314 v11 = 5 * v4->uNumLoadedSprites;
315 v18 = -1;
316 pHardwareSprites[uNumLoadedSprites].uBufferWidth = DstBuf.uWidth;
317 pHardwareSprites[uNumLoadedSprites].uBufferHeight = DstBuf.uHeight;
318 pSpriteHeaders[uNumLoadedSprites].uWidth = DstBuf.uWidth;
319 pSpriteHeaders[uNumLoadedSprites].uHeight = DstBuf.uHeight;
320 //LODSprite::dtor(&DstBuf);
321 goto LABEL_29;
322 }
323 v12 = LoadSpriteFromFile( &v4->pSpriteHeaders[v5], pContainerName);
324 v4->pSpriteHeaders[v4->uNumLoadedSprites].word_1A = 0;
325 if ( v12 != -1 )
326 {
327 LABEL_28:
328 v4->pSpriteHeaders[v4->uNumLoadedSprites].uPaletteId = pPaletteManager->LoadPalette(
329 v4->pSpriteHeaders[v4->uNumLoadedSprites].uPaletteId);
330 LABEL_29:
331 if ( pRenderer->pRenderD3D )
332 {
333 v4->pHardwareSprites[v4->uNumLoadedSprites].pName = (const char *)pAllocator->AllocNamedChunk(
334 v4->pHardwareSprites[v4->uNumLoadedSprites].pName,
335 0x14u,
336 pContainerName);
337 strcpy((char *)pHardwareSprites[uNumLoadedSprites].pName, pContainerName);
338 v4->pHardwareSprites[v4->uNumLoadedSprites].uPaletteID = uPaletteID;
339 pRenderer->MoveSpriteToDevice(&pHardwareSprites[uNumLoadedSprites]);
340 }
341 ++v4->uNumLoadedSprites;
342 return v4->uNumLoadedSprites - 1;
343 }
344 v13 = v4->uNumLoadedSprites == 0;
345 v14 = (v4->uNumLoadedSprites & 0x80000000u) != 0;
346 v17 = 0;
347 if ( v14 | v13 )
348 {
349 LABEL_27:
350 if ( LoadSpriteFromFile(&v4->pSpriteHeaders[v4->uNumLoadedSprites], "pending") == -1 )
351 return -1;
352 goto LABEL_28;
353 }
354 Str1 = (char *)v4->pSpriteHeaders;
355 while ( _strcmpi(Str1, "pending") )
356 {
357 v17 = (LODSprite *)((char *)v17 + 1);
358 Str1 += 40;
359 if ( (signed int)v17 >= (signed int)v4->uNumLoadedSprites )
360 goto LABEL_27;
361 }
362 return (int)v17;
363 }
364
365 //----- (004ACADA) --------------------------------------------------------
366 void LODFile_Sprites::ReleaseLostHardwareSprites()
367 {
368 LODFile_Sprites *v1; // esi@1
369 signed int v2; // ebx@2
370 int v3; // edi@3
371 IDirectDrawSurface *v4; // eax@4
372 IDirect3DTexture2 *v5; // eax@6
373 IDirectDrawSurface *v6; // ST00_4@8
374
375 v1 = this;
376 if ( this->pHardwareSprites )
377 {
378 v2 = 0;
379 if ( (signed int)this->uNumLoadedSprites > 0 )
380 {
381 v3 = 0;
382 do
383 {
384 v4 = (IDirectDrawSurface *)v1->pHardwareSprites[v3].pTextureSurface;
385 if ( v4 && v4->IsLost() == DDERR_SURFACELOST )
386 {
387 v5 = v1->pHardwareSprites[v3].pTexture;
388 if ( v5 )
389 {
390 v5->Release();
391 v1->pHardwareSprites[v3].pTexture = 0;
392 }
393 v6 = (IDirectDrawSurface *)v1->pHardwareSprites[v3].pTextureSurface;
394 v6->Release();
395 v1->pHardwareSprites[v3].pTextureSurface = 0;
396 pRenderer->MoveSpriteToDevice(&v1->pHardwareSprites[v3]);
397 }
398 ++v2;
399 ++v3;
400 }
401 while ( v2 < (signed int)v1->uNumLoadedSprites );
402 }
403 }
404 }
405
406 //----- (004ACB70) --------------------------------------------------------
407 void LODFile_Sprites::ReleaseAll()
408 {
409 LODFile_Sprites *v1; // esi@1
410 signed int v2; // ebx@2
411 int v3; // edi@3
412 Sprite *v4; // eax@4
413 IDirect3DTexture2 *v5; // eax@5
414 Sprite *v6; // eax@7
415 IDirectDrawSurface *v7; // eax@8
416
417 v1 = this;
418 if ( this->pHardwareSprites )
419 {
420 v2 = 0;
421 if ( (signed int)this->uNumLoadedSprites > 0 )
422 {
423 v3 = 0;
424 do
425 {
426 v4 = v1->pHardwareSprites;
427 if ( v4 )
428 {
429 v5 = v4[v3].pTexture;
430 if ( v5 )
431 {
432 v5->Release();
433 v1->pHardwareSprites[v3].pTexture = 0;
434 }
435 v6 = v1->pHardwareSprites;
436 if ( v6 )
437 {
438 v7 = (IDirectDrawSurface *)v6[v3].pTextureSurface;
439 if ( v7 )
440 {
441 v7->Release();
442 v1->pHardwareSprites[v3].pTextureSurface = 0;
443 }
444 }
445 }
446 ++v2;
447 ++v3;
448 }
449 while ( v2 < (signed int)v1->uNumLoadedSprites );
450 }
451 }
452 }
453
454 //----- (004ACBE0) --------------------------------------------------------
455 void LODFile_Sprites::MoveSpritesToVideoMemory()
456 {
457 LODFile_Sprites *v1; // esi@1
458 int v2; // ebx@1
459 signed int v3; // edi@2
460
461 v1 = this;
462 v2 = 0;
463 if ( this->pHardwareSprites )
464 {
465 v3 = 0;
466 if ( (signed int)this->uNumLoadedSprites > 0 )
467 {
468 do
469 {
470 pRenderer->MoveSpriteToDevice(&v1->pHardwareSprites[v2]);
471 ++v3;
472 ++v2;
473 }
474 while ( v3 < (signed int)v1->uNumLoadedSprites );
475 }
476 }
477 }
478
479 //----- (004ACC38) --------------------------------------------------------
480 int LODSprite::_4ACC38(RenderBillboardTransform_local0 *a2, char a3)
481 {
482 RenderBillboardTransform_local0 *v3; // edi@1
483 int result; // eax@1
484 int v5; // esi@2
485 int v6; // ST18_4@2
486 signed int v7; // eax@2
487 signed int v8; // ebx@2
488 int v9; // ebx@2
489 int *v10; // ecx@2
490 int v11; // esi@2
491 unsigned int v12; // edx@4
492 int v13; // esi@13
493 int v14; // esi@17
494 int v15; // ecx@17
495 char *v16; // edx@17
496 int v17; // esi@17
497 int v18; // ecx@18
498 int v19; // esi@18
499 LODSprite_stru0 *v20; // edx@21
500 int v21; // eax@22
501 int v22; // esi@22
502 int v23; // eax@25
503 int v24; // ecx@25
504 signed __int64 v25; // qtt@27
505 int v26; // eax@27
506 unsigned __int16 *v27; // eax@29
507 LODSprite_stru0 *v28; // edx@29
508 signed int v29; // ecx@30
509 int v30; // ecx@37
510 int v31; // ecx@38
511 signed int v32; // ecx@41
512 int v33; // ecx@47
513 int v34; // ecx@56
514 int v35; // esi@58
515 __int16 v36; // ax@58
516 int v37; // ecx@59
517 int v38; // eax@59
518 int v39; // ecx@62
519 signed int v40; // ST30_4@64
520 signed __int64 v41; // qtt@64
521 int v42; // ecx@64
522 unsigned __int16 *v43; // eax@66
523 LODSprite_stru0 *v44; // ecx@66
524 int v45; // edx@69
525 int v46; // edx@77
526 unsigned __int16 *pTarget; // [sp+Ch] [bp-50h]@2
527 signed int v48; // [sp+10h] [bp-4Ch]@2
528 signed int v49; // [sp+14h] [bp-48h]@2
529 int v50; // [sp+14h] [bp-48h]@19
530 int v51; // [sp+14h] [bp-48h]@57
531 int v52; // [sp+18h] [bp-44h]@13
532 int v53; // [sp+1Ch] [bp-40h]@2
533 int v54; // [sp+1Ch] [bp-40h]@22
534 int v55; // [sp+1Ch] [bp-40h]@32
535 int v56; // [sp+1Ch] [bp-40h]@69
536 int v57; // [sp+20h] [bp-3Ch]@2
537 int v58; // [sp+24h] [bp-38h]@1
538 int v59; // [sp+28h] [bp-34h]@2
539 int v60; // [sp+28h] [bp-34h]@13
540 unsigned __int16 *v61; // [sp+2Ch] [bp-30h]@2
541 int v62; // [sp+30h] [bp-2Ch]@2
542 void *v63; // [sp+30h] [bp-2Ch]@29
543 void *v64; // [sp+30h] [bp-2Ch]@66
544 int v65; // [sp+34h] [bp-28h]@2
545 int v66; // [sp+34h] [bp-28h]@22
546 int v67; // [sp+34h] [bp-28h]@59
547 int v68; // [sp+38h] [bp-24h]@13
548 unsigned int v69; // [sp+3Ch] [bp-20h]@2
549 int v70; // [sp+40h] [bp-1Ch]@2
550 signed int v71; // [sp+40h] [bp-1Ch]@15
551 int v72; // [sp+44h] [bp-18h]@2
552 unsigned __int16 *v73; // [sp+44h] [bp-18h]@29
553 unsigned __int16 *v74; // [sp+44h] [bp-18h]@66
554 int v75; // [sp+48h] [bp-14h]@4
555 int v76; // [sp+48h] [bp-14h]@22
556 int v77; // [sp+48h] [bp-14h]@59
557 LODSprite *v78; // [sp+4Ch] [bp-10h]@1
558 int v79; // [sp+50h] [bp-Ch]@4
559 int v80; // [sp+50h] [bp-Ch]@21
560 int v81; // [sp+50h] [bp-Ch]@62
561 int v82; // [sp+50h] [bp-Ch]@67
562 int v83; // [sp+50h] [bp-Ch]@75
563 int *pTargetZ; // [sp+54h] [bp-8h]@4
564 int v85; // [sp+58h] [bp-4h]@18
565 int v86; // [sp+58h] [bp-4h]@56
566 signed int v87; // [sp+64h] [bp+8h]@2
567 int v88; // [sp+68h] [bp+Ch]@18
568 int v89; // [sp+68h] [bp+Ch]@56
569
570 v3 = a2;
571 v78 = this;
572 result = a2->field_10;
573 v58 = a2->field_10;
574 if ( result <= 0 )
575 return result;
576 v5 = a2->field_14;
577 v6 = a2->field_10;
578 v87 = (signed __int64)0x100000000ui64 / result;
579 v48 = (signed __int64)0x100000000ui64 / result;
580 v62 = (signed __int64)0x100000000ui64 / v5;
581 v7 = this->uHeight;
582 v8 = (signed int)((signed __int64)0x100000000ui64 / v5) >> 1;
583 v53 = v8;
584 v70 = (this->uHeight << 16) - v8;
585 v49 = v7;
586 v69 = v3->uTargetPitch;
587 pTarget = v3->pTarget;
588 v57 = v3->sZValue;
589 v61 = v3->pPalette;
590 v9 = (v6 * this->uWidth + 32768) >> 16;
591 v72 = v3->uScreenSpaceY;
592 result = (v5 * v7 + 32768) >> 16;
593 v10 = (int *)(v72 - result + 1);
594 v11 = v3->uScreenSpaceX - (v9 >> 1) + 1;
595 v65 = v72 - result + 1;
596 v59 = v11 + v9 - 1;
597 if ( BYTE1(v3->uFlags) & 8 )
598 {
599 v10 = (int *)((char *)v10 + (v49 >> 1));
600 v72 += v49 >> 1;
601 v65 = (int)v10;
602 }
603 v12 = v72;
604 pTargetZ = v10;
605 v75 = v3->uScreenSpaceX - (v9 >> 1) + 1;
606 v79 = v11 + v9 - 1;
607 if ( !(v3->uFlags & 8) )
608 {
609 if ( v65 < (signed int)v3->uViewportY )
610 pTargetZ = (int *)v3->uViewportY;
611 if ( v72 > (signed int)v3->uViewportW )
612 v12 = v3->uViewportW;
613 if ( v11 < (signed int)v3->uViewportX )
614 v75 = v3->uViewportX;
615 if ( v59 > (signed int)v3->uViewportZ )
616 v79 = v3->uViewportZ;
617 }
618 v68 = v75 - v11;
619 v13 = -v62;
620 v60 = v59 - v79;
621 v52 = -v62;
622 if ( v3->uFlags & 1 )
623 {
624 v13 = v62;
625 v70 = v53;
626 v52 = v62;
627 }
628 v71 = v13 * (v72 - v12) + v70;
629 if ( LOBYTE(viewparams->field_20) )
630 {
631 if ( a3 )
632 return result;
633 }
634 v14 = 5 * v12;
635 v15 = v69 * v12;
636 result = v12 - v72 + result - 1;
637 v16 = (char *)pTargetZ - v65;
638 v17 = v14 << 7;
639 if ( v3->uFlags & 4 )
640 {
641 v34 = v79 + v15;
642 v89 = v34;
643 v86 = v79 + v17;
644 if ( result < (signed int)v16 )
645 return result;
646 v51 = result - (int)v16 + 1;
647 while ( 1 )
648 {
649 v35 = v71 >> 16;
650 v36 = LOWORD(v78->pSpriteLines[v35].dword_0);
651 if ( v36 == -1 )
652 {
653 v34 -= v69;
654 v89 = v34;
655 goto LABEL_84;
656 }
657 v37 = v9 - ((unsigned __int64)(v36 * (signed __int64)v58) >> 16);
658 v67 = v87 * ((unsigned __int64)(LOWORD(v78->pSpriteLines[v35].dword_0) * (signed __int64)v58) >> 16);
659 v38 = v9 - v60;
660 v77 = v9 - v60;
661 if ( v9 - v60 <= (signed int)(v9
662 - ((unsigned __int64)(HIWORD(v78->pSpriteLines[v35].dword_0) * (signed __int64)v58) >> 16))
663 || v68 >= v37 )
664 {
665 v89 -= v69;
666 v34 = v89;
667 LABEL_84:
668 v86 -= 640;
669 goto LABEL_85;
670 }
671 if ( v38 < v37 )
672 {
673 v81 = (v87 >> 1) + v87 * (v37 - v38);
674 }
675 else
676 {
677 v77 = v37;
678 v81 = v87 >> 1;
679 v39 = v37 - v9;
680 v89 += v39 + v60;
681 v86 += v60 + v39;
682 }
683 v40 = ((HIWORD(v78->pSpriteLines[v35].dword_0) + 1) << 16) - v81 - v67;
684 LODWORD(v41) = v40 << 16;
685 HIDWORD(v41) = v40 >> 16;
686 v42 = v77 - (((signed int)((unsigned __int64)(v41 / v48) - 32768) >> 16) + 1);
687 if ( v68 >= v42 )
688 v42 = v68;
689 v43 = &pTarget[v89];
690 v74 = &v43[v42 - v77 + 1];
691 v44 = &v78->pSpriteLines[v35];
692 v64 = v44->ptr_4;
693 if ( !v57 )
694 {
695 v83 = v67 + v81;
696 if ( ((v83 - (LOWORD(v44->dword_0) << 16)) & 0xFFFF0000) < 0 )
697 {
698 v83 += v87;
699 --v43;
700 --pTargetZ;
701 }
702 while ( v43 >= v74 )
703 {
704 v46 = (v83 - ((signed int)LOWORD(v78->pSpriteLines[v35].dword_0) << 16)) >> 16;
705 if ( *((char *)v64 + v46) )
706 *v43 = v61[*((char *)v64 + v46)];
707 v83 += v87;
708 --v43;
709 }
710 goto LABEL_81;
711 }
712 pTargetZ = &v3->pTargetZ[v86];
713 v82 = v67 + v81;
714 if ( ((v82 - (LOWORD(v44->dword_0) << 16)) & 0xFFFF0000) < 0 )
715 goto LABEL_72;
716 LABEL_73:
717 if ( v43 >= v74 )
718 break;
719 LABEL_81:
720 v89 += v9 - v77 - v60 - v69;
721 v34 = v89;
722 v86 = v86 + v9 - v77 - v60 - 640;
723 LABEL_85:
724 result = v52;
725 v71 += v52;
726 --v51;
727 if ( !v51 )
728 return result;
729 }
730 v45 = (v82 - ((signed int)LOWORD(v78->pSpriteLines[v35].dword_0) << 16)) >> 16;
731 v56 = *((char *)v64 + v45);
732 if ( *((char *)v64 + v45) && v57 <= (unsigned int)*pTargetZ )
733 {
734 *pTargetZ = v57;
735 *v43 = v61[v56];
736 }
737 LABEL_72:
738 v82 += v87;
739 --v43;
740 --pTargetZ;
741 goto LABEL_73;
742 }
743 v18 = v75 + v15;
744 v19 = v75 + v17;
745 v88 = v18;
746 v85 = v19;
747 if ( result >= (signed int)v16 )
748 {
749 v50 = result - (int)v16 + 1;
750 while ( 1 )
751 {
752 v20 = &v78->pSpriteLines[v71 >> 16];
753 v80 = v71 >> 16;
754 if ( LOWORD(v20->dword_0) != -1 )
755 break;
756 v18 -= v69;
757 v85 = v19 - 640;
758 v88 = v18;
759 LABEL_54:
760 result = v52;
761 v71 += v52;
762 --v50;
763 if ( !v50 )
764 return result;
765 v19 = v85;
766 }
767 v21 = (v58 * LOWORD(v20->dword_0) + 32768) >> 16;
768 v66 = v21 * v87;
769 v76 = v68;
770 v54 = HIWORD(v20->dword_0);
771 v22 = v9 - v60;
772 if ( v68 >= (v58 * v54 + 32768) >> 16 || v22 <= v21 )
773 {
774 v88 -= v69;
775 v85 -= 640;
776 goto LABEL_51;
777 }
778 if ( v68 > v21 )
779 {
780 v24 = (v87 >> 1) + v87 * (v68 - v21);
781 }
782 else
783 {
784 v76 = (v58 * LOWORD(v20->dword_0) + 32768) >> 16;
785 v23 = v21 - v68;
786 v88 += v23;
787 v24 = v87 >> 1;
788 v85 += v23;
789 }
790 LODWORD(v25) = (((v54 + 1) << 16) - v24 - v66) << 16;
791 HIDWORD(v25) = (((v54 + 1) << 16) - v24 - v66) >> 16;
792 v26 = v76 + ((signed int)(v25 / v48) >> 16) + 1;
793 if ( v22 > v26 )
794 v22 = v26;
795 v27 = &pTarget[v88];
796 v73 = &v27[v22 - v76 - 1];
797 v28 = &v78->pSpriteLines[v80];
798 v63 = v28->ptr_4;
799 if ( v57 )
800 {
801 pTargetZ = &v3->pTargetZ[v85];
802 v29 = v66 - (LOWORD(v28->dword_0) << 16) + v24;
803 if ( (v29 & 0xFFFF0000) >= 0 )
804 goto LABEL_36;
805 while ( 1 )
806 {
807 v29 += v87;
808 ++v27;
809 ++pTargetZ;
810 LABEL_36:
811 if ( v27 >= v73 )
812 break;
813 v55 = *((char *)v63 + (v29 >> 16));
814 if ( *((char *)v63 + (v29 >> 16)) && v57 <= (unsigned int)*pTargetZ )
815 {
816 *pTargetZ = v57;
817 *v27 = v61[v55];
818 }
819 }
820 v30 = v29 >> 16;
821 if ( v30 > HIWORD(v78->pSpriteLines[v80].dword_0) - (signed int)LOWORD(v78->pSpriteLines[v80].dword_0)
822 || (v31 = *((char *)v63 + v30)) == 0
823 || v57 > (unsigned int)*pTargetZ )
824 goto LABEL_50;
825 *pTargetZ = v57;
826 }
827 else
828 {
829 v32 = v66 - (LOWORD(v28->dword_0) << 16) + v24;
830 if ( (v32 & 0xFFFF0000) < 0 )
831 {
832 v32 += v87;
833 ++v27;
834 ++pTargetZ;
835 }
836 while ( v27 < v73 )
837 {
838 if ( *((char *)v63 + (v32 >> 16)) )
839 *v27 = v61[*((char *)v63 + (v32 >> 16))];
840 v32 += v87;
841 ++v27;
842 }
843 v33 = v32 >> 16;
844 if ( v33 > HIWORD(v78->pSpriteLines[v80].dword_0) - (signed int)LOWORD(v78->pSpriteLines[v80].dword_0)
845 || (v31 = *((char *)v63 + v33)) == 0 )
846 goto LABEL_50;
847 }
848 *v27 = v61[v31];
849 LABEL_50:
850 v88 += v68 - v76 - v69;
851 v85 = v85 + v68 - v76 - 640;
852 LABEL_51:
853 v18 = v88;
854 goto LABEL_54;
855 }
856 return result;
857 }
858
859 //----- (004AD2D1) --------------------------------------------------------
860 int LODSprite::_4AD2D1(struct RenderBillboardTransform_local0 *a2, int a3)
861 {
862 int result; // eax@1
863 unsigned int v4; // esi@1
864 int v5; // edi@1
865 LODSprite_stru0 *v6; // edx@2
866 __int16 v7; // bx@2
867 int v8; // ecx@3
868 unsigned __int16 *v9; // esi@3
869 int v10; // ebx@3
870 void *v11; // edx@3
871 unsigned __int16 *v12; // ecx@3
872 int v13; // ebx@4
873 LODSprite *v14; // [sp+8h] [bp-10h]@1
874 unsigned __int16 *v15; // [sp+10h] [bp-8h]@1
875 unsigned __int16 *v16; // [sp+14h] [bp-4h]@1
876 int i; // [sp+20h] [bp+8h]@1
877
878 result = (int)a2;
879 v14 = this;
880 v4 = a2->uTargetPitch;
881 v16 = a2->pTarget;
882 v15 = a2->pPalette;
883 v5 = this->uHeight - 1;
884 for ( i = v4 * a2->uScreenSpaceY - (this->uWidth >> 1) + a2->uScreenSpaceX + 1; v5 >= 0; --v5 )
885 {
886 v6 = &this->pSpriteLines[v5];
887 v7 = LOWORD(v6->dword_0);
888 if ( LOWORD(v6->dword_0) != -1 )
889 {
890 v8 = v7;
891 v9 = &v16[v7 + i];
892 v10 = HIWORD(v6->dword_0);
893 v11 = v6->ptr_4;
894 v12 = &v9[v10 - v8];
895 while ( v9 <= v12 )
896 {
897 v13 = *(char *)v11;
898 v11 = (char *)v11 + 1;
899 if ( v13 )
900 *v9 = v15[v13];
901 ++v9;
902 }
903 v4 = *(int *)(result + 48);
904 //this = v14;
905 }
906 i -= v4;
907 }
908 return result;
909 }
910
911 //----- (0046454B) --------------------------------------------------------
912 void LODFile_IconsBitmaps::ReleaseAll2()
913 {
914 LODFile_IconsBitmaps *v1; // esi@1
915 int v2; // edi@1
916 Texture *v3; // ebx@2
917 struct IDirect3DTexture2 **v4; // eax@3
918 struct IDirect3DTexture2 *v5; // eax@4
919 struct IDirectDrawSurface **v6; // eax@6
920 struct IDirectDrawSurface *v7; // eax@7
921 int v8; // eax@10
922
923 v1 = this;
924 v2 = this->uNumLoadedFiles - 1;
925 if ( v2 >= this->dword_11B84 )
926 {
927 v3 = &this->pTextures[v2];
928 do
929 {
930 v3->Release();
931 v4 = v1->pHardwareTextures;
932 if ( v4 )
933 {
934 v5 = v4[v2];
935 if ( v5 )
936 {
937 v5->Release();
938 v1->pHardwareTextures[v2] = 0;
939 }
940 }
941 v6 = v1->pHardwareSurfaces;
942 if ( v6 )
943 {
944 v7 = v6[v2];
945 if ( v7 )
946 {
947 v7->Release();
948 v1->pHardwareSurfaces[v2] = 0;
949 }
950 }
951 --v2;
952 --v3;
953 }
954 while ( v2 >= v1->dword_11B84 );
955 }
956 v8 = v1->dword_11B84;
957 v1->uTexturePacksCount = 0;
958 v1->uNumPrevLoadedFiles = 0;
959 v1->uNumLoadedFiles = v8;
960 }
961
962 //----- (004645DC) --------------------------------------------------------
963 void LODFile_Sprites::DeleteSomeOtherSprites()
964 {
965 int *v1; // esi@1
966 int *v2; // edi@1
967
968 v1 = (int *)&this->uNumLoadedSprites;
969 v2 = &this->field_ECA0;
970 DeleteSpritesRange(field_ECA0, uNumLoadedSprites);
971 *v1 = *v2;
972 }
973
974
975 //----- (00461431) --------------------------------------------------------
976 void LOD::File::Close()
977 {
978 LOD::File *v1; // esi@1
979 LOD::Directory **v2; // edi@2
980 FILE *v3; // ST00_4@2
981
982 v1 = this;
983 if ( this->isFileOpened )
984 {
985 this->pContainerName[0] = 0;
986 this->uCurrentIndexDir = 0;
987 v2 = &this->pSubIndices;
988 pAllocator->FreeChunk(this->pSubIndices);
989 pAllocator->FreeChunk(v1->pRoot);
990 v3 = v1->pFile;
991 *v2 = 0;
992 v1->pRoot = 0;
993 fclose(v3);
994 v1->isFileOpened = 0;
995 _6A0CA8_lod_unused = 0;
996 }
997 }
998
999
1000
1001 //----- (00461492) --------------------------------------------------------
1002 int LODWriteableFile::_461492(LOD::FileHeader *pHeader, LOD::Directory *pDir, const char *Source)
1003 {
1004 if (isFileOpened)
1005 return 1;
1006 if ( !pDir->pFilename[0] )
1007 return 2;
1008 strcpy(pHeader->pSignature, "LOD");
1009 pHeader->LODSize = 100;
1010 pHeader->uNumIndices = 1;
1011 pDir->pFilename[15] = 0;
1012 pDir->uDataSize = 0;
1013 pDir->uOfsetFromSubindicesStart = 288;
1014 strcpy(pLODName, Source);
1015
1016 pFile = fopen(pLODName, "wb+");
1017 if (!pFile)
1018 return 3;
1019
1020 fwrite(pHeader, 0x100, 1, pFile);
1021 fwrite(pDir, 0x20, 1, pFile);
1022 fclose(pFile);
1023 pFile = 0;
1024 return 0;
1025 }
1026
1027 //----- (0046153F) --------------------------------------------------------
1028 void LOD::File::ResetSubIndices()
1029 {
1030 LOD::Directory **pSubIndices_dup2; // esi@2
1031 LOD::Directory *pSubIndices_dup; // ST00_4@2
1032
1033 if ( this->isFileOpened )
1034 {
1035 pSubIndices_dup2 = &this->pSubIndices;
1036 this->pContainerName[0] = 0;
1037 this->uCurrentIndexDir = 0;
1038 pSubIndices_dup = this->pSubIndices;
1039 this->uOffsetToSubIndex = 0;
1040 this->uNumSubIndices = 0;
1041 this->uLODDataSize = 0;
1042 pAllocator->FreeChunk(pSubIndices_dup);
1043 *pSubIndices_dup2 = 0;
1044 }
1045 }
1046
1047
1048
1049
1050
1051
1052
1053 //----- (00450C8B) --------------------------------------------------------
1054 void LODFile_Sprites::DeleteSomeSprites()
1055 {
1056 int *v1; // esi@1
1057 int *v2; // edi@1
1058
1059 v1 = (int *)&this->uNumLoadedSprites;
1060 v2 = &this->field_ECA8;
1061 DeleteSpritesRange(this->field_ECA8, this->uNumLoadedSprites);
1062 *v1 = *v2;
1063 }
1064
1065 //----- (00450CA9) --------------------------------------------------------
1066 void LODFile_Sprites::DeleteSpritesRange(int uStartIndex, int uStopIndex)
1067 {
1068 LODFile_Sprites *v3; // edi@1
1069 int v4; // esi@3
1070 LODSprite *v5; // ebx@3
1071 LODSprite *v6; // esi@7
1072 int v7; // edi@7
1073 int a2a; // [sp+10h] [bp+8h]@3
1074
1075 v3 = this;
1076 if ( this->pHardwareSprites )
1077 {
1078 if ( uStartIndex < uStopIndex )
1079 {
1080 v4 = uStartIndex;
1081 v5 = &this->pSpriteHeaders[uStartIndex];
1082 a2a = uStopIndex - uStartIndex;
1083 do
1084 {
1085 v5->Release();
1086 pHardwareSprites[v4].Release();
1087 ++v4;
1088 ++v5;
1089 --a2a;
1090 }
1091 while ( a2a );
1092 }
1093 }
1094 else
1095 {
1096 if ( uStartIndex < uStopIndex )
1097 {
1098 v6 = &this->pSpriteHeaders[uStartIndex];
1099 v7 = uStopIndex - uStartIndex;
1100 do
1101 {
1102 v6->Release();
1103 ++v6;
1104 --v7;
1105 }
1106 while ( v7 );
1107 }
1108 }
1109 }
1110
1111 //----- (00450D1D) --------------------------------------------------------
1112 void LODSprite::Release()
1113 {
1114 LODSprite *v1; // esi@1
1115
1116 v1 = this;
1117 if ( !(HIBYTE(this->word_1A) & 4) )
1118 {
1119 pAllocator->FreeChunk(this->pDecompressedBytes);
1120 pAllocator->FreeChunk(v1->pSpriteLines);
1121 }
1122 v1->word_1A = 0;
1123 v1->pDecompressedBytes = 0;
1124 v1->pSpriteLines = 0;
1125 v1->pName[0] = 0;
1126 v1->word_16 = 0;
1127 v1->uPaletteId = 0;
1128 v1->uTexturePitch = 0;
1129 v1->uHeight = 0;
1130 v1->uWidth = 0;
1131 v1->uSpriteSize = 0;
1132 }
1133
1134 //----- (00450D68) --------------------------------------------------------
1135 void Sprite::Release()
1136 {
1137 if (pName)
1138 pAllocator->FreeChunk((void *)pName);
1139 pName = nullptr;
1140
1141 if (pTextureSurface)
1142 pTextureSurface->Release();
1143 pTextureSurface = nullptr;
1144
1145 if (pTexture)
1146 pTexture->Release();
1147 pTexture = nullptr;
1148 }
1149
1150
1151
1152
1153 //----- (0040FA2E) --------------------------------------------------------
1154 bool LODFile_IconsBitmaps::LoadBitmaps(const char *pFilename)
1155 {
1156 ReleaseAll();
1157 if (LoadHeader(pFilename, 1))
1158 return false;
1159 else
1160 return LoadSubIndices("bitmaps") == 0;
1161 }
1162
1163
1164 //----- (0040FAEE) --------------------------------------------------------
1165 bool LODFile_IconsBitmaps::LoadIconsOrEvents(const char *pLODFilename)
1166 {
1167 ReleaseAll();
1168
1169 if (LoadHeader(pLODFilename, 1))
1170 return false;
1171 else
1172 return LoadSubIndices("icons") == 0;
1173 }
1174
1175
1176 //----- (0040FA60) --------------------------------------------------------
1177 void LODFile_IconsBitmaps::ReleaseAll()
1178 {
1179 LODFile_IconsBitmaps *v1; // esi@1
1180 unsigned int v2; // edi@1
1181 Texture *v3; // ebp@2
1182 struct IDirect3DTexture2 **v4; // eax@3
1183 struct IDirect3DTexture2 *v5; // eax@4
1184 struct IDirectDrawSurface **v6; // eax@6
1185 struct IDirectDrawSurface *v7; // eax@7
1186
1187 v1 = this;
1188 v2 = this->uNumLoadedFiles - 1;
1189 if ( (v2 & 0x80000000u) == 0 )
1190 {
1191 v3 = &this->pTextures[v2];
1192 do
1193 {
1194 v3->Release();
1195 v4 = v1->pHardwareTextures;
1196 if ( v4 )
1197 {
1198 v5 = v4[v2];
1199 if ( v5 )
1200 {
1201 v5->Release();
1202 v1->pHardwareTextures[v2] = 0;
1203 }
1204 }
1205 v6 = v1->pHardwareSurfaces;
1206 if ( v6 )
1207 {
1208 v7 = v6[v2];
1209 if ( v7 )
1210 {
1211 v7->Release();
1212 v1->pHardwareSurfaces[v2] = 0;
1213 }
1214 }
1215 --v2;
1216 --v3;
1217 }
1218 while ( (v2 & 0x80000000u) == 0 );
1219 }
1220 v1->uTexturePacksCount = 0;
1221 v1->uNumPrevLoadedFiles = 0;
1222 v1->dword_11B84 = 0;
1223 v1->dword_11B80 = 0;
1224 v1->uNumLoadedFiles = 0;
1225 }
1226
1227 //----- (0040F9F0) --------------------------------------------------------
1228 unsigned int LODFile_IconsBitmaps::FindTextureByName(const char *pName)
1229 {
1230 LODFile_IconsBitmaps *v2; // esi@1
1231 unsigned int v3; // edi@1
1232 Texture *v4; // ebx@2
1233 unsigned int result; // eax@5
1234
1235 v2 = this;
1236 v3 = 0;
1237 if ( (signed int)this->uNumLoadedFiles <= 0 )
1238 {
1239 LABEL_5:
1240 result = -1;
1241 }
1242 else
1243 {
1244 v4 = this->pTextures;
1245 while ( _strcmpi(v4->pName, pName) )
1246 {
1247 ++v3;
1248 ++v4;
1249 if ( (signed int)v3 >= (signed int)v2->uNumLoadedFiles )
1250 goto LABEL_5;
1251 }
1252 result = v3;
1253 }
1254 return result;
1255 }
1256
1257 //----- (0040F9C5) --------------------------------------------------------
1258 int LODFile_IconsBitmaps::_40F9C5()
1259 {
1260 signed int result; // eax@1
1261 Texture *pTex; // edx@1
1262
1263 result = this->uNumLoadedFiles;
1264 for ( pTex = &this->pTextures[result]; !pTex->pName[0]; --pTex )
1265 --result;
1266 if ( result < (signed int)this->uNumLoadedFiles )
1267 {
1268 ++result;
1269 this->uNumLoadedFiles = result;
1270 }
1271 return result;
1272 }
1273
1274
1275
1276 //----- (0046249B) --------------------------------------------------------
1277 LODFile_Sprites::~LODFile_Sprites()
1278 {
1279 LODFile_Sprites *v1; // esi@1
1280 signed int v2; // ebx@1
1281 LODSprite *v3; // edi@3
1282 char *v4; // edi@6
1283 int thisa; // [sp+4h] [bp-10h]@3
1284 LODSprite *thisb; // [sp+4h] [bp-10h]@7
1285
1286 v1 = this;
1287 v2 = 0;
1288 if ( this->pHardwareSprites )
1289 {
1290 if ( (signed int)this->uNumLoadedSprites > 0 )
1291 {
1292 thisa = 0;
1293 v3 = this->pSpriteHeaders;
1294 do
1295 {
1296 v3->Release();
1297 v1->pHardwareSprites[thisa].Release();
1298 ++thisa;
1299 ++v2;
1300 ++v3;
1301 }
1302 while ( v2 < (signed int)v1->uNumLoadedSprites );
1303 }
1304 }
1305 else
1306 {
1307 v4 = (char *)&this->uNumLoadedSprites;
1308 if ( (signed int)this->uNumLoadedSprites > 0 )
1309 {
1310 thisb = this->pSpriteHeaders;
1311 do
1312 {
1313 thisb->Release();
1314 ++thisb;
1315 ++v2;
1316 }
1317 while ( v2 < *(int *)v4 );
1318 }
1319 }
1320 //_eh_vector_destructor_iterator_(v1->pSpriteHeaders, 40, 1500, LODSprite::dtor);
1321 //LOD::File::vdtor((LOD::File *)v1);
1322 }
1323 // 4CC2B4: using guessed type int __stdcall _eh vector destructor iterator_(int, int, int, int);
1324
1325
1326 //----- (00462463) --------------------------------------------------------
1327 LODSprite::~LODSprite()
1328 {
1329 LODSprite *v1; // esi@1
1330
1331 v1 = this;
1332 if ( !(HIBYTE(this->word_1A) & 4) )
1333 {
1334 pAllocator->FreeChunk(this->pDecompressedBytes);
1335 pAllocator->FreeChunk(v1->pSpriteLines);
1336 }
1337 v1->pDecompressedBytes = 0;
1338 v1->pSpriteLines = 0;
1339 }
1340
1341 //----- (004623E5) --------------------------------------------------------
1342 LODFile_Sprites::LODFile_Sprites():
1343 LOD::File()
1344 {
1345 /*_eh_vector_constructor_iterator_(
1346 v1->pSpriteHeaders,
1347 40,
1348 1500,
1349 (void (__thiscall *)(void *))LODSprite::LODSprite,
1350 (void (__thiscall *)(void *))LODSprite::dtor);*/
1351 field_ECA4 = 0;
1352 field_ECA0 = 0;
1353 pHardwareSprites = 0;
1354 field_ECAC = 0;
1355 field_ECB4 = 0;
1356 uNumLoadedSprites = 0;
1357 }
1358
1359 //----- (00462303) --------------------------------------------------------
1360 LODFile_IconsBitmaps::~LODFile_IconsBitmaps()
1361 {
1362 LODFile_IconsBitmaps *v1; // esi@1
1363 unsigned int v2; // edi@1
1364 struct IDirect3DTexture2 **v3; // eax@3
1365 struct IDirect3DTexture2 *v4; // eax@4
1366 struct IDirectDrawSurface **v5; // eax@6
1367 struct IDirectDrawSurface *v6; // eax@7
1368 Texture *thisa; // [sp+4h] [bp-10h]@2
1369
1370 v1 = this;
1371 v2 = this->uNumLoadedFiles - 1;
1372 if ( (v2 & 0x80000000u) == 0 )
1373 {
1374 thisa = &this->pTextures[v2];
1375 do
1376 {
1377 thisa->Release();
1378 v3 = v1->pHardwareTextures;
1379 if ( v3 )
1380 {
1381 v4 = v3[v2];
1382 if ( v4 )
1383 {
1384 v4->Release();
1385 v1->pHardwareTextures[v2] = 0;
1386 }
1387 }
1388 v5 = v1->pHardwareSurfaces;
1389 if ( v5 )
1390 {
1391 v6 = v5[v2];
1392 if ( v6 )
1393 {
1394 v6->Release();
1395 v1->pHardwareSurfaces[v2] = 0;
1396 }
1397 }
1398 --thisa;
1399 --v2;
1400 }
1401 while ( (v2 & 0x80000000u) == 0 );
1402 }
1403 if ( v1->pHardwareSurfaces )
1404 free(v1->pHardwareSurfaces);
1405 if ( v1->pHardwareTextures )
1406 free(v1->pHardwareTextures);
1407 if ( v1->ptr_011BB4 )
1408 free(v1->ptr_011BB4);
1409 //LOD::File::vdtor((LOD::File *)v1);
1410 }
1411
1412 //----- (00462272) --------------------------------------------------------
1413 LODFile_IconsBitmaps::LODFile_IconsBitmaps():
1414 LOD::File()
1415 {
1416 LODFile_IconsBitmaps *v1; // esi@1
1417 Texture *v2; // ebx@1
1418 signed int v3; // [sp+4h] [bp-10h]@1
1419
1420 v1 = this;
1421 /*v2 = v1->pTextures;
1422 v3 = 1000;
1423 do
1424 {
1425 Texture::Texture(v2);
1426 ++v2;
1427 --v3;
1428 }
1429 while ( v3 );*/
1430 v1->uTexturePacksCount = 0;
1431 v1->uNumPrevLoadedFiles = 0;
1432 v1->dword_11B84 = 0;
1433 v1->dword_11B80 = 0;
1434 v1->uNumLoadedFiles = 0;
1435 v1->dword_011BA4 = 0;
1436 v1->dword_011BA8 = 0;
1437 v1->pHardwareSurfaces = 0;
1438 v1->pHardwareTextures = 0;
1439 v1->ptr_011BB4 = 0;
1440 }
1441
1442
1443 //----- (004621A7) --------------------------------------------------------
1444 bool LODWriteableFile::_4621A7()
1445 {
1446 CloseWriteFile();
1447 return LoadFile(pLODName, 0);
1448 }
1449
1450
1451 //----- (00461FD4) --------------------------------------------------------
1452 int LODWriteableFile::Save()
1453 {
1454 LODWriteableFile *v1; // esi@1
1455 int v2; // edi@1
1456 unsigned int v3; // edx@1
1457 LOD::Directory *v4; // eax@2
1458 unsigned int v5; // ecx@2
1459 int v6; // eax@2
1460 signed int v7; // ebx@5
1461 int v8; // ecx@5
1462 LOD::Directory **v9; // edi@6
1463 int v10; // edx@6
1464 LOD::Directory *v11; // eax@6
1465 FILE *v12; // eax@9
1466 FILE *v13; // ebx@9
1467 signed int result; // eax@10
1468 unsigned int v15; // eax@11
1469 FILE *v16; // ST00_4@11
1470 size_t v17; // edi@12
1471 char OldFilename[256]; // [sp+Ch] [bp-228h]@9
1472 char NewFilename[256]; // [sp+10Ch] [bp-128h]@15
1473 //LOD::Directory v0; // [sp+20Ch] [bp-28h]@11
1474 unsigned int v21; // [sp+22Ch] [bp-8h]@5
1475 int v22; // [sp+230h] [bp-4h]@1
1476
1477 v1 = this;
1478 v2 = 0;
1479 v3 = this->uNumSubIndices;
1480 v22 = 0;
1481 if ( (signed int)v3 > 0 )
1482 {
1483 v4 = this->pSubIndices;
1484 v5 = v3;
1485 v6 = (int)&v4->uDataSize;
1486 do
1487 {
1488 v2 += *(int *)v6;
1489 v6 += 32;
1490 --v5;
1491 }
1492 while ( v5 );
1493 v22 = v2;
1494 }
1495 v7 = 0;
1496 v21 = 32 * v3 + v2;
1497 v8 = 32 * v3;
1498 if ( (signed int)v3 > 0 )
1499 {
1500 v9 = &v1->pSubIndices;
1501 v10 = 0;
1502 v11 = v1->pSubIndices;
1503 do
1504 {
1505 v11[v10].uOfsetFromSubindicesStart = v8;
1506 v11 = *v9;
1507 v8 += (*v9)[v10].uDataSize;
1508 ++v7;
1509 ++v10;
1510 }
1511 while ( v7 < (signed int)v1->uNumSubIndices );
1512 v2 = v22;
1513 }
1514 strcpy(OldFilename, "lod.tmp");
1515 v12 = fopen(OldFilename, "wb+");
1516 v13 = v12;
1517 if ( v12 )
1518 {
1519 fwrite(&v1->header, 0x100, 1, v12);
1520
1521 LOD::Directory v0; // [sp+20Ch] [bp-28h]@11
1522 //LOD::Directory::LOD::Directory(&v0);
1523
1524 strcpy((char *)&v0, "chapter");
1525 v15 = v1->uOffsetToSubIndex;
1526 v0.dword_000018 = 0;
1527 v0.uOfsetFromSubindicesStart = v15;
1528 v0.word_00001E = 0;
1529 v0.uDataSize = v21;
1530 v0.uNumSubIndices = LOWORD(v1->uNumSubIndices);
1531 fwrite(&v0, 0x20, 1, v13);
1532 fwrite(v1->pSubIndices, 0x20, v1->uNumSubIndices, v13);
1533 v16 = v1->pOutputFileHandle;
1534 v22 = v2;
1535 fseek(v16, 0, 0);
1536 if ( v2 > 0 )
1537 {
1538 do
1539 {
1540 v17 = v1->uIOBufferSize;
1541 if ( v22 <= (signed int)v17 )
1542 v17 = v22;
1543 fread(v1->pIOBuffer, 1, v17, v1->pOutputFileHandle);
1544 fwrite(v1->pIOBuffer, 1, v17, v13);
1545 v22 -= v17;
1546 }
1547 while ( v22 > 0 );
1548 }
1549 strcpy(NewFilename, (const char *)v1->pLODName);
1550 fclose(v13);
1551 fclose(v1->pOutputFileHandle);
1552 v1->CloseWriteFile();
1553 remove("lodapp.tmp");
1554 remove(NewFilename);
1555 rename(OldFilename, NewFilename);
1556 v1->CloseWriteFile();
1557 v1->LoadFile(v1->pLODName, 0);
1558 result = 0;
1559 }
1560 else
1561 {
1562 result = 5;
1563 }
1564 return result;
1565 }
1566
1567
1568 //----- (00461F71) --------------------------------------------------------
1569 bool LOD::File::AppendDirectory(LOD::Directory *pDir, const void *pData)
1570 {
1571 unsigned int v3; // edi@1
1572 bool result; // eax@2
1573 FILE *v5; // ST0C_4@3
1574
1575 v3 = this->uNumSubIndices;
1576 if ( (signed int)v3 < 299 )
1577 {
1578 memcpy(&this->pSubIndices[v3], pDir, sizeof(this->pSubIndices[v3]));
1579 v5 = this->pOutputFileHandle;
1580 ++this->uNumSubIndices;
1581 fwrite(pData, 1u, pDir->uDataSize, v5);
1582 result = 1;
1583 }
1584 else
1585 {
1586 MessageBoxA(0, "Unable to append item!", "LOD::File", 0x30u);
1587 result = 0;
1588 }
1589 return result;
1590 }
1591
1592
1593 //----- (00461F1E) --------------------------------------------------------
1594 int LODWriteableFile::CreateTempFile()
1595 {
1596 LODWriteableFile *v1; // esi@1
1597 int result; // eax@2
1598 FILE *pFile; // eax@5
1599 int v4; // eax@5
1600
1601 v1 = this;
1602 if ( this->isFileOpened )
1603 {
1604 if ( this->pIOBuffer && this->uIOBufferSize )
1605 {
1606 this->uCurrentIndexDir = 0;
1607 this->uNumSubIndices = 0;
1608 pFile = fopen("lodapp.tmp", "wb+");
1609 v1->pOutputFileHandle = pFile;
1610 v4 = -(pFile != 0);
1611 LOBYTE(v4) = v4 & 0xF9;
1612 result = v4 + 7;
1613 }
1614 else
1615 {
1616 result = 5;
1617 }
1618 }
1619 else
1620 {
1621 result = 1;
1622 }
1623 return result;
1624 }
1625
1626
1627
1628 //----- (00461EE9) --------------------------------------------------------
1629 void LODWriteableFile::CloseWriteFile()
1630 {
1631 if (isFileOpened)
1632 {
1633 pContainerName[0] = 0;
1634 uCurrentIndexDir = 0;
1635 _6A0CA8_lod_unused = 0;
1636
1637 isFileOpened = false;
1638 fflush(pFile);
1639 fclose(pFile);
1640 pFile = 0;
1641 }
1642 }
1643 // 6A0CA8: using guessed type int 6A0CA8_lod_unused;
1644
1645
1646 //----- (00461B48) --------------------------------------------------------
1647 unsigned int LODWriteableFile::Write(const LOD::Directory *pDir, const void *pDirData, int a4)
1648 {
1649 LODWriteableFile *v4; // ebx@1
1650 int v5; // esi@1
1651 unsigned __int8 v7; // zf@7
1652 unsigned __int8 v8; // sf@7
1653 const LOD::Directory *v9; // edi@9
1654 int v10; // eax@9
1655 unsigned __int8 v11; // of@15
1656 unsigned __int16 v12; // dx@17
1657 LOD::Directory *v13; // eax@17
1658 unsigned __int16 v14; // cx@17
1659 int v15; // edi@27
1660 unsigned int v16; // eax@27
1661 int v17; // eax@29
1662 int v18; // edx@31
1663 int v19; // eax@31
1664 void *v20; // edi@32
1665 LOD::Directory *v21; // edi@34
1666 signed int v22; // esi@34
1667 int v23; // eax@34
1668 LOD::Directory *v24; // ecx@35
1669 int v25; // edx@35
1670 __int32 v26; // eax@37
1671 int i; // esi@39
1672 __int32 v28; // esi@46
1673 char pFilename[256]; // [sp+Ch] [bp-230h]@22
1674 char NewFilename[256]; // [sp+10Ch] [bp-130h]@51
1675 //LOD::Directory Str; // [sp+20Ch] [bp-30h]@27
1676 size_t v33; // [sp+22Ch] [bp-10h]@27
1677 int v34; // [sp+230h] [bp-Ch]@7
1678 __int32 v35; // [sp+234h] [bp-8h]@8
1679 int v36; // [sp+238h] [bp-4h]@7
1680 size_t Count; // [sp+244h] [bp+8h]@40
1681 __int32 Countc; // [sp+244h] [bp+8h]@46
1682 size_t Countb; // [sp+244h] [bp+8h]@47
1683 FILE *pFile; // [sp+24Ch] [bp+10h]@22
1684
1685 v4 = this;
1686 v5 = 0;
1687 if ( !this->isFileOpened )
1688 return 1;
1689 if ( !this->pSubIndices )
1690 return 2;
1691 if ( !this->pIOBuffer || !this->uIOBufferSize )
1692 return 3;
1693 v7 = this->uNumSubIndices == 0;
1694 v8 = (this->uNumSubIndices & 0x80000000u) != 0;
1695 v36 = 0;
1696 v34 = 0;
1697 if ( v8 | v7 )
1698 {
1699 v9 = pDir;
1700 goto LABEL_22;
1701 }
1702 v35 = 0;
1703 while ( 1 )
1704 {
1705 v9 = pDir;
1706 v10 = _strcmpi((const char *)v4->pSubIndices + v35, (const char *)pDir);
1707 if ( v10 )
1708 {
1709 if ( v10 > 0 )
1710 goto LABEL_22;
1711 goto LABEL_15;
1712 }
1713 if ( !a4 )
1714 goto LABEL_20;
1715 if ( a4 == 1 )
1716 break;
1717 if ( a4 == 2 )
1718 return 4;
1719 LABEL_15:
1720 v35 += 32;
1721 ++v5;
1722 v11 = v5 >= v4->uNumSubIndices;
1723 v8 = ((v5 - v4->uNumSubIndices) & 0x80000000u) != 0;
1724 v34 = v5;
1725 if ( !(v8 ^ v11) )
1726 goto LABEL_22;
1727 }
1728 v12 = pDir->uNumSubIndices;
1729 v13 = &v4->pSubIndices[v5];
1730 v14 = v13->uNumSubIndices;
1731 if ( v14 >= v12 && (v14 != v12 || (unsigned __int16)v13->word_00001E >= pDir->word_00001E) )
1732 return 4;
1733 LABEL_20:
1734 v36 = 1;
1735 LABEL_22:
1736 strcpy(pFilename, "lod.tmp");
1737 pFile = fopen(pFilename, "wb+");
1738 if ( !pFile )
1739 return 5;
1740 if ( v36 )
1741 v35 = v4->pSubIndices[v5].uDataSize;
1742 else
1743 v35 = 0;
1744 v33 = v9->uDataSize;
1745 v15 = v33 - v35;
1746
1747 LOD::Directory Str; // [sp+20Ch] [bp-30h]@27
1748 //LOD::Directory::LOD::Directory(&Str);
1749
1750 strcpy((char *)&Str, "chapter");
1751 v16 = v4->uLODDataSize;
1752 Str.uNumSubIndices = LOWORD(v4->uNumSubIndices);
1753 Str.dword_000018 = 0;
1754 Str.word_00001E = 0;
1755 if ( !v36 )
1756 {
1757 ++Str.uNumSubIndices;
1758 v15 += 32;
1759 }
1760 v7 = v36 == 0;
1761 Str.uDataSize = v15 + v16;
1762 Str.uOfsetFromSubindicesStart = 288;
1763 v17 = (signed __int16)Str.uNumSubIndices;
1764 v4->uNumSubIndices = (signed __int16)Str.uNumSubIndices;
1765 if ( v7 && v17 > v5 )
1766 {
1767 v18 = v17;
1768 v19 = v17 - v5;
1769 do
1770 {
1771 v20 = &v4->pSubIndices[v18];
1772 --v18;
1773 --v19;
1774 memcpy(v20, (char *)v20 - 32, 0x20u);
1775 }
1776 while ( v19 );
1777 v5 = v34;
1778 }
1779 v21 = v4->pSubIndices;
1780 v34 = 32 * v5;
1781 memcpy(&v21[v5], pDir, sizeof(v21[v5]));
1782 v22 = 0;
1783 v23 = 32 * v4->uNumSubIndices;
1784 if ( (signed int)v4->uNumSubIndices > 0 )
1785 {
1786 v24 = v4->pSubIndices;
1787 v25 = 0;
1788 do
1789 {
1790 v24[v25].uOfsetFromSubindicesStart = v23;
1791 v24 = v4->pSubIndices;
1792 v23 += v24[v25].uDataSize;
1793 ++v22;
1794 ++v25;
1795 }
1796 while ( v22 < (signed int)v4->uNumSubIndices );
1797 }
1798 fwrite(&v4->header, 0x100u, 1u, pFile);
1799 fwrite(&Str, 0x20, 1, pFile);
1800 fseek(v4->pFile, Str.uOfsetFromSubindicesStart, 0);
1801 fwrite(v4->pSubIndices, 0x20u, v4->uNumSubIndices, pFile);
1802 v26 = 32 * v4->uNumSubIndices;
1803 if ( !v36 )
1804 v26 -= 32;
1805 fseek(v4->pFile, v26, 1);
1806 for ( i = *(unsigned int *)((char *)&v4->pSubIndices->uOfsetFromSubindicesStart + v34)
1807 - v4->pSubIndices->uOfsetFromSubindicesStart; i > 0; i -= Count )
1808 {
1809 Count = v4->uIOBufferSize;
1810 if ( i <= (signed int)v4->uIOBufferSize )
1811 Count = i;
1812 fread(v4->pIOBuffer, 1u, Count, v4->pFile);
1813 fwrite(v4->pIOBuffer, 1u, Count, pFile);
1814 }
1815 fwrite(pDirData, 1u, v33, pFile);
1816 if ( v36 )
1817 fseek(v4->pFile, v35, 1);
1818 Countc = ftell(v4->pFile);
1819 fseek(v4->pFile, 0, 2);
1820 v28 = ftell(v4->pFile) - Countc;
1821 fseek(v4->pFile, Countc, 0);
1822 while ( v28 > 0 )
1823 {
1824 Countb = v4->uIOBufferSize;
1825 if ( v28 <= (signed int)v4->uIOBufferSize )
1826 Countb = v28;
1827 fread(v4->pIOBuffer, 1u, Countb, v4->pFile);
1828 fwrite(v4->pIOBuffer, 1u, Countb, pFile);
1829 v28 -= Countb;
1830 }
1831 strcpy(NewFilename, (const char *)v4->pLODName);
1832 fclose(pFile);
1833 v4->CloseWriteFile();
1834 remove(NewFilename);
1835 rename(pFilename, NewFilename);
1836 v4->CloseWriteFile();
1837 v4->LoadFile(v4->pLODName, 0);
1838 return 0;
1839 }
1840
1841
1842 //----- (00461A43) --------------------------------------------------------
1843 bool LODWriteableFile::LoadFile(const char *pFilename, bool bWriting)
1844 {
1845 LODWriteableFile *v3; // esi@1
1846 FILE *pFile_dup; // eax@4
1847 unsigned int v5; // ecx@5
1848 __int32 v6; // eax@5
1849 FILE *v7; // ST00_4@5
1850 size_t v8; // edi@5
1851 const char *v10; // [sp-4h] [bp-30h]@2
1852
1853 v3 = this;
1854 if ( bWriting & 1 )
1855 v10 = "rb";
1856 else
1857 v10 = "rb+";
1858 pFile_dup = fopen(pFilename, v10);
1859 v3->pFile = pFile_dup;
1860 if ( !pFile_dup )
1861 {
1862 isFileOpened = false;
1863 return 0;
1864 }
1865 strcpy(pLODName, pFilename);
1866 fread(&header, 0x100u, 1u, v3->pFile);
1867
1868 LOD::Directory dir; // [sp+Ch] [bp-20h]@5
1869 //LOD::Directory::LOD::Directory(&dir);
1870
1871 fread(&dir, 0x20u, 1u, v3->pFile);
1872 fseek(v3->pFile, 0, 0);
1873 isFileOpened = 1;
1874 strcpy((char *)v3->pContainerName, "chapter");
1875 v5 = (signed __int16)dir.uNumSubIndices;
1876 v6 = dir.uOfsetFromSubindicesStart;
1877 v3->uCurrentIndexDir = 0;
1878 v3->uOffsetToSubIndex = v6;
1879 v7 = v3->pFile;
1880 v3->uNumSubIndices = v5;
1881 v3->uLODDataSize = dir.uDataSize;
1882 fseek(v7, v6, SEEK_SET);
1883 v8 = v3->uNumSubIndices;
1884 if ( (signed int)v8 > 300 )
1885 {
1886 MessageBoxA(0, "LODchapterPages exceed 300", "LOD::File", MB_ICONEXCLAMATION);
1887 fclose(v3->pFile);
1888 return 0;
1889 }
1890 fread(pSubIndices, 0x20u, v8, v3->pFile);
1891 return 1;
1892 }
1893
1894
1895 //----- (00461A11) --------------------------------------------------------
1896 void LOD::File::FreeSubIndexAndIO()
1897 {
1898 void *v1; // edi@1
1899 LOD::Directory **v2; // esi@1
1900
1901 v1 = this;
1902 v2 = &this->pSubIndices;
1903 pAllocator->FreeChunk(this->pSubIndices);
1904 v1 = (char *)v1 + 264;
1905 pAllocator->FreeChunk(pIOBuffer);// delete [] pIOBuffer;
1906 pIOBuffer = nullptr;
1907 pSubIndices = nullptr;
1908 }
1909
1910
1911 //----- (00461954) --------------------------------------------------------
1912 void LOD::File::AllocSubIndicesAndIO(unsigned int uNumSubIndices, unsigned int uBufferSize)
1913 {
1914 //LOD::File *v3; // esi@1
1915 LOD::Directory *pSubIndices_dup; // eax@3
1916 char v5; // zf@3
1917
1918 //v3 = this;
1919 if (pSubIndices)
1920 {
1921 MessageBoxA(0, "Attempt to reset a LOD subindex!", "MM6", MB_ICONEXCLAMATION);
1922 pAllocator->FreeChunk(pSubIndices);
1923 pSubIndices = nullptr;
1924 }
1925 pSubIndices_dup = (LOD::Directory *)pAllocator->AllocNamedChunk(
1926 pSubIndices,
1927 32 * uNumSubIndices,
1928 "LODsub");
1929 v5 = pIOBuffer == 0;
1930 pSubIndices = pSubIndices_dup;
1931 if ( !v5 )
1932 {
1933 MessageBoxA(0, "Attempt to reset a LOD IObuffer!", "MM6", MB_ICONEXCLAMATION);
1934 pAllocator->FreeChunk(pIOBuffer);
1935 pIOBuffer = 0;
1936 uIOBufferSize = 0;
1937 }
1938 if ( uBufferSize )
1939 {
1940 pIOBuffer = (unsigned __int8 *)pAllocator->AllocNamedChunk(pIOBuffer, uBufferSize, "LODio");
1941 uIOBufferSize = uBufferSize;
1942 }
1943 }
1944
1945
1946
1947 //----- (0046188A) --------------------------------------------------------
1948 int LOD::File::LoadSubIndices(const char *pContainer)
1949 {
1950 LOD::File *v2; // esi@1
1951 unsigned int uDir; // edi@1
1952 int uDir_dup; // ebx@2
1953 int result; // eax@5
1954 LOD::Directory *v6; // eax@7
1955 LOD::Directory *v7; // eax@7
1956 __int32 v8; // edx@7
1957 FILE *v9; // ST00_4@7
1958 LOD::Directory *pSubIndices_dup; // eax@7
1959
1960 v2 = this;
1961 ResetSubIndices();
1962 uDir = 0;
1963 if ( (signed int)v2->header.uNumIndices <= 0 )
1964 {
1965 LABEL_5:
1966 result = 3;
1967 }
1968 else
1969 {
1970 uDir_dup = 0;
1971 while ( _strcmpi(pContainer, (const char *)&v2->pRoot[uDir_dup]) )
1972 {
1973 ++uDir;
1974 ++uDir_dup;
1975 if ( (signed int)uDir >= (signed int)v2->header.uNumIndices )
1976 goto LABEL_5;
1977 }
1978 strcpy((char *)v2->pContainerName, pContainer);
1979 v6 = v2->pRoot;
1980 v2->uCurrentIndexDir = uDir;
1981 v7 = &v6[uDir];
1982 v8 = v7->uOfsetFromSubindicesStart;
1983 v2->uOffsetToSubIndex = v8;
1984 v9 = v2->pFile;
1985 v2->uNumSubIndices = v7->uNumSubIndices;
1986 fseek(v9, v8, 0);
1987 pSubIndices_dup = (LOD::Directory *)pAllocator->AllocNamedChunk(
1988 v2->pSubIndices,
1989 32 * (v2->uNumSubIndices + 5),
1990 "LOD Index");
1991 v2->pSubIndices = pSubIndices_dup;
1992 if ( pSubIndices_dup )
1993 fread(pSubIndices_dup, 0x20u, v2->uNumSubIndices, v2->pFile);
1994 result = 0;
1995 }
1996 return result;
1997 }
1998
1999 //----- (004617D5) --------------------------------------------------------
2000 bool LOD::File::LoadHeader(const char *pFilename, bool bWriting)
2001 {
2002 LOD::File *this_dup; // esi@1
2003 FILE *pFile_dup; // eax@6
2004 void *pRoot_dup; // eax@7
2005 const char *v6; // [sp-4h] [bp-Ch]@4
2006 FILE *v7; // [sp-4h] [bp-Ch]@7
2007
2008 this_dup = this;
2009 if ( this->isFileOpened )
2010 Close();
2011 if ( bWriting & 1 )
2012 v6 = "rb";
2013 else
2014 v6 = "rb+";
2015 pFile_dup = fopen(pFilename, v6);
2016 this_dup->pFile = pFile_dup;
2017 if ( pFile_dup )
2018 {
2019 strcpy(this_dup->pLODName, pFilename);
2020 fread(&this_dup->header, 0x100u, 1u, this_dup->pFile);
2021 pRoot_dup = pAllocator->AllocNamedChunk(this_dup->pRoot, 0xA0u, "LOD CArray");
2022 this_dup->pRoot = (LOD::Directory *)pRoot_dup;
2023 v7 = this_dup->pFile;
2024 if ( pRoot_dup )
2025 {
2026 fread(pRoot_dup, 0x20u, this_dup->header.uNumIndices, v7);
2027 fseek(this_dup->pFile, 0, 0);
2028 this_dup->isFileOpened = 1;
2029 return false;
2030 }
2031 else
2032 {
2033 fclose(v7);
2034 return true;
2035 }
2036 }
2037 return true;
2038 }
2039
2040
2041 //----- (004617B6) --------------------------------------------------------
2042 void LOD::FileHeader::Reset()
2043 {
2044 this->pSignature[0] = 0;
2045 this->LodVersion[0] = 0;
2046 this->LodDescription[0] = 0;
2047 this->LODSize = 0;
2048 this->dword_0000A8 = 0;
2049 this->uNumIndices = 0;
2050 }
2051
2052 //----- (00461790) --------------------------------------------------------
2053 LOD::File::~File()
2054 {
2055 LOD::File *v1; // esi@1
2056
2057 v1 = this;
2058 if ( this->isFileOpened )
2059 {
2060 fclose(this->pFile);
2061 pAllocator->FreeChunk(v1->pSubIndices);
2062 }
2063 }
2064
2065
2066 //----- (0046175B) --------------------------------------------------------
2067 LOD::File::File():
2068 pRoot(nullptr),
2069 isFileOpened(false)
2070 {
2071 LOD::File *v1; // esi@1
2072
2073 memset(pLODName, 0, 256);
2074 memset(pContainerName, 0, 16);
2075 v1 = this;
2076 v1->pFile = 0;
2077 v1->pSubIndices = 0;
2078 v1->pIOBuffer = 0;
2079 v1->isFileOpened = 0;
2080 v1->uIOBufferSize = 0;
2081 Close();
2082 }
2083
2084
2085 //----- (00461743) --------------------------------------------------------
2086 LOD::Directory *LOD::Directory::Reset()
2087 {
2088 LOD::Directory *result; // eax@1
2089
2090 result = this;
2091 this->pFilename[0] = 0;
2092 this->uOfsetFromSubindicesStart = 0;
2093 this->uDataSize = 0;
2094 this->dword_000018 = 0;
2095 this->uNumSubIndices = 0;
2096 this->word_00001E = 0;
2097 return result;
2098 }
2099
2100
2101 //----- (0046172B) --------------------------------------------------------
2102 LOD::Directory::Directory()
2103 {
2104 memset(pFilename, 0, 16);
2105 this->pFilename[0] = 0;
2106 this->uOfsetFromSubindicesStart = 0;
2107 this->uDataSize = 0;
2108 this->uNumSubIndices = 0;
2109 this->dword_000018 = 0;
2110 this->word_00001E = 0;
2111 }
2112
2113 //----- (0046165E) --------------------------------------------------------
2114 int LOD::File::CalcIndexFast(int startIndex, int maxIndex, const char *pContainerName)
2115 {
2116 int v4; // esi@1
2117 int v5; // ebx@2
2118 int result; // eax@2
2119 int v7; // edi@10
2120 int v8; // esi@11
2121 int v9; // esi@17
2122 LOD::File *v10; // [sp+Ch] [bp-4h]@1
2123
2124 v4 = startIndex;
2125 v10 = this;
2126 while ( 1 ) // binary search in LOD indices
2127 {
2128 while ( 1 )
2129 {
2130 v5 = maxIndex - v4;
2131 result = _strcmpi((const char *)pContainerName, (const char *)(&v10->pSubIndices[(maxIndex - v4) / 2] + v4));
2132 if ( !result )
2133 _6A0CA4_lod_binary_search = (maxIndex - v4) / 2 + v4;
2134 if ( v4 == maxIndex )
2135 goto LABEL_14;
2136 if ( result < 0 )
2137 break;
2138 if ( v5 <= 4 )
2139 {
2140 v7 = v4;
2141 if ( v4 < maxIndex )
2142 {
2143 v9 = v4;
2144 do
2145 {
2146 result = _strcmpi((const char *)pContainerName, (const char *)&v10->pSubIndices[v9]);
2147 if ( !result )
2148 goto LABEL_21;
2149 ++v7;
2150 ++v9;
2151 }
2152 while ( v7 < maxIndex );
2153 }
2154 LABEL_14:
2155 _6A0CA4_lod_binary_search = -1;
2156 return result;
2157 }
2158 v4 += (maxIndex - v4) / 2;
2159 }
2160 if ( v5 <= 4 )
2161 break;
2162 maxIndex = (maxIndex - v4) / 2 + v4;
2163 }
2164 v7 = v4;
2165 if ( v4 >= maxIndex )
2166 goto LABEL_14;
2167 v8 = v4;
2168 while ( 1 )
2169 {
2170 result = _strcmpi((const char *)pContainerName, (const char *)&v10->pSubIndices[v8]);
2171 if ( !result )
2172 break;
2173 ++v7;
2174 ++v8;
2175 if ( v7 >= maxIndex )
2176 goto LABEL_14;
2177 }
2178 LABEL_21:
2179 _6A0CA4_lod_binary_search = v7;
2180 return result;
2181 }
2182 // 6A0CA4: using guessed type int _6A0CA4_lod_binary_search;
2183
2184
2185 //----- (0046161C) --------------------------------------------------------
2186 bool LOD::File::DoesContainerExist(const char *pContainer)
2187 {
2188 LOD::File *this_dup; // esi@1
2189 int i; // ebx@1
2190 signed int i_dup; // edi@1
2191 bool result; // eax@4
2192
2193 this_dup = this;
2194 i = 0;
2195 i_dup = 0;
2196 if ( (signed int)this->uNumSubIndices <= 0 )
2197 {
2198 LABEL_4:
2199 result = 0;
2200 }
2201 else
2202 {
2203 while ( _strcmpi((const char *)pContainer, (const char *)&this_dup->pSubIndices[i]) )
2204 {
2205 ++i_dup;
2206 ++i;
2207 if ( i_dup >= (signed int)this_dup->uNumSubIndices )
2208 goto LABEL_4;
2209 }
2210 result = 1;
2211 }
2212 return result;
2213 }
2214
2215
2216 //----- (00461397) --------------------------------------------------------
2217 int LODFile_Sprites::_461397()
2218 {
2219 int result; // eax@1
2220 int *pfield_ECA0; // edi@1
2221 int v3; // esi@1
2222 int v4; // ecx@3
2223
2224 result = this->uNumLoadedSprites;
2225 pfield_ECA0 = &this->field_ECA0;
2226 v3 = this->field_ECA0;
2227 this->field_ECA8 = result;
2228 if ( result < v3 )
2229 this->field_ECA8 = v3;
2230 v4 = this->field_ECA4;
2231 if ( v3 < v4 )
2232 *pfield_ECA0 = v4;
2233 return result;
2234 }
2235
2236 //----- (00461580) --------------------------------------------------------
2237 FILE *LOD::File::FindContainer(const char *pContainerName, bool bLinearSearch)
2238 {
2239 unsigned int v4; // eax@4
2240 if (!isFileOpened)
2241 return 0;
2242
2243
2244 if (bLinearSearch)
2245 {
2246 for (uint i = 0; i < uNumSubIndices; ++i)
2247 if (!strcmpi(pContainerName, pSubIndices[i].pFilename))
2248 {
2249 v4 = pSubIndices[i].uOfsetFromSubindicesStart;
2250 fseek(pFile, uOffsetToSubIndex + v4, SEEK_SET);
2251 return pFile;
2252 }
2253
2254 return nullptr;
2255 }
2256 else
2257 {
2258 CalcIndexFast(0, uNumSubIndices, pContainerName);
2259 if ( _6A0CA4_lod_binary_search < 0 )
2260 return 0;
2261 v4 = pSubIndices[_6A0CA4_lod_binary_search].uOfsetFromSubindicesStart;
2262 fseek(pFile, uOffsetToSubIndex + v4, SEEK_SET);
2263 return pFile;
2264 }
2265 }
2266
2267 //----- (0041097D) --------------------------------------------------------
2268 void LODFile_IconsBitmaps::SetupPalettes(unsigned int uTargetRBits, unsigned int uTargetGBits, unsigned int uTargetBBits)
2269 {
2270 int v4; // edx@1
2271 LODFile_IconsBitmaps *v5; // esi@1
2272 int v6; // ecx@1
2273 unsigned __int8 v7; // zf@4
2274 unsigned __int8 v8; // sf@4
2275 unsigned __int16 **v9; // edi@5
2276 FILE *v10; // eax@7
2277 FILE *v11; // ebx@7
2278 signed int v12; // ebx@8
2279 int v13; // eax@9
2280 int v14; // edx@9
2281 int v16; // [sp+4Ch] [bp-8h]@4
2282 FILE *File; // [sp+50h] [bp-4h]@7
2283
2284 v4 = uTargetGBits;
2285 v5 = this;
2286 v6 = uTargetBBits;
2287 if ( v5->uTextureRedBits != uTargetRBits
2288 || v5->uTextureGreenBits != uTargetGBits
2289 || v5->uTextureBlueBits != uTargetBBits )
2290 {
2291 v16 = 0;
2292 v7 = v5->uNumLoadedFiles == 0;
2293 v8 = (v5->uNumLoadedFiles & 0x80000000u) != 0;
2294 v5->uTextureRedBits = uTargetRBits;
2295 v5->uTextureGreenBits = v4;
2296 v5->uTextureBlueBits = v6;
2297 if ( !(v8 | v7) )
2298 {
2299 v9 = &v5->pTextures[0].pPalette16;
2300 do
2301 {
2302 Texture DstBuf; // [sp+4h] [bp-50h]@6
2303 //Texture::Texture(&DstBuf);
2304
2305 if ( *v9 )
2306 {
2307 v10 = FindContainer((const char *)v9 - 64, 0);
2308 v11 = v10;
2309 File = v10;
2310 if ( v10 )
2311 {
2312 fread(&DstBuf, 1u, 0x30u, v10);
2313 fseek(v11, DstBuf.uTextureSize, 1);
2314 v12 = 0;
2315 do
2316 {
2317 fread((char *)&uTargetRBits + 3, 1u, 1u, File);
2318 fread((char *)&uTargetBBits + 3, 1u, 1u, File);
2319 v13 = fread((char *)&uTargetGBits + 3, 1u, 1u, File);
2320 LOWORD(v13) = (unsigned __int8)(BYTE3(uTargetRBits) >> (8 - LOBYTE(v5->uTextureRedBits)));
2321 (*v9)[v12] = v13 << (LOBYTE(v5->uTextureGreenBits) + LOBYTE(v5->uTextureBlueBits));
2322 LOWORD(v14) = (unsigned __int8)(BYTE3(uTargetBBits) >> (8 - LOBYTE(v5->uTextureGreenBits)));
2323 (*v9)[v12] |= v14 << v5->uTextureBlueBits;
2324 (*v9)[v12] |= BYTE3(uTargetGBits) >> (8 - LOBYTE(v5->uTextureBlueBits));
2325 ++v12;
2326 }
2327 while ( v12 < 256 );
2328 }
2329 }
2330 ++v16;
2331 v9 += 18;
2332 }
2333 while ( v16 < (signed int)v5->uNumLoadedFiles );
2334 }
2335 }
2336 }
2337
2338
2339
2340 //----- (0041088B) --------------------------------------------------------
2341 void *LOD::File::LoadRaw(const char *pContainer, int a3)
2342 {
2343 LOD::File *v3; // esi@1
2344 FILE *v4; // eax@1
2345 FILE *v5; // esi@1
2346 void *v6; // eax@5
2347 void *v7; // ebx@7
2348 void *v8; // edi@7
2349 void *v9; // eax@9
2350 Texture DstBuf; // [sp+Ch] [bp-4Ch]@1
2351 FILE *File; // [sp+54h] [bp-4h]@1
2352 unsigned int Argsa; // [sp+60h] [bp+8h]@3
2353
2354 v3 = this;
2355 v4 = FindContainer(pContainer, 0);
2356 v5 = v4;
2357 File = v4;
2358 if ( !v4 )
2359 Abortf("Unable to load %s", pContainer);
2360 fread(&DstBuf, 1u, 0x30u, v4);
2361 Argsa = DstBuf.uTextureSize;
2362 if ( DstBuf.uDecompressedSize )
2363 {
2364 if ( a3 )
2365 v6 = malloc(DstBuf.uDecompressedSize);
2366 else
2367 v6 = pAllocator->AllocNamedChunk(0, DstBuf.uDecompressedSize, DstBuf.pName);
2368 v7 = v6;
2369 v8 = pAllocator->AllocNamedChunk(0, DstBuf.uTextureSize, DstBuf.pName);
2370 fread(v8, 1u, Argsa, File);
2371 zlib::MemUnzip(v7, &DstBuf.uDecompressedSize, v8, DstBuf.uTextureSize);
2372 DstBuf.uTextureSize = DstBuf.uDecompressedSize;
2373 pAllocator->FreeChunk(v8);
2374 }
2375 else
2376 {
2377 if ( a3 )
2378 v9 = malloc(DstBuf.uTextureSize);
2379 else
2380 v9 = pAllocator->AllocNamedChunk(0, DstBuf.uTextureSize, DstBuf.pName);
2381 v7 = v9;
2382 fread(v9, 1u, Argsa, v5);
2383 }
2384 return v7;
2385 }
2386
2387
2388
2389 //----- (00410522) --------------------------------------------------------
2390 int LODFile_IconsBitmaps::_410522(Texture *pDst, const char *pContainer, unsigned int uTextureType)
2391 {
2392 LODFile_IconsBitmaps *v4; // edi@1
2393 Texture *v5; // esi@5
2394 unsigned int v6; // eax@5
2395 void *v7; // eax@6
2396 unsigned int v8; // ST28_4@6
2397 void *v9; // ST2C_4@6
2398 unsigned __int8 *v10; // eax@7
2399 FILE *v11; // ST28_4@7
2400 void *v12; // eax@9
2401 FILE *v13; // ST28_4@9
2402 signed int v14; // eax@12
2403 int v15; // ecx@12
2404 int v16; // ecx@12
2405 int v17; // eax@12
2406 signed int v18; // ebx@14
2407 int v19; // eax@15
2408 int v20; // edx@15
2409 signed int v21; // ecx@18
2410 signed int v22; // ecx@23
2411 char Args[100]; // [sp+4h] [bp-68h]@3
2412 FILE *File; // [sp+68h] [bp-4h]@1
2413
2414 v4 = this;
2415 File = FindContainer(pContainer, 0);
2416 if ( !File )
2417 {
2418 File = FindContainer("pending", 0);
2419 if ( !File )
2420 {
2421 sprintf(Args, "Can't find %s!", pContainer);
2422 Abortf(Args);
2423 }
2424 }
2425 v5 = pDst;
2426 fread(pDst, 1u, 0x30u, File);
2427 strcpy(v5->pName, pContainer);
2428 pDst = (Texture *)v5->uTextureSize;
2429 v6 = v5->uDecompressedSize;
2430 v5->pLevelOfDetail0 = 0;
2431 if ( v6 )
2432 {
2433 v7 = operator new(v6);
2434 v8 = v5->uTextureSize;
2435 v5->pLevelOfDetail0 = (unsigned __int8 *)v7;
2436 pContainer = (const char *)operator new(v8);
2437 fread((void *)pContainer, 1u, (size_t)pDst, File);
2438 zlib::MemUnzip(v5->pLevelOfDetail0, &v5->uDecompressedSize, pContainer, v5->uTextureSize);
2439 v9 = (void *)pContainer;
2440 v5->uTextureSize = v5->uDecompressedSize;
2441 free(v9);
2442 }
2443 else
2444 {
2445 v10 = (unsigned __int8 *)operator new(0);
2446 v11 = File;
2447 v5->pLevelOfDetail0 = v10;
2448 fread(v10, 1u, (size_t)pDst, v11);
2449 }
2450 v5->pPalette24 = 0;
2451 if ( uTextureType == 1 )
2452 {
2453 v12 = operator new(0x300u);
2454 v13 = File;
2455 v5->pPalette24 = (unsigned __int8 *)v12;
2456 fread(v12, 1u, 0x300u, v13);
2457 LABEL_10:
2458 v5->pPalette16 = 0;
2459 goto LABEL_11;
2460 }
2461 if ( uTextureType != 2 )
2462 goto LABEL_10;
2463 v18 = 0;
2464 v5->pPalette16 = 0;
2465 v5->pPalette16 = (unsigned __int16 *)operator new(0x400u);
2466 do
2467 {
2468 fread((char *)&pContainer + 3, 1u, 1u, File);
2469 fread((char *)&uTextureType + 3, 1u, 1u, File);
2470 v19 = fread((char *)&pDst + 3, 1u, 1u, File);
2471 LOWORD(v19) = (unsigned __int8)(BYTE3(pContainer) >> (8 - LOBYTE(v4->uTextureRedBits)));
2472 v5->pPalette16[v18] = v19 << (LOBYTE(v4->uTextureBlueBits) + LOBYTE(v4->uTextureGreenBits));
2473 LOWORD(v20) = (unsigned __int8)(BYTE3(uTextureType) >> (8 - LOBYTE(v4->uTextureGreenBits)));
2474 v5->pPalette16[v18] += v20 << v4->uTextureBlueBits;
2475 v5->pPalette16[v18] += (unsigned __int8)(BYTE3(pDst) >> (8 - LOBYTE(v4->uTextureBlueBits)));
2476 ++v18;
2477 }
2478 while ( v18 < 256 );
2479 LABEL_11:
2480 if ( v5->pBits & 2 )
2481 {
2482 v14 = v5->uSizeOfMaxLevelOfDetail;
2483 v15 = (int)&v5->pLevelOfDetail0[v14];
2484 v5->pLevelOfDetail1 = (unsigned __int8 *)v15;
2485 v16 = (v14 >> 2) + v15;
2486 v5->pLevelOfDetail2 = (unsigned __int8 *)v16;
2487 v17 = v16 + (v14 >> 4);
2488 }
2489 else
2490 {
2491 v17 = 0;
2492 v5->pLevelOfDetail2 = 0;
2493 v5->pLevelOfDetail1 = 0;
2494 }
2495 v5->pLevelOfDetail3 = (unsigned __int8 *)v17;
2496 v21 = 1;
2497 while ( 1 << v21 != v5->uTextureWidth )
2498 {
2499 ++v21;
2500 if ( v21 >= 15 )
2501 goto LABEL_23;
2502 }
2503 v5->uWidthLn2 = v21;
2504 LABEL_23:
2505 v22 = 1;
2506 while ( 1 << v22 != v5->uTextureHeight )
2507 {
2508 ++v22;
2509 if ( v22 >= 15 )
2510 goto LABEL_28;
2511 }
2512 v5->uHeightLn2 = v22;
2513 LABEL_28:
2514 switch ( v5->uWidthLn2 )
2515 {
2516 case 2:
2517 v5->uWidthMinus1 = 3;
2518 break;
2519 case 3:
2520 v5->uWidthMinus1 = 7;
2521 break;
2522 case 4:
2523 v5->uWidthMinus1 = 15;
2524 break;
2525 case 5:
2526 v5->uWidthMinus1 = 31;
2527 break;
2528 case 6:
2529 v5->uWidthMinus1 = 63;
2530 break;
2531 case 7:
2532 v5->uWidthMinus1 = 127;
2533 break;
2534 case 8:
2535 v5->uWidthMinus1 = 255;
2536 break;
2537 case 9:
2538 v5->uWidthMinus1 = 511;
2539 break;
2540 case 10:
2541 v5->uWidthMinus1 = 1023;
2542 break;
2543 case 11:
2544 v5->uWidthMinus1 = 2047;
2545 break;
2546 case 12:
2547 v5->uWidthMinus1 = 4095;
2548 break;
2549 default:
2550 break;
2551 }
2552 switch ( v5->uHeightLn2 )
2553 {
2554 case 2:
2555 v5->uHeightMinus1 = 3;
2556 break;
2557 case 3:
2558 v5->uHeightMinus1 = 7;
2559 break;
2560 case 4:
2561 v5->uHeightMinus1 = 15;
2562 break;
2563 case 5:
2564 v5->uHeightMinus1 = 31;
2565 break;
2566 case 6:
2567 v5->uHeightMinus1 = 63;
2568 break;
2569 case 7:
2570 v5->uHeightMinus1 = 127;
2571 break;
2572 case 8:
2573 v5->uHeightMinus1 = 255;
2574 break;
2575 case 9:
2576 v5->uHeightMinus1 = 511;
2577 break;
2578 case 10:
2579 v5->uHeightMinus1 = 1023;
2580 break;
2581 case 11:
2582 v5->uHeightMinus1 = 2047;
2583 break;
2584 case 12:
2585 v5->uHeightMinus1 = 4095;
2586 break;
2587 default:
2588 return 1;
2589 }
2590 return 1;
2591 }
2592
2593
2594 //----- (00410423) --------------------------------------------------------
2595 void LODFile_IconsBitmaps::_410423_move_textures_to_device()
2596 {
2597 LODFile_IconsBitmaps *v1; // esi@1
2598 unsigned int v2; // edi@1
2599 char *v3; // ebx@2
2600 size_t v4; // eax@9
2601 char *v5; // ST1C_4@9
2602 void *v6; // eax@12
2603 signed int v7; // esi@13
2604
2605 v1 = this;
2606 v2 = this->uNumLoadedFiles - 1;
2607 if ( (v2 & 0x80000000u) == 0 )
2608 {
2609 v3 = &this->pTextures[v2].pName[2];
2610 do
2611 {
2612 if ( v1->ptr_011BB4[v2] )
2613 {
2614 if ( *(v3 - 2) != 'w' || *(v3 - 1) != 't' || *v3 != 'r' || v3[1] != 'd' || v3[2] != 'r' )
2615 {
2616 pRenderer->LoadTexture(
2617 v3 - 2,
2618 *((short *)v3 + 17),
2619 (IDirectDrawSurface4 **)&v1->pHardwareSurfaces[v2],
2620 &v1->pHardwareTextures[v2]);
2621 }
2622 else
2623 {
2624 v4 = strlen(v3 - 2);
2625 v5 = (char *)operator new(v4 + 2);
2626 *v5 = 'h';
2627 strcpy(v5 + 1, v3 - 2);
2628 pRenderer->LoadTexture(
2629 v5,
2630 *((short *)v3 + 17),
2631 (IDirectDrawSurface4 **)&v1->pHardwareSurfaces[v2],
2632 &v1->pHardwareTextures[v2]);
2633 free(v5);
2634 }
2635 }
2636 --v2;
2637 v3 -= 72;
2638 }
2639 while ( (v2 & 0x80000000u) == 0 );
2640 }
2641 v6 = v1->ptr_011BB4;
2642 if ( v6 )
2643 {
2644 v7 = v1->uNumLoadedFiles;
2645 if ( v7 > 1 )
2646 memset(v6, 0, v7 - 1);
2647 }
2648 }
2649
2650
2651 //----- (004103BB) --------------------------------------------------------
2652 void LODFile_IconsBitmaps::ReleaseHardwareTextures()
2653 {
2654 LODFile_IconsBitmaps *v1; // esi@1
2655 unsigned int v2; // edi@1
2656 struct IDirect3DTexture2 **v3; // eax@2
2657 struct IDirect3DTexture2 *v4; // eax@3
2658 struct IDirectDrawSurface **v5; // eax@5
2659 struct IDirectDrawSurface *v6; // eax@6
2660
2661 v1 = this;
2662 v2 = this->uNumLoadedFiles;
2663 while ( 1 )
2664 {
2665 --v2;
2666 if ( (v2 & 0x80000000u) != 0 )
2667 break;
2668 v3 = v1->pHardwareTextures;
2669 if ( v3 )
2670 {
2671 v4 = v3[v2];
2672 if ( v4 )
2673 {
2674 v4->Release();
2675 v1->pHardwareTextures[v2] = 0;
2676 v1->ptr_011BB4[v2] = 1;
2677 }
2678 }
2679 v5 = v1->pHardwareSurfaces;
2680 if ( v5 )
2681 {
2682 v6 = v5[v2];
2683 if ( v6 )
2684 {
2685 v6->Release();
2686 v1->pHardwareSurfaces[v2] = 0;
2687 v1->ptr_011BB4[v2] = 1;
2688 }
2689 }
2690 }
2691 }
2692
2693
2694 //----- (0041033D) --------------------------------------------------------
2695 void LODFile_IconsBitmaps::ReleaseLostHardwareTextures()
2696 {
2697 LODFile_IconsBitmaps *v1; // edi@1
2698 unsigned int i; // ebx@1
2699 struct IDirectDrawSurface **pHardwareSurfaces; // eax@2
2700 int v4; // esi@3
2701 struct IDirectDrawSurface *pSurface; // eax@3
2702 struct IDirect3DTexture2 **v6; // eax@5
2703 struct IDirect3DTexture2 *v7; // eax@6
2704
2705 v1 = this;
2706 for ( i = this->uNumLoadedFiles - 1; (i & 0x80000000u) == 0; --i )
2707 {
2708 pHardwareSurfaces = v1->pHardwareSurfaces;
2709 if ( pHardwareSurfaces )
2710 {
2711 v4 = i;
2712 pSurface = pHardwareSurfaces[i];
2713 if ( pSurface )
2714 {
2715 if ( pSurface->IsLost() == DDERR_SURFACELOST )
2716 {
2717 v6 = v1->pHardwareTextures;
2718 if ( v6 )
2719 {
2720 v7 = v6[v4];
2721 if ( v7 )
2722 {
2723 v7->Release();
2724 v1->pHardwareTextures[v4] = 0;
2725 }
2726 }
2727 v1->pHardwareSurfaces[v4]->Release();
2728 v1->pHardwareSurfaces[v4] = 0;
2729 v1->ptr_011BB4[i] = 1;
2730 }
2731 }
2732 }
2733 }
2734 }
2735
2736 //----- (004101B1) --------------------------------------------------------
2737 int LODFile_IconsBitmaps::ReloadTexture(Texture *pDst, const char *pContainer, int mode)
2738 {
2739 LODFile_IconsBitmaps *v4; // edi@1
2740 FILE *v5; // eax@1
2741 Texture *v6; // esi@2
2742 unsigned int v7; // ebx@6
2743 unsigned int v8; // ecx@6
2744 signed int result; // eax@7
2745 size_t *v10; // ebx@8
2746 signed int v11; // ebx@12
2747 int v12; // eax@13
2748 int v13; // edx@13
2749 FILE *File; // [sp+Ch] [bp-8h]@1
2750 unsigned __int8 v15; // [sp+11h] [bp-3h]@13
2751 unsigned __int8 v16; // [sp+12h] [bp-2h]@13
2752 unsigned __int8 DstBuf; // [sp+13h] [bp-1h]@13
2753 void *DstBufa; // [sp+1Ch] [bp+8h]@10
2754 void *Sourcea; // [sp+20h] [bp+Ch]@10
2755 unsigned int Counta; // [sp+24h] [bp+10h]@6
2756
2757 v4 = this;
2758 v5 = FindContainer(pContainer, 0);
2759 File = v5;
2760 if ( v5
2761 && (v6 = pDst, pDst->pLevelOfDetail0)
2762 && mode == 2
2763 && pDst->pPalette16
2764 && !pDst->pPalette24
2765 && (v7 = pDst->uTextureSize,
2766 fread(pDst, 1u, 0x30u, v5),
2767 strcpy(pDst->pName, pContainer),
2768 v8 = pDst->uTextureSize,
2769 Counta = pDst->uTextureSize,
2770 (signed int)v8 <= (signed int)v7) )
2771 {
2772 v10 = &pDst->uDecompressedSize;
2773 if ( !pDst->uDecompressedSize || v4->dword_011BA4 )
2774 {
2775 fread(pDst->pLevelOfDetail0, 1u, v8, File);
2776 }
2777 else
2778 {
2779 Sourcea = malloc(pDst->uDecompressedSize);
2780 DstBufa = malloc(pDst->uTextureSize);
2781 fread(DstBufa, 1u, Counta, File);
2782 zlib::MemUnzip(Sourcea, &v6->uDecompressedSize, DstBufa, v6->uTextureSize);
2783 v6->uTextureSize = *v10;
2784 free(DstBufa);
2785 memcpy(v6->pLevelOfDetail0, Sourcea, *v10);
2786 free(Sourcea);
2787 }
2788 v11 = 0;
2789 do
2790 {
2791 fread(&DstBuf, 1u, 1u, File);
2792 fread(&v16, 1u, 1u, File);
2793 v12 = fread(&v15, 1u, 1u, File);
2794 LOWORD(v12) = (unsigned __int8)(DstBuf >> (8 - LOBYTE(v4->uTextureRedBits)));
2795 v6->pPalette16[v11] = v12 << (LOBYTE(v4->uTextureBlueBits) + LOBYTE(v4->uTextureGreenBits));
2796 LOWORD(v13) = (unsigned __int8)(v16 >> (8 - LOBYTE(v4->uTextureGreenBits)));
2797 v6->pPalette16[v11] += v13 << v4->uTextureBlueBits;
2798 v6->pPalette16[v11] += (unsigned __int8)(v15 >> (8 - LOBYTE(v4->uTextureBlueBits)));
2799 ++v11;
2800 }
2801 while ( v11 < 256 );
2802 result = 1;
2803 }
2804 else
2805 {
2806 result = -1;
2807 }
2808 return result;
2809 }
2810
2811
2812 //----- (0040FC08) --------------------------------------------------------
2813 int LODFile_IconsBitmaps::LoadTextureFromLOD(Texture *pOutTex, const char *pContainer, enum TEXTURE_TYPE eTextureType)
2814 {
2815 Texture *v8; // esi@3
2816 size_t v11; // eax@14
2817 enum TEXTURE_TYPE v12; // eax@14
2818 signed int v13; // esi@14
2819 unsigned int v14; // eax@21
2820 unsigned int v15; // ecx@25
2821 unsigned int *v16; // ebx@25
2822 void *v17; // eax@27
2823 unsigned int v18; // ST28_4@27
2824 void *v19; // ST3C_4@27
2825 Allocator *v20; // ebx@29
2826 void *v21; // eax@29
2827 size_t v22; // ST2C_4@29
2828 const void *v23; // ecx@29
2829 unsigned __int16 v24; // ax@29
2830 unsigned __int16 v25; // cx@29
2831 __int16 v26; // dx@29
2832 unsigned int v27; // ecx@29
2833 Texture *v28; // eax@29
2834 unsigned int v29; // ST28_4@30
2835 void *v30; // eax@30
2836 unsigned int v31; // ST2C_4@30
2837 void *v32; // eax@32
2838 void *v33; // eax@34
2839 signed int v34; // eax@37
2840 unsigned __int8 *v35; // ecx@37
2841 unsigned __int8 *v36; // ecx@37
2842 unsigned __int8 *v37; // eax@37
2843 signed int v38; // ebx@39
2844 int v39; // eax@40
2845 int v40; // edx@40
2846 signed int v41; // ecx@43
2847 signed int v42; // ecx@48
2848
2849 //v4 = pContainer;
2850 //v5 = this;
2851 //v6 = FindContainer(pContainer, 0);
2852 //File = v6;
2853 auto pFile = FindContainer(pContainer, false);
2854 if (!pFile)
2855 return -1;
2856 v8 = pOutTex;
2857 fread(pOutTex, 1u, 0x30u, pFile);
2858 strcpy(v8->pName, pContainer);
2859 if (pRenderer->pRenderD3D && v8->pBits & 2 && dword_011BA8)
2860 {
2861 if (!pHardwareSurfaces || !pHardwareTextures)
2862 {
2863 pHardwareSurfaces = new IDirectDrawSurface *[1000];
2864 memset(pHardwareSurfaces, 0, 1000 * sizeof(IDirectDrawSurface4 *));
2865
2866 pHardwareTextures = new IDirect3DTexture2 *[1000];
2867 memset(pHardwareTextures, 0, 1000 * sizeof(IDirect3DTexture2 *));
2868
2869 ptr_011BB4 = new char[1000];
2870 memset(ptr_011BB4, 0, 1000);
2871 }
2872 if (strcmp(pContainer, "wtrdr"))//*v4 != 'w' || v4[1] != 't' || v4[2] != 'r' || v4[3] != 'd' || v4[4] != 'r' )
2873 {
2874 if (strcmp(pContainer, "WtrTyl"))//if ( *v4 != 'W' || v4[1] != 't' || v4[2] != 'r' || v4[3] != 'T' || v4[4] != 'y' || v4[5] != 'l' )
2875 {
2876 v14 = uNumLoadedFiles;
2877 }
2878 else
2879 {
2880 pRenderer->field_1036AC_bitmapid = uNumLoadedFiles;
2881 v14 = uNumLoadedFiles;
2882 }
2883 v13 = pRenderer->LoadTexture(
2884 pContainer,
2885 v8->palette_id1,
2886 (IDirectDrawSurface4 **)&pHardwareSurfaces[v14],
2887 &pHardwareTextures[v14]);
2888 }
2889 else
2890 {
2891 v11 = strlen(pContainer);
2892 v12 = (enum TEXTURE_TYPE)(int)operator new(v11 + 2);
2893 eTextureType = v12;
2894 *(char *)v12 = 104;
2895 strcpy((char *)(v12 + 1), pContainer);
2896 v13 = pRenderer->LoadTexture(
2897 (const char *)eTextureType,
2898 v8->palette_id1,
2899 (IDirectDrawSurface4 **)&pHardwareSurfaces[uNumLoadedFiles],
2900 &pHardwareTextures[uNumLoadedFiles]);
2901 free((void *)eTextureType);
2902 }
2903 return v13;
2904 }
2905 v15 = v8->uTextureSize;
2906 v16 = &v8->uDecompressedSize;
2907 pOutTex = (Texture *)v8->uTextureSize;
2908 if ( !v8->uDecompressedSize || dword_011BA4 )
2909 {
2910 v20 = pAllocator;
2911 v32 = pAllocator->AllocNamedChunk(v8->pLevelOfDetail0, v15, v8->pName);
2912 v8->pLevelOfDetail0 = (unsigned __int8 *)v32;
2913 fread(v32, 1u, (size_t)pOutTex, pFile);
2914 }
2915 else
2916 {
2917 v17 = malloc(v8->uDecompressedSize);
2918 v18 = v8->uTextureSize;
2919 pContainer = (const char *)v17;
2920 v19 = malloc(v18);
2921 fread(v19, 1u, (size_t)pOutTex, pFile);
2922 zlib::MemUnzip((void *)pContainer, &v8->uDecompressedSize, v19, v8->uTextureSize);
2923 v8->uTextureSize = *v16;
2924 free(v19);
2925 if ( bUseLoResSprites && v8->pBits & 2 )
2926 {
2927 v20 = pAllocator;
2928 pOutTex = (Texture *)(((signed int)v8->uSizeOfMaxLevelOfDetail >> 2)
2929 + ((signed int)v8->uSizeOfMaxLevelOfDetail >> 4)
2930 + ((signed int)v8->uSizeOfMaxLevelOfDetail >> 6));
2931 v21 = pAllocator->AllocNamedChunk(v8->pLevelOfDetail0, (unsigned int)pOutTex, v8->pName);
2932 v22 = (size_t)pOutTex;
2933 v23 = &pContainer[v8->uTextureWidth * v8->uTextureHeight];
2934 v8->pLevelOfDetail0 = (unsigned __int8 *)v21;
2935 memcpy(v21, v23, v22);
2936 v8->uTextureWidth = (signed __int16)v8->uTextureWidth >> 1;
2937 v24 = v8->uTextureWidth;
2938 v8->uTextureHeight = (signed __int16)v8->uTextureHeight >> 1;
2939 v25 = v8->uTextureHeight;
2940 --v8->uWidthLn2;
2941 --v8->uHeightLn2;
2942 v8->uWidthMinus1 = v24 - 1;
2943 v26 = v25 - 1;
2944 v27 = (signed __int16)v24 * (signed __int16)v25;
2945 v28 = pOutTex;
2946 v8->uHeightMinus1 = v26;
2947 v8->uSizeOfMaxLevelOfDetail = v27;
2948 v8->uTextureSize = (unsigned int)v28;
2949 }
2950 else
2951 {
2952 v29 = *v16;
2953 v20 = pAllocator;
2954 v30 = pAllocator->AllocNamedChunk(v8->pLevelOfDetail0, v29, v8->pName);
2955 v31 = v8->uDecompressedSize;
2956 v8->pLevelOfDetail0 = (unsigned __int8 *)v30;
2957 memcpy(v30, pContainer, v31);
2958 }
2959 free((void *)pContainer);
2960 }
2961 pAllocator->FreeChunk(v8->pPalette16);
2962 pAllocator->FreeChunk(v8->pPalette24);
2963 if ( eTextureType == TEXTURE_24BIT_PALETTE )
2964 {
2965 v33 = pAllocator->AllocNamedChunk(v8->pPalette24, 0x300u, v8->pName);
2966 v8->pPalette24 = (unsigned __int8 *)v33;
2967 fread(v33, 1u, 0x300u, pFile);
2968 }
2969 else
2970 {
2971 v8->pPalette24 = 0;
2972 if ( eTextureType == TEXTURE_16BIT_PALETTE )
2973 {
2974 v8->pPalette16 = (unsigned __int16 *)pAllocator->AllocNamedChunk(v8->pPalette16, 0x200u, v8->pName);
2975 v38 = 0;
2976 do
2977 {
2978 fread((char *)&eTextureType + 3, 1u, 1u, pFile);
2979 fread((char *)&pContainer + 3, 1u, 1u, pFile);
2980 v39 = fread((char *)&pOutTex + 3, 1u, 1u, pFile);
2981 LOWORD(v39) = (unsigned __int8)(BYTE3(eTextureType) >> (8 - LOBYTE(uTextureRedBits)));
2982 v8->pPalette16[v38] = v39 << (LOBYTE(uTextureBlueBits) + LOBYTE(uTextureGreenBits));
2983 LOWORD(v40) = (unsigned __int8)(BYTE3(pContainer) >> (8 - LOBYTE(uTextureGreenBits)));
2984 v8->pPalette16[v38] += v40 << uTextureBlueBits;
2985 v8->pPalette16[v38] += (unsigned __int8)(BYTE3(pOutTex) >> (8 - LOBYTE(uTextureBlueBits)));
2986 ++v38;
2987 }
2988 while ( v38 < 256 );
2989 goto LABEL_36;
2990 }
2991 }
2992 v8->pPalette16 = 0;
2993 LABEL_36:
2994 if ( v8->pBits & 2 )
2995 {
2996 v34 = v8->uSizeOfMaxLevelOfDetail;
2997 v35 = &v8->pLevelOfDetail0[v34];
2998 v8->pLevelOfDetail1 = v35;
2999 v36 = &v35[v34 >> 2];
3000 v8->pLevelOfDetail2 = v36;
3001 v37 = &v36[v34 >> 4];
3002 }
3003 else
3004 {
3005 v37 = 0;
3006 v8->pLevelOfDetail2 = 0;
3007 v8->pLevelOfDetail1 = 0;
3008 }
3009 v8->pLevelOfDetail3 = v37;
3010 v41 = 1;
3011 while ( 1 << v41 != v8->uTextureWidth )
3012 {
3013 ++v41;
3014 if ( v41 >= 15 )
3015 goto LABEL_48;
3016 }
3017 v8->uWidthLn2 = v41;
3018 LABEL_48:
3019 v42 = 1;
3020 while ( 1 << v42 != v8->uTextureHeight )
3021 {
3022 ++v42;
3023 if ( v42 >= 15 )
3024 goto LABEL_53;
3025 }
3026 v8->uHeightLn2 = v42;
3027 LABEL_53:
3028 switch ( v8->uWidthLn2 )
3029 {
3030 case 2:
3031 v8->uWidthMinus1 = 3;
3032 break;
3033 case 3:
3034 v8->uWidthMinus1 = 7;
3035 break;
3036 case 4:
3037 v8->uWidthMinus1 = 15;
3038 break;
3039 case 5:
3040 v8->uWidthMinus1 = 31;
3041 break;
3042 case 6:
3043 v8->uWidthMinus1 = 63;
3044 break;
3045 case 7:
3046 v8->uWidthMinus1 = 127;
3047 break;
3048 case 8:
3049 v8->uWidthMinus1 = 255;
3050 break;
3051 case 9:
3052 v8->uWidthMinus1 = 511;
3053 break;
3054 case 10:
3055 v8->uWidthMinus1 = 1023;
3056 break;
3057 case 11:
3058 v8->uWidthMinus1 = 2047;
3059 break;
3060 case 12:
3061 v8->uWidthMinus1 = 4095;
3062 break;
3063 default:
3064 break;
3065 }
3066 switch ( v8->uHeightLn2 )
3067 {
3068 case 2:
3069 v8->uHeightMinus1 = 3;
3070 break;
3071 case 3:
3072 v8->uHeightMinus1 = 7;
3073 break;
3074 case 4:
3075 v8->uHeightMinus1 = 15;
3076 break;
3077 case 5:
3078 v8->uHeightMinus1 = 31;
3079 break;
3080 case 6:
3081 v8->uHeightMinus1 = 63;
3082 break;
3083 case 7:
3084 v8->uHeightMinus1 = 127;
3085 break;
3086 case 8:
3087 v8->uHeightMinus1 = 255;
3088 break;
3089 case 9:
3090 v8->uHeightMinus1 = 511;
3091 break;
3092 case 10:
3093 v8->uHeightMinus1 = 1023;
3094 break;
3095 case 11:
3096 v8->uHeightMinus1 = 2047;
3097 break;
3098 case 12:
3099 v8->uHeightMinus1 = 4095;
3100 break;
3101 default:
3102 return 1;
3103 }
3104 return 1;
3105 }
3106
3107
3108 Texture *LODFile_IconsBitmaps::LoadTexturePtr(const char *pContainer, enum TEXTURE_TYPE uTextureType)
3109 {
3110 uint id = LoadTexture(pContainer, uTextureType);
3111 if (id == -1)
3112 {
3113 Log::Warning(L"LOD error\\no container: \"%S\"", pContainer);
3114 return nullptr;
3115 }
3116 return &pTextures[id];
3117 }
3118
3119 //----- (0040FB20) --------------------------------------------------------
3120 unsigned int LODFile_IconsBitmaps::LoadTexture(const char *pContainer, enum TEXTURE_TYPE uTextureType)
3121 {
3122 //LODFile_IconsBitmaps *v3; // esi@1
3123 //unsigned int v4; // edi@1
3124 //Texture *v5; // ebx@2
3125 unsigned int v6; // ebx@8
3126 const char *Sourcea; // [sp+14h] [bp+8h]@9
3127
3128 //v3 = this;
3129 //v4 = 0;
3130 areWeLoadingTexture = 1;
3131
3132 for (uint i = 0; i < uNumLoadedFiles; ++i)
3133 if (!strcmpi(pContainer, pTextures[i].pName))
3134 return i;
3135
3136 // if (!uNumLoadedFiles)
3137 // {
3138 //LABEL_5:
3139 if (uNumLoadedFiles >= 1000)
3140 {
3141 Log::Warning(L"Maximum texture number exceeded");
3142 AbortWithError();
3143 }
3144 if (LoadTextureFromLOD(&pTextures[uNumLoadedFiles], pContainer, uTextureType) == -1)
3145 {
3146 v6 = 0;
3147 if (uNumLoadedFiles > 0)
3148 {
3149 Sourcea = (const char *)pTextures;
3150 while ( _strcmpi(Sourcea, "pending") )
3151 {
3152 Sourcea += 72;
3153 ++v6;
3154 if (v6 >= uNumLoadedFiles)
3155 goto LABEL_15;
3156 }
3157 return v6;
3158 }
3159 LABEL_15:
3160 LoadTextureFromLOD(&pTextures[uNumLoadedFiles], "pending", uTextureType);
3161 }
3162 areWeLoadingTexture = 0;
3163 ++uNumLoadedFiles;
3164 return uNumLoadedFiles - 1;
3165 // }
3166 // v5 = pTextures;
3167 // while ( _strcmpi(v5->pName, pContainer) )
3168 // {
3169 // ++v4;
3170 // ++v5;
3171 // if (v4 >= uNumLoadedFiles )
3172 // goto LABEL_5;
3173 // }
3174 // return v4;
3175 }