Mercurial > mm7

comparison PaletteManager.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 9824e2eeee30
comparison
equal deleted inserted replaced
-1:000000000000 0:9c0607679772
1 #include "PaletteManager.h"
2 #include "Texture.h"
3 #include "Game.h"
4 #include "LOD.h"
5
6 #include "mm7_data.h"
7
8
9
10
11 PaletteManager *pPaletteManager = new PaletteManager;
12
13
14
15
16 //----- (0048A643) --------------------------------------------------------
17 bool __fastcall HSV2RGB(float *a1, float *a2, float *a3, float a4, float a5, float a6)
18 {
19 float *v6; // ebx@1
20 float *v7; // edi@1
21 float *v8; // esi@1
22 double v9; // st7@5
23 signed __int64 v10; // qax@5
24 double v11; // st7@5
25 double v12; // st5@5
26 int v13; // eax@6
27 int v14; // eax@7
28 int v15; // eax@8
29 int v16; // eax@9
30 float v17; // eax@11
31 float a3a; // [sp+1Ch] [bp+8h]@14
32 float a4b; // [sp+20h] [bp+Ch]@5
33 float a4c; // [sp+20h] [bp+Ch]@5
34 float a4a; // [sp+20h] [bp+Ch]@5
35
36 v6 = a3;
37 v7 = a2;
38 v8 = a1;
39 if ( a5 == 0.0 )
40 {
41 *a3 = a6;
42 *a2 = a6;
43 *a1 = a6;
44 goto LABEL_20;
45 }
46 if ( a4 == 360.0 )
47 a4 = 0.0;
48 v9 = a4 * 0.01666666666666667;
49 a4b = v9;
50 floor(v9);
51 v10 = (signed __int64)v9;
52 a4c = a4b - (double)(signed int)(signed __int64)v9;
53 v11 = (1.0 - a5) * a6;
54 v12 = (1.0 - a4c * a5) * a6;
55 a4a = (1.0 - (1.0 - a4c) * a5) * a6;
56 if ( (int)v10 )
57 {
58 v13 = v10 - 1;
59 if ( v13 )
60 {
61 v14 = v13 - 1;
62 if ( v14 )
63 {
64 v15 = v14 - 1;
65 if ( v15 )
66 {
67 v16 = v15 - 1;
68 if ( v16 )
69 {
70 if ( v16 != 1 )
71 goto LABEL_20;
72 *v8 = a6;
73 v17 = v12;
74 *v7 = v11;
75 goto LABEL_12;
76 }
77 *(int *)v8 = LODWORD(a4a);
78 *v7 = v11;
79 }
80 else
81 {
82 *v8 = v11;
83 a3a = v12;
84 *(int *)v7 = LODWORD(a3a);
85 }
86 v17 = a6;
87 }
88 else
89 {
90 *v8 = v11;
91 *(int *)v7 = LODWORD(a6);
92 v17 = a4a;
93 }
94 LABEL_12:
95 *(int *)v6 = LODWORD(v17);
96 goto LABEL_20;
97 }
98 *v8 = v12;
99 *v7 = a6;
100 }
101 else
102 {
103 *v8 = a6;
104 *(int *)v7 = LODWORD(a4a);
105 }
106 *a3 = v11;
107 LABEL_20:
108 if ( *v8 > 1.0 )
109 *v8 = 1.0;
110 if ( *v7 > 1.0 )
111 *v7 = 1.0;
112 if ( *v6 > 1.0 )
113 *v6 = 1.0;
114 if ( *v8 < 0.0 )
115 *v8 = 0.0;
116 if ( *v7 < 0.0 )
117 *v7 = 0.0;
118 if ( *v6 < 0.0 )
119 *v6 = 0.0;
120 return 1;
121 }
122
123 //----- (0048A7AA) --------------------------------------------------------
124 void __fastcall RGB2HSV(float *a1, float *a2, float a3, float a4, float a5, float *a6)
125 {
126 double v6; // st7@2
127 double v7; // st6@7
128 double v8; // st5@12
129 double v9; // st7@15
130 double v10; // st7@17
131 double v11; // st7@21
132 __int16 v12; // fps@21
133 unsigned __int8 v13; // c0@21
134 unsigned __int8 v14; // c2@21
135 float a6a; // [sp+14h] [bp+14h]@16
136
137 if ( a3 <= (double)a4 )
138 v6 = a4;
139 else
140 v6 = a3;
141 if ( v6 < a5 )
142 v6 = a5;
143 if ( a3 <= (double)a4 )
144 v7 = a3;
145 else
146 v7 = a4;
147 if ( v7 > a5 )
148 v7 = a5;
149 *a6 = v6;
150 if ( v6 == 0.0 )
151 v8 = 0.0;
152 else
153 v8 = (v6 - v7) / v6;
154 *a2 = v8;
155 if ( v8 == 0.0 )
156 {
157 v9 = 0.0;
158 LABEL_23:
159 *a1 = v9;
160 return;
161 }
162 a6a = v6 - v7;
163 if ( a3 == v6 )
164 {
165 v10 = (a4 - a5) / a6a;
166 }
167 else
168 {
169 if ( a4 == v6 )
170 v10 = (a5 - a3) / a6a + 2.0;
171 else
172 v10 = (a3 - a4) / a6a + 4.0;
173 }
174 //*a1 = v10;
175 //v11 = *a1 * 60.0;
176 //UNDEF(v12);
177 *a1 = v10 * 60.0;
178 if (*a1 < 0)
179 {
180 *a1 += 360.0;
181 }
182 }
183
184
185
186 //----- (0048A8A3) --------------------------------------------------------
187 int PaletteManager::LockAll()
188 {
189 int *v1; // edx@1
190 signed int v2; // eax@1
191
192 v1 = &this->pPaletteIDs[1];
193 v2 = 1;
194 do
195 {
196 if ( *v1 )
197 this->_num_locked = v2 + 1;
198 ++v2;
199 ++v1;
200 }
201 while ( v2 < 50 );
202 return this->_num_locked;
203 }
204
205 //----- (0048A8CC) --------------------------------------------------------
206 int PaletteManager::LockTestAll()
207 {
208 char *v1; // edx@1
209 signed int v2; // eax@1
210
211 v1 = (char *)&this->pPaletteIDs[1];
212 v2 = 1;
213 do
214 {
215 if ( *(int *)v1 )
216 this->_pal_lock_test = v2 + 1;
217 ++v2;
218 v1 += 4;
219 }
220 while ( v2 < 50 );
221 return this->_pal_lock_test;
222 }
223
224
225 //----- (0048A8F5) --------------------------------------------------------
226 void PaletteManager::SetColorChannelInfo(int uNumRBits, int uNumGBits, int uNumBBits)
227 {
228 PaletteManager *v4; // esi@1
229 int v5; // edi@1
230 int v6; // eax@1
231 int v7; // ebx@1
232
233 v4 = this;
234 this->uNumTargetRBits = uNumRBits;
235 this->uNumTargetGBits = uNumGBits;
236 v5 = this->uNumTargetGBits;
237 this->uNumTargetBBits = uNumBBits;
238 v6 = MakeColorMaskFromBitDepth(uNumRBits);
239 v7 = v4->uNumTargetBBits;
240 v4->uTargetRMask = v6 << (v5 + v4->uNumTargetBBits);
241 v4->uTargetGMask = MakeColorMaskFromBitDepth(v5) << v7;
242 v4->uTargetBMask = MakeColorMaskFromBitDepth(v7);
243 }
244
245
246 //----- (00489BE0) --------------------------------------------------------
247 int PaletteManager::CalcPalettes_LUT(int a2)
248 {
249 PaletteManager *v2; // esi@1
250 char *v3; // edi@1
251 signed int v4; // ebx@4
252 float v5; // ST08_4@5
253 float v6; // ST04_4@5
254 float v7; // ST00_4@5
255 int v8; // eax@7
256 float *v9; // edx@8
257 float *v10; // ST0C_4@8
258 float *v11; // ecx@8
259 int v12; // ebx@8
260 int v13; // eax@8
261 float v14; // ebx@8
262 float v15; // ST08_4@8
263 float v16; // ST04_4@8
264 float v17; // ST00_4@8
265 unsigned __int8 v18; // sf@8
266 unsigned __int8 v19; // of@8
267 int v20; // eax@10
268 double v21; // st5@11
269 float v22; // ST0C_4@13
270 unsigned int v23; // eax@13
271 __int16 v24; // bx@16
272 int v25; // eax@16
273 double v26; // st7@20
274 float v27; // ST0C_4@22
275 unsigned int v28; // eax@22
276 __int16 v29; // bx@25
277 __int16 *v30; // eax@25
278 int v31; // eax@27
279 double v32; // st5@28
280 float v33; // ST0C_4@30
281 float v34; // ST08_4@30
282 unsigned int v35; // ebx@30
283 signed __int64 v36; // qax@33
284 signed int v37; // edx@33
285 char v38; // cl@33
286 unsigned int v39; // ebx@33
287 signed int v40; // edi@33
288 unsigned int v41; // ecx@33
289 unsigned int v42; // ecx@35
290 int v43; // eax@39
291 signed int v44; // edx@39
292 unsigned __int8 v45; // al@40
293 double v46; // st6@43
294 signed int v47; // eax@43
295 int v48; // eax@45
296 double v49; // st6@47
297 float v50; // ST08_4@49
298 unsigned int v51; // ebx@49
299 int v52; // edi@55
300 int v53; // ebx@55
301 signed __int64 v54; // qax@55
302 double v55; // st7@56
303 unsigned int v56; // ecx@57
304 unsigned int v57; // ecx@59
305 //int v58; // edx@61
306 unsigned int v59; // ecx@61
307 unsigned int v60; // eax@63
308 char v61; // cl@63
309 int result; // eax@63
310 float v63[256]; // [sp+1Ch] [bp-C38h]@5
311 float v64[256]; // [sp+41Ch] [bp-838h]@5
312 int a6[256]; // [sp+81Ch] [bp-438h]@5
313 int v66; // [sp+C1Ch] [bp-38h]@43
314 float v67; // [sp+C20h] [bp-34h]@43
315 float v68; // [sp+C24h] [bp-30h]@43
316 PaletteManager *v69; // [sp+C28h] [bp-2Ch]@9
317 float v70; // [sp+C2Ch] [bp-28h]@43
318 double v71; // [sp+C30h] [bp-24h]@10
319 int v72; // [sp+C38h] [bp-1Ch]@9
320 int v73; // [sp+C3Ch] [bp-18h]@9
321 int i; // [sp+C40h] [bp-14h]@7
322 float v75; // [sp+C44h] [bp-10h]@5
323 float a2a; // [sp+C48h] [bp-Ch]@13
324 float a1; // [sp+C4Ch] [bp-8h]@13
325 float a3; // [sp+C50h] [bp-4h]@13
326 signed int v79; // [sp+C5Ch] [bp+8h]@33
327 signed int v80; // [sp+C5Ch] [bp+8h]@43
328 int v81; // [sp+C5Ch] [bp+8h]@57
329
330 v2 = this;
331 v3 = (char *)this + 768 * a2;
332 if (pPalette_tintColor[0] || pPalette_tintColor[1] || pPalette_tintColor[2])
333 {
334 v8 = 0;
335 i = 0;
336 do
337 {
338 v9 = (float *)((char *)v63 + v8);
339 v10 = (float *)((char *)a6 + v8);
340 v11 = (float *)((char *)v64 + v8);
341 v12 = pPalette_tintColor[1];
342 LODWORD(v75) = pPalette_tintColor[2] + (unsigned __int8)v3[2];
343 v13 = v12 + (unsigned __int8)v3[1];
344 LODWORD(v14) = (unsigned __int8)*v3;
345 v15 = (double)SLODWORD(v75) * 0.00196078431372549;
346 LODWORD(v75) = v13;
347 LODWORD(v75) = LODWORD(v14) + pPalette_tintColor[0];
348 v16 = (double)v13 * 0.00196078431372549;
349 v17 = (double)SLODWORD(v75) * 0.00196078431372549;
350 RGB2HSV(v11, v9, v17, v16, v15, v10);
351 v3 += 3;
352 v8 = i + 4;
353 v19 = __OFSUB__(i + 4, 1024);
354 v18 = i - 1020 < 0;
355 i += 4;
356 }
357 while ( v18 ^ v19 );
358 }
359 else
360 {
361 v4 = 0;
362 do
363 {
364 LODWORD(v75) = (unsigned __int8)v3[2];
365 v5 = (double)SLODWORD(v75) * 0.00392156862745098;
366 LODWORD(v75) = (unsigned __int8)v3[1];
367 v6 = (double)SLODWORD(v75) * 0.00392156862745098;
368 LODWORD(v75) = (unsigned __int8)*v3;
369 v7 = (double)SLODWORD(v75) * 0.00392156862745098;
370 RGB2HSV(&v64[v4], &v63[v4], v7, v6, v5, (float *)&a6[v4]);
371 ++v4;
372 v3 += 3;
373 }
374 while ( v4 < 256 );
375 }
376 v69 = (PaletteManager *)((char *)v2 + 16384 * a2);
377 v72 = 0;
378 v73 = (int)v69->pPalette1;
379 do
380 {
381 v20 = 0;
382 i = 0;
383 v71 = 1.0 - (double)v72 * 0.03225806451612903;
384 do
385 {
386 v21 = *(float *)((char *)a6 + v20) * v71;
387 if ( v21 < 0.0 )
388 v21 = 0.0;
389 v22 = v21;
390 HSV2RGB(&a1, &a2a, &a3, *(float *)((char *)v64 + v20), *(float *)((char *)v63 + v20), v22);
391 v23 = v2->uNumTargetGBits;
392 if ( v23 == 6 )
393 {
394 a1 = a1 * 31.0;
395 a2a = a2a * 62.0;
396 a3 = a3 * 31.0;
397 }
398 else
399 {
400 a1 = a1 * 31.0;
401 a2a = a2a * 31.0;
402 a3 = a3 * 31.0;
403 }
404 v24 = (unsigned __int64)(signed __int64)a3 | ((unsigned __int16)(signed __int64)a2a << v2->uNumTargetBBits) | (unsigned __int16)((unsigned __int16)(signed __int64)a1 << (v2->uNumTargetBBits + v23));
405 v25 = v73;
406 v73 += 2;
407 *(short *)v25 = v24;
408 v20 = i + 4;
409 v19 = __OFSUB__(i + 4, 1024);
410 v18 = i - 1020 < 0;
411 i += 4;
412 }
413 while ( v18 ^ v19 );
414 ++v72;
415 }
416 while ( v72 < 32 );
417 v72 = 0;
418 v73 = (int)v69->field_199600_palettes;
419 do
420 {
421 i = 0;
422 v71 = 1.0 - (double)v72 * 0.03225806451612903;
423 do
424 {
425 v26 = *(float *)&a6[i] * v71;
426 if ( v26 < 0.0 )
427 v26 = 0.0;
428 v27 = v26;
429 HSV2RGB(&a1, &a2a, &a3, 1.0, 1.0, v27);
430 v28 = v2->uNumTargetGBits;
431 if ( v28 == 6 )
432 {
433 a1 = a1 * 31.0;
434 a2a = a2a * 62.0;
435 a3 = a3 * 31.0;
436 }
437 else
438 {
439 a1 = a1 * 31.0;
440 a2a = a2a * 31.0;
441 a3 = a3 * 31.0;
442 }
443 v29 = (unsigned __int64)(signed __int64)a3 | ((unsigned __int16)(signed __int64)a2a << v2->uNumTargetBBits) | (unsigned __int16)((unsigned __int16)(signed __int64)a1 << (v2->uNumTargetBBits + v28));
444 v30 = (__int16 *)v73;
445 ++i;
446 v73 += 2;
447 v19 = __OFSUB__(i, 256);
448 v18 = i - 256 < 0;
449 *v30 = v29;
450 }
451 while ( v18 ^ v19 );
452 ++v72;
453 }
454 while ( v72 < 32 );
455 v73 = (int)((char *)v2 + 512 * (a2 + 4875));
456 v31 = 0;
457 i = 0;
458 do
459 {
460 v32 = (*(float *)((char *)a6 + v31) - 0.8) * 0.8387096774193549 + 0.8;
461 if ( v32 < 0.0 )
462 v32 = 0.0;
463 v33 = v32;
464 v34 = *(float *)((char *)v63 + v31) * 0.7034339229968783;
465 HSV2RGB(&a1, &a2a, &a3, *(float *)((char *)v64 + v31), v34, v33);
466 v35 = v2->uNumTargetGBits;
467 if ( v35 == 6 )
468 {
469 a1 = a1 * 31.0;
470 a2a = a2a * 62.0;
471 a3 = a3 * 31.0;
472 }
473 else
474 {
475 a1 = a1 * 31.0;
476 a2a = a2a * 31.0;
477 a3 = a3 * 31.0;
478 }
479 v36 = (signed __int64)((a1 + a2a + a3) * 0.3333333333333333 * 8.0);
480 v37 = (signed int)v36 >> (8 - v2->uNumTargetRBits);
481 v38 = 8 - v35;
482 v39 = v2->uNumTargetBBits;
483 v40 = (signed int)v36 >> v38;
484 v41 = v2->uNumTargetRBits;
485 v79 = (signed int)v36 >> (8 - v39);
486 if ( v37 > (1 << v41) - 1 )
487 v37 = (1 << v41) - 1;
488 v42 = v2->uNumTargetGBits;
489 if ( v40 > (1 << v42) - 1 )
490 v40 = (1 << v42) - 1;
491 if ( v79 > (1 << v39) - 1 )
492 v79 = (1 << v39) - 1;
493 v43 = v73;
494 v44 = v37 << (v39 + v2->uNumTargetGBits);
495 v73 += 2;
496 *(short *)v43 = v79 | ((short)v40 << v39) | (unsigned __int16)v44;
497 v31 = i + 4;
498 v19 = __OFSUB__(i + 4, 1024);
499 v18 = i - 1020 < 0;
500 i += 4;
501 }
502 while ( v18 ^ v19 );
503 v45 = pPalette_mistColor[0];
504 if (v45 || pPalette_mistColor[1] || pPalette_mistColor[2])
505 {
506 v46 = (double)v45;
507 v80 = pPalette_mistColor[1];
508 v47 = pPalette_mistColor[2];
509 v70 = v46 * 0.00392156862745098;
510 *((float *)&v71 + 1) = (double)v80 * 0.00392156862745098;
511 v75 = (double)v47 * 0.00392156862745098;
512 RGB2HSV(&v68, &v67, v70, *((float *)&v71 + 1), v75, (float *)&v66);
513 }
514 v72 = 0;
515 v73 = (int)v69->field_D1600;
516
517
518 do
519 {
520 v48 = 0;
521 for ( i = 0; ; v48 = i )
522 {
523 v49 = *(float *)((char *)v63 + v48);
524 if ( v49 < 0.0 )
525 v49 = 0.0;
526 v50 = v49;
527 HSV2RGB(&a1, &a2a, &a3, *(float *)((char *)v64 + v48), v50, *(float *)((char *)a6 + v48));
528 v51 = v2->uNumTargetGBits;
529 if ( v51 == 6 )
530 {
531 a1 = a1 * 31.0;
532 a2a = a2a * 62.0;
533 a3 = a3 * 31.0;
534 }
535 else
536 {
537 a1 = a1 * 31.0;
538 a2a = a2a * 31.0;
539 a3 = a3 * 31.0;
540 }
541 if (pPalette_mistColor[0] || pPalette_mistColor[1] || pPalette_mistColor[2])
542 {
543 v55 = (double)v72 * 0.03225806451612903;
544 v52 = (signed __int64)((double)(1 << v2->uNumTargetRBits) * v70 * v55 + a1 * (1.0 - v55));
545 v53 = (signed __int64)((double)(1 << v51) * *((float *)&v71 + 1) * v55 + a2a * (1.0 - v55));
546 v54 = (signed __int64)((double)(1 << v2->uNumTargetBBits) * v75 * v55 + a3 * (1.0 - v55));
547 }
548 else
549 {
550 v52 = (signed __int64)a1;
551 v53 = (signed __int64)a2a;
552 v54 = (signed __int64)a3;
553 }
554 v56 = v2->uNumTargetRBits;
555 v81 = v54;
556 if ( v52 > (1 << v56) - 1 )
557 v52 = (1 << v56) - 1;
558 v57 = v2->uNumTargetGBits;
559 if ( v53 > (1 << v57) - 1 )
560 v53 = (1 << v57) - 1;
561 HIDWORD(v54) = v2->uNumTargetBBits;
562 v59 = v2->uNumTargetBBits;
563 if ( (signed int)v54 > (1 << v59) - 1 )
564 v81 = (1 << v59) - 1;
565 v60 = v2->uNumTargetGBits;
566 i += 4;
567 v61 = uNumTargetBBits + v60;
568 result = v73;
569 v73 += 2;
570 v19 = __OFSUB__(i, 1024);
571 v18 = i - 1024 < 0;
572 *(short *)result = v81 | ((short)v53 << uNumTargetBBits) | (v52 << v61);
573 if ( !(v18 ^ v19) )
574 break;
575 }
576 ++v72;
577 }
578 while ( v72 < 32 );
579 return result;
580 }
581
582
583 //----- (0048A300) --------------------------------------------------------
584 PaletteManager::PaletteManager():
585 uNumTargetRBits(0), uNumTargetGBits(0),uNumTargetBBits(0)
586 {
587 for (uint i = 0; i < 256; ++i)
588 {
589 pBaseColors[0][i][0] = i;
590 pBaseColors[0][i][1] = i;
591 pBaseColors[0][i][2] = i;
592 }
593
594 CalcPalettes_LUT(0);
595 memset(pPaletteIDs, 0, sizeof(pPaletteIDs));
596 }
597
598 //----- (0048A336) --------------------------------------------------------
599 // make grayscale palette at 0, clear all palettes ids that aren't locked
600 int PaletteManager::ResetNonLocked()
601 {
602 PaletteManager *v1; // esi@1
603 signed int v2; // ecx@1
604 int v3; // eax@1
605 signed int result; // eax@3
606 void *v5; // edi@4
607 int v6; // ecx@4
608
609 v1 = this;
610 v2 = 0;
611 v3 = (int)&v1->pBaseColors[0][0][1];
612 do
613 {
614 *(char *)(v3 + 1) = v2;
615 *(char *)v3 = v2;
616 *(char *)(v3 - 1) = v2++;
617 v3 += 3;
618 }
619 while ( v2 < 256 );
620 CalcPalettes_LUT(0);
621 result = v1->_num_locked;
622 if ( result < 50 )
623 {
624 v5 = &v1->pPaletteIDs[result];
625 v6 = 50 - result;
626 result = 0;
627 memset(v5, 0, 4 * v6);
628 }
629 return result;
630 }
631
632 //----- (0048A379) --------------------------------------------------------
633 // make grayscale palette at 0, clear all palettes ids that aren't in "lock_test"
634 int PaletteManager::ResetNonTestLocked()
635 {
636 PaletteManager *v1; // esi@1
637 signed int v2; // ecx@1
638 int v3; // eax@1
639 signed int result; // eax@3
640 void *v5; // edi@4
641 int v6; // ecx@4
642
643 v1 = this;
644 v2 = 0;
645 v3 = (int)&v1->pBaseColors[0][0][1];
646 do
647 {
648 *(char *)(v3 + 1) = v2;
649 *(char *)v3 = v2;
650 *(char *)(v3 - 1) = v2++;
651 v3 += 3;
652 }
653 while ( v2 < 256 );
654 CalcPalettes_LUT(0);
655 result = v1->_pal_lock_test;
656 if ( result < 50 )
657 {
658 v5 = &v1->pPaletteIDs[result];
659 v6 = 50 - result;
660 result = 0;
661 memset(v5, 0, 4 * v6);
662 }
663 return result;
664 }
665
666 //----- (0048A3BC) --------------------------------------------------------
667 int PaletteManager::LoadPalette(unsigned int uPaletteID)
668 {
669 unsigned int *v2; // ecx@1
670 signed int result; // eax@1
671 signed int v4; // esi@6
672 double v5; // st7@7
673 double v6; // st7@12
674 double v7; // st6@17
675 signed __int64 v8; // qax@17
676 double v9; // st6@17
677 char v10[768]; // [sp+18h] [bp-388h]@6
678 //char v11; // [sp+19h] [bp-387h]@17
679 //char v12[766]; // [sp+1Ah] [bp-386h]@17
680 char Source[32]; // [sp+360h] [bp-40h]@4
681 PaletteManager *v15; // [sp+380h] [bp-20h]@1
682 float v16; // [sp+384h] [bp-1Ch]@7
683 int v17; // [sp+388h] [bp-18h]@6
684 float v18; // [sp+38Ch] [bp-14h]@7
685 float a2a; // [sp+390h] [bp-10h]@7
686 float a1; // [sp+394h] [bp-Ch]@7
687 int a6; // [sp+398h] [bp-8h]@7
688 int a3; // [sp+39Ch] [bp-4h]@7
689
690 v15 = this;
691 v2 = (unsigned int *)&this->pPaletteIDs[1];
692 result = 1;
693 while ( *v2 != uPaletteID )
694 {
695 ++result;
696 ++v2;
697 if ( result >= 50 )
698 {
699 sprintf(Source, "pal%03i", uPaletteID);
700
701 Texture tex; // [sp+318h] [bp-88h]@4
702 //Texture::Texture(&tex);
703
704 if ( pBitmaps_LOD->LoadTextureFromLOD(&tex, Source, TEXTURE_24BIT_PALETTE) == 1 )
705 {
706 v4 = 0;
707 v17 = 1 - (int)&v10;
708 do
709 {
710 LODWORD(a1) = tex.pPalette24[v4];
711 a1 = (double)SLODWORD(a1) * 0.0039215689;
712 LODWORD(a2a) = (unsigned __int8)*(&v10 + v4 + v17 + (unsigned int)tex.pPalette24);
713 a2a = (double)SLODWORD(a2a) * 0.0039215689;
714 a3 = tex.pPalette24[v4 + 2];
715 *(float *)&a3 = (double)a3 * 0.0039215689;
716 RGB2HSV(&v16, &v18, a1, a2a, *(float *)&a3, (float *)&a6);
717 v5 = *(float *)&a6 * 1.1;
718 if ( v5 >= 0.0 && v5 >= 1.0 )
719 {
720 v5 = 1.0;
721 }
722 else
723 {
724 if ( v5 < 0.0 )
725 v5 = 0.0;
726 }
727 *(float *)&a6 = v5;
728 v6 = v18 * 0.64999998;
729 if ( v6 >= 0.0 && v6 >= 1.0 )
730 {
731 v6 = 1.0;
732 }
733 else
734 {
735 if ( v6 < 0.0 )
736 v6 = 0.0;
737 }
738 v18 = v6;
739 HSV2RGB(&a1, &a2a, (float *)&a3, v16, v18, *(float *)&a6);
740 v7 = a2a * 255.0;
741 v10[v4] = (signed __int64)(a1 * 255.0);
742 v8 = (signed __int64)v7;
743 v9 = *(float *)&a3 * 255.0;
744 v10[v4 + 1] = v8;
745 v10[v4 + 2] = (signed __int64)v9;
746 v4 += 3;
747 }
748 while ( v4 < 768 );
749 tex.Release();
750 result = v15->MakePaletteLUT(uPaletteID, v10);
751 }
752 else
753 {
754 result = 0;
755 }
756 return result;
757 }
758 }
759 return result;
760 }
761 // 48A3BC: using guessed type char var_386[766];
762
763 //----- (0048A5A4) --------------------------------------------------------
764 int PaletteManager::MakePaletteLUT(int a2, char *entries)
765 {
766 PaletteManager *v3; // edi@1
767 signed int result; // eax@1
768 int *v5; // ecx@1
769 int v6; // eax@4
770 int v7; // esi@4
771 int v8; // eax@9
772 signed int v9; // ecx@9
773 int v10; // edx@9
774
775 v3 = this;
776 result = 0;
777 v5 = this->pPaletteIDs;
778 while ( *v5 != a2 )
779 {
780 ++result;
781 ++v5;
782 if ( result >= 50 )
783 {
784 v6 = (int)&v3->pPaletteIDs[1];
785 v7 = 1;
786 while ( *(int *)v6 )
787 {
788 ++v7;
789 v6 += 4;
790 if ( v7 >= 50 )
791 return 0;
792 }
793 v8 = (int)((char *)v3 + 768 * v7);
794 v9 = 768;
795 v10 = (int)(entries - v8);
796 do
797 {
798 *(char *)v8 = *(char *)(v10 + v8);
799 ++v8;
800 --v9;
801 }
802 while ( v9 );
803 v3->pPaletteIDs[v7] = a2;
804 CalcPalettes_LUT(v7);
805 return v7;
806 }
807 }
808 return result;
809 }
810
811 //----- (0048A614) --------------------------------------------------------
812 void PaletteManager::RecalculateAll()
813 {
814 CalcPalettes_LUT(0);
815
816 for (uint i = 1; i < 50; ++i)
817 if (pPaletteIDs[i])
818 CalcPalettes_LUT(i);
819 }
820
821
822 //----- (0047BE67) --------------------------------------------------------
823 unsigned __int16 *PaletteManager::Get(int a1)
824 {
825 return (unsigned __int16 *)pPaletteManager->field_199600_palettes[a1];
826 }
827
828 //----- (0047BE72) --------------------------------------------------------
829 unsigned __int16 *PaletteManager::Get_Mist_or_Red_LUT(int a1, int a2, char a3)
830 {
831 int v3; // eax@4
832
833 if ( a3 & 2 || byte_4D864C && BYTE2(pGame->uFlags) & 4 )
834 v3 = 32 * a1 + a2 + 3275;
835 else
836 v3 = 32 * a1 + a2 + 1675;
837 return (unsigned __int16 *)((char *)&pPaletteManager + 512 * v3);
838 }
839 // 4D864C: using guessed type char byte_4D864C;
840
841
842 //----- (0041F50D) --------------------------------------------------------
843 unsigned __int16 *PaletteManager::Get_Dark_or_Red_LUT(int a1, int a2, char a3)
844 {
845 int v3; // eax@4
846
847 if ( a3 & 2 || byte_4D864C && BYTE2(pGame->uFlags) & 4 )
848 v3 = 32 * a1 + a2 + 3275;
849 else
850 v3 = 32 * a1 + a2 + 75;
851 return (unsigned __int16 *)((char *)&pPaletteManager + 512 * v3);
852 }
853 // 4D864C: using guessed type char byte_4D864C;
854
855
856 //----- (0047C30E) --------------------------------------------------------
857 unsigned __int16 *PaletteManager::_47C30E_get_palette(int a1, char a2)
858 {
859 char *result; // eax@4
860
861 if ( a2 & 2 || byte_4D864C && BYTE2(pGame->uFlags) & 4 )
862 result = (char *)pPaletteManager->field_199600_palettes[a1];
863 else
864 result = (char *)pPaletteManager->field_D1600[a1];
865 return (unsigned __int16 *)result;
866 }
867
868
869 //----- (0047C33F) --------------------------------------------------------
870 unsigned __int16 *PaletteManager::_47C33F_get_palette(int a1, char a2)
871 {
872 unsigned __int16 *result; // eax@4
873
874 if ( a2 & 2 || byte_4D864C && BYTE2(pGame->uFlags) & 4 )
875 result = (unsigned __int16 *)pPaletteManager->field_199600_palettes[a1];
876 else
877 result = (unsigned __int16 *)pPaletteManager->pPalette1[a1];
878 return result;
879 }
880 // 4D864C: using guessed type char byte_4D864C;