1 /***************************************************************************
\r
2 texture.c - description
\r
4 begin : Sun Mar 08 2009
\r
5 copyright : (C) 1999-2009 by Pete Bernert
\r
6 web : www.pbernert.com
\r
7 ***************************************************************************/
\r
9 /***************************************************************************
\r
11 * This program is free software; you can redistribute it and/or modify *
\r
12 * it under the terms of the GNU General Public License as published by *
\r
13 * the Free Software Foundation; either version 2 of the License, or *
\r
14 * (at your option) any later version. See also the license.txt file for *
\r
15 * additional informations. *
\r
17 ***************************************************************************/
\r
19 //*************************************************************************//
\r
20 // History of changes:
\r
22 // 2009/03/08 - Pete
\r
23 // - generic cleanup for the Peops release
\r
25 //*************************************************************************//
\r
28 ////////////////////////////////////////////////////////////////////////////////////
\r
29 // Texture related functions are here !
\r
31 // The texture handling is heart and soul of this gpu. The plugin was developed
\r
32 // 1999, by this time no shaders were available. Since the psx gpu is making
\r
33 // heavy use of CLUT (="color lookup tables", aka palettized textures), it was
\r
34 // an interesting task to get those emulated at good speed on NV TNT cards
\r
35 // (which was my major goal when I created the first "gpuPeteTNT"). Later cards
\r
36 // (Geforce256) supported texture palettes by an OGL extension, but at some point
\r
37 // this support was dropped again by gfx card vendors.
\r
38 // Well, at least there is a certain advatage, if no texture palettes extension can
\r
39 // be used: it is possible to modify the textures in any way, allowing "hi-res"
\r
40 // textures and other tweaks.
\r
42 // My main texture caching is kinda complex: the plugin is allocating "n" 256x256 textures,
\r
43 // and it places small psx texture parts inside them. The plugin keeps track what
\r
44 // part (with what palette) it had placed in which texture, so it can re-use this
\r
45 // part again. The more ogl textures it can use, the better (of course the managing/
\r
46 // searching will be slower, but everything is faster than uploading textures again
\r
47 // and again to a gfx card). My first card (TNT1) had 16 MB Vram, and it worked
\r
48 // well with many games, but I recommend nowadays 64 MB Vram to get a good speed.
\r
50 // Sadly, there is also a second kind of texture cache needed, for "psx texture windows".
\r
51 // Those are "repeated" textures, so a psx "texture window" needs to be put in
\r
52 // a whole texture to use the GL_TEXTURE_WRAP_ features. This cache can get full very
\r
53 // fast in games which are having an heavy "texture window" usage, like RRT4. As an
\r
54 // alternative, this plugin can use the OGL "palette" extension on texture windows,
\r
55 // if available. Nowadays also a fragment shader can easily be used to emulate
\r
56 // texture wrapping in a texture atlas, so the main cache could hold the texture
\r
57 // windows as well (that's what I am doing in the OGL2 plugin). But currently the
\r
58 // OGL1 plugin is a "shader-free" zone, so heavy "texture window" games will cause
\r
59 // much texture uploads.
\r
61 // Some final advice: take care if you change things in here. I've removed my ASM
\r
62 // handlers (they didn't cause much speed gain anyway) for readability/portability,
\r
63 // but still the functions/data structures used here are easy to mess up. I guess it
\r
64 // can be a pain in the ass to port the plugin to another byte order :)
\r
66 ////////////////////////////////////////////////////////////////////////////////////
\r
70 #include "gpuStdafx.h"
\r
72 #include "gpuDraw.h"
\r
73 //#include "plugins.h"
\r
74 #include "gpuExternals.h"
\r
75 #include "gpuTexture.h"
\r
76 #include "gpuPlugin.h"
\r
77 #include "gpuPrim.h"
\r
79 #define CLUTCHK 0x00060000
\r
80 #define CLUTSHIFT 17
\r
82 ////////////////////////////////////////////////////////////////////////
\r
83 // texture conversion buffer ..
\r
84 ////////////////////////////////////////////////////////////////////////
\r
86 GLubyte ubPaletteBuffer[256][4];
\r
87 GLuint gTexMovieName=0;
\r
88 GLuint gTexBlurName=0;
\r
89 GLuint gTexFrameName=0;
\r
90 int iTexGarbageCollection=1;
\r
91 unsigned long dwTexPageComp=0;
\r
93 int iClampType=GL_CLAMP_TO_EDGE;
\r
94 int iFilter = GL_LINEAR;
\r
95 void (*LoadSubTexFn) (int,int,short,short);
\r
96 unsigned long (*PalTexturedColourFn) (unsigned long);
\r
98 ////////////////////////////////////////////////////////////////////////
\r
100 ////////////////////////////////////////////////////////////////////////
\r
102 #define PALCOL(x) PalTexturedColourFn (x)
\r
104 #define CSUBSIZE 2048
\r
105 #define CSUBSIZEA 8192
\r
106 #define CSUBSIZES 4096
\r
123 #define MAXWNDTEXCACHE 128
\r
125 #define XCHECK(pos1,pos2) ((pos1.c[0]>=pos2.c[1])&&(pos1.c[1]<=pos2.c[0])&&(pos1.c[2]>=pos2.c[3])&&(pos1.c[3]<=pos2.c[2]))
\r
126 #define INCHECK(pos2,pos1) ((pos1.c[0]<=pos2.c[0]) && (pos1.c[1]>=pos2.c[1]) && (pos1.c[2]<=pos2.c[2]) && (pos1.c[3]>=pos2.c[3]))
\r
128 ////////////////////////////////////////////////////////////////////////
\r
130 unsigned char * CheckTextureInSubSCache(long TextureMode,unsigned long GivenClutId,unsigned short * pCache);
\r
131 void LoadSubTexturePageSort(int pageid, int mode, short cx, short cy);
\r
132 void LoadPackedSubTexturePageSort(int pageid, int mode, short cx, short cy);
\r
133 void DefineSubTextureSort(void);
\r
135 ////////////////////////////////////////////////////////////////////////
\r
137 ////////////////////////////////////////////////////////////////////////
\r
139 long GlobalTexturePage;
\r
144 int iSortTexCnt=32;
\r
145 BOOL bUseFastMdec=FALSE;
\r
146 BOOL bUse15bitMdec=FALSE;
\r
147 int iFrameTexType=0;
\r
148 int iFrameReadType=0;
\r
150 unsigned long (*TCF[2]) (unsigned long);
\r
151 unsigned short (*PTCF[2]) (unsigned short);
\r
153 ////////////////////////////////////////////////////////////////////////
\r
154 // texture cache implementation
\r
155 ////////////////////////////////////////////////////////////////////////
\r
157 // "texture window" cache entry
\r
159 typedef struct textureWndCacheEntryTag
\r
161 unsigned long ClutID;
\r
168 } textureWndCacheEntry;
\r
170 // "standard texture" cache entry (12 byte per entry, as small as possible... we need lots of them)
\r
172 typedef struct textureSubCacheEntryTagS
\r
174 unsigned long ClutID;
\r
176 unsigned char posTX;
\r
177 unsigned char posTY;
\r
178 unsigned char cTexID;
\r
179 unsigned char Opaque;
\r
180 } textureSubCacheEntryS;
\r
183 //---------------------------------------------
\r
185 #define MAXTPAGES_MAX 64
\r
186 #define MAXSORTTEX_MAX 196
\r
188 //---------------------------------------------
\r
190 textureWndCacheEntry wcWndtexStore[MAXWNDTEXCACHE];
\r
191 textureSubCacheEntryS * pscSubtexStore[3][MAXTPAGES_MAX];
\r
192 EXLong * pxSsubtexLeft [MAXSORTTEX_MAX];
\r
193 GLuint uiStexturePage[MAXSORTTEX_MAX];
\r
195 unsigned short usLRUTexPage=0;
\r
199 int iTexWndLimit=MAXWNDTEXCACHE/2;
\r
201 GLubyte * texturepart=NULL;
\r
202 GLubyte * texturebuffer=NULL;
\r
203 unsigned long g_x1,g_y1,g_x2,g_y2;
\r
204 unsigned char ubOpaqueDraw=0;
\r
206 unsigned short MAXTPAGES = 32;
\r
207 unsigned short CLUTMASK = 0x7fff;
\r
208 unsigned short CLUTYMASK = 0x1ff;
\r
209 unsigned short MAXSORTTEX = 196;
\r
211 ////////////////////////////////////////////////////////////////////////
\r
212 // Texture color conversions... all my ASM funcs are removed for easier
\r
213 // porting... and honestly: nowadays the speed gain would be pointless
\r
214 ////////////////////////////////////////////////////////////////////////
\r
216 unsigned long XP8RGBA(unsigned long BGR)
\r
218 if(!(BGR&0xffff)) return 0x50000000;
\r
219 if(DrawSemiTrans && !(BGR&0x8000))
\r
220 {ubOpaqueDraw=1;return ((((BGR<<3)&0xf8)|((BGR<<6)&0xf800)|((BGR<<9)&0xf80000))&0xffffff);}
\r
221 return ((((BGR<<3)&0xf8)|((BGR<<6)&0xf800)|((BGR<<9)&0xf80000))&0xffffff)|0xff000000;
\r
224 unsigned long XP8RGBAEx(unsigned long BGR)
\r
226 if(!(BGR&0xffff)) return 0x03000000;
\r
227 if(DrawSemiTrans && !(BGR&0x8000))
\r
228 {ubOpaqueDraw=1;return ((((BGR<<3)&0xf8)|((BGR<<6)&0xf800)|((BGR<<9)&0xf80000))&0xffffff);}
\r
229 return ((((BGR<<3)&0xf8)|((BGR<<6)&0xf800)|((BGR<<9)&0xf80000))&0xffffff)|0xff000000;
\r
232 unsigned long CP8RGBA(unsigned long BGR)
\r
235 if(!(BGR&0xffff)) return 0x50000000;
\r
236 if(DrawSemiTrans && !(BGR&0x8000))
\r
237 {ubOpaqueDraw=1;return ((((BGR<<3)&0xf8)|((BGR<<6)&0xf800)|((BGR<<9)&0xf80000))&0xffffff);}
\r
238 l=((((BGR<<3)&0xf8)|((BGR<<6)&0xf800)|((BGR<<9)&0xf80000))&0xffffff)|0xff000000;
\r
239 if(l==0xffffff00) l=0xff000000;
\r
243 unsigned long CP8RGBAEx(unsigned long BGR)
\r
246 if(!(BGR&0xffff)) return 0x03000000;
\r
247 if(DrawSemiTrans && !(BGR&0x8000))
\r
248 {ubOpaqueDraw=1;return ((((BGR<<3)&0xf8)|((BGR<<6)&0xf800)|((BGR<<9)&0xf80000))&0xffffff);}
\r
249 l=((((BGR<<3)&0xf8)|((BGR<<6)&0xf800)|((BGR<<9)&0xf80000))&0xffffff)|0xff000000;
\r
250 if(l==0xffffff00) l=0xff000000;
\r
254 unsigned long XP8RGBA_0(unsigned long BGR)
\r
256 if(!(BGR&0xffff)) return 0x50000000;
\r
257 return ((((BGR<<3)&0xf8)|((BGR<<6)&0xf800)|((BGR<<9)&0xf80000))&0xffffff)|0xff000000;
\r
260 unsigned long XP8RGBAEx_0(unsigned long BGR)
\r
262 if(!(BGR&0xffff)) return 0x03000000;
\r
263 return ((((BGR<<3)&0xf8)|((BGR<<6)&0xf800)|((BGR<<9)&0xf80000))&0xffffff)|0xff000000;
\r
266 unsigned long XP8BGRA_0(unsigned long BGR)
\r
268 if(!(BGR&0xffff)) return 0x50000000;
\r
269 return ((((BGR>>7)&0xf8)|((BGR<<6)&0xf800)|((BGR<<19)&0xf80000))&0xffffff)|0xff000000;
\r
272 unsigned long XP8BGRAEx_0(unsigned long BGR)
\r
274 if(!(BGR&0xffff)) return 0x03000000;
\r
275 return ((((BGR>>7)&0xf8)|((BGR<<6)&0xf800)|((BGR<<19)&0xf80000))&0xffffff)|0xff000000;
\r
278 unsigned long CP8RGBA_0(unsigned long BGR)
\r
282 if(!(BGR&0xffff)) return 0x50000000;
\r
283 l=((((BGR<<3)&0xf8)|((BGR<<6)&0xf800)|((BGR<<9)&0xf80000))&0xffffff)|0xff000000;
\r
284 if(l==0xfff8f800) l=0xff000000;
\r
288 unsigned long CP8RGBAEx_0(unsigned long BGR)
\r
292 if(!(BGR&0xffff)) return 0x03000000;
\r
293 l=((((BGR<<3)&0xf8)|((BGR<<6)&0xf800)|((BGR<<9)&0xf80000))&0xffffff)|0xff000000;
\r
294 if(l==0xfff8f800) l=0xff000000;
\r
298 unsigned long CP8BGRA_0(unsigned long BGR)
\r
302 if(!(BGR&0xffff)) return 0x50000000;
\r
303 l=((((BGR>>7)&0xf8)|((BGR<<6)&0xf800)|((BGR<<19)&0xf80000))&0xffffff)|0xff000000;
\r
304 if(l==0xff00f8f8) l=0xff000000;
\r
308 unsigned long CP8BGRAEx_0(unsigned long BGR)
\r
312 if(!(BGR&0xffff)) return 0x03000000;
\r
313 l=((((BGR>>7)&0xf8)|((BGR<<6)&0xf800)|((BGR<<19)&0xf80000))&0xffffff)|0xff000000;
\r
314 if(l==0xff00f8f8) l=0xff000000;
\r
318 unsigned long XP8RGBA_1(unsigned long BGR)
\r
320 if(!(BGR&0xffff)) return 0x50000000;
\r
321 if(!(BGR&0x8000)) {ubOpaqueDraw=1;return ((((BGR<<3)&0xf8)|((BGR<<6)&0xf800)|((BGR<<9)&0xf80000))&0xffffff);}
\r
322 return ((((BGR<<3)&0xf8)|((BGR<<6)&0xf800)|((BGR<<9)&0xf80000))&0xffffff)|0xff000000;
\r
325 unsigned long XP8RGBAEx_1(unsigned long BGR)
\r
327 if(!(BGR&0xffff)) return 0x03000000;
\r
328 if(!(BGR&0x8000)) {ubOpaqueDraw=1;return ((((BGR<<3)&0xf8)|((BGR<<6)&0xf800)|((BGR<<9)&0xf80000))&0xffffff);}
\r
329 return ((((BGR<<3)&0xf8)|((BGR<<6)&0xf800)|((BGR<<9)&0xf80000))&0xffffff)|0xff000000;
\r
332 unsigned long XP8BGRA_1(unsigned long BGR)
\r
334 if(!(BGR&0xffff)) return 0x50000000;
\r
335 if(!(BGR&0x8000)) {ubOpaqueDraw=1;return ((((BGR>>7)&0xf8)|((BGR<<6)&0xf800)|((BGR<<19)&0xf80000))&0xffffff);}
\r
336 return ((((BGR>>7)&0xf8)|((BGR<<6)&0xf800)|((BGR<<19)&0xf80000))&0xffffff)|0xff000000;
\r
339 unsigned long XP8BGRAEx_1(unsigned long BGR)
\r
341 if(!(BGR&0xffff)) return 0x03000000;
\r
342 if(!(BGR&0x8000)) {ubOpaqueDraw=1;return ((((BGR>>7)&0xf8)|((BGR<<6)&0xf800)|((BGR<<19)&0xf80000))&0xffffff);}
\r
343 return ((((BGR>>7)&0xf8)|((BGR<<6)&0xf800)|((BGR<<19)&0xf80000))&0xffffff)|0xff000000;
\r
346 unsigned long P8RGBA(unsigned long BGR)
\r
348 if(!(BGR&0xffff)) return 0;
\r
349 return ((((BGR<<3)&0xf8)|((BGR<<6)&0xf800)|((BGR<<9)&0xf80000))&0xffffff)|0xff000000;
\r
352 unsigned long P8BGRA(unsigned long BGR)
\r
354 if(!(BGR&0xffff)) return 0;
\r
355 return ((((BGR>>7)&0xf8)|((BGR<<6)&0xf800)|((BGR<<19)&0xf80000))&0xffffff)|0xff000000;
\r
358 unsigned short XP5RGBA(unsigned short BGR)
\r
361 if(DrawSemiTrans && !(BGR&0x8000))
\r
362 {ubOpaqueDraw=1;return ((((BGR<<11))|((BGR>>9)&0x3e)|((BGR<<1)&0x7c0)));}
\r
363 return ((((BGR<<11))|((BGR>>9)&0x3e)|((BGR<<1)&0x7c0)))|1;
\r
366 unsigned short XP5RGBA_0 (unsigned short BGR)
\r
370 return ((((BGR<<11))|((BGR>>9)&0x3e)|((BGR<<1)&0x7c0)))|1;
\r
373 unsigned short CP5RGBA_0 (unsigned short BGR)
\r
379 s=((((BGR<<11))|((BGR>>9)&0x3e)|((BGR<<1)&0x7c0)))|1;
\r
384 unsigned short XP5RGBA_1(unsigned short BGR)
\r
388 {ubOpaqueDraw=1;return ((((BGR<<11))|((BGR>>9)&0x3e)|((BGR<<1)&0x7c0)));}
\r
389 return ((((BGR<<11))|((BGR>>9)&0x3e)|((BGR<<1)&0x7c0)))|1;
\r
392 unsigned short P5RGBA(unsigned short BGR)
\r
395 return ((((BGR<<11))|((BGR>>9)&0x3e)|((BGR<<1)&0x7c0)))|1;
\r
398 unsigned short XP4RGBA(unsigned short BGR)
\r
401 if(DrawSemiTrans && !(BGR&0x8000))
\r
402 {ubOpaqueDraw=1;return ((((BGR<<11))|((BGR>>9)&0x3e)|((BGR<<1)&0x7c0)));}
\r
403 return (((((BGR&0x1e)<<11))|((BGR&0x7800)>>7)|((BGR&0x3c0)<<2)))|0xf;
\r
406 unsigned short XP4RGBA_0 (unsigned short BGR)
\r
409 return (((((BGR&0x1e)<<11))|((BGR&0x7800)>>7)|((BGR&0x3c0)<<2)))|0xf;
\r
412 unsigned short CP4RGBA_0 (unsigned short BGR)
\r
416 s=(((((BGR&0x1e)<<11))|((BGR&0x7800)>>7)|((BGR&0x3c0)<<2)))|0xf;
\r
417 if(s==0x0fff) s=0x000f;
\r
421 unsigned short XP4RGBA_1(unsigned short BGR)
\r
425 {ubOpaqueDraw=1;return ((((BGR<<11))|((BGR>>9)&0x3e)|((BGR<<1)&0x7c0)));}
\r
426 return (((((BGR&0x1e)<<11))|((BGR&0x7800)>>7)|((BGR&0x3c0)<<2)))|0xf;
\r
429 unsigned short P4RGBA(unsigned short BGR)
\r
432 return (((((BGR&0x1e)<<11))|((BGR&0x7800)>>7)|((BGR&0x3c0)<<2)))|0xf;
\r
435 ////////////////////////////////////////////////////////////////////////
\r
436 // CHECK TEXTURE MEM (on plugin startup)
\r
437 ////////////////////////////////////////////////////////////////////////
\r
442 void CheckTextureMemory(void)
\r
444 GLboolean b;GLboolean * bDetail;
\r
445 int i,iCnt,iRam=iVRamSize*1024*1024;
\r
446 int iTSize;char * p;
\r
453 iRam-=(iResX*iResY*8);
\r
454 iRam-=(iResX*iResY*(iZBufferDepth/8));
\r
457 iSortTexCnt=iRam/(256*256*ts);
\r
459 if(iSortTexCnt>MAXSORTTEX)
\r
461 iSortTexCnt=MAXSORTTEX-min(1,0);
\r
465 iSortTexCnt-=3+min(1,0);
\r
466 if(iSortTexCnt<8) iSortTexCnt=8;
\r
469 for(i=0;i<MAXSORTTEX;i++)
\r
470 uiStexturePage[i]=0;
\r
477 p=(char *)malloc(iTSize*iTSize*4);
\r
480 glGenTextures(MAXSORTTEX,uiStexturePage);
\r
481 for(i=0;i<MAXSORTTEX;i++)
\r
483 glBindTexture(GL_TEXTURE_2D,uiStexturePage[i]);
\r
484 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, iClampType);
\r
485 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, iClampType);
\r
486 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, iFilter);
\r
487 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, iFilter);
\r
488 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, iTSize, iTSize, 0,GL_RGBA, GL_UNSIGNED_BYTE, p);
\r
490 glBindTexture(GL_TEXTURE_2D,0);
\r
494 bDetail=(GLboolean*)malloc(MAXSORTTEX*sizeof(GLboolean));
\r
495 memset(bDetail,0,MAXSORTTEX*sizeof(GLboolean));
\r
497 glDeleteTextures(MAXSORTTEX,uiStexturePage);
\r
499 for(i=0;i<MAXSORTTEX;i++)
\r
501 if(bDetail[i]) iCnt++;
\r
502 uiStexturePage[i]=0;
\r
507 if(b) iSortTexCnt=MAXSORTTEX-min(1,0);
\r
508 else iSortTexCnt=iCnt-3+min(1,0); // place for menu&texwnd
\r
510 if(iSortTexCnt<8) iSortTexCnt=8;
\r
513 ////////////////////////////////////////////////////////////////////////
\r
514 // Main init of textures
\r
515 ////////////////////////////////////////////////////////////////////////
\r
517 void InitializeTextureStore()
\r
521 if(iGPUHeight==1024)
\r
527 iTexGarbageCollection=0;
\r
537 memset(vertex,0,4*sizeof(OGLVertex)); // init vertices
\r
539 gTexName=0; // init main tex name
\r
541 iTexWndLimit=MAXWNDTEXCACHE;
\r
542 /* if(!iUsePalTextures) */iTexWndLimit/=2;
\r
544 memset(wcWndtexStore,0,sizeof(textureWndCacheEntry)*
\r
546 texturepart=(GLubyte *)malloc(256*256*4);
\r
547 memset(texturepart,0,256*256*4);
\r
548 texturebuffer=NULL;
\r
550 for(i=0;i<3;i++) // -> info for 32*3
\r
551 for(j=0;j<MAXTPAGES;j++)
\r
553 pscSubtexStore[i][j]=(textureSubCacheEntryS *)malloc(CSUBSIZES*sizeof(textureSubCacheEntryS));
\r
554 memset(pscSubtexStore[i][j],0,CSUBSIZES*sizeof(textureSubCacheEntryS));
\r
556 for(i=0;i<MAXSORTTEX;i++) // -> info 0..511
\r
558 pxSsubtexLeft[i]=(EXLong *)malloc(CSUBSIZE*sizeof(EXLong));
\r
559 memset(pxSsubtexLeft[i],0,CSUBSIZE*sizeof(EXLong));
\r
560 uiStexturePage[i]=0;
\r
564 ////////////////////////////////////////////////////////////////////////
\r
565 // Clean up on exit
\r
566 ////////////////////////////////////////////////////////////////////////
\r
568 void CleanupTextureStore()
\r
570 int i,j;textureWndCacheEntry * tsx;
\r
571 //----------------------------------------------------//
\r
572 glBindTexture(GL_TEXTURE_2D,0);
\r
574 //----------------------------------------------------//
\r
575 free(texturepart); // free tex part
\r
579 free(texturebuffer);
\r
582 //----------------------------------------------------//
\r
583 tsx=wcWndtexStore; // loop tex window cache
\r
584 for(i=0;i<MAXWNDTEXCACHE;i++,tsx++)
\r
586 if(tsx->texname) // -> some tex?
\r
587 glDeleteTextures(1,&tsx->texname); // --> delete it
\r
590 iMaxTexWnds=0; // no more tex wnds
\r
591 //----------------------------------------------------//
\r
592 if(gTexMovieName!=0) // some movie tex?
\r
593 glDeleteTextures(1, &gTexMovieName); // -> delete it
\r
595 gTexMovieName=0; // no more movie tex
\r
596 //----------------------------------------------------//
\r
597 if(gTexFrameName!=0) // some 15bit framebuffer tex?
\r
598 glDeleteTextures(1, &gTexFrameName); // -> delete it
\r
600 gTexFrameName=0; // no more movie tex
\r
601 //----------------------------------------------------//
\r
602 if(gTexBlurName!=0) // some 15bit framebuffer tex?
\r
603 glDeleteTextures(1, &gTexBlurName); // -> delete it
\r
605 gTexBlurName=0; // no more movie tex
\r
606 //----------------------------------------------------//
\r
607 for(i=0;i<3;i++) // -> loop
\r
608 for(j=0;j<MAXTPAGES;j++) // loop tex pages
\r
610 free(pscSubtexStore[i][j]); // -> clean mem
\r
612 for(i=0;i<MAXSORTTEX;i++)
\r
614 if(uiStexturePage[i]) // --> tex used ?
\r
616 glDeleteTextures(1,&uiStexturePage[i]);
\r
618 uiStexturePage[i]=0; // --> delete it
\r
620 free(pxSsubtexLeft[i]); // -> clean mem
\r
622 //----------------------------------------------------//
\r
625 ////////////////////////////////////////////////////////////////////////
\r
626 // Reset textures in game...
\r
627 ////////////////////////////////////////////////////////////////////////
\r
629 void ResetTextureArea(BOOL bDelTex)
\r
631 int i,j;textureSubCacheEntryS * tss;EXLong * lu;
\r
632 textureWndCacheEntry * tsx;
\r
633 //----------------------------------------------------//
\r
637 //----------------------------------------------------//
\r
638 if(bDelTex) {glBindTexture(GL_TEXTURE_2D,0); glError();gTexName=0;}
\r
639 //----------------------------------------------------//
\r
641 for(i=0;i<MAXWNDTEXCACHE;i++,tsx++)
\r
644 if(bDelTex && tsx->texname)
\r
646 glDeleteTextures(1,&tsx->texname); glError();
\r
651 //----------------------------------------------------//
\r
654 for(j=0;j<MAXTPAGES;j++)
\r
656 tss=pscSubtexStore[i][j];
\r
657 (tss+SOFFA)->pos.l=0;
\r
658 (tss+SOFFB)->pos.l=0;
\r
659 (tss+SOFFC)->pos.l=0;
\r
660 (tss+SOFFD)->pos.l=0;
\r
663 for(i=0;i<iSortTexCnt;i++)
\r
665 lu=pxSsubtexLeft[i];
\r
667 if(bDelTex && uiStexturePage[i])
\r
668 {glDeleteTextures(1,&uiStexturePage[i]); glError();uiStexturePage[i]=0;}
\r
673 ////////////////////////////////////////////////////////////////////////
\r
674 // Invalidate tex windows
\r
675 ////////////////////////////////////////////////////////////////////////
\r
677 void InvalidateWndTextureArea(long X,long Y,long W, long H)
\r
679 int i,px1,px2,py1,py2,iYM=1;
\r
680 textureWndCacheEntry * tsw=wcWndtexStore;
\r
684 if(X<0) X=0;if(X>1023) X=1023;
\r
685 if(W<0) W=0;if(W>1023) W=1023;
\r
686 if(Y<0) Y=0;if(Y>iGPUHeightMask) Y=iGPUHeightMask;
\r
687 if(H<0) H=0;if(H>iGPUHeightMask) H=iGPUHeightMask;
\r
690 if(iGPUHeight==1024) iYM=3;
\r
693 py2=min(iYM,H>>8); // y: 0 or 1
\r
696 px2=min(15,(W>>6));
\r
700 py1=py1<<4;px1+=py1;px2+=py1; // change to 0-31
\r
701 for(i=0;i<iMaxTexWnds;i++,tsw++)
\r
705 if(tsw->pageid>=px1 && tsw->pageid<=px2)
\r
714 py1=px1+16;py2=px2+16;
\r
715 for(i=0;i<iMaxTexWnds;i++,tsw++)
\r
719 if((tsw->pageid>=px1 && tsw->pageid<=px2) ||
\r
720 (tsw->pageid>=py1 && tsw->pageid<=py2))
\r
728 // adjust tex window count
\r
729 tsw=wcWndtexStore+iMaxTexWnds-1;
\r
730 while(iMaxTexWnds && !tsw->used) {iMaxTexWnds--;tsw--;}
\r
735 ////////////////////////////////////////////////////////////////////////
\r
736 // same for sort textures
\r
737 ////////////////////////////////////////////////////////////////////////
\r
739 void MarkFree(textureSubCacheEntryS * tsx)
\r
741 EXLong * ul, * uls;
\r
742 int j,iMax;unsigned char x1,y1,dx,dy;
\r
744 uls=pxSsubtexLeft[tsx->cTexID];
\r
745 iMax=uls->l;ul=uls+1;
\r
749 for(j=0;j<iMax;j++,ul++)
\r
750 if(ul->l==0xffffffff) break;
\r
754 if(j==iMax) uls->l=uls->l+1;
\r
756 x1=tsx->posTX;dx=tsx->pos.c[2]-tsx->pos.c[3];
\r
757 if(tsx->posTX) {x1--;dx+=3;}
\r
758 y1=tsx->posTY;dy=tsx->pos.c[0]-tsx->pos.c[1];
\r
759 if(tsx->posTY) {y1--;dy+=3;}
\r
768 void InvalidateSubSTextureArea(long X,long Y,long W, long H)
\r
770 int i,j,k,iMax,px,py,px1,px2,py1,py2,iYM=1;
\r
771 EXLong npos;textureSubCacheEntryS * tsb;
\r
772 long x1,x2,y1,y2,xa,sw;
\r
776 if(X<0) X=0;if(X>1023) X=1023;
\r
777 if(W<0) W=0;if(W>1023) W=1023;
\r
778 if(Y<0) Y=0;if(Y>iGPUHeightMask) Y=iGPUHeightMask;
\r
779 if(H<0) H=0;if(H>iGPUHeightMask) H=iGPUHeightMask;
\r
782 if(iGPUHeight==1024) iYM=3;
\r
785 py2=min(iYM,H>>8); // y: 0 or 1
\r
786 px1=max(0,(X>>6)-3);
\r
787 px2=min(15,(W>>6)+3); // x: 0-15
\r
789 for(py=py1;py<=py2;py++)
\r
791 j=(py<<4)+px1; // get page
\r
793 y1=py*256;y2=y1+255;
\r
800 if(y2<y1) {sw=y1;y1=y2;y2=sw;}
\r
804 for(px=px1;px<=px2;px++,j++)
\r
815 if(x2<x1) {sw=x1;x1=x2;x2=sw;}
\r
817 if (dwGPUVersion == 2)
\r
820 npos.l=((x1-xa)<<(26-k))|((x2-xa)<<(18-k))|y1|y2;
\r
823 tsb=pscSubtexStore[k][j]+SOFFA;iMax=tsb->pos.l;tsb++;
\r
824 for(i=0;i<iMax;i++,tsb++)
\r
825 if(tsb->ClutID && XCHECK(tsb->pos,npos)) {tsb->ClutID=0;MarkFree(tsb);}
\r
827 // if(npos.l & 0x00800000)
\r
829 tsb=pscSubtexStore[k][j]+SOFFB;iMax=tsb->pos.l;tsb++;
\r
830 for(i=0;i<iMax;i++,tsb++)
\r
831 if(tsb->ClutID && XCHECK(tsb->pos,npos)) {tsb->ClutID=0;MarkFree(tsb);}
\r
834 // if(npos.l & 0x00000080)
\r
836 tsb=pscSubtexStore[k][j]+SOFFC;iMax=tsb->pos.l;tsb++;
\r
837 for(i=0;i<iMax;i++,tsb++)
\r
838 if(tsb->ClutID && XCHECK(tsb->pos,npos)) {tsb->ClutID=0;MarkFree(tsb);}
\r
841 // if(npos.l & 0x00800080)
\r
843 tsb=pscSubtexStore[k][j]+SOFFD;iMax=tsb->pos.l;tsb++;
\r
844 for(i=0;i<iMax;i++,tsb++)
\r
845 if(tsb->ClutID && XCHECK(tsb->pos,npos)) {tsb->ClutID=0;MarkFree(tsb);}
\r
853 ////////////////////////////////////////////////////////////////////////
\r
854 // Invalidate some parts of cache: main routine
\r
855 ////////////////////////////////////////////////////////////////////////
\r
857 void InvalidateTextureAreaEx(void)
\r
859 short W=sxmax-sxmin;
\r
860 short H=symax-symin;
\r
862 if(W==0 && H==0) return;
\r
865 InvalidateWndTextureArea(sxmin,symin,W,H);
\r
867 InvalidateSubSTextureArea(sxmin,symin,W,H);
\r
870 ////////////////////////////////////////////////////////////////////////
\r
872 void InvalidateTextureArea(long X,long Y,long W, long H)
\r
874 if(W==0 && H==0) return;
\r
876 if(iMaxTexWnds) InvalidateWndTextureArea(X,Y,W,H);
\r
878 InvalidateSubSTextureArea(X,Y,W,H);
\r
882 ////////////////////////////////////////////////////////////////////////
\r
883 // tex window: define
\r
884 ////////////////////////////////////////////////////////////////////////
\r
886 void DefineTextureWnd(void)
\r
889 glGenTextures(1, &gTexName);
\r
891 glBindTexture(GL_TEXTURE_2D, gTexName);
\r
893 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
\r
894 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
\r
897 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, iFilter);
\r
898 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, iFilter);
\r
902 glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA,
\r
905 0, GL_RGBA, GL_UNSIGNED_BYTE, texturepart);
\r
907 //LOGE("DefineTextureWnd x:%d y:%d",TWin.Position.x1,TWin.Position.y1);
\r
911 ////////////////////////////////////////////////////////////////////////
\r
912 // tex window: load packed stretch
\r
913 ////////////////////////////////////////////////////////////////////////
\r
915 void LoadStretchPackedWndTexturePage(int pageid, int mode, short cx, short cy)
\r
917 unsigned long start,row,column,j,sxh,sxm,ldx,ldy,ldxo;
\r
918 unsigned int palstart;
\r
919 unsigned short *px,*pa,*ta;
\r
920 unsigned char *cSRCPtr,*cOSRCPtr;
\r
921 unsigned short *wSRCPtr,*wOSRCPtr;
\r
922 unsigned long LineOffset;unsigned short s;
\r
923 int pmult=pageid/16;
\r
924 unsigned short (*LPTCOL)(unsigned short);
\r
926 LPTCOL=PTCF[DrawSemiTrans];
\r
928 ldxo=TWin.Position.x1-TWin.OPosition.x1;
\r
929 ldy =TWin.Position.y1-TWin.OPosition.y1;
\r
931 pa=px=(unsigned short *)ubPaletteBuffer;
\r
932 ta=(unsigned short *)texturepart;
\r
933 palstart=cx+(cy*1024);
\r
939 //--------------------------------------------------//
\r
940 // 4bit texture load ..
\r
944 unsigned int TXV,TXU,n_xi,n_yi;
\r
946 wSRCPtr=psxVuw+palstart;
\r
947 for(row=0;row<16;row++)
\r
948 *px++=LPTCOL(*wSRCPtr++);
\r
951 for(TXV=g_y1;TXV<=column;TXV++)
\r
954 for(TXU=g_x1;TXU<=g_x2-ldxo;TXU++)
\r
956 n_xi = ( ( TXU >> 2 ) & ~0x3c ) + ( ( TXV << 2 ) & 0x3c );
\r
957 n_yi = ( TXV & ~0xf ) + ( ( TXU >> 4 ) & 0xf );
\r
959 s=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x03 ) << 2 ) ) & 0x0f ));
\r
962 if(ldx) {*ta++=s;ldx--;}
\r
967 for(TXU=g_x1;TXU<=g_x2;TXU++)
\r
968 *ta++=*(ta-(g_x2-g_x1));
\r
972 DefineTextureWnd();
\r
978 start=((pageid-16*pmult)*128)+256*2048*pmult;
\r
980 // convert CLUT to 32bits .. and then use THAT as a lookup table
\r
982 wSRCPtr=psxVuw+palstart;
\r
983 for(row=0;row<16;row++)
\r
984 *px++=LPTCOL(*wSRCPtr++);
\r
986 sxm=g_x1&1;sxh=g_x1>>1;
\r
987 if(sxm) j=g_x1+1; else j=g_x1;
\r
988 cSRCPtr = psxVub + start + (2048*g_y1) + sxh;
\r
989 for(column=g_y1;column<=g_y2;column++)
\r
991 cOSRCPtr=cSRCPtr;ldx=ldxo;
\r
992 if(sxm) *ta++=*(pa+((*cSRCPtr++ >> 4) & 0xF));
\r
994 for(row=j;row<=g_x2-ldxo;row++)
\r
996 s=*(pa+(*cSRCPtr & 0xF));
\r
998 if(ldx) {*ta++=s;ldx--;}
\r
1000 if(row<=g_x2-ldxo)
\r
1002 s=*(pa+((*cSRCPtr >> 4) & 0xF));
\r
1004 if(ldx) {*ta++=s;ldx--;}
\r
1009 if(ldy && column&1)
\r
1010 {ldy--;cSRCPtr = cOSRCPtr;}
\r
1011 else cSRCPtr = psxVub + start + (2048*(column+1)) + sxh;
\r
1014 DefineTextureWnd();
\r
1016 //--------------------------------------------------//
\r
1017 // 8bit texture load ..
\r
1021 unsigned int TXV,TXU,n_xi,n_yi;
\r
1023 wSRCPtr=psxVuw+palstart;
\r
1024 for(row=0;row<256;row++)
\r
1025 *px++=LPTCOL(*wSRCPtr++);
\r
1028 for(TXV=g_y1;TXV<=column;TXV++)
\r
1031 for(TXU=g_x1;TXU<=g_x2-ldxo;TXU++)
\r
1033 n_xi = ( ( TXU >> 1 ) & ~0x78 ) + ( ( TXU << 2 ) & 0x40 ) + ( ( TXV << 3 ) & 0x38 );
\r
1034 n_yi = ( TXV & ~0x7 ) + ( ( TXU >> 5 ) & 0x7 );
\r
1036 s=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x01 ) << 3 ) ) & 0xff));
\r
1039 if(ldx) {*ta++=s;ldx--;}
\r
1044 for(TXU=g_x1;TXU<=g_x2;TXU++)
\r
1045 *ta++=*(ta-(g_x2-g_x1));
\r
1050 DefineTextureWnd();
\r
1055 start=((pageid-16*pmult)*128)+256*2048*pmult;
\r
1057 // not using a lookup table here... speeds up smaller texture areas
\r
1058 cSRCPtr = psxVub + start + (2048*g_y1) + g_x1;
\r
1059 LineOffset = 2048 - (g_x2-g_x1+1) +ldxo;
\r
1061 for(column=g_y1;column<=g_y2;column++)
\r
1063 cOSRCPtr=cSRCPtr;ldx=ldxo;
\r
1064 for(row=g_x1;row<=g_x2-ldxo;row++)
\r
1066 s=LPTCOL(psxVuw[palstart+ *cSRCPtr++]);
\r
1068 if(ldx) {*ta++=s;ldx--;}
\r
1070 if(ldy && column&1) {ldy--;cSRCPtr=cOSRCPtr;}
\r
1071 else cSRCPtr+=LineOffset;
\r
1074 DefineTextureWnd();
\r
1076 //--------------------------------------------------//
\r
1077 // 16bit texture load ..
\r
1079 start=((pageid-16*pmult)*64)+256*1024*pmult;
\r
1080 wSRCPtr = psxVuw + start + (1024*g_y1) + g_x1;
\r
1081 LineOffset = 1024 - (g_x2-g_x1+1) +ldxo;
\r
1083 for(column=g_y1;column<=g_y2;column++)
\r
1085 wOSRCPtr=wSRCPtr;ldx=ldxo;
\r
1086 for(row=g_x1;row<=g_x2-ldxo;row++)
\r
1088 s=LPTCOL(*wSRCPtr++);
\r
1090 if(ldx) {*ta++=s;ldx--;}
\r
1092 if(ldy && column&1) {ldy--;wSRCPtr=wOSRCPtr;}
\r
1093 else wSRCPtr+=LineOffset;
\r
1096 DefineTextureWnd();
\r
1098 //--------------------------------------------------//
\r
1099 // others are not possible !
\r
1103 ////////////////////////////////////////////////////////////////////////
\r
1104 // tex window: load stretched
\r
1105 ////////////////////////////////////////////////////////////////////////
\r
1107 void LoadStretchWndTexturePage(int pageid, int mode, short cx, short cy)
\r
1109 unsigned long start,row,column,j,sxh,sxm,ldx,ldy,ldxo,s;
\r
1110 unsigned int palstart;
\r
1111 unsigned long *px,*pa,*ta;
\r
1112 unsigned char *cSRCPtr,*cOSRCPtr;
\r
1113 unsigned short *wSRCPtr,*wOSRCPtr;
\r
1114 unsigned long LineOffset;
\r
1115 int pmult=pageid/16;
\r
1116 unsigned long (*LTCOL)(unsigned long);
\r
1118 LTCOL=TCF[DrawSemiTrans];
\r
1120 ldxo=TWin.Position.x1-TWin.OPosition.x1;
\r
1121 ldy =TWin.Position.y1-TWin.OPosition.y1;
\r
1123 pa=px=(unsigned long *)ubPaletteBuffer;
\r
1124 ta=(unsigned long *)texturepart;
\r
1125 palstart=cx+(cy*1024);
\r
1131 //--------------------------------------------------//
\r
1132 // 4bit texture load ..
\r
1134 //------------------- ZN STUFF
\r
1138 unsigned int TXV,TXU,n_xi,n_yi;
\r
1140 wSRCPtr=psxVuw+palstart;
\r
1144 *px =LTCOL(*wSRCPtr);
\r
1145 *(px+1)=LTCOL(*(wSRCPtr+1));
\r
1146 *(px+2)=LTCOL(*(wSRCPtr+2));
\r
1147 *(px+3)=LTCOL(*(wSRCPtr+3));
\r
1148 row--;px+=4;wSRCPtr+=4;
\r
1153 for(TXV=g_y1;TXV<=column;TXV++)
\r
1156 for(TXU=g_x1;TXU<=g_x2-ldxo;TXU++)
\r
1158 n_xi = ( ( TXU >> 2 ) & ~0x3c ) + ( ( TXV << 2 ) & 0x3c );
\r
1159 n_yi = ( TXV & ~0xf ) + ( ( TXU >> 4 ) & 0xf );
\r
1161 s=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x03 ) << 2 ) ) & 0x0f ));
\r
1164 if(ldx) {*ta++=s;ldx--;}
\r
1169 for(TXU=g_x1;TXU<=g_x2;TXU++)
\r
1170 *ta++=*(ta-(g_x2-g_x1));
\r
1174 DefineTextureWnd();
\r
1179 //-------------------
\r
1181 start=((pageid-16*pmult)*128)+256*2048*pmult;
\r
1182 // convert CLUT to 32bits .. and then use THAT as a lookup table
\r
1184 wSRCPtr=psxVuw+palstart;
\r
1185 for(row=0;row<16;row++)
\r
1186 *px++=LTCOL(*wSRCPtr++);
\r
1188 sxm=g_x1&1;sxh=g_x1>>1;
\r
1189 if(sxm) j=g_x1+1; else j=g_x1;
\r
1190 cSRCPtr = psxVub + start + (2048*g_y1) + sxh;
\r
1191 for(column=g_y1;column<=g_y2;column++)
\r
1193 cOSRCPtr=cSRCPtr;ldx=ldxo;
\r
1194 if(sxm) *ta++=*(pa+((*cSRCPtr++ >> 4) & 0xF));
\r
1196 for(row=j;row<=g_x2-ldxo;row++)
\r
1198 s=*(pa+(*cSRCPtr & 0xF));
\r
1200 if(ldx) {*ta++=s;ldx--;}
\r
1202 if(row<=g_x2-ldxo)
\r
1204 s=*(pa+((*cSRCPtr >> 4) & 0xF));
\r
1206 if(ldx) {*ta++=s;ldx--;}
\r
1210 if(ldy && column&1)
\r
1211 {ldy--;cSRCPtr = cOSRCPtr;}
\r
1212 else cSRCPtr = psxVub + start + (2048*(column+1)) + sxh;
\r
1215 DefineTextureWnd();
\r
1217 //--------------------------------------------------//
\r
1218 // 8bit texture load ..
\r
1220 //------------ ZN STUFF
\r
1223 unsigned int TXV,TXU,n_xi,n_yi;
\r
1225 wSRCPtr=psxVuw+palstart;
\r
1229 *px =LTCOL(*wSRCPtr);
\r
1230 *(px+1)=LTCOL(*(wSRCPtr+1));
\r
1231 *(px+2)=LTCOL(*(wSRCPtr+2));
\r
1232 *(px+3)=LTCOL(*(wSRCPtr+3));
\r
1233 row--;px+=4;wSRCPtr+=4;
\r
1238 for(TXV=g_y1;TXV<=column;TXV++)
\r
1241 for(TXU=g_x1;TXU<=g_x2-ldxo;TXU++)
\r
1243 n_xi = ( ( TXU >> 1 ) & ~0x78 ) + ( ( TXU << 2 ) & 0x40 ) + ( ( TXV << 3 ) & 0x38 );
\r
1244 n_yi = ( TXV & ~0x7 ) + ( ( TXU >> 5 ) & 0x7 );
\r
1246 s=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x01 ) << 3 ) ) & 0xff));
\r
1248 if(ldx) {*ta++=s;ldx--;}
\r
1253 for(TXU=g_x1;TXU<=g_x2;TXU++)
\r
1254 *ta++=*(ta-(g_x2-g_x1));
\r
1259 DefineTextureWnd();
\r
1265 start=((pageid-16*pmult)*128)+256*2048*pmult;
\r
1267 // not using a lookup table here... speeds up smaller texture areas
\r
1268 cSRCPtr = psxVub + start + (2048*g_y1) + g_x1;
\r
1269 LineOffset = 2048 - (g_x2-g_x1+1) +ldxo;
\r
1271 for(column=g_y1;column<=g_y2;column++)
\r
1273 cOSRCPtr=cSRCPtr;ldx=ldxo;
\r
1274 for(row=g_x1;row<=g_x2-ldxo;row++)
\r
1276 s=LTCOL(psxVuw[palstart+ *cSRCPtr++]);
\r
1278 if(ldx) {*ta++=s;ldx--;}
\r
1280 if(ldy && column&1) {ldy--;cSRCPtr=cOSRCPtr;}
\r
1281 else cSRCPtr+=LineOffset;
\r
1284 DefineTextureWnd();
\r
1286 //--------------------------------------------------//
\r
1287 // 16bit texture load ..
\r
1289 start=((pageid-16*pmult)*64)+256*1024*pmult;
\r
1291 wSRCPtr = psxVuw + start + (1024*g_y1) + g_x1;
\r
1292 LineOffset = 1024 - (g_x2-g_x1+1) +ldxo;
\r
1294 for(column=g_y1;column<=g_y2;column++)
\r
1296 wOSRCPtr=wSRCPtr;ldx=ldxo;
\r
1297 for(row=g_x1;row<=g_x2-ldxo;row++)
\r
1299 s=LTCOL(*wSRCPtr++);
\r
1301 if(ldx) {*ta++=s;ldx--;}
\r
1303 if(ldy && column&1) {ldy--;wSRCPtr=wOSRCPtr;}
\r
1304 else wSRCPtr+=LineOffset;
\r
1307 DefineTextureWnd();
\r
1309 //--------------------------------------------------//
\r
1310 // others are not possible !
\r
1314 ////////////////////////////////////////////////////////////////////////
\r
1315 // tex window: load packed simple
\r
1316 ////////////////////////////////////////////////////////////////////////
\r
1318 void LoadPackedWndTexturePage(int pageid, int mode, short cx, short cy)
\r
1320 unsigned long start,row,column,j,sxh,sxm;
\r
1321 unsigned int palstart;
\r
1322 unsigned short *px,*pa,*ta;
\r
1323 unsigned char *cSRCPtr;
\r
1324 unsigned short *wSRCPtr;
\r
1325 unsigned long LineOffset;
\r
1326 int pmult=pageid/16;
\r
1327 unsigned short (*LPTCOL)(unsigned short);
\r
1329 LPTCOL=PTCF[DrawSemiTrans];
\r
1331 pa=px=(unsigned short *)ubPaletteBuffer;
\r
1332 ta=(unsigned short *)texturepart;
\r
1333 palstart=cx+(cy*1024);
\r
1339 //--------------------------------------------------//
\r
1340 // 4bit texture load ..
\r
1344 unsigned int TXV,TXU,n_xi,n_yi;
\r
1346 wSRCPtr=psxVuw+palstart;
\r
1347 for(row=0;row<16;row++)
\r
1348 *px++=LPTCOL(*wSRCPtr++);
\r
1350 for(TXV=g_y1;TXV<=g_y2;TXV++)
\r
1352 for(TXU=g_x1;TXU<=g_x2;TXU++)
\r
1354 n_xi = ( ( TXU >> 2 ) & ~0x3c ) + ( ( TXV << 2 ) & 0x3c );
\r
1355 n_yi = ( TXV & ~0xf ) + ( ( TXU >> 4 ) & 0xf );
\r
1357 *ta++=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x03 ) << 2 ) ) & 0x0f ));
\r
1361 DefineTextureWnd();
\r
1366 start=((pageid-16*pmult)*128)+256*2048*pmult;
\r
1368 // convert CLUT to 32bits .. and then use THAT as a lookup table
\r
1370 wSRCPtr=psxVuw+palstart;
\r
1371 for(row=0;row<16;row++)
\r
1372 *px++=LPTCOL(*wSRCPtr++);
\r
1374 sxm=g_x1&1;sxh=g_x1>>1;
\r
1375 if(sxm) j=g_x1+1; else j=g_x1;
\r
1376 cSRCPtr = psxVub + start + (2048*g_y1) + sxh;
\r
1377 for(column=g_y1;column<=g_y2;column++)
\r
1379 cSRCPtr = psxVub + start + (2048*column) + sxh;
\r
1381 if(sxm) *ta++=*(pa+((*cSRCPtr++ >> 4) & 0xF));
\r
1383 for(row=j;row<=g_x2;row++)
\r
1385 *ta++=*(pa+(*cSRCPtr & 0xF)); row++;
\r
1386 if(row<=g_x2) *ta++=*(pa+((*cSRCPtr >> 4) & 0xF));
\r
1391 DefineTextureWnd();
\r
1393 //--------------------------------------------------//
\r
1394 // 8bit texture load ..
\r
1398 unsigned int TXV,TXU,n_xi,n_yi;
\r
1400 wSRCPtr=psxVuw+palstart;
\r
1401 for(row=0;row<256;row++)
\r
1402 *px++=LPTCOL(*wSRCPtr++);
\r
1404 for(TXV=g_y1;TXV<=g_y2;TXV++)
\r
1406 for(TXU=g_x1;TXU<=g_x2;TXU++)
\r
1408 n_xi = ( ( TXU >> 1 ) & ~0x78 ) + ( ( TXU << 2 ) & 0x40 ) + ( ( TXV << 3 ) & 0x38 );
\r
1409 n_yi = ( TXV & ~0x7 ) + ( ( TXU >> 5 ) & 0x7 );
\r
1411 *ta++=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x01 ) << 3 ) ) & 0xff));
\r
1415 DefineTextureWnd();
\r
1420 start=((pageid-16*pmult)*128)+256*2048*pmult;
\r
1422 // not using a lookup table here... speeds up smaller texture areas
\r
1423 cSRCPtr = psxVub + start + (2048*g_y1) + g_x1;
\r
1424 LineOffset = 2048 - (g_x2-g_x1+1);
\r
1426 for(column=g_y1;column<=g_y2;column++)
\r
1428 for(row=g_x1;row<=g_x2;row++)
\r
1429 *ta++=LPTCOL(psxVuw[palstart+ *cSRCPtr++]);
\r
1430 cSRCPtr+=LineOffset;
\r
1433 DefineTextureWnd();
\r
1435 //--------------------------------------------------//
\r
1436 // 16bit texture load ..
\r
1438 start=((pageid-16*pmult)*64)+256*1024*pmult;
\r
1439 wSRCPtr = psxVuw + start + (1024*g_y1) + g_x1;
\r
1440 LineOffset = 1024 - (g_x2-g_x1+1);
\r
1442 for(column=g_y1;column<=g_y2;column++)
\r
1444 for(row=g_x1;row<=g_x2;row++)
\r
1445 *ta++=LPTCOL(*wSRCPtr++);
\r
1446 wSRCPtr+=LineOffset;
\r
1449 DefineTextureWnd();
\r
1451 //--------------------------------------------------//
\r
1452 // others are not possible !
\r
1456 ////////////////////////////////////////////////////////////////////////
\r
1457 // tex window: load simple
\r
1458 ////////////////////////////////////////////////////////////////////////
\r
1460 void LoadWndTexturePage(int pageid, int mode, short cx, short cy)
\r
1462 unsigned long start,row,column,j,sxh,sxm;
\r
1463 unsigned int palstart;
\r
1464 unsigned long *px,*pa,*ta;
\r
1465 unsigned char *cSRCPtr;
\r
1466 unsigned short *wSRCPtr;
\r
1467 unsigned long LineOffset;
\r
1468 int pmult=pageid/16;
\r
1469 unsigned long (*LTCOL)(unsigned long);
\r
1471 LTCOL=TCF[DrawSemiTrans];
\r
1473 pa=px=(unsigned long *)ubPaletteBuffer;
\r
1474 ta=(unsigned long *)texturepart;
\r
1475 palstart=cx+(cy*1024);
\r
1481 //--------------------------------------------------//
\r
1482 // 4bit texture load ..
\r
1486 unsigned int TXV,TXU,n_xi,n_yi;
\r
1488 wSRCPtr=psxVuw+palstart;
\r
1492 *px =LTCOL(*wSRCPtr);
\r
1493 *(px+1)=LTCOL(*(wSRCPtr+1));
\r
1494 *(px+2)=LTCOL(*(wSRCPtr+2));
\r
1495 *(px+3)=LTCOL(*(wSRCPtr+3));
\r
1496 row--;px+=4;wSRCPtr+=4;
\r
1500 for(TXV=g_y1;TXV<=g_y2;TXV++)
\r
1502 for(TXU=g_x1;TXU<=g_x2;TXU++)
\r
1504 n_xi = ( ( TXU >> 2 ) & ~0x3c ) + ( ( TXV << 2 ) & 0x3c );
\r
1505 n_yi = ( TXV & ~0xf ) + ( ( TXU >> 4 ) & 0xf );
\r
1507 *ta++=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x03 ) << 2 ) ) & 0x0f ));
\r
1511 DefineTextureWnd();
\r
1516 start=((pageid-16*pmult)*128)+256*2048*pmult;
\r
1518 // convert CLUT to 32bits .. and then use THAT as a lookup table
\r
1520 wSRCPtr=psxVuw+palstart;
\r
1521 for(row=0;row<16;row++)
\r
1522 *px++=LTCOL(*wSRCPtr++);
\r
1524 sxm=g_x1&1;sxh=g_x1>>1;
\r
1525 if(sxm) j=g_x1+1; else j=g_x1;
\r
1526 cSRCPtr = psxVub + start + (2048*g_y1) + sxh;
\r
1527 for(column=g_y1;column<=g_y2;column++)
\r
1529 cSRCPtr = psxVub + start + (2048*column) + sxh;
\r
1531 if(sxm) *ta++=*(pa+((*cSRCPtr++ >> 4) & 0xF));
\r
1533 for(row=j;row<=g_x2;row++)
\r
1535 *ta++=*(pa+(*cSRCPtr & 0xF)); row++;
\r
1536 if(row<=g_x2) *ta++=*(pa+((*cSRCPtr >> 4) & 0xF));
\r
1541 DefineTextureWnd();
\r
1543 //--------------------------------------------------//
\r
1544 // 8bit texture load ..
\r
1548 unsigned int TXV,TXU,n_xi,n_yi;
\r
1550 wSRCPtr=psxVuw+palstart;
\r
1554 *px =LTCOL(*wSRCPtr);
\r
1555 *(px+1)=LTCOL(*(wSRCPtr+1));
\r
1556 *(px+2)=LTCOL(*(wSRCPtr+2));
\r
1557 *(px+3)=LTCOL(*(wSRCPtr+3));
\r
1558 row--;px+=4;wSRCPtr+=4;
\r
1562 for(TXV=g_y1;TXV<=g_y2;TXV++)
\r
1564 for(TXU=g_x1;TXU<=g_x2;TXU++)
\r
1566 n_xi = ( ( TXU >> 1 ) & ~0x78 ) + ( ( TXU << 2 ) & 0x40 ) + ( ( TXV << 3 ) & 0x38 );
\r
1567 n_yi = ( TXV & ~0x7 ) + ( ( TXU >> 5 ) & 0x7 );
\r
1569 *ta++=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x01 ) << 3 ) ) & 0xff));
\r
1573 DefineTextureWnd();
\r
1578 start=((pageid-16*pmult)*128)+256*2048*pmult;
\r
1580 // not using a lookup table here... speeds up smaller texture areas
\r
1581 cSRCPtr = psxVub + start + (2048*g_y1) + g_x1;
\r
1582 LineOffset = 2048 - (g_x2-g_x1+1);
\r
1584 for(column=g_y1;column<=g_y2;column++)
\r
1586 for(row=g_x1;row<=g_x2;row++)
\r
1587 *ta++=LTCOL(psxVuw[palstart+ *cSRCPtr++]);
\r
1588 cSRCPtr+=LineOffset;
\r
1591 DefineTextureWnd();
\r
1593 //--------------------------------------------------//
\r
1594 // 16bit texture load ..
\r
1596 start=((pageid-16*pmult)*64)+256*1024*pmult;
\r
1598 wSRCPtr = psxVuw + start + (1024*g_y1) + g_x1;
\r
1599 LineOffset = 1024 - (g_x2-g_x1+1);
\r
1601 for(column=g_y1;column<=g_y2;column++)
\r
1603 for(row=g_x1;row<=g_x2;row++)
\r
1604 *ta++=LTCOL(*wSRCPtr++);
\r
1605 wSRCPtr+=LineOffset;
\r
1608 DefineTextureWnd();
\r
1610 //--------------------------------------------------//
\r
1611 // others are not possible !
\r
1615 ////////////////////////////////////////////////////////////////////////
\r
1616 ////////////////////////////////////////////////////////////////////////
\r
1617 ////////////////////////////////////////////////////////////////////////
\r
1618 ////////////////////////////////////////////////////////////////////////
\r
1620 void UploadTexWndPal(int mode,short cx,short cy)
\r
1622 unsigned int i,iSize;
\r
1623 unsigned short * wSrcPtr;
\r
1624 unsigned long * ta=(unsigned long *)texturepart;
\r
1626 wSrcPtr=psxVuw+cx+(cy*1024);
\r
1627 if(mode==0) i=4; else i=64;
\r
1633 *ta =PALCOL(*wSrcPtr);
\r
1634 *(ta+1)=PALCOL(*(wSrcPtr+1));
\r
1635 *(ta+2)=PALCOL(*(wSrcPtr+2));
\r
1636 *(ta+3)=PALCOL(*(wSrcPtr+3));
\r
1637 ta+=4;wSrcPtr+=4;i--;
\r
1641 /* (*glColorTableEXTEx)(GL_TEXTURE_2D,GL_RGBA8,iSize,
\r
1642 GL_RGBA,GL_UNSIGNED_BYTE,texturepart);
\r
1645 ////////////////////////////////////////////////////////////////////////
\r
1647 void DefinePalTextureWnd(void)
\r
1650 glGenTextures(1, &gTexName);
\r
1652 glBindTexture(GL_TEXTURE_2D, gTexName);
\r
1654 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
\r
1655 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
\r
1658 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, iFilter);
\r
1659 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, iFilter);
\r
1662 glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA,
\r
1663 TWin.Position.x1,
\r
1664 TWin.Position.y1,
\r
1665 0, GL_RGBA, GL_UNSIGNED_BYTE,texturepart);
\r
1667 //LOGE("DefinePalTextureWnd x:%d y:%d",TWin.Position.x1,TWin.Position.y1);
\r
1670 ///////////////////////////////////////////////////////
\r
1672 void LoadPalWndTexturePage(int pageid, int mode, short cx, short cy)
\r
1674 unsigned long start,row,column,j,sxh,sxm;
\r
1675 unsigned char *ta;
\r
1676 unsigned char *cSRCPtr;
\r
1677 unsigned long LineOffset;
\r
1678 int pmult=pageid/16;
\r
1680 ta=(unsigned char *)texturepart;
\r
1684 //--------------------------------------------------//
\r
1685 // 4bit texture load ..
\r
1687 start=((pageid-16*pmult)*128)+256*2048*pmult;
\r
1689 sxm=g_x1&1;sxh=g_x1>>1;
\r
1690 if(sxm) j=g_x1+1; else j=g_x1;
\r
1691 cSRCPtr = psxVub + start + (2048*g_y1) + sxh;
\r
1692 for(column=g_y1;column<=g_y2;column++)
\r
1694 cSRCPtr = psxVub + start + (2048*column) + sxh;
\r
1696 if(sxm) *ta++=((*cSRCPtr++ >> 4) & 0xF);
\r
1698 for(row=j;row<=g_x2;row++)
\r
1700 *ta++=(*cSRCPtr & 0xF); row++;
\r
1701 if(row<=g_x2) *ta++=((*cSRCPtr >> 4) & 0xF);
\r
1706 DefinePalTextureWnd();
\r
1708 //--------------------------------------------------//
\r
1709 // 8bit texture load ..
\r
1711 start=((pageid-16*pmult)*128)+256*2048*pmult;
\r
1713 // not using a lookup table here... speeds up smaller texture areas
\r
1714 cSRCPtr = psxVub + start + (2048*g_y1) + g_x1;
\r
1715 LineOffset = 2048 - (g_x2-g_x1+1);
\r
1717 for(column=g_y1;column<=g_y2;column++)
\r
1719 for(row=g_x1;row<=g_x2;row++)
\r
1721 cSRCPtr+=LineOffset;
\r
1724 DefinePalTextureWnd();
\r
1727 UploadTexWndPal(mode,cx,cy);
\r
1730 ////////////////////////////////////////////////////////////////////////
\r
1732 void LoadStretchPalWndTexturePage(int pageid, int mode, short cx, short cy)
\r
1734 unsigned long start,row,column,j,sxh,sxm,ldx,ldy,ldxo;
\r
1735 unsigned char *ta,s;
\r
1736 unsigned char *cSRCPtr,*cOSRCPtr;
\r
1737 unsigned long LineOffset;
\r
1738 int pmult=pageid/16;
\r
1740 ldxo=TWin.Position.x1-TWin.OPosition.x1;
\r
1741 ldy =TWin.Position.y1-TWin.OPosition.y1;
\r
1743 ta=(unsigned char *)texturepart;
\r
1747 //--------------------------------------------------//
\r
1748 // 4bit texture load ..
\r
1750 start=((pageid-16*pmult)*128)+256*2048*pmult;
\r
1752 sxm=g_x1&1;sxh=g_x1>>1;
\r
1753 if(sxm) j=g_x1+1; else j=g_x1;
\r
1754 cSRCPtr = psxVub + start + (2048*g_y1) + sxh;
\r
1755 for(column=g_y1;column<=g_y2;column++)
\r
1757 cOSRCPtr=cSRCPtr;ldx=ldxo;
\r
1758 if(sxm) *ta++=((*cSRCPtr++ >> 4) & 0xF);
\r
1760 for(row=j;row<=g_x2-ldxo;row++)
\r
1762 s=(*cSRCPtr & 0xF);
\r
1764 if(ldx) {*ta++=s;ldx--;}
\r
1766 if(row<=g_x2-ldxo)
\r
1768 s=((*cSRCPtr >> 4) & 0xF);
\r
1770 if(ldx) {*ta++=s;ldx--;}
\r
1774 if(ldy && column&1)
\r
1775 {ldy--;cSRCPtr = cOSRCPtr;}
\r
1776 else cSRCPtr = psxVub + start + (2048*(column+1)) + sxh;
\r
1779 DefinePalTextureWnd();
\r
1781 //--------------------------------------------------//
\r
1782 // 8bit texture load ..
\r
1784 start=((pageid-16*pmult)*128)+256*2048*pmult;
\r
1786 cSRCPtr = psxVub + start + (2048*g_y1) + g_x1;
\r
1787 LineOffset = 2048 - (g_x2-g_x1+1) +ldxo;
\r
1789 for(column=g_y1;column<=g_y2;column++)
\r
1791 cOSRCPtr=cSRCPtr;ldx=ldxo;
\r
1792 for(row=g_x1;row<=g_x2-ldxo;row++)
\r
1796 if(ldx) {*ta++=s;ldx--;}
\r
1798 if(ldy && column&1) {ldy--;cSRCPtr=cOSRCPtr;}
\r
1799 else cSRCPtr+=LineOffset;
\r
1802 DefinePalTextureWnd();
\r
1805 UploadTexWndPal(mode,cx,cy);
\r
1808 ////////////////////////////////////////////////////////////////////////
\r
1809 // tex window: main selecting, cache handler included
\r
1810 ////////////////////////////////////////////////////////////////////////
\r
1812 GLuint LoadTextureWnd(long pageid,long TextureMode,unsigned long GivenClutId)
\r
1814 textureWndCacheEntry * ts, * tsx=NULL;
\r
1815 int i;short cx,cy;
\r
1818 npos.c[3]=TWin.Position.x0;
\r
1819 npos.c[2]=TWin.OPosition.x1;
\r
1820 npos.c[1]=TWin.Position.y0;
\r
1821 npos.c[0]=TWin.OPosition.y1;
\r
1823 g_x1=TWin.Position.x0;g_x2=g_x1+TWin.Position.x1-1;
\r
1824 g_y1=TWin.Position.y0;g_y2=g_y1+TWin.Position.y1-1;
\r
1826 if(TextureMode==2) {GivenClutId=0;cx=cy=0;}
\r
1829 cx=((GivenClutId << 4) & 0x3F0);cy=((GivenClutId >> 6) & CLUTYMASK);
\r
1830 GivenClutId=(GivenClutId&CLUTMASK)|(DrawSemiTrans<<30);
\r
1832 // palette check sum
\r
1834 unsigned long l=0,row;
\r
1835 unsigned long * lSRCPtr=(unsigned long *)(psxVuw+cx+(cy*1024));
\r
1836 if(TextureMode==1) for(row=1;row<129;row++) l+=((*lSRCPtr++)-1)*row;
\r
1837 else for(row=1;row<9;row++) l+=((*lSRCPtr++)-1)<<row;
\r
1838 l=(l+HIWORD(l))&0x3fffL;
\r
1839 GivenClutId|=(l<<16);
\r
1846 for(i=0;i<iMaxTexWnds;i++,ts++)
\r
1850 if(ts->pos.l==npos.l &&
\r
1851 ts->pageid==pageid &&
\r
1852 ts->textureMode==TextureMode)
\r
1854 if(ts->ClutID==GivenClutId)
\r
1856 ubOpaqueDraw=ts->Opaque;
\r
1857 return ts->texname;
\r
1866 if(iMaxTexWnds==iTexWndLimit)
\r
1868 tsx=wcWndtexStore+iTexWndTurn;
\r
1870 if(iTexWndTurn==iTexWndLimit) iTexWndTurn=0;
\r
1874 tsx=wcWndtexStore+iMaxTexWnds;
\r
1879 gTexName=tsx->texname;
\r
1881 if(TWin.OPosition.y1==TWin.Position.y1 &&
\r
1882 TWin.OPosition.x1==TWin.Position.x1)
\r
1884 LoadWndTexturePage(pageid,TextureMode,cx,cy);
\r
1888 LoadStretchWndTexturePage(pageid,TextureMode,cx,cy);
\r
1891 tsx->Opaque=ubOpaqueDraw;
\r
1892 tsx->pos.l=npos.l;
\r
1893 tsx->ClutID=GivenClutId;
\r
1894 tsx->pageid=pageid;
\r
1895 tsx->textureMode=TextureMode;
\r
1896 tsx->texname=gTexName;
\r
1902 /////////////////////////////////////////////////////////////////////////////
\r
1903 /////////////////////////////////////////////////////////////////////////////
\r
1904 /////////////////////////////////////////////////////////////////////////////
\r
1906 ////////////////////////////////////////////////////////////////////////
\r
1907 // movie texture: define
\r
1908 ////////////////////////////////////////////////////////////////////////
\r
1910 void DefinePackedTextureMovie(void)
\r
1912 if(gTexMovieName==0)
\r
1914 glEnable(GL_TEXTURE_2D);
\r
1915 glGenTextures(1, &gTexMovieName); glError();
\r
1916 gTexName=gTexMovieName;
\r
1917 glBindTexture(GL_TEXTURE_2D, gTexName); glError();
\r
1919 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, iClampType); glError();
\r
1920 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, iClampType); glError();
\r
1922 if(!bUseFastMdec)
\r
1924 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glError();
\r
1925 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glError();
\r
1929 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, iFilter); glError();
\r
1930 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, iFilter); glError();
\r
1933 glTexImage2D(GL_TEXTURE_2D, 0, //giWantedRGBA,
\r
1935 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, texturepart); glError();
\r
1939 gTexName=gTexMovieName;glBindTexture(GL_TEXTURE_2D, gTexName); glError();
\r
1942 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
\r
1943 (xrMovieArea.x1-xrMovieArea.x0),
\r
1944 (xrMovieArea.y1-xrMovieArea.y0),
\r
1946 GL_UNSIGNED_SHORT,
\r
1947 texturepart); glError();
\r
1948 //LOGE("DefinePackedTextureMovie x:%d y:%d",(xrMovieArea.x1-xrMovieArea.x0),(xrMovieArea.y1-xrMovieArea.y0));
\r
1952 ////////////////////////////////////////////////////////////////////////
\r
1954 void DefineTextureMovie(void)
\r
1956 if(gTexMovieName==0)
\r
1958 glGenTextures(1, &gTexMovieName); glError();
\r
1959 gTexName=gTexMovieName;
\r
1960 glBindTexture(GL_TEXTURE_2D, gTexName); glError();
\r
1962 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, iClampType); glError();
\r
1963 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, iClampType); glError();
\r
1965 if(!bUseFastMdec)
\r
1967 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glError();
\r
1968 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glError();
\r
1972 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, iFilter); glError();
\r
1973 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, iFilter); glError();
\r
1976 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, texturepart); glError();
\r
1980 gTexName=gTexMovieName;glBindTexture(GL_TEXTURE_2D, gTexName); glError();
\r
1983 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
\r
1984 (xrMovieArea.x1-xrMovieArea.x0),
\r
1985 (xrMovieArea.y1-xrMovieArea.y0),
\r
1986 GL_RGBA, GL_UNSIGNED_BYTE, texturepart); glError();
\r
1987 //LOGE("DefineTextureMovie x:%d y:%d",(xrMovieArea.x1-xrMovieArea.x0),(xrMovieArea.y1-xrMovieArea.y0));
\r
1990 ////////////////////////////////////////////////////////////////////////
\r
1991 // movie texture: load
\r
1992 ////////////////////////////////////////////////////////////////////////
\r
1994 #define MRED(x) ((x>>3) & 0x1f)
\r
1995 #define MGREEN(x) ((x>>6) & 0x3e0)
\r
1996 #define MBLUE(x) ((x>>9) & 0x7c00)
\r
1998 #define XMGREEN(x) ((x>>5) & 0x07c0)
\r
1999 #define XMRED(x) ((x<<8) & 0xf800)
\r
2000 #define XMBLUE(x) ((x>>18) & 0x003e)
\r
2002 ////////////////////////////////////////////////////////////////////////
\r
2003 // movie texture: load
\r
2004 ////////////////////////////////////////////////////////////////////////
\r
2006 unsigned char * LoadDirectMovieFast(void)
\r
2009 unsigned int startxy;
\r
2011 unsigned long * ta=(unsigned long *)texturepart;
\r
2013 if(PSXDisplay.RGB24)
\r
2015 unsigned char * pD;
\r
2017 startxy=((1024)*xrMovieArea.y0)+xrMovieArea.x0;
\r
2019 for(column=xrMovieArea.y0;column<xrMovieArea.y1;column++,startxy+=1024)
\r
2021 pD=(unsigned char *)&psxVuw[startxy];
\r
2022 for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)
\r
2024 *ta++=*((unsigned long *)pD)|0xff000000;
\r
2031 unsigned long (*LTCOL)(unsigned long);
\r
2033 LTCOL=XP8RGBA_0;//TCF[0];
\r
2037 for(column=xrMovieArea.y0;column<xrMovieArea.y1;column++)
\r
2039 startxy=((1024)*column)+xrMovieArea.x0;
\r
2040 for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)
\r
2041 *ta++=LTCOL(psxVuw[startxy++]|0x8000);
\r
2045 return texturepart;
\r
2048 ////////////////////////////////////////////////////////////////////////
\r
2050 GLuint LoadTextureMovieFast(void)
\r
2053 unsigned int start,startxy;
\r
2056 if(PSXDisplay.RGB24)
\r
2058 unsigned char * pD;
\r
2059 unsigned long * ta=(unsigned long *)texturepart;
\r
2061 startxy=((1024)*xrMovieArea.y0)+xrMovieArea.x0;
\r
2063 for(column=xrMovieArea.y0;column<xrMovieArea.y1;column++,startxy+=1024)
\r
2065 //startxy=((1024)*column)+xrMovieArea.x0;
\r
2066 pD=(unsigned char *)&psxVuw[startxy];
\r
2067 for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)
\r
2069 *ta++=*((unsigned long *)pD)|0xff000000;
\r
2076 unsigned long (*LTCOL)(unsigned long);
\r
2077 unsigned long *ta;
\r
2079 LTCOL=XP8RGBA_0;//TCF[0];
\r
2082 ta=(unsigned long *)texturepart;
\r
2084 for(column=xrMovieArea.y0;column<xrMovieArea.y1;column++)
\r
2086 startxy=((1024)*column)+xrMovieArea.x0;
\r
2087 for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)
\r
2088 *ta++=LTCOL(psxVuw[startxy++]|0x8000);
\r
2091 DefineTextureMovie();
\r
2096 ////////////////////////////////////////////////////////////////////////
\r
2098 GLuint LoadTextureMovie(void)
\r
2100 short row,column,dx;
\r
2101 unsigned int startxy;
\r
2104 if(bUseFastMdec) return LoadTextureMovieFast();
\r
2106 b_X=FALSE;b_Y=FALSE;
\r
2108 if((xrMovieArea.x1-xrMovieArea.x0)<255) b_X=TRUE;
\r
2109 if((xrMovieArea.y1-xrMovieArea.y0)<255) b_Y=TRUE;
\r
2112 if(PSXDisplay.RGB24)
\r
2114 unsigned char * pD;
\r
2115 unsigned long * ta=(unsigned long *)texturepart;
\r
2119 for(column=xrMovieArea.y0;column<xrMovieArea.y1;column++)
\r
2121 startxy=((1024)*column)+xrMovieArea.x0;
\r
2122 pD=(unsigned char *)&psxVuw[startxy];
\r
2123 for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)
\r
2125 *ta++=*((unsigned long *)pD)|0xff000000;
\r
2132 dx=xrMovieArea.x1-xrMovieArea.x0+1;
\r
2133 for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)
\r
2140 for(column=xrMovieArea.y0;column<xrMovieArea.y1;column++)
\r
2142 startxy=((1024)*column)+xrMovieArea.x0;
\r
2143 pD=(unsigned char *)&psxVuw[startxy];
\r
2144 for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)
\r
2146 *ta++=*((unsigned long *)pD)|0xff000000;
\r
2152 dx=xrMovieArea.x1-xrMovieArea.x0;
\r
2153 for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)
\r
2160 unsigned long (*LTCOL)(unsigned long);
\r
2161 unsigned long *ta;
\r
2163 LTCOL=XP8RGBA_0;//TCF[0];
\r
2166 ta=(unsigned long *)texturepart;
\r
2170 for(column=xrMovieArea.y0;column<xrMovieArea.y1;column++)
\r
2172 startxy=((1024)*column)+xrMovieArea.x0;
\r
2173 for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)
\r
2174 *ta++=LTCOL(psxVuw[startxy++]|0x8000);
\r
2180 dx=xrMovieArea.x1-xrMovieArea.x0+1;
\r
2181 for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)
\r
2188 for(column=xrMovieArea.y0;column<xrMovieArea.y1;column++)
\r
2190 startxy=((1024)*column)+xrMovieArea.x0;
\r
2191 for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)
\r
2192 *ta++=LTCOL(psxVuw[startxy++]|0x8000);
\r
2197 dx=xrMovieArea.x1-xrMovieArea.x0;
\r
2198 for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)
\r
2204 xrMovieArea.x1+=b_X;xrMovieArea.y1+=b_Y;
\r
2205 DefineTextureMovie();
\r
2206 xrMovieArea.x1-=b_X;xrMovieArea.y1-=b_Y;
\r
2211 /////////////////////////////////////////////////////////////////////////////
\r
2212 /////////////////////////////////////////////////////////////////////////////
\r
2213 /////////////////////////////////////////////////////////////////////////////
\r
2215 GLuint BlackFake15BitTexture(void)
\r
2217 long pmult;short x1,x2,y1,y2;
\r
2219 if(PSXDisplay.InterlacedTest) return 0;
\r
2221 pmult=GlobalTexturePage/16;
\r
2223 x2=gl_ux[6]-gl_ux[7];
\r
2225 y2=gl_ux[4]-gl_ux[5];
\r
2234 x1+=((GlobalTexturePage-16*pmult)<<6);
\r
2236 if( FastCheckAgainstFrontScreen(x1,y1,x2,y2)
\r
2237 || FastCheckAgainstScreen(x1,y1,x2,y2))
\r
2239 if(!gTexFrameName)
\r
2241 glGenTextures(1, &gTexFrameName); glError();
\r
2242 gTexName=gTexFrameName;
\r
2243 glBindTexture(GL_TEXTURE_2D, gTexName); glError();
\r
2245 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, iClampType); glError();
\r
2246 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, iClampType); glError();
\r
2247 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, iFilter); glError();
\r
2248 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, iFilter); glError();
\r
2251 unsigned long * ta=(unsigned long *)texturepart;
\r
2252 for(y1=0;y1<=4;y1++)
\r
2253 for(x1=0;x1<=4;x1++)
\r
2256 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, texturepart); glError();
\r
2261 gTexName=gTexFrameName;
\r
2262 glBindTexture(GL_TEXTURE_2D, gTexName); glError();
\r
2264 //LOGE("BlackFake15BitTexture x:%d y:%d",4,4);
\r
2267 return (GLuint)gTexName;
\r
2272 /////////////////////////////////////////////////////////////////////////////
\r
2274 BOOL bFakeFrontBuffer=FALSE;
\r
2275 BOOL bIgnoreNextTile =FALSE;
\r
2279 GLuint Fake15BitTexture(void)
\r
2281 long pmult;short x1,x2,y1,y2;int iYAdjust;
\r
2282 float ScaleX,ScaleY;RECT rSrc;
\r
2284 if(iFrameTexType==1) return BlackFake15BitTexture();
\r
2285 if(PSXDisplay.InterlacedTest) return 0;
\r
2287 pmult=GlobalTexturePage/16;
\r
2289 x2=gl_ux[6]-gl_ux[7];
\r
2291 y2=gl_ux[4]-gl_ux[5];
\r
2294 x1+=((GlobalTexturePage-16*pmult)<<6);
\r
2296 if(iFrameTexType==3)
\r
2298 if(iFrameReadType==4) return 0;
\r
2300 if(!FastCheckAgainstFrontScreen(x1,y1,x2,y2) &&
\r
2301 !FastCheckAgainstScreen(x1,y1,x2,y2))
\r
2304 if(bFakeFrontBuffer) bIgnoreNextTile=TRUE;
\r
2305 CheckVRamReadEx(x1,y1,x1+x2,y1+y2);
\r
2309 /////////////////////////
\r
2311 if(FastCheckAgainstFrontScreen(x1,y1,x2,y2))
\r
2313 x1-=PSXDisplay.DisplayPosition.x;
\r
2314 y1-=PSXDisplay.DisplayPosition.y;
\r
2317 if(FastCheckAgainstScreen(x1,y1,x2,y2))
\r
2319 x1-=PreviousPSXDisplay.DisplayPosition.x;
\r
2320 y1-=PreviousPSXDisplay.DisplayPosition.y;
\r
2324 bDrawMultiPass = FALSE;
\r
2326 if(!gTexFrameName)
\r
2330 if(iResX>1280 || iResY>1024) iFTex=2048;
\r
2332 if(iResX>640 || iResY>480) iFTex=1024;
\r
2335 glGenTextures(1, &gTexFrameName); glError();
\r
2336 gTexName=gTexFrameName;
\r
2337 glBindTexture(GL_TEXTURE_2D, gTexName); glError();
\r
2339 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, iClampType); glError();
\r
2340 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, iClampType); glError();
\r
2341 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, iFilter); glError();
\r
2342 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, iFilter); glError();
\r
2344 p=(char *)malloc(iFTex*iFTex*4);
\r
2345 memset(p,0,iFTex*iFTex*4);
\r
2346 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, iFTex, iFTex, 0, GL_RGBA, GL_UNSIGNED_BYTE, p); glError();
\r
2353 gTexName=gTexFrameName;
\r
2354 glBindTexture(GL_TEXTURE_2D, gTexName); glError();
\r
2356 //LOGE("Fake15BitTexture x:%d y:%d",iFTex,iFTex);
\r
2357 x1+=PreviousPSXDisplay.Range.x0;
\r
2358 y1+=PreviousPSXDisplay.Range.y0;
\r
2360 if(PSXDisplay.DisplayMode.x)
\r
2361 ScaleX=(float)rRatioRect.right/(float)PSXDisplay.DisplayMode.x;
\r
2363 if(PSXDisplay.DisplayMode.y)
\r
2364 ScaleY=(float)rRatioRect.bottom/(float)PSXDisplay.DisplayMode.y;
\r
2367 rSrc.left =max(x1*ScaleX,0);
\r
2368 rSrc.right =min((x1+x2)*ScaleX+0.99f,iResX-1);
\r
2369 rSrc.top =max(y1*ScaleY,0);
\r
2370 rSrc.bottom=min((y1+y2)*ScaleY+0.99f,iResY-1);
\r
2372 iYAdjust=(y1+y2)-PSXDisplay.DisplayMode.y;
\r
2374 iYAdjust=(int)((float)iYAdjust*ScaleY)+1;
\r
2377 gl_vy[0]=255-gl_vy[0];
\r
2378 gl_vy[1]=255-gl_vy[1];
\r
2379 gl_vy[2]=255-gl_vy[2];
\r
2380 gl_vy[3]=255-gl_vy[3];
\r
2382 y1=min(gl_vy[0],min(gl_vy[1],min(gl_vy[2],gl_vy[3])));
\r
2388 gl_ux[0]-=gl_ux[7];
\r
2389 gl_ux[1]-=gl_ux[7];
\r
2390 gl_ux[2]-=gl_ux[7];
\r
2391 gl_ux[3]-=gl_ux[7];
\r
2393 ScaleX*=256.0f/((float)(iFTex));
\r
2394 ScaleY*=256.0f/((float)(iFTex));
\r
2396 y1=((float)gl_vy[0]*ScaleY); if(y1>255) y1=255;
\r
2398 y1=((float)gl_vy[1]*ScaleY); if(y1>255) y1=255;
\r
2400 y1=((float)gl_vy[2]*ScaleY); if(y1>255) y1=255;
\r
2402 y1=((float)gl_vy[3]*ScaleY); if(y1>255) y1=255;
\r
2405 x1=((float)gl_ux[0]*ScaleX); if(x1>255) x1=255;
\r
2407 x1=((float)gl_ux[1]*ScaleX); if(x1>255) x1=255;
\r
2409 x1=((float)gl_ux[2]*ScaleX); if(x1>255) x1=255;
\r
2411 x1=((float)gl_ux[3]*ScaleX); if(x1>255) x1=255;
\r
2414 x1=rSrc.right-rSrc.left;
\r
2416 if(x1>iFTex) x1=iFTex;
\r
2418 y1=rSrc.bottom-rSrc.top;
\r
2420 if(y1+iYAdjust>iFTex) y1=iFTex-iYAdjust;
\r
2423 glCopyTexSubImage2D( GL_TEXTURE_2D, 0,
\r
2426 rSrc.left+rRatioRect.left,
\r
2427 iResY-rSrc.bottom-rRatioRect.top,
\r
2428 x1,y1); glError();
\r
2432 char * p=(char *)malloc(iFTex*iFTex*4);
\r
2433 memset(p,0,iFTex*iFTex*4);
\r
2434 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, iFTex, iFTex,
\r
2435 GL_RGBA, GL_UNSIGNED_BYTE, p); glError();
\r
2444 sprtW=gl_ux[1]-gl_ux[0];
\r
2445 sprtH=-(gl_vy[0]-gl_vy[2]);
\r
2448 return (GLuint)gTexName;
\r
2451 /////////////////////////////////////////////////////////////////////////////
\r
2452 /////////////////////////////////////////////////////////////////////////////
\r
2453 /////////////////////////////////////////////////////////////////////////////
\r
2455 // load texture part (unpacked)
\r
2457 /////////////////////////////////////////////////////////////////////////////
\r
2458 /////////////////////////////////////////////////////////////////////////////
\r
2459 /////////////////////////////////////////////////////////////////////////////
\r
2461 void LoadSubTexturePageSort(int pageid, int mode, short cx, short cy)
\r
2463 unsigned long start,row,column,j,sxh,sxm;
\r
2464 unsigned int palstart;
\r
2465 unsigned long *px,*pa,*ta;
\r
2466 unsigned char *cSRCPtr;
\r
2467 unsigned short *wSRCPtr;
\r
2468 unsigned long LineOffset;
\r
2469 unsigned long x2a,xalign=0;
\r
2470 unsigned long x1=gl_ux[7];
\r
2471 unsigned long x2=gl_ux[6];
\r
2472 unsigned long y1=gl_ux[5];
\r
2473 unsigned long y2=gl_ux[4];
\r
2474 unsigned long dx=x2-x1+1;
\r
2475 unsigned long dy=y2-y1+1;
\r
2476 int pmult=pageid/16;
\r
2477 unsigned long (*LTCOL)(unsigned long);
\r
2478 unsigned int a,r,g,b,cnt,h;
\r
2479 unsigned long scol[8];
\r
2481 LTCOL=TCF[DrawSemiTrans];
\r
2483 pa=px=(unsigned long *)ubPaletteBuffer;
\r
2484 ta=(unsigned long *)texturepart;
\r
2485 palstart=cx+(cy<<10);
\r
2489 if(YTexS) {ta+=dx;if(XTexS) ta+=2;}
\r
2490 if(XTexS) {ta+=1;xalign=2;}
\r
2494 //--------------------------------------------------//
\r
2495 // 4bit texture load ..
\r
2499 unsigned int TXV,TXU,n_xi,n_yi;
\r
2501 wSRCPtr=psxVuw+palstart;
\r
2505 *px =LTCOL(*wSRCPtr);
\r
2506 *(px+1)=LTCOL(*(wSRCPtr+1));
\r
2507 *(px+2)=LTCOL(*(wSRCPtr+2));
\r
2508 *(px+3)=LTCOL(*(wSRCPtr+3));
\r
2509 row--;px+=4;wSRCPtr+=4;
\r
2513 for(TXV=y1;TXV<=y2;TXV++)
\r
2515 for(TXU=x1;TXU<=x2;TXU++)
\r
2517 n_xi = ( ( TXU >> 2 ) & ~0x3c ) + ( ( TXV << 2 ) & 0x3c );
\r
2518 n_yi = ( TXV & ~0xf ) + ( ( TXU >> 4 ) & 0xf );
\r
2520 *ta++=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x03 ) << 2 ) ) & 0x0f ));
\r
2527 start=((pageid-16*pmult)<<7)+524288*pmult;
\r
2528 // convert CLUT to 32bits .. and then use THAT as a lookup table
\r
2530 wSRCPtr=psxVuw+palstart;
\r
2534 *px =LTCOL(*wSRCPtr);
\r
2535 *(px+1)=LTCOL(*(wSRCPtr+1));
\r
2536 *(px+2)=LTCOL(*(wSRCPtr+2));
\r
2537 *(px+3)=LTCOL(*(wSRCPtr+3));
\r
2538 row--;px+=4;wSRCPtr+=4;
\r
2542 x2a=x2?(x2-1):0;//if(x2) x2a=x2-1; else x2a=0;
\r
2543 sxm=x1&1;sxh=x1>>1;
\r
2544 j=sxm?(x1+1):x1;//if(sxm) j=x1+1; else j=x1;
\r
2545 for(column=y1;column<=y2;column++)
\r
2547 cSRCPtr = psxVub + start + (column<<11) + sxh;
\r
2549 if(sxm) *ta++=*(pa+((*cSRCPtr++ >> 4) & 0xF));
\r
2551 for(row=j;row<x2a;row+=2)
\r
2553 *ta =*(pa+(*cSRCPtr & 0xF));
\r
2554 *(ta+1)=*(pa+((*cSRCPtr >> 4) & 0xF));
\r
2560 *ta++=*(pa+(*cSRCPtr & 0xF)); row++;
\r
2561 if(row<=x2) *ta++=*(pa+((*cSRCPtr >> 4) & 0xF));
\r
2568 //--------------------------------------------------//
\r
2569 // 8bit texture load ..
\r
2573 unsigned int TXV,TXU,n_xi,n_yi;
\r
2575 wSRCPtr=psxVuw+palstart;
\r
2579 *px =LTCOL(*wSRCPtr);
\r
2580 *(px+1)=LTCOL(*(wSRCPtr+1));
\r
2581 *(px+2)=LTCOL(*(wSRCPtr+2));
\r
2582 *(px+3)=LTCOL(*(wSRCPtr+3));
\r
2583 row--;px+=4;wSRCPtr+=4;
\r
2587 for(TXV=y1;TXV<=y2;TXV++)
\r
2589 for(TXU=x1;TXU<=x2;TXU++)
\r
2591 n_xi = ( ( TXU >> 1 ) & ~0x78 ) + ( ( TXU << 2 ) & 0x40 ) + ( ( TXV << 3 ) & 0x38 );
\r
2592 n_yi = ( TXV & ~0x7 ) + ( ( TXU >> 5 ) & 0x7 );
\r
2594 *ta++=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x01 ) << 3 ) ) & 0xff));
\r
2602 start=((pageid-16*pmult)<<7)+524288*pmult;
\r
2604 cSRCPtr = psxVub + start + (y1<<11) + x1;
\r
2605 LineOffset = 2048 - dx;
\r
2609 wSRCPtr=psxVuw+palstart;
\r
2613 *px =LTCOL(*wSRCPtr);
\r
2614 *(px+1)=LTCOL(*(wSRCPtr+1));
\r
2615 *(px+2)=LTCOL(*(wSRCPtr+2));
\r
2616 *(px+3)=LTCOL(*(wSRCPtr+3));
\r
2617 row--;px+=4;wSRCPtr+=4;
\r
2624 do {*ta++=*(pa+(*cSRCPtr++));row--;} while(row);
\r
2626 cSRCPtr+=LineOffset;column--;
\r
2632 wSRCPtr=psxVuw+palstart;
\r
2637 do {*ta++=LTCOL(*(wSRCPtr+*cSRCPtr++));row--;} while(row);
\r
2639 cSRCPtr+=LineOffset;column--;
\r
2645 //--------------------------------------------------//
\r
2646 // 16bit texture load ..
\r
2648 start=((pageid-16*pmult)<<6)+262144*pmult;
\r
2650 wSRCPtr = psxVuw + start + (y1<<10) + x1;
\r
2651 LineOffset = 1024 - dx;
\r
2656 do {*ta++=LTCOL(*wSRCPtr++);row--;} while(row);
\r
2658 wSRCPtr+=LineOffset;column--;
\r
2663 //--------------------------------------------------//
\r
2664 // others are not possible !
\r
2671 ta=(unsigned long *)texturepart;
\r
2672 pa=(unsigned long *)texturepart+x2a;
\r
2673 row=x2a;do {*ta++=*pa++;row--;} while(row);
\r
2674 pa=(unsigned long *)texturepart+dy*x2a;
\r
2676 row=x2a;do {*ta++=*pa++;row--;} while(row);
\r
2683 ta=(unsigned long *)texturepart;
\r
2685 row=dy;do {*ta=*pa;ta+=x2a;pa+=x2a;row--;} while(row);
\r
2686 pa=(unsigned long *)texturepart+dx;
\r
2688 row=dy;do {*ta=*pa;ta+=x2a;pa+=x2a;row--;} while(row);
\r
2693 DXTexS=dx;DYTexS=dy;
\r
2695 if(!iFilterType) {DefineSubTextureSort();return;}
\r
2696 if(iFilterType!=2 && iFilterType!=4 && iFilterType!=6) {DefineSubTextureSort();return;}
\r
2697 if((iFilterType==4 || iFilterType==6) && ly0==ly1 && ly2==ly3 && lx0==lx3 && lx1==lx2)
\r
2698 {DefineSubTextureSort();return;}
\r
2700 ta=(unsigned long *)texturepart;
\r
2707 for(column=0;column<dy;column++)
\r
2709 for(row=0;row<dx;row++)
\r
2711 if(*ta==0x50000000)
\r
2715 if( column && *(ta-dx) !=0x50000000 && *(ta-dx)>>24!=1) scol[cnt++]=*(ta-dx);
\r
2716 if(row && *(ta-1) !=0x50000000 && *(ta-1)>>24!=1) scol[cnt++]=*(ta-1);
\r
2717 if(row!=x1 && *(ta+1) !=0x50000000 && *(ta+1)>>24!=1) scol[cnt++]=*(ta+1);
\r
2718 if( column!=y1 && *(ta+dx) !=0x50000000 && *(ta+dx)>>24!=1) scol[cnt++]=*(ta+dx);
\r
2720 if(row && column && *(ta-dx-1)!=0x50000000 && *(ta-dx-1)>>24!=1) scol[cnt++]=*(ta-dx-1);
\r
2721 if(row!=x1 && column && *(ta-dx+1)!=0x50000000 && *(ta-dx+1)>>24!=1) scol[cnt++]=*(ta-dx+1);
\r
2722 if(row && column!=y1 && *(ta+dx-1)!=0x50000000 && *(ta+dx-1)>>24!=1) scol[cnt++]=*(ta+dx-1);
\r
2723 if(row!=x1 && column!=y1 && *(ta+dx+1)!=0x50000000 && *(ta+dx+1)>>24!=1) scol[cnt++]=*(ta+dx+1);
\r
2728 for(h=0;h<cnt;h++)
\r
2731 r+=(scol[h]>>16)&0xff;
\r
2732 g+=(scol[h]>>8)&0xff;
\r
2735 r/=cnt;b/=cnt;g/=cnt;
\r
2737 *ta=(r<<16)|(g<<8)|b;
\r
2738 if(a) *ta|=0x50000000;
\r
2739 else *ta|=0x01000000;
\r
2748 for(column=0;column<dy;column++)
\r
2750 for(row=0;row<dx;row++)
\r
2752 if(*ta==0x00000000)
\r
2756 if(row!=x1 && *(ta+1) !=0x00000000) scol[cnt++]=*(ta+1);
\r
2757 if( column!=y1 && *(ta+dx) !=0x00000000) scol[cnt++]=*(ta+dx);
\r
2762 for(h=0;h<cnt;h++)
\r
2764 r+=(scol[h]>>16)&0xff;
\r
2765 g+=(scol[h]>>8)&0xff;
\r
2768 r/=cnt;b/=cnt;g/=cnt;
\r
2769 *ta=(r<<16)|(g<<8)|b;
\r
2776 DefineSubTextureSort();
\r
2779 /////////////////////////////////////////////////////////////////////////////
\r
2780 /////////////////////////////////////////////////////////////////////////////
\r
2781 /////////////////////////////////////////////////////////////////////////////
\r
2783 // load texture part (packed)
\r
2785 /////////////////////////////////////////////////////////////////////////////
\r
2786 /////////////////////////////////////////////////////////////////////////////
\r
2787 /////////////////////////////////////////////////////////////////////////////
\r
2789 void LoadPackedSubTexturePageSort(int pageid, int mode, short cx, short cy)
\r
2791 unsigned long start,row,column,j,sxh,sxm;
\r
2792 unsigned int palstart;
\r
2793 unsigned short *px,*pa,*ta;
\r
2794 unsigned char *cSRCPtr;
\r
2795 unsigned short *wSRCPtr;
\r
2796 unsigned long LineOffset;
\r
2797 unsigned long x2a,xalign=0;
\r
2798 unsigned long x1=gl_ux[7];
\r
2799 unsigned long x2=gl_ux[6];
\r
2800 unsigned long y1=gl_ux[5];
\r
2801 unsigned long y2=gl_ux[4];
\r
2802 unsigned long dx=x2-x1+1;
\r
2803 unsigned long dy=y2-y1+1;
\r
2804 int pmult=pageid/16;
\r
2805 unsigned short (*LPTCOL)(unsigned short);
\r
2806 unsigned int a,r,g,b,cnt,h;
\r
2807 unsigned short scol[8];
\r
2809 LPTCOL=PTCF[DrawSemiTrans];
\r
2811 pa=px=(unsigned short *)ubPaletteBuffer;
\r
2812 ta=(unsigned short *)texturepart;
\r
2813 palstart=cx+(cy<<10);
\r
2817 if(YTexS) {ta+=dx;if(XTexS) ta+=2;}
\r
2818 if(XTexS) {ta+=1;xalign=2;}
\r
2822 //--------------------------------------------------//
\r
2823 // 4bit texture load ..
\r
2827 unsigned int TXV,TXU,n_xi,n_yi;
\r
2829 wSRCPtr=psxVuw+palstart;
\r
2832 *px =LPTCOL(*wSRCPtr);
\r
2833 *(px+1)=LPTCOL(*(wSRCPtr+1));
\r
2834 *(px+2)=LPTCOL(*(wSRCPtr+2));
\r
2835 *(px+3)=LPTCOL(*(wSRCPtr+3));
\r
2836 row--;px+=4;wSRCPtr+=4;
\r
2840 for(TXV=y1;TXV<=y2;TXV++)
\r
2842 for(TXU=x1;TXU<=x2;TXU++)
\r
2844 n_xi = ( ( TXU >> 2 ) & ~0x3c ) + ( ( TXV << 2 ) & 0x3c );
\r
2845 n_yi = ( TXV & ~0xf ) + ( ( TXU >> 4 ) & 0xf );
\r
2847 *ta++=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x03 ) << 2 ) ) & 0x0f ));
\r
2854 start=((pageid-16*pmult)<<7)+524288*pmult;
\r
2856 wSRCPtr=psxVuw+palstart;
\r
2859 *px =LPTCOL(*wSRCPtr);
\r
2860 *(px+1)=LPTCOL(*(wSRCPtr+1));
\r
2861 *(px+2)=LPTCOL(*(wSRCPtr+2));
\r
2862 *(px+3)=LPTCOL(*(wSRCPtr+3));
\r
2863 row--;px+=4;wSRCPtr+=4;
\r
2867 x2a=x2?(x2-1):0;//if(x2) x2a=x2-1; else x2a=0;
\r
2868 sxm=x1&1;sxh=x1>>1;
\r
2869 j=sxm?(x1+1):x1;//if(sxm) j=x1+1; else j=x1;
\r
2871 for(column=y1;column<=y2;column++)
\r
2873 cSRCPtr = psxVub + start + (column<<11) + sxh;
\r
2875 if(sxm) *ta++=*(pa+((*cSRCPtr++ >> 4) & 0xF));
\r
2877 for(row=j;row<x2a;row+=2)
\r
2879 *ta =*(pa+(*cSRCPtr & 0xF));
\r
2880 *(ta+1)=*(pa+((*cSRCPtr >> 4) & 0xF));
\r
2886 *ta++=*(pa+(*cSRCPtr & 0xF));row++;
\r
2887 if(row<=x2) *ta++=*(pa+((*cSRCPtr >> 4) & 0xF));
\r
2893 //--------------------------------------------------//
\r
2894 // 8bit texture load ..
\r
2898 unsigned int TXV,TXU,n_xi,n_yi;
\r
2900 wSRCPtr=psxVuw+palstart;
\r
2904 *px =LPTCOL(*wSRCPtr);
\r
2905 *(px+1)=LPTCOL(*(wSRCPtr+1));
\r
2906 *(px+2)=LPTCOL(*(wSRCPtr+2));
\r
2907 *(px+3)=LPTCOL(*(wSRCPtr+3));
\r
2908 row--;px+=4;wSRCPtr+=4;
\r
2912 for(TXV=y1;TXV<=y2;TXV++)
\r
2914 for(TXU=x1;TXU<=x2;TXU++)
\r
2916 n_xi = ( ( TXU >> 1 ) & ~0x78 ) + ( ( TXU << 2 ) & 0x40 ) + ( ( TXV << 3 ) & 0x38 );
\r
2917 n_yi = ( TXV & ~0x7 ) + ( ( TXU >> 5 ) & 0x7 );
\r
2919 *ta++=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x01 ) << 3 ) ) & 0xff));
\r
2927 start=((pageid-16*pmult)<<7)+524288*pmult;
\r
2929 cSRCPtr = psxVub + start + (y1<<11) + x1;
\r
2930 LineOffset = 2048 - dx;
\r
2932 if(dy*dx>384) // more pix? use lut
\r
2934 wSRCPtr=psxVuw+palstart;
\r
2938 *px =LPTCOL(*wSRCPtr);
\r
2939 *(px+1)=LPTCOL(*(wSRCPtr+1));
\r
2940 *(px+2)=LPTCOL(*(wSRCPtr+2));
\r
2941 *(px+3)=LPTCOL(*(wSRCPtr+3));
\r
2942 row--;px+=4;wSRCPtr+=4;
\r
2949 do {*ta++=*(pa+(*cSRCPtr++));row--;} while(row);
\r
2953 cSRCPtr+=LineOffset;column--;
\r
2957 else // small area? no lut
\r
2959 wSRCPtr=psxVuw+palstart;
\r
2964 do {*ta++=LPTCOL(*(wSRCPtr+*cSRCPtr++));row--;} while(row);
\r
2968 cSRCPtr+=LineOffset;column--;
\r
2973 //--------------------------------------------------//
\r
2974 // 16bit texture load ..
\r
2976 start=((pageid-16*pmult)<<6)+262144*pmult;
\r
2978 wSRCPtr = psxVuw + start + (y1<<10) + x1;
\r
2979 LineOffset = 1024 - dx;
\r
2984 do {*ta++=LPTCOL(*wSRCPtr++);row--;} while(row);
\r
2988 wSRCPtr+=LineOffset;column--;
\r
2992 //--------------------------------------------------//
\r
2993 // others are not possible !
\r
2996 ////////////////////////////////////////////////////////
\r
3002 ta=(unsigned short *)texturepart;
\r
3003 pa=(unsigned short *)texturepart+x2a;
\r
3004 row=x2a;do {*ta++=*pa++;row--;} while(row);
\r
3006 pa=(unsigned short *)texturepart+dy*x2a;
\r
3008 row=x2a;do {*ta++=*pa++;row--;} while(row);
\r
3016 ta=(unsigned short *)texturepart;
\r
3018 row=dy;do {*ta=*pa;ta+=x2a;pa+=x2a;row--;} while(row);
\r
3020 pa=(unsigned short *)texturepart+dx;
\r
3022 row=dy;do {*ta=*pa;ta+=x2a;pa+=x2a;row--;} while(row);
\r
3028 DXTexS=dx;DYTexS=dy;
\r
3030 if(!iFilterType) {DefineSubTextureSort();return;}
\r
3031 if(iFilterType!=2 && iFilterType!=4 && iFilterType!=6) {DefineSubTextureSort();return;}
\r
3032 if((iFilterType==4 || iFilterType==6) && ly0==ly1 && ly2==ly3 && lx0==lx3 && lx1==lx2)
\r
3033 {DefineSubTextureSort();return;}
\r
3035 ta=(unsigned short *)texturepart;
\r
3040 for(column=0;column<dy;column++)
\r
3042 for(row=0;row<dx;row++)
\r
3048 if( column && *(ta-dx) &1) scol[cnt++]=*(ta-dx);
\r
3049 if(row && *(ta-1) &1) scol[cnt++]=*(ta-1);
\r
3050 if(row!=x1 && *(ta+1) &1) scol[cnt++]=*(ta+1);
\r
3051 if( column!=y1 && *(ta+dx) &1) scol[cnt++]=*(ta+dx);
\r
3053 if(row && column && *(ta-dx-1)&1) scol[cnt++]=*(ta-dx-1);
\r
3054 if(row!=x1 && column && *(ta-dx+1)&1) scol[cnt++]=*(ta-dx+1);
\r
3055 if(row && column!=y1 && *(ta+dx-1)&1) scol[cnt++]=*(ta+dx-1);
\r
3056 if(row!=x1 && column!=y1 && *(ta+dx+1)&1) scol[cnt++]=*(ta+dx+1);
\r
3061 for(h=0;h<cnt;h++)
\r
3064 g+=(scol[h]>>6)&0x1f;
\r
3065 b+=(scol[h]>>1)&0x1f;
\r
3067 r/=cnt;b/=cnt;g/=cnt;
\r
3068 *ta=(r<<11)|(g<<6)|(b<<1);
\r
3076 DefineSubTextureSort();
\r
3079 /////////////////////////////////////////////////////////////////////////////
\r
3081 /////////////////////////////////////////////////////////////////////////////
\r
3082 /////////////////////////////////////////////////////////////////////////////
\r
3083 /////////////////////////////////////////////////////////////////////////////
\r
3085 // hires texture funcs
\r
3087 /////////////////////////////////////////////////////////////////////////////
\r
3088 /////////////////////////////////////////////////////////////////////////////
\r
3089 /////////////////////////////////////////////////////////////////////////////
\r
3092 #define GET_RESULT(A, B, C, D) ((A != C || A != D) - (B != C || B != D))
\r
3094 ////////////////////////////////////////////////////////////////////////
\r
3096 #define colorMask8 0x00FEFEFE
\r
3097 #define lowPixelMask8 0x00010101
\r
3098 #define qcolorMask8 0x00FCFCFC
\r
3099 #define qlowpixelMask8 0x00030303
\r
3102 #define INTERPOLATE8_02(A, B) (((((A & colorMask8) >> 1) + ((B & colorMask8) >> 1) + (A & B & lowPixelMask8))|((((A&0xFF000000)==0x03000000)?0x03000000:(((B&0xFF000000)==0x03000000)?0x03000000:(((A&0xFF000000)==0x00000000)?0x00000000:(((B&0xFF000000)==0x00000000)?0x00000000:0xFF000000)))))))
\r
3104 #define Q_INTERPOLATE8_02(A, B, C, D) (((((A & qcolorMask8) >> 2) + ((B & qcolorMask8) >> 2) + ((C & qcolorMask8) >> 2) + ((D & qcolorMask8) >> 2) + ((((A & qlowpixelMask8) + (B & qlowpixelMask8) + (C & qlowpixelMask8) + (D & qlowpixelMask8)) >> 2) & qlowpixelMask8))|((((A&0xFF000000)==0x03000000)?0x03000000:(((B&0xFF000000)==0x03000000)?0x03000000:(((C&0xFF000000)==0x03000000)?0x03000000:(((D&0xFF000000)==0x03000000)?0x03000000:(((A&0xFF000000)==0x00000000)?0x00000000:(((B&0xFF000000)==0x00000000)?0x00000000:(((C&0xFF000000)==0x00000000)?0x00000000:(((D&0xFF000000)==0x00000000)?0x00000000:0xFF000000)))))))))))
\r
3106 #define INTERPOLATE8(A, B) (((((A & colorMask8) >> 1) + ((B & colorMask8) >> 1) + (A & B & lowPixelMask8))|((((A&0xFF000000)==0x50000000)?0x50000000:(((B&0xFF000000)==0x50000000)?0x50000000:(((A&0xFF000000)==0x00000000)?0x00000000:(((B&0xFF000000)==0x00000000)?0x00000000:0xFF000000)))))))
\r
3108 #define Q_INTERPOLATE8(A, B, C, D) (((((A & qcolorMask8) >> 2) + ((B & qcolorMask8) >> 2) + ((C & qcolorMask8) >> 2) + ((D & qcolorMask8) >> 2) + ((((A & qlowpixelMask8) + (B & qlowpixelMask8) + (C & qlowpixelMask8) + (D & qlowpixelMask8)) >> 2) & qlowpixelMask8))|((((A&0xFF000000)==0x50000000)?0x50000000:(((B&0xFF000000)==0x50000000)?0x50000000:(((C&0xFF000000)==0x50000000)?0x50000000:(((D&0xFF000000)==0x50000000)?0x50000000:(((A&0xFF000000)==0x00000000)?0x00000000:(((B&0xFF000000)==0x00000000)?0x00000000:(((C&0xFF000000)==0x00000000)?0x00000000:(((D&0xFF000000)==0x00000000)?0x00000000:0xFF000000)))))))))))
\r
3110 void Super2xSaI_ex8_Ex(unsigned char *srcPtr, DWORD srcPitch,
\r
3111 unsigned char *dstBitmap, int width, int height)
\r
3113 DWORD dstPitch = srcPitch * 2;
\r
3117 int width2 = width*2;
\r
3118 int iXA,iXB,iXC,iYA,iYB,iYC,finish;
\r
3119 DWORD color4, color5, color6;
\r
3120 DWORD color1, color2, color3;
\r
3121 DWORD colorA0, colorA1, colorA2, colorA3,
\r
3122 colorB0, colorB1, colorB2, colorB3,
\r
3124 DWORD product1a, product1b,
\r
3125 product2a, product2b;
\r
3130 for (; height; height-=1)
\r
3132 bP = (DWORD *)srcPtr;
\r
3133 dP = (DWORD *)(dstBitmap + line*dstPitch);
\r
3134 for (finish = width; finish; finish -= 1 )
\r
3136 //--------------------------------------- B1 B2
\r
3140 if(finish==width) iXA=0;
\r
3142 if(finish>4) {iXB=1;iXC=2;}
\r
3144 if(finish>3) {iXB=1;iXC=1;}
\r
3145 else {iXB=0;iXC=0;}
\r
3146 if(line==0) iYA=0;
\r
3148 if(height>4) {iYB=width;iYC=width2;}
\r
3150 if(height>3) {iYB=width;iYC=width;}
\r
3151 else {iYB=0;iYC=0;}
\r
3154 colorB0 = *(bP- iYA - iXA);
\r
3155 colorB1 = *(bP- iYA);
\r
3156 colorB2 = *(bP- iYA + iXB);
\r
3157 colorB3 = *(bP- iYA + iXC);
\r
3159 color4 = *(bP - iXA);
\r
3161 color6 = *(bP + iXB);
\r
3162 colorS2 = *(bP + iXC);
\r
3164 color1 = *(bP + iYB - iXA);
\r
3165 color2 = *(bP + iYB);
\r
3166 color3 = *(bP + iYB + iXB);
\r
3167 colorS1= *(bP + iYB + iXC);
\r
3169 colorA0 = *(bP + iYC - iXA);
\r
3170 colorA1 = *(bP + iYC);
\r
3171 colorA2 = *(bP + iYC + iXB);
\r
3172 colorA3 = *(bP + iYC + iXC);
\r
3174 //--------------------------------------
\r
3175 if (color2 == color6 && color5 != color3)
\r
3177 product2b = product1b = color2;
\r
3180 if (color5 == color3 && color2 != color6)
\r
3182 product2b = product1b = color5;
\r
3185 if (color5 == color3 && color2 == color6)
\r
3187 register int r = 0;
\r
3189 r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (color1&0x00ffffff), (colorA1&0x00ffffff));
\r
3190 r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (color4&0x00ffffff), (colorB1&0x00ffffff));
\r
3191 r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (colorA2&0x00ffffff), (colorS1&0x00ffffff));
\r
3192 r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (colorB2&0x00ffffff), (colorS2&0x00ffffff));
\r
3195 product2b = product1b = color6;
\r
3198 product2b = product1b = color5;
\r
3201 product2b = product1b = INTERPOLATE8_02(color5, color6);
\r
3206 if (color6 == color3 && color3 == colorA1 && color2 != colorA2 && color3 != colorA0)
\r
3207 product2b = Q_INTERPOLATE8_02 (color3, color3, color3, color2);
\r
3209 if (color5 == color2 && color2 == colorA2 && colorA1 != color3 && color2 != colorA3)
\r
3210 product2b = Q_INTERPOLATE8_02 (color2, color2, color2, color3);
\r
3212 product2b = INTERPOLATE8_02 (color2, color3);
\r
3214 if (color6 == color3 && color6 == colorB1 && color5 != colorB2 && color6 != colorB0)
\r
3215 product1b = Q_INTERPOLATE8_02 (color6, color6, color6, color5);
\r
3217 if (color5 == color2 && color5 == colorB2 && colorB1 != color6 && color5 != colorB3)
\r
3218 product1b = Q_INTERPOLATE8_02 (color6, color5, color5, color5);
\r
3220 product1b = INTERPOLATE8_02 (color5, color6);
\r
3223 if (color5 == color3 && color2 != color6 && color4 == color5 && color5 != colorA2)
\r
3224 product2a = INTERPOLATE8_02(color2, color5);
\r
3226 if (color5 == color1 && color6 == color5 && color4 != color2 && color5 != colorA0)
\r
3227 product2a = INTERPOLATE8_02(color2, color5);
\r
3229 product2a = color2;
\r
3231 if (color2 == color6 && color5 != color3 && color1 == color2 && color2 != colorB2)
\r
3232 product1a = INTERPOLATE8_02(color2, color5);
\r
3234 if (color4 == color2 && color3 == color2 && color1 != color5 && color2 != colorB0)
\r
3235 product1a = INTERPOLATE8_02(color2, color5);
\r
3237 product1a = color5;
\r
3240 *(dP+1)=product1b;
\r
3241 *(dP+(width2))=product2a;
\r
3242 *(dP+1+(width2))=product2b;
\r
3246 }//end of for ( finish= width etc..)
\r
3249 srcPtr += srcPitch;
\r
3250 }; //endof: for (; height; height--)
\r
3255 void Super2xSaI_ex8(unsigned char *srcPtr, DWORD srcPitch,
\r
3256 unsigned char *dstBitmap, int width, int height)
\r
3258 DWORD dstPitch = srcPitch * 2;
\r
3262 int width2 = width*2;
\r
3263 int iXA,iXB,iXC,iYA,iYB,iYC,finish;
\r
3264 DWORD color4, color5, color6;
\r
3265 DWORD color1, color2, color3;
\r
3266 DWORD colorA0, colorA1, colorA2, colorA3,
\r
3267 colorB0, colorB1, colorB2, colorB3,
\r
3269 DWORD product1a, product1b,
\r
3270 product2a, product2b;
\r
3275 for (; height; height-=1)
\r
3277 bP = (DWORD *)srcPtr;
\r
3278 dP = (DWORD *)(dstBitmap + line*dstPitch);
\r
3279 for (finish = width; finish; finish -= 1 )
\r
3281 //--------------------------------------- B1 B2
\r
3285 if(finish==width) iXA=0;
\r
3287 if(finish>4) {iXB=1;iXC=2;}
\r
3289 if(finish>3) {iXB=1;iXC=1;}
\r
3290 else {iXB=0;iXC=0;}
\r
3291 if(line==0) iYA=0;
\r
3293 if(height>4) {iYB=width;iYC=width2;}
\r
3295 if(height>3) {iYB=width;iYC=width;}
\r
3296 else {iYB=0;iYC=0;}
\r
3299 colorB0 = *(bP- iYA - iXA);
\r
3300 colorB1 = *(bP- iYA);
\r
3301 colorB2 = *(bP- iYA + iXB);
\r
3302 colorB3 = *(bP- iYA + iXC);
\r
3304 color4 = *(bP - iXA);
\r
3306 color6 = *(bP + iXB);
\r
3307 colorS2 = *(bP + iXC);
\r
3309 color1 = *(bP + iYB - iXA);
\r
3310 color2 = *(bP + iYB);
\r
3311 color3 = *(bP + iYB + iXB);
\r
3312 colorS1= *(bP + iYB + iXC);
\r
3314 colorA0 = *(bP + iYC - iXA);
\r
3315 colorA1 = *(bP + iYC);
\r
3316 colorA2 = *(bP + iYC + iXB);
\r
3317 colorA3 = *(bP + iYC + iXC);
\r
3319 //--------------------------------------
\r
3320 if (color2 == color6 && color5 != color3)
\r
3322 product2b = product1b = color2;
\r
3325 if (color5 == color3 && color2 != color6)
\r
3327 product2b = product1b = color5;
\r
3330 if (color5 == color3 && color2 == color6)
\r
3332 register int r = 0;
\r
3334 r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (color1&0x00ffffff), (colorA1&0x00ffffff));
\r
3335 r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (color4&0x00ffffff), (colorB1&0x00ffffff));
\r
3336 r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (colorA2&0x00ffffff), (colorS1&0x00ffffff));
\r
3337 r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (colorB2&0x00ffffff), (colorS2&0x00ffffff));
\r
3340 product2b = product1b = color6;
\r
3343 product2b = product1b = color5;
\r
3346 product2b = product1b = INTERPOLATE8(color5, color6);
\r
3351 if (color6 == color3 && color3 == colorA1 && color2 != colorA2 && color3 != colorA0)
\r
3352 product2b = Q_INTERPOLATE8 (color3, color3, color3, color2);
\r
3354 if (color5 == color2 && color2 == colorA2 && colorA1 != color3 && color2 != colorA3)
\r
3355 product2b = Q_INTERPOLATE8 (color2, color2, color2, color3);
\r
3357 product2b = INTERPOLATE8 (color2, color3);
\r
3359 if (color6 == color3 && color6 == colorB1 && color5 != colorB2 && color6 != colorB0)
\r
3360 product1b = Q_INTERPOLATE8 (color6, color6, color6, color5);
\r
3362 if (color5 == color2 && color5 == colorB2 && colorB1 != color6 && color5 != colorB3)
\r
3363 product1b = Q_INTERPOLATE8 (color6, color5, color5, color5);
\r
3365 product1b = INTERPOLATE8 (color5, color6);
\r
3368 if (color5 == color3 && color2 != color6 && color4 == color5 && color5 != colorA2)
\r
3369 product2a = INTERPOLATE8(color2, color5);
\r
3371 if (color5 == color1 && color6 == color5 && color4 != color2 && color5 != colorA0)
\r
3372 product2a = INTERPOLATE8(color2, color5);
\r
3374 product2a = color2;
\r
3376 if (color2 == color6 && color5 != color3 && color1 == color2 && color2 != colorB2)
\r
3377 product1a = INTERPOLATE8(color2, color5);
\r
3379 if (color4 == color2 && color3 == color2 && color1 != color5 && color2 != colorB0)
\r
3380 product1a = INTERPOLATE8(color2, color5);
\r
3382 product1a = color5;
\r
3385 *(dP+1)=product1b;
\r
3386 *(dP+(width2))=product2a;
\r
3387 *(dP+1+(width2))=product2b;
\r
3391 }//end of for ( finish= width etc..)
\r
3394 srcPtr += srcPitch;
\r
3395 }; //endof: for (; height; height--)
\r
3398 /////////////////////////////////////////////////////////////////////////////
\r
3400 #define colorMask4 0x0000EEE0
\r
3401 #define lowPixelMask4 0x00001110
\r
3402 #define qcolorMask4 0x0000CCC0
\r
3403 #define qlowpixelMask4 0x00003330
\r
3405 #define INTERPOLATE4(A, B) ((((A & colorMask4) >> 1) + ((B & colorMask4) >> 1) + (A & B & lowPixelMask4))|((((A&0x0000000F)==0x00000006)?0x00000006:(((B&0x0000000F)==0x00000006)?0x00000006:(((A&0x0000000F)==0x00000000)?0x00000000:(((B&0x0000000F)==0x00000000)?0x00000000:0x0000000F))))))
\r
3407 #define Q_INTERPOLATE4(A, B, C, D) ((((A & qcolorMask4) >> 2) + ((B & qcolorMask4) >> 2) + ((C & qcolorMask4) >> 2) + ((D & qcolorMask4) >> 2) + ((((A & qlowpixelMask4) + (B & qlowpixelMask4) + (C & qlowpixelMask4) + (D & qlowpixelMask4)) >> 2) & qlowpixelMask4))| ((((A&0x0000000F)==0x00000006)?0x00000006:(((B&0x0000000F)==0x00000006)?0x00000006:(((C&0x0000000F)==0x00000006)?0x00000006:(((D&0x0000000F)==0x00000006)?0x00000006:(((A&0x0000000F)==0x00000000)?0x00000000:(((B&0x0000000F)==0x00000000)?0x00000000:(((C&0x0000000F)==0x00000000)?0x00000000:(((D&0x0000000F)==0x00000000)?0x00000000:0x0000000F))))))))))
\r
3410 #define colorMask5 0x0000F7BC
\r
3411 #define lowPixelMask5 0x00000842
\r
3412 #define qcolorMask5 0x0000E738
\r
3413 #define qlowpixelMask5 0x000018C6
\r
3415 #define INTERPOLATE5(A, B) ((((A & colorMask5) >> 1) + ((B & colorMask5) >> 1) + (A & B & lowPixelMask5))|((((A&0x00000001)==0x00000000)?0x00000000:(((B&0x00000001)==0x00000000)?0x00000000:0x00000001))))
\r
3417 #define Q_INTERPOLATE5(A, B, C, D) ((((A & qcolorMask5) >> 2) + ((B & qcolorMask5) >> 2) + ((C & qcolorMask5) >> 2) + ((D & qcolorMask5) >> 2) + ((((A & qlowpixelMask5) + (B & qlowpixelMask5) + (C & qlowpixelMask5) + (D & qlowpixelMask5)) >> 2) & qlowpixelMask5))| ((((A&0x00000001)==0x00000000)?0x00000000:(((B&0x00000001)==0x00000000)?0x00000000:(((C&0x00000001)==0x00000000)?0x00000000:(((D&0x00000001)==0x00000000)?0x00000000:0x00000001))))))
\r
3418 /////////////////////////////////////////////////////////////////////////////
\r
3419 /////////////////////////////////////////////////////////////////////////////
\r
3420 /////////////////////////////////////////////////////////////////////////////
\r
3422 // ogl texture defines
\r
3424 /////////////////////////////////////////////////////////////////////////////
\r
3425 /////////////////////////////////////////////////////////////////////////////
\r
3426 /////////////////////////////////////////////////////////////////////////////
\r
3428 void DefineSubTextureSortHiRes(void)
\r
3434 glGenTextures(1, &gTexName); glError();
\r
3435 glBindTexture(GL_TEXTURE_2D, gTexName); glError();
\r
3437 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, iClampType); glError();
\r
3438 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, iClampType); glError();
\r
3442 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glError();
\r
3443 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glError();
\r
3447 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, iFilter); glError();
\r
3448 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, iFilter); glError();
\r
3450 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 512, 512, 0, GL_RGBA, GL_UNSIGNED_BYTE, texturebuffer); glError();
\r
3452 else glBindTexture(GL_TEXTURE_2D, gTexName); glError();
\r
3454 glTexSubImage2D(GL_TEXTURE_2D, 0, XTexS<<1, YTexS<<1,
\r
3455 DXTexS<<1, DYTexS<<1,
\r
3456 GL_RGBA, GL_UNSIGNED_BYTE, texturebuffer); glError();
\r
3457 //LOGE("DefineSubTextureSortHiRes x:%d y:%d",XTexS<<1,YTexS<<1);
\r
3460 /////////////////////////////////////////////////////////////////////////////
\r
3462 void DefineSubTextureSort(void)
\r
3467 glGenTextures(1, &gTexName); glError();
\r
3468 glBindTexture(GL_TEXTURE_2D, gTexName); glError();
\r
3470 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, iClampType); glError();
\r
3471 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, iClampType); glError();
\r
3475 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glError();
\r
3476 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glError();
\r
3480 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, iFilter); glError();
\r
3481 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, iFilter); glError();
\r
3483 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0,GL_RGBA, GL_UNSIGNED_BYTE, texturepart); glError();
\r
3485 else glBindTexture(GL_TEXTURE_2D, gTexName); glError();
\r
3487 glTexSubImage2D(GL_TEXTURE_2D, 0, XTexS, YTexS,
\r
3489 GL_RGBA, GL_UNSIGNED_BYTE, texturepart); glError();
\r
3490 //LOGE("DefineSubTextureSort x:%d y:%d w:%d h:%d",XTexS,YTexS,DXTexS,DYTexS);
\r
3493 /////////////////////////////////////////////////////////////////////////////
\r
3495 /////////////////////////////////////////////////////////////////////////////
\r
3496 /////////////////////////////////////////////////////////////////////////////
\r
3497 /////////////////////////////////////////////////////////////////////////////
\r
3499 // texture cache garbage collection
\r
3501 /////////////////////////////////////////////////////////////////////////////
\r
3502 /////////////////////////////////////////////////////////////////////////////
\r
3503 /////////////////////////////////////////////////////////////////////////////
\r
3505 void DoTexGarbageCollection(void)
\r
3507 static unsigned short LRUCleaned=0;
\r
3508 unsigned short iC,iC1,iC2;
\r
3509 int i,j,iMax;textureSubCacheEntryS * tsb;
\r
3511 iC=4;//=iSortTexCnt/2,
\r
3512 LRUCleaned+=iC; // we clean different textures each time
\r
3513 if((LRUCleaned+iC)>=iSortTexCnt) LRUCleaned=0; // wrap? wrap!
\r
3514 iC1=LRUCleaned; // range of textures to clean
\r
3515 iC2=LRUCleaned+iC;
\r
3517 for(iC=iC1;iC<iC2;iC++) // make some textures available
\r
3519 pxSsubtexLeft[iC]->l=0;
\r
3522 for(i=0;i<3;i++) // remove all references to that textures
\r
3523 for(j=0;j<MAXTPAGES;j++)
\r
3524 for(iC=0;iC<4;iC++) // loop all texture rect info areas
\r
3526 tsb=pscSubtexStore[i][j]+(iC*SOFFB);
\r
3532 if(tsb->cTexID>=iC1 && tsb->cTexID<iC2) // info uses the cleaned textures? remove info
\r
3538 usLRUTexPage=LRUCleaned;
\r
3541 /////////////////////////////////////////////////////////////////////////////
\r
3542 /////////////////////////////////////////////////////////////////////////////
\r
3543 /////////////////////////////////////////////////////////////////////////////
\r
3545 // search cache for existing (already used) parts
\r
3547 /////////////////////////////////////////////////////////////////////////////
\r
3548 /////////////////////////////////////////////////////////////////////////////
\r
3549 /////////////////////////////////////////////////////////////////////////////
\r
3551 unsigned char * CheckTextureInSubSCache(long TextureMode,unsigned long GivenClutId,unsigned short * pCache)
\r
3553 textureSubCacheEntryS * tsx, * tsb, *tsg;//, *tse=NULL;
\r
3554 int i,iMax;EXLong npos;
\r
3555 unsigned char cx,cy;
\r
3556 int iC,j,k;unsigned long rx,ry,mx,my;
\r
3557 EXLong * ul=0, * uls;
\r
3559 unsigned char cXAdj,cYAdj;
\r
3561 npos.l=*((unsigned long *)&gl_ux[4]);
\r
3563 //--------------------------------------------------------------//
\r
3564 // find matching texturepart first... speed up...
\r
3565 //--------------------------------------------------------------//
\r
3567 tsg=pscSubtexStore[TextureMode][GlobalTexturePage];
\r
3568 tsg+=((GivenClutId&CLUTCHK)>>CLUTSHIFT)*SOFFB;
\r
3577 if(GivenClutId==tsb->ClutID &&
\r
3578 (INCHECK(tsb->pos,npos)))
\r
3581 cx=tsb->pos.c[3]-tsb->posTX;
\r
3582 cy=tsb->pos.c[1]-tsb->posTY;
\r
3593 ubOpaqueDraw=tsb->Opaque;
\r
3594 *pCache=tsb->cTexID;
\r
3603 //----------------------------------------------------//
\r
3607 rx=(int)gl_ux[6]-(int)gl_ux[7];
\r
3608 ry=(int)gl_ux[4]-(int)gl_ux[5];
\r
3610 tsx=NULL;tsb=tsg+1;
\r
3611 for(i=0;i<iMax;i++,tsb++)
\r
3613 if(!tsb->ClutID) {tsx=tsb;break;}
\r
3619 if(iMax>=SOFFB-2)
\r
3621 if(iTexGarbageCollection) // gc mode?
\r
3625 dwTexPageComp|=(1<<GlobalTexturePage);
\r
3633 for(i=0;i<iMax;i++,tsb++) // 1. search other slots with same cluts, and unite the area
\r
3634 if(GivenClutId==tsb->ClutID)
\r
3636 if(!tsx) {tsx=tsb;rfree.l=npos.l;} //
\r
3637 else tsb->ClutID=0;
\r
3638 rfree.c[3]=min(rfree.c[3],tsb->pos.c[3]);
\r
3639 rfree.c[2]=max(rfree.c[2],tsb->pos.c[2]);
\r
3640 rfree.c[1]=min(rfree.c[1],tsb->pos.c[1]);
\r
3641 rfree.c[0]=max(rfree.c[0],tsb->pos.c[0]);
\r
3645 if(tsx) // 3. if one or more found, create a new rect with bigger size
\r
3647 *((unsigned long *)&gl_ux[4])=npos.l=rfree.l;
\r
3648 rx=(int)rfree.c[2]-(int)rfree.c[3];
\r
3649 ry=(int)rfree.c[0]-(int)rfree.c[1];
\r
3650 DoTexGarbageCollection();
\r
3662 //----------------------------------------------------//
\r
3663 // now get a free texture space
\r
3664 //----------------------------------------------------//
\r
3666 if(iTexGarbageCollection) usLRUTexPage=0;
\r
3670 rx+=3;if(rx>255) {cXAdj=0;rx=255;}
\r
3671 ry+=3;if(ry>255) {cYAdj=0;ry=255;}
\r
3675 for(k=0;k<iSortTexCnt;k++)
\r
3677 uls=pxSsubtexLeft[iC];
\r
3678 iMax=uls->l;ul=uls+1;
\r
3680 //--------------------------------------------------//
\r
3687 if(rx>252 && ry>252)
\r
3688 {uls->l=1;ul->l=0xffffffff;ul=0;goto ENDLOOP;}
\r
3712 //--------------------------------------------------//
\r
3713 for(i=0;i<iMax;i++,ul++)
\r
3715 if(ul->l!=0xffffffff &&
\r
3722 if(rx<mx && ry<my)
\r
3728 for(ul=uls+1,j=0;j<iMax;j++,ul++)
\r
3729 if(ul->l==0xffffffff) break;
\r
3733 if(j==iMax) uls->l=uls->l+1;
\r
3735 ul->c[3]=rfree.c[3];
\r
3736 ul->c[2]=rfree.c[2];
\r
3737 ul->c[1]=rfree.c[1]+ry;
\r
3738 ul->c[0]=rfree.c[0]-ry;
\r
3760 //--------------------------------------------------//
\r
3762 iC++; if(iC>=iSortTexCnt) iC=0;
\r
3765 //----------------------------------------------------//
\r
3766 // check, if free space got
\r
3767 //----------------------------------------------------//
\r
3772 //////////////////////////////////////////////////////
\r
3777 for(i=0;i<3;i++) // cleaning up
\r
3778 for(j=0;j<MAXTPAGES;j++)
\r
3780 tsb=pscSubtexStore[i][j];
\r
3781 (tsb+SOFFA)->pos.l=0;
\r
3782 (tsb+SOFFB)->pos.l=0;
\r
3783 (tsb+SOFFC)->pos.l=0;
\r
3784 (tsb+SOFFD)->pos.l=0;
\r
3786 for(i=0;i<iSortTexCnt;i++)
\r
3787 {ul=pxSsubtexLeft[i];ul->l=0;}
\r
3791 //////////////////////////////////////////////////////
\r
3793 uls=pxSsubtexLeft[usLRUTexPage];
\r
3794 uls->l=0;ul=uls+1;
\r
3797 if(rx>252 && ry>252)
\r
3798 {uls->l=1;ul->l=0xffffffff;}
\r
3819 tsg->pos.l=1;tsx=tsg+1;
\r
3822 rfree.c[3]+=cXAdj;
\r
3823 rfree.c[1]+=cYAdj;
\r
3825 tsx->cTexID =*pCache=iC;
\r
3827 tsx->ClutID = GivenClutId;
\r
3828 tsx->posTX = rfree.c[3];
\r
3829 tsx->posTY = rfree.c[1];
\r
3831 cx=gl_ux[7]-rfree.c[3];
\r
3832 cy=gl_ux[5]-rfree.c[1];
\r
3846 return &tsx->Opaque;
\r
3849 /////////////////////////////////////////////////////////////////////////////
\r
3850 /////////////////////////////////////////////////////////////////////////////
\r
3851 /////////////////////////////////////////////////////////////////////////////
\r
3853 // search cache for free place (on compress)
\r
3855 /////////////////////////////////////////////////////////////////////////////
\r
3856 /////////////////////////////////////////////////////////////////////////////
\r
3857 /////////////////////////////////////////////////////////////////////////////
\r
3859 BOOL GetCompressTexturePlace(textureSubCacheEntryS * tsx)
\r
3861 int i,j,k,iMax,iC;unsigned long rx,ry,mx,my;
\r
3862 EXLong * ul=0, * uls, rfree;
\r
3863 unsigned char cXAdj=1,cYAdj=1;
\r
3865 rx=(int)tsx->pos.c[2]-(int)tsx->pos.c[3];
\r
3866 ry=(int)tsx->pos.c[0]-(int)tsx->pos.c[1];
\r
3868 rx+=3;if(rx>255) {cXAdj=0;rx=255;}
\r
3869 ry+=3;if(ry>255) {cYAdj=0;ry=255;}
\r
3873 for(k=0;k<iSortTexCnt;k++)
\r
3875 uls=pxSsubtexLeft[iC];
\r
3876 iMax=uls->l;ul=uls+1;
\r
3878 //--------------------------------------------------//
\r
3885 if(rx>252 && ry>252)
\r
3886 {uls->l=1;ul->l=0xffffffff;ul=0;goto TENDLOOP;}
\r
3910 //--------------------------------------------------//
\r
3911 for(i=0;i<iMax;i++,ul++)
\r
3913 if(ul->l!=0xffffffff &&
\r
3921 if(rx<mx && ry<my)
\r
3927 for(ul=uls+1,j=0;j<iMax;j++,ul++)
\r
3928 if(ul->l==0xffffffff) break;
\r
3932 if(j==iMax) uls->l=uls->l+1;
\r
3934 ul->c[3]=rfree.c[3];
\r
3935 ul->c[2]=rfree.c[2];
\r
3936 ul->c[1]=rfree.c[1]+ry;
\r
3937 ul->c[0]=rfree.c[0]-ry;
\r
3959 //--------------------------------------------------//
\r
3961 iC++; if(iC>=iSortTexCnt) iC=0;
\r
3964 //----------------------------------------------------//
\r
3965 // check, if free space got
\r
3966 //----------------------------------------------------//
\r
3969 if(ul) return FALSE;
\r
3971 rfree.c[3]+=cXAdj;
\r
3972 rfree.c[1]+=cYAdj;
\r
3975 tsx->posTX = rfree.c[3];
\r
3976 tsx->posTY = rfree.c[1];
\r
3984 /////////////////////////////////////////////////////////////////////////////
\r
3985 /////////////////////////////////////////////////////////////////////////////
\r
3986 /////////////////////////////////////////////////////////////////////////////
\r
3988 // compress texture cache (to make place for new texture part, if needed)
\r
3990 /////////////////////////////////////////////////////////////////////////////
\r
3991 /////////////////////////////////////////////////////////////////////////////
\r
3992 /////////////////////////////////////////////////////////////////////////////
\r
3994 void CompressTextureSpace(void)
\r
3996 textureSubCacheEntryS * tsx, * tsg, * tsb;
\r
3997 int i,j,k,m,n,iMax;EXLong * ul, r,opos;
\r
3998 short sOldDST=DrawSemiTrans,cx,cy;
\r
3999 long lOGTP=GlobalTexturePage;
\r
4000 unsigned long l,row;
\r
4001 unsigned long * lSRCPtr;
\r
4003 opos.l=*((unsigned long *)&gl_ux[4]);
\r
4005 // 1. mark all textures as free
\r
4006 for(i=0;i<iSortTexCnt;i++)
\r
4007 {ul=pxSsubtexLeft[i];ul->l=0;}
\r
4013 for(k=0;k<MAXTPAGES;k++)
\r
4015 tsg=pscSubtexStore[j][k];
\r
4017 if((!(dwTexPageComp&(1<<k))))
\r
4019 (tsg+SOFFA)->pos.l=0;
\r
4020 (tsg+SOFFB)->pos.l=0;
\r
4021 (tsg+SOFFC)->pos.l=0;
\r
4022 (tsg+SOFFD)->pos.l=0;
\r
4026 for(m=0;m<4;m++,tsg+=SOFFB)
\r
4031 for(i=0;i<iMax;i++,tsx++)
\r
4036 for(n=i+1,tsb=tsx+1;n<iMax;n++,tsb++)
\r
4038 if(tsx->ClutID==tsb->ClutID)
\r
4040 r.c[3]=min(r.c[3],tsb->pos.c[3]);
\r
4041 r.c[2]=max(r.c[2],tsb->pos.c[2]);
\r
4042 r.c[1]=min(r.c[1],tsb->pos.c[1]);
\r
4043 r.c[0]=max(r.c[0],tsb->pos.c[0]);
\r
4048 // if(r.l!=tsx->pos.l)
\r
4050 cx=((tsx->ClutID << 4) & 0x3F0);
\r
4051 cy=((tsx->ClutID >> 6) & CLUTYMASK);
\r
4055 // palette check sum
\r
4056 l=0;lSRCPtr=(unsigned long *)(psxVuw+cx+(cy*1024));
\r
4057 if(j==1) for(row=1;row<129;row++) l+=((*lSRCPtr++)-1)*row;
\r
4058 else for(row=1;row<9;row++) l+=((*lSRCPtr++)-1)<<row;
\r
4059 l=((l+HIWORD(l))&0x3fffL)<<16;
\r
4060 if(l!=(tsx->ClutID&(0x00003fff<<16)))
\r
4062 tsx->ClutID=0;continue;
\r
4067 if(!GetCompressTexturePlace(tsx)) // no place?
\r
4069 for(i=0;i<3;i++) // -> clean up everything
\r
4070 for(j=0;j<MAXTPAGES;j++)
\r
4072 tsb=pscSubtexStore[i][j];
\r
4073 (tsb+SOFFA)->pos.l=0;
\r
4074 (tsb+SOFFB)->pos.l=0;
\r
4075 (tsb+SOFFC)->pos.l=0;
\r
4076 (tsb+SOFFD)->pos.l=0;
\r
4078 for(i=0;i<iSortTexCnt;i++)
\r
4079 {ul=pxSsubtexLeft[i];ul->l=0;}
\r
4081 DrawSemiTrans=sOldDST;
\r
4082 GlobalTexturePage=lOGTP;
\r
4083 *((unsigned long *)&gl_ux[4])=opos.l;
\r
4089 if(tsx->ClutID&(1<<30)) DrawSemiTrans=1;
\r
4090 else DrawSemiTrans=0;
\r
4091 *((unsigned long *)&gl_ux[4])=r.l;
\r
4093 gTexName=uiStexturePage[tsx->cTexID];
\r
4094 LoadSubTexFn(k,j,cx,cy);
\r
4095 uiStexturePage[tsx->cTexID]=gTexName;
\r
4096 tsx->Opaque=ubOpaqueDraw;
\r
4104 while(!tsx->ClutID && iMax) {tsx--;iMax--;}
\r
4112 if(dwTexPageComp==0xffffffff) dwTexPageComp=0;
\r
4114 *((unsigned long *)&gl_ux[4])=opos.l;
\r
4115 GlobalTexturePage=lOGTP;
\r
4116 DrawSemiTrans=sOldDST;
\r
4119 /////////////////////////////////////////////////////////////////////////////
\r
4120 /////////////////////////////////////////////////////////////////////////////
\r
4121 /////////////////////////////////////////////////////////////////////////////
\r
4123 // main entry for searching/creating textures, called from prim.c
\r
4125 /////////////////////////////////////////////////////////////////////////////
\r
4126 /////////////////////////////////////////////////////////////////////////////
\r
4127 /////////////////////////////////////////////////////////////////////////////
\r
4129 GLuint SelectSubTextureS(long TextureMode, unsigned long GivenClutId)
\r
4131 unsigned char * OPtr;unsigned short iCache;short cx,cy;
\r
4133 // sort sow/tow infos for fast access
\r
4135 unsigned char ma1,ma2,mi1,mi2;
\r
4136 if(gl_ux[0]>gl_ux[1]) {mi1=gl_ux[1];ma1=gl_ux[0];}
\r
4137 else {mi1=gl_ux[0];ma1=gl_ux[1];}
\r
4138 if(gl_ux[2]>gl_ux[3]) {mi2=gl_ux[3];ma2=gl_ux[2];}
\r
4139 else {mi2=gl_ux[2];ma2=gl_ux[3];}
\r
4140 if(mi1>mi2) gl_ux[7]=mi2;
\r
4141 else gl_ux[7]=mi1;
\r
4142 if(ma1>ma2) gl_ux[6]=ma1;
\r
4143 else gl_ux[6]=ma2;
\r
4145 if(gl_vy[0]>gl_vy[1]) {mi1=gl_vy[1];ma1=gl_vy[0];}
\r
4146 else {mi1=gl_vy[0];ma1=gl_vy[1];}
\r
4147 if(gl_vy[2]>gl_vy[3]) {mi2=gl_vy[3];ma2=gl_vy[2];}
\r
4148 else {mi2=gl_vy[2];ma2=gl_vy[3];}
\r
4149 if(mi1>mi2) gl_ux[5]=mi2;
\r
4150 else gl_ux[5]=mi1;
\r
4151 if(ma1>ma2) gl_ux[4]=ma1;
\r
4152 else gl_ux[4]=ma2;
\r
4154 // get clut infos in one 32 bit val
\r
4156 if(TextureMode==2) // no clut here
\r
4158 GivenClutId=CLUTUSED|(DrawSemiTrans<<30);cx=cy=0;
\r
4160 if(iFrameTexType && Fake15BitTexture())
\r
4161 return (GLuint)gTexName;
\r
4165 cx=((GivenClutId << 4) & 0x3F0); // but here
\r
4166 cy=((GivenClutId >> 6) & CLUTYMASK);
\r
4167 GivenClutId=(GivenClutId&CLUTMASK)|(DrawSemiTrans<<30)|CLUTUSED;
\r
4169 // palette check sum.. removed MMX asm, this easy func works as well
\r
4171 unsigned long l=0,row;
\r
4173 unsigned long * lSRCPtr=(unsigned long *)(psxVuw+cx+(cy*1024));
\r
4174 if(TextureMode==1) for(row=1;row<129;row++) l+=((*lSRCPtr++)-1)*row;
\r
4175 else for(row=1;row<9;row++) l+=((*lSRCPtr++)-1)<<row;
\r
4176 l=(l+HIWORD(l))&0x3fffL;
\r
4177 GivenClutId|=(l<<16);
\r
4184 OPtr=CheckTextureInSubSCache(TextureMode,GivenClutId,&iCache);
\r
4186 // cache full? compress and try again
\r
4187 if(iCache==0xffff)
\r
4189 CompressTextureSpace();
\r
4190 OPtr=CheckTextureInSubSCache(TextureMode,GivenClutId,&iCache);
\r
4194 usLRUTexPage=iCache;
\r
4195 if(!OPtr) return uiStexturePage[iCache];
\r
4197 // not found? upload texture and store infos in cache
\r
4198 gTexName=uiStexturePage[iCache];
\r
4199 LoadSubTexFn(GlobalTexturePage,TextureMode,cx,cy);
\r
4200 uiStexturePage[iCache]=gTexName;
\r
4201 *OPtr=ubOpaqueDraw;
\r
4202 return (GLuint) gTexName;
\r
4205 /////////////////////////////////////////////////////////////////////////////
\r
4206 /////////////////////////////////////////////////////////////////////////////
\r
4207 /////////////////////////////////////////////////////////////////////////////
\r