--- /dev/null
+#include <time.h>
+#include <stdlib.h>
+#include <memory.h>
+
+#ifndef min
+#define min(a,b) ((a) < (b) ? (a) : (b))
+#endif
+
+#include "Common.h"
+#include "Config.h"
+#include "OpenGL.h"
+#include "Textures.h"
+#include "GBI.h"
+#include "RSP.h"
+#include "gDP.h"
+#include "gSP.h"
+#include "N64.h"
+#include "CRC.h"
+#include "convert.h"
+#include "2xSAI.h"
+//#include "FrameBuffer.h"
+
+#define FORMAT_NONE 0
+#define FORMAT_I8 1
+#define FORMAT_IA88 2
+#define FORMAT_RGBA4444 3
+#define FORMAT_RGBA5551 4
+#define FORMAT_RGBA8888 5
+
+//#define PRINT_TEXTUREFORMAT
+
+TextureCache cache;
+
+typedef u32 (*GetTexelFunc)( void *src, u16 x, u16 i, u8 palette );
+
+u32 GetNone( void *src, u16 x, u16 i, u8 palette )
+{
+ return 0x00000000;
+}
+
+u32 GetCI4IA_RGBA4444( void *src, u16 x, u16 i, u8 palette )
+{
+ u8 color4B = ((u8*)src)[(x>>1)^(i<<1)];
+ if (x & 1)
+ return IA88_RGBA4444( *(u16*)&TMEM[256 + (palette << 4) + (color4B & 0x0F)] );
+ else
+ return IA88_RGBA4444( *(u16*)&TMEM[256 + (palette << 4) + (color4B >> 4)] );
+}
+
+u32 GetCI4IA_RGBA8888( void *src, u16 x, u16 i, u8 palette )
+{
+ u8 color4B = ((u8*)src)[(x>>1)^(i<<1)];
+ if (x & 1)
+ return IA88_RGBA8888( *(u16*)&TMEM[256 + (palette << 4) + (color4B & 0x0F)] );
+ else
+ return IA88_RGBA8888( *(u16*)&TMEM[256 + (palette << 4) + (color4B >> 4)] );
+}
+
+u32 GetCI4RGBA_RGBA5551( void *src, u16 x, u16 i, u8 palette )
+{
+ u8 color4B = ((u8*)src)[(x>>1)^(i<<1)];
+ if (x & 1)
+ return RGBA5551_RGBA5551( *(u16*)&TMEM[256 + (palette << 4) + (color4B & 0x0F)] );
+ else
+ return RGBA5551_RGBA5551( *(u16*)&TMEM[256 + (palette << 4) + (color4B >> 4)] );
+}
+
+u32 GetCI4RGBA_RGBA8888( void *src, u16 x, u16 i, u8 palette )
+{
+ u8 color4B = ((u8*)src)[(x>>1)^(i<<1)];
+ if (x & 1)
+ return RGBA5551_RGBA8888( *(u16*)&TMEM[256 + (palette << 4) + (color4B & 0x0F)] );
+ else
+ return RGBA5551_RGBA8888( *(u16*)&TMEM[256 + (palette << 4) + (color4B >> 4)] );
+}
+
+u32 GetIA31_RGBA8888( void *src, u16 x, u16 i, u8 palette )
+{
+ u8 color4B = ((u8*)src)[(x>>1)^(i<<1)];
+ return IA31_RGBA8888( (x & 1) ? (color4B & 0x0F) : (color4B >> 4) );
+}
+
+u32 GetIA31_RGBA4444( void *src, u16 x, u16 i, u8 palette )
+{
+ u8 color4B = ((u8*)src)[(x>>1)^(i<<1)];
+ return IA31_RGBA4444( (x & 1) ? (color4B & 0x0F) : (color4B >> 4) );
+}
+
+u32 GetIA31_IA88( void *src, u16 x, u16 i, u8 palette )
+{
+ u8 color4B = ((u8*)src)[(x>>1)^(i<<1)];
+ return IA31_IA88( (x & 1) ? (color4B & 0x0F) : (color4B >> 4) );
+}
+
+u32 GetI4_RGBA8888( void *src, u16 x, u16 i, u8 palette )
+{
+ u8 color4B = ((u8*)src)[(x>>1)^(i<<1)];
+ return I4_RGBA8888( (x & 1) ? (color4B & 0x0F) : (color4B >> 4) );
+}
+
+u32 GetI4_RGBA4444( void *src, u16 x, u16 i, u8 palette )
+{
+ u8 color4B = ((u8*)src)[(x>>1)^(i<<1)];
+ return I4_RGBA4444( (x & 1) ? (color4B & 0x0F) : (color4B >> 4) );
+}
+
+u32 GetI4_I8( void *src, u16 x, u16 i, u8 palette )
+{
+ u8 color4B = ((u8*)src)[(x>>1)^(i<<1)];
+ return I4_I8( (x & 1) ? (color4B & 0x0F) : (color4B >> 4) );
+}
+
+
+u32 GetI4_IA88( void *src, u16 x, u16 i, u8 palette )
+{
+ u8 color4B = ((u8*)src)[(x>>1)^(i<<1)];
+ return I4_IA88( (x & 1) ? (color4B & 0x0F) : (color4B >> 4) );
+}
+
+u32 GetCI8IA_RGBA4444( void *src, u16 x, u16 i, u8 palette )
+{
+ return IA88_RGBA4444( *(u16*)&TMEM[256 + ((u8*)src)[x^(i<<1)]] );
+}
+
+u32 GetCI8IA_RGBA8888( void *src, u16 x, u16 i, u8 palette )
+{
+ return IA88_RGBA8888( *(u16*)&TMEM[256 + ((u8*)src)[x^(i<<1)]] );
+}
+
+u32 GetCI8RGBA_RGBA5551( void *src, u16 x, u16 i, u8 palette )
+{
+ return RGBA5551_RGBA5551( *(u16*)&TMEM[256 + ((u8*)src)[x^(i<<1)]] );
+}
+
+u32 GetCI8RGBA_RGBA8888( void *src, u16 x, u16 i, u8 palette )
+{
+ return RGBA5551_RGBA8888( *(u16*)&TMEM[256 + ((u8*)src)[x^(i<<1)]] );
+}
+
+u32 GetIA44_RGBA8888( void *src, u16 x, u16 i, u8 palette )
+{
+ return IA44_RGBA8888(((u8*)src)[x^(i<<1)]);
+}
+
+u32 GetIA44_RGBA4444( void *src, u16 x, u16 i, u8 palette )
+{
+ return IA44_RGBA4444(((u8*)src)[x^(i<<1)]);
+}
+
+u32 GetIA44_IA88( void *src, u16 x, u16 i, u8 palette )
+{
+ return IA44_IA88(((u8*)src)[x^(i<<1)]);
+}
+
+u32 GetI8_RGBA8888( void *src, u16 x, u16 i, u8 palette )
+{
+ return I8_RGBA8888(((u8*)src)[x^(i<<1)]);
+}
+
+u32 GetI8_I8( void *src, u16 x, u16 i, u8 palette )
+{
+ return ((u8*)src)[x^(i<<1)];
+}
+
+u32 GetI8_IA88( void *src, u16 x, u16 i, u8 palette )
+{
+ return I8_IA88(((u8*)src)[x^(i<<1)]);
+}
+
+u32 GetI8_RGBA4444( void *src, u16 x, u16 i, u8 palette )
+{
+ return I8_RGBA4444(((u8*)src)[x^(i<<1)]);
+}
+
+u32 GetRGBA5551_RGBA8888( void *src, u16 x, u16 i, u8 palette )
+{
+ return RGBA5551_RGBA8888( ((u16*)src)[x^i] );
+}
+
+u32 GetRGBA5551_RGBA5551( void *src, u16 x, u16 i, u8 palette )
+{
+ return RGBA5551_RGBA5551( ((u16*)src)[x^i] );
+}
+
+u32 GetIA88_RGBA8888( void *src, u16 x, u16 i, u8 palette )
+{
+ return IA88_RGBA8888(((u16*)src)[x^i]);
+}
+
+u32 GetIA88_RGBA4444( void *src, u16 x, u16 i, u8 palette )
+{
+ return IA88_RGBA4444(((u16*)src)[x^i]);
+}
+
+u32 GetIA88_IA88( void *src, u16 x, u16 i, u8 palette )
+{
+ return IA88_IA88(((u16*)src)[x^i]);
+}
+
+u32 GetRGBA8888_RGBA8888( void *src, u16 x, u16 i, u8 palette )
+{
+ return ((u32*)src)[x^i];
+}
+
+u32 GetRGBA8888_RGBA4444( void *src, u16 x, u16 i, u8 palette )
+{
+ return RGBA8888_RGBA4444(((u32*)src)[x^i]);
+}
+
+
+struct TextureFormat
+{
+ int format;
+ GetTexelFunc getTexel;
+ int lineShift, maxTexels;
+};
+
+
+TextureFormat textureFormatIA[4*6] =
+{
+ // 4-bit
+ { FORMAT_RGBA5551, GetCI4RGBA_RGBA5551, 4, 4096 }, // RGBA (SELECT)
+ { FORMAT_NONE, GetNone, 4, 8192 }, // YUV
+ { FORMAT_RGBA5551, GetCI4RGBA_RGBA5551, 4, 4096 }, // CI
+ { FORMAT_IA88, GetIA31_IA88, 4, 8192 }, // IA
+ { FORMAT_IA88, GetI4_IA88, 4, 8192 }, // I
+ { FORMAT_RGBA8888, GetCI4IA_RGBA8888, 4, 4096 }, // IA Palette
+ // 8-bit
+ { FORMAT_RGBA5551, GetCI8RGBA_RGBA5551, 3, 2048 }, // RGBA (SELECT)
+ { FORMAT_NONE, GetNone, 3, 4096 }, // YUV
+ { FORMAT_RGBA5551, GetCI8RGBA_RGBA5551, 3, 2048 }, // CI
+ { FORMAT_IA88, GetIA44_IA88, 3, 4096 }, // IA
+ { FORMAT_IA88, GetI8_IA88, 3, 4096 }, // I
+ { FORMAT_RGBA8888, GetCI8IA_RGBA8888, 3, 2048 }, // IA Palette
+ // 16-bit
+ { FORMAT_RGBA5551, GetRGBA5551_RGBA5551, 2, 2048 }, // RGBA
+ { FORMAT_NONE, GetNone, 2, 2048 }, // YUV
+ { FORMAT_NONE, GetNone, 2, 2048 }, // CI
+ { FORMAT_IA88, GetIA88_IA88, 2, 2048 }, // IA
+ { FORMAT_NONE, GetNone, 2, 2048 }, // I
+ { FORMAT_NONE, GetNone, 2, 2048 }, // IA Palette
+ // 32-bit
+ { FORMAT_RGBA8888, GetRGBA8888_RGBA8888, 2, 1024 }, // RGBA
+ { FORMAT_NONE, GetNone, 2, 1024 }, // YUV
+ { FORMAT_NONE, GetNone, 2, 1024 }, // CI
+ { FORMAT_NONE, GetNone, 2, 1024 }, // IA
+ { FORMAT_NONE, GetNone, 2, 1024 }, // I
+ { FORMAT_NONE, GetNone, 2, 1024 }, // IA Palette
+};
+
+TextureFormat textureFormatRGBA[4*6] =
+{
+ // 4-bit
+ { FORMAT_RGBA5551, GetCI4RGBA_RGBA5551, 4, 4096 }, // RGBA (SELECT)
+ { FORMAT_NONE, GetNone, 4, 8192 }, // YUV
+ { FORMAT_RGBA5551, GetCI4RGBA_RGBA5551, 4, 4096 }, // CI
+ { FORMAT_RGBA4444, GetIA31_RGBA4444, 4, 8192 }, // IA
+ { FORMAT_RGBA4444, GetI4_RGBA4444, 4, 8192 }, // I
+ { FORMAT_RGBA8888, GetCI4IA_RGBA8888, 4, 4096 }, // IA Palette
+ // 8-bit
+ { FORMAT_RGBA5551, GetCI8RGBA_RGBA5551, 3, 2048 }, // RGBA (SELECT)
+ { FORMAT_NONE, GetNone, 3, 4096 }, // YUV
+ { FORMAT_RGBA5551, GetCI8RGBA_RGBA5551, 3, 2048 }, // CI
+ { FORMAT_RGBA4444, GetIA44_RGBA4444, 3, 4096 }, // IA
+ { FORMAT_RGBA8888, GetI8_RGBA8888, 3, 4096 }, // I
+ { FORMAT_RGBA8888, GetCI8IA_RGBA8888, 3, 2048 }, // IA Palette
+ // 16-bit
+ { FORMAT_RGBA5551, GetRGBA5551_RGBA5551, 2, 2048 }, // RGBA
+ { FORMAT_NONE, GetNone, 2, 2048 }, // YUV
+ { FORMAT_NONE, GetNone, 2, 2048 }, // CI
+ { FORMAT_RGBA8888, GetIA88_RGBA8888, 2, 2048 }, // IA
+ { FORMAT_NONE, GetNone, 2, 2048 }, // I
+ { FORMAT_NONE, GetNone, 2, 2048 }, // IA Palette
+ // 32-bit
+ { FORMAT_RGBA8888, GetRGBA8888_RGBA8888, 2, 1024 }, // RGBA
+ { FORMAT_NONE, GetNone, 2, 1024 }, // YUV
+ { FORMAT_NONE, GetNone, 2, 1024 }, // CI
+ { FORMAT_NONE, GetNone, 2, 1024 }, // IA
+ { FORMAT_NONE, GetNone, 2, 1024 }, // I
+ { FORMAT_NONE, GetNone, 2, 1024 }, // IA Palette
+};
+
+
+TextureFormat *textureFormat = textureFormatIA;
+
+void __texture_format_rgba(int size, int format, TextureFormat *texFormat)
+{
+ if (size < G_IM_SIZ_16b)
+ {
+ if (gDP.otherMode.textureLUT == G_TT_NONE)
+ *texFormat = textureFormat[size*6 + G_IM_FMT_I];
+ else if (gDP.otherMode.textureLUT == G_TT_RGBA16)
+ *texFormat = textureFormat[size*6 + G_IM_FMT_CI];
+ else
+ *texFormat = textureFormat[size*6 + G_IM_FMT_IA];
+ }
+ else
+ {
+ *texFormat = textureFormat[size*6 + G_IM_FMT_RGBA];
+ }
+}
+
+void __texture_format_ci(int size, int format, TextureFormat *texFormat)
+{
+ switch(size)
+ {
+ case G_IM_SIZ_4b:
+ if (gDP.otherMode.textureLUT == G_TT_IA16)
+ *texFormat = textureFormat[G_IM_SIZ_4b*6 + G_IM_FMT_CI_IA];
+ else
+ *texFormat = textureFormat[G_IM_SIZ_4b*6 + G_IM_FMT_CI];
+ break;
+
+ case G_IM_SIZ_8b:
+ if (gDP.otherMode.textureLUT == G_TT_NONE)
+ *texFormat = textureFormat[G_IM_SIZ_8b*6 + G_IM_FMT_I];
+ else if (gDP.otherMode.textureLUT == G_TT_IA16)
+ *texFormat = textureFormat[G_IM_SIZ_8b*6 + G_IM_FMT_CI_IA];
+ else
+ *texFormat = textureFormat[G_IM_SIZ_8b*6 + G_IM_FMT_CI];
+ break;
+
+ default:
+ *texFormat = textureFormat[size*6 + format];
+ }
+}
+
+void __texture_format(int size, int format, TextureFormat *texFormat)
+{
+ if (format == G_IM_FMT_RGBA)
+ {
+ __texture_format_rgba(size, format, texFormat);
+ }
+ else if (format == G_IM_FMT_YUV)
+ {
+ *texFormat = textureFormat[size*6 + G_IM_FMT_YUV];
+ }
+ else if (format == G_IM_FMT_CI)
+ {
+ __texture_format_ci(size, format, texFormat);
+ }
+ else if (format == G_IM_FMT_IA)
+ {
+ if (gDP.otherMode.textureLUT != G_TT_NONE)
+ __texture_format_ci(size, format, texFormat);
+ else
+ *texFormat = textureFormat[size*6 + G_IM_FMT_IA];
+ }
+ else if (format == G_IM_FMT_I)
+ {
+ if (gDP.otherMode.textureLUT == G_TT_NONE)
+ *texFormat = textureFormat[size*6 + G_IM_FMT_I];
+ else
+ __texture_format_ci(size, format, texFormat);
+ }
+}
+
+
+int isTexCacheInit = 0;
+
+void TextureCache_Init()
+{
+ u32 dummyTexture[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+ isTexCacheInit = 1;
+ cache.current[0] = NULL;
+ cache.current[1] = NULL;
+ cache.top = NULL;
+ cache.bottom = NULL;
+ cache.numCached = 0;
+ cache.cachedBytes = 0;
+
+#ifdef __HASHMAP_OPT
+ cache.hash.init(11);
+#endif
+
+ if (config.texture.useIA) textureFormat = textureFormatIA;
+ else textureFormat = textureFormatRGBA;
+
+ glPixelStorei(GL_PACK_ALIGNMENT, 1);
+ glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+ glGenTextures( 32, cache.glNoiseNames );
+
+ srand(time(NULL));
+ u8 noise[64*64*2];
+ for (u32 i = 0; i < 32; i++)
+ {
+ glBindTexture( GL_TEXTURE_2D, cache.glNoiseNames[i] );
+ for (u32 y = 0; y < 64; y++)
+ {
+ for (u32 x = 0; x < 64; x++)
+ {
+ u32 r = (rand()&0xFF);
+ noise[y*64*2+x*2] = r;
+ noise[y*64*2+x*2+1] = r;
+ }
+ }
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, 64, 64, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, noise);
+ }
+
+ cache.dummy = TextureCache_AddTop();
+ cache.dummy->address = 0;
+ cache.dummy->clampS = 1;
+ cache.dummy->clampT = 1;
+ cache.dummy->clampWidth = 4;
+ cache.dummy->clampHeight = 4;
+ cache.dummy->crc = 0;
+ cache.dummy->format = 0;
+ cache.dummy->size = 0;
+ cache.dummy->width = 4;
+ cache.dummy->height = 4;
+ cache.dummy->realWidth = 0;
+ cache.dummy->realHeight = 0;
+ cache.dummy->maskS = 0;
+ cache.dummy->maskT = 0;
+ cache.dummy->scaleS = 0.5f;
+ cache.dummy->scaleT = 0.5f;
+ cache.dummy->shiftScaleS = 1.0f;
+ cache.dummy->shiftScaleT = 1.0f;
+ cache.dummy->textureBytes = 64;
+ cache.dummy->tMem = 0;
+
+ glBindTexture( GL_TEXTURE_2D, cache.dummy->glName );
+ glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, dummyTexture);
+
+ cache.cachedBytes = cache.dummy->textureBytes;
+ TextureCache_ActivateDummy(0);
+ TextureCache_ActivateDummy(1);
+ CRC_BuildTable();
+}
+
+bool TextureCache_Verify()
+{
+ u16 i = 0;
+ CachedTexture *current;
+
+ current = cache.top;
+
+ while (current)
+ {
+ i++;
+ current = current->lower;
+ }
+ if (i != cache.numCached) return false;
+
+ i = 0;
+ current = cache.bottom;
+ while (current)
+ {
+ i++;
+ current = current->higher;
+ }
+ if (i != cache.numCached) return false;
+
+ return true;
+}
+
+void TextureCache_RemoveBottom()
+{
+ CachedTexture *newBottom = cache.bottom->higher;
+
+#ifdef __HASHMAP_OPT
+ CachedTexture* tex= cache.hash.find(cache.bottom->crc);
+ if (tex == cache.bottom)
+ cache.hash.insert(cache.bottom->crc, NULL);
+#endif
+
+ glDeleteTextures( 1, &cache.bottom->glName );
+ cache.cachedBytes -= cache.bottom->textureBytes;
+
+ if (cache.bottom == cache.top)
+ cache.top = NULL;
+
+ free( cache.bottom );
+
+ cache.bottom = newBottom;
+
+ if (cache.bottom)
+ cache.bottom->lower = NULL;
+
+ cache.numCached--;
+}
+
+void TextureCache_Remove( CachedTexture *texture )
+{
+ if ((texture == cache.bottom) && (texture == cache.top))
+ {
+ cache.top = NULL;
+ cache.bottom = NULL;
+ }
+ else if (texture == cache.bottom)
+ {
+ cache.bottom = texture->higher;
+
+ if (cache.bottom)
+ cache.bottom->lower = NULL;
+ }
+ else if (texture == cache.top)
+ {
+ cache.top = texture->lower;
+
+ if (cache.top)
+ cache.top->higher = NULL;
+ }
+ else
+ {
+ texture->higher->lower = texture->lower;
+ texture->lower->higher = texture->higher;
+ }
+
+#ifdef __HASHMAP_OPT
+ CachedTexture* tex= cache.hash.find(texture->crc);
+ if (tex == texture);
+ cache.hash.insert(texture->crc, NULL);
+#endif
+
+ glDeleteTextures( 1, &texture->glName );
+ cache.cachedBytes -= texture->textureBytes;
+ free( texture );
+
+ cache.numCached--;
+}
+
+CachedTexture *TextureCache_AddTop()
+{
+ while (cache.cachedBytes > TEXTURECACHE_MAX)
+ {
+ if (cache.bottom != cache.dummy)
+ TextureCache_RemoveBottom();
+ else if (cache.dummy->higher)
+ TextureCache_Remove( cache.dummy->higher );
+ }
+
+ CachedTexture *newtop = (CachedTexture*)malloc( sizeof( CachedTexture ) );
+
+ glGenTextures( 1, &newtop->glName );
+
+ newtop->lower = cache.top;
+ newtop->higher = NULL;
+
+ if (cache.top)
+ cache.top->higher = newtop;
+
+ if (!cache.bottom)
+ cache.bottom = newtop;
+
+ cache.top = newtop;
+
+ cache.numCached++;
+
+ return newtop;
+}
+
+void TextureCache_MoveToTop( CachedTexture *newtop )
+{
+ if (newtop == cache.top) return;
+
+ if (newtop == cache.bottom)
+ {
+ cache.bottom = newtop->higher;
+ cache.bottom->lower = NULL;
+ }
+ else
+ {
+ newtop->higher->lower = newtop->lower;
+ newtop->lower->higher = newtop->higher;
+ }
+
+ newtop->higher = NULL;
+ newtop->lower = cache.top;
+ cache.top->higher = newtop;
+ cache.top = newtop;
+}
+
+void TextureCache_Destroy()
+{
+ while (cache.bottom)
+ TextureCache_RemoveBottom();
+
+ glDeleteTextures( 32, cache.glNoiseNames );
+ glDeleteTextures( 1, &cache.dummy->glName );
+
+#ifdef __HASHMAP_OPT
+ cache.hash.destroy();
+#endif
+
+ cache.top = NULL;
+ cache.bottom = NULL;
+}
+
+
+
+void TextureCache_LoadBackground( CachedTexture *texInfo )
+{
+ u32 *dest, *scaledDest;
+ u8 *swapped, *src;
+ u32 numBytes, bpl;
+ u32 x, y, j, tx, ty;
+ u16 clampSClamp, clampTClamp;
+
+ int bytePerPixel=0;
+ TextureFormat texFormat;
+ GetTexelFunc getTexel;
+ GLint glWidth=0, glHeight=0;
+ GLenum glType=0;
+ GLenum glFormat=0;
+
+ __texture_format(texInfo->size, texInfo->format, &texFormat);
+
+#ifdef PRINT_TEXTUREFORMAT
+ printf("BG LUT=%i, TEXTURE SIZE=%i, FORMAT=%i -> GL FORMAT=%i\n", gDP.otherMode.textureLUT, texInfo->size, texInfo->format, texFormat.format); fflush(stdout);
+#endif
+
+ if (texFormat.format == FORMAT_NONE)
+ {
+ LOG(LOG_WARNING, "No Texture Conversion function available, size=%i format=%i\n", texInfo->size, texInfo->format);
+ }
+
+ switch(texFormat.format)
+ {
+ case FORMAT_I8:
+ glFormat = GL_LUMINANCE;
+ glType = GL_UNSIGNED_BYTE;
+ bytePerPixel = 1;
+ break;
+ case FORMAT_IA88:
+ glFormat = GL_LUMINANCE_ALPHA;
+ glType = GL_UNSIGNED_BYTE;
+ bytePerPixel = 2;
+ break;
+ case FORMAT_RGBA4444:
+ glFormat = GL_RGBA;
+ glType = GL_UNSIGNED_SHORT_4_4_4_4;
+ bytePerPixel = 2;
+ break;
+ case FORMAT_RGBA5551:
+ glFormat = GL_RGBA;
+ glType = GL_UNSIGNED_SHORT_5_5_5_1;
+ bytePerPixel = 2;
+ break;
+ case FORMAT_RGBA8888:
+ glFormat = GL_RGBA;
+ glType = GL_UNSIGNED_BYTE;
+ bytePerPixel = 4;
+ break;
+ }
+
+ glWidth = texInfo->realWidth;
+ glHeight = texInfo->realHeight;
+ texInfo->textureBytes = (glWidth * glHeight) * bytePerPixel;
+ getTexel = texFormat.getTexel;
+
+ bpl = gSP.bgImage.width << gSP.bgImage.size >> 1;
+ numBytes = bpl * gSP.bgImage.height;
+ swapped = (u8*) malloc(numBytes);
+ dest = (u32*) malloc(texInfo->textureBytes);
+
+ if (!dest || !swapped)
+ {
+ LOG(LOG_ERROR, "Malloc failed!\n");
+ return;
+ }
+
+ UnswapCopy(&RDRAM[gSP.bgImage.address], swapped, numBytes);
+
+ clampSClamp = texInfo->width - 1;
+ clampTClamp = texInfo->height - 1;
+
+ j = 0;
+ for (y = 0; y < texInfo->realHeight; y++)
+ {
+ ty = min(y, clampTClamp);
+ src = &swapped[bpl * ty];
+ for (x = 0; x < texInfo->realWidth; x++)
+ {
+ tx = min(x, clampSClamp);
+ if (bytePerPixel == 4)
+ ((u32*)dest)[j++] = getTexel(src, tx, 0, texInfo->palette);
+ else if (bytePerPixel == 2)
+ ((u16*)dest)[j++] = getTexel(src, tx, 0, texInfo->palette);
+ else if (bytePerPixel == 1)
+ ((u8*)dest)[j++] = getTexel(src, tx, 0, texInfo->palette);
+ }
+ }
+
+ if (!config.texture.sai2x || (texFormat.format == FORMAT_I8 || texFormat.format == FORMAT_IA88))
+ {
+ glTexImage2D( GL_TEXTURE_2D, 0, glFormat, glWidth, glHeight, 0, glFormat, glType, dest);
+ }
+ else
+ {
+ LOG(LOG_VERBOSE, "Using 2xSAI Filter on Texture\n");
+ texInfo->textureBytes <<= 2;
+
+ scaledDest = (u32*) malloc( texInfo->textureBytes );
+
+ if (glType == GL_UNSIGNED_BYTE)
+ _2xSaI8888( (u32*)dest, (u32*)scaledDest, texInfo->realWidth, texInfo->realHeight, texInfo->clampS, texInfo->clampT );
+ if (glType == GL_UNSIGNED_SHORT_4_4_4_4)
+ _2xSaI4444( (u16*)dest, (u16*)scaledDest, texInfo->realWidth, texInfo->realHeight, texInfo->clampS, texInfo->clampT );
+ else
+ _2xSaI5551( (u16*)dest, (u16*)scaledDest, texInfo->realWidth, texInfo->realHeight, texInfo->clampS, texInfo->clampT );
+
+ glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, texInfo->realWidth << 1, texInfo->realHeight << 1, 0, GL_RGBA, glType, scaledDest );
+
+ free( scaledDest );
+ }
+
+ free(dest);
+ free(swapped);
+
+
+ if (config.texture.enableMipmap)
+ glGenerateMipmap(GL_TEXTURE_2D);
+}
+
+void TextureCache_Load( CachedTexture *texInfo )
+{
+ u32 *dest, *scaledDest;
+
+ void *src;
+ u16 x, y, i, j, tx, ty, line;
+ u16 mirrorSBit, maskSMask, clampSClamp;
+ u16 mirrorTBit, maskTMask, clampTClamp;
+
+ int bytePerPixel=0;
+ TextureFormat texFormat;
+ GetTexelFunc getTexel;
+ GLint glWidth=0, glHeight=0;
+ GLenum glType=0;
+ GLenum glFormat=0;
+
+ __texture_format(texInfo->size, texInfo->format, &texFormat);
+
+#ifdef PRINT_TEXTUREFORMAT
+ printf("TEX LUT=%i, TEXTURE SIZE=%i, FORMAT=%i -> GL FORMAT=%i\n", gDP.otherMode.textureLUT, texInfo->size, texInfo->format, texFormat.format); fflush(stdout);
+#endif
+
+ if (texFormat.format == FORMAT_NONE)
+ {
+ LOG(LOG_WARNING, "No Texture Conversion function available, size=%i format=%i\n", texInfo->size, texInfo->format);
+ }
+
+ switch(texFormat.format)
+ {
+ case FORMAT_I8:
+ glFormat = GL_LUMINANCE;
+ glType = GL_UNSIGNED_BYTE;
+ bytePerPixel = 1;
+ break;
+ case FORMAT_IA88:
+ glFormat = GL_LUMINANCE_ALPHA;
+ glType = GL_UNSIGNED_BYTE;
+ bytePerPixel = 2;
+ break;
+ case FORMAT_RGBA4444:
+ glFormat = GL_RGBA;
+ glType = GL_UNSIGNED_SHORT_4_4_4_4;
+ bytePerPixel = 2;
+ break;
+ case FORMAT_RGBA5551:
+ glFormat = GL_RGBA;
+ glType = GL_UNSIGNED_SHORT_5_5_5_1;
+ bytePerPixel = 2;
+ break;
+ case FORMAT_RGBA8888:
+ glFormat = GL_RGBA;
+ glType = GL_UNSIGNED_BYTE;
+ bytePerPixel = 4;
+ break;
+ }
+
+ glWidth = texInfo->realWidth;
+ glHeight = texInfo->realHeight;
+ texInfo->textureBytes = (glWidth * glHeight) * bytePerPixel;
+ getTexel = texFormat.getTexel;
+
+ dest = (u32*)malloc(texInfo->textureBytes);
+
+ if (!dest)
+ {
+ LOG(LOG_ERROR, "Malloc failed!\n");
+ return;
+ }
+
+
+ line = texInfo->line;
+
+ if (texInfo->size == G_IM_SIZ_32b)
+ line <<= 1;
+
+ if (texInfo->maskS)
+ {
+ clampSClamp = texInfo->clampS ? texInfo->clampWidth - 1 : (texInfo->mirrorS ? (texInfo->width << 1) - 1 : texInfo->width - 1);
+ maskSMask = (1 << texInfo->maskS) - 1;
+ mirrorSBit = texInfo->mirrorS ? (1 << texInfo->maskS) : 0;
+ }
+ else
+ {
+ clampSClamp = min( texInfo->clampWidth, texInfo->width ) - 1;
+ maskSMask = 0xFFFF;
+ mirrorSBit = 0x0000;
+ }
+
+ if (texInfo->maskT)
+ {
+ clampTClamp = texInfo->clampT ? texInfo->clampHeight - 1 : (texInfo->mirrorT ? (texInfo->height << 1) - 1: texInfo->height - 1);
+ maskTMask = (1 << texInfo->maskT) - 1;
+ mirrorTBit = texInfo->mirrorT ? (1 << texInfo->maskT) : 0;
+ }
+ else
+ {
+ clampTClamp = min( texInfo->clampHeight, texInfo->height ) - 1;
+ maskTMask = 0xFFFF;
+ mirrorTBit = 0x0000;
+ }
+
+ // Hack for Zelda warp texture
+ if (((texInfo->tMem << 3) + (texInfo->width * texInfo->height << texInfo->size >> 1)) > 4096)
+ {
+ texInfo->tMem = 0;
+ }
+
+ // limit clamp values to min-0 (Perfect Dark has height=0 textures, making negative clamps)
+ if (clampTClamp & 0x8000) clampTClamp = 0;
+ if (clampSClamp & 0x8000) clampSClamp = 0;
+
+ j = 0;
+ for (y = 0; y < texInfo->realHeight; y++)
+ {
+ ty = min(y, clampTClamp) & maskTMask;
+ if (y & mirrorTBit) ty ^= maskTMask;
+ src = &TMEM[(texInfo->tMem + line * ty) & 511];
+ i = (ty & 1) << 1;
+ for (x = 0; x < texInfo->realWidth; x++)
+ {
+ tx = min(x, clampSClamp) & maskSMask;
+
+ if (x & mirrorSBit) tx ^= maskSMask;
+
+ if (bytePerPixel == 4)
+ {
+ ((u32*)dest)[j] = getTexel(src, tx, i, texInfo->palette);
+ }
+ else if (bytePerPixel == 2)
+ {
+ ((u16*)dest)[j] = getTexel(src, tx, i, texInfo->palette);
+ }
+ else if (bytePerPixel == 1)
+ {
+ ((u8*)dest)[j] = getTexel(src, tx, i, texInfo->palette);
+ }
+ j++;
+ }
+ }
+
+ if (!config.texture.sai2x || (texFormat.format == FORMAT_I8) || (texFormat.format == FORMAT_IA88))
+ {
+#ifdef PRINT_TEXTUREFORMAT
+ 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);
+#endif
+ glTexImage2D( GL_TEXTURE_2D, 0, glFormat, glWidth, glHeight, 0, glFormat, glType, dest);
+ }
+ else
+ {
+ LOG(LOG_VERBOSE, "Using 2xSAI Filter on Texture\n");
+
+ texInfo->textureBytes <<= 2;
+
+ scaledDest = (u32*)malloc( texInfo->textureBytes );
+
+ if (glType == GL_UNSIGNED_BYTE)
+ _2xSaI8888( (u32*)dest, (u32*)scaledDest, texInfo->realWidth, texInfo->realHeight, 1, 1 );
+ else if (glType == GL_UNSIGNED_SHORT_4_4_4_4)
+ _2xSaI4444( (u16*)dest, (u16*)scaledDest, texInfo->realWidth, texInfo->realHeight, 1, 1 );
+ else
+ _2xSaI5551( (u16*)dest, (u16*)scaledDest, texInfo->realWidth, texInfo->realHeight, 1, 1 );
+
+ glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, texInfo->realWidth << 1, texInfo->realHeight << 1, 0, GL_RGBA, glType, scaledDest );
+
+ free( scaledDest );
+ }
+
+ free(dest);
+
+ if (config.texture.enableMipmap)
+ glGenerateMipmap(GL_TEXTURE_2D);
+
+}
+
+#define max(a,b) ((a) > (b) ? (a) : (b))
+
+u32 TextureCache_CalculateCRC( u32 t, u32 width, u32 height )
+{
+ u32 crc;
+ u32 y, /*i,*/ bpl, lineBytes, line;
+ void *src;
+
+ bpl = width << gSP.textureTile[t]->size >> 1;
+ lineBytes = gSP.textureTile[t]->line << 3;
+
+ line = gSP.textureTile[t]->line;
+ if (gSP.textureTile[t]->size == G_IM_SIZ_32b)
+ line <<= 1;
+
+ crc = 0xFFFFFFFF;
+
+#ifdef __CRC_OPT
+ unsigned n = (config.texture.fastCRC) ? max(1, height / 8) : 1;
+#else
+ unsigned n = 1;
+#endif
+
+ for (y = 0; y < height; y += n)
+ {
+ src = (void*) &TMEM[(gSP.textureTile[t]->tmem + (y * line)) & 511];
+ crc = CRC_Calculate( crc, src, bpl );
+ }
+
+ if (gSP.textureTile[t]->format == G_IM_FMT_CI)
+ {
+ if (gSP.textureTile[t]->size == G_IM_SIZ_4b)
+ crc = CRC_Calculate( crc, &gDP.paletteCRC16[gSP.textureTile[t]->palette], 4 );
+ else if (gSP.textureTile[t]->size == G_IM_SIZ_8b)
+ crc = CRC_Calculate( crc, &gDP.paletteCRC256, 4 );
+ }
+ return crc;
+}
+
+void TextureCache_ActivateTexture( u32 t, CachedTexture *texture )
+{
+
+#ifdef __HASHMAP_OPT
+ cache.hash.insert(texture->crc, texture);
+#endif
+
+ glActiveTexture( GL_TEXTURE0 + t );
+ glBindTexture( GL_TEXTURE_2D, texture->glName );
+
+ // Set filter mode. Almost always bilinear, but check anyways
+ if ((gDP.otherMode.textureFilter == G_TF_BILERP) || (gDP.otherMode.textureFilter == G_TF_AVERAGE) || (config.texture.forceBilinear))
+ {
+ glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+ glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+ }
+ else
+ {
+ glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
+ glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
+ }
+
+ // Set clamping modes
+ glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, (texture->clampS) ? GL_CLAMP_TO_EDGE : GL_REPEAT );
+ glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, (texture->clampT) ? GL_CLAMP_TO_EDGE : GL_REPEAT );
+
+ if (config.texture.maxAnisotropy > 0)
+ {
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, config.texture.maxAnisotropy);
+ }
+
+ texture->lastDList = RSP.DList;
+ TextureCache_MoveToTop( texture );
+ cache.current[t] = texture;
+}
+
+void TextureCache_ActivateDummy( u32 t)
+{
+ glActiveTexture(GL_TEXTURE0 + t);
+ glBindTexture(GL_TEXTURE_2D, cache.dummy->glName );
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+}
+
+int _background_compare(CachedTexture *current, u32 crc)
+{
+ if ((current != NULL) &&
+ (current->crc == crc) &&
+ (current->width == gSP.bgImage.width) &&
+ (current->height == gSP.bgImage.height) &&
+ (current->format == gSP.bgImage.format) &&
+ (current->size == gSP.bgImage.size))
+ return 1;
+ else
+ return 0;
+}
+
+void TextureCache_UpdateBackground()
+{
+ u32 numBytes = gSP.bgImage.width * gSP.bgImage.height << gSP.bgImage.size >> 1;
+ u32 crc;
+
+ crc = CRC_Calculate( 0xFFFFFFFF, &RDRAM[gSP.bgImage.address], numBytes );
+
+ if (gSP.bgImage.format == G_IM_FMT_CI)
+ {
+ if (gSP.bgImage.size == G_IM_SIZ_4b)
+ crc = CRC_Calculate( crc, &gDP.paletteCRC16[gSP.bgImage.palette], 4 );
+ else if (gSP.bgImage.size == G_IM_SIZ_8b)
+ crc = CRC_Calculate( crc, &gDP.paletteCRC256, 4 );
+ }
+
+ //before we traverse cache, check to see if texture is already bound:
+ if (_background_compare(cache.current[0], crc))
+ {
+ return;
+ }
+
+#ifdef __HASHMAP_OPT
+ CachedTexture *tex = cache.hash.find(crc);
+ if (tex)
+ {
+ if (_background_compare(tex, crc))
+ {
+ TextureCache_ActivateTexture(0, tex);
+ cache.hits++;
+ return;
+ }
+ }
+#endif
+
+ CachedTexture *current = cache.top;
+ while (current)
+ {
+ if (_background_compare(current, crc))
+ {
+ TextureCache_ActivateTexture( 0, current );
+ cache.hits++;
+ return;
+ }
+ current = current->lower;
+ }
+ cache.misses++;
+
+ glActiveTexture(GL_TEXTURE0);
+ cache.current[0] = TextureCache_AddTop();
+
+ glBindTexture( GL_TEXTURE_2D, cache.current[0]->glName );
+ cache.current[0]->address = gSP.bgImage.address;
+ cache.current[0]->crc = crc;
+ cache.current[0]->format = gSP.bgImage.format;
+ cache.current[0]->size = gSP.bgImage.size;
+ cache.current[0]->width = gSP.bgImage.width;
+ cache.current[0]->height = gSP.bgImage.height;
+ cache.current[0]->clampWidth = gSP.bgImage.width;
+ cache.current[0]->clampHeight = gSP.bgImage.height;
+ cache.current[0]->palette = gSP.bgImage.palette;
+ cache.current[0]->maskS = 0;
+ cache.current[0]->maskT = 0;
+ cache.current[0]->mirrorS = 0;
+ cache.current[0]->mirrorT = 0;
+ cache.current[0]->clampS = 1;
+ cache.current[0]->clampT = 1;
+ cache.current[0]->line = 0;
+ cache.current[0]->tMem = 0;
+ cache.current[0]->lastDList = RSP.DList;
+
+ cache.current[0]->realWidth = (config.texture.pow2) ? pow2(gSP.bgImage.width ) : gSP.bgImage.width;
+ cache.current[0]->realHeight = (config.texture.pow2) ? pow2(gSP.bgImage.height) : gSP.bgImage.height;
+
+ cache.current[0]->scaleS = 1.0f / (f32)(cache.current[0]->realWidth);
+ cache.current[0]->scaleT = 1.0f / (f32)(cache.current[0]->realHeight);
+ cache.current[0]->shiftScaleS = 1.0f;
+ cache.current[0]->shiftScaleT = 1.0f;
+
+ TextureCache_LoadBackground( cache.current[0] );
+ TextureCache_ActivateTexture( 0, cache.current[0] );
+
+ cache.cachedBytes += cache.current[0]->textureBytes;
+}
+
+int _texture_compare(u32 t, CachedTexture *current, u32 crc, u32 width, u32 height, u32 clampWidth, u32 clampHeight)
+{
+ if ((current != NULL) &&
+ (current->crc == crc) &&
+ (current->width == width) &&
+ (current->height == height) &&
+ (current->clampWidth == clampWidth) &&
+ (current->clampHeight == clampHeight) &&
+ (current->maskS == gSP.textureTile[t]->masks) &&
+ (current->maskT == gSP.textureTile[t]->maskt) &&
+ (current->mirrorS == gSP.textureTile[t]->mirrors) &&
+ (current->mirrorT == gSP.textureTile[t]->mirrort) &&
+ (current->clampS == gSP.textureTile[t]->clamps) &&
+ (current->clampT == gSP.textureTile[t]->clampt) &&
+ (current->format == gSP.textureTile[t]->format) &&
+ (current->size == gSP.textureTile[t]->size))
+ return 1;
+ else
+ return 0;
+}
+
+
+void TextureCache_Update( u32 t )
+{
+ CachedTexture *current;
+
+ u32 crc, maxTexels;
+ u32 tileWidth, maskWidth, loadWidth, lineWidth, clampWidth, height;
+ u32 tileHeight, maskHeight, loadHeight, lineHeight, clampHeight, width;
+
+ if (gDP.textureMode == TEXTUREMODE_BGIMAGE)
+ {
+ TextureCache_UpdateBackground();
+ return;
+ }
+
+ TextureFormat texFormat;
+ __texture_format(gSP.textureTile[t]->size, gSP.textureTile[t]->format, &texFormat);
+
+ maxTexels = texFormat.maxTexels;
+
+ // Here comes a bunch of code that just calculates the texture size...I wish there was an easier way...
+ tileWidth = gSP.textureTile[t]->lrs - gSP.textureTile[t]->uls + 1;
+ tileHeight = gSP.textureTile[t]->lrt - gSP.textureTile[t]->ult + 1;
+
+ maskWidth = 1 << gSP.textureTile[t]->masks;
+ maskHeight = 1 << gSP.textureTile[t]->maskt;
+
+ loadWidth = gDP.loadTile->lrs - gDP.loadTile->uls + 1;
+ loadHeight = gDP.loadTile->lrt - gDP.loadTile->ult + 1;
+
+ lineWidth = gSP.textureTile[t]->line << texFormat.lineShift;
+
+ if (lineWidth) // Don't allow division by zero
+ lineHeight = min( maxTexels / lineWidth, tileHeight );
+ else
+ lineHeight = 0;
+
+ if (gDP.textureMode == TEXTUREMODE_TEXRECT)
+ {
+ u32 texRectWidth = gDP.texRect.width - gSP.textureTile[t]->uls;
+ u32 texRectHeight = gDP.texRect.height - gSP.textureTile[t]->ult;
+
+ if (gSP.textureTile[t]->masks && ((maskWidth * maskHeight) <= maxTexels))
+ width = maskWidth;
+ else if ((tileWidth * tileHeight) <= maxTexels)
+ width = tileWidth;
+ else if ((tileWidth * texRectHeight) <= maxTexels)
+ width = tileWidth;
+ else if ((texRectWidth * tileHeight) <= maxTexels)
+ width = gDP.texRect.width;
+ else if ((texRectWidth * texRectHeight) <= maxTexels)
+ width = gDP.texRect.width;
+ else if (gDP.loadType == LOADTYPE_TILE)
+ width = loadWidth;
+ else
+ width = lineWidth;
+
+ if (gSP.textureTile[t]->maskt && ((maskWidth * maskHeight) <= maxTexels))
+ height = maskHeight;
+ else if ((tileWidth * tileHeight) <= maxTexels)
+ height = tileHeight;
+ else if ((tileWidth * texRectHeight) <= maxTexels)
+ height = gDP.texRect.height;
+ else if ((texRectWidth * tileHeight) <= maxTexels)
+ height = tileHeight;
+ else if ((texRectWidth * texRectHeight) <= maxTexels)
+ height = gDP.texRect.height;
+ else if (gDP.loadType == LOADTYPE_TILE)
+ height = loadHeight;
+ else
+ height = lineHeight;
+ }
+ else
+ {
+ if (gSP.textureTile[t]->masks && ((maskWidth * maskHeight) <= maxTexels))
+ width = maskWidth;
+ else if ((tileWidth * tileHeight) <= maxTexels)
+ width = tileWidth;
+ else if (gDP.loadType == LOADTYPE_TILE)
+ width = loadWidth;
+ else
+ width = lineWidth;
+
+ if (gSP.textureTile[t]->maskt && ((maskWidth * maskHeight) <= maxTexels))
+ height = maskHeight;
+ else if ((tileWidth * tileHeight) <= maxTexels)
+ height = tileHeight;
+ else if (gDP.loadType == LOADTYPE_TILE)
+ height = loadHeight;
+ else
+ height = lineHeight;
+ }
+
+ clampWidth = gSP.textureTile[t]->clamps ? tileWidth : width;
+ clampHeight = gSP.textureTile[t]->clampt ? tileHeight : height;
+
+ if (clampWidth > 256)
+ gSP.textureTile[t]->clamps = 0;
+ if (clampHeight > 256)
+ gSP.textureTile[t]->clampt = 0;
+
+ // Make sure masking is valid
+ if (maskWidth > width)
+ {
+ gSP.textureTile[t]->masks = powof( width );
+ maskWidth = 1 << gSP.textureTile[t]->masks;
+ }
+
+ if (maskHeight > height)
+ {
+ gSP.textureTile[t]->maskt = powof( height );
+ maskHeight = 1 << gSP.textureTile[t]->maskt;
+ }
+
+ crc = TextureCache_CalculateCRC( t, width, height );
+
+ //before we traverse cache, check to see if texture is already bound:
+ if (_texture_compare(t, cache.current[t], crc, width, height, clampWidth, clampHeight))
+ {
+ cache.hits++;
+ return;
+ }
+
+#ifdef __HASHMAP_OPT
+ CachedTexture *tex = cache.hash.find(crc);
+ if (tex)
+ {
+ if (_texture_compare(t, tex, crc, width, height, clampWidth, clampHeight))
+ {
+ TextureCache_ActivateTexture( t, tex);
+ cache.hits++;
+ return;
+ }
+ }
+#endif
+
+ current = cache.top;
+ while (current)
+ {
+ if (_texture_compare(t, current, crc, width, height, clampWidth, clampHeight))
+ {
+ TextureCache_ActivateTexture( t, current );
+ cache.hits++;
+ return;
+ }
+
+ current = current->lower;
+ }
+
+ cache.misses++;
+
+ glActiveTexture( GL_TEXTURE0 + t);
+
+ cache.current[t] = TextureCache_AddTop();
+
+ if (cache.current[t] == NULL)
+ {
+ LOG(LOG_ERROR, "Texture Cache Failure\n");
+ }
+
+ glBindTexture( GL_TEXTURE_2D, cache.current[t]->glName );
+
+ cache.current[t]->address = gDP.textureImage.address;
+ cache.current[t]->crc = crc;
+
+ cache.current[t]->format = gSP.textureTile[t]->format;
+ cache.current[t]->size = gSP.textureTile[t]->size;
+
+ cache.current[t]->width = width;
+ cache.current[t]->height = height;
+ cache.current[t]->clampWidth = clampWidth;
+ cache.current[t]->clampHeight = clampHeight;
+ cache.current[t]->palette = gSP.textureTile[t]->palette;
+ cache.current[t]->maskS = gSP.textureTile[t]->masks;
+ cache.current[t]->maskT = gSP.textureTile[t]->maskt;
+ cache.current[t]->mirrorS = gSP.textureTile[t]->mirrors;
+ cache.current[t]->mirrorT = gSP.textureTile[t]->mirrort;
+ cache.current[t]->clampS = gSP.textureTile[t]->clamps;
+ cache.current[t]->clampT = gSP.textureTile[t]->clampt;
+ cache.current[t]->line = gSP.textureTile[t]->line;
+ cache.current[t]->tMem = gSP.textureTile[t]->tmem;
+ cache.current[t]->lastDList = RSP.DList;
+
+
+ if (cache.current[t]->clampS)
+ cache.current[t]->realWidth = (config.texture.pow2) ? pow2(clampWidth) : clampWidth;
+ else if (cache.current[t]->mirrorS)
+ cache.current[t]->realWidth = maskWidth << 1;
+ else
+ cache.current[t]->realWidth = (config.texture.pow2) ? pow2(width) : width;
+
+ if (cache.current[t]->clampT)
+ cache.current[t]->realHeight = (config.texture.pow2) ? pow2(clampHeight) : clampHeight;
+ else if (cache.current[t]->mirrorT)
+ cache.current[t]->realHeight = maskHeight << 1;
+ else
+ cache.current[t]->realHeight = (config.texture.pow2) ? pow2(height) : height;
+
+
+ cache.current[t]->scaleS = 1.0f / (f32)(cache.current[t]->realWidth);
+ cache.current[t]->scaleT = 1.0f / (f32)(cache.current[t]->realHeight);
+
+ // Hack for Zelda Sun
+ if ((config.hackZelda) && (gDP.combine.mux == 0x00262a60150c937fLL))
+ {
+ if ((cache.current[t]->format = G_IM_FMT_I) && (cache.current[t]->size == G_IM_SIZ_8b) &&
+ (cache.current[t]->width == 64))
+ {
+ cache.current[t]->scaleS *= 0.5f;
+ cache.current[t]->scaleT *= 0.5f;
+ }
+ }
+
+ cache.current[t]->shiftScaleS = 1.0f;
+ cache.current[t]->shiftScaleT = 1.0f;
+
+ cache.current[t]->offsetS = config.texture.sai2x ? 0.25f : 0.5f;
+ cache.current[t]->offsetT = config.texture.sai2x ? 0.25f : 0.5f;
+
+ if (gSP.textureTile[t]->shifts > 10)
+ cache.current[t]->shiftScaleS = (f32)(1 << (16 - gSP.textureTile[t]->shifts));
+ else if (gSP.textureTile[t]->shifts > 0)
+ cache.current[t]->shiftScaleS /= (f32)(1 << gSP.textureTile[t]->shifts);
+
+ if (gSP.textureTile[t]->shiftt > 10)
+ cache.current[t]->shiftScaleT = (f32)(1 << (16 - gSP.textureTile[t]->shiftt));
+ else if (gSP.textureTile[t]->shiftt > 0)
+ cache.current[t]->shiftScaleT /= (f32)(1 << gSP.textureTile[t]->shiftt);
+
+ TextureCache_Load( cache.current[t] );
+ TextureCache_ActivateTexture( t, cache.current[t] );
+
+ cache.cachedBytes += cache.current[t]->textureBytes;
+}
+
+void TextureCache_ActivateNoise(u32 t)
+{
+ glActiveTexture(GL_TEXTURE0 + t);
+ glBindTexture(GL_TEXTURE_2D, cache.glNoiseNames[RSP.DList & 0x1F]);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
+}
+
notaz.gp2x.de / mupen64plus-pandora.git / blobdiff