Mercurial > mm7

comparison Engine/LOD.cpp @ 2499:68cdef6879a0

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
engine folder
author Ritor1
date Fri, 19 Sep 2014 02:57:42 +0600
parents
children fb1c61a82a55
comparison
equal deleted inserted replaced
2498:92eeeb5200f2 2499:68cdef6879a0
1 #define _CRTDBG_MAP_ALLOC
2 #include <stdlib.h>
3 #include <crtdbg.h>
4
5 #define _CRT_SECURE_NO_WARNINGS
6 #include "Engine/ErrorHandling.h"
7 #include "LOD.h"
8 #include "Engine/Graphics/Render.h"
9 #include "Engine/Graphics/Viewport.h"
10 #include "mm7_data.h"
11 #include "ZlibWrapper.h"
12
13 #include "Engine/Graphics/Sprites.h"
14
15
16
17
18
19
20 LODFile_IconsBitmaps *pEvents_LOD = nullptr;
21
22 LODFile_IconsBitmaps *pIcons_LOD = nullptr;
23 LODFile_IconsBitmaps *pIcons_LOD_mm6 = nullptr;
24 LODFile_IconsBitmaps *pIcons_LOD_mm8 = nullptr;
25
26 LODFile_IconsBitmaps *pBitmaps_LOD = nullptr;
27 LODFile_IconsBitmaps *pBitmaps_LOD_mm6 = nullptr;
28 LODFile_IconsBitmaps *pBitmaps_LOD_mm8 = nullptr;
29
30 LODFile_Sprites *pSprites_LOD = nullptr;
31 LODFile_Sprites *pSprites_LOD_mm6 = nullptr;
32 LODFile_Sprites *pSprites_LOD_mm8 = nullptr;
33
34 LODWriteableFile *pNew_LOD = nullptr;
35 LODWriteableFile *pGames_LOD = nullptr;
36
37
38
39
40 int _6A0CA4_lod_binary_search; // weak
41 int _6A0CA8_lod_unused; // weak
42
43
44 // inlined
45 //----- (mm6c::00408860) --------------------------------------------------
46 void LODFile_IconsBitmaps::_inlined_sub2()
47 {
48 ++uTexturePacksCount;
49 if (!uNumPrevLoadedFiles)
50 uNumPrevLoadedFiles = uNumLoadedFiles;
51 }
52
53 // inlined
54 //----- (mm6c::0045BE60) --------------------------------------------------
55 void LODFile_IconsBitmaps::_inlined_sub1()
56 {
57 dword_11B84 = uNumLoadedFiles;
58 }
59
60 // inlined
61 //----- (mm6c::0045C310) --------------------------------------------------
62 void LODFile_Sprites::_inlined_sub1()
63 {
64 field_ECA0 = uNumLoadedSprites;
65 }
66
67 // inlined
68 //----- (mm6c::0045C5B0) --------------------------------------------------
69 void LODFile_IconsBitmaps::_inlined_sub0()
70 {
71 dword_11B80 = uNumLoadedFiles;
72 if (dword_11B84 < uNumLoadedFiles)
73 dword_11B84 = uNumLoadedFiles;
74 }
75
76
77 // inlined
78 //----- (mm6c::0045C660) --------------------------------------------------
79 void LODFile_Sprites::_inlined_sub0()
80 {
81 field_ECA4 = uNumLoadedSprites;
82 if (field_ECA0 < uNumLoadedSprites)
83 field_ECA0 = uNumLoadedSprites;
84 }
85
86 //----- (004355F7) --------------------------------------------------------
87 void LODFile_IconsBitmaps::RemoveTexturesFromTextureList()
88 {
89 if ( this->uTexturePacksCount )
90 {
91 if ( (this->uNumLoadedFiles - 1) >= this->uNumPrevLoadedFiles )
92 {
93 for ( uint i = this->uNumLoadedFiles - 1; i >= this->uNumPrevLoadedFiles; --i )
94 {
95 this->pTextures[i].Release();
96 if ( this->pHardwareTextures )
97 {
98 if ( this->pHardwareTextures[i] )
99 {
100 this->pHardwareTextures[i]->Release();
101 this->pHardwareTextures[i] = 0;
102 }
103 }
104 if ( this->pHardwareSurfaces )
105 {
106 if ( this->pHardwareSurfaces[i] )
107 {
108 this->pHardwareSurfaces[i]->Release();
109 this->pHardwareSurfaces[i] = 0;
110 }
111 }
112 }
113 }
114 this->uNumLoadedFiles = this->uNumPrevLoadedFiles;
115 this->uNumPrevLoadedFiles = 0;
116 this->uTexturePacksCount = 0;
117 }
118 }
119
120 //----- (004114F2) --------------------------------------------------------
121 void LODFile_IconsBitmaps::RemoveTexturesPackFromTextureList()
122 {
123 if ( this->uTexturePacksCount )
124 {
125 this->uTexturePacksCount--;
126 if ( !this->uTexturePacksCount )
127 {
128 if ( (this->uNumLoadedFiles - 1) >= this->uNumPrevLoadedFiles )
129 {
130 for ( uint i = this->uNumLoadedFiles - 1; i >= this->uNumPrevLoadedFiles; --i )
131 {
132 this->pTextures[i].Release();
133 if ( this->pHardwareTextures )
134 {
135 if ( this->pHardwareTextures[i] )
136 {
137 this->pHardwareTextures[i]->Release();
138 this->pHardwareTextures[i] = 0;
139 }
140 }
141 if ( this->pHardwareSurfaces )
142 {
143 if ( this->pHardwareSurfaces[i] )
144 {
145 this->pHardwareSurfaces[i]->Release();
146 this->pHardwareSurfaces[i] = 0;
147 }
148 }
149 }
150 }
151 this->uNumLoadedFiles = this->uNumPrevLoadedFiles;
152 this->uNumPrevLoadedFiles = 0;
153 }
154 }
155 }
156
157 //----- (004AC67E) --------------------------------------------------------
158 int LODFile_Sprites::LoadSpriteFromFile(LODSprite *pSpriteHeader, const char *pContainer)
159 {
160 FILE *File; // [sp+4h] [bp-4h]@1
161 void *DstBufa; // [sp+10h] [bp+8h]@4
162 int Sizea; // [sp+14h] [bp+Ch]@3
163
164 File = FindContainer(pContainer, 0);
165 if ( File )
166 {
167 fread(pSpriteHeader, 1, 0x20u, File);
168 strcpy(pSpriteHeader->pName, pContainer);
169 Sizea = pSpriteHeader->uSpriteSize;
170 pSpriteHeader->pSpriteLines = (LODSprite_stru0 *)malloc(8 * pSpriteHeader->uHeight);
171 fread(pSpriteHeader->pSpriteLines, 1, 8 * pSpriteHeader->uHeight, File);
172
173 if ( pSpriteHeader->uDecompressedSize )
174 {
175 pSpriteHeader->pDecompressedBytes = malloc(pSpriteHeader->uDecompressedSize);
176 DstBufa = malloc(Sizea);
177 fread(DstBufa, 1, Sizea, File);
178 zlib::MemUnzip(pSpriteHeader->pDecompressedBytes, (unsigned int *)&pSpriteHeader->uDecompressedSize, DstBufa, pSpriteHeader->uSpriteSize);
179 pSpriteHeader->uSpriteSize = pSpriteHeader->uDecompressedSize;
180 free(DstBufa);
181 }
182 else
183 {
184 pSpriteHeader->pDecompressedBytes = malloc(Sizea);
185 fread(pSpriteHeader->pDecompressedBytes, 1, Sizea, File);
186 }
187 for ( uint i = 0; i < pSpriteHeader->uHeight; i++ )
188 pSpriteHeader->pSpriteLines[i].pos += (unsigned int)pSpriteHeader->pDecompressedBytes;
189 return 1;
190 }
191 else
192 return -1;
193 }
194
195 //----- (004AC795) --------------------------------------------------------
196 bool LODFile_Sprites::LoadSprites(const char *pFilename)
197 {
198 if (LoadHeader(pFilename, 1))
199 return false;
200 else
201 return LoadSubIndices("sprites08") == 0;
202 }
203
204 //----- (004AC7C0) --------------------------------------------------------
205 int LODFile_Sprites::LoadSprite(const char *pContainerName, unsigned int uPaletteID)
206 {
207
208 FILE *sprite_file; // eax@12
209 LODSprite temp_sprite_hdr; // [sp+Ch] [bp-3Ch]@12
210 int i;//, sprite_indx;
211
212 //find if already loaded
213 //if ( pRenderer->pRenderD3D )
214 {
215 for (i=0; i<uNumLoadedSprites;++i)
216 {
217 if (!(_stricmp(pHardwareSprites[i].pName, pContainerName)))
218 return i;
219 }
220 }
221 /*else
222 {
223 for (i=0; i<uNumLoadedSprites;++i)
224 {
225 if (!(_stricmp(pSpriteHeaders[i].pName, pContainerName)))
226 return i;
227 }
228 }*/
229
230 if (uNumLoadedSprites >= 1500 )
231 return -1;
232 //if not loaded - load from file
233
234 //if ( pRenderer->pRenderD3D && can_load_hardware_sprites )
235 {
236 if ( !pHardwareSprites )
237 {
238 pHardwareSprites = (Sprite *)malloc(1500*sizeof(Sprite));//0xEA60u
239 for (i=0; i<1500;++i)
240 {
241 pHardwareSprites[i].pName=nullptr;
242 pHardwareSprites[i].pTextureSurface=nullptr;
243 pHardwareSprites[i].pTexture=nullptr;
244 }
245 }
246 temp_sprite_hdr.uHeight = 0;
247 temp_sprite_hdr.uPaletteId = 0;
248 temp_sprite_hdr.word_1A = 0;
249 temp_sprite_hdr.pSpriteLines = nullptr;
250 temp_sprite_hdr.pDecompressedBytes = nullptr;
251 sprite_file = FindContainer(pContainerName, 0);
252 if ( !sprite_file )
253 return -1;
254 //fread(&temp_sprite_hdr, 1, sizeof(LODSprite), sprite_file);
255 fread(&temp_sprite_hdr, 1, 0x20, sprite_file);
256 pHardwareSprites[uNumLoadedSprites].uBufferWidth = temp_sprite_hdr.uWidth;
257 pHardwareSprites[uNumLoadedSprites].uBufferHeight = temp_sprite_hdr.uHeight;
258 pSpriteHeaders[uNumLoadedSprites].uWidth = temp_sprite_hdr.uWidth;
259 pSpriteHeaders[uNumLoadedSprites].uHeight = temp_sprite_hdr.uHeight;
260 LoadSpriteFromFile( &pSpriteHeaders[uNumLoadedSprites], pContainerName); //this line is not present here in the original. necessary for Grayface's mouse picking fix
261 }
262 /*else
263 {
264 sprite_indx = LoadSpriteFromFile( &pSpriteHeaders[uNumLoadedSprites], pContainerName);
265 pSpriteHeaders[uNumLoadedSprites].word_1A = 0;
266
267 if ( sprite_indx != -1 )
268 {
269 pSpriteHeaders[uNumLoadedSprites].uPaletteId = pPaletteManager->LoadPalette(pSpriteHeaders[uNumLoadedSprites].uPaletteId);
270 }
271 else
272 {
273 if ( uNumLoadedSprites<=0 )
274 uNumLoadedSprites=0;
275 else
276 {
277 for (i=0; i<uNumLoadedSprites;++i)
278 {
279 if (!(_stricmp(pSpriteHeaders[i].pName, "pending")))
280 return i;
281 }
282 }
283 if ( LoadSpriteFromFile(&pSpriteHeaders[uNumLoadedSprites], "pending") == -1 )
284 return -1;
285 pSpriteHeaders[uNumLoadedSprites].uPaletteId = pPaletteManager->LoadPalette(pSpriteHeaders[uNumLoadedSprites].uPaletteId);
286 }
287 }*/
288
289 //if ( pRenderer->pRenderD3D )
290 {
291 pHardwareSprites[uNumLoadedSprites].pName = (const char *)malloc(20);
292 strcpy((char *)pHardwareSprites[uNumLoadedSprites].pName, pContainerName);
293 pHardwareSprites[uNumLoadedSprites].uPaletteID = uPaletteID;
294 pRenderer->MoveSpriteToDevice(&pHardwareSprites[uNumLoadedSprites]);
295 }
296 ++uNumLoadedSprites;
297 return uNumLoadedSprites - 1;
298
299 }
300
301 //----- (004ACADA) --------------------------------------------------------
302 void LODFile_Sprites::ReleaseLostHardwareSprites()
303 {
304 signed int v2; // ebx@2
305 int v3; // edi@3
306 IDirectDrawSurface *v4; // eax@4
307 IDirect3DTexture2 *v5; // eax@6
308 IDirectDrawSurface *v6; // ST00_4@8
309
310 if ( this->pHardwareSprites )
311 {
312 v2 = 0;
313 if ( (signed int)this->uNumLoadedSprites > 0 )
314 {
315 v3 = 0;
316 do
317 {
318 v4 = (IDirectDrawSurface *)this->pHardwareSprites[v3].pTextureSurface;
319 if ( v4 && v4->IsLost() == DDERR_SURFACELOST )
320 {
321 v5 = this->pHardwareSprites[v3].pTexture;
322 if ( v5 )
323 {
324 v5->Release();
325 this->pHardwareSprites[v3].pTexture = nullptr;
326 }
327 v6 = (IDirectDrawSurface *)this->pHardwareSprites[v3].pTextureSurface;
328 v6->Release();
329 this->pHardwareSprites[v3].pTextureSurface = nullptr;
330 pRenderer->MoveSpriteToDevice(&this->pHardwareSprites[v3]);
331 }
332 ++v2;
333 ++v3;
334 }
335 while ( v2 < (signed int)this->uNumLoadedSprites );
336 }
337 }
338 }
339
340 //----- (004ACB70) --------------------------------------------------------
341 void LODFile_Sprites::ReleaseAll()
342 {
343 if ( this->pHardwareSprites )
344 {
345 for ( int i = 0; i < this->uNumLoadedSprites; ++i )
346 {
347 if ( this->pHardwareSprites )
348 {
349 if ( this->pHardwareSprites[i].pTexture )
350 {
351 this->pHardwareSprites[i].pTexture->Release();
352 this->pHardwareSprites[i].pTexture = nullptr;
353 }
354 if ( this->pHardwareSprites )
355 {
356 if ( this->pHardwareSprites[i].pTextureSurface )
357 {
358 this->pHardwareSprites[i].pTextureSurface->Release();
359 this->pHardwareSprites[i].pTextureSurface = nullptr;
360 }
361 }
362 }
363 }
364 }
365 }
366
367 //----- (004ACBE0) --------------------------------------------------------
368 void LODFile_Sprites::MoveSpritesToVideoMemory()
369 {
370 if ( this->pHardwareSprites )
371 {
372 for ( int i = 0; i < this->uNumLoadedSprites; ++i )
373 pRenderer->MoveSpriteToDevice(&this->pHardwareSprites[i]);
374 }
375 }
376
377 //----- (004ACC38) --------------------------------------------------------
378 int LODSprite::DrawSprite_sw(RenderBillboardTransform_local0 *a2, char a3)
379 {
380 RenderBillboardTransform_local0 *v3; // edi@1
381 int result; // eax@1
382 int v5; // esi@2
383 int v6; // ST18_4@2
384 //signed int v7; // eax@2
385 signed int v8; // ebx@2
386 int v9; // ebx@2
387 int *v10; // ecx@2
388 int v11; // esi@2
389 unsigned int v12; // edx@4
390 int v13; // esi@13
391 int v14; // esi@17
392 int v15; // ecx@17
393 char *v16; // edx@17
394 int v17; // esi@17
395 int v18; // ecx@18
396 int v19; // esi@18
397 LODSprite_stru0 *v20; // edx@21
398 int v21; // eax@22
399 int v22; // esi@22
400 int v23; // eax@25
401 int v24; // ecx@25
402 signed __int64 v25; // qtt@27
403 int v26; // eax@27
404 unsigned __int16 *v27; // eax@29
405 LODSprite_stru0 *v28; // edx@29
406 signed int v29; // ecx@30
407 int v30; // ecx@37
408 int v31; // ecx@38
409 signed int v32; // ecx@41
410 int v33; // ecx@47
411 int v34; // ecx@56
412 int v35; // esi@58
413 __int16 v36; // ax@58
414 int v37; // ecx@59
415 int v38; // eax@59
416 int v39; // ecx@62
417 signed int v40; // ST30_4@64
418 signed __int64 v41; // qtt@64
419 int v42; // ecx@64
420 unsigned __int16 *v43; // eax@66
421 LODSprite_stru0 *v44; // ecx@66
422 int v45; // edx@69
423 int v46; // edx@77
424 //unsigned __int16 *pTarget; // [sp+Ch] [bp-50h]@2
425 signed int v48; // [sp+10h] [bp-4Ch]@2
426 signed int v49; // [sp+14h] [bp-48h]@2
427 int v50; // [sp+14h] [bp-48h]@19
428 int v51; // [sp+14h] [bp-48h]@57
429 int v52; // [sp+18h] [bp-44h]@13
430 int v53; // [sp+1Ch] [bp-40h]@2
431 int v54; // [sp+1Ch] [bp-40h]@22
432 int v55; // [sp+1Ch] [bp-40h]@32
433 int v56; // [sp+1Ch] [bp-40h]@69
434 int v57; // [sp+20h] [bp-3Ch]@2
435 int v58; // [sp+24h] [bp-38h]@1
436 int v59; // [sp+28h] [bp-34h]@2
437 int v60; // [sp+28h] [bp-34h]@13
438 unsigned __int16 *v61; // [sp+2Ch] [bp-30h]@2
439 int v62; // [sp+30h] [bp-2Ch]@2
440 void *v63; // [sp+30h] [bp-2Ch]@29
441 void *v64; // [sp+30h] [bp-2Ch]@66
442 int v65; // [sp+34h] [bp-28h]@2
443 int v66; // [sp+34h] [bp-28h]@22
444 int v67; // [sp+34h] [bp-28h]@59
445 int v68; // [sp+38h] [bp-24h]@13
446 unsigned int v69; // [sp+3Ch] [bp-20h]@2
447 int v70; // [sp+40h] [bp-1Ch]@2
448 signed int v71; // [sp+40h] [bp-1Ch]@15
449 int v72; // [sp+44h] [bp-18h]@2
450 unsigned __int16 *v73; // [sp+44h] [bp-18h]@29
451 unsigned __int16 *v74; // [sp+44h] [bp-18h]@66
452 int v75; // [sp+48h] [bp-14h]@4
453 int v76; // [sp+48h] [bp-14h]@22
454 int v77; // [sp+48h] [bp-14h]@59
455 //LODSprite *v78; // [sp+4Ch] [bp-10h]@1
456 int v79; // [sp+50h] [bp-Ch]@4
457 int v80; // [sp+50h] [bp-Ch]@21
458 int v81; // [sp+50h] [bp-Ch]@62
459 int v82; // [sp+50h] [bp-Ch]@67
460 int v83; // [sp+50h] [bp-Ch]@75
461 int *pTargetZ; // [sp+54h] [bp-8h]@4
462 int v85; // [sp+58h] [bp-4h]@18
463 int v86; // [sp+58h] [bp-4h]@56
464 signed int v87; // [sp+64h] [bp+8h]@2
465 int v88; // [sp+68h] [bp+Ch]@18
466 int v89; // [sp+68h] [bp+Ch]@56
467
468 v3 = a2;
469 //v78 = this;
470 result = a2->_screenspace_x_scaler_packedfloat;
471 v58 = a2->_screenspace_x_scaler_packedfloat;
472 if ( result <= 0 )
473 return result;
474 v5 = a2->_screenspace_y_scaler_packedfloat;
475 v6 = a2->_screenspace_x_scaler_packedfloat;
476 v87 = (signed __int64)0x100000000ui64 / result;
477 v48 = (signed __int64)0x100000000ui64 / result;
478 v62 = (signed __int64)0x100000000ui64 / v5;
479 //v7 = this->uHeight;
480 v8 = (signed int)((signed __int64)0x100000000ui64 / v5) >> 1;
481 v53 = v8;
482 v70 = (this->uHeight << 16) - v8;
483 v49 = this->uHeight;
484 v69 = v3->uTargetPitch;
485
486 __debugbreak(); // target surface will most likely be 32bit, but this sub awaits 16bits
487 auto pTarget = (unsigned __int16 *)v3->pTarget;
488 v57 = v3->sZValue;
489 v61 = v3->pPalette;
490 v9 = (v6 * this->uWidth + 0x8000) >> 16;
491 v72 = v3->uScreenSpaceY;
492 result = (v5 * this->uHeight + 0x8000) >> 16;
493 v10 = (int *)(v72 - result + 1);
494 v11 = v3->uScreenSpaceX - (v9 >> 1) + 1;
495 v65 = v72 - result + 1;
496 v59 = v11 + v9 - 1;
497 if ( v3->uFlags & 0x800 )
498 {
499 v10 = (int *)((char *)v10 + (v49 >> 1));
500 v72 += v49 >> 1;
501 v65 = (int)v10;
502 }
503 v12 = v72;
504 pTargetZ = v10;
505 v75 = v3->uScreenSpaceX - (v9 >> 1) + 1;
506 v79 = v11 + v9 - 1;
507 if ( !(v3->uFlags & 8) )
508 {
509 if ( v65 < (signed int)v3->uViewportY )
510 pTargetZ = (int *)v3->uViewportY;
511 if ( v72 > (signed int)v3->uViewportW )
512 v12 = v3->uViewportW;
513 if ( v11 < (signed int)v3->uViewportX )
514 v75 = v3->uViewportX;
515 if ( v59 > (signed int)v3->uViewportZ )
516 v79 = v3->uViewportZ;
517 }
518 v68 = v75 - v11;
519 v13 = -v62;
520 v60 = v59 - v79;
521 v52 = -v62;
522 if ( v3->uFlags & 1 )
523 {
524 v13 = v62;
525 v70 = v53;
526 v52 = v62;
527 }
528 v71 = v13 * (v72 - v12) + v70;
529 if ( LOBYTE(viewparams->field_20) )
530 {
531 if ( a3 )
532 return result;
533 }
534 v14 = 5 * v12;
535 v15 = v69 * v12;
536 result = v12 - v72 + result - 1;
537 v16 = (char *)pTargetZ - v65;
538 v17 = v14 << 7;
539 if ( v3->uFlags & 4 )
540 {
541 v34 = v79 + v15;
542 v89 = v34;
543 v86 = v79 + v17;
544 if ( result < (signed int)v16 )
545 return result;
546 v51 = result - (int)v16 + 1;
547 while ( 1 )
548 {
549 v35 = v71 >> 16;
550 v36 = this->pSpriteLines[v35].a1;
551 if ( v36 == -1 )
552 {
553 v34 -= v69;
554 v89 = v34;
555 goto LABEL_84;
556 }
557 v37 = v9 - ((unsigned __int64)(v36 * (signed __int64)v58) >> 16);
558 v67 = v87 * ((unsigned __int64)(this->pSpriteLines[v35].a2 * (signed __int64)v58) >> 16);
559 v38 = v9 - v60;
560 v77 = v9 - v60;
561 if ( v9 - v60 <= (signed int)(v9 - ((unsigned __int64)(this->pSpriteLines[v35].a2 * (signed __int64)v58) >> 16))
562 || v68 >= v37 )
563 {
564 v89 -= v69;
565 v34 = v89;
566 LABEL_84:
567 v86 -= window->GetWidth();
568 goto LABEL_85;
569 }
570 if ( v38 < v37 )
571 v81 = (v87 >> 1) + v87 * (v37 - v38);
572 else
573 {
574 v77 = v37;
575 v81 = v87 >> 1;
576 v39 = v37 - v9;
577 v89 += v39 + v60;
578 v86 += v60 + v39;
579 }
580 v40 = ((this->pSpriteLines[v35].a2 + 1) << 16) - v81 - v67;
581 LODWORD(v41) = v40 << 16;
582 HIDWORD(v41) = v40 >> 16;
583 v42 = v77 - (((signed int)((unsigned __int64)(v41 / v48) - 0x8000) >> 16) + 1);
584 if ( v68 >= v42 )
585 v42 = v68;
586 v43 = &pTarget[v89];
587 v74 = &v43[v42 - v77 + 1];
588 v44 = &this->pSpriteLines[v35];
589 v64 = v44->pos;
590 if ( !v57 )
591 {
592 v83 = v67 + v81;
593 if ( ((v83 - (v44->a1 << 16)) & 0xFFFF0000) < 0 )
594 {
595 v83 += v87;
596 --v43;
597 --pTargetZ;
598 }
599 while ( v43 >= v74 )
600 {
601 v46 = (v83 - ((signed int)this->pSpriteLines[v35].a1 << 16)) >> 16;
602 if ( *((char *)v64 + v46) )
603 *v43 = v61[*((char *)v64 + v46)];
604 v83 += v87;
605 --v43;
606 }
607 goto LABEL_81;
608 }
609 pTargetZ = &v3->pTargetZ[v86];
610 v82 = v67 + v81;
611 if ( ((v82 - (v44->a1 << 16)) & 0xFFFF0000) < 0 )
612 goto LABEL_72;
613 LABEL_73:
614 if ( v43 >= v74 )
615 break;
616 LABEL_81:
617 v89 += v9 - v77 - v60 - v69;
618 v34 = v89;
619 v86 = v86 + v9 - v77 - v60 - window->GetWidth();
620 LABEL_85:
621 result = v52;
622 v71 += v52;
623 --v51;
624 if ( !v51 )
625 return result;
626 }
627 v45 = (v82 - ((signed int)this->pSpriteLines[v35].a1 << 16)) >> 16;
628 v56 = *((char *)v64 + v45);
629 if ( *((char *)v64 + v45) && v57 <= (unsigned int)*pTargetZ )
630 {
631 *pTargetZ = v57;
632 *v43 = v61[v56];
633 }
634 LABEL_72:
635 v82 += v87;
636 --v43;
637 --pTargetZ;
638 goto LABEL_73;
639 }
640 v18 = v75 + v15;
641 v19 = v75 + v17;
642 v88 = v18;
643 v85 = v19;
644 if ( result >= (signed int)v16 )
645 {
646 v50 = result - (int)v16 + 1;
647 while ( 1 )
648 {
649 v20 = &this->pSpriteLines[v71 >> 16];
650 v80 = v71 >> 16;
651 if ( v20->a1 != -1 )
652 break;
653 v18 -= v69;
654 v85 = v19 - window->GetWidth();
655 v88 = v18;
656 LABEL_54:
657 result = v52;
658 v71 += v52;
659 --v50;
660 if ( !v50 )
661 return result;
662 v19 = v85;
663 }
664 v21 = (v58 * v20->a1 + 32768) >> 16;
665 v66 = v21 * v87;
666 v76 = v68;
667 v54 = v20->a2;
668 v22 = v9 - v60;
669 if ( v68 >= (v58 * v54 + 32768) >> 16 || v22 <= v21 )
670 {
671 v88 -= v69;
672 v85 -= window->GetWidth();
673 goto LABEL_51;
674 }
675 if ( v68 > v21 )
676 {
677 v24 = (v87 >> 1) + v87 * (v68 - v21);
678 }
679 else
680 {
681 v76 = (v58 * v20->a1 + 0x8000) >> 16;
682 v23 = v21 - v68;
683 v88 += v23;
684 v24 = v87 >> 1;
685 v85 += v23;
686 }
687 LODWORD(v25) = (((v54 + 1) << 16) - v24 - v66) << 16;
688 HIDWORD(v25) = (((v54 + 1) << 16) - v24 - v66) >> 16;
689 v26 = v76 + ((signed int)(v25 / v48) >> 16) + 1;
690 if ( v22 > v26 )
691 v22 = v26;
692 v27 = &pTarget[v88];
693 v73 = &v27[v22 - v76 - 1];
694 v28 = &this->pSpriteLines[v80];
695 v63 = v28->pos;
696 if ( v57 )
697 {
698 pTargetZ = &v3->pTargetZ[v85];
699 v29 = v66 - (v28->a1 << 16) + v24;
700 if ( (v29 & 0xFFFF0000) >= 0 )
701 goto LABEL_36;
702 while ( 1 )
703 {
704 v29 += v87;
705 ++v27;
706 ++pTargetZ;
707 LABEL_36:
708 if ( v27 >= v73 )
709 break;
710 v55 = *((char *)v63 + (v29 >> 16));
711 if ( *((char *)v63 + (v29 >> 16)) && v57 <= (unsigned int)*pTargetZ )
712 {
713 *pTargetZ = v57;
714 *v27 = v61[v55];
715 }
716 }
717 v30 = v29 >> 16;
718 if ( v30 > this->pSpriteLines[v80].a2 - (signed int)this->pSpriteLines[v80].a1
719 || (v31 = *((char *)v63 + v30)) == 0
720 || v57 > (unsigned int)*pTargetZ )
721 goto LABEL_50;
722 *pTargetZ = v57;
723 }
724 else
725 {
726 v32 = v66 - (v28->a1 << 16) + v24;
727 if ( (v32 & 0xFFFF0000) < 0 )
728 {
729 v32 += v87;
730 ++v27;
731 ++pTargetZ;
732 }
733 while ( v27 < v73 )
734 {
735 if ( *((char *)v63 + (v32 >> 16)) )
736 *v27 = v61[*((char *)v63 + (v32 >> 16))];
737 v32 += v87;
738 ++v27;
739 }
740 v33 = v32 >> 16;
741 if ( v33 > this->pSpriteLines[v80].a2 - (signed int)this->pSpriteLines[v80].a1
742 || (v31 = *((char *)v63 + v33)) == 0 )
743 goto LABEL_50;
744 }
745 *v27 = v61[v31];
746 LABEL_50:
747 v88 += v68 - v76 - v69;
748 v85 = v85 + v68 - v76 - window->GetWidth();
749 LABEL_51:
750 v18 = v88;
751 goto LABEL_54;
752 }
753 return result;
754 }
755
756 //----- (004AD2D1) --------------------------------------------------------
757 int LODSprite::_4AD2D1(struct RenderBillboardTransform_local0 *a2, int a3)
758 {
759 int result; // eax@1
760 unsigned int v4; // esi@1
761 int v5; // edi@1
762 LODSprite_stru0 *v6; // edx@2
763 __int16 v7; // bx@2
764 int v8; // ecx@3
765 unsigned __int16 *v9; // esi@3
766 int v10; // ebx@3
767 void *v11; // edx@3
768 unsigned __int16 *v12; // ecx@3
769 int v13; // ebx@4
770 //LODSprite *v14; // [sp+8h] [bp-10h]@1
771 unsigned __int16 *v15; // [sp+10h] [bp-8h]@1
772 unsigned __int16 *v16; // [sp+14h] [bp-4h]@1
773 int i; // [sp+20h] [bp+8h]@1
774
775 result = (int)a2;
776 v4 = a2->uTargetPitch;
777
778 __debugbreak(); // sub expects 16bit target surface, we may have 32bit
779 v16 = (unsigned short *)a2->pTarget;
780 v15 = a2->pPalette;
781 v5 = this->uHeight - 1;
782 for ( i = v4 * a2->uScreenSpaceY - (this->uWidth >> 1) + a2->uScreenSpaceX + 1; v5 >= 0; --v5 )
783 {
784 v6 = &this->pSpriteLines[v5];
785 v7 = this->pSpriteLines[v5].a1;
786 if ( this->pSpriteLines[v5].a1 != -1 )
787 {
788 v8 = v7;
789 v9 = &v16[v7 + i];
790 v10 = v6->a2;
791 v11 = v6->pos;
792 v12 = &v9[v10 - v8];
793 while ( v9 <= v12 )
794 {
795 v13 = *(char *)v11;
796 v11 = (char *)v11 + 1;
797 if ( v13 )
798 *v9 = v15[v13];
799 ++v9;
800 }
801 v4 = *(int *)(result + 48);
802 //this = v14;
803 }
804 i -= v4;
805 }
806 return result;
807 }
808
809 //----- (0046454B) --------------------------------------------------------
810 void LODFile_IconsBitmaps::ReleaseAll2()
811 {
812 for ( uint i = (uint)this->dword_11B84; i < this->uNumLoadedFiles; i++ )
813 {
814 this->pTextures[i].Release();
815 if ( this->pHardwareTextures )
816 {
817 if ( this->pHardwareTextures[i] )
818 {
819 this->pHardwareTextures[i]->Release();
820 this->pHardwareTextures[i] = 0;
821 }
822 }
823 if ( this->pHardwareSurfaces )
824 {
825 if ( this->pHardwareSurfaces[i] )
826 {
827 this->pHardwareSurfaces[i]->Release();
828 this->pHardwareSurfaces[i] = 0;
829 }
830 }
831 }
832 this->uTexturePacksCount = 0;
833 this->uNumPrevLoadedFiles = 0;
834 this->uNumLoadedFiles = this->dword_11B84;
835 }
836
837 //----- (004645DC) --------------------------------------------------------
838 void LODFile_Sprites::DeleteSomeOtherSprites()
839 {
840 int *v1; // esi@1
841 int *v2; // edi@1
842
843 v1 = (int *)&this->uNumLoadedSprites;
844 v2 = &this->field_ECA0;
845 DeleteSpritesRange(field_ECA0, uNumLoadedSprites);
846 *v1 = *v2;
847 }
848
849 //----- (00461431) --------------------------------------------------------
850 void LOD::File::Close()
851 {
852 if (isFileOpened )
853 {
854 this->pContainerName[0] = 0;
855 this->uCurrentIndexDir = 0;
856 free(pSubIndices);
857 free(pRoot);
858 pSubIndices = nullptr;
859 pRoot = nullptr;
860 fclose(pFile);
861 isFileOpened = false;
862 _6A0CA8_lod_unused = 0;
863 }
864 }
865
866 //----- (00461492) --------------------------------------------------------
867 int LODWriteableFile::CreateNewLod(LOD::FileHeader *pHeader, LOD::Directory *pDir, const char *lod_name)
868 {
869 if (isFileOpened)
870 return 1;
871 if ( !pDir->pFilename[0] )
872 return 2;
873 strcpy(pHeader->pSignature, "LOD");
874 pHeader->LODSize = 100;
875 pHeader->uNumIndices = 1;
876 pDir->field_F = 0;
877 pDir->uDataSize = 0;
878 pDir->uOfsetFromSubindicesStart = 288;
879 strcpy(pLODName, lod_name);
880
881 pFile = fopen(pLODName, "wb+");
882 if (!pFile)
883 return 3;
884 fwrite(pHeader,sizeof(LOD::FileHeader), 1, pFile);
885 fwrite(pDir, sizeof(LOD::Directory), 1, pFile);
886 fclose(pFile);
887 pFile = nullptr;
888 return 0;
889 }
890
891 //----- (0046153F) --------------------------------------------------------
892 void LOD::File::ResetSubIndices()
893 {
894 if ( isFileOpened )
895 {
896 pContainerName[0] = 0;
897 uCurrentIndexDir = 0;
898 uOffsetToSubIndex = 0;
899 uNumSubDirs = 0;
900 uLODDataSize = 0;
901 free(pSubIndices);
902 pSubIndices = nullptr;
903 }
904 }
905
906 //----- (00450C8B) --------------------------------------------------------
907 void LODFile_Sprites::DeleteSomeSprites()
908 {
909 int *v1; // esi@1
910 int *v2; // edi@1
911
912 v1 = (int *)&this->uNumLoadedSprites;
913 v2 = &this->field_ECA8;
914 DeleteSpritesRange(this->field_ECA8, this->uNumLoadedSprites);
915 *v1 = *v2;
916 }
917
918 //----- (00450CA9) --------------------------------------------------------
919 void LODFile_Sprites::DeleteSpritesRange(int uStartIndex, int uStopIndex)
920 {
921 if ( this->pHardwareSprites )
922 {
923 if ( uStartIndex < uStopIndex )
924 {
925 for ( int i = uStartIndex; i < uStopIndex; i++ )
926 {
927 this->pSpriteHeaders[i].Release();
928 pHardwareSprites[i].Release();
929 }
930 }
931 }
932 else
933 {
934 if ( uStartIndex < uStopIndex )
935 {
936 for ( int i = uStartIndex; i < uStopIndex; i++ )
937 this->pSpriteHeaders[i].Release();
938 }
939 }
940 }
941
942 //----- (00450D1D) --------------------------------------------------------
943 void LODSprite::Release()
944 {
945 if ( !(HIBYTE(this->word_1A) & 4) )
946 {
947 free(this->pDecompressedBytes);
948 free(this->pSpriteLines);
949 }
950 this->word_1A = 0;
951 this->pDecompressedBytes = nullptr;
952 this->pSpriteLines = nullptr;
953 this->pName[0] = 0;
954 this->word_16 = 0;
955 this->uPaletteId = 0;
956 this->uTexturePitch = 0;
957 this->uHeight = 0;
958 this->uWidth = 0;
959 this->uSpriteSize = 0;
960 }
961
962 //----- (00450D68) --------------------------------------------------------
963 void Sprite::Release()
964 {
965 free((void *)pName);
966 pName = nullptr;
967
968 if (pTextureSurface)
969 pTextureSurface->Release();
970 pTextureSurface = nullptr;
971
972 if (pTexture)
973 pTexture->Release();
974 pTexture = nullptr;
975 }
976
977 //----- (0040FAEE) --------------------------------------------------------
978 //----- (0040FA2E) --------------------------------------------------------
979 bool LODFile_IconsBitmaps::Load(const char *pLODFilename, const char *pFolderName)
980 {
981 ReleaseAll();
982
983 if (LoadHeader(pLODFilename, 1))
984 return false;
985
986 return LoadSubIndices(pFolderName) == 0;
987 }
988
989 //----- (0040FA60) --------------------------------------------------------
990 void LODFile_IconsBitmaps::ReleaseAll()
991 {
992 for( uint i = 0; i < this->uNumLoadedFiles; i++ )
993 {
994 this->pTextures[i].Release();
995 if ( this->pHardwareTextures )
996 {
997 if ( this->pHardwareTextures[i] )
998 {
999 this->pHardwareTextures[i]->Release();
1000 this->pHardwareTextures[i] = 0;
1001 }
1002 }
1003 if ( this->pHardwareSurfaces )
1004 {
1005 if ( this->pHardwareSurfaces[i] )
1006 {
1007 this->pHardwareSurfaces[i]->Release();
1008 this->pHardwareSurfaces[i] = 0;
1009 }
1010 }
1011 }
1012 this->uTexturePacksCount = 0;
1013 this->uNumPrevLoadedFiles = 0;
1014 this->dword_11B84 = 0;
1015 this->dword_11B80 = 0;
1016 this->uNumLoadedFiles = 0;
1017 }
1018
1019 //----- (0040F9F0) --------------------------------------------------------
1020 unsigned int LODFile_IconsBitmaps::FindTextureByName(const char *pName)
1021 {
1022 for ( uint i = 0; i < this->uNumLoadedFiles; i++ )
1023 {
1024 if ( !_stricmp(this->pTextures[i].pName, pName) )
1025 return i;
1026 }
1027 return -1;
1028 }
1029
1030 //----- (0040F9C5) --------------------------------------------------------
1031 void LODFile_IconsBitmaps::SyncLoadedFilesCount()
1032 {
1033 signed int loaded_files; // eax@1
1034 Texture *pTex; // edx@1
1035
1036 loaded_files = this->uNumLoadedFiles;
1037 for ( pTex = &this->pTextures[loaded_files]; !pTex->pName[0]; --pTex )
1038 --loaded_files;
1039 if ( loaded_files < (signed int)this->uNumLoadedFiles )
1040 {
1041 ++loaded_files;
1042 this->uNumLoadedFiles = loaded_files;
1043 }
1044
1045 }
1046
1047 //----- (0046249B) --------------------------------------------------------
1048 LODFile_Sprites::~LODFile_Sprites()
1049 {
1050 if ( this->pHardwareSprites )
1051 {
1052 for ( int i = 0; i < this->uNumLoadedSprites; ++i )
1053 {
1054 this->pSpriteHeaders[i].Release();
1055 this->pHardwareSprites[i].Release();
1056 }
1057 }
1058 else
1059 {
1060 for ( int i = 0; i < this->uNumLoadedSprites; ++i )
1061 this->pSpriteHeaders[i].Release();
1062 }
1063 //_eh_vector_destructor_iterator_(v1->pSpriteHeaders, 40, 1500, LODSprite::dtor);
1064 //LOD::File::vdtor((LOD::File *)v1);
1065 }
1066 // 4CC2B4: using guessed type int __stdcall _eh vector destructor iterator_(int, int, int, int);
1067
1068 //----- (00462463) --------------------------------------------------------
1069 LODSprite::~LODSprite()
1070 {
1071 if ( !(HIBYTE(this->word_1A) & 4) )
1072 {
1073 free(pDecompressedBytes);
1074 free(pSpriteLines);
1075 }
1076 pDecompressedBytes = nullptr;
1077 pSpriteLines = nullptr;
1078 }
1079
1080 //----- (004623E5) --------------------------------------------------------
1081 LODFile_Sprites::LODFile_Sprites():
1082 LOD::File()
1083 {
1084 /*_eh_vector_constructor_iterator_(
1085 v1->pSpriteHeaders,
1086 40,
1087 1500,
1088 (void ( *)(void *))LODSprite::LODSprite,
1089 (void ( *)(void *))LODSprite::dtor);*/
1090 field_ECA4 = 0;
1091 field_ECA0 = 0;
1092 pHardwareSprites = 0;
1093 //can_load_hardware_sprites = 0;
1094 field_ECB4 = 0;
1095 uNumLoadedSprites = 0;
1096 }
1097
1098 //----- (00462303) --------------------------------------------------------
1099 LODFile_IconsBitmaps::~LODFile_IconsBitmaps()
1100 {
1101
1102 for ( uint i = 0; i < this->uNumLoadedFiles; i++ )
1103 {
1104 this->pTextures[i].Release();
1105 if ( this->pHardwareTextures )
1106 {
1107 if ( this->pHardwareTextures[i] )
1108 {
1109 this->pHardwareTextures[i]->Release();
1110 this->pHardwareTextures[i] = 0;
1111 }
1112 }
1113 if ( this->pHardwareSurfaces )
1114 {
1115 if ( this->pHardwareSurfaces[i] )
1116 {
1117 this->pHardwareSurfaces[i]->Release();
1118 this->pHardwareSurfaces[i] = 0;
1119 }
1120 }
1121 }
1122 free(this->pHardwareSurfaces);
1123 free(this->pHardwareTextures);
1124 free(this->ptr_011BB4);
1125 //LOD::File::vdtor((LOD::File *)v1);
1126 }
1127
1128 //----- (00462272) --------------------------------------------------------
1129 LODFile_IconsBitmaps::LODFile_IconsBitmaps():
1130 LOD::File()
1131 {
1132 /*v2 = v1->pTextures;
1133 v3 = 1000;
1134 do
1135 {
1136 Texture::Texture(v2);
1137 ++v2;
1138 --v3;
1139 }
1140 while ( v3 );*/
1141 this->uTexturePacksCount = 0;
1142 this->uNumPrevLoadedFiles = 0;
1143 this->dword_11B84 = 0;
1144 this->dword_11B80 = 0;
1145 this->uNumLoadedFiles = 0;
1146 this->dword_011BA4 = 0;
1147 //this->can_load_hardware_sprites = 0;
1148 this->pHardwareSurfaces = 0;
1149 this->pHardwareTextures = 0;
1150 this->ptr_011BB4 = 0;
1151 this->uTextureRedBits = 0;
1152 this->uTextureGreenBits = 0;
1153 this->uTextureBlueBits = 0;
1154 }
1155
1156 //----- (004621A7) --------------------------------------------------------
1157 bool LODWriteableFile::_4621A7()//çàêðûòü è çàãðóçèòü çàïèñûâàåìûé ô-ë(ïðè ñîõðàíåíèè)
1158 {
1159 CloseWriteFile();
1160 return LoadFile(pLODName, 0);
1161 }
1162
1163 //----- (00461FD4) ---LODFile_sub_461FD4---text:004632EA --------------------------------------------------
1164 int LODWriteableFile::FixDirectoryOffsets()
1165 {
1166 int total_size; // edi@1
1167 int temp_offset; // ecx@5
1168 FILE *tmp_file; // eax@9
1169 size_t write_size; // edi@12
1170 int result;
1171 char Filename[256]; // [sp+Ch] [bp-228h]@9
1172 char NewFilename[256]; // [sp+10Ch] [bp-128h]@15
1173 int i;
1174
1175 total_size = 0;
1176 for ( i = 0; i < uNumSubDirs; i++ )
1177 total_size += pSubIndices[i].uDataSize;
1178 //fix offsets
1179 temp_offset = sizeof(LOD::Directory) * uNumSubDirs;
1180 for ( i = 0; i < uNumSubDirs; i++ )
1181 {
1182 pSubIndices[i].uOfsetFromSubindicesStart=temp_offset;
1183 temp_offset+=pSubIndices[i].uDataSize;
1184 }
1185 strcpy(Filename, "lod.tmp");
1186 tmp_file = fopen(Filename, "wb+");
1187
1188 if ( tmp_file )
1189 {
1190 fwrite((const void *)&header, sizeof(LOD::FileHeader), 1, tmp_file);
1191
1192 LOD::Directory Lindx;
1193 strcpy(Lindx.pFilename, "chapter");
1194 Lindx.uOfsetFromSubindicesStart = uOffsetToSubIndex; //10h 16
1195 Lindx.uDataSize = sizeof(LOD::Directory) * uNumSubDirs + total_size; //14h 20
1196 Lindx.dword_000018 = 0; //18h 24
1197 Lindx.uNumSubIndices = uNumSubDirs; //1ch 28
1198 Lindx.word_00001E = 0; // 1Eh 30
1199 fwrite(&Lindx, sizeof(LOD::Directory), 1, tmp_file);
1200 fwrite(pSubIndices, sizeof(LOD::Directory), uNumSubDirs, tmp_file);
1201 fseek(pOutputFileHandle, 0, 0);
1202 if ( total_size > 0 )
1203 {
1204 do
1205 {
1206 write_size = uIOBufferSize;
1207 if ( total_size <= (signed int)uIOBufferSize )
1208 write_size =total_size;
1209 fread(pIOBuffer, 1, write_size, pOutputFileHandle);
1210 fwrite(pIOBuffer, 1, write_size, tmp_file);
1211 total_size -= write_size;
1212 }
1213 while ( total_size > 0 );
1214 }
1215 strcpy(NewFilename, (const char *)&pLODName);
1216 fclose(tmp_file);
1217 fclose(pOutputFileHandle);
1218 CloseWriteFile();
1219 remove("lodapp.tmp");
1220 remove(NewFilename);
1221 rename(Filename, NewFilename);
1222 CloseWriteFile();
1223 LoadFile( (const char *)&pLODName, 0);
1224 result = 0;
1225 }
1226 else
1227 result = 5;
1228 return result;
1229 }
1230
1231 //----- (00461F71) --------------------------------------------------------
1232 bool LOD::File::AppendDirectory(LOD::Directory *pDir, const void *pData)
1233 {
1234 Assert(uNumSubDirs < 299);
1235
1236 memcpy(&pSubIndices[uNumSubDirs++], pDir, sizeof(LOD::Directory));
1237 fwrite(pData, 1, pDir->uDataSize, pOutputFileHandle);
1238 return true;
1239 }
1240
1241 //----- (00461F1E) --------------------------------------------------------
1242 int LODWriteableFile::CreateTempFile()
1243 {
1244 if (!isFileOpened)
1245 return 1;
1246
1247 if (pIOBuffer && uIOBufferSize )
1248 {
1249 uCurrentIndexDir = 0;
1250 uNumSubDirs = 0;
1251 pOutputFileHandle = fopen("lodapp.tmp", "wb+");
1252 return pOutputFileHandle ? 1 : 7;
1253 }
1254 else
1255 return 5;
1256 }
1257
1258 //----- (00461EE9) --------------------------------------------------------
1259 void LODWriteableFile::CloseWriteFile()
1260 {
1261 if (isFileOpened)
1262 {
1263 pContainerName[0] = 0;
1264 uCurrentIndexDir = 0;
1265 _6A0CA8_lod_unused = 0;
1266
1267 isFileOpened = false;
1268 fflush(pFile);
1269 fclose(pFile);
1270 pFile = nullptr;
1271 }
1272 //else
1273 //__debugbreak();
1274 }
1275 // 6A0CA8: using guessed type int 6A0CA8_lod_unused;
1276
1277
1278 //----- (00461B48) --------------------------------------------------------
1279 unsigned int LODWriteableFile::Write(const LOD::Directory *pDir, const void *pDirData, int a4)
1280 {
1281 char Filename[256];
1282 char NewFilename[256];
1283 FILE *tmp_file;
1284 int comp_res;
1285 bool bRewrite_data;
1286 int offset_to_data;
1287 int total_data_size;
1288 int size_correction;
1289 int to_copy_size;
1290 int read_size;
1291 int curr_position;
1292 int insert_index;
1293
1294 //insert new data in sorted index lod file
1295 bRewrite_data = false;
1296 insert_index = -1;
1297 if ( !isFileOpened )//sometimes gives crash
1298 return 1;
1299 if ( !pSubIndices )
1300 return 2;
1301 if ( !pIOBuffer || !uIOBufferSize )
1302 return 3;
1303
1304 for ( int i = 0; i < uNumSubDirs; i++ )
1305 {
1306 comp_res = _stricmp(pSubIndices[i].pFilename, pDir->pFilename);
1307 if( comp_res == 0 )
1308 {
1309 insert_index = i;
1310 if ( a4 == 0 )
1311 {
1312 bRewrite_data = true;
1313 break;
1314 }
1315 if ( a4 == 1 )
1316 {
1317 if ( pSubIndices[i].uNumSubIndices < pDir->uNumSubIndices )
1318 {
1319 if ( pSubIndices[i].word_00001E < pDir->word_00001E )
1320 return 4;
1321 }
1322 else
1323 bRewrite_data = true;
1324 break;
1325 }
1326 if ( a4 == 2 )
1327 return 4;
1328 }
1329 else if ( comp_res > 0 )
1330 {
1331 if ( insert_index == -1 )
1332 {
1333 insert_index=i;
1334 break;
1335 }
1336 }
1337 }
1338 strcpy(Filename, "lod.tmp");
1339 tmp_file = fopen(Filename, "wb+");
1340 if ( !tmp_file )
1341 return 5;
1342 if (!bRewrite_data)
1343 size_correction = 0;
1344 else
1345 size_correction = pSubIndices[insert_index].uDataSize;
1346
1347 //create chapter index
1348 LOD::Directory Lindx;
1349 strcpy(Lindx.pFilename, "chapter");
1350 Lindx.dword_000018 = 0;
1351 Lindx.word_00001E = 0;
1352 Lindx.uNumSubIndices = uNumSubDirs;
1353 Lindx.uOfsetFromSubindicesStart = sizeof(LOD::FileHeader) + sizeof(LOD::Directory);
1354 total_data_size = uLODDataSize + pDir->uDataSize-size_correction;
1355 if (!bRewrite_data)
1356 {
1357 total_data_size += sizeof(LOD::Directory);
1358 Lindx.uNumSubIndices++;
1359 }
1360
1361 Lindx.uDataSize = total_data_size;
1362 uNumSubDirs = Lindx.uNumSubIndices;
1363 //move indexes +1 after insert point
1364 if ( !bRewrite_data && (insert_index < uNumSubDirs) )//ïåðåçàïèñûâàíèå ôàéëîâ äëÿ îñâîáîæäåíèÿ ìåñòà äëÿ íîâîãî ô-ëà
1365 {
1366 for( int i = uNumSubDirs; i > insert_index; --i )
1367 memcpy(&pSubIndices[i], &pSubIndices[i - 1], sizeof(LOD::Directory)); //Uninitialized memory access
1368 }
1369 //insert
1370 memcpy(&pSubIndices[insert_index], pDir, sizeof(LOD::Directory));//çàïèñàòü òåêóùèé ôàéë
1371 //correct offsets to data
1372 if (uNumSubDirs > 0)
1373 {
1374 offset_to_data = sizeof(LOD::Directory) * uNumSubDirs;
1375 for ( int i = 0; i < uNumSubDirs; i++ )
1376 {
1377 pSubIndices[i].uOfsetFromSubindicesStart = offset_to_data;
1378 offset_to_data += pSubIndices[i].uDataSize;
1379 }
1380 }
1381
1382 //construct lod file with added data
1383 fwrite(&header, sizeof(LOD::FileHeader), 1, tmp_file);
1384 fwrite(&Lindx, sizeof(LOD::Directory), 1, tmp_file);
1385 fseek(pFile,Lindx.uOfsetFromSubindicesStart, SEEK_SET);
1386 fwrite(pSubIndices, sizeof(LOD::Directory), uNumSubDirs, tmp_file);
1387
1388 offset_to_data = sizeof(LOD::Directory) * uNumSubDirs;
1389 if ( !bRewrite_data )
1390 offset_to_data -= sizeof(LOD::Directory);
1391
1392 fseek(pFile, offset_to_data, SEEK_CUR);
1393 //copy from open lod to temp lod first half
1394 to_copy_size = pSubIndices[insert_index].uOfsetFromSubindicesStart - pSubIndices[0].uOfsetFromSubindicesStart;
1395 while(to_copy_size > 0)
1396 {
1397 read_size = uIOBufferSize;
1398 if ( to_copy_size <= uIOBufferSize )
1399 read_size = to_copy_size;
1400 fread(pIOBuffer, 1, read_size, pFile);
1401 fwrite(pIOBuffer, 1, read_size, tmp_file);
1402 to_copy_size -= read_size;
1403 }
1404 // add container data
1405 fwrite(pDirData, 1, pDir->uDataSize, tmp_file);// Uninitialized memory access(tmp_file)
1406 if ( bRewrite_data )
1407 fseek(pFile,size_correction , SEEK_CUR);
1408
1409 //add remainng data last half
1410 curr_position = ftell(pFile);
1411 fseek(pFile, 0, SEEK_END);
1412 to_copy_size = ftell(pFile) - curr_position;
1413 fseek(pFile, curr_position, SEEK_SET);
1414 while ( to_copy_size > 0 )
1415 {
1416 read_size = uIOBufferSize;
1417 if ( to_copy_size <= uIOBufferSize )
1418 read_size = to_copy_size;
1419 fread(pIOBuffer, 1, read_size, pFile);
1420 fwrite(pIOBuffer, 1, read_size, tmp_file);
1421 to_copy_size -= read_size;
1422 }
1423 //replace old file by new with added data
1424 strcpy(NewFilename, (const char *)&pLODName);
1425 fclose(tmp_file);
1426 fclose(pFile);
1427 CloseWriteFile();
1428 remove(NewFilename);
1429 rename(Filename, NewFilename);
1430 CloseWriteFile();
1431 //reload new
1432 LoadFile((const char *)&pLODName, 0);//isFileOpened == true, next file
1433 return 0;
1434 }
1435
1436 //----- (00461A43) --------------------------------------------------------
1437 bool LODWriteableFile::LoadFile(const char *pFilename, bool bWriting)
1438 {
1439 if (bWriting & 1)
1440 pFile = fopen(pFilename, "rb");
1441 else
1442 pFile = fopen(pFilename, "rb+");
1443 if (!pFile)
1444 {
1445 __debugbreak();
1446 return false;// âîçìîæíî ôàéë íå çàêðûò, ïîýòîìó íå îòêðûâàåòñÿ
1447 }
1448
1449 strcpy(pLODName, pFilename);
1450 fread(&header, sizeof(LOD::FileHeader), 1, pFile);
1451
1452 LOD::Directory lod_indx;
1453 fread( &lod_indx,sizeof(LOD::Directory), 1, pFile);
1454
1455 fseek(pFile, 0, SEEK_SET);
1456 isFileOpened = true;
1457 strcpy(pContainerName, "chapter");
1458 uCurrentIndexDir = 0;
1459 uLODDataSize = lod_indx.uDataSize;
1460 uNumSubDirs = lod_indx.uNumSubIndices;
1461 Assert(uNumSubDirs <= 300);
1462
1463 uOffsetToSubIndex = lod_indx.uOfsetFromSubindicesStart;
1464 fseek(pFile, uOffsetToSubIndex, SEEK_SET);
1465
1466 fread(pSubIndices, sizeof(LOD::Directory), uNumSubDirs, pFile);
1467 return true;
1468 }
1469
1470 //----- (00461A11) --------------------------------------------------------
1471 void LOD::File::FreeSubIndexAndIO()
1472 {
1473 free(pSubIndices);
1474 free(pIOBuffer);// delete [] pIOBuffer;
1475 pIOBuffer = nullptr;
1476 pSubIndices = nullptr;
1477 }
1478
1479 //----- (00461954) --------------------------------------------------------
1480 void LOD::File::AllocSubIndicesAndIO(unsigned int uNumSubIndices, unsigned int uBufferSize)
1481 {
1482 if (pSubIndices)
1483 {
1484 MessageBoxA(0, "Attempt to reset a LOD subindex!", "MM6", MB_ICONEXCLAMATION);
1485 free(pSubIndices);
1486 pSubIndices = nullptr;
1487 }
1488 pSubIndices =(LOD::Directory *)malloc(32 * uNumSubIndices);
1489 if (pIOBuffer)
1490 {
1491 MessageBoxA(0, "Attempt to reset a LOD IObuffer!", "MM6", MB_ICONEXCLAMATION);
1492 free(pIOBuffer);
1493 pIOBuffer = nullptr;
1494 uIOBufferSize = 0;
1495 }
1496 if ( uBufferSize )
1497 {
1498 pIOBuffer = (unsigned __int8 *)malloc(uBufferSize);
1499 uIOBufferSize = uBufferSize;
1500 }
1501 }
1502
1503 //----- (0046188A) --------------------------------------------------------
1504 int LOD::File::LoadSubIndices(const char *pContainer)
1505 {
1506 unsigned int uDir; // edi@1
1507 LOD::Directory *curr_index; // eax@7
1508
1509 ResetSubIndices();
1510 uDir = 0;
1511
1512 for (uDir=0; uDir <header.uNumIndices;++uDir)
1513 {
1514 if (!_stricmp(pContainer, pRoot[uDir].pFilename))
1515 {
1516 strcpy(pContainerName, pContainer);
1517 uCurrentIndexDir = uDir;
1518 curr_index = (LOD::Directory *)&pRoot[uDir];
1519 uOffsetToSubIndex = curr_index->uOfsetFromSubindicesStart ;
1520 uNumSubDirs = curr_index->uNumSubIndices;// *(_WORD *)(v8 + 28);
1521 fseek( pFile, uOffsetToSubIndex, SEEK_SET);
1522 pSubIndices = (LOD::Directory *)malloc(sizeof(LOD::Directory)*(uNumSubDirs + 5));
1523
1524 if ( pSubIndices)
1525 fread( pSubIndices, sizeof(LOD::Directory), uNumSubDirs, pFile);
1526 return 0;
1527 }
1528 }
1529 return 3;
1530 }
1531
1532 //----- (004617D5) --------------------------------------------------------
1533 bool LOD::File::LoadHeader(const char *pFilename, bool bWriting)
1534 {
1535 const char *v6; // [sp-4h] [bp-Ch]@4
1536
1537 if ( this->isFileOpened )
1538 Close();
1539 if ( bWriting & 1 )
1540 v6 = "rb";
1541 else
1542 v6 = "rb+";
1543
1544 pFile = fopen(pFilename, v6);
1545 if ( pFile )
1546 {
1547 strcpy(pLODName, pFilename);
1548 fread(&header, sizeof(LOD::FileHeader), 1, pFile);
1549 pRoot = (LOD::Directory *)malloc(160);
1550 if ( pRoot )
1551 {
1552 fread(pRoot, sizeof(LOD::Directory), header.uNumIndices, pFile);
1553 fseek(pFile, 0, SEEK_SET);
1554 isFileOpened = true;
1555 return false;
1556 }
1557 else
1558 {
1559 fclose(pFile);
1560 return true;
1561 }
1562 }
1563 return true;
1564 }
1565
1566 //----- (00461790) --------------------------------------------------------
1567 LOD::File::~File()
1568 {
1569 if ( this->isFileOpened )
1570 {
1571 fclose(this->pFile);
1572 free(this->pSubIndices);
1573 }
1574 }
1575
1576 //----- (0046175B) --------------------------------------------------------
1577 LOD::File::File():
1578 pRoot(nullptr),
1579 isFileOpened(false)
1580 {
1581 memset(pLODName, 0, 256);
1582 memset(pContainerName, 0, 16);
1583 this->pFile = nullptr;
1584 this->pSubIndices = nullptr;
1585 this->pIOBuffer = nullptr;
1586 this->isFileOpened = false;
1587 this->uIOBufferSize = 0;
1588 Close();
1589 }
1590
1591 //----- (0046172B) --------------------------------------------------------
1592 LOD::Directory::Directory()
1593 {
1594 memset(pFilename, 0, 16);
1595 this->pFilename[0] = 0;
1596 this->uOfsetFromSubindicesStart = 0;
1597 this->uDataSize = 0;
1598 this->uNumSubIndices = 0;
1599 this->dword_000018 = 0;
1600 this->word_00001E = 0;
1601 }
1602
1603 //----- (0046165E) --------------------------------------------------------
1604 int LOD::File::CalcIndexFast(int startIndex, int maxIndex, const char *pContainerName)
1605 {
1606 int pCurrent_position; // esi@1
1607 int v5; // ebx@2
1608 int result; // eax@2
1609
1610 pCurrent_position = startIndex;
1611 while ( 1 ) // binary search in LOD indices
1612 {
1613
1614 while ( 1 )
1615 {
1616 v5 = maxIndex - pCurrent_position;
1617 result = _stricmp(pContainerName, (const char *)(&this->pSubIndices[(maxIndex - pCurrent_position) / 2] + pCurrent_position));
1618 if ( !_stricmp(pContainerName, (const char *)(&this->pSubIndices[(maxIndex - pCurrent_position) / 2] + pCurrent_position)) )
1619 _6A0CA4_lod_binary_search = (maxIndex - pCurrent_position) / 2 + pCurrent_position;
1620 if ( pCurrent_position == maxIndex )
1621 {
1622 _6A0CA4_lod_binary_search = -1;
1623 return result;
1624 }
1625 if ( result < 0 )//ïåðâàÿ ñòðîêà ìåíüøå âòîðîé
1626 break;
1627 if ( v5 <= 4 )
1628 {
1629 for ( int i = pCurrent_position; i < maxIndex; ++i )
1630 {
1631 result = _stricmp(pContainerName, this->pSubIndices[i].pFilename);
1632 if ( !_stricmp(pContainerName, this->pSubIndices[i].pFilename) )
1633 {
1634 _6A0CA4_lod_binary_search = i;
1635 return 0;//ñòðîêè ðîâíû
1636 }
1637 }
1638 _6A0CA4_lod_binary_search = -1;
1639 return result;
1640 }
1641 pCurrent_position += (maxIndex - pCurrent_position) / 2;
1642 }
1643
1644 if ( v5 <= 4 )
1645 break;
1646 maxIndex = (maxIndex - pCurrent_position) / 2 + pCurrent_position;
1647 }
1648
1649 for (int i = pCurrent_position; i < maxIndex; ++i)
1650 {
1651 result = _stricmp(pContainerName, this->pSubIndices[i].pFilename);
1652 if ( !_stricmp(pContainerName, this->pSubIndices[i].pFilename) )
1653 {
1654 _6A0CA4_lod_binary_search = i;
1655 return 0;
1656 }
1657 }
1658 _6A0CA4_lod_binary_search = -1;
1659 return result;
1660 }
1661 // 6A0CA4: using guessed type int _6A0CA4_lod_binary_search;
1662
1663 //----- (0046161C) --------------------------------------------------------
1664 bool LOD::File::DoesContainerExist(const char *pContainer)
1665 {
1666 for ( int i = 0; i < (signed int)this->uNumSubDirs; ++i )
1667 {
1668 if ( !_stricmp(pContainer, this->pSubIndices[i].pFilename) )
1669 return 1;
1670 }
1671 return 0;
1672 }
1673
1674 //----- (00461397) --------------------------------------------------------
1675 int LODFile_Sprites::_461397()
1676 {
1677 this->field_ECA8 = this->uNumLoadedSprites;
1678 if ( this->uNumLoadedSprites < this->field_ECA0 )
1679 this->field_ECA8 = this->field_ECA0;
1680 if ( this->field_ECA0 < this->field_ECA4 )
1681 field_ECA0 = this->field_ECA4;
1682 return this->uNumLoadedSprites;
1683 }
1684
1685 //----- (00461580) --------------------------------------------------------
1686 FILE *LOD::File::FindContainer(const char *pContainer_Name, bool bLinearSearch)
1687 {
1688 if (!isFileOpened)
1689 return 0;
1690
1691 if (bLinearSearch)
1692 {
1693 for (uint i = 0; i < uNumSubDirs; ++i)
1694 if (!_stricmp(pContainer_Name, pSubIndices[i].pFilename))
1695 {
1696 fseek(pFile, uOffsetToSubIndex + pSubIndices[i].uOfsetFromSubindicesStart, SEEK_SET);
1697 return pFile;
1698 }
1699 return nullptr;
1700 }
1701 else
1702 {
1703 CalcIndexFast(0, uNumSubDirs, pContainer_Name);
1704 if ( _6A0CA4_lod_binary_search < 0 )
1705 return 0;
1706 fseek(pFile, uOffsetToSubIndex + pSubIndices[_6A0CA4_lod_binary_search].uOfsetFromSubindicesStart, SEEK_SET);
1707 return pFile;
1708 }
1709 }
1710
1711 //----- (0041097D) --------------------------------------------------------
1712 void LODFile_IconsBitmaps::SetupPalettes(unsigned int uTargetRBits, unsigned int uTargetGBits, unsigned int uTargetBBits)
1713 {
1714 FILE *File; // [sp+50h] [bp-4h]@7
1715
1716 if ( this->uTextureRedBits != uTargetRBits
1717 || this->uTextureGreenBits != uTargetGBits
1718 || this->uTextureBlueBits != uTargetBBits ) //Uninitialized memory access
1719 {
1720 this->uTextureRedBits = uTargetRBits;
1721 this->uTextureGreenBits = uTargetGBits;
1722 this->uTextureBlueBits = uTargetBBits;
1723 for ( uint i = 0; i < this->uNumLoadedFiles; ++i )
1724 {
1725 Texture DstBuf; // [sp+4h] [bp-50h]@6
1726 //Texture::Texture(&DstBuf);
1727 if ( this->pTextures[i].pPalette16 )
1728 {
1729 File = FindContainer((const char *)this->pTextures[i].pName, 0);
1730 if ( File )
1731 {
1732 fread(&DstBuf, 1, 0x30u, File);
1733 fseek(File, DstBuf.uTextureSize, 1);
1734 for ( uint j = 0; j < 256; ++j )
1735 {
1736 fread((char *)&uTargetRBits + 3, 1, 1, File);
1737 fread((char *)&uTargetGBits + 3, 1, 1, File);
1738 fread((char *)&uTargetBBits + 3, 1, 1, File);
1739 this->pTextures[i].pPalette16[j] = (BYTE3(uTargetRBits) >> (8 - LOBYTE(this->uTextureRedBits)))
1740 << (LOBYTE(this->uTextureGreenBits) + LOBYTE(this->uTextureBlueBits));
1741 this->pTextures[i].pPalette16[j] |= (BYTE3(uTargetGBits) >> (8 - LOBYTE(this->uTextureGreenBits)))
1742 << this->uTextureBlueBits;
1743 this->pTextures[i].pPalette16[j] |= BYTE3(uTargetBBits) >> (8 - LOBYTE(this->uTextureBlueBits));
1744 }
1745 }
1746 }
1747 }
1748 }
1749 }
1750
1751 //----- (0041088B) --------------------------------------------------------
1752 void *LOD::File::LoadRaw(const char *pContainer, int a3)
1753 {
1754 FILE *File; // eax@1
1755 void *v7; // ebx@7
1756 void *v8; // edi@7
1757 Texture DstBuf; // [sp+Ch] [bp-4Ch]@1
1758
1759 File = FindContainer(pContainer, 0);
1760 if ( !File )
1761 Error("Unable to load %s", pContainer);
1762
1763 fread(&DstBuf, 1, 0x30u, File);
1764 if ( DstBuf.uDecompressedSize )
1765 {
1766 if ( a3 )
1767 v7 = malloc(DstBuf.uDecompressedSize+1);
1768 else
1769 v7 = malloc(DstBuf.uDecompressedSize+1);
1770 v8 = malloc(DstBuf.uTextureSize+1);
1771 fread(v8, 1, DstBuf.uTextureSize, File);
1772 zlib::MemUnzip(v7, &DstBuf.uDecompressedSize, v8, DstBuf.uTextureSize);
1773 DstBuf.uTextureSize = DstBuf.uDecompressedSize;
1774 free(v8);
1775 }
1776 else
1777 {
1778 if ( a3 )
1779 v7 = malloc(DstBuf.uTextureSize+1);
1780 else
1781 v7 = malloc(DstBuf.uTextureSize+1);
1782 fread(v7, 1, DstBuf.uTextureSize, File);
1783 }
1784 return v7;
1785 }
1786
1787 //----- (00410522) --------------------------------------------------------
1788 int LODFile_IconsBitmaps::_410522(Texture *pDst, const char *pContainer, unsigned int uTextureType)
1789 {
1790 void *v9; // ST2C_4@6
1791 int v15; // ecx@12
1792 int v16; // ecx@12
1793 int v17; // eax@12
1794 signed int v21; // ecx@18
1795 signed int v22; // ecx@23
1796 FILE *File; // [sp+68h] [bp-4h]@1
1797 unsigned int uTargetRBits;
1798 unsigned int uTargetGBits;
1799 unsigned int uTargetBBits;
1800
1801 File = FindContainer(pContainer, 0);
1802 if ( !File )
1803 {
1804 File = FindContainer("pending", 0);
1805 if ( !File )
1806 Error("Can't find %s!", pContainer);
1807 }
1808
1809 fread(pDst, 1, 0x30u, File);
1810 strcpy(pDst->pName, pContainer);
1811 pDst->pLevelOfDetail0_prolly_alpha_mask = 0;
1812 if ( pDst->uDecompressedSize )
1813 {
1814 pDst->pLevelOfDetail0_prolly_alpha_mask = (unsigned __int8 *)malloc(pDst->uDecompressedSize);
1815 v9 = malloc(pDst->uTextureSize);
1816 fread((void *)v9, 1, (size_t)pDst->uTextureSize, File);
1817 zlib::MemUnzip(pDst->pLevelOfDetail0_prolly_alpha_mask, &pDst->uDecompressedSize, v9, pDst->uTextureSize);
1818 pDst->uTextureSize = pDst->uDecompressedSize;
1819 free(v9);
1820 }
1821 else
1822 {
1823 pDst->pLevelOfDetail0_prolly_alpha_mask = (unsigned __int8 *)malloc(0);
1824 fread(pDst->pLevelOfDetail0_prolly_alpha_mask, 1, (size_t)pDst->uTextureSize, File);
1825 }
1826 pDst->pPalette16 = 0;
1827 pDst->pPalette24 = 0;
1828 if ( uTextureType == 1 )
1829 {
1830 pDst->pPalette24 = (unsigned __int8 *)malloc(0x300u);
1831 fread(pDst->pPalette24, 1, 0x300u, File);
1832 }
1833 else if ( uTextureType == 2 )
1834 {
1835 pDst->pPalette16 = (unsigned __int16 *)malloc(0x400u);
1836 for ( uint i = 0; i < 256; ++i )
1837 {
1838 fread((char *)&uTargetRBits + 3, 1, 1, File);
1839 fread((char *)&uTargetGBits + 3, 1, 1, File);
1840 fread((char *)&uTargetBBits + 3, 1, 1, File);
1841 pDst->pPalette16[i] = (unsigned __int8)(BYTE3(uTargetRBits) >> (8 - LOBYTE(this->uTextureRedBits)))
1842 << (LOBYTE(this->uTextureBlueBits) + LOBYTE(this->uTextureGreenBits));
1843 pDst->pPalette16[i] += (unsigned __int8)(BYTE3(uTargetGBits) >> (8 - LOBYTE(this->uTextureGreenBits)))
1844 << this->uTextureBlueBits;
1845 pDst->pPalette16[i] += (unsigned __int8)(BYTE3(uTargetBBits) >> (8 - LOBYTE(this->uTextureBlueBits)));
1846 }
1847 }
1848
1849 if ( pDst->pBits & 2 )
1850 {
1851 v15 = (int)&pDst->pLevelOfDetail0_prolly_alpha_mask[pDst->uSizeOfMaxLevelOfDetail];
1852 pDst->pLevelOfDetail1 = (unsigned __int8 *)v15;
1853 v16 = (pDst->uSizeOfMaxLevelOfDetail >> 2) + v15;
1854 pDst->pLevelOfDetail2 = (unsigned __int8 *)v16;
1855 v17 = v16 + (pDst->uSizeOfMaxLevelOfDetail >> 4);
1856 }
1857 else
1858 {
1859 v17 = 0;
1860 pDst->pLevelOfDetail2 = 0;
1861 pDst->pLevelOfDetail1 = 0;
1862 }
1863 pDst->pLevelOfDetail3 = (unsigned __int8 *)v17;
1864 v21 = 1;
1865 while ( 1 << v21 != pDst->uTextureWidth )
1866 {
1867 ++v21;
1868 if ( v21 >= 15 )
1869 goto LABEL_23;
1870 }
1871 pDst->uWidthLn2 = v21;
1872 LABEL_23:
1873 v22 = 1;
1874 while ( 1 << v22 != pDst->uTextureHeight )
1875 {
1876 ++v22;
1877 if ( v22 >= 15 )
1878 goto LABEL_28;
1879 }
1880 pDst->uHeightLn2 = v22;
1881 LABEL_28:
1882 switch ( pDst->uWidthLn2 )
1883 {
1884 case 2:
1885 pDst->uWidthMinus1 = 3;
1886 break;
1887 case 3:
1888 pDst->uWidthMinus1 = 7;
1889 break;
1890 case 4:
1891 pDst->uWidthMinus1 = 15;
1892 break;
1893 case 5:
1894 pDst->uWidthMinus1 = 31;
1895 break;
1896 case 6:
1897 pDst->uWidthMinus1 = 63;
1898 break;
1899 case 7:
1900 pDst->uWidthMinus1 = 127;
1901 break;
1902 case 8:
1903 pDst->uWidthMinus1 = 255;
1904 break;
1905 case 9:
1906 pDst->uWidthMinus1 = 511;
1907 break;
1908 case 10:
1909 pDst->uWidthMinus1 = 1023;
1910 break;
1911 case 11:
1912 pDst->uWidthMinus1 = 2047;
1913 break;
1914 case 12:
1915 pDst->uWidthMinus1 = 4095;
1916 break;
1917 default:
1918 break;
1919 }
1920 switch ( pDst->uHeightLn2 )
1921 {
1922 case 2:
1923 pDst->uHeightMinus1 = 3;
1924 break;
1925 case 3:
1926 pDst->uHeightMinus1 = 7;
1927 break;
1928 case 4:
1929 pDst->uHeightMinus1 = 15;
1930 break;
1931 case 5:
1932 pDst->uHeightMinus1 = 31;
1933 break;
1934 case 6:
1935 pDst->uHeightMinus1 = 63;
1936 break;
1937 case 7:
1938 pDst->uHeightMinus1 = 127;
1939 break;
1940 case 8:
1941 pDst->uHeightMinus1 = 255;
1942 break;
1943 case 9:
1944 pDst->uHeightMinus1 = 511;
1945 break;
1946 case 10:
1947 pDst->uHeightMinus1 = 1023;
1948 break;
1949 case 11:
1950 pDst->uHeightMinus1 = 2047;
1951 break;
1952 case 12:
1953 pDst->uHeightMinus1 = 4095;
1954 break;
1955 default:
1956 return 1;
1957 }
1958 return 1;
1959 }
1960
1961 //----- (00410423) --------------------------------------------------------
1962 void LODFile_IconsBitmaps::_410423_move_textures_to_device()
1963 {
1964 size_t v4; // eax@9
1965 char *v5; // ST1C_4@9
1966
1967 for ( uint i = 0; i < this->uNumLoadedFiles; i++ )
1968 {
1969 if ( this->ptr_011BB4[i] )
1970 {
1971 if ( this->pTextures[i].pName[0] != 'w' || this->pTextures[i].pName[1] != 't'
1972 || this->pTextures[i].pName[2] != 'r' || this->pTextures[i].pName[3] != 'd' || this->pTextures[i].pName[4] != 'r' )
1973 pRenderer->LoadTexture(&this->pTextures[i].pName[0], this->pTextures[i].uTextureSize, (IDirectDrawSurface4 **)&this->pHardwareSurfaces[i],
1974 &this->pHardwareTextures[i]);
1975 else
1976 {
1977 v4 = strlen(&this->pTextures[i].pName[0]);
1978 v5 = (char *)malloc(v4 + 2);
1979 *v5 = 'h';
1980 strcpy(v5 + 1, &this->pTextures[i].pName[0]);
1981 pRenderer->LoadTexture(v5, this->pTextures[i].uTextureSize, (IDirectDrawSurface4 **)&this->pHardwareSurfaces[i], &this->pHardwareTextures[i]);
1982 free(v5);
1983 }
1984 }
1985 }
1986 if ( this->ptr_011BB4 )
1987 {
1988 if ( this->uNumLoadedFiles > 1 )
1989 memset(this->ptr_011BB4, 0, this->uNumLoadedFiles - 1);
1990 }
1991 }
1992
1993 //----- (004103BB) --------------------------------------------------------
1994 void LODFile_IconsBitmaps::ReleaseHardwareTextures()
1995 {
1996 for ( uint i = 0; i < this->uNumLoadedFiles; i++ )
1997 {
1998 if ( this->pHardwareTextures )
1999 {
2000 if ( this->pHardwareTextures[i] )
2001 {
2002 this->pHardwareTextures[i]->Release();
2003 this->pHardwareTextures[i] = 0;
2004 this->ptr_011BB4[i] = 1;
2005 }
2006 }
2007 if ( this->pHardwareSurfaces )
2008 {
2009 if ( this->pHardwareSurfaces[i] )
2010 {
2011 this->pHardwareSurfaces[i]->Release();
2012 this->pHardwareSurfaces[i] = 0;
2013 this->ptr_011BB4[i] = 1;
2014 }
2015 }
2016 }
2017 }
2018
2019 //----- (0041033D) --------------------------------------------------------
2020 void LODFile_IconsBitmaps::ReleaseLostHardwareTextures()
2021 {
2022 for ( uint i = 0; i < this->uNumLoadedFiles; ++i )
2023 {
2024 if ( this->pHardwareSurfaces )
2025 {
2026 if ( this->pHardwareSurfaces[i] )
2027 {
2028 if ( this->pHardwareSurfaces[i]->IsLost() == DDERR_SURFACELOST )
2029 {
2030 if ( this->pHardwareTextures )
2031 {
2032 if ( this->pHardwareTextures[i] )
2033 {
2034 this->pHardwareTextures[i]->Release();
2035 this->pHardwareTextures[i] = 0;
2036 }
2037 }
2038 this->pHardwareSurfaces[i]->Release();
2039 this->pHardwareSurfaces[i] = 0;
2040 this->ptr_011BB4[i] = 1;
2041 }
2042 }
2043 }
2044 }
2045 }
2046
2047 //----- (004101B1) --------------------------------------------------------
2048 int LODFile_IconsBitmaps::ReloadTexture(Texture *pDst, const char *pContainer, int mode)
2049 {
2050 Texture *v6; // esi@2
2051 unsigned int v7; // ebx@6
2052 unsigned int v8; // ecx@6
2053 signed int result; // eax@7
2054 FILE *File; // [sp+Ch] [bp-8h]@1
2055 unsigned __int8 v15; // [sp+11h] [bp-3h]@13
2056 unsigned __int8 v16; // [sp+12h] [bp-2h]@13
2057 unsigned __int8 DstBuf; // [sp+13h] [bp-1h]@13
2058 void *DstBufa; // [sp+1Ch] [bp+8h]@10
2059 void *Sourcea; // [sp+20h] [bp+Ch]@10
2060
2061 File = FindContainer(pContainer, 0);
2062 v6 = pDst;
2063 if ( File && pDst->pLevelOfDetail0_prolly_alpha_mask
2064 && mode == 2
2065 && pDst->pPalette16 && !pDst->pPalette24
2066 && (v7 = pDst->uTextureSize,
2067 fread(pDst, 1, 0x30u, File),
2068 strcpy(pDst->pName, pContainer),
2069 v8 = pDst->uTextureSize,
2070 (signed int)v8 <= (signed int)v7) )
2071 {
2072 if ( !pDst->uDecompressedSize || this->dword_011BA4 )
2073 {
2074 fread(pDst->pLevelOfDetail0_prolly_alpha_mask, 1, pDst->uTextureSize, File);
2075 }
2076 else
2077 {
2078 Sourcea = malloc(pDst->uDecompressedSize);
2079 DstBufa = malloc(pDst->uTextureSize);
2080 fread(DstBufa, 1, pDst->uTextureSize, File);
2081 zlib::MemUnzip(Sourcea, &v6->uDecompressedSize, DstBufa, v6->uTextureSize);
2082 v6->uTextureSize = pDst->uDecompressedSize;
2083 free(DstBufa);
2084 memcpy(v6->pLevelOfDetail0_prolly_alpha_mask, Sourcea, pDst->uDecompressedSize);
2085 free(Sourcea);
2086 }
2087 for( uint i = 0; i < 256; ++i )
2088 {
2089 fread(&DstBuf, 1, 1, File);
2090 fread(&v16, 1, 1, File);
2091 fread(&v15, 1, 1, File);
2092 v6->pPalette16[i] = (unsigned __int8)(DstBuf >> (8 - LOBYTE(this->uTextureRedBits)))
2093 << (LOBYTE(this->uTextureBlueBits) + LOBYTE(this->uTextureGreenBits));
2094 v6->pPalette16[i] += (unsigned __int8)(v16 >> (8 - LOBYTE(this->uTextureGreenBits)))
2095 << this->uTextureBlueBits;
2096 v6->pPalette16[i] += (unsigned __int8)(v15 >> (8 - LOBYTE(this->uTextureBlueBits)));
2097 }
2098 result = 1;
2099 }
2100 else
2101 result = -1;
2102 return result;
2103 }
2104
2105 //----- (0040FC08) --------------------------------------------------------
2106 int LODFile_IconsBitmaps::LoadTextureFromLOD(Texture *pOutTex, const char *pContainer, enum TEXTURE_TYPE eTextureType)
2107 {
2108 Texture *v8; // esi@3
2109 enum TEXTURE_TYPE v12; // eax@14
2110 signed int result; // esi@14
2111 unsigned int v14; // eax@21
2112 void *v19; // ST3C_4@27
2113 size_t v22; // ST2C_4@29
2114 const void *v23; // ecx@29
2115 void *v30; // eax@30
2116 signed int v41; // ecx@43
2117 signed int v42; // ecx@48
2118
2119 FILE* pFile = FindContainer(pContainer, false);
2120 if (!pFile)
2121 return -1;
2122 v8 = pOutTex;
2123 fread(pOutTex, 1, 0x30, pFile);
2124 strcpy(pOutTex->pName, pContainer);
2125 if (/*pRenderer->pRenderD3D &&*/ (pOutTex->pBits & 2) && strcmp(v8->pName, "sptext01"))//Ritor1: "&& strcmp(v8->pName, "sptext01")" - temporarily for red_aura
2126 {
2127 if (!pHardwareSurfaces || !pHardwareTextures)
2128 {
2129 pHardwareSurfaces = new IDirectDrawSurface *[1000];
2130 memset(pHardwareSurfaces, 0, 1000 * sizeof(IDirectDrawSurface4 *));
2131
2132 pHardwareTextures = new IDirect3DTexture2 *[1000];
2133 memset(pHardwareTextures, 0, 1000 * sizeof(IDirect3DTexture2 *));
2134
2135 ptr_011BB4 = new char[1000];
2136 memset(ptr_011BB4, 0, 1000);
2137 }
2138 if (_strnicmp(pContainer, "wtrdr", 5))
2139 {
2140 if (_strnicmp(pContainer, "WtrTyl", 6))
2141 v14 = uNumLoadedFiles;
2142 else
2143 {
2144 pRenderer->hd_water_tile_id = uNumLoadedFiles;
2145 v14 = uNumLoadedFiles;
2146 }
2147 result = pRenderer->LoadTexture(pContainer, pOutTex->palette_id1, (IDirectDrawSurface4 **)&pHardwareSurfaces[v14], &pHardwareTextures[v14]);
2148 }
2149 else
2150 {
2151 char *temp_container;
2152 temp_container = (char *)malloc(strlen(pContainer) + 2);
2153 *temp_container = 104;//'h'
2154 strcpy(temp_container + 1, pContainer);
2155 result = pRenderer->LoadTexture((const char *)temp_container, pOutTex->palette_id1,
2156 (IDirectDrawSurface4 **)&pHardwareSurfaces[uNumLoadedFiles], &pHardwareTextures[uNumLoadedFiles]);
2157 free((void *)temp_container);
2158 }
2159 return result;
2160 }
2161 if ( !v8->uDecompressedSize || dword_011BA4 )
2162 {
2163 v8->pLevelOfDetail0_prolly_alpha_mask = (unsigned __int8 *)malloc(v8->uTextureSize);
2164 fread(v8->pLevelOfDetail0_prolly_alpha_mask, 1, (size_t)v8->uTextureSize, pFile);
2165 }
2166 else
2167 {
2168 pContainer = (const char *)malloc(v8->uDecompressedSize);
2169 v19 = malloc(v8->uTextureSize);
2170 fread(v19, 1, (size_t)v8->uTextureSize, pFile);
2171 zlib::MemUnzip((void *)pContainer, &v8->uDecompressedSize, v19, v8->uTextureSize);
2172 v8->uTextureSize = v8->uDecompressedSize;
2173 free(v19);
2174 if ( /*bUseLoResSprites*/false && v8->pBits & 2 )
2175 {
2176 pOutTex = (Texture *)(((signed int)v8->uSizeOfMaxLevelOfDetail >> 2)
2177 + ((signed int)v8->uSizeOfMaxLevelOfDetail >> 4)
2178 + ((signed int)v8->uSizeOfMaxLevelOfDetail >> 6));
2179 v22 = (size_t)pOutTex;
2180 v23 = &pContainer[v8->uTextureWidth * v8->uTextureHeight];
2181 v8->pLevelOfDetail0_prolly_alpha_mask = (unsigned __int8 *)malloc((unsigned int)pOutTex);
2182 memcpy(v8->pLevelOfDetail0_prolly_alpha_mask, v23, v22);
2183 v8->uTextureWidth = (signed __int16)v8->uTextureWidth / 2;
2184 v8->uTextureHeight = (signed __int16)v8->uTextureHeight / 2;
2185 --v8->uWidthLn2;
2186 --v8->uHeightLn2;
2187 v8->uWidthMinus1 = v8->uTextureWidth - 1;
2188 v8->uHeightMinus1 = v8->uTextureHeight - 1;
2189 v8->uSizeOfMaxLevelOfDetail = (signed __int16)v8->uTextureWidth * (signed __int16)v8->uTextureHeight;
2190 v8->uTextureSize = (unsigned int)pOutTex;
2191 }
2192 else
2193 {
2194 v8->pLevelOfDetail0_prolly_alpha_mask = (unsigned __int8 *)malloc(v8->uDecompressedSize);
2195 memcpy(v8->pLevelOfDetail0_prolly_alpha_mask, pContainer, v8->uDecompressedSize);
2196 }
2197 free((void *)pContainer);
2198 }
2199
2200 free(v8->pPalette16);
2201 v8->pPalette16 = NULL;
2202
2203 free(v8->pPalette24);
2204 v8->pPalette24 = NULL;
2205
2206 if ( eTextureType == TEXTURE_24BIT_PALETTE )
2207 {
2208 v8->pPalette24 = (unsigned __int8 *)malloc(0x300);
2209 fread(v8->pPalette24, 1, 0x300, pFile);
2210 }
2211 else
2212 {
2213 if ( eTextureType == TEXTURE_16BIT_PALETTE )
2214 {
2215 v8->pPalette16 = (unsigned __int16 *)malloc(0x200);
2216 for ( uint i = 0; i < 256; ++i )
2217 {
2218 fread((char *)&eTextureType + 3, 1, 1, pFile);
2219 fread((char *)&pContainer + 3, 1, 1, pFile);
2220 fread((char *)&pOutTex + 3, 1, 1, pFile);
2221 v8->pPalette16[i] = (unsigned __int8)(BYTE3(eTextureType) >> (8 - LOBYTE(this->uTextureRedBits))) //Uninitialized memory access
2222 << (LOBYTE(this->uTextureBlueBits) + LOBYTE(this->uTextureGreenBits));
2223 v8->pPalette16[i] += (unsigned __int8)(BYTE3(pContainer) >> (8 - LOBYTE(this->uTextureGreenBits)))
2224 << this->uTextureBlueBits;
2225 v8->pPalette16[i] += (unsigned __int8)(BYTE3(pOutTex) >> (8 - LOBYTE(this->uTextureBlueBits)));
2226 }
2227 }
2228 }
2229
2230 if ( v8->pBits & 2 )
2231 {
2232 v8->pLevelOfDetail1 = &v8->pLevelOfDetail0_prolly_alpha_mask[v8->uSizeOfMaxLevelOfDetail];
2233 v8->pLevelOfDetail2 = &v8->pLevelOfDetail1[v8->uSizeOfMaxLevelOfDetail >> 2];
2234 v8->pLevelOfDetail3 = &v8->pLevelOfDetail2[v8->uSizeOfMaxLevelOfDetail >> 4];
2235 }
2236 else
2237 {
2238 v8->pLevelOfDetail1 = 0;
2239 v8->pLevelOfDetail2 = 0;
2240 v8->pLevelOfDetail3 = 0;
2241 }
2242 for ( v41 = 1; v41 < 15; ++v41 )
2243 {
2244 if ( 1 << v41 == v8->uTextureWidth )
2245 v8->uWidthLn2 = v41;
2246 }
2247 for ( v42 = 1; v42 < 15; ++v42 )
2248 {
2249 if ( 1 << v42 == v8->uTextureHeight )
2250 v8->uHeightLn2 = v42;
2251 }
2252
2253 switch ( v8->uWidthLn2 )
2254 {
2255 case 2:
2256 v8->uWidthMinus1 = 3;
2257 break;
2258 case 3:
2259 v8->uWidthMinus1 = 7;
2260 break;
2261 case 4:
2262 v8->uWidthMinus1 = 15;
2263 break;
2264 case 5:
2265 v8->uWidthMinus1 = 31;
2266 break;
2267 case 6:
2268 v8->uWidthMinus1 = 63;
2269 break;
2270 case 7:
2271 v8->uWidthMinus1 = 127;
2272 break;
2273 case 8:
2274 v8->uWidthMinus1 = 255;
2275 break;
2276 case 9:
2277 v8->uWidthMinus1 = 511;
2278 break;
2279 case 10:
2280 v8->uWidthMinus1 = 1023;
2281 break;
2282 case 11:
2283 v8->uWidthMinus1 = 2047;
2284 break;
2285 case 12:
2286 v8->uWidthMinus1 = 4095;
2287 break;
2288 default:
2289 break;
2290 }
2291 switch ( v8->uHeightLn2 )
2292 {
2293 case 2:
2294 v8->uHeightMinus1 = 3;
2295 break;
2296 case 3:
2297 v8->uHeightMinus1 = 7;
2298 break;
2299 case 4:
2300 v8->uHeightMinus1 = 15;
2301 break;
2302 case 5:
2303 v8->uHeightMinus1 = 31;
2304 break;
2305 case 6:
2306 v8->uHeightMinus1 = 63;
2307 break;
2308 case 7:
2309 v8->uHeightMinus1 = 127;
2310 break;
2311 case 8:
2312 v8->uHeightMinus1 = 255;
2313 break;
2314 case 9:
2315 v8->uHeightMinus1 = 511;
2316 break;
2317 case 10:
2318 v8->uHeightMinus1 = 1023;
2319 break;
2320 case 11:
2321 v8->uHeightMinus1 = 2047;
2322 break;
2323 case 12:
2324 v8->uHeightMinus1 = 4095;
2325 break;
2326 default:
2327 return 1;
2328 }
2329 return 1;
2330 }
2331
2332 Texture *LODFile_IconsBitmaps::LoadTexturePtr(const char *pContainer, enum TEXTURE_TYPE uTextureType)
2333 {
2334 uint id = LoadTexture(pContainer, uTextureType);
2335
2336 Assert(id != -1 && L"Texture not found");
2337
2338 return &pTextures[id];
2339 }
2340
2341 //----- (0040FB20) --------------------------------------------------------
2342 unsigned int LODFile_IconsBitmaps::LoadTexture(const char *pContainer, enum TEXTURE_TYPE uTextureType)
2343 {
2344 areWeLoadingTexture = 1;
2345
2346 //check loaded texture?
2347 for (uint i = 0; i < uNumLoadedFiles; ++i)
2348 {
2349 if (!_stricmp(pContainer, pTextures[i].pName))
2350 return i;
2351 }
2352
2353 // if (!uNumLoadedFiles)
2354 // {
2355 //LABEL_5:
2356 Assert(uNumLoadedFiles < 1000);
2357 /*if (uNumLoadedFiles >= 1000)
2358 {
2359 Log::Warning(L"Maximum texture number exceeded");
2360 AbortWithError();
2361 }*/
2362 if (LoadTextureFromLOD(&pTextures[uNumLoadedFiles], pContainer, uTextureType) == -1)
2363 {
2364 for ( uint i = 0; i < uNumLoadedFiles; ++i )
2365 {
2366 if (!_stricmp(pTextures[i].pName, "pending"))
2367 return i;
2368 }
2369 LoadTextureFromLOD(&pTextures[uNumLoadedFiles], "pending", uTextureType);
2370 }
2371 areWeLoadingTexture = 0;
2372 ++uNumLoadedFiles;
2373 return uNumLoadedFiles - 1;
2374 // }
2375 // v5 = pTextures;
2376 // while ( _stricmp(v5->pName, pContainer) )
2377 // {
2378 // ++v4;
2379 // ++v5;
2380 // if (v4 >= uNumLoadedFiles )
2381 // goto LABEL_5;
2382 // }
2383 // return v4;
2384 }
2385
2386 Texture * LODFile_IconsBitmaps::GetTexture( int idx )
2387 {
2388 Assert(idx < MAX_LOD_TEXTURES, "Texture index out of bounds (%u)", idx);
2389 if (idx == -1)
2390 {
2391 //Log::Warning(L"Texture id = %d missing", idx);
2392 return pTextures + LoadDummyTexture();
2393 }
2394 return pTextures + idx;
2395 }
2396
2397 //----- (0046082C) --------------------------------------------------------
2398 bool Initialize_GamesLOD_NewLOD()
2399 {
2400 pGames_LOD = new LODWriteableFile;
2401 pGames_LOD->AllocSubIndicesAndIO(300, 0);
2402 if (pGames_LOD->LoadFile("data\\games.lod", 1))
2403 {
2404 pNew_LOD = new LODWriteableFile;
2405 pNew_LOD->AllocSubIndicesAndIO(300, 100000);
2406 return true;
2407 }
2408 return false;
2409 }