34cf4058 |
1 | #include <time.h> |
2 | #include <stdlib.h> |
3 | #include <memory.h> |
4 | |
5 | #ifndef min |
6 | #define min(a,b) ((a) < (b) ? (a) : (b)) |
7 | #endif |
8 | |
9 | #include "Common.h" |
10 | #include "Config.h" |
11 | #include "OpenGL.h" |
12 | #include "Textures.h" |
13 | #include "GBI.h" |
14 | #include "RSP.h" |
15 | #include "gDP.h" |
16 | #include "gSP.h" |
17 | #include "N64.h" |
18 | #include "CRC.h" |
19 | #include "convert.h" |
20 | #include "2xSAI.h" |
21 | //#include "FrameBuffer.h" |
22 | |
23 | #define FORMAT_NONE 0 |
24 | #define FORMAT_I8 1 |
25 | #define FORMAT_IA88 2 |
26 | #define FORMAT_RGBA4444 3 |
27 | #define FORMAT_RGBA5551 4 |
28 | #define FORMAT_RGBA8888 5 |
29 | |
30 | //#define PRINT_TEXTUREFORMAT |
31 | |
32 | TextureCache cache; |
33 | |
34 | typedef u32 (*GetTexelFunc)( void *src, u16 x, u16 i, u8 palette ); |
35 | |
36 | u32 GetNone( void *src, u16 x, u16 i, u8 palette ) |
37 | { |
38 | return 0x00000000; |
39 | } |
40 | |
41 | u32 GetCI4IA_RGBA4444( void *src, u16 x, u16 i, u8 palette ) |
42 | { |
43 | u8 color4B = ((u8*)src)[(x>>1)^(i<<1)]; |
44 | if (x & 1) |
45 | return IA88_RGBA4444( *(u16*)&TMEM[256 + (palette << 4) + (color4B & 0x0F)] ); |
46 | else |
47 | return IA88_RGBA4444( *(u16*)&TMEM[256 + (palette << 4) + (color4B >> 4)] ); |
48 | } |
49 | |
50 | u32 GetCI4IA_RGBA8888( void *src, u16 x, u16 i, u8 palette ) |
51 | { |
52 | u8 color4B = ((u8*)src)[(x>>1)^(i<<1)]; |
53 | if (x & 1) |
54 | return IA88_RGBA8888( *(u16*)&TMEM[256 + (palette << 4) + (color4B & 0x0F)] ); |
55 | else |
56 | return IA88_RGBA8888( *(u16*)&TMEM[256 + (palette << 4) + (color4B >> 4)] ); |
57 | } |
58 | |
59 | u32 GetCI4RGBA_RGBA5551( void *src, u16 x, u16 i, u8 palette ) |
60 | { |
61 | u8 color4B = ((u8*)src)[(x>>1)^(i<<1)]; |
62 | if (x & 1) |
63 | return RGBA5551_RGBA5551( *(u16*)&TMEM[256 + (palette << 4) + (color4B & 0x0F)] ); |
64 | else |
65 | return RGBA5551_RGBA5551( *(u16*)&TMEM[256 + (palette << 4) + (color4B >> 4)] ); |
66 | } |
67 | |
68 | u32 GetCI4RGBA_RGBA8888( void *src, u16 x, u16 i, u8 palette ) |
69 | { |
70 | u8 color4B = ((u8*)src)[(x>>1)^(i<<1)]; |
71 | if (x & 1) |
72 | return RGBA5551_RGBA8888( *(u16*)&TMEM[256 + (palette << 4) + (color4B & 0x0F)] ); |
73 | else |
74 | return RGBA5551_RGBA8888( *(u16*)&TMEM[256 + (palette << 4) + (color4B >> 4)] ); |
75 | } |
76 | |
77 | u32 GetIA31_RGBA8888( void *src, u16 x, u16 i, u8 palette ) |
78 | { |
79 | u8 color4B = ((u8*)src)[(x>>1)^(i<<1)]; |
80 | return IA31_RGBA8888( (x & 1) ? (color4B & 0x0F) : (color4B >> 4) ); |
81 | } |
82 | |
83 | u32 GetIA31_RGBA4444( void *src, u16 x, u16 i, u8 palette ) |
84 | { |
85 | u8 color4B = ((u8*)src)[(x>>1)^(i<<1)]; |
86 | return IA31_RGBA4444( (x & 1) ? (color4B & 0x0F) : (color4B >> 4) ); |
87 | } |
88 | |
89 | u32 GetIA31_IA88( void *src, u16 x, u16 i, u8 palette ) |
90 | { |
91 | u8 color4B = ((u8*)src)[(x>>1)^(i<<1)]; |
92 | return IA31_IA88( (x & 1) ? (color4B & 0x0F) : (color4B >> 4) ); |
93 | } |
94 | |
95 | u32 GetI4_RGBA8888( void *src, u16 x, u16 i, u8 palette ) |
96 | { |
97 | u8 color4B = ((u8*)src)[(x>>1)^(i<<1)]; |
98 | return I4_RGBA8888( (x & 1) ? (color4B & 0x0F) : (color4B >> 4) ); |
99 | } |
100 | |
101 | u32 GetI4_RGBA4444( void *src, u16 x, u16 i, u8 palette ) |
102 | { |
103 | u8 color4B = ((u8*)src)[(x>>1)^(i<<1)]; |
104 | return I4_RGBA4444( (x & 1) ? (color4B & 0x0F) : (color4B >> 4) ); |
105 | } |
106 | |
107 | u32 GetI4_I8( void *src, u16 x, u16 i, u8 palette ) |
108 | { |
109 | u8 color4B = ((u8*)src)[(x>>1)^(i<<1)]; |
110 | return I4_I8( (x & 1) ? (color4B & 0x0F) : (color4B >> 4) ); |
111 | } |
112 | |
113 | |
114 | u32 GetI4_IA88( void *src, u16 x, u16 i, u8 palette ) |
115 | { |
116 | u8 color4B = ((u8*)src)[(x>>1)^(i<<1)]; |
117 | return I4_IA88( (x & 1) ? (color4B & 0x0F) : (color4B >> 4) ); |
118 | } |
119 | |
120 | u32 GetCI8IA_RGBA4444( void *src, u16 x, u16 i, u8 palette ) |
121 | { |
122 | return IA88_RGBA4444( *(u16*)&TMEM[256 + ((u8*)src)[x^(i<<1)]] ); |
123 | } |
124 | |
125 | u32 GetCI8IA_RGBA8888( void *src, u16 x, u16 i, u8 palette ) |
126 | { |
127 | return IA88_RGBA8888( *(u16*)&TMEM[256 + ((u8*)src)[x^(i<<1)]] ); |
128 | } |
129 | |
130 | u32 GetCI8RGBA_RGBA5551( void *src, u16 x, u16 i, u8 palette ) |
131 | { |
132 | return RGBA5551_RGBA5551( *(u16*)&TMEM[256 + ((u8*)src)[x^(i<<1)]] ); |
133 | } |
134 | |
135 | u32 GetCI8RGBA_RGBA8888( void *src, u16 x, u16 i, u8 palette ) |
136 | { |
137 | return RGBA5551_RGBA8888( *(u16*)&TMEM[256 + ((u8*)src)[x^(i<<1)]] ); |
138 | } |
139 | |
140 | u32 GetIA44_RGBA8888( void *src, u16 x, u16 i, u8 palette ) |
141 | { |
142 | return IA44_RGBA8888(((u8*)src)[x^(i<<1)]); |
143 | } |
144 | |
145 | u32 GetIA44_RGBA4444( void *src, u16 x, u16 i, u8 palette ) |
146 | { |
147 | return IA44_RGBA4444(((u8*)src)[x^(i<<1)]); |
148 | } |
149 | |
150 | u32 GetIA44_IA88( void *src, u16 x, u16 i, u8 palette ) |
151 | { |
152 | return IA44_IA88(((u8*)src)[x^(i<<1)]); |
153 | } |
154 | |
155 | u32 GetI8_RGBA8888( void *src, u16 x, u16 i, u8 palette ) |
156 | { |
157 | return I8_RGBA8888(((u8*)src)[x^(i<<1)]); |
158 | } |
159 | |
160 | u32 GetI8_I8( void *src, u16 x, u16 i, u8 palette ) |
161 | { |
162 | return ((u8*)src)[x^(i<<1)]; |
163 | } |
164 | |
165 | u32 GetI8_IA88( void *src, u16 x, u16 i, u8 palette ) |
166 | { |
167 | return I8_IA88(((u8*)src)[x^(i<<1)]); |
168 | } |
169 | |
170 | u32 GetI8_RGBA4444( void *src, u16 x, u16 i, u8 palette ) |
171 | { |
172 | return I8_RGBA4444(((u8*)src)[x^(i<<1)]); |
173 | } |
174 | |
175 | u32 GetRGBA5551_RGBA8888( void *src, u16 x, u16 i, u8 palette ) |
176 | { |
177 | return RGBA5551_RGBA8888( ((u16*)src)[x^i] ); |
178 | } |
179 | |
180 | u32 GetRGBA5551_RGBA5551( void *src, u16 x, u16 i, u8 palette ) |
181 | { |
182 | return RGBA5551_RGBA5551( ((u16*)src)[x^i] ); |
183 | } |
184 | |
185 | u32 GetIA88_RGBA8888( void *src, u16 x, u16 i, u8 palette ) |
186 | { |
187 | return IA88_RGBA8888(((u16*)src)[x^i]); |
188 | } |
189 | |
190 | u32 GetIA88_RGBA4444( void *src, u16 x, u16 i, u8 palette ) |
191 | { |
192 | return IA88_RGBA4444(((u16*)src)[x^i]); |
193 | } |
194 | |
195 | u32 GetIA88_IA88( void *src, u16 x, u16 i, u8 palette ) |
196 | { |
197 | return IA88_IA88(((u16*)src)[x^i]); |
198 | } |
199 | |
200 | u32 GetRGBA8888_RGBA8888( void *src, u16 x, u16 i, u8 palette ) |
201 | { |
202 | return ((u32*)src)[x^i]; |
203 | } |
204 | |
205 | u32 GetRGBA8888_RGBA4444( void *src, u16 x, u16 i, u8 palette ) |
206 | { |
207 | return RGBA8888_RGBA4444(((u32*)src)[x^i]); |
208 | } |
209 | |
210 | |
211 | struct TextureFormat |
212 | { |
213 | int format; |
214 | GetTexelFunc getTexel; |
215 | int lineShift, maxTexels; |
216 | }; |
217 | |
218 | |
219 | TextureFormat textureFormatIA[4*6] = |
220 | { |
221 | // 4-bit |
222 | { FORMAT_RGBA5551, GetCI4RGBA_RGBA5551, 4, 4096 }, // RGBA (SELECT) |
223 | { FORMAT_NONE, GetNone, 4, 8192 }, // YUV |
224 | { FORMAT_RGBA5551, GetCI4RGBA_RGBA5551, 4, 4096 }, // CI |
225 | { FORMAT_IA88, GetIA31_IA88, 4, 8192 }, // IA |
226 | { FORMAT_IA88, GetI4_IA88, 4, 8192 }, // I |
227 | { FORMAT_RGBA8888, GetCI4IA_RGBA8888, 4, 4096 }, // IA Palette |
228 | // 8-bit |
229 | { FORMAT_RGBA5551, GetCI8RGBA_RGBA5551, 3, 2048 }, // RGBA (SELECT) |
230 | { FORMAT_NONE, GetNone, 3, 4096 }, // YUV |
231 | { FORMAT_RGBA5551, GetCI8RGBA_RGBA5551, 3, 2048 }, // CI |
232 | { FORMAT_IA88, GetIA44_IA88, 3, 4096 }, // IA |
233 | { FORMAT_IA88, GetI8_IA88, 3, 4096 }, // I |
234 | { FORMAT_RGBA8888, GetCI8IA_RGBA8888, 3, 2048 }, // IA Palette |
235 | // 16-bit |
236 | { FORMAT_RGBA5551, GetRGBA5551_RGBA5551, 2, 2048 }, // RGBA |
237 | { FORMAT_NONE, GetNone, 2, 2048 }, // YUV |
238 | { FORMAT_NONE, GetNone, 2, 2048 }, // CI |
239 | { FORMAT_IA88, GetIA88_IA88, 2, 2048 }, // IA |
240 | { FORMAT_NONE, GetNone, 2, 2048 }, // I |
241 | { FORMAT_NONE, GetNone, 2, 2048 }, // IA Palette |
242 | // 32-bit |
243 | { FORMAT_RGBA8888, GetRGBA8888_RGBA8888, 2, 1024 }, // RGBA |
244 | { FORMAT_NONE, GetNone, 2, 1024 }, // YUV |
245 | { FORMAT_NONE, GetNone, 2, 1024 }, // CI |
246 | { FORMAT_NONE, GetNone, 2, 1024 }, // IA |
247 | { FORMAT_NONE, GetNone, 2, 1024 }, // I |
248 | { FORMAT_NONE, GetNone, 2, 1024 }, // IA Palette |
249 | }; |
250 | |
251 | TextureFormat textureFormatRGBA[4*6] = |
252 | { |
253 | // 4-bit |
254 | { FORMAT_RGBA5551, GetCI4RGBA_RGBA5551, 4, 4096 }, // RGBA (SELECT) |
255 | { FORMAT_NONE, GetNone, 4, 8192 }, // YUV |
256 | { FORMAT_RGBA5551, GetCI4RGBA_RGBA5551, 4, 4096 }, // CI |
257 | { FORMAT_RGBA4444, GetIA31_RGBA4444, 4, 8192 }, // IA |
258 | { FORMAT_RGBA4444, GetI4_RGBA4444, 4, 8192 }, // I |
259 | { FORMAT_RGBA8888, GetCI4IA_RGBA8888, 4, 4096 }, // IA Palette |
260 | // 8-bit |
261 | { FORMAT_RGBA5551, GetCI8RGBA_RGBA5551, 3, 2048 }, // RGBA (SELECT) |
262 | { FORMAT_NONE, GetNone, 3, 4096 }, // YUV |
263 | { FORMAT_RGBA5551, GetCI8RGBA_RGBA5551, 3, 2048 }, // CI |
264 | { FORMAT_RGBA4444, GetIA44_RGBA4444, 3, 4096 }, // IA |
265 | { FORMAT_RGBA8888, GetI8_RGBA8888, 3, 4096 }, // I |
266 | { FORMAT_RGBA8888, GetCI8IA_RGBA8888, 3, 2048 }, // IA Palette |
267 | // 16-bit |
268 | { FORMAT_RGBA5551, GetRGBA5551_RGBA5551, 2, 2048 }, // RGBA |
269 | { FORMAT_NONE, GetNone, 2, 2048 }, // YUV |
270 | { FORMAT_NONE, GetNone, 2, 2048 }, // CI |
271 | { FORMAT_RGBA8888, GetIA88_RGBA8888, 2, 2048 }, // IA |
272 | { FORMAT_NONE, GetNone, 2, 2048 }, // I |
273 | { FORMAT_NONE, GetNone, 2, 2048 }, // IA Palette |
274 | // 32-bit |
275 | { FORMAT_RGBA8888, GetRGBA8888_RGBA8888, 2, 1024 }, // RGBA |
276 | { FORMAT_NONE, GetNone, 2, 1024 }, // YUV |
277 | { FORMAT_NONE, GetNone, 2, 1024 }, // CI |
278 | { FORMAT_NONE, GetNone, 2, 1024 }, // IA |
279 | { FORMAT_NONE, GetNone, 2, 1024 }, // I |
280 | { FORMAT_NONE, GetNone, 2, 1024 }, // IA Palette |
281 | }; |
282 | |
283 | |
284 | TextureFormat *textureFormat = textureFormatIA; |
285 | |
286 | void __texture_format_rgba(int size, int format, TextureFormat *texFormat) |
287 | { |
288 | if (size < G_IM_SIZ_16b) |
289 | { |
290 | if (gDP.otherMode.textureLUT == G_TT_NONE) |
291 | *texFormat = textureFormat[size*6 + G_IM_FMT_I]; |
292 | else if (gDP.otherMode.textureLUT == G_TT_RGBA16) |
293 | *texFormat = textureFormat[size*6 + G_IM_FMT_CI]; |
294 | else |
295 | *texFormat = textureFormat[size*6 + G_IM_FMT_IA]; |
296 | } |
297 | else |
298 | { |
299 | *texFormat = textureFormat[size*6 + G_IM_FMT_RGBA]; |
300 | } |
301 | } |
302 | |
303 | void __texture_format_ci(int size, int format, TextureFormat *texFormat) |
304 | { |
305 | switch(size) |
306 | { |
307 | case G_IM_SIZ_4b: |
308 | if (gDP.otherMode.textureLUT == G_TT_IA16) |
309 | *texFormat = textureFormat[G_IM_SIZ_4b*6 + G_IM_FMT_CI_IA]; |
310 | else |
311 | *texFormat = textureFormat[G_IM_SIZ_4b*6 + G_IM_FMT_CI]; |
312 | break; |
313 | |
314 | case G_IM_SIZ_8b: |
315 | if (gDP.otherMode.textureLUT == G_TT_NONE) |
316 | *texFormat = textureFormat[G_IM_SIZ_8b*6 + G_IM_FMT_I]; |
317 | else if (gDP.otherMode.textureLUT == G_TT_IA16) |
318 | *texFormat = textureFormat[G_IM_SIZ_8b*6 + G_IM_FMT_CI_IA]; |
319 | else |
320 | *texFormat = textureFormat[G_IM_SIZ_8b*6 + G_IM_FMT_CI]; |
321 | break; |
322 | |
323 | default: |
324 | *texFormat = textureFormat[size*6 + format]; |
325 | } |
326 | } |
327 | |
328 | void __texture_format(int size, int format, TextureFormat *texFormat) |
329 | { |
330 | if (format == G_IM_FMT_RGBA) |
331 | { |
332 | __texture_format_rgba(size, format, texFormat); |
333 | } |
334 | else if (format == G_IM_FMT_YUV) |
335 | { |
336 | *texFormat = textureFormat[size*6 + G_IM_FMT_YUV]; |
337 | } |
338 | else if (format == G_IM_FMT_CI) |
339 | { |
340 | __texture_format_ci(size, format, texFormat); |
341 | } |
342 | else if (format == G_IM_FMT_IA) |
343 | { |
344 | if (gDP.otherMode.textureLUT != G_TT_NONE) |
345 | __texture_format_ci(size, format, texFormat); |
346 | else |
347 | *texFormat = textureFormat[size*6 + G_IM_FMT_IA]; |
348 | } |
349 | else if (format == G_IM_FMT_I) |
350 | { |
351 | if (gDP.otherMode.textureLUT == G_TT_NONE) |
352 | *texFormat = textureFormat[size*6 + G_IM_FMT_I]; |
353 | else |
354 | __texture_format_ci(size, format, texFormat); |
355 | } |
356 | } |
357 | |
358 | |
359 | int isTexCacheInit = 0; |
360 | |
361 | void TextureCache_Init() |
362 | { |
363 | u32 dummyTexture[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; |
364 | |
365 | isTexCacheInit = 1; |
366 | cache.current[0] = NULL; |
367 | cache.current[1] = NULL; |
368 | cache.top = NULL; |
369 | cache.bottom = NULL; |
370 | cache.numCached = 0; |
371 | cache.cachedBytes = 0; |
372 | |
373 | #ifdef __HASHMAP_OPT |
374 | cache.hash.init(11); |
375 | #endif |
376 | |
377 | if (config.texture.useIA) textureFormat = textureFormatIA; |
378 | else textureFormat = textureFormatRGBA; |
379 | |
380 | glPixelStorei(GL_PACK_ALIGNMENT, 1); |
381 | glPixelStorei(GL_UNPACK_ALIGNMENT, 1); |
382 | glGenTextures( 32, cache.glNoiseNames ); |
383 | |
384 | srand(time(NULL)); |
385 | u8 noise[64*64*2]; |
386 | for (u32 i = 0; i < 32; i++) |
387 | { |
388 | glBindTexture( GL_TEXTURE_2D, cache.glNoiseNames[i] ); |
389 | for (u32 y = 0; y < 64; y++) |
390 | { |
391 | for (u32 x = 0; x < 64; x++) |
392 | { |
393 | u32 r = (rand()&0xFF); |
394 | noise[y*64*2+x*2] = r; |
395 | noise[y*64*2+x*2+1] = r; |
396 | } |
397 | } |
398 | glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, 64, 64, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, noise); |
399 | } |
400 | |
401 | cache.dummy = TextureCache_AddTop(); |
402 | cache.dummy->address = 0; |
403 | cache.dummy->clampS = 1; |
404 | cache.dummy->clampT = 1; |
405 | cache.dummy->clampWidth = 4; |
406 | cache.dummy->clampHeight = 4; |
407 | cache.dummy->crc = 0; |
408 | cache.dummy->format = 0; |
409 | cache.dummy->size = 0; |
410 | cache.dummy->width = 4; |
411 | cache.dummy->height = 4; |
412 | cache.dummy->realWidth = 0; |
413 | cache.dummy->realHeight = 0; |
414 | cache.dummy->maskS = 0; |
415 | cache.dummy->maskT = 0; |
416 | cache.dummy->scaleS = 0.5f; |
417 | cache.dummy->scaleT = 0.5f; |
418 | cache.dummy->shiftScaleS = 1.0f; |
419 | cache.dummy->shiftScaleT = 1.0f; |
420 | cache.dummy->textureBytes = 64; |
421 | cache.dummy->tMem = 0; |
422 | |
423 | glBindTexture( GL_TEXTURE_2D, cache.dummy->glName ); |
424 | glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, dummyTexture); |
425 | |
426 | cache.cachedBytes = cache.dummy->textureBytes; |
427 | TextureCache_ActivateDummy(0); |
428 | TextureCache_ActivateDummy(1); |
429 | CRC_BuildTable(); |
430 | } |
431 | |
432 | bool TextureCache_Verify() |
433 | { |
434 | u16 i = 0; |
435 | CachedTexture *current; |
436 | |
437 | current = cache.top; |
438 | |
439 | while (current) |
440 | { |
441 | i++; |
442 | current = current->lower; |
443 | } |
444 | if (i != cache.numCached) return false; |
445 | |
446 | i = 0; |
447 | current = cache.bottom; |
448 | while (current) |
449 | { |
450 | i++; |
451 | current = current->higher; |
452 | } |
453 | if (i != cache.numCached) return false; |
454 | |
455 | return true; |
456 | } |
457 | |
458 | void TextureCache_RemoveBottom() |
459 | { |
460 | CachedTexture *newBottom = cache.bottom->higher; |
461 | |
462 | #ifdef __HASHMAP_OPT |
463 | CachedTexture* tex= cache.hash.find(cache.bottom->crc); |
464 | if (tex == cache.bottom) |
465 | cache.hash.insert(cache.bottom->crc, NULL); |
466 | #endif |
467 | |
468 | glDeleteTextures( 1, &cache.bottom->glName ); |
469 | cache.cachedBytes -= cache.bottom->textureBytes; |
470 | |
471 | if (cache.bottom == cache.top) |
472 | cache.top = NULL; |
473 | |
474 | free( cache.bottom ); |
475 | |
476 | cache.bottom = newBottom; |
477 | |
478 | if (cache.bottom) |
479 | cache.bottom->lower = NULL; |
480 | |
481 | cache.numCached--; |
482 | } |
483 | |
484 | void TextureCache_Remove( CachedTexture *texture ) |
485 | { |
486 | if ((texture == cache.bottom) && (texture == cache.top)) |
487 | { |
488 | cache.top = NULL; |
489 | cache.bottom = NULL; |
490 | } |
491 | else if (texture == cache.bottom) |
492 | { |
493 | cache.bottom = texture->higher; |
494 | |
495 | if (cache.bottom) |
496 | cache.bottom->lower = NULL; |
497 | } |
498 | else if (texture == cache.top) |
499 | { |
500 | cache.top = texture->lower; |
501 | |
502 | if (cache.top) |
503 | cache.top->higher = NULL; |
504 | } |
505 | else |
506 | { |
507 | texture->higher->lower = texture->lower; |
508 | texture->lower->higher = texture->higher; |
509 | } |
510 | |
511 | #ifdef __HASHMAP_OPT |
512 | CachedTexture* tex= cache.hash.find(texture->crc); |
513 | if (tex == texture); |
514 | cache.hash.insert(texture->crc, NULL); |
515 | #endif |
516 | |
517 | glDeleteTextures( 1, &texture->glName ); |
518 | cache.cachedBytes -= texture->textureBytes; |
519 | free( texture ); |
520 | |
521 | cache.numCached--; |
522 | } |
523 | |
524 | CachedTexture *TextureCache_AddTop() |
525 | { |
526 | while (cache.cachedBytes > TEXTURECACHE_MAX) |
527 | { |
528 | if (cache.bottom != cache.dummy) |
529 | TextureCache_RemoveBottom(); |
530 | else if (cache.dummy->higher) |
531 | TextureCache_Remove( cache.dummy->higher ); |
532 | } |
533 | |
534 | CachedTexture *newtop = (CachedTexture*)malloc( sizeof( CachedTexture ) ); |
535 | |
536 | glGenTextures( 1, &newtop->glName ); |
537 | |
538 | newtop->lower = cache.top; |
539 | newtop->higher = NULL; |
540 | |
541 | if (cache.top) |
542 | cache.top->higher = newtop; |
543 | |
544 | if (!cache.bottom) |
545 | cache.bottom = newtop; |
546 | |
547 | cache.top = newtop; |
548 | |
549 | cache.numCached++; |
550 | |
551 | return newtop; |
552 | } |
553 | |
554 | void TextureCache_MoveToTop( CachedTexture *newtop ) |
555 | { |
556 | if (newtop == cache.top) return; |
557 | |
558 | if (newtop == cache.bottom) |
559 | { |
560 | cache.bottom = newtop->higher; |
561 | cache.bottom->lower = NULL; |
562 | } |
563 | else |
564 | { |
565 | newtop->higher->lower = newtop->lower; |
566 | newtop->lower->higher = newtop->higher; |
567 | } |
568 | |
569 | newtop->higher = NULL; |
570 | newtop->lower = cache.top; |
571 | cache.top->higher = newtop; |
572 | cache.top = newtop; |
573 | } |
574 | |
575 | void TextureCache_Destroy() |
576 | { |
577 | while (cache.bottom) |
578 | TextureCache_RemoveBottom(); |
579 | |
580 | glDeleteTextures( 32, cache.glNoiseNames ); |
581 | glDeleteTextures( 1, &cache.dummy->glName ); |
582 | |
583 | #ifdef __HASHMAP_OPT |
584 | cache.hash.destroy(); |
585 | #endif |
586 | |
587 | cache.top = NULL; |
588 | cache.bottom = NULL; |
589 | } |
590 | |
591 | |
592 | |
593 | void TextureCache_LoadBackground( CachedTexture *texInfo ) |
594 | { |
595 | u32 *dest, *scaledDest; |
596 | u8 *swapped, *src; |
597 | u32 numBytes, bpl; |
598 | u32 x, y, j, tx, ty; |
599 | u16 clampSClamp, clampTClamp; |
600 | |
601 | int bytePerPixel=0; |
602 | TextureFormat texFormat; |
603 | GetTexelFunc getTexel; |
604 | GLint glWidth=0, glHeight=0; |
605 | GLenum glType=0; |
606 | GLenum glFormat=0; |
607 | |
608 | __texture_format(texInfo->size, texInfo->format, &texFormat); |
609 | |
610 | #ifdef PRINT_TEXTUREFORMAT |
611 | printf("BG LUT=%i, TEXTURE SIZE=%i, FORMAT=%i -> GL FORMAT=%i\n", gDP.otherMode.textureLUT, texInfo->size, texInfo->format, texFormat.format); fflush(stdout); |
612 | #endif |
613 | |
614 | if (texFormat.format == FORMAT_NONE) |
615 | { |
616 | LOG(LOG_WARNING, "No Texture Conversion function available, size=%i format=%i\n", texInfo->size, texInfo->format); |
617 | } |
618 | |
619 | switch(texFormat.format) |
620 | { |
621 | case FORMAT_I8: |
622 | glFormat = GL_LUMINANCE; |
623 | glType = GL_UNSIGNED_BYTE; |
624 | bytePerPixel = 1; |
625 | break; |
626 | case FORMAT_IA88: |
627 | glFormat = GL_LUMINANCE_ALPHA; |
628 | glType = GL_UNSIGNED_BYTE; |
629 | bytePerPixel = 2; |
630 | break; |
631 | case FORMAT_RGBA4444: |
632 | glFormat = GL_RGBA; |
633 | glType = GL_UNSIGNED_SHORT_4_4_4_4; |
634 | bytePerPixel = 2; |
635 | break; |
636 | case FORMAT_RGBA5551: |
637 | glFormat = GL_RGBA; |
638 | glType = GL_UNSIGNED_SHORT_5_5_5_1; |
639 | bytePerPixel = 2; |
640 | break; |
641 | case FORMAT_RGBA8888: |
642 | glFormat = GL_RGBA; |
643 | glType = GL_UNSIGNED_BYTE; |
644 | bytePerPixel = 4; |
645 | break; |
646 | } |
647 | |
648 | glWidth = texInfo->realWidth; |
649 | glHeight = texInfo->realHeight; |
650 | texInfo->textureBytes = (glWidth * glHeight) * bytePerPixel; |
651 | getTexel = texFormat.getTexel; |
652 | |
653 | bpl = gSP.bgImage.width << gSP.bgImage.size >> 1; |
654 | numBytes = bpl * gSP.bgImage.height; |
655 | swapped = (u8*) malloc(numBytes); |
656 | dest = (u32*) malloc(texInfo->textureBytes); |
657 | |
658 | if (!dest || !swapped) |
659 | { |
660 | LOG(LOG_ERROR, "Malloc failed!\n"); |
661 | return; |
662 | } |
663 | |
664 | UnswapCopy(&RDRAM[gSP.bgImage.address], swapped, numBytes); |
665 | |
666 | clampSClamp = texInfo->width - 1; |
667 | clampTClamp = texInfo->height - 1; |
668 | |
669 | j = 0; |
670 | for (y = 0; y < texInfo->realHeight; y++) |
671 | { |
672 | ty = min(y, clampTClamp); |
673 | src = &swapped[bpl * ty]; |
674 | for (x = 0; x < texInfo->realWidth; x++) |
675 | { |
676 | tx = min(x, clampSClamp); |
677 | if (bytePerPixel == 4) |
678 | ((u32*)dest)[j++] = getTexel(src, tx, 0, texInfo->palette); |
679 | else if (bytePerPixel == 2) |
680 | ((u16*)dest)[j++] = getTexel(src, tx, 0, texInfo->palette); |
681 | else if (bytePerPixel == 1) |
682 | ((u8*)dest)[j++] = getTexel(src, tx, 0, texInfo->palette); |
683 | } |
684 | } |
685 | |
686 | if (!config.texture.sai2x || (texFormat.format == FORMAT_I8 || texFormat.format == FORMAT_IA88)) |
687 | { |
688 | glTexImage2D( GL_TEXTURE_2D, 0, glFormat, glWidth, glHeight, 0, glFormat, glType, dest); |
689 | } |
690 | else |
691 | { |
692 | LOG(LOG_VERBOSE, "Using 2xSAI Filter on Texture\n"); |
693 | texInfo->textureBytes <<= 2; |
694 | |
695 | scaledDest = (u32*) malloc( texInfo->textureBytes ); |
696 | |
697 | if (glType == GL_UNSIGNED_BYTE) |
698 | _2xSaI8888( (u32*)dest, (u32*)scaledDest, texInfo->realWidth, texInfo->realHeight, texInfo->clampS, texInfo->clampT ); |
699 | if (glType == GL_UNSIGNED_SHORT_4_4_4_4) |
700 | _2xSaI4444( (u16*)dest, (u16*)scaledDest, texInfo->realWidth, texInfo->realHeight, texInfo->clampS, texInfo->clampT ); |
701 | else |
702 | _2xSaI5551( (u16*)dest, (u16*)scaledDest, texInfo->realWidth, texInfo->realHeight, texInfo->clampS, texInfo->clampT ); |
703 | |
704 | glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, texInfo->realWidth << 1, texInfo->realHeight << 1, 0, GL_RGBA, glType, scaledDest ); |
705 | |
706 | free( scaledDest ); |
707 | } |
708 | |
709 | free(dest); |
710 | free(swapped); |
711 | |
712 | |
713 | if (config.texture.enableMipmap) |
714 | glGenerateMipmap(GL_TEXTURE_2D); |
715 | } |
716 | |
717 | void TextureCache_Load( CachedTexture *texInfo ) |
718 | { |
719 | u32 *dest, *scaledDest; |
720 | |
721 | void *src; |
722 | u16 x, y, i, j, tx, ty, line; |
723 | u16 mirrorSBit, maskSMask, clampSClamp; |
724 | u16 mirrorTBit, maskTMask, clampTClamp; |
725 | |
726 | int bytePerPixel=0; |
727 | TextureFormat texFormat; |
728 | GetTexelFunc getTexel; |
729 | GLint glWidth=0, glHeight=0; |
730 | GLenum glType=0; |
731 | GLenum glFormat=0; |
732 | |
733 | __texture_format(texInfo->size, texInfo->format, &texFormat); |
734 | |
735 | #ifdef PRINT_TEXTUREFORMAT |
736 | printf("TEX LUT=%i, TEXTURE SIZE=%i, FORMAT=%i -> GL FORMAT=%i\n", gDP.otherMode.textureLUT, texInfo->size, texInfo->format, texFormat.format); fflush(stdout); |
737 | #endif |
738 | |
739 | if (texFormat.format == FORMAT_NONE) |
740 | { |
741 | LOG(LOG_WARNING, "No Texture Conversion function available, size=%i format=%i\n", texInfo->size, texInfo->format); |
742 | } |
743 | |
744 | switch(texFormat.format) |
745 | { |
746 | case FORMAT_I8: |
747 | glFormat = GL_LUMINANCE; |
748 | glType = GL_UNSIGNED_BYTE; |
749 | bytePerPixel = 1; |
750 | break; |
751 | case FORMAT_IA88: |
752 | glFormat = GL_LUMINANCE_ALPHA; |
753 | glType = GL_UNSIGNED_BYTE; |
754 | bytePerPixel = 2; |
755 | break; |
756 | case FORMAT_RGBA4444: |
757 | glFormat = GL_RGBA; |
758 | glType = GL_UNSIGNED_SHORT_4_4_4_4; |
759 | bytePerPixel = 2; |
760 | break; |
761 | case FORMAT_RGBA5551: |
762 | glFormat = GL_RGBA; |
763 | glType = GL_UNSIGNED_SHORT_5_5_5_1; |
764 | bytePerPixel = 2; |
765 | break; |
766 | case FORMAT_RGBA8888: |
767 | glFormat = GL_RGBA; |
768 | glType = GL_UNSIGNED_BYTE; |
769 | bytePerPixel = 4; |
770 | break; |
771 | } |
772 | |
773 | glWidth = texInfo->realWidth; |
774 | glHeight = texInfo->realHeight; |
775 | texInfo->textureBytes = (glWidth * glHeight) * bytePerPixel; |
776 | getTexel = texFormat.getTexel; |
777 | |
778 | dest = (u32*)malloc(texInfo->textureBytes); |
779 | |
780 | if (!dest) |
781 | { |
782 | LOG(LOG_ERROR, "Malloc failed!\n"); |
783 | return; |
784 | } |
785 | |
786 | |
787 | line = texInfo->line; |
788 | |
789 | if (texInfo->size == G_IM_SIZ_32b) |
790 | line <<= 1; |
791 | |
792 | if (texInfo->maskS) |
793 | { |
794 | clampSClamp = texInfo->clampS ? texInfo->clampWidth - 1 : (texInfo->mirrorS ? (texInfo->width << 1) - 1 : texInfo->width - 1); |
795 | maskSMask = (1 << texInfo->maskS) - 1; |
796 | mirrorSBit = texInfo->mirrorS ? (1 << texInfo->maskS) : 0; |
797 | } |
798 | else |
799 | { |
800 | clampSClamp = min( texInfo->clampWidth, texInfo->width ) - 1; |
801 | maskSMask = 0xFFFF; |
802 | mirrorSBit = 0x0000; |
803 | } |
804 | |
805 | if (texInfo->maskT) |
806 | { |
807 | clampTClamp = texInfo->clampT ? texInfo->clampHeight - 1 : (texInfo->mirrorT ? (texInfo->height << 1) - 1: texInfo->height - 1); |
808 | maskTMask = (1 << texInfo->maskT) - 1; |
809 | mirrorTBit = texInfo->mirrorT ? (1 << texInfo->maskT) : 0; |
810 | } |
811 | else |
812 | { |
813 | clampTClamp = min( texInfo->clampHeight, texInfo->height ) - 1; |
814 | maskTMask = 0xFFFF; |
815 | mirrorTBit = 0x0000; |
816 | } |
817 | |
818 | // Hack for Zelda warp texture |
819 | if (((texInfo->tMem << 3) + (texInfo->width * texInfo->height << texInfo->size >> 1)) > 4096) |
820 | { |
821 | texInfo->tMem = 0; |
822 | } |
823 | |
824 | // limit clamp values to min-0 (Perfect Dark has height=0 textures, making negative clamps) |
825 | if (clampTClamp & 0x8000) clampTClamp = 0; |
826 | if (clampSClamp & 0x8000) clampSClamp = 0; |
827 | |
828 | j = 0; |
829 | for (y = 0; y < texInfo->realHeight; y++) |
830 | { |
831 | ty = min(y, clampTClamp) & maskTMask; |
832 | if (y & mirrorTBit) ty ^= maskTMask; |
833 | src = &TMEM[(texInfo->tMem + line * ty) & 511]; |
834 | i = (ty & 1) << 1; |
835 | for (x = 0; x < texInfo->realWidth; x++) |
836 | { |
837 | tx = min(x, clampSClamp) & maskSMask; |
838 | |
839 | if (x & mirrorSBit) tx ^= maskSMask; |
840 | |
841 | if (bytePerPixel == 4) |
842 | { |
843 | ((u32*)dest)[j] = getTexel(src, tx, i, texInfo->palette); |
844 | } |
845 | else if (bytePerPixel == 2) |
846 | { |
847 | ((u16*)dest)[j] = getTexel(src, tx, i, texInfo->palette); |
848 | } |
849 | else if (bytePerPixel == 1) |
850 | { |
851 | ((u8*)dest)[j] = getTexel(src, tx, i, texInfo->palette); |
852 | } |
853 | j++; |
854 | } |
855 | } |
856 | |
857 | if (!config.texture.sai2x || (texFormat.format == FORMAT_I8) || (texFormat.format == FORMAT_IA88)) |
858 | { |
859 | #ifdef PRINT_TEXTUREFORMAT |
860 | printf("j=%u DEST=0x%x SIZE=%i F=0x%x, W=%i, H=%i, T=0x%x\n", j, dest, texInfo->textureBytes,glFormat, glWidth, glHeight, glType); fflush(stdout); |
861 | #endif |
862 | glTexImage2D( GL_TEXTURE_2D, 0, glFormat, glWidth, glHeight, 0, glFormat, glType, dest); |
863 | } |
864 | else |
865 | { |
866 | LOG(LOG_VERBOSE, "Using 2xSAI Filter on Texture\n"); |
867 | |
868 | texInfo->textureBytes <<= 2; |
869 | |
870 | scaledDest = (u32*)malloc( texInfo->textureBytes ); |
871 | |
872 | if (glType == GL_UNSIGNED_BYTE) |
873 | _2xSaI8888( (u32*)dest, (u32*)scaledDest, texInfo->realWidth, texInfo->realHeight, 1, 1 ); |
874 | else if (glType == GL_UNSIGNED_SHORT_4_4_4_4) |
875 | _2xSaI4444( (u16*)dest, (u16*)scaledDest, texInfo->realWidth, texInfo->realHeight, 1, 1 ); |
876 | else |
877 | _2xSaI5551( (u16*)dest, (u16*)scaledDest, texInfo->realWidth, texInfo->realHeight, 1, 1 ); |
878 | |
879 | glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, texInfo->realWidth << 1, texInfo->realHeight << 1, 0, GL_RGBA, glType, scaledDest ); |
880 | |
881 | free( scaledDest ); |
882 | } |
883 | |
884 | free(dest); |
885 | |
886 | if (config.texture.enableMipmap) |
887 | glGenerateMipmap(GL_TEXTURE_2D); |
888 | |
889 | } |
890 | |
891 | #define max(a,b) ((a) > (b) ? (a) : (b)) |
892 | |
893 | u32 TextureCache_CalculateCRC( u32 t, u32 width, u32 height ) |
894 | { |
895 | u32 crc; |
896 | u32 y, /*i,*/ bpl, lineBytes, line; |
897 | void *src; |
898 | |
899 | bpl = width << gSP.textureTile[t]->size >> 1; |
900 | lineBytes = gSP.textureTile[t]->line << 3; |
901 | |
902 | line = gSP.textureTile[t]->line; |
903 | if (gSP.textureTile[t]->size == G_IM_SIZ_32b) |
904 | line <<= 1; |
905 | |
906 | crc = 0xFFFFFFFF; |
907 | |
908 | #ifdef __CRC_OPT |
909 | unsigned n = (config.texture.fastCRC) ? max(1, height / 8) : 1; |
910 | #else |
911 | unsigned n = 1; |
912 | #endif |
913 | |
914 | for (y = 0; y < height; y += n) |
915 | { |
916 | src = (void*) &TMEM[(gSP.textureTile[t]->tmem + (y * line)) & 511]; |
917 | crc = CRC_Calculate( crc, src, bpl ); |
918 | } |
919 | |
920 | if (gSP.textureTile[t]->format == G_IM_FMT_CI) |
921 | { |
922 | if (gSP.textureTile[t]->size == G_IM_SIZ_4b) |
923 | crc = CRC_Calculate( crc, &gDP.paletteCRC16[gSP.textureTile[t]->palette], 4 ); |
924 | else if (gSP.textureTile[t]->size == G_IM_SIZ_8b) |
925 | crc = CRC_Calculate( crc, &gDP.paletteCRC256, 4 ); |
926 | } |
927 | return crc; |
928 | } |
929 | |
930 | void TextureCache_ActivateTexture( u32 t, CachedTexture *texture ) |
931 | { |
932 | |
933 | #ifdef __HASHMAP_OPT |
934 | cache.hash.insert(texture->crc, texture); |
935 | #endif |
936 | |
937 | glActiveTexture( GL_TEXTURE0 + t ); |
938 | glBindTexture( GL_TEXTURE_2D, texture->glName ); |
939 | |
940 | // Set filter mode. Almost always bilinear, but check anyways |
941 | if ((gDP.otherMode.textureFilter == G_TF_BILERP) || (gDP.otherMode.textureFilter == G_TF_AVERAGE) || (config.texture.forceBilinear)) |
942 | { |
943 | glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); |
944 | glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); |
945 | } |
946 | else |
947 | { |
948 | glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); |
949 | glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); |
950 | } |
951 | |
952 | // Set clamping modes |
953 | glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, (texture->clampS) ? GL_CLAMP_TO_EDGE : GL_REPEAT ); |
954 | glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, (texture->clampT) ? GL_CLAMP_TO_EDGE : GL_REPEAT ); |
955 | |
956 | if (config.texture.maxAnisotropy > 0) |
957 | { |
958 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, config.texture.maxAnisotropy); |
959 | } |
960 | |
961 | texture->lastDList = RSP.DList; |
962 | TextureCache_MoveToTop( texture ); |
963 | cache.current[t] = texture; |
964 | } |
965 | |
966 | void TextureCache_ActivateDummy( u32 t) |
967 | { |
968 | glActiveTexture(GL_TEXTURE0 + t); |
969 | glBindTexture(GL_TEXTURE_2D, cache.dummy->glName ); |
970 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
971 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
972 | } |
973 | |
974 | int _background_compare(CachedTexture *current, u32 crc) |
975 | { |
976 | if ((current != NULL) && |
977 | (current->crc == crc) && |
978 | (current->width == gSP.bgImage.width) && |
979 | (current->height == gSP.bgImage.height) && |
980 | (current->format == gSP.bgImage.format) && |
981 | (current->size == gSP.bgImage.size)) |
982 | return 1; |
983 | else |
984 | return 0; |
985 | } |
986 | |
987 | void TextureCache_UpdateBackground() |
988 | { |
989 | u32 numBytes = gSP.bgImage.width * gSP.bgImage.height << gSP.bgImage.size >> 1; |
990 | u32 crc; |
991 | |
992 | crc = CRC_Calculate( 0xFFFFFFFF, &RDRAM[gSP.bgImage.address], numBytes ); |
993 | |
994 | if (gSP.bgImage.format == G_IM_FMT_CI) |
995 | { |
996 | if (gSP.bgImage.size == G_IM_SIZ_4b) |
997 | crc = CRC_Calculate( crc, &gDP.paletteCRC16[gSP.bgImage.palette], 4 ); |
998 | else if (gSP.bgImage.size == G_IM_SIZ_8b) |
999 | crc = CRC_Calculate( crc, &gDP.paletteCRC256, 4 ); |
1000 | } |
1001 | |
1002 | //before we traverse cache, check to see if texture is already bound: |
1003 | if (_background_compare(cache.current[0], crc)) |
1004 | { |
1005 | return; |
1006 | } |
1007 | |
1008 | #ifdef __HASHMAP_OPT |
1009 | CachedTexture *tex = cache.hash.find(crc); |
1010 | if (tex) |
1011 | { |
1012 | if (_background_compare(tex, crc)) |
1013 | { |
1014 | TextureCache_ActivateTexture(0, tex); |
1015 | cache.hits++; |
1016 | return; |
1017 | } |
1018 | } |
1019 | #endif |
1020 | |
1021 | CachedTexture *current = cache.top; |
1022 | while (current) |
1023 | { |
1024 | if (_background_compare(current, crc)) |
1025 | { |
1026 | TextureCache_ActivateTexture( 0, current ); |
1027 | cache.hits++; |
1028 | return; |
1029 | } |
1030 | current = current->lower; |
1031 | } |
1032 | cache.misses++; |
1033 | |
1034 | glActiveTexture(GL_TEXTURE0); |
1035 | cache.current[0] = TextureCache_AddTop(); |
1036 | |
1037 | glBindTexture( GL_TEXTURE_2D, cache.current[0]->glName ); |
1038 | cache.current[0]->address = gSP.bgImage.address; |
1039 | cache.current[0]->crc = crc; |
1040 | cache.current[0]->format = gSP.bgImage.format; |
1041 | cache.current[0]->size = gSP.bgImage.size; |
1042 | cache.current[0]->width = gSP.bgImage.width; |
1043 | cache.current[0]->height = gSP.bgImage.height; |
1044 | cache.current[0]->clampWidth = gSP.bgImage.width; |
1045 | cache.current[0]->clampHeight = gSP.bgImage.height; |
1046 | cache.current[0]->palette = gSP.bgImage.palette; |
1047 | cache.current[0]->maskS = 0; |
1048 | cache.current[0]->maskT = 0; |
1049 | cache.current[0]->mirrorS = 0; |
1050 | cache.current[0]->mirrorT = 0; |
1051 | cache.current[0]->clampS = 1; |
1052 | cache.current[0]->clampT = 1; |
1053 | cache.current[0]->line = 0; |
1054 | cache.current[0]->tMem = 0; |
1055 | cache.current[0]->lastDList = RSP.DList; |
1056 | |
1057 | cache.current[0]->realWidth = (config.texture.pow2) ? pow2(gSP.bgImage.width ) : gSP.bgImage.width; |
1058 | cache.current[0]->realHeight = (config.texture.pow2) ? pow2(gSP.bgImage.height) : gSP.bgImage.height; |
1059 | |
1060 | cache.current[0]->scaleS = 1.0f / (f32)(cache.current[0]->realWidth); |
1061 | cache.current[0]->scaleT = 1.0f / (f32)(cache.current[0]->realHeight); |
1062 | cache.current[0]->shiftScaleS = 1.0f; |
1063 | cache.current[0]->shiftScaleT = 1.0f; |
1064 | |
1065 | TextureCache_LoadBackground( cache.current[0] ); |
1066 | TextureCache_ActivateTexture( 0, cache.current[0] ); |
1067 | |
1068 | cache.cachedBytes += cache.current[0]->textureBytes; |
1069 | } |
1070 | |
1071 | int _texture_compare(u32 t, CachedTexture *current, u32 crc, u32 width, u32 height, u32 clampWidth, u32 clampHeight) |
1072 | { |
1073 | if ((current != NULL) && |
1074 | (current->crc == crc) && |
1075 | (current->width == width) && |
1076 | (current->height == height) && |
1077 | (current->clampWidth == clampWidth) && |
1078 | (current->clampHeight == clampHeight) && |
1079 | (current->maskS == gSP.textureTile[t]->masks) && |
1080 | (current->maskT == gSP.textureTile[t]->maskt) && |
1081 | (current->mirrorS == gSP.textureTile[t]->mirrors) && |
1082 | (current->mirrorT == gSP.textureTile[t]->mirrort) && |
1083 | (current->clampS == gSP.textureTile[t]->clamps) && |
1084 | (current->clampT == gSP.textureTile[t]->clampt) && |
1085 | (current->format == gSP.textureTile[t]->format) && |
1086 | (current->size == gSP.textureTile[t]->size)) |
1087 | return 1; |
1088 | else |
1089 | return 0; |
1090 | } |
1091 | |
1092 | |
1093 | void TextureCache_Update( u32 t ) |
1094 | { |
1095 | CachedTexture *current; |
1096 | |
1097 | u32 crc, maxTexels; |
1098 | u32 tileWidth, maskWidth, loadWidth, lineWidth, clampWidth, height; |
1099 | u32 tileHeight, maskHeight, loadHeight, lineHeight, clampHeight, width; |
1100 | |
1101 | if (gDP.textureMode == TEXTUREMODE_BGIMAGE) |
1102 | { |
1103 | TextureCache_UpdateBackground(); |
1104 | return; |
1105 | } |
1106 | |
1107 | TextureFormat texFormat; |
1108 | __texture_format(gSP.textureTile[t]->size, gSP.textureTile[t]->format, &texFormat); |
1109 | |
1110 | maxTexels = texFormat.maxTexels; |
1111 | |
1112 | // Here comes a bunch of code that just calculates the texture size...I wish there was an easier way... |
1113 | tileWidth = gSP.textureTile[t]->lrs - gSP.textureTile[t]->uls + 1; |
1114 | tileHeight = gSP.textureTile[t]->lrt - gSP.textureTile[t]->ult + 1; |
1115 | |
1116 | maskWidth = 1 << gSP.textureTile[t]->masks; |
1117 | maskHeight = 1 << gSP.textureTile[t]->maskt; |
1118 | |
1119 | loadWidth = gDP.loadTile->lrs - gDP.loadTile->uls + 1; |
1120 | loadHeight = gDP.loadTile->lrt - gDP.loadTile->ult + 1; |
1121 | |
1122 | lineWidth = gSP.textureTile[t]->line << texFormat.lineShift; |
1123 | |
1124 | if (lineWidth) // Don't allow division by zero |
1125 | lineHeight = min( maxTexels / lineWidth, tileHeight ); |
1126 | else |
1127 | lineHeight = 0; |
1128 | |
1129 | if (gDP.textureMode == TEXTUREMODE_TEXRECT) |
1130 | { |
1131 | u32 texRectWidth = gDP.texRect.width - gSP.textureTile[t]->uls; |
1132 | u32 texRectHeight = gDP.texRect.height - gSP.textureTile[t]->ult; |
1133 | |
1134 | if (gSP.textureTile[t]->masks && ((maskWidth * maskHeight) <= maxTexels)) |
1135 | width = maskWidth; |
1136 | else if ((tileWidth * tileHeight) <= maxTexels) |
1137 | width = tileWidth; |
1138 | else if ((tileWidth * texRectHeight) <= maxTexels) |
1139 | width = tileWidth; |
1140 | else if ((texRectWidth * tileHeight) <= maxTexels) |
1141 | width = gDP.texRect.width; |
1142 | else if ((texRectWidth * texRectHeight) <= maxTexels) |
1143 | width = gDP.texRect.width; |
1144 | else if (gDP.loadType == LOADTYPE_TILE) |
1145 | width = loadWidth; |
1146 | else |
1147 | width = lineWidth; |
1148 | |
1149 | if (gSP.textureTile[t]->maskt && ((maskWidth * maskHeight) <= maxTexels)) |
1150 | height = maskHeight; |
1151 | else if ((tileWidth * tileHeight) <= maxTexels) |
1152 | height = tileHeight; |
1153 | else if ((tileWidth * texRectHeight) <= maxTexels) |
1154 | height = gDP.texRect.height; |
1155 | else if ((texRectWidth * tileHeight) <= maxTexels) |
1156 | height = tileHeight; |
1157 | else if ((texRectWidth * texRectHeight) <= maxTexels) |
1158 | height = gDP.texRect.height; |
1159 | else if (gDP.loadType == LOADTYPE_TILE) |
1160 | height = loadHeight; |
1161 | else |
1162 | height = lineHeight; |
1163 | } |
1164 | else |
1165 | { |
1166 | if (gSP.textureTile[t]->masks && ((maskWidth * maskHeight) <= maxTexels)) |
1167 | width = maskWidth; |
1168 | else if ((tileWidth * tileHeight) <= maxTexels) |
1169 | width = tileWidth; |
1170 | else if (gDP.loadType == LOADTYPE_TILE) |
1171 | width = loadWidth; |
1172 | else |
1173 | width = lineWidth; |
1174 | |
1175 | if (gSP.textureTile[t]->maskt && ((maskWidth * maskHeight) <= maxTexels)) |
1176 | height = maskHeight; |
1177 | else if ((tileWidth * tileHeight) <= maxTexels) |
1178 | height = tileHeight; |
1179 | else if (gDP.loadType == LOADTYPE_TILE) |
1180 | height = loadHeight; |
1181 | else |
1182 | height = lineHeight; |
1183 | } |
1184 | |
1185 | clampWidth = gSP.textureTile[t]->clamps ? tileWidth : width; |
1186 | clampHeight = gSP.textureTile[t]->clampt ? tileHeight : height; |
1187 | |
1188 | if (clampWidth > 256) |
1189 | gSP.textureTile[t]->clamps = 0; |
1190 | if (clampHeight > 256) |
1191 | gSP.textureTile[t]->clampt = 0; |
1192 | |
1193 | // Make sure masking is valid |
1194 | if (maskWidth > width) |
1195 | { |
1196 | gSP.textureTile[t]->masks = powof( width ); |
1197 | maskWidth = 1 << gSP.textureTile[t]->masks; |
1198 | } |
1199 | |
1200 | if (maskHeight > height) |
1201 | { |
1202 | gSP.textureTile[t]->maskt = powof( height ); |
1203 | maskHeight = 1 << gSP.textureTile[t]->maskt; |
1204 | } |
1205 | |
1206 | crc = TextureCache_CalculateCRC( t, width, height ); |
1207 | |
1208 | //before we traverse cache, check to see if texture is already bound: |
1209 | if (_texture_compare(t, cache.current[t], crc, width, height, clampWidth, clampHeight)) |
1210 | { |
1211 | cache.hits++; |
1212 | return; |
1213 | } |
1214 | |
1215 | #ifdef __HASHMAP_OPT |
1216 | CachedTexture *tex = cache.hash.find(crc); |
1217 | if (tex) |
1218 | { |
1219 | if (_texture_compare(t, tex, crc, width, height, clampWidth, clampHeight)) |
1220 | { |
1221 | TextureCache_ActivateTexture( t, tex); |
1222 | cache.hits++; |
1223 | return; |
1224 | } |
1225 | } |
1226 | #endif |
1227 | |
1228 | current = cache.top; |
1229 | while (current) |
1230 | { |
1231 | if (_texture_compare(t, current, crc, width, height, clampWidth, clampHeight)) |
1232 | { |
1233 | TextureCache_ActivateTexture( t, current ); |
1234 | cache.hits++; |
1235 | return; |
1236 | } |
1237 | |
1238 | current = current->lower; |
1239 | } |
1240 | |
1241 | cache.misses++; |
1242 | |
1243 | glActiveTexture( GL_TEXTURE0 + t); |
1244 | |
1245 | cache.current[t] = TextureCache_AddTop(); |
1246 | |
1247 | if (cache.current[t] == NULL) |
1248 | { |
1249 | LOG(LOG_ERROR, "Texture Cache Failure\n"); |
1250 | } |
1251 | |
1252 | glBindTexture( GL_TEXTURE_2D, cache.current[t]->glName ); |
1253 | |
1254 | cache.current[t]->address = gDP.textureImage.address; |
1255 | cache.current[t]->crc = crc; |
1256 | |
1257 | cache.current[t]->format = gSP.textureTile[t]->format; |
1258 | cache.current[t]->size = gSP.textureTile[t]->size; |
1259 | |
1260 | cache.current[t]->width = width; |
1261 | cache.current[t]->height = height; |
1262 | cache.current[t]->clampWidth = clampWidth; |
1263 | cache.current[t]->clampHeight = clampHeight; |
1264 | cache.current[t]->palette = gSP.textureTile[t]->palette; |
1265 | cache.current[t]->maskS = gSP.textureTile[t]->masks; |
1266 | cache.current[t]->maskT = gSP.textureTile[t]->maskt; |
1267 | cache.current[t]->mirrorS = gSP.textureTile[t]->mirrors; |
1268 | cache.current[t]->mirrorT = gSP.textureTile[t]->mirrort; |
1269 | cache.current[t]->clampS = gSP.textureTile[t]->clamps; |
1270 | cache.current[t]->clampT = gSP.textureTile[t]->clampt; |
1271 | cache.current[t]->line = gSP.textureTile[t]->line; |
1272 | cache.current[t]->tMem = gSP.textureTile[t]->tmem; |
1273 | cache.current[t]->lastDList = RSP.DList; |
1274 | |
1275 | |
1276 | if (cache.current[t]->clampS) |
1277 | cache.current[t]->realWidth = (config.texture.pow2) ? pow2(clampWidth) : clampWidth; |
1278 | else if (cache.current[t]->mirrorS) |
1279 | cache.current[t]->realWidth = maskWidth << 1; |
1280 | else |
1281 | cache.current[t]->realWidth = (config.texture.pow2) ? pow2(width) : width; |
1282 | |
1283 | if (cache.current[t]->clampT) |
1284 | cache.current[t]->realHeight = (config.texture.pow2) ? pow2(clampHeight) : clampHeight; |
1285 | else if (cache.current[t]->mirrorT) |
1286 | cache.current[t]->realHeight = maskHeight << 1; |
1287 | else |
1288 | cache.current[t]->realHeight = (config.texture.pow2) ? pow2(height) : height; |
1289 | |
1290 | |
1291 | cache.current[t]->scaleS = 1.0f / (f32)(cache.current[t]->realWidth); |
1292 | cache.current[t]->scaleT = 1.0f / (f32)(cache.current[t]->realHeight); |
1293 | |
1294 | // Hack for Zelda Sun |
1295 | if ((config.hackZelda) && (gDP.combine.mux == 0x00262a60150c937fLL)) |
1296 | { |
1297 | if ((cache.current[t]->format = G_IM_FMT_I) && (cache.current[t]->size == G_IM_SIZ_8b) && |
1298 | (cache.current[t]->width == 64)) |
1299 | { |
1300 | cache.current[t]->scaleS *= 0.5f; |
1301 | cache.current[t]->scaleT *= 0.5f; |
1302 | } |
1303 | } |
1304 | |
1305 | cache.current[t]->shiftScaleS = 1.0f; |
1306 | cache.current[t]->shiftScaleT = 1.0f; |
1307 | |
1308 | cache.current[t]->offsetS = config.texture.sai2x ? 0.25f : 0.5f; |
1309 | cache.current[t]->offsetT = config.texture.sai2x ? 0.25f : 0.5f; |
1310 | |
1311 | if (gSP.textureTile[t]->shifts > 10) |
1312 | cache.current[t]->shiftScaleS = (f32)(1 << (16 - gSP.textureTile[t]->shifts)); |
1313 | else if (gSP.textureTile[t]->shifts > 0) |
1314 | cache.current[t]->shiftScaleS /= (f32)(1 << gSP.textureTile[t]->shifts); |
1315 | |
1316 | if (gSP.textureTile[t]->shiftt > 10) |
1317 | cache.current[t]->shiftScaleT = (f32)(1 << (16 - gSP.textureTile[t]->shiftt)); |
1318 | else if (gSP.textureTile[t]->shiftt > 0) |
1319 | cache.current[t]->shiftScaleT /= (f32)(1 << gSP.textureTile[t]->shiftt); |
1320 | |
1321 | TextureCache_Load( cache.current[t] ); |
1322 | TextureCache_ActivateTexture( t, cache.current[t] ); |
1323 | |
1324 | cache.cachedBytes += cache.current[t]->textureBytes; |
1325 | } |
1326 | |
1327 | void TextureCache_ActivateNoise(u32 t) |
1328 | { |
1329 | glActiveTexture(GL_TEXTURE0 + t); |
1330 | glBindTexture(GL_TEXTURE_2D, cache.glNoiseNames[RSP.DList & 0x1F]); |
1331 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); |
1332 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); |
1333 | } |
1334 | |