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