plugins/gpu-gles/gpuTexture.c

   1 /***************************************************************************\r
   2                           texture.c  -  description\r
   3                              -------------------\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
   8 \r
   9 /***************************************************************************\r
  10  *                                                                         *\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
  16  *                                                                         *\r
  17  ***************************************************************************/\r
  18 \r
  19 //*************************************************************************// \r
  20 // History of changes:\r
  21 //\r
  22 // 2009/03/08 - Pete  \r
  23 // - generic cleanup for the Peops release\r
  24 //\r
  25 //*************************************************************************// \r
  26 \r
  27 \r
  28 ////////////////////////////////////////////////////////////////////////////////////\r
  29 // Texture related functions are here !\r
  30 //\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
  41 //\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
  49 //\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
  60 //\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
  65 //\r
  66 ////////////////////////////////////////////////////////////////////////////////////\r
  67  \r
  68 #define _IN_TEXTURE\r
  69 \r
  70 #include "gpuStdafx.h"\r
  71 \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
  78 \r
  79 #define CLUTCHK   0x00060000\r
  80 #define CLUTSHIFT 17\r
  81 \r
  82 ////////////////////////////////////////////////////////////////////////\r
  83 // texture conversion buffer .. \r
  84 ////////////////////////////////////////////////////////////////////////\r
  85 \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
  92 int           iVRamSize=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
  97 \r
  98 ////////////////////////////////////////////////////////////////////////\r
  99 // defines\r
 100 ////////////////////////////////////////////////////////////////////////\r
 101 \r
 102 #define PALCOL(x) PalTexturedColourFn (x)\r
 103 \r
 104 #define CSUBSIZE  2048\r
 105 #define CSUBSIZEA 8192\r
 106 #define CSUBSIZES 4096\r
 107 \r
 108 #define OFFA 0\r
 109 #define OFFB 2048\r
 110 #define OFFC 4096\r
 111 #define OFFD 6144\r
 112 \r
 113 #define XOFFA 0\r
 114 #define XOFFB 512\r
 115 #define XOFFC 1024\r
 116 #define XOFFD 1536\r
 117 \r
 118 #define SOFFA 0\r
 119 #define SOFFB 1024\r
 120 #define SOFFC 2048\r
 121 #define SOFFD 3072\r
 122 \r
 123 #define MAXWNDTEXCACHE 128\r
 124 \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
 127 \r
 128 ////////////////////////////////////////////////////////////////////////\r
 129 \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
 134 \r
 135 ////////////////////////////////////////////////////////////////////////\r
 136 // some globals\r
 137 ////////////////////////////////////////////////////////////////////////\r
 138 \r
 139 long  GlobalTexturePage;\r
 140 GLint XTexS;\r
 141 GLint YTexS;\r
 142 GLint DXTexS;\r
 143 GLint DYTexS;\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
 149 \r
 150 unsigned long  (*TCF[2]) (unsigned long);\r
 151 unsigned short (*PTCF[2]) (unsigned short);\r
 152 \r
 153 ////////////////////////////////////////////////////////////////////////\r
 154 // texture cache implementation\r
 155 ////////////////////////////////////////////////////////////////////////\r
 156 \r
 157 // "texture window" cache entry\r
 158 \r
 159 typedef struct textureWndCacheEntryTag\r
 160 {\r
 161  unsigned long  ClutID;\r
 162  short          pageid;\r
 163  short          textureMode;\r
 164  short          Opaque;\r
 165  short          used;\r
 166  EXLong         pos;\r
 167  GLuint         texname;\r
 168 } textureWndCacheEntry;\r
 169 \r
 170 // "standard texture" cache entry (12 byte per entry, as small as possible... we need lots of them)\r
 171 \r
 172 typedef struct textureSubCacheEntryTagS \r
 173 {\r
 174  unsigned long   ClutID;\r
 175  EXLong          pos;\r
 176  unsigned char   posTX;\r
 177  unsigned char   posTY;\r
 178  unsigned char   cTexID;\r
 179  unsigned char   Opaque;\r
 180 } textureSubCacheEntryS;\r
 181 \r
 182 \r
 183 //---------------------------------------------\r
 184 \r
 185 #define MAXTPAGES_MAX  64\r
 186 #define MAXSORTTEX_MAX 196\r
 187 \r
 188 //---------------------------------------------\r
 189 \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
 194 \r
 195 unsigned short           usLRUTexPage=0;\r
 196 \r
 197 int                      iMaxTexWnds=0;\r
 198 int                      iTexWndTurn=0;\r
 199 int                      iTexWndLimit=MAXWNDTEXCACHE/2;\r
 200 \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
 205 \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
 210 \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
 215 \r
 216 unsigned long XP8RGBA(unsigned long BGR)\r
 217 {\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
 222 }\r
 223 \r
 224 unsigned long XP8RGBAEx(unsigned long BGR)\r
 225 {\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
 230 }\r
 231 \r
 232 unsigned long CP8RGBA(unsigned long BGR)\r
 233 {\r
 234  unsigned long l;\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
 240  return l;\r
 241 }\r
 242 \r
 243 unsigned long CP8RGBAEx(unsigned long BGR)\r
 244 {\r
 245  unsigned long l;\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
 251  return l;\r
 252 }\r
 253 \r
 254 unsigned long XP8RGBA_0(unsigned long BGR)\r
 255 {\r
 256  if(!(BGR&0xffff)) return 0x50000000;\r
 257  return ((((BGR<<3)&0xf8)|((BGR<<6)&0xf800)|((BGR<<9)&0xf80000))&0xffffff)|0xff000000;\r
 258 }\r
 259 \r
 260 unsigned long XP8RGBAEx_0(unsigned long BGR)\r
 261 {\r
 262  if(!(BGR&0xffff)) return 0x03000000;\r
 263  return ((((BGR<<3)&0xf8)|((BGR<<6)&0xf800)|((BGR<<9)&0xf80000))&0xffffff)|0xff000000;\r
 264 }\r
 265 \r
 266 unsigned long XP8BGRA_0(unsigned long BGR)\r
 267 {\r
 268  if(!(BGR&0xffff)) return 0x50000000;\r
 269  return ((((BGR>>7)&0xf8)|((BGR<<6)&0xf800)|((BGR<<19)&0xf80000))&0xffffff)|0xff000000;\r
 270 }\r
 271 \r
 272 unsigned long XP8BGRAEx_0(unsigned long BGR)\r
 273 {\r
 274  if(!(BGR&0xffff)) return 0x03000000;\r
 275  return ((((BGR>>7)&0xf8)|((BGR<<6)&0xf800)|((BGR<<19)&0xf80000))&0xffffff)|0xff000000;\r
 276 }\r
 277 \r
 278 unsigned long CP8RGBA_0(unsigned long BGR)\r
 279 {\r
 280  unsigned long l;\r
 281 \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
 285  return l;\r
 286 }\r
 287 \r
 288 unsigned long CP8RGBAEx_0(unsigned long BGR)\r
 289 {\r
 290  unsigned long l;\r
 291 \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
 295  return l;\r
 296 }\r
 297 \r
 298 unsigned long CP8BGRA_0(unsigned long BGR)\r
 299 {\r
 300  unsigned long l;\r
 301 \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
 305  return l;\r
 306 }\r
 307 \r
 308 unsigned long CP8BGRAEx_0(unsigned long BGR)\r
 309 {\r
 310  unsigned long l;\r
 311 \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
 315  return l;\r
 316 }\r
 317 \r
 318 unsigned long XP8RGBA_1(unsigned long BGR)\r
 319 {\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
 323 }\r
 324 \r
 325 unsigned long XP8RGBAEx_1(unsigned long BGR)\r
 326 {\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
 330 }\r
 331 \r
 332 unsigned long XP8BGRA_1(unsigned long BGR)\r
 333 {\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
 337 }\r
 338 \r
 339 unsigned long XP8BGRAEx_1(unsigned long BGR)\r
 340 {\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
 344 }\r
 345 \r
 346 unsigned long P8RGBA(unsigned long BGR)\r
 347 {\r
 348  if(!(BGR&0xffff)) return 0;\r
 349  return ((((BGR<<3)&0xf8)|((BGR<<6)&0xf800)|((BGR<<9)&0xf80000))&0xffffff)|0xff000000;\r
 350 }\r
 351 \r
 352 unsigned long P8BGRA(unsigned long BGR)\r
 353 {\r
 354  if(!(BGR&0xffff)) return 0;\r
 355  return ((((BGR>>7)&0xf8)|((BGR<<6)&0xf800)|((BGR<<19)&0xf80000))&0xffffff)|0xff000000;\r
 356 }\r
 357 \r
 358 unsigned short XP5RGBA(unsigned short BGR)\r
 359 {\r
 360  if(!BGR) return 0;\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
 364 }\r
 365 \r
 366 unsigned short XP5RGBA_0 (unsigned short BGR)\r
 367 {\r
 368  if(!BGR) return 0;\r
 369 \r
 370  return ((((BGR<<11))|((BGR>>9)&0x3e)|((BGR<<1)&0x7c0)))|1;\r
 371 }\r
 372 \r
 373 unsigned short CP5RGBA_0 (unsigned short BGR)\r
 374 {\r
 375  unsigned short s;\r
 376 \r
 377  if(!BGR) return 0;\r
 378 \r
 379  s=((((BGR<<11))|((BGR>>9)&0x3e)|((BGR<<1)&0x7c0)))|1;\r
 380  if(s==0x07ff) s=1;\r
 381  return s;\r
 382 }\r
 383 \r
 384 unsigned short XP5RGBA_1(unsigned short BGR)\r
 385 {\r
 386  if(!BGR) return 0;\r
 387  if(!(BGR&0x8000)) \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
 390 }\r
 391 \r
 392 unsigned short P5RGBA(unsigned short BGR)\r
 393 {\r
 394  if(!BGR) return 0;\r
 395  return ((((BGR<<11))|((BGR>>9)&0x3e)|((BGR<<1)&0x7c0)))|1;\r
 396 }\r
 397 \r
 398 unsigned short XP4RGBA(unsigned short BGR)\r
 399 {\r
 400  if(!BGR) return 6;\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
 404 }\r
 405 \r
 406 unsigned short XP4RGBA_0 (unsigned short BGR)\r
 407 {\r
 408  if(!BGR) return 6;\r
 409  return (((((BGR&0x1e)<<11))|((BGR&0x7800)>>7)|((BGR&0x3c0)<<2)))|0xf;\r
 410 }\r
 411 \r
 412 unsigned short CP4RGBA_0 (unsigned short BGR)\r
 413 {\r
 414  unsigned short s;\r
 415  if(!BGR) return 6;\r
 416  s=(((((BGR&0x1e)<<11))|((BGR&0x7800)>>7)|((BGR&0x3c0)<<2)))|0xf;\r
 417  if(s==0x0fff) s=0x000f;\r
 418  return s;\r
 419 }\r
 420 \r
 421 unsigned short XP4RGBA_1(unsigned short BGR)\r
 422 {\r
 423  if(!BGR) return 6;\r
 424  if(!(BGR&0x8000)) \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
 427 }\r
 428 \r
 429 unsigned short P4RGBA(unsigned short BGR)\r
 430 {\r
 431  if(!BGR) return 0;\r
 432  return (((((BGR&0x1e)<<11))|((BGR&0x7800)>>7)|((BGR&0x3c0)<<2)))|0xf;\r
 433 }\r
 434 \r
 435 ////////////////////////////////////////////////////////////////////////\r
 436 // CHECK TEXTURE MEM (on plugin startup)\r
 437 ////////////////////////////////////////////////////////////////////////\r
 438 \r
 439 int iFTexA=512;\r
 440 int iFTexB=512;\r
 441 \r
 442 void CheckTextureMemory(void)\r
 443 {\r
 444  GLboolean b;GLboolean * bDetail;\r
 445  int i,iCnt,iRam=iVRamSize*1024*1024;\r
 446  int iTSize;char * p;\r
 447 \r
 448 \r
 449  if(iVRamSize)\r
 450   {\r
 451    int ts;\r
 452 \r
 453    iRam-=(iResX*iResY*8);\r
 454    iRam-=(iResX*iResY*(iZBufferDepth/8));\r
 455 \r
 456            ts=4;\r
 457            iSortTexCnt=iRam/(256*256*ts);\r
 458 \r
 459    if(iSortTexCnt>MAXSORTTEX) \r
 460     {\r
 461      iSortTexCnt=MAXSORTTEX-min(1,0);\r
 462     }\r
 463    else\r
 464     {\r
 465      iSortTexCnt-=3+min(1,0);\r
 466      if(iSortTexCnt<8) iSortTexCnt=8;\r
 467     }\r
 468 \r
 469    for(i=0;i<MAXSORTTEX;i++)\r
 470     uiStexturePage[i]=0;\r
 471  \r
 472    return;\r
 473   }\r
 474 \r
 475 #if 1\r
 476  iSortTexCnt=MAXSORTTEX;\r
 477 #else // below vram detector supposedly crashes some drivers\r
 478 \r
 479          iTSize=256;\r
 480  p=(char *)malloc(iTSize*iTSize*4);\r
 481 \r
 482  iCnt=0;\r
 483  glGenTextures(MAXSORTTEX,uiStexturePage);\r
 484  for(i=0;i<MAXSORTTEX;i++)\r
 485   {\r
 486    glBindTexture(GL_TEXTURE_2D,uiStexturePage[i]);\r
 487    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, iClampType);\r
 488    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, iClampType);\r
 489    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, iFilter);\r
 490    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, iFilter);\r
 491    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, iTSize, iTSize, 0,GL_RGBA, GL_UNSIGNED_BYTE, p);\r
 492   }\r
 493  glBindTexture(GL_TEXTURE_2D,0);\r
 494 \r
 495  free(p);\r
 496 \r
 497  bDetail=(GLboolean*)malloc(MAXSORTTEX*sizeof(GLboolean));\r
 498  memset(bDetail,0,MAXSORTTEX*sizeof(GLboolean));\r
 499 \r
 500  glDeleteTextures(MAXSORTTEX,uiStexturePage);\r
 501 \r
 502  for(i=0;i<MAXSORTTEX;i++)\r
 503   {\r
 504    if(bDetail[i]) iCnt++;\r
 505    uiStexturePage[i]=0;\r
 506   }\r
 507 \r
 508  free(bDetail);\r
 509 \r
 510  if(b) iSortTexCnt=MAXSORTTEX-min(1,0);\r
 511  else  iSortTexCnt=iCnt-3+min(1,0);       // place for menu&texwnd\r
 512 \r
 513  if(iSortTexCnt<8) iSortTexCnt=8;\r
 514 #endif\r
 515 } \r
 516 \r
 517 ////////////////////////////////////////////////////////////////////////\r
 518 // Main init of textures\r
 519 ////////////////////////////////////////////////////////////////////////\r
 520 \r
 521 void InitializeTextureStore() \r
 522 {\r
 523  int i,j;\r
 524 \r
 525  if(iGPUHeight==1024)\r
 526   {\r
 527    MAXTPAGES     = 64;\r
 528    CLUTMASK      = 0xffff;\r
 529    CLUTYMASK     = 0x3ff;\r
 530    MAXSORTTEX    = 128;\r
 531    iTexGarbageCollection=0;\r
 532   }\r
 533  else\r
 534   {\r
 535    MAXTPAGES     = 32;\r
 536    CLUTMASK      = 0x7fff;\r
 537    CLUTYMASK     = 0x1ff;\r
 538    MAXSORTTEX    = 196;\r
 539   }\r
 540 \r
 541  memset(vertex,0,4*sizeof(OGLVertex));                 // init vertices\r
 542 \r
 543  gTexName=0;                                           // init main tex name\r
 544 \r
 545  iTexWndLimit=MAXWNDTEXCACHE;\r
 546 /* if(!iUsePalTextures) */iTexWndLimit/=2;\r
 547 \r
 548  memset(wcWndtexStore,0,sizeof(textureWndCacheEntry)*\r
 549                         MAXWNDTEXCACHE);\r
 550  texturepart=(GLubyte *)malloc(256*256*4);\r
 551  memset(texturepart,0,256*256*4);\r
 552          texturebuffer=NULL;\r
 553 \r
 554  for(i=0;i<3;i++)                                    // -> info for 32*3\r
 555   for(j=0;j<MAXTPAGES;j++)\r
 556    {                                               \r
 557     pscSubtexStore[i][j]=(textureSubCacheEntryS *)malloc(CSUBSIZES*sizeof(textureSubCacheEntryS));\r
 558     memset(pscSubtexStore[i][j],0,CSUBSIZES*sizeof(textureSubCacheEntryS));\r
 559    }\r
 560  for(i=0;i<MAXSORTTEX;i++)                           // -> info 0..511\r
 561   {\r
 562    pxSsubtexLeft[i]=(EXLong *)malloc(CSUBSIZE*sizeof(EXLong));\r
 563    memset(pxSsubtexLeft[i],0,CSUBSIZE*sizeof(EXLong));\r
 564    uiStexturePage[i]=0;\r
 565   }\r
 566 }\r
 567 \r
 568 ////////////////////////////////////////////////////////////////////////\r
 569 // Clean up on exit\r
 570 ////////////////////////////////////////////////////////////////////////\r
 571 \r
 572 void CleanupTextureStore() \r
 573 {\r
 574  int i,j;textureWndCacheEntry * tsx;\r
 575  //----------------------------------------------------//\r
 576  glBindTexture(GL_TEXTURE_2D,0);\r
 577  glError();\r
 578  //----------------------------------------------------//\r
 579  free(texturepart);                                    // free tex part\r
 580  texturepart=0;\r
 581  if(texturebuffer)\r
 582   {\r
 583    free(texturebuffer);\r
 584    texturebuffer=0;\r
 585   }\r
 586  //----------------------------------------------------//\r
 587  tsx=wcWndtexStore;                                    // loop tex window cache\r
 588  for(i=0;i<MAXWNDTEXCACHE;i++,tsx++)\r
 589   {\r
 590    if(tsx->texname)                                    // -> some tex?\r
 591     glDeleteTextures(1,&tsx->texname);                 // --> delete it\r
 592     glError();\r
 593   }\r
 594  iMaxTexWnds=0;                                        // no more tex wnds\r
 595  //----------------------------------------------------//\r
 596  if(gTexMovieName!=0)                                  // some movie tex?\r
 597   glDeleteTextures(1, &gTexMovieName);                 // -> delete it\r
 598   glError();\r
 599  gTexMovieName=0;                                      // no more movie tex\r
 600  //----------------------------------------------------//\r
 601  if(gTexFrameName!=0)                                  // some 15bit framebuffer tex?\r
 602   glDeleteTextures(1, &gTexFrameName);                 // -> delete it\r
 603   glError();\r
 604  gTexFrameName=0;                                      // no more movie tex\r
 605  //----------------------------------------------------//\r
 606  if(gTexBlurName!=0)                                   // some 15bit framebuffer tex?\r
 607   glDeleteTextures(1, &gTexBlurName);                  // -> delete it\r
 608   glError();\r
 609  gTexBlurName=0;                                       // no more movie tex\r
 610  //----------------------------------------------------//\r
 611  for(i=0;i<3;i++)                                    // -> loop\r
 612   for(j=0;j<MAXTPAGES;j++)                           // loop tex pages\r
 613    {\r
 614     free(pscSubtexStore[i][j]);                      // -> clean mem\r
 615    }\r
 616  for(i=0;i<MAXSORTTEX;i++)\r
 617   {\r
 618    if(uiStexturePage[i])                             // --> tex used ?\r
 619     {\r
 620      glDeleteTextures(1,&uiStexturePage[i]);\r
 621      glError();\r
 622      uiStexturePage[i]=0;                            // --> delete it\r
 623     }\r
 624    free(pxSsubtexLeft[i]);                           // -> clean mem\r
 625   }\r
 626  //----------------------------------------------------//\r
 627 }\r
 628 \r
 629 ////////////////////////////////////////////////////////////////////////\r
 630 // Reset textures in game...\r
 631 ////////////////////////////////////////////////////////////////////////\r
 632 \r
 633 void ResetTextureArea(BOOL bDelTex)\r
 634 {\r
 635  int i,j;textureSubCacheEntryS * tss;EXLong * lu;\r
 636  textureWndCacheEntry * tsx;\r
 637  //----------------------------------------------------//\r
 638 \r
 639  dwTexPageComp=0;\r
 640 \r
 641  //----------------------------------------------------//\r
 642  if(bDelTex) {glBindTexture(GL_TEXTURE_2D,0); glError();gTexName=0;}\r
 643  //----------------------------------------------------//\r
 644  tsx=wcWndtexStore;\r
 645  for(i=0;i<MAXWNDTEXCACHE;i++,tsx++)\r
 646   {\r
 647    tsx->used=0;\r
 648    if(bDelTex && tsx->texname)\r
 649     {\r
 650      glDeleteTextures(1,&tsx->texname); glError();\r
 651      tsx->texname=0;\r
 652     }\r
 653   }\r
 654  iMaxTexWnds=0;\r
 655  //----------------------------------------------------//\r
 656 \r
 657  for(i=0;i<3;i++)\r
 658   for(j=0;j<MAXTPAGES;j++)\r
 659    {\r
 660     tss=pscSubtexStore[i][j];\r
 661     (tss+SOFFA)->pos.l=0;\r
 662     (tss+SOFFB)->pos.l=0;\r
 663     (tss+SOFFC)->pos.l=0;\r
 664     (tss+SOFFD)->pos.l=0;\r
 665    }\r
 666 \r
 667  for(i=0;i<iSortTexCnt;i++)\r
 668   {\r
 669    lu=pxSsubtexLeft[i];\r
 670    lu->l=0;\r
 671    if(bDelTex && uiStexturePage[i])\r
 672     {glDeleteTextures(1,&uiStexturePage[i]); glError();uiStexturePage[i]=0;}\r
 673   }\r
 674 }\r
 675 \r
 676 \r
 677 ////////////////////////////////////////////////////////////////////////\r
 678 // Invalidate tex windows\r
 679 ////////////////////////////////////////////////////////////////////////\r
 680 \r
 681 void InvalidateWndTextureArea(long X,long Y,long W, long H)\r
 682 {\r
 683  int i,px1,px2,py1,py2,iYM=1;\r
 684  textureWndCacheEntry * tsw=wcWndtexStore;\r
 685 \r
 686  W+=X-1;      \r
 687  H+=Y-1;\r
 688  if(X<0) X=0;if(X>1023) X=1023;\r
 689  if(W<0) W=0;if(W>1023) W=1023;\r
 690  if(Y<0) Y=0;if(Y>iGPUHeightMask)  Y=iGPUHeightMask;\r
 691  if(H<0) H=0;if(H>iGPUHeightMask)  H=iGPUHeightMask;\r
 692  W++;H++;\r
 693 \r
 694  if(iGPUHeight==1024) iYM=3;\r
 695 \r
 696  py1=min(iYM,Y>>8);\r
 697  py2=min(iYM,H>>8);                                    // y: 0 or 1\r
 698 \r
 699  px1=max(0,(X>>6));\r
 700  px2=min(15,(W>>6));\r
 701 \r
 702  if(py1==py2)\r
 703   {\r
 704    py1=py1<<4;px1+=py1;px2+=py1;                       // change to 0-31\r
 705    for(i=0;i<iMaxTexWnds;i++,tsw++)\r
 706     {\r
 707      if(tsw->used)\r
 708       {\r
 709        if(tsw->pageid>=px1 && tsw->pageid<=px2)\r
 710         {\r
 711          tsw->used=0;\r
 712         }\r
 713       }\r
 714     }\r
 715   }\r
 716  else\r
 717   {\r
 718    py1=px1+16;py2=px2+16;\r
 719    for(i=0;i<iMaxTexWnds;i++,tsw++)\r
 720     {\r
 721      if(tsw->used)\r
 722       {\r
 723        if((tsw->pageid>=px1 && tsw->pageid<=px2) ||\r
 724           (tsw->pageid>=py1 && tsw->pageid<=py2))\r
 725         {\r
 726          tsw->used=0;\r
 727         }\r
 728       }\r
 729     }\r
 730   }\r
 731 \r
 732  // adjust tex window count\r
 733  tsw=wcWndtexStore+iMaxTexWnds-1;\r
 734  while(iMaxTexWnds && !tsw->used) {iMaxTexWnds--;tsw--;}\r
 735 }\r
 736 \r
 737 \r
 738 \r
 739 ////////////////////////////////////////////////////////////////////////\r
 740 // same for sort textures\r
 741 ////////////////////////////////////////////////////////////////////////\r
 742 \r
 743 void MarkFree(textureSubCacheEntryS * tsx)\r
 744 {\r
 745  EXLong * ul, * uls;\r
 746  int j,iMax;unsigned char x1,y1,dx,dy;\r
 747 \r
 748  uls=pxSsubtexLeft[tsx->cTexID];\r
 749  iMax=uls->l;ul=uls+1;\r
 750 \r
 751  if(!iMax) return;\r
 752 \r
 753  for(j=0;j<iMax;j++,ul++)\r
 754   if(ul->l==0xffffffff) break;\r
 755 \r
 756  if(j<CSUBSIZE-2)\r
 757   {\r
 758    if(j==iMax) uls->l=uls->l+1;\r
 759 \r
 760    x1=tsx->posTX;dx=tsx->pos.c[2]-tsx->pos.c[3];\r
 761    if(tsx->posTX) {x1--;dx+=3;}\r
 762    y1=tsx->posTY;dy=tsx->pos.c[0]-tsx->pos.c[1];\r
 763    if(tsx->posTY) {y1--;dy+=3;}\r
 764 \r
 765    ul->c[3]=x1;\r
 766    ul->c[2]=dx;\r
 767    ul->c[1]=y1;\r
 768    ul->c[0]=dy;\r
 769   }\r
 770 }\r
 771 \r
 772 void InvalidateSubSTextureArea(long X,long Y,long W, long H)\r
 773 {\r
 774  int i,j,k,iMax,px,py,px1,px2,py1,py2,iYM=1;\r
 775  EXLong npos;textureSubCacheEntryS * tsb;\r
 776  long x1,x2,y1,y2,xa,sw;\r
 777 \r
 778  W+=X-1;      \r
 779  H+=Y-1;\r
 780  if(X<0) X=0;if(X>1023) X=1023;\r
 781  if(W<0) W=0;if(W>1023) W=1023;\r
 782  if(Y<0) Y=0;if(Y>iGPUHeightMask)  Y=iGPUHeightMask;\r
 783  if(H<0) H=0;if(H>iGPUHeightMask)  H=iGPUHeightMask;\r
 784  W++;H++;\r
 785 \r
 786  if(iGPUHeight==1024) iYM=3;\r
 787 \r
 788  py1=min(iYM,Y>>8);\r
 789  py2=min(iYM,H>>8);                                    // y: 0 or 1\r
 790  px1=max(0,(X>>6)-3);                                   \r
 791  px2=min(15,(W>>6)+3);                                 // x: 0-15\r
 792 \r
 793  for(py=py1;py<=py2;py++)\r
 794   {\r
 795    j=(py<<4)+px1;                                      // get page\r
 796 \r
 797    y1=py*256;y2=y1+255;\r
 798 \r
 799    if(H<y1)  continue;\r
 800    if(Y>y2)  continue;\r
 801 \r
 802    if(Y>y1)  y1=Y;\r
 803    if(H<y2)  y2=H;\r
 804    if(y2<y1) {sw=y1;y1=y2;y2=sw;}\r
 805    y1=((y1%256)<<8);\r
 806    y2=(y2%256);\r
 807 \r
 808    for(px=px1;px<=px2;px++,j++)\r
 809     {\r
 810      for(k=0;k<3;k++)\r
 811       {\r
 812        xa=x1=px<<6;\r
 813        if(W<x1) continue;\r
 814        x2=x1+(64<<k)-1;\r
 815        if(X>x2) continue;\r
 816 \r
 817        if(X>x1)  x1=X;\r
 818        if(W<x2)  x2=W;\r
 819        if(x2<x1) {sw=x1;x1=x2;x2=sw;}\r
 820 \r
 821        if (dwGPUVersion == 2)\r
 822         npos.l=0x00ff00ff;\r
 823        else\r
 824         npos.l=((x1-xa)<<(26-k))|((x2-xa)<<(18-k))|y1|y2;\r
 825 \r
 826         {\r
 827          tsb=pscSubtexStore[k][j]+SOFFA;iMax=tsb->pos.l;tsb++;\r
 828          for(i=0;i<iMax;i++,tsb++)\r
 829           if(tsb->ClutID && XCHECK(tsb->pos,npos)) {tsb->ClutID=0;MarkFree(tsb);}\r
 830 \r
 831 //         if(npos.l & 0x00800000)\r
 832           {\r
 833            tsb=pscSubtexStore[k][j]+SOFFB;iMax=tsb->pos.l;tsb++;\r
 834            for(i=0;i<iMax;i++,tsb++)\r
 835             if(tsb->ClutID && XCHECK(tsb->pos,npos)) {tsb->ClutID=0;MarkFree(tsb);}\r
 836           }\r
 837 \r
 838 //         if(npos.l & 0x00000080)\r
 839           {\r
 840            tsb=pscSubtexStore[k][j]+SOFFC;iMax=tsb->pos.l;tsb++;\r
 841            for(i=0;i<iMax;i++,tsb++)\r
 842             if(tsb->ClutID && XCHECK(tsb->pos,npos)) {tsb->ClutID=0;MarkFree(tsb);}\r
 843           }\r
 844 \r
 845 //         if(npos.l & 0x00800080)\r
 846           {\r
 847            tsb=pscSubtexStore[k][j]+SOFFD;iMax=tsb->pos.l;tsb++;\r
 848            for(i=0;i<iMax;i++,tsb++)\r
 849             if(tsb->ClutID && XCHECK(tsb->pos,npos)) {tsb->ClutID=0;MarkFree(tsb);}\r
 850           }\r
 851         }\r
 852       }\r
 853     }\r
 854   }\r
 855 }\r
 856 \r
 857 ////////////////////////////////////////////////////////////////////////\r
 858 // Invalidate some parts of cache: main routine\r
 859 ////////////////////////////////////////////////////////////////////////\r
 860 \r
 861 void InvalidateTextureAreaEx(void)\r
 862 {\r
 863  short W=sxmax-sxmin;\r
 864  short H=symax-symin;\r
 865 \r
 866  if(W==0 && H==0) return;\r
 867 \r
 868  if(iMaxTexWnds) \r
 869   InvalidateWndTextureArea(sxmin,symin,W,H);\r
 870 \r
 871  InvalidateSubSTextureArea(sxmin,symin,W,H);\r
 872 }\r
 873 \r
 874 ////////////////////////////////////////////////////////////////////////\r
 875 \r
 876 void InvalidateTextureArea(long X,long Y,long W, long H)\r
 877 {\r
 878  if(W==0 && H==0) return;\r
 879 \r
 880  if(iMaxTexWnds) InvalidateWndTextureArea(X,Y,W,H); \r
 881 \r
 882  InvalidateSubSTextureArea(X,Y,W,H);\r
 883 }\r
 884 \r
 885 \r
 886 ////////////////////////////////////////////////////////////////////////\r
 887 // tex window: define\r
 888 ////////////////////////////////////////////////////////////////////////\r
 889 \r
 890 void DefineTextureWnd(void)\r
 891 {\r
 892  if(gTexName==0)\r
 893   glGenTextures(1, &gTexName);\r
 894  glError();\r
 895  glBindTexture(GL_TEXTURE_2D, gTexName);\r
 896  glError();\r
 897  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);\r
 898  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);\r
 899  glError(); \r
 900 {\r
 901    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, iFilter);\r
 902    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, iFilter);\r
 903    glError();\r
 904   }\r
 905 \r
 906  glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA, \r
 907               TWin.Position.x1, \r
 908               TWin.Position.y1, \r
 909               0, GL_RGBA, GL_UNSIGNED_BYTE, texturepart);\r
 910  glError();\r
 911  //LOGE("DefineTextureWnd x:%d y:%d",TWin.Position.x1,TWin.Position.y1);\r
 912 \r
 913 }\r
 914 \r
 915 ////////////////////////////////////////////////////////////////////////\r
 916 // tex window: load packed stretch\r
 917 ////////////////////////////////////////////////////////////////////////\r
 918 \r
 919 void LoadStretchPackedWndTexturePage(int pageid, int mode, short cx, short cy)\r
 920 {\r
 921  unsigned long start,row,column,j,sxh,sxm,ldx,ldy,ldxo;\r
 922  unsigned int   palstart;\r
 923  unsigned short *px,*pa,*ta;\r
 924  unsigned char  *cSRCPtr,*cOSRCPtr;\r
 925  unsigned short *wSRCPtr,*wOSRCPtr;\r
 926  unsigned long  LineOffset;unsigned short s;\r
 927  int pmult=pageid/16;\r
 928  unsigned short (*LPTCOL)(unsigned short);\r
 929 \r
 930  LPTCOL=PTCF[DrawSemiTrans];\r
 931 \r
 932  ldxo=TWin.Position.x1-TWin.OPosition.x1;\r
 933  ldy =TWin.Position.y1-TWin.OPosition.y1;\r
 934 \r
 935  pa=px=(unsigned short *)ubPaletteBuffer;\r
 936  ta=(unsigned short *)texturepart;\r
 937  palstart=cx+(cy*1024);\r
 938 \r
 939  ubOpaqueDraw=0;\r
 940 \r
 941  switch(mode)\r
 942   {\r
 943    //--------------------------------------------------// \r
 944    // 4bit texture load ..\r
 945    case 0:\r
 946     if(GlobalTextIL)\r
 947      {\r
 948       unsigned int TXV,TXU,n_xi,n_yi;\r
 949 \r
 950       wSRCPtr=psxVuw+palstart;\r
 951       for(row=0;row<16;row++)\r
 952        *px++=LPTCOL(*wSRCPtr++);\r
 953 \r
 954       column=g_y2-ldy;\r
 955       for(TXV=g_y1;TXV<=column;TXV++)\r
 956        {\r
 957         ldx=ldxo;\r
 958         for(TXU=g_x1;TXU<=g_x2-ldxo;TXU++)\r
 959          {\r
 960                   n_xi = ( ( TXU >> 2 ) & ~0x3c ) + ( ( TXV << 2 ) & 0x3c );\r
 961                   n_yi = ( TXV & ~0xf ) + ( ( TXU >> 4 ) & 0xf );\r
 962 \r
 963           s=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x03 ) << 2 ) ) & 0x0f ));\r
 964           *ta++=s;\r
 965 \r
 966           if(ldx) {*ta++=s;ldx--;}\r
 967          }\r
 968 \r
 969         if(ldy) \r
 970          {ldy--;\r
 971           for(TXU=g_x1;TXU<=g_x2;TXU++)\r
 972            *ta++=*(ta-(g_x2-g_x1));\r
 973          }\r
 974        }\r
 975 \r
 976       DefineTextureWnd();\r
 977 \r
 978       break;\r
 979      }\r
 980 \r
 981 \r
 982     start=((pageid-16*pmult)*128)+256*2048*pmult;\r
 983 \r
 984     // convert CLUT to 32bits .. and then use THAT as a lookup table\r
 985 \r
 986     wSRCPtr=psxVuw+palstart;\r
 987     for(row=0;row<16;row++)\r
 988      *px++=LPTCOL(*wSRCPtr++);\r
 989 \r
 990     sxm=g_x1&1;sxh=g_x1>>1;\r
 991     if(sxm) j=g_x1+1; else j=g_x1;\r
 992     cSRCPtr = psxVub + start + (2048*g_y1) + sxh;\r
 993     for(column=g_y1;column<=g_y2;column++)\r
 994      {\r
 995       cOSRCPtr=cSRCPtr;ldx=ldxo;\r
 996       if(sxm) *ta++=*(pa+((*cSRCPtr++ >> 4) & 0xF));\r
 997       \r
 998       for(row=j;row<=g_x2-ldxo;row++)\r
 999        {\r
1000         s=*(pa+(*cSRCPtr & 0xF));\r
1001         *ta++=s;\r
1002         if(ldx) {*ta++=s;ldx--;}\r
1003         row++;\r
1004         if(row<=g_x2-ldxo) \r
1005          {\r
1006           s=*(pa+((*cSRCPtr >> 4) & 0xF));\r
1007           *ta++=s; \r
1008           if(ldx) {*ta++=s;ldx--;}\r
1009          }\r
1010         cSRCPtr++;\r
1011        }\r
1012 \r
1013       if(ldy && column&1) \r
1014            {ldy--;cSRCPtr = cOSRCPtr;}\r
1015       else cSRCPtr = psxVub + start + (2048*(column+1)) + sxh;\r
1016      }\r
1017 \r
1018     DefineTextureWnd();\r
1019     break;\r
1020    //--------------------------------------------------// \r
1021    // 8bit texture load ..\r
1022    case 1:\r
1023     if(GlobalTextIL)\r
1024      {\r
1025       unsigned int TXV,TXU,n_xi,n_yi;\r
1026 \r
1027       wSRCPtr=psxVuw+palstart;\r
1028       for(row=0;row<256;row++)\r
1029        *px++=LPTCOL(*wSRCPtr++);\r
1030 \r
1031       column=g_y2-ldy;\r
1032       for(TXV=g_y1;TXV<=column;TXV++)\r
1033        {\r
1034         ldx=ldxo;\r
1035         for(TXU=g_x1;TXU<=g_x2-ldxo;TXU++)\r
1036          {\r
1037                   n_xi = ( ( TXU >> 1 ) & ~0x78 ) + ( ( TXU << 2 ) & 0x40 ) + ( ( TXV << 3 ) & 0x38 );\r
1038                   n_yi = ( TXV & ~0x7 ) + ( ( TXU >> 5 ) & 0x7 );\r
1039 \r
1040           s=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x01 ) << 3 ) ) & 0xff));\r
1041 \r
1042           *ta++=s;\r
1043           if(ldx) {*ta++=s;ldx--;}\r
1044          }\r
1045 \r
1046         if(ldy) \r
1047          {ldy--;\r
1048           for(TXU=g_x1;TXU<=g_x2;TXU++)\r
1049            *ta++=*(ta-(g_x2-g_x1));\r
1050          }\r
1051 \r
1052        }\r
1053 \r
1054       DefineTextureWnd();\r
1055 \r
1056       break;\r
1057      }\r
1058 \r
1059     start=((pageid-16*pmult)*128)+256*2048*pmult;\r
1060 \r
1061     // not using a lookup table here... speeds up smaller texture areas\r
1062     cSRCPtr = psxVub + start + (2048*g_y1) + g_x1;\r
1063     LineOffset = 2048 - (g_x2-g_x1+1) +ldxo; \r
1064 \r
1065     for(column=g_y1;column<=g_y2;column++)\r
1066      {\r
1067       cOSRCPtr=cSRCPtr;ldx=ldxo;\r
1068       for(row=g_x1;row<=g_x2-ldxo;row++)\r
1069        {\r
1070         s=LPTCOL(psxVuw[palstart+ *cSRCPtr++]);\r
1071         *ta++=s;\r
1072         if(ldx) {*ta++=s;ldx--;}\r
1073        }\r
1074       if(ldy && column&1) {ldy--;cSRCPtr=cOSRCPtr;}\r
1075       else                cSRCPtr+=LineOffset;\r
1076      }\r
1077 \r
1078     DefineTextureWnd();\r
1079     break;\r
1080    //--------------------------------------------------// \r
1081    // 16bit texture load ..\r
1082    case 2:\r
1083     start=((pageid-16*pmult)*64)+256*1024*pmult;\r
1084     wSRCPtr = psxVuw + start + (1024*g_y1) + g_x1;\r
1085     LineOffset = 1024 - (g_x2-g_x1+1) +ldxo; \r
1086                                 \r
1087     for(column=g_y1;column<=g_y2;column++)\r
1088      {\r
1089       wOSRCPtr=wSRCPtr;ldx=ldxo;\r
1090       for(row=g_x1;row<=g_x2-ldxo;row++)\r
1091        {\r
1092         s=LPTCOL(*wSRCPtr++);\r
1093         *ta++=s;\r
1094         if(ldx) {*ta++=s;ldx--;}\r
1095        }\r
1096       if(ldy && column&1) {ldy--;wSRCPtr=wOSRCPtr;}\r
1097       else                 wSRCPtr+=LineOffset;\r
1098      }\r
1099 \r
1100     DefineTextureWnd();\r
1101     break;\r
1102    //--------------------------------------------------// \r
1103    // others are not possible !\r
1104   }\r
1105 }\r
1106 \r
1107 ////////////////////////////////////////////////////////////////////////\r
1108 // tex window: load stretched\r
1109 ////////////////////////////////////////////////////////////////////////\r
1110 \r
1111 void LoadStretchWndTexturePage(int pageid, int mode, short cx, short cy)\r
1112 {\r
1113  unsigned long start,row,column,j,sxh,sxm,ldx,ldy,ldxo,s;\r
1114  unsigned int   palstart;\r
1115  unsigned long  *px,*pa,*ta;\r
1116  unsigned char  *cSRCPtr,*cOSRCPtr;\r
1117  unsigned short *wSRCPtr,*wOSRCPtr;\r
1118  unsigned long  LineOffset;\r
1119  int pmult=pageid/16;\r
1120  unsigned long (*LTCOL)(unsigned long);\r
1121  \r
1122  LTCOL=TCF[DrawSemiTrans];\r
1123 \r
1124  ldxo=TWin.Position.x1-TWin.OPosition.x1;\r
1125  ldy =TWin.Position.y1-TWin.OPosition.y1;\r
1126 \r
1127  pa=px=(unsigned long *)ubPaletteBuffer;\r
1128  ta=(unsigned long *)texturepart;\r
1129  palstart=cx+(cy*1024);\r
1130 \r
1131  ubOpaqueDraw=0;\r
1132 \r
1133  switch(mode)\r
1134   {\r
1135    //--------------------------------------------------// \r
1136    // 4bit texture load ..\r
1137    case 0:\r
1138     //------------------- ZN STUFF\r
1139 \r
1140     if(GlobalTextIL)\r
1141      {\r
1142       unsigned int TXV,TXU,n_xi,n_yi;\r
1143 \r
1144       wSRCPtr=psxVuw+palstart;\r
1145 \r
1146       row=4;do\r
1147        {\r
1148         *px    =LTCOL(*wSRCPtr);\r
1149         *(px+1)=LTCOL(*(wSRCPtr+1));\r
1150         *(px+2)=LTCOL(*(wSRCPtr+2));\r
1151         *(px+3)=LTCOL(*(wSRCPtr+3));\r
1152         row--;px+=4;wSRCPtr+=4;\r
1153        }\r
1154       while (row);\r
1155 \r
1156       column=g_y2-ldy;\r
1157       for(TXV=g_y1;TXV<=column;TXV++)\r
1158        {\r
1159         ldx=ldxo;\r
1160         for(TXU=g_x1;TXU<=g_x2-ldxo;TXU++)\r
1161          {\r
1162                   n_xi = ( ( TXU >> 2 ) & ~0x3c ) + ( ( TXV << 2 ) & 0x3c );\r
1163                   n_yi = ( TXV & ~0xf ) + ( ( TXU >> 4 ) & 0xf );\r
1164 \r
1165           s=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x03 ) << 2 ) ) & 0x0f ));\r
1166           *ta++=s;\r
1167 \r
1168           if(ldx) {*ta++=s;ldx--;}\r
1169          }\r
1170 \r
1171         if(ldy) \r
1172          {ldy--;\r
1173           for(TXU=g_x1;TXU<=g_x2;TXU++)\r
1174            *ta++=*(ta-(g_x2-g_x1));\r
1175          }\r
1176        }\r
1177 \r
1178       DefineTextureWnd();\r
1179 \r
1180       break;\r
1181      }\r
1182 \r
1183     //-------------------\r
1184 \r
1185     start=((pageid-16*pmult)*128)+256*2048*pmult;\r
1186     // convert CLUT to 32bits .. and then use THAT as a lookup table\r
1187 \r
1188     wSRCPtr=psxVuw+palstart;\r
1189     for(row=0;row<16;row++)\r
1190      *px++=LTCOL(*wSRCPtr++);\r
1191 \r
1192     sxm=g_x1&1;sxh=g_x1>>1;\r
1193     if(sxm) j=g_x1+1; else j=g_x1;\r
1194     cSRCPtr = psxVub + start + (2048*g_y1) + sxh;\r
1195     for(column=g_y1;column<=g_y2;column++)\r
1196      {\r
1197       cOSRCPtr=cSRCPtr;ldx=ldxo;\r
1198       if(sxm) *ta++=*(pa+((*cSRCPtr++ >> 4) & 0xF));\r
1199       \r
1200       for(row=j;row<=g_x2-ldxo;row++)\r
1201        {\r
1202         s=*(pa+(*cSRCPtr & 0xF));\r
1203         *ta++=s;\r
1204         if(ldx) {*ta++=s;ldx--;}\r
1205         row++;\r
1206         if(row<=g_x2-ldxo) \r
1207          {\r
1208           s=*(pa+((*cSRCPtr >> 4) & 0xF));\r
1209           *ta++=s; \r
1210           if(ldx) {*ta++=s;ldx--;}\r
1211          }\r
1212         cSRCPtr++;\r
1213        }\r
1214       if(ldy && column&1) \r
1215            {ldy--;cSRCPtr = cOSRCPtr;}\r
1216       else cSRCPtr = psxVub + start + (2048*(column+1)) + sxh;\r
1217      }\r
1218 \r
1219     DefineTextureWnd();\r
1220     break;\r
1221    //--------------------------------------------------//\r
1222    // 8bit texture load ..\r
1223    case 1:\r
1224     //------------ ZN STUFF\r
1225     if(GlobalTextIL)\r
1226      {\r
1227       unsigned int TXV,TXU,n_xi,n_yi;\r
1228 \r
1229       wSRCPtr=psxVuw+palstart;\r
1230 \r
1231       row=64;do\r
1232        {\r
1233         *px    =LTCOL(*wSRCPtr);\r
1234         *(px+1)=LTCOL(*(wSRCPtr+1));\r
1235         *(px+2)=LTCOL(*(wSRCPtr+2));\r
1236         *(px+3)=LTCOL(*(wSRCPtr+3));\r
1237         row--;px+=4;wSRCPtr+=4;\r
1238        }\r
1239       while (row);\r
1240 \r
1241       column=g_y2-ldy;\r
1242       for(TXV=g_y1;TXV<=column;TXV++)\r
1243        {\r
1244         ldx=ldxo;\r
1245         for(TXU=g_x1;TXU<=g_x2-ldxo;TXU++)\r
1246          {\r
1247                   n_xi = ( ( TXU >> 1 ) & ~0x78 ) + ( ( TXU << 2 ) & 0x40 ) + ( ( TXV << 3 ) & 0x38 );\r
1248                   n_yi = ( TXV & ~0x7 ) + ( ( TXU >> 5 ) & 0x7 );\r
1249 \r
1250           s=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x01 ) << 3 ) ) & 0xff));\r
1251           *ta++=s;\r
1252           if(ldx) {*ta++=s;ldx--;}\r
1253          }\r
1254 \r
1255         if(ldy) \r
1256          {ldy--;\r
1257           for(TXU=g_x1;TXU<=g_x2;TXU++)\r
1258            *ta++=*(ta-(g_x2-g_x1));\r
1259          }\r
1260 \r
1261        }\r
1262 \r
1263       DefineTextureWnd();\r
1264 \r
1265       break;\r
1266      }\r
1267     //------------\r
1268 \r
1269     start=((pageid-16*pmult)*128)+256*2048*pmult;    \r
1270 \r
1271     // not using a lookup table here... speeds up smaller texture areas\r
1272     cSRCPtr = psxVub + start + (2048*g_y1) + g_x1;\r
1273     LineOffset = 2048 - (g_x2-g_x1+1) +ldxo; \r
1274 \r
1275     for(column=g_y1;column<=g_y2;column++)\r
1276      {\r
1277       cOSRCPtr=cSRCPtr;ldx=ldxo;\r
1278       for(row=g_x1;row<=g_x2-ldxo;row++)\r
1279        {\r
1280         s=LTCOL(psxVuw[palstart+ *cSRCPtr++]);\r
1281         *ta++=s;\r
1282         if(ldx) {*ta++=s;ldx--;}\r
1283        }\r
1284       if(ldy && column&1) {ldy--;cSRCPtr=cOSRCPtr;}\r
1285       else                cSRCPtr+=LineOffset;\r
1286      }\r
1287 \r
1288     DefineTextureWnd();\r
1289     break;\r
1290    //--------------------------------------------------// \r
1291    // 16bit texture load ..\r
1292    case 2:\r
1293     start=((pageid-16*pmult)*64)+256*1024*pmult;\r
1294 \r
1295     wSRCPtr = psxVuw + start + (1024*g_y1) + g_x1;\r
1296     LineOffset = 1024 - (g_x2-g_x1+1) +ldxo; \r
1297 \r
1298     for(column=g_y1;column<=g_y2;column++)\r
1299      {\r
1300       wOSRCPtr=wSRCPtr;ldx=ldxo;\r
1301       for(row=g_x1;row<=g_x2-ldxo;row++)\r
1302        {\r
1303         s=LTCOL(*wSRCPtr++);\r
1304         *ta++=s;\r
1305         if(ldx) {*ta++=s;ldx--;}\r
1306        }\r
1307       if(ldy && column&1) {ldy--;wSRCPtr=wOSRCPtr;}\r
1308       else                 wSRCPtr+=LineOffset;\r
1309      }\r
1310 \r
1311     DefineTextureWnd();\r
1312     break;\r
1313    //--------------------------------------------------// \r
1314    // others are not possible !\r
1315   }\r
1316 }\r
1317 \r
1318 ////////////////////////////////////////////////////////////////////////\r
1319 // tex window: load packed simple\r
1320 ////////////////////////////////////////////////////////////////////////\r
1321 \r
1322 void LoadPackedWndTexturePage(int pageid, int mode, short cx, short cy)\r
1323 {\r
1324  unsigned long start,row,column,j,sxh,sxm;\r
1325  unsigned int   palstart;\r
1326  unsigned short *px,*pa,*ta;\r
1327  unsigned char  *cSRCPtr;\r
1328  unsigned short *wSRCPtr;\r
1329  unsigned long  LineOffset;\r
1330  int pmult=pageid/16;\r
1331  unsigned short (*LPTCOL)(unsigned short);\r
1332 \r
1333  LPTCOL=PTCF[DrawSemiTrans];\r
1334 \r
1335  pa=px=(unsigned short *)ubPaletteBuffer;\r
1336  ta=(unsigned short *)texturepart;\r
1337  palstart=cx+(cy*1024);\r
1338 \r
1339  ubOpaqueDraw=0;\r
1340 \r
1341  switch(mode)\r
1342   {\r
1343    //--------------------------------------------------// \r
1344    // 4bit texture load ..\r
1345    case 0:\r
1346     if(GlobalTextIL)\r
1347      {\r
1348       unsigned int TXV,TXU,n_xi,n_yi;\r
1349 \r
1350       wSRCPtr=psxVuw+palstart;\r
1351       for(row=0;row<16;row++)\r
1352        *px++=LPTCOL(*wSRCPtr++);\r
1353 \r
1354       for(TXV=g_y1;TXV<=g_y2;TXV++)\r
1355        {\r
1356         for(TXU=g_x1;TXU<=g_x2;TXU++)\r
1357          {\r
1358                   n_xi = ( ( TXU >> 2 ) & ~0x3c ) + ( ( TXV << 2 ) & 0x3c );\r
1359                   n_yi = ( TXV & ~0xf ) + ( ( TXU >> 4 ) & 0xf );\r
1360 \r
1361           *ta++=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x03 ) << 2 ) ) & 0x0f ));\r
1362          }\r
1363        }\r
1364 \r
1365       DefineTextureWnd();\r
1366 \r
1367       break;\r
1368      }\r
1369 \r
1370     start=((pageid-16*pmult)*128)+256*2048*pmult;\r
1371 \r
1372     // convert CLUT to 32bits .. and then use THAT as a lookup table\r
1373 \r
1374     wSRCPtr=psxVuw+palstart;\r
1375     for(row=0;row<16;row++)\r
1376      *px++=LPTCOL(*wSRCPtr++);\r
1377 \r
1378     sxm=g_x1&1;sxh=g_x1>>1;\r
1379     if(sxm) j=g_x1+1; else j=g_x1;\r
1380     cSRCPtr = psxVub + start + (2048*g_y1) + sxh;\r
1381     for(column=g_y1;column<=g_y2;column++)\r
1382      {\r
1383       cSRCPtr = psxVub + start + (2048*column) + sxh;\r
1384     \r
1385       if(sxm) *ta++=*(pa+((*cSRCPtr++ >> 4) & 0xF));\r
1386       \r
1387       for(row=j;row<=g_x2;row++)\r
1388        {\r
1389         *ta++=*(pa+(*cSRCPtr & 0xF)); row++;\r
1390         if(row<=g_x2) *ta++=*(pa+((*cSRCPtr >> 4) & 0xF)); \r
1391         cSRCPtr++;\r
1392        }\r
1393      }\r
1394 \r
1395     DefineTextureWnd();\r
1396     break;\r
1397    //--------------------------------------------------// \r
1398    // 8bit texture load ..\r
1399    case 1:\r
1400     if(GlobalTextIL)\r
1401      {\r
1402       unsigned int TXV,TXU,n_xi,n_yi;\r
1403 \r
1404       wSRCPtr=psxVuw+palstart;\r
1405       for(row=0;row<256;row++)\r
1406        *px++=LPTCOL(*wSRCPtr++);\r
1407 \r
1408       for(TXV=g_y1;TXV<=g_y2;TXV++)\r
1409        {\r
1410         for(TXU=g_x1;TXU<=g_x2;TXU++)\r
1411          {\r
1412                   n_xi = ( ( TXU >> 1 ) & ~0x78 ) + ( ( TXU << 2 ) & 0x40 ) + ( ( TXV << 3 ) & 0x38 );\r
1413                   n_yi = ( TXV & ~0x7 ) + ( ( TXU >> 5 ) & 0x7 );\r
1414 \r
1415           *ta++=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x01 ) << 3 ) ) & 0xff));\r
1416          }\r
1417        }\r
1418 \r
1419       DefineTextureWnd();\r
1420 \r
1421       break;\r
1422      }\r
1423 \r
1424     start=((pageid-16*pmult)*128)+256*2048*pmult;\r
1425 \r
1426     // not using a lookup table here... speeds up smaller texture areas\r
1427     cSRCPtr = psxVub + start + (2048*g_y1) + g_x1;\r
1428     LineOffset = 2048 - (g_x2-g_x1+1); \r
1429 \r
1430     for(column=g_y1;column<=g_y2;column++)\r
1431      {\r
1432       for(row=g_x1;row<=g_x2;row++)\r
1433        *ta++=LPTCOL(psxVuw[palstart+ *cSRCPtr++]);\r
1434       cSRCPtr+=LineOffset;\r
1435      }\r
1436 \r
1437     DefineTextureWnd();\r
1438     break;\r
1439    //--------------------------------------------------// \r
1440    // 16bit texture load ..\r
1441    case 2:\r
1442     start=((pageid-16*pmult)*64)+256*1024*pmult;\r
1443     wSRCPtr = psxVuw + start + (1024*g_y1) + g_x1;\r
1444     LineOffset = 1024 - (g_x2-g_x1+1); \r
1445 \r
1446     for(column=g_y1;column<=g_y2;column++)\r
1447      {\r
1448       for(row=g_x1;row<=g_x2;row++)\r
1449        *ta++=LPTCOL(*wSRCPtr++);\r
1450       wSRCPtr+=LineOffset;\r
1451      }\r
1452 \r
1453     DefineTextureWnd();\r
1454     break;\r
1455    //--------------------------------------------------// \r
1456    // others are not possible !\r
1457   }\r
1458 }\r
1459 \r
1460 ////////////////////////////////////////////////////////////////////////\r
1461 // tex window: load simple\r
1462 ////////////////////////////////////////////////////////////////////////\r
1463 \r
1464 void LoadWndTexturePage(int pageid, int mode, short cx, short cy)\r
1465 {\r
1466  unsigned long start,row,column,j,sxh,sxm;\r
1467  unsigned int   palstart;\r
1468  unsigned long  *px,*pa,*ta;\r
1469  unsigned char  *cSRCPtr;\r
1470  unsigned short *wSRCPtr;\r
1471  unsigned long  LineOffset;\r
1472  int pmult=pageid/16;\r
1473  unsigned long (*LTCOL)(unsigned long);\r
1474  \r
1475  LTCOL=TCF[DrawSemiTrans];\r
1476 \r
1477  pa=px=(unsigned long *)ubPaletteBuffer;\r
1478  ta=(unsigned long *)texturepart;\r
1479  palstart=cx+(cy*1024);\r
1480 \r
1481  ubOpaqueDraw=0;\r
1482 \r
1483  switch(mode)\r
1484   {\r
1485    //--------------------------------------------------// \r
1486    // 4bit texture load ..\r
1487    case 0:\r
1488     if(GlobalTextIL)\r
1489      {\r
1490       unsigned int TXV,TXU,n_xi,n_yi;\r
1491 \r
1492       wSRCPtr=psxVuw+palstart;\r
1493 \r
1494       row=4;do\r
1495        {\r
1496         *px    =LTCOL(*wSRCPtr);\r
1497         *(px+1)=LTCOL(*(wSRCPtr+1));\r
1498         *(px+2)=LTCOL(*(wSRCPtr+2));\r
1499         *(px+3)=LTCOL(*(wSRCPtr+3));\r
1500         row--;px+=4;wSRCPtr+=4;\r
1501        }\r
1502       while (row);\r
1503 \r
1504       for(TXV=g_y1;TXV<=g_y2;TXV++)\r
1505        {\r
1506         for(TXU=g_x1;TXU<=g_x2;TXU++)\r
1507          {\r
1508                   n_xi = ( ( TXU >> 2 ) & ~0x3c ) + ( ( TXV << 2 ) & 0x3c );\r
1509                   n_yi = ( TXV & ~0xf ) + ( ( TXU >> 4 ) & 0xf );\r
1510 \r
1511           *ta++=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x03 ) << 2 ) ) & 0x0f ));\r
1512          }\r
1513        }\r
1514 \r
1515       DefineTextureWnd();\r
1516 \r
1517       break;\r
1518      }\r
1519 \r
1520     start=((pageid-16*pmult)*128)+256*2048*pmult;\r
1521 \r
1522     // convert CLUT to 32bits .. and then use THAT as a lookup table\r
1523 \r
1524     wSRCPtr=psxVuw+palstart;\r
1525     for(row=0;row<16;row++)\r
1526      *px++=LTCOL(*wSRCPtr++);\r
1527 \r
1528     sxm=g_x1&1;sxh=g_x1>>1;\r
1529     if(sxm) j=g_x1+1; else j=g_x1;\r
1530     cSRCPtr = psxVub + start + (2048*g_y1) + sxh;\r
1531     for(column=g_y1;column<=g_y2;column++)\r
1532      {\r
1533       cSRCPtr = psxVub + start + (2048*column) + sxh;\r
1534     \r
1535       if(sxm) *ta++=*(pa+((*cSRCPtr++ >> 4) & 0xF));\r
1536       \r
1537       for(row=j;row<=g_x2;row++)\r
1538        {\r
1539         *ta++=*(pa+(*cSRCPtr & 0xF)); row++;\r
1540         if(row<=g_x2) *ta++=*(pa+((*cSRCPtr >> 4) & 0xF)); \r
1541         cSRCPtr++;\r
1542        }\r
1543      }\r
1544 \r
1545     DefineTextureWnd();\r
1546     break;\r
1547    //--------------------------------------------------//\r
1548    // 8bit texture load ..\r
1549    case 1:\r
1550     if(GlobalTextIL)\r
1551      {\r
1552       unsigned int TXV,TXU,n_xi,n_yi;\r
1553 \r
1554       wSRCPtr=psxVuw+palstart;\r
1555 \r
1556       row=64;do\r
1557        {\r
1558         *px    =LTCOL(*wSRCPtr);\r
1559         *(px+1)=LTCOL(*(wSRCPtr+1));\r
1560         *(px+2)=LTCOL(*(wSRCPtr+2));\r
1561         *(px+3)=LTCOL(*(wSRCPtr+3));\r
1562         row--;px+=4;wSRCPtr+=4;\r
1563        }\r
1564       while (row);\r
1565 \r
1566       for(TXV=g_y1;TXV<=g_y2;TXV++)\r
1567        {\r
1568         for(TXU=g_x1;TXU<=g_x2;TXU++)\r
1569          {\r
1570                   n_xi = ( ( TXU >> 1 ) & ~0x78 ) + ( ( TXU << 2 ) & 0x40 ) + ( ( TXV << 3 ) & 0x38 );\r
1571                   n_yi = ( TXV & ~0x7 ) + ( ( TXU >> 5 ) & 0x7 );\r
1572 \r
1573           *ta++=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x01 ) << 3 ) ) & 0xff));\r
1574          }\r
1575        }\r
1576 \r
1577       DefineTextureWnd();\r
1578 \r
1579       break;\r
1580      }\r
1581 \r
1582     start=((pageid-16*pmult)*128)+256*2048*pmult;\r
1583 \r
1584     // not using a lookup table here... speeds up smaller texture areas\r
1585     cSRCPtr = psxVub + start + (2048*g_y1) + g_x1;\r
1586     LineOffset = 2048 - (g_x2-g_x1+1); \r
1587 \r
1588     for(column=g_y1;column<=g_y2;column++)\r
1589      {\r
1590       for(row=g_x1;row<=g_x2;row++)\r
1591        *ta++=LTCOL(psxVuw[palstart+ *cSRCPtr++]);\r
1592       cSRCPtr+=LineOffset;\r
1593      }\r
1594 \r
1595     DefineTextureWnd();\r
1596     break;\r
1597    //--------------------------------------------------// \r
1598    // 16bit texture load ..\r
1599    case 2:\r
1600     start=((pageid-16*pmult)*64)+256*1024*pmult;\r
1601 \r
1602     wSRCPtr = psxVuw + start + (1024*g_y1) + g_x1;\r
1603     LineOffset = 1024 - (g_x2-g_x1+1); \r
1604 \r
1605     for(column=g_y1;column<=g_y2;column++)\r
1606      {\r
1607       for(row=g_x1;row<=g_x2;row++)\r
1608        *ta++=LTCOL(*wSRCPtr++);\r
1609       wSRCPtr+=LineOffset;\r
1610      }\r
1611 \r
1612     DefineTextureWnd();\r
1613     break;\r
1614    //--------------------------------------------------// \r
1615    // others are not possible !\r
1616   }\r
1617 }\r
1618 \r
1619 ////////////////////////////////////////////////////////////////////////\r
1620 ////////////////////////////////////////////////////////////////////////\r
1621 ////////////////////////////////////////////////////////////////////////\r
1622 ////////////////////////////////////////////////////////////////////////\r
1623 \r
1624 void UploadTexWndPal(int mode,short cx,short cy)\r
1625 {\r
1626  unsigned int i,iSize;\r
1627  unsigned short * wSrcPtr;\r
1628  unsigned long * ta=(unsigned long *)texturepart;\r
1629 \r
1630  wSrcPtr=psxVuw+cx+(cy*1024);\r
1631  if(mode==0) i=4; else i=64;\r
1632  iSize=i<<2;\r
1633  ubOpaqueDraw=0;\r
1634 \r
1635  do\r
1636   {\r
1637    *ta    =PALCOL(*wSrcPtr);\r
1638    *(ta+1)=PALCOL(*(wSrcPtr+1));\r
1639    *(ta+2)=PALCOL(*(wSrcPtr+2));\r
1640    *(ta+3)=PALCOL(*(wSrcPtr+3));\r
1641    ta+=4;wSrcPtr+=4;i--;\r
1642   }\r
1643  while(i);\r
1644 \r
1645 /* (*glColorTableEXTEx)(GL_TEXTURE_2D,GL_RGBA8,iSize,\r
1646                     GL_RGBA,GL_UNSIGNED_BYTE,texturepart);\r
1647 */}\r
1648 \r
1649 ////////////////////////////////////////////////////////////////////////\r
1650 \r
1651 void DefinePalTextureWnd(void)\r
1652 {\r
1653  if(gTexName==0)\r
1654   glGenTextures(1, &gTexName);\r
1655  glError();\r
1656  glBindTexture(GL_TEXTURE_2D, gTexName);\r
1657  glError();\r
1658  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);\r
1659  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);\r
1660  glError();\r
1661 {\r
1662    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, iFilter);\r
1663    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, iFilter);\r
1664   }\r
1665  glError();\r
1666  glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA, \r
1667               TWin.Position.x1, \r
1668               TWin.Position.y1, \r
1669               0, GL_RGBA, GL_UNSIGNED_BYTE,texturepart);\r
1670   glError();\r
1671   //LOGE("DefinePalTextureWnd x:%d y:%d",TWin.Position.x1,TWin.Position.y1);\r
1672 }\r
1673 \r
1674 ///////////////////////////////////////////////////////\r
1675 \r
1676 void LoadPalWndTexturePage(int pageid, int mode, short cx, short cy)\r
1677 {\r
1678  unsigned long start,row,column,j,sxh,sxm;\r
1679  unsigned char  *ta;\r
1680  unsigned char  *cSRCPtr;\r
1681  unsigned long  LineOffset;\r
1682  int pmult=pageid/16;\r
1683 \r
1684  ta=(unsigned char *)texturepart;\r
1685 \r
1686  switch(mode)\r
1687   {\r
1688    //--------------------------------------------------// \r
1689    // 4bit texture load ..\r
1690    case 0:\r
1691     start=((pageid-16*pmult)*128)+256*2048*pmult;\r
1692 \r
1693     sxm=g_x1&1;sxh=g_x1>>1;\r
1694     if(sxm) j=g_x1+1; else j=g_x1;\r
1695     cSRCPtr = psxVub + start + (2048*g_y1) + sxh;\r
1696     for(column=g_y1;column<=g_y2;column++)\r
1697      {\r
1698       cSRCPtr = psxVub + start + (2048*column) + sxh;\r
1699     \r
1700       if(sxm) *ta++=((*cSRCPtr++ >> 4) & 0xF);\r
1701       \r
1702       for(row=j;row<=g_x2;row++)\r
1703        {\r
1704         *ta++=(*cSRCPtr & 0xF); row++;\r
1705         if(row<=g_x2) *ta++=((*cSRCPtr >> 4) & 0xF); \r
1706         cSRCPtr++;\r
1707        }\r
1708      }\r
1709 \r
1710     DefinePalTextureWnd();\r
1711     break;\r
1712    //--------------------------------------------------// \r
1713    // 8bit texture load ..\r
1714    case 1:\r
1715     start=((pageid-16*pmult)*128)+256*2048*pmult;\r
1716 \r
1717     // not using a lookup table here... speeds up smaller texture areas\r
1718     cSRCPtr = psxVub + start + (2048*g_y1) + g_x1;\r
1719     LineOffset = 2048 - (g_x2-g_x1+1); \r
1720 \r
1721     for(column=g_y1;column<=g_y2;column++)\r
1722      {\r
1723       for(row=g_x1;row<=g_x2;row++)\r
1724        *ta++=*cSRCPtr++;\r
1725       cSRCPtr+=LineOffset;\r
1726      }\r
1727 \r
1728     DefinePalTextureWnd();\r
1729     break;\r
1730   }\r
1731  UploadTexWndPal(mode,cx,cy);\r
1732 }\r
1733 \r
1734 ////////////////////////////////////////////////////////////////////////\r
1735 \r
1736 void LoadStretchPalWndTexturePage(int pageid, int mode, short cx, short cy)\r
1737 {\r
1738  unsigned long start,row,column,j,sxh,sxm,ldx,ldy,ldxo;\r
1739  unsigned char  *ta,s;\r
1740  unsigned char  *cSRCPtr,*cOSRCPtr;\r
1741  unsigned long  LineOffset;\r
1742  int pmult=pageid/16;\r
1743 \r
1744  ldxo=TWin.Position.x1-TWin.OPosition.x1;\r
1745  ldy =TWin.Position.y1-TWin.OPosition.y1;\r
1746 \r
1747  ta=(unsigned char *)texturepart;\r
1748 \r
1749  switch(mode)\r
1750   {\r
1751    //--------------------------------------------------// \r
1752    // 4bit texture load ..\r
1753    case 0:\r
1754     start=((pageid-16*pmult)*128)+256*2048*pmult;\r
1755 \r
1756     sxm=g_x1&1;sxh=g_x1>>1;\r
1757     if(sxm) j=g_x1+1; else j=g_x1;\r
1758     cSRCPtr = psxVub + start + (2048*g_y1) + sxh;\r
1759     for(column=g_y1;column<=g_y2;column++)\r
1760      {\r
1761       cOSRCPtr=cSRCPtr;ldx=ldxo;\r
1762       if(sxm) *ta++=((*cSRCPtr++ >> 4) & 0xF);\r
1763       \r
1764       for(row=j;row<=g_x2-ldxo;row++)\r
1765        {\r
1766         s=(*cSRCPtr & 0xF);\r
1767         *ta++=s;\r
1768         if(ldx) {*ta++=s;ldx--;}\r
1769         row++;\r
1770         if(row<=g_x2-ldxo) \r
1771          {\r
1772           s=((*cSRCPtr >> 4) & 0xF);\r
1773           *ta++=s; \r
1774           if(ldx) {*ta++=s;ldx--;}\r
1775          }\r
1776         cSRCPtr++;\r
1777        }\r
1778       if(ldy && column&1) \r
1779            {ldy--;cSRCPtr = cOSRCPtr;}\r
1780       else cSRCPtr = psxVub + start + (2048*(column+1)) + sxh;\r
1781      }\r
1782 \r
1783     DefinePalTextureWnd();\r
1784     break;\r
1785    //--------------------------------------------------// \r
1786    // 8bit texture load ..\r
1787    case 1:\r
1788     start=((pageid-16*pmult)*128)+256*2048*pmult;\r
1789 \r
1790     cSRCPtr = psxVub + start + (2048*g_y1) + g_x1;\r
1791     LineOffset = 2048 - (g_x2-g_x1+1) +ldxo; \r
1792 \r
1793     for(column=g_y1;column<=g_y2;column++)\r
1794      {\r
1795       cOSRCPtr=cSRCPtr;ldx=ldxo;\r
1796       for(row=g_x1;row<=g_x2-ldxo;row++)\r
1797        {\r
1798         s=*cSRCPtr++;\r
1799         *ta++=s;\r
1800         if(ldx) {*ta++=s;ldx--;}\r
1801        }\r
1802       if(ldy && column&1) {ldy--;cSRCPtr=cOSRCPtr;}\r
1803       else                cSRCPtr+=LineOffset;\r
1804      }\r
1805 \r
1806     DefinePalTextureWnd();\r
1807     break;\r
1808   }\r
1809  UploadTexWndPal(mode,cx,cy);\r
1810 }\r
1811 \r
1812 ////////////////////////////////////////////////////////////////////////\r
1813 // tex window: main selecting, cache handler included\r
1814 ////////////////////////////////////////////////////////////////////////\r
1815 \r
1816 GLuint LoadTextureWnd(long pageid,long TextureMode,unsigned long GivenClutId)\r
1817 {\r
1818  textureWndCacheEntry * ts, * tsx=NULL;\r
1819  int i;short cx,cy;\r
1820  EXLong npos;\r
1821 \r
1822  npos.c[3]=TWin.Position.x0;\r
1823  npos.c[2]=TWin.OPosition.x1;\r
1824  npos.c[1]=TWin.Position.y0;\r
1825  npos.c[0]=TWin.OPosition.y1;\r
1826 \r
1827  g_x1=TWin.Position.x0;g_x2=g_x1+TWin.Position.x1-1;\r
1828  g_y1=TWin.Position.y0;g_y2=g_y1+TWin.Position.y1-1;\r
1829 \r
1830  if(TextureMode==2) {GivenClutId=0;cx=cy=0;}\r
1831  else  \r
1832   {\r
1833    cx=((GivenClutId << 4) & 0x3F0);cy=((GivenClutId >> 6) & CLUTYMASK);\r
1834    GivenClutId=(GivenClutId&CLUTMASK)|(DrawSemiTrans<<30);\r
1835 \r
1836    // palette check sum\r
1837     {\r
1838      unsigned long l=0,row;\r
1839      unsigned long * lSRCPtr=(unsigned long *)(psxVuw+cx+(cy*1024));\r
1840      if(TextureMode==1) for(row=1;row<129;row++) l+=((*lSRCPtr++)-1)*row;\r
1841      else               for(row=1;row<9;row++)   l+=((*lSRCPtr++)-1)<<row;\r
1842      l=(l+HIWORD(l))&0x3fffL;\r
1843      GivenClutId|=(l<<16);\r
1844     }\r
1845 \r
1846   }\r
1847 \r
1848  ts=wcWndtexStore;\r
1849 \r
1850  for(i=0;i<iMaxTexWnds;i++,ts++)\r
1851   {\r
1852    if(ts->used)\r
1853     {\r
1854      if(ts->pos.l==npos.l &&\r
1855         ts->pageid==pageid &&\r
1856         ts->textureMode==TextureMode)\r
1857       {\r
1858        if(ts->ClutID==GivenClutId)\r
1859         {\r
1860          ubOpaqueDraw=ts->Opaque;\r
1861          return ts->texname;\r
1862         }\r
1863       }\r
1864     }\r
1865    else tsx=ts;\r
1866   }\r
1867 \r
1868  if(!tsx) \r
1869   {\r
1870    if(iMaxTexWnds==iTexWndLimit)\r
1871     {\r
1872      tsx=wcWndtexStore+iTexWndTurn;\r
1873      iTexWndTurn++; \r
1874      if(iTexWndTurn==iTexWndLimit) iTexWndTurn=0;\r
1875     }\r
1876    else\r
1877     {\r
1878      tsx=wcWndtexStore+iMaxTexWnds;\r
1879      iMaxTexWnds++;\r
1880     }\r
1881   }\r
1882 \r
1883  gTexName=tsx->texname;\r
1884 \r
1885  if(TWin.OPosition.y1==TWin.Position.y1 &&\r
1886     TWin.OPosition.x1==TWin.Position.x1)\r
1887   {\r
1888     LoadWndTexturePage(pageid,TextureMode,cx,cy);\r
1889   }       \r
1890  else\r
1891   {\r
1892     LoadStretchWndTexturePage(pageid,TextureMode,cx,cy);\r
1893   }\r
1894 \r
1895  tsx->Opaque=ubOpaqueDraw;\r
1896  tsx->pos.l=npos.l;\r
1897  tsx->ClutID=GivenClutId;\r
1898  tsx->pageid=pageid;\r
1899  tsx->textureMode=TextureMode;\r
1900  tsx->texname=gTexName;\r
1901  tsx->used=1;\r
1902        \r
1903  return gTexName;\r
1904 }\r
1905 \r
1906 /////////////////////////////////////////////////////////////////////////////\r
1907 /////////////////////////////////////////////////////////////////////////////\r
1908 /////////////////////////////////////////////////////////////////////////////\r
1909 \r
1910 ////////////////////////////////////////////////////////////////////////\r
1911 // movie texture: define\r
1912 ////////////////////////////////////////////////////////////////////////\r
1913 \r
1914 void DefinePackedTextureMovie(void)\r
1915 {\r
1916  if(gTexMovieName==0)\r
1917   {\r
1918    glEnable(GL_TEXTURE_2D);\r
1919    glGenTextures(1, &gTexMovieName); glError();\r
1920    gTexName=gTexMovieName;\r
1921    glBindTexture(GL_TEXTURE_2D, gTexName); glError();\r
1922 \r
1923    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, iClampType); glError();\r
1924    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, iClampType); glError();\r
1925 \r
1926    if(!bUseFastMdec) \r
1927     {\r
1928      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glError();\r
1929      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glError();\r
1930     }\r
1931    else\r
1932     {\r
1933      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, iFilter); glError();\r
1934      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, iFilter); glError();\r
1935     }\r
1936                                  \r
1937    glTexImage2D(GL_TEXTURE_2D, 0, //giWantedRGBA, \r
1938                 GL_RGBA,\r
1939                 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, texturepart); glError();\r
1940   }\r
1941  else \r
1942   {\r
1943    gTexName=gTexMovieName;glBindTexture(GL_TEXTURE_2D, gTexName); glError();\r
1944   }\r
1945 \r
1946  glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,\r
1947                  (xrMovieArea.x1-xrMovieArea.x0), \r
1948                  (xrMovieArea.y1-xrMovieArea.y0), \r
1949                  GL_RGBA,\r
1950                  GL_UNSIGNED_SHORT,\r
1951                  texturepart); glError();\r
1952  //LOGE("DefinePackedTextureMovie x:%d y:%d",(xrMovieArea.x1-xrMovieArea.x0),(xrMovieArea.y1-xrMovieArea.y0));\r
1953 \r
1954 }\r
1955 \r
1956 ////////////////////////////////////////////////////////////////////////\r
1957 \r
1958 void DefineTextureMovie(void)\r
1959 {\r
1960  if(gTexMovieName==0)\r
1961   {\r
1962    glGenTextures(1, &gTexMovieName); glError();\r
1963    gTexName=gTexMovieName;\r
1964    glBindTexture(GL_TEXTURE_2D, gTexName); glError();\r
1965 \r
1966    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, iClampType); glError();\r
1967    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, iClampType); glError();\r
1968  \r
1969    if(!bUseFastMdec) \r
1970     {\r
1971      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glError();\r
1972      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glError();\r
1973     }\r
1974    else\r
1975     {\r
1976      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, iFilter); glError();\r
1977      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, iFilter); glError();\r
1978     }\r
1979 \r
1980    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, texturepart); glError();\r
1981   }\r
1982  else \r
1983   {\r
1984    gTexName=gTexMovieName;glBindTexture(GL_TEXTURE_2D, gTexName); glError();\r
1985   }\r
1986 \r
1987  glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,\r
1988                  (xrMovieArea.x1-xrMovieArea.x0), \r
1989                  (xrMovieArea.y1-xrMovieArea.y0), \r
1990                  GL_RGBA, GL_UNSIGNED_BYTE, texturepart); glError();\r
1991  //LOGE("DefineTextureMovie x:%d y:%d",(xrMovieArea.x1-xrMovieArea.x0),(xrMovieArea.y1-xrMovieArea.y0));\r
1992 }\r
1993 \r
1994 ////////////////////////////////////////////////////////////////////////\r
1995 // movie texture: load\r
1996 ////////////////////////////////////////////////////////////////////////\r
1997 \r
1998 #define MRED(x)   ((x>>3) & 0x1f)\r
1999 #define MGREEN(x) ((x>>6) & 0x3e0)\r
2000 #define MBLUE(x)  ((x>>9) & 0x7c00)\r
2001 \r
2002 #define XMGREEN(x) ((x>>5)  & 0x07c0)\r
2003 #define XMRED(x)   ((x<<8)  & 0xf800)\r
2004 #define XMBLUE(x)  ((x>>18) & 0x003e)\r
2005 \r
2006 ////////////////////////////////////////////////////////////////////////\r
2007 // movie texture: load\r
2008 ////////////////////////////////////////////////////////////////////////\r
2009 \r
2010 unsigned char * LoadDirectMovieFast(void)\r
2011 {\r
2012  long row,column;\r
2013  unsigned int startxy;\r
2014 \r
2015  unsigned long * ta=(unsigned long *)texturepart;\r
2016 \r
2017  if(PSXDisplay.RGB24)\r
2018   {\r
2019    unsigned char * pD;\r
2020 \r
2021    startxy=((1024)*xrMovieArea.y0)+xrMovieArea.x0;\r
2022 \r
2023    for(column=xrMovieArea.y0;column<xrMovieArea.y1;column++,startxy+=1024)\r
2024     {\r
2025      pD=(unsigned char *)&psxVuw[startxy];\r
2026      for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)\r
2027       {\r
2028        *ta++=*((unsigned long *)pD)|0xff000000;\r
2029        pD+=3;\r
2030       }\r
2031     }\r
2032   }\r
2033  else\r
2034   {\r
2035    unsigned long (*LTCOL)(unsigned long);\r
2036 \r
2037    LTCOL=XP8RGBA_0;//TCF[0];\r
2038 \r
2039    ubOpaqueDraw=0;\r
2040 \r
2041    for(column=xrMovieArea.y0;column<xrMovieArea.y1;column++)\r
2042     {\r
2043      startxy=((1024)*column)+xrMovieArea.x0;\r
2044      for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)\r
2045       *ta++=LTCOL(psxVuw[startxy++]|0x8000);\r
2046     }\r
2047   }\r
2048  \r
2049  return texturepart;\r
2050 }\r
2051 \r
2052 ////////////////////////////////////////////////////////////////////////\r
2053 \r
2054 GLuint LoadTextureMovieFast(void)\r
2055 {\r
2056  long row,column;\r
2057  unsigned int start,startxy;\r
2058 \r
2059 {\r
2060    if(PSXDisplay.RGB24)\r
2061     {\r
2062      unsigned char * pD;\r
2063      unsigned long * ta=(unsigned long *)texturepart;\r
2064 \r
2065      startxy=((1024)*xrMovieArea.y0)+xrMovieArea.x0;\r
2066 \r
2067      for(column=xrMovieArea.y0;column<xrMovieArea.y1;column++,startxy+=1024)\r
2068       {\r
2069        //startxy=((1024)*column)+xrMovieArea.x0;\r
2070        pD=(unsigned char *)&psxVuw[startxy];\r
2071        for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)\r
2072         {\r
2073          *ta++=*((unsigned long *)pD)|0xff000000;\r
2074          pD+=3;\r
2075         }\r
2076       }\r
2077     }\r
2078    else\r
2079     {\r
2080      unsigned long (*LTCOL)(unsigned long);\r
2081      unsigned long *ta;\r
2082 \r
2083      LTCOL=XP8RGBA_0;//TCF[0];\r
2084 \r
2085      ubOpaqueDraw=0;\r
2086      ta=(unsigned long *)texturepart;\r
2087 \r
2088      for(column=xrMovieArea.y0;column<xrMovieArea.y1;column++)\r
2089       {\r
2090        startxy=((1024)*column)+xrMovieArea.x0;\r
2091        for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)\r
2092         *ta++=LTCOL(psxVuw[startxy++]|0x8000);\r
2093       }\r
2094     }\r
2095    DefineTextureMovie();\r
2096   }\r
2097  return gTexName;   \r
2098 }\r
2099 \r
2100 ////////////////////////////////////////////////////////////////////////\r
2101 \r
2102 GLuint LoadTextureMovie(void)\r
2103 {\r
2104  short row,column,dx;\r
2105  unsigned int startxy;\r
2106  BOOL b_X,b_Y;\r
2107 \r
2108  if(bUseFastMdec) return LoadTextureMovieFast();\r
2109 \r
2110  b_X=FALSE;b_Y=FALSE;\r
2111 \r
2112  if((xrMovieArea.x1-xrMovieArea.x0)<255)  b_X=TRUE;\r
2113  if((xrMovieArea.y1-xrMovieArea.y0)<255)  b_Y=TRUE;\r
2114 \r
2115 {\r
2116    if(PSXDisplay.RGB24)\r
2117     {\r
2118      unsigned char * pD;\r
2119      unsigned long * ta=(unsigned long *)texturepart;\r
2120 \r
2121      if(b_X)\r
2122       {\r
2123        for(column=xrMovieArea.y0;column<xrMovieArea.y1;column++)\r
2124         {\r
2125          startxy=((1024)*column)+xrMovieArea.x0;\r
2126          pD=(unsigned char *)&psxVuw[startxy];\r
2127          for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)\r
2128           {\r
2129            *ta++=*((unsigned long *)pD)|0xff000000;\r
2130            pD+=3;\r
2131           }\r
2132          *ta++=*(ta-1);\r
2133         }\r
2134        if(b_Y)\r
2135         {\r
2136          dx=xrMovieArea.x1-xrMovieArea.x0+1;\r
2137          for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)\r
2138           *ta++=*(ta-dx);\r
2139          *ta++=*(ta-1);\r
2140         }\r
2141       }\r
2142      else\r
2143       {\r
2144        for(column=xrMovieArea.y0;column<xrMovieArea.y1;column++)\r
2145         {\r
2146          startxy=((1024)*column)+xrMovieArea.x0;\r
2147          pD=(unsigned char *)&psxVuw[startxy];\r
2148          for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)\r
2149           {\r
2150            *ta++=*((unsigned long *)pD)|0xff000000;\r
2151            pD+=3;\r
2152           }\r
2153         }\r
2154        if(b_Y)\r
2155         {\r
2156          dx=xrMovieArea.x1-xrMovieArea.x0;\r
2157          for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)\r
2158           *ta++=*(ta-dx);\r
2159         }\r
2160       }\r
2161     }\r
2162    else\r
2163     {\r
2164      unsigned long (*LTCOL)(unsigned long);\r
2165      unsigned long *ta;\r
2166 \r
2167      LTCOL=XP8RGBA_0;//TCF[0];\r
2168 \r
2169      ubOpaqueDraw=0;\r
2170      ta=(unsigned long *)texturepart;\r
2171 \r
2172      if(b_X)\r
2173       {\r
2174        for(column=xrMovieArea.y0;column<xrMovieArea.y1;column++)\r
2175         {\r
2176          startxy=((1024)*column)+xrMovieArea.x0;\r
2177          for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)\r
2178           *ta++=LTCOL(psxVuw[startxy++]|0x8000);\r
2179          *ta++=*(ta-1);\r
2180         }\r
2181 \r
2182        if(b_Y)\r
2183         {\r
2184          dx=xrMovieArea.x1-xrMovieArea.x0+1;\r
2185          for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)\r
2186           *ta++=*(ta-dx);\r
2187          *ta++=*(ta-1);\r
2188         }\r
2189       }\r
2190      else\r
2191       {\r
2192        for(column=xrMovieArea.y0;column<xrMovieArea.y1;column++)\r
2193         {\r
2194          startxy=((1024)*column)+xrMovieArea.x0;\r
2195          for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)\r
2196           *ta++=LTCOL(psxVuw[startxy++]|0x8000);\r
2197         }\r
2198 \r
2199        if(b_Y)\r
2200         {\r
2201          dx=xrMovieArea.x1-xrMovieArea.x0;\r
2202          for(row=xrMovieArea.x0;row<xrMovieArea.x1;row++)\r
2203           *ta++=*(ta-dx);\r
2204         }\r
2205       }\r
2206     }\r
2207 \r
2208    xrMovieArea.x1+=b_X;xrMovieArea.y1+=b_Y;\r
2209    DefineTextureMovie();\r
2210    xrMovieArea.x1-=b_X;xrMovieArea.y1-=b_Y;\r
2211   }\r
2212  return gTexName;   \r
2213 }\r
2214 \r
2215 /////////////////////////////////////////////////////////////////////////////\r
2216 /////////////////////////////////////////////////////////////////////////////\r
2217 /////////////////////////////////////////////////////////////////////////////\r
2218 \r
2219 GLuint BlackFake15BitTexture(void)\r
2220 {\r
2221  long pmult;short x1,x2,y1,y2;\r
2222 \r
2223  if(PSXDisplay.InterlacedTest) return 0;\r
2224  \r
2225  pmult=GlobalTexturePage/16;\r
2226  x1=gl_ux[7];\r
2227  x2=gl_ux[6]-gl_ux[7];\r
2228  y1=gl_ux[5];\r
2229  y2=gl_ux[4]-gl_ux[5];\r
2230 \r
2231  if(iSpriteTex)\r
2232   {\r
2233    if(x2<255) x2++;\r
2234    if(y2<255) y2++;\r
2235   }\r
2236 \r
2237  y1+=pmult*256;\r
2238  x1+=((GlobalTexturePage-16*pmult)<<6);\r
2239 \r
2240  if(   FastCheckAgainstFrontScreen(x1,y1,x2,y2)\r
2241     || FastCheckAgainstScreen(x1,y1,x2,y2))\r
2242   {\r
2243    if(!gTexFrameName)\r
2244     {\r
2245      glGenTextures(1, &gTexFrameName); glError();\r
2246      gTexName=gTexFrameName;\r
2247      glBindTexture(GL_TEXTURE_2D, gTexName); glError();\r
2248 \r
2249      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, iClampType); glError();\r
2250      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, iClampType); glError();\r
2251      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, iFilter); glError();\r
2252      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, iFilter); glError();\r
2253  \r
2254      {\r
2255        unsigned long * ta=(unsigned long *)texturepart;\r
2256        for(y1=0;y1<=4;y1++)\r
2257         for(x1=0;x1<=4;x1++)\r
2258          *ta++=0xff000000;\r
2259       }\r
2260      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, texturepart); glError();\r
2261 \r
2262     }\r
2263    else\r
2264     {\r
2265      gTexName=gTexFrameName;\r
2266      glBindTexture(GL_TEXTURE_2D, gTexName); glError();\r
2267     }\r
2268       //LOGE("BlackFake15BitTexture x:%d y:%d",4,4);\r
2269    ubOpaqueDraw=0;\r
2270 \r
2271    return (GLuint)gTexName;\r
2272   }\r
2273  return 0;\r
2274 }\r
2275 \r
2276 /////////////////////////////////////////////////////////////////////////////\r
2277 \r
2278 BOOL bFakeFrontBuffer=FALSE;\r
2279 BOOL bIgnoreNextTile =FALSE;\r
2280 \r
2281 int iFTex=512;\r
2282 \r
2283 GLuint Fake15BitTexture(void)\r
2284 {\r
2285  long pmult;short x1,x2,y1,y2;int iYAdjust;\r
2286  float ScaleX,ScaleY;RECT rSrc;\r
2287 \r
2288  if(iFrameTexType==1) return BlackFake15BitTexture();\r
2289  if(PSXDisplay.InterlacedTest) return 0;\r
2290  \r
2291  pmult=GlobalTexturePage/16;\r
2292  x1=gl_ux[7];\r
2293  x2=gl_ux[6]-gl_ux[7];\r
2294  y1=gl_ux[5];\r
2295  y2=gl_ux[4]-gl_ux[5];\r
2296 \r
2297  y1+=pmult*256;\r
2298  x1+=((GlobalTexturePage-16*pmult)<<6);\r
2299 \r
2300  if(iFrameTexType==3)\r
2301   {\r
2302    if(iFrameReadType==4) return 0;\r
2303 \r
2304    if(!FastCheckAgainstFrontScreen(x1,y1,x2,y2) &&\r
2305       !FastCheckAgainstScreen(x1,y1,x2,y2))\r
2306     return 0;\r
2307 \r
2308    if(bFakeFrontBuffer) bIgnoreNextTile=TRUE;\r
2309    CheckVRamReadEx(x1,y1,x1+x2,y1+y2);\r
2310    return 0;\r
2311   }\r
2312 \r
2313  /////////////////////////\r
2314 \r
2315  if(FastCheckAgainstFrontScreen(x1,y1,x2,y2))\r
2316   {\r
2317    x1-=PSXDisplay.DisplayPosition.x;\r
2318    y1-=PSXDisplay.DisplayPosition.y;\r
2319   }\r
2320  else\r
2321  if(FastCheckAgainstScreen(x1,y1,x2,y2))\r
2322   {\r
2323    x1-=PreviousPSXDisplay.DisplayPosition.x;\r
2324    y1-=PreviousPSXDisplay.DisplayPosition.y;\r
2325   }\r
2326  else return 0;\r
2327 \r
2328  bDrawMultiPass = FALSE;\r
2329 \r
2330  if(!gTexFrameName)\r
2331   {\r
2332    char * p;\r
2333 \r
2334    if(iResX>1280 || iResY>1024) iFTex=2048;\r
2335    else\r
2336    if(iResX>640  || iResY>480)  iFTex=1024;\r
2337    else                         iFTex=512; \r
2338 \r
2339    glGenTextures(1, &gTexFrameName); glError();\r
2340    gTexName=gTexFrameName;\r
2341    glBindTexture(GL_TEXTURE_2D, gTexName); glError();\r
2342 \r
2343    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, iClampType); glError();\r
2344    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, iClampType); glError();\r
2345    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, iFilter); glError();\r
2346    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, iFilter); glError();\r
2347 \r
2348    p=(char *)malloc(iFTex*iFTex*4);\r
2349    memset(p,0,iFTex*iFTex*4);\r
2350    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, iFTex, iFTex, 0, GL_RGBA, GL_UNSIGNED_BYTE, p); glError();\r
2351    free(p);\r
2352 \r
2353    glGetError();\r
2354   }\r
2355  else \r
2356   {\r
2357    gTexName=gTexFrameName;\r
2358    glBindTexture(GL_TEXTURE_2D, gTexName); glError();\r
2359   }\r
2360       //LOGE("Fake15BitTexture x:%d y:%d",iFTex,iFTex);\r
2361  x1+=PreviousPSXDisplay.Range.x0;\r
2362  y1+=PreviousPSXDisplay.Range.y0;\r
2363 \r
2364  if(PSXDisplay.DisplayMode.x)\r
2365       ScaleX=(float)rRatioRect.right/(float)PSXDisplay.DisplayMode.x;\r
2366  else ScaleX=1.0f;\r
2367  if(PSXDisplay.DisplayMode.y)\r
2368       ScaleY=(float)rRatioRect.bottom/(float)PSXDisplay.DisplayMode.y;\r
2369  else ScaleY=1.0f;\r
2370 \r
2371  rSrc.left  =max(x1*ScaleX,0);\r
2372  rSrc.right =min((x1+x2)*ScaleX+0.99f,iResX-1);\r
2373  rSrc.top   =max(y1*ScaleY,0);\r
2374  rSrc.bottom=min((y1+y2)*ScaleY+0.99f,iResY-1);\r
2375 \r
2376  iYAdjust=(y1+y2)-PSXDisplay.DisplayMode.y;\r
2377  if(iYAdjust>0)\r
2378       iYAdjust=(int)((float)iYAdjust*ScaleY)+1;\r
2379  else iYAdjust=0;\r
2380           \r
2381  gl_vy[0]=255-gl_vy[0];\r
2382  gl_vy[1]=255-gl_vy[1];\r
2383  gl_vy[2]=255-gl_vy[2];\r
2384  gl_vy[3]=255-gl_vy[3];\r
2385 \r
2386  y1=min(gl_vy[0],min(gl_vy[1],min(gl_vy[2],gl_vy[3])));\r
2387 \r
2388  gl_vy[0]-=y1;\r
2389  gl_vy[1]-=y1;\r
2390  gl_vy[2]-=y1;\r
2391  gl_vy[3]-=y1;\r
2392  gl_ux[0]-=gl_ux[7];\r
2393  gl_ux[1]-=gl_ux[7];\r
2394  gl_ux[2]-=gl_ux[7];\r
2395  gl_ux[3]-=gl_ux[7];\r
2396 \r
2397  ScaleX*=256.0f/((float)(iFTex));\r
2398  ScaleY*=256.0f/((float)(iFTex));\r
2399 \r
2400  y1=((float)gl_vy[0]*ScaleY); if(y1>255) y1=255;\r
2401  gl_vy[0]=y1;\r
2402  y1=((float)gl_vy[1]*ScaleY); if(y1>255) y1=255;\r
2403  gl_vy[1]=y1;\r
2404  y1=((float)gl_vy[2]*ScaleY); if(y1>255) y1=255;\r
2405  gl_vy[2]=y1;\r
2406  y1=((float)gl_vy[3]*ScaleY); if(y1>255) y1=255;\r
2407  gl_vy[3]=y1;\r
2408 \r
2409  x1=((float)gl_ux[0]*ScaleX); if(x1>255) x1=255;\r
2410  gl_ux[0]=x1;\r
2411  x1=((float)gl_ux[1]*ScaleX); if(x1>255) x1=255;\r
2412  gl_ux[1]=x1;\r
2413  x1=((float)gl_ux[2]*ScaleX); if(x1>255) x1=255;\r
2414  gl_ux[2]=x1;\r
2415  x1=((float)gl_ux[3]*ScaleX); if(x1>255) x1=255;\r
2416  gl_ux[3]=x1;\r
2417 \r
2418  x1=rSrc.right-rSrc.left;\r
2419  if(x1<=0)             x1=1;\r
2420  if(x1>iFTex)          x1=iFTex;\r
2421 \r
2422  y1=rSrc.bottom-rSrc.top;\r
2423  if(y1<=0)             y1=1;\r
2424  if(y1+iYAdjust>iFTex) y1=iFTex-iYAdjust;\r
2425 \r
2426 \r
2427  glCopyTexSubImage2D( GL_TEXTURE_2D, 0, \r
2428                       0,\r
2429                       iYAdjust,\r
2430                       rSrc.left+rRatioRect.left,\r
2431                       iResY-rSrc.bottom-rRatioRect.top,\r
2432                       x1,y1); glError();\r
2433 \r
2434  if(glGetError()) \r
2435   {\r
2436    char * p=(char *)malloc(iFTex*iFTex*4);\r
2437    memset(p,0,iFTex*iFTex*4);\r
2438    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, iFTex, iFTex,\r
2439                    GL_RGBA, GL_UNSIGNED_BYTE, p); glError();\r
2440    free(p);\r
2441   }\r
2442 \r
2443  \r
2444  ubOpaqueDraw=0;\r
2445 \r
2446  if(iSpriteTex)\r
2447   {\r
2448    sprtW=gl_ux[1]-gl_ux[0];    \r
2449    sprtH=-(gl_vy[0]-gl_vy[2]);\r
2450   }\r
2451 \r
2452  return (GLuint)gTexName;\r
2453 }\r
2454 \r
2455 /////////////////////////////////////////////////////////////////////////////\r
2456 /////////////////////////////////////////////////////////////////////////////\r
2457 /////////////////////////////////////////////////////////////////////////////\r
2458 //\r
2459 // load texture part (unpacked)\r
2460 //\r
2461 /////////////////////////////////////////////////////////////////////////////\r
2462 /////////////////////////////////////////////////////////////////////////////\r
2463 /////////////////////////////////////////////////////////////////////////////\r
2464 \r
2465 void LoadSubTexturePageSort(int pageid, int mode, short cx, short cy)\r
2466 {\r
2467  unsigned long  start,row,column,j,sxh,sxm;\r
2468  unsigned int   palstart;\r
2469  unsigned long  *px,*pa,*ta;\r
2470  unsigned char  *cSRCPtr;\r
2471  unsigned short *wSRCPtr;\r
2472  unsigned long  LineOffset;\r
2473  unsigned long  x2a,xalign=0;\r
2474  unsigned long  x1=gl_ux[7];\r
2475  unsigned long  x2=gl_ux[6];\r
2476  unsigned long  y1=gl_ux[5];\r
2477  unsigned long  y2=gl_ux[4];\r
2478  unsigned long  dx=x2-x1+1;\r
2479  unsigned long  dy=y2-y1+1;\r
2480  int pmult=pageid/16;\r
2481  unsigned long (*LTCOL)(unsigned long);\r
2482  unsigned int a,r,g,b,cnt,h;\r
2483  unsigned long scol[8];\r
2484  \r
2485  LTCOL=TCF[DrawSemiTrans];\r
2486 \r
2487  pa=px=(unsigned long *)ubPaletteBuffer;\r
2488  ta=(unsigned long *)texturepart;\r
2489  palstart=cx+(cy<<10);\r
2490 \r
2491  ubOpaqueDraw=0;\r
2492 \r
2493  if(YTexS) {ta+=dx;if(XTexS) ta+=2;}\r
2494  if(XTexS) {ta+=1;xalign=2;}\r
2495 \r
2496  switch(mode)\r
2497   {\r
2498    //--------------------------------------------------// \r
2499    // 4bit texture load ..\r
2500    case 0:\r
2501     if(GlobalTextIL)\r
2502      {\r
2503       unsigned int TXV,TXU,n_xi,n_yi;\r
2504 \r
2505       wSRCPtr=psxVuw+palstart;\r
2506 \r
2507       row=4;do\r
2508        {\r
2509         *px    =LTCOL(*wSRCPtr);\r
2510         *(px+1)=LTCOL(*(wSRCPtr+1));\r
2511         *(px+2)=LTCOL(*(wSRCPtr+2));\r
2512         *(px+3)=LTCOL(*(wSRCPtr+3));\r
2513         row--;px+=4;wSRCPtr+=4;\r
2514        }\r
2515       while (row);\r
2516 \r
2517       for(TXV=y1;TXV<=y2;TXV++)\r
2518        {\r
2519         for(TXU=x1;TXU<=x2;TXU++)\r
2520          {\r
2521                   n_xi = ( ( TXU >> 2 ) & ~0x3c ) + ( ( TXV << 2 ) & 0x3c );\r
2522                   n_yi = ( TXV & ~0xf ) + ( ( TXU >> 4 ) & 0xf );\r
2523 \r
2524           *ta++=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x03 ) << 2 ) ) & 0x0f ));\r
2525          }\r
2526         ta+=xalign;\r
2527        }\r
2528       break;\r
2529      }\r
2530 \r
2531     start=((pageid-16*pmult)<<7)+524288*pmult;\r
2532     // convert CLUT to 32bits .. and then use THAT as a lookup table\r
2533 \r
2534     wSRCPtr=psxVuw+palstart;\r
2535 \r
2536     row=4;do\r
2537      {\r
2538       *px    =LTCOL(*wSRCPtr);\r
2539       *(px+1)=LTCOL(*(wSRCPtr+1));\r
2540       *(px+2)=LTCOL(*(wSRCPtr+2));\r
2541       *(px+3)=LTCOL(*(wSRCPtr+3));\r
2542       row--;px+=4;wSRCPtr+=4;\r
2543      }\r
2544     while (row);\r
2545 \r
2546     x2a=x2?(x2-1):0;//if(x2) x2a=x2-1; else x2a=0;\r
2547     sxm=x1&1;sxh=x1>>1;\r
2548     j=sxm?(x1+1):x1;//if(sxm) j=x1+1; else j=x1;\r
2549     for(column=y1;column<=y2;column++)\r
2550      {\r
2551       cSRCPtr = psxVub + start + (column<<11) + sxh;\r
2552     \r
2553       if(sxm) *ta++=*(pa+((*cSRCPtr++ >> 4) & 0xF));\r
2554 \r
2555       for(row=j;row<x2a;row+=2)\r
2556        {\r
2557         *ta    =*(pa+(*cSRCPtr & 0xF)); \r
2558         *(ta+1)=*(pa+((*cSRCPtr >> 4) & 0xF)); \r
2559         cSRCPtr++;ta+=2;\r
2560        }\r
2561 \r
2562       if(row<=x2) \r
2563        {\r
2564         *ta++=*(pa+(*cSRCPtr & 0xF)); row++;\r
2565         if(row<=x2) *ta++=*(pa+((*cSRCPtr >> 4) & 0xF));\r
2566        }\r
2567 \r
2568       ta+=xalign;\r
2569      }\r
2570 \r
2571     break;\r
2572    //--------------------------------------------------// \r
2573    // 8bit texture load ..\r
2574    case 1:\r
2575     if(GlobalTextIL)\r
2576      {\r
2577       unsigned int TXV,TXU,n_xi,n_yi;\r
2578 \r
2579       wSRCPtr=psxVuw+palstart;\r
2580 \r
2581       row=64;do\r
2582        {\r
2583         *px    =LTCOL(*wSRCPtr);\r
2584         *(px+1)=LTCOL(*(wSRCPtr+1));\r
2585         *(px+2)=LTCOL(*(wSRCPtr+2));\r
2586         *(px+3)=LTCOL(*(wSRCPtr+3));\r
2587         row--;px+=4;wSRCPtr+=4;\r
2588        }\r
2589       while (row);\r
2590 \r
2591       for(TXV=y1;TXV<=y2;TXV++)\r
2592        {\r
2593         for(TXU=x1;TXU<=x2;TXU++)\r
2594          {\r
2595                   n_xi = ( ( TXU >> 1 ) & ~0x78 ) + ( ( TXU << 2 ) & 0x40 ) + ( ( TXV << 3 ) & 0x38 );\r
2596                   n_yi = ( TXV & ~0x7 ) + ( ( TXU >> 5 ) & 0x7 );\r
2597 \r
2598           *ta++=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x01 ) << 3 ) ) & 0xff));\r
2599          }\r
2600         ta+=xalign;\r
2601        }\r
2602 \r
2603       break;\r
2604      }\r
2605 \r
2606     start=((pageid-16*pmult)<<7)+524288*pmult;\r
2607 \r
2608     cSRCPtr = psxVub + start + (y1<<11) + x1;\r
2609     LineOffset = 2048 - dx; \r
2610 \r
2611     if(dy*dx>384)\r
2612      {\r
2613       wSRCPtr=psxVuw+palstart;\r
2614 \r
2615       row=64;do\r
2616        {\r
2617         *px    =LTCOL(*wSRCPtr);\r
2618         *(px+1)=LTCOL(*(wSRCPtr+1));\r
2619         *(px+2)=LTCOL(*(wSRCPtr+2));\r
2620         *(px+3)=LTCOL(*(wSRCPtr+3));\r
2621         row--;px+=4;wSRCPtr+=4;\r
2622        }\r
2623       while (row);\r
2624 \r
2625       column=dy;do \r
2626        {\r
2627         row=dx;\r
2628         do {*ta++=*(pa+(*cSRCPtr++));row--;} while(row);\r
2629         ta+=xalign;\r
2630         cSRCPtr+=LineOffset;column--;\r
2631        }\r
2632       while(column);\r
2633      }\r
2634     else\r
2635      {\r
2636       wSRCPtr=psxVuw+palstart;\r
2637 \r
2638       column=dy;do \r
2639        {\r
2640         row=dx;\r
2641         do {*ta++=LTCOL(*(wSRCPtr+*cSRCPtr++));row--;} while(row);\r
2642         ta+=xalign;\r
2643         cSRCPtr+=LineOffset;column--;\r
2644        }\r
2645       while(column);\r
2646      }\r
2647 \r
2648     break;\r
2649    //--------------------------------------------------// \r
2650    // 16bit texture load ..\r
2651    case 2:\r
2652     start=((pageid-16*pmult)<<6)+262144*pmult;\r
2653 \r
2654     wSRCPtr = psxVuw + start + (y1<<10) + x1;\r
2655     LineOffset = 1024 - dx; \r
2656 \r
2657     column=dy;do \r
2658      {\r
2659       row=dx;\r
2660       do {*ta++=LTCOL(*wSRCPtr++);row--;} while(row);\r
2661       ta+=xalign;\r
2662       wSRCPtr+=LineOffset;column--;\r
2663      }\r
2664     while(column);\r
2665 \r
2666     break;\r
2667    //--------------------------------------------------//\r
2668    // others are not possible !\r
2669   }\r
2670 \r
2671  x2a=dx+xalign;\r
2672 \r
2673  if(YTexS)\r
2674   {\r
2675    ta=(unsigned long *)texturepart;\r
2676    pa=(unsigned long *)texturepart+x2a;\r
2677    row=x2a;do {*ta++=*pa++;row--;} while(row);        \r
2678    pa=(unsigned long *)texturepart+dy*x2a;\r
2679    ta=pa+x2a;\r
2680    row=x2a;do {*ta++=*pa++;row--;} while(row);\r
2681    YTexS--;\r
2682    dy+=2;\r
2683   }\r
2684 \r
2685  if(XTexS)\r
2686   {\r
2687    ta=(unsigned long *)texturepart;\r
2688    pa=ta+1;\r
2689    row=dy;do {*ta=*pa;ta+=x2a;pa+=x2a;row--;} while(row);\r
2690    pa=(unsigned long *)texturepart+dx;\r
2691    ta=pa+1;\r
2692    row=dy;do {*ta=*pa;ta+=x2a;pa+=x2a;row--;} while(row);\r
2693    XTexS--;\r
2694    dx+=2;\r
2695   }\r
2696 \r
2697  DXTexS=dx;DYTexS=dy;\r
2698 \r
2699  if(!iFilterType) {DefineSubTextureSort();return;}\r
2700  if(iFilterType!=2 && iFilterType!=4 && iFilterType!=6) {DefineSubTextureSort();return;}\r
2701  if((iFilterType==4 || iFilterType==6) && ly0==ly1 && ly2==ly3 && lx0==lx3 && lx1==lx2)\r
2702   {DefineSubTextureSort();return;}\r
2703 \r
2704  ta=(unsigned long *)texturepart;\r
2705  x1=dx-1;\r
2706  y1=dy-1;\r
2707 \r
2708  if(bOpaquePass)\r
2709   {\r
2710 {\r
2711      for(column=0;column<dy;column++)\r
2712       {\r
2713        for(row=0;row<dx;row++)\r
2714         {\r
2715          if(*ta==0x50000000)\r
2716           {\r
2717            cnt=0;\r
2718 \r
2719            if(           column     && *(ta-dx)  !=0x50000000 && *(ta-dx)>>24!=1) scol[cnt++]=*(ta-dx);\r
2720            if(row                   && *(ta-1)   !=0x50000000 && *(ta-1)>>24!=1) scol[cnt++]=*(ta-1);\r
2721            if(row!=x1               && *(ta+1)   !=0x50000000 && *(ta+1)>>24!=1) scol[cnt++]=*(ta+1);\r
2722            if(           column!=y1 && *(ta+dx)  !=0x50000000 && *(ta+dx)>>24!=1) scol[cnt++]=*(ta+dx);\r
2723 \r
2724            if(row     && column     && *(ta-dx-1)!=0x50000000 && *(ta-dx-1)>>24!=1) scol[cnt++]=*(ta-dx-1);\r
2725            if(row!=x1 && column     && *(ta-dx+1)!=0x50000000 && *(ta-dx+1)>>24!=1) scol[cnt++]=*(ta-dx+1);\r
2726            if(row     && column!=y1 && *(ta+dx-1)!=0x50000000 && *(ta+dx-1)>>24!=1) scol[cnt++]=*(ta+dx-1);\r
2727            if(row!=x1 && column!=y1 && *(ta+dx+1)!=0x50000000 && *(ta+dx+1)>>24!=1) scol[cnt++]=*(ta+dx+1);\r
2728 \r
2729            if(cnt)\r
2730             {\r
2731              r=g=b=a=0;\r
2732              for(h=0;h<cnt;h++)\r
2733               {\r
2734                a+=(scol[h]>>24);\r
2735                r+=(scol[h]>>16)&0xff;\r
2736                g+=(scol[h]>>8)&0xff;\r
2737                b+=scol[h]&0xff;\r
2738               }\r
2739              r/=cnt;b/=cnt;g/=cnt;\r
2740 \r
2741              *ta=(r<<16)|(g<<8)|b;\r
2742              if(a) *ta|=0x50000000;\r
2743              else  *ta|=0x01000000;\r
2744             }\r
2745           }\r
2746          ta++;\r
2747         }\r
2748       }\r
2749     }\r
2750   }\r
2751  else\r
2752  for(column=0;column<dy;column++)\r
2753   {\r
2754    for(row=0;row<dx;row++)\r
2755     {\r
2756      if(*ta==0x00000000)\r
2757       {\r
2758        cnt=0;\r
2759 \r
2760        if(row!=x1               && *(ta+1)   !=0x00000000) scol[cnt++]=*(ta+1);\r
2761        if(           column!=y1 && *(ta+dx)  !=0x00000000) scol[cnt++]=*(ta+dx);\r
2762 \r
2763        if(cnt)\r
2764         {\r
2765          r=g=b=0;\r
2766          for(h=0;h<cnt;h++)\r
2767           {\r
2768            r+=(scol[h]>>16)&0xff;\r
2769            g+=(scol[h]>>8)&0xff;\r
2770            b+=scol[h]&0xff;\r
2771           }\r
2772          r/=cnt;b/=cnt;g/=cnt;\r
2773          *ta=(r<<16)|(g<<8)|b;\r
2774         }\r
2775       }\r
2776      ta++;\r
2777     }\r
2778   }\r
2779 \r
2780  DefineSubTextureSort();\r
2781 }\r
2782 \r
2783 /////////////////////////////////////////////////////////////////////////////\r
2784 /////////////////////////////////////////////////////////////////////////////\r
2785 /////////////////////////////////////////////////////////////////////////////\r
2786 //\r
2787 // load texture part (packed)\r
2788 //\r
2789 /////////////////////////////////////////////////////////////////////////////\r
2790 /////////////////////////////////////////////////////////////////////////////\r
2791 /////////////////////////////////////////////////////////////////////////////\r
2792 \r
2793 void LoadPackedSubTexturePageSort(int pageid, int mode, short cx, short cy)\r
2794 {\r
2795  unsigned long  start,row,column,j,sxh,sxm;\r
2796  unsigned int   palstart;\r
2797  unsigned short *px,*pa,*ta;\r
2798  unsigned char  *cSRCPtr;\r
2799  unsigned short *wSRCPtr;\r
2800  unsigned long  LineOffset;\r
2801  unsigned long  x2a,xalign=0;\r
2802  unsigned long  x1=gl_ux[7];\r
2803  unsigned long  x2=gl_ux[6];\r
2804  unsigned long  y1=gl_ux[5];\r
2805  unsigned long  y2=gl_ux[4];\r
2806  unsigned long  dx=x2-x1+1;\r
2807  unsigned long  dy=y2-y1+1;\r
2808  int pmult=pageid/16;\r
2809  unsigned short (*LPTCOL)(unsigned short);\r
2810  unsigned int a,r,g,b,cnt,h;\r
2811  unsigned short scol[8];\r
2812 \r
2813  LPTCOL=PTCF[DrawSemiTrans];\r
2814 \r
2815  pa=px=(unsigned short *)ubPaletteBuffer;\r
2816  ta=(unsigned short *)texturepart;\r
2817  palstart=cx+(cy<<10);\r
2818 \r
2819  ubOpaqueDraw=0;\r
2820 \r
2821  if(YTexS) {ta+=dx;if(XTexS) ta+=2;}\r
2822  if(XTexS) {ta+=1;xalign=2;}\r
2823 \r
2824  switch(mode)\r
2825   {\r
2826    //--------------------------------------------------// \r
2827    // 4bit texture load ..\r
2828    case 0:\r
2829     if(GlobalTextIL)\r
2830      {\r
2831       unsigned int TXV,TXU,n_xi,n_yi;\r
2832 \r
2833       wSRCPtr=psxVuw+palstart;\r
2834       row=4;do\r
2835        {\r
2836         *px    =LPTCOL(*wSRCPtr);\r
2837         *(px+1)=LPTCOL(*(wSRCPtr+1));\r
2838         *(px+2)=LPTCOL(*(wSRCPtr+2));\r
2839         *(px+3)=LPTCOL(*(wSRCPtr+3));\r
2840         row--;px+=4;wSRCPtr+=4;\r
2841        }\r
2842       while (row);\r
2843 \r
2844       for(TXV=y1;TXV<=y2;TXV++)\r
2845        {\r
2846         for(TXU=x1;TXU<=x2;TXU++)\r
2847          {\r
2848                   n_xi = ( ( TXU >> 2 ) & ~0x3c ) + ( ( TXV << 2 ) & 0x3c );\r
2849                   n_yi = ( TXV & ~0xf ) + ( ( TXU >> 4 ) & 0xf );\r
2850 \r
2851           *ta++=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x03 ) << 2 ) ) & 0x0f ));\r
2852          }\r
2853         ta+=xalign;\r
2854        }\r
2855       break;\r
2856      }\r
2857 \r
2858     start=((pageid-16*pmult)<<7)+524288*pmult;\r
2859 \r
2860     wSRCPtr=psxVuw+palstart;\r
2861     row=4;do\r
2862      {\r
2863       *px    =LPTCOL(*wSRCPtr);\r
2864       *(px+1)=LPTCOL(*(wSRCPtr+1));\r
2865       *(px+2)=LPTCOL(*(wSRCPtr+2));\r
2866       *(px+3)=LPTCOL(*(wSRCPtr+3));\r
2867       row--;px+=4;wSRCPtr+=4;\r
2868      }\r
2869     while (row);\r
2870 \r
2871     x2a=x2?(x2-1):0;//if(x2) x2a=x2-1; else x2a=0;\r
2872     sxm=x1&1;sxh=x1>>1;\r
2873     j=sxm?(x1+1):x1;//if(sxm) j=x1+1; else j=x1;\r
2874 \r
2875     for(column=y1;column<=y2;column++)\r
2876      {\r
2877       cSRCPtr = psxVub + start + (column<<11) + sxh;\r
2878     \r
2879       if(sxm) *ta++=*(pa+((*cSRCPtr++ >> 4) & 0xF));\r
2880  \r
2881       for(row=j;row<x2a;row+=2)\r
2882        {\r
2883         *ta    =*(pa+(*cSRCPtr & 0xF));\r
2884         *(ta+1)=*(pa+((*cSRCPtr >> 4) & 0xF)); \r
2885         cSRCPtr++;ta+=2;\r
2886        }\r
2887 \r
2888       if(row<=x2)\r
2889        {\r
2890         *ta++=*(pa+(*cSRCPtr & 0xF));row++;\r
2891         if(row<=x2) *ta++=*(pa+((*cSRCPtr >> 4) & 0xF));\r
2892        }\r
2893 \r
2894       ta+=xalign;\r
2895      }\r
2896     break;\r
2897    //--------------------------------------------------// \r
2898    // 8bit texture load ..\r
2899    case 1:\r
2900     if(GlobalTextIL)\r
2901      {\r
2902       unsigned int TXV,TXU,n_xi,n_yi;\r
2903 \r
2904       wSRCPtr=psxVuw+palstart;\r
2905 \r
2906       row=64;do\r
2907        {\r
2908         *px    =LPTCOL(*wSRCPtr);\r
2909         *(px+1)=LPTCOL(*(wSRCPtr+1));\r
2910         *(px+2)=LPTCOL(*(wSRCPtr+2));\r
2911         *(px+3)=LPTCOL(*(wSRCPtr+3));\r
2912         row--;px+=4;wSRCPtr+=4;\r
2913        }\r
2914       while (row);\r
2915 \r
2916       for(TXV=y1;TXV<=y2;TXV++)\r
2917        {\r
2918         for(TXU=x1;TXU<=x2;TXU++)\r
2919          {\r
2920                   n_xi = ( ( TXU >> 1 ) & ~0x78 ) + ( ( TXU << 2 ) & 0x40 ) + ( ( TXV << 3 ) & 0x38 );\r
2921                   n_yi = ( TXV & ~0x7 ) + ( ( TXU >> 5 ) & 0x7 );\r
2922 \r
2923           *ta++=*(pa+((*( psxVuw + ((GlobalTextAddrY + n_yi)*1024) + GlobalTextAddrX + n_xi ) >> ( ( TXU & 0x01 ) << 3 ) ) & 0xff));\r
2924          }\r
2925         ta+=xalign;\r
2926        }\r
2927 \r
2928       break;\r
2929      }\r
2930 \r
2931     start=((pageid-16*pmult)<<7)+524288*pmult;\r
2932 \r
2933     cSRCPtr = psxVub + start + (y1<<11) + x1;\r
2934     LineOffset = 2048 - dx;\r
2935 \r
2936     if(dy*dx>384)                                      // more pix? use lut\r
2937      {\r
2938       wSRCPtr=psxVuw+palstart;\r
2939 \r
2940       row=64;do\r
2941        {\r
2942         *px    =LPTCOL(*wSRCPtr);\r
2943         *(px+1)=LPTCOL(*(wSRCPtr+1));\r
2944         *(px+2)=LPTCOL(*(wSRCPtr+2));\r
2945         *(px+3)=LPTCOL(*(wSRCPtr+3));\r
2946         row--;px+=4;wSRCPtr+=4;\r
2947        }\r
2948       while (row);\r
2949 \r
2950       column=dy;do \r
2951        {\r
2952         row=dx;\r
2953         do {*ta++=*(pa+(*cSRCPtr++));row--;} while(row);\r
2954 \r
2955         ta+=xalign;\r
2956 \r
2957         cSRCPtr+=LineOffset;column--;\r
2958        }\r
2959       while(column);\r
2960      }\r
2961     else                                               // small area? no lut\r
2962      {                                            \r
2963       wSRCPtr=psxVuw+palstart;\r
2964 \r
2965       column=dy;do \r
2966        {\r
2967         row=dx;\r
2968         do {*ta++=LPTCOL(*(wSRCPtr+*cSRCPtr++));row--;} while(row);\r
2969 \r
2970         ta+=xalign;\r
2971 \r
2972         cSRCPtr+=LineOffset;column--;\r
2973        }\r
2974       while(column);\r
2975      }\r
2976     break;\r
2977    //--------------------------------------------------// \r
2978    // 16bit texture load ..\r
2979    case 2:\r
2980     start=((pageid-16*pmult)<<6)+262144*pmult;\r
2981 \r
2982     wSRCPtr = psxVuw + start + (y1<<10) + x1;\r
2983     LineOffset = 1024 - dx; \r
2984 \r
2985     column=dy;do \r
2986      {\r
2987       row=dx;\r
2988       do {*ta++=LPTCOL(*wSRCPtr++);row--;} while(row);\r
2989 \r
2990       ta+=xalign;\r
2991 \r
2992       wSRCPtr+=LineOffset;column--;\r
2993      }\r
2994     while(column);\r
2995     break;\r
2996    //--------------------------------------------------// \r
2997    // others are not possible !\r
2998   }\r
2999 \r
3000  ////////////////////////////////////////////////////////\r
3001 \r
3002  x2a=dx+xalign;\r
3003 \r
3004  if(YTexS)\r
3005   {\r
3006    ta=(unsigned short *)texturepart;\r
3007    pa=(unsigned short *)texturepart+x2a;\r
3008    row=x2a;do {*ta++=*pa++;row--;} while(row);\r
3009 \r
3010    pa=(unsigned short *)texturepart+dy*x2a;\r
3011    ta=pa+x2a;\r
3012    row=x2a;do {*ta++=*pa++;row--;} while(row);\r
3013 \r
3014    YTexS--;\r
3015    dy+=2;\r
3016   }\r
3017 \r
3018  if(XTexS)\r
3019   {\r
3020    ta=(unsigned short *)texturepart;\r
3021    pa=ta+1;\r
3022    row=dy;do {*ta=*pa;ta+=x2a;pa+=x2a;row--;} while(row);\r
3023 \r
3024    pa=(unsigned short *)texturepart+dx;\r
3025    ta=pa+1;\r
3026    row=dy;do {*ta=*pa;ta+=x2a;pa+=x2a;row--;} while(row);\r
3027 \r
3028    XTexS--;\r
3029    dx+=2;\r
3030   }\r
3031 \r
3032  DXTexS=dx;DYTexS=dy;\r
3033 \r
3034  if(!iFilterType) {DefineSubTextureSort();return;}\r
3035  if(iFilterType!=2 && iFilterType!=4 && iFilterType!=6) {DefineSubTextureSort();return;}\r
3036  if((iFilterType==4 || iFilterType==6) && ly0==ly1 && ly2==ly3 && lx0==lx3 && lx1==lx2)\r
3037   {DefineSubTextureSort();return;}\r
3038 \r
3039  ta=(unsigned short *)texturepart;\r
3040  x1=dx-1;\r
3041  y1=dy-1;      \r
3042 \r
3043 {\r
3044    for(column=0;column<dy;column++)\r
3045     {\r
3046      for(row=0;row<dx;row++)\r
3047       {\r
3048        if(*ta==0)\r
3049         {\r
3050          cnt=0;\r
3051 \r
3052          if(           column     && *(ta-dx)  &1) scol[cnt++]=*(ta-dx);\r
3053          if(row                   && *(ta-1)   &1) scol[cnt++]=*(ta-1);\r
3054          if(row!=x1               && *(ta+1)   &1) scol[cnt++]=*(ta+1);\r
3055          if(           column!=y1 && *(ta+dx)  &1) scol[cnt++]=*(ta+dx);\r
3056 \r
3057          if(row     && column     && *(ta-dx-1)&1) scol[cnt++]=*(ta-dx-1);\r
3058          if(row!=x1 && column     && *(ta-dx+1)&1) scol[cnt++]=*(ta-dx+1);\r
3059          if(row     && column!=y1 && *(ta+dx-1)&1) scol[cnt++]=*(ta+dx-1);\r
3060          if(row!=x1 && column!=y1 && *(ta+dx+1)&1) scol[cnt++]=*(ta+dx+1);\r
3061 \r
3062          if(cnt)\r
3063           {\r
3064            r=g=b=0;\r
3065            for(h=0;h<cnt;h++)\r
3066             {\r
3067              r+=scol[h]>>11;\r
3068              g+=(scol[h]>>6)&0x1f;\r
3069              b+=(scol[h]>>1)&0x1f;\r
3070             }\r
3071            r/=cnt;b/=cnt;g/=cnt;\r
3072            *ta=(r<<11)|(g<<6)|(b<<1);\r
3073           }\r
3074         }\r
3075        ta++;\r
3076       }\r
3077     }\r
3078   }\r
3079 \r
3080  DefineSubTextureSort();\r
3081 }\r
3082 \r
3083 /////////////////////////////////////////////////////////////////////////////\r
3084 \r
3085 /////////////////////////////////////////////////////////////////////////////\r
3086 /////////////////////////////////////////////////////////////////////////////\r
3087 /////////////////////////////////////////////////////////////////////////////\r
3088 //\r
3089 // hires texture funcs\r
3090 //\r
3091 /////////////////////////////////////////////////////////////////////////////\r
3092 /////////////////////////////////////////////////////////////////////////////\r
3093 /////////////////////////////////////////////////////////////////////////////\r
3094 \r
3095 \r
3096 #define GET_RESULT(A, B, C, D) ((A != C || A != D) - (B != C || B != D))\r
3097 \r
3098 ////////////////////////////////////////////////////////////////////////\r
3099 \r
3100 #define colorMask8     0x00FEFEFE\r
3101 #define lowPixelMask8  0x00010101\r
3102 #define qcolorMask8    0x00FCFCFC\r
3103 #define qlowpixelMask8 0x00030303\r
3104 \r
3105 \r
3106 #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
3107 \r
3108 #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
3109 \r
3110 #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
3111 \r
3112 #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
3113 \r
3114 void Super2xSaI_ex8_Ex(unsigned char *srcPtr, DWORD srcPitch,\r
3115                     unsigned char  *dstBitmap, int width, int height)\r
3116 {\r
3117  DWORD dstPitch = srcPitch * 2;\r
3118  DWORD line;\r
3119  DWORD *dP;\r
3120  DWORD *bP;\r
3121  int   width2 = width*2;\r
3122  int iXA,iXB,iXC,iYA,iYB,iYC,finish;\r
3123  DWORD color4, color5, color6;\r
3124  DWORD color1, color2, color3;\r
3125  DWORD colorA0, colorA1, colorA2, colorA3,\r
3126        colorB0, colorB1, colorB2, colorB3,\r
3127        colorS1, colorS2;\r
3128  DWORD product1a, product1b,\r
3129        product2a, product2b;\r
3130 \r
3131  line = 0;\r
3132 \r
3133   {\r
3134    for (; height; height-=1)\r
3135         {\r
3136      bP = (DWORD *)srcPtr;\r
3137          dP = (DWORD *)(dstBitmap + line*dstPitch);\r
3138      for (finish = width; finish; finish -= 1 )\r
3139       {\r
3140 //---------------------------------------    B1 B2\r
3141 //                                         4  5  6 S2\r
3142 //                                         1  2  3 S1\r
3143 //                                           A1 A2\r
3144        if(finish==width) iXA=0;\r
3145        else              iXA=1;\r
3146        if(finish>4) {iXB=1;iXC=2;}\r
3147        else\r
3148        if(finish>3) {iXB=1;iXC=1;}\r
3149        else         {iXB=0;iXC=0;}\r
3150        if(line==0) iYA=0;\r
3151        else        iYA=width;\r
3152        if(height>4) {iYB=width;iYC=width2;}\r
3153        else\r
3154        if(height>3) {iYB=width;iYC=width;}\r
3155        else         {iYB=0;iYC=0;}\r
3156 \r
3157 \r
3158        colorB0 = *(bP- iYA - iXA);\r
3159        colorB1 = *(bP- iYA);\r
3160        colorB2 = *(bP- iYA + iXB);\r
3161        colorB3 = *(bP- iYA + iXC);\r
3162 \r
3163        color4 = *(bP  - iXA);\r
3164        color5 = *(bP);\r
3165        color6 = *(bP  + iXB);\r
3166        colorS2 = *(bP + iXC);\r
3167 \r
3168        color1 = *(bP  + iYB  - iXA);\r
3169        color2 = *(bP  + iYB);\r
3170        color3 = *(bP  + iYB  + iXB);\r
3171        colorS1= *(bP  + iYB  + iXC);\r
3172 \r
3173        colorA0 = *(bP + iYC - iXA);\r
3174        colorA1 = *(bP + iYC);\r
3175        colorA2 = *(bP + iYC + iXB);\r
3176        colorA3 = *(bP + iYC + iXC);\r
3177 \r
3178 //--------------------------------------\r
3179        if (color2 == color6 && color5 != color3)\r
3180         {\r
3181          product2b = product1b = color2;\r
3182         }\r
3183        else\r
3184        if (color5 == color3 && color2 != color6)\r
3185         {\r
3186          product2b = product1b = color5;\r
3187         }\r
3188        else\r
3189        if (color5 == color3 && color2 == color6)\r
3190         {\r
3191          register int r = 0;\r
3192 \r
3193          r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (color1&0x00ffffff),  (colorA1&0x00ffffff));\r
3194          r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (color4&0x00ffffff),  (colorB1&0x00ffffff));\r
3195          r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (colorA2&0x00ffffff), (colorS1&0x00ffffff));\r
3196          r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (colorB2&0x00ffffff), (colorS2&0x00ffffff));\r
3197 \r
3198          if (r > 0)\r
3199           product2b = product1b = color6;\r
3200          else\r
3201          if (r < 0)\r
3202           product2b = product1b = color5;\r
3203          else\r
3204           {\r
3205            product2b = product1b = INTERPOLATE8_02(color5, color6);\r
3206           }\r
3207         }\r
3208        else\r
3209         {\r
3210          if (color6 == color3 && color3 == colorA1 && color2 != colorA2 && color3 != colorA0)\r
3211              product2b = Q_INTERPOLATE8_02 (color3, color3, color3, color2);\r
3212          else\r
3213          if (color5 == color2 && color2 == colorA2 && colorA1 != color3 && color2 != colorA3)\r
3214              product2b = Q_INTERPOLATE8_02 (color2, color2, color2, color3);\r
3215          else\r
3216              product2b = INTERPOLATE8_02 (color2, color3);\r
3217 \r
3218          if (color6 == color3 && color6 == colorB1 && color5 != colorB2 && color6 != colorB0)\r
3219              product1b = Q_INTERPOLATE8_02 (color6, color6, color6, color5);\r
3220          else\r
3221          if (color5 == color2 && color5 == colorB2 && colorB1 != color6 && color5 != colorB3)\r
3222              product1b = Q_INTERPOLATE8_02 (color6, color5, color5, color5);\r
3223          else\r
3224              product1b = INTERPOLATE8_02 (color5, color6);\r
3225         }\r
3226 \r
3227        if (color5 == color3 && color2 != color6 && color4 == color5 && color5 != colorA2)\r
3228         product2a = INTERPOLATE8_02(color2, color5);\r
3229        else\r
3230        if (color5 == color1 && color6 == color5 && color4 != color2 && color5 != colorA0)\r
3231         product2a = INTERPOLATE8_02(color2, color5);\r
3232        else\r
3233         product2a = color2;\r
3234 \r
3235        if (color2 == color6 && color5 != color3 && color1 == color2 && color2 != colorB2)\r
3236         product1a = INTERPOLATE8_02(color2, color5);\r
3237        else\r
3238        if (color4 == color2 && color3 == color2 && color1 != color5 && color2 != colorB0)\r
3239         product1a = INTERPOLATE8_02(color2, color5);\r
3240        else\r
3241         product1a = color5;\r
3242 \r
3243        *dP=product1a;\r
3244        *(dP+1)=product1b;\r
3245        *(dP+(width2))=product2a;\r
3246        *(dP+1+(width2))=product2b;\r
3247 \r
3248        bP += 1;\r
3249        dP += 2;\r
3250       }//end of for ( finish= width etc..)\r
3251 \r
3252      line += 2;\r
3253      srcPtr += srcPitch;\r
3254         }; //endof: for (; height; height--)\r
3255   }\r
3256 }\r
3257 \r
3258 \r
3259 void Super2xSaI_ex8(unsigned char *srcPtr, DWORD srcPitch,\r
3260                     unsigned char  *dstBitmap, int width, int height)\r
3261 {\r
3262  DWORD dstPitch = srcPitch * 2;\r
3263  DWORD line;\r
3264  DWORD *dP;\r
3265  DWORD *bP;\r
3266  int   width2 = width*2;\r
3267  int iXA,iXB,iXC,iYA,iYB,iYC,finish;\r
3268  DWORD color4, color5, color6;\r
3269  DWORD color1, color2, color3;\r
3270  DWORD colorA0, colorA1, colorA2, colorA3,\r
3271        colorB0, colorB1, colorB2, colorB3,\r
3272        colorS1, colorS2;\r
3273  DWORD product1a, product1b,\r
3274        product2a, product2b;\r
3275 \r
3276  line = 0;\r
3277 \r
3278   {\r
3279    for (; height; height-=1)\r
3280         {\r
3281      bP = (DWORD *)srcPtr;\r
3282          dP = (DWORD *)(dstBitmap + line*dstPitch);\r
3283      for (finish = width; finish; finish -= 1 )\r
3284       {\r
3285 //---------------------------------------    B1 B2\r
3286 //                                         4  5  6 S2\r
3287 //                                         1  2  3 S1\r
3288 //                                           A1 A2\r
3289        if(finish==width) iXA=0;\r
3290        else              iXA=1;\r
3291        if(finish>4) {iXB=1;iXC=2;}\r
3292        else\r
3293        if(finish>3) {iXB=1;iXC=1;}\r
3294        else         {iXB=0;iXC=0;}\r
3295        if(line==0) iYA=0;\r
3296        else        iYA=width;\r
3297        if(height>4) {iYB=width;iYC=width2;}\r
3298        else\r
3299        if(height>3) {iYB=width;iYC=width;}\r
3300        else         {iYB=0;iYC=0;}\r
3301 \r
3302 \r
3303        colorB0 = *(bP- iYA - iXA);\r
3304        colorB1 = *(bP- iYA);\r
3305        colorB2 = *(bP- iYA + iXB);\r
3306        colorB3 = *(bP- iYA + iXC);\r
3307 \r
3308        color4 = *(bP  - iXA);\r
3309        color5 = *(bP);\r
3310        color6 = *(bP  + iXB);\r
3311        colorS2 = *(bP + iXC);\r
3312 \r
3313        color1 = *(bP  + iYB  - iXA);\r
3314        color2 = *(bP  + iYB);\r
3315        color3 = *(bP  + iYB  + iXB);\r
3316        colorS1= *(bP  + iYB  + iXC);\r
3317 \r
3318        colorA0 = *(bP + iYC - iXA);\r
3319        colorA1 = *(bP + iYC);\r
3320        colorA2 = *(bP + iYC + iXB);\r
3321        colorA3 = *(bP + iYC + iXC);\r
3322 \r
3323 //--------------------------------------\r
3324        if (color2 == color6 && color5 != color3)\r
3325         {\r
3326          product2b = product1b = color2;\r
3327         }\r
3328        else\r
3329        if (color5 == color3 && color2 != color6)\r
3330         {\r
3331          product2b = product1b = color5;\r
3332         }\r
3333        else\r
3334        if (color5 == color3 && color2 == color6)\r
3335         {\r
3336          register int r = 0;\r
3337 \r
3338          r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (color1&0x00ffffff),  (colorA1&0x00ffffff));\r
3339          r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (color4&0x00ffffff),  (colorB1&0x00ffffff));\r
3340          r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (colorA2&0x00ffffff), (colorS1&0x00ffffff));\r
3341          r += GET_RESULT ((color6&0x00ffffff), (color5&0x00ffffff), (colorB2&0x00ffffff), (colorS2&0x00ffffff));\r
3342 \r
3343          if (r > 0)\r
3344           product2b = product1b = color6;\r
3345          else\r
3346          if (r < 0)\r
3347           product2b = product1b = color5;\r
3348          else\r
3349           {\r
3350            product2b = product1b = INTERPOLATE8(color5, color6);\r
3351           }\r
3352         }\r
3353        else\r
3354         {\r
3355          if (color6 == color3 && color3 == colorA1 && color2 != colorA2 && color3 != colorA0)\r
3356              product2b = Q_INTERPOLATE8 (color3, color3, color3, color2);\r
3357          else\r
3358          if (color5 == color2 && color2 == colorA2 && colorA1 != color3 && color2 != colorA3)\r
3359              product2b = Q_INTERPOLATE8 (color2, color2, color2, color3);\r
3360          else\r
3361              product2b = INTERPOLATE8 (color2, color3);\r
3362 \r
3363          if (color6 == color3 && color6 == colorB1 && color5 != colorB2 && color6 != colorB0)\r
3364              product1b = Q_INTERPOLATE8 (color6, color6, color6, color5);\r
3365          else\r
3366          if (color5 == color2 && color5 == colorB2 && colorB1 != color6 && color5 != colorB3)\r
3367              product1b = Q_INTERPOLATE8 (color6, color5, color5, color5);\r
3368          else\r
3369              product1b = INTERPOLATE8 (color5, color6);\r
3370         }\r
3371 \r
3372        if (color5 == color3 && color2 != color6 && color4 == color5 && color5 != colorA2)\r
3373         product2a = INTERPOLATE8(color2, color5);\r
3374        else\r
3375        if (color5 == color1 && color6 == color5 && color4 != color2 && color5 != colorA0)\r
3376         product2a = INTERPOLATE8(color2, color5);\r
3377        else\r
3378         product2a = color2;\r
3379 \r
3380        if (color2 == color6 && color5 != color3 && color1 == color2 && color2 != colorB2)\r
3381         product1a = INTERPOLATE8(color2, color5);\r
3382        else\r
3383        if (color4 == color2 && color3 == color2 && color1 != color5 && color2 != colorB0)\r
3384         product1a = INTERPOLATE8(color2, color5);\r
3385        else\r
3386         product1a = color5;\r
3387 \r
3388        *dP=product1a;\r
3389        *(dP+1)=product1b;\r
3390        *(dP+(width2))=product2a;\r
3391        *(dP+1+(width2))=product2b;\r
3392 \r
3393        bP += 1;\r
3394        dP += 2;\r
3395       }//end of for ( finish= width etc..)\r
3396 \r
3397      line += 2;\r
3398      srcPtr += srcPitch;\r
3399         }; //endof: for (; height; height--)\r
3400   }\r
3401 }\r
3402 /////////////////////////////////////////////////////////////////////////////\r
3403 \r
3404 #define colorMask4     0x0000EEE0\r
3405 #define lowPixelMask4  0x00001110\r
3406 #define qcolorMask4    0x0000CCC0\r
3407 #define qlowpixelMask4 0x00003330\r
3408 \r
3409 #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
3410 \r
3411 #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
3412 \r
3413 \r
3414 #define colorMask5     0x0000F7BC\r
3415 #define lowPixelMask5  0x00000842\r
3416 #define qcolorMask5    0x0000E738\r
3417 #define qlowpixelMask5 0x000018C6\r
3418 \r
3419 #define INTERPOLATE5(A, B) ((((A & colorMask5) >> 1) + ((B & colorMask5) >> 1) + (A & B & lowPixelMask5))|((((A&0x00000001)==0x00000000)?0x00000000:(((B&0x00000001)==0x00000000)?0x00000000:0x00000001))))\r
3420 \r
3421 #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
3422 /////////////////////////////////////////////////////////////////////////////\r
3423 /////////////////////////////////////////////////////////////////////////////\r
3424 /////////////////////////////////////////////////////////////////////////////\r
3425 //\r
3426 // ogl texture defines\r
3427 //\r
3428 /////////////////////////////////////////////////////////////////////////////\r
3429 /////////////////////////////////////////////////////////////////////////////\r
3430 /////////////////////////////////////////////////////////////////////////////\r
3431 \r
3432 void DefineSubTextureSortHiRes(void)\r
3433 {\r
3434  int x,y,dx2;\r
3435 \r
3436  if(!gTexName)             \r
3437   {\r
3438    glGenTextures(1, &gTexName); glError();\r
3439    glBindTexture(GL_TEXTURE_2D, gTexName); glError();\r
3440 \r
3441    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, iClampType); glError();\r
3442    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, iClampType); glError();\r
3443 \r
3444    if(iFilterType)\r
3445     {\r
3446      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glError();\r
3447      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glError();\r
3448     }\r
3449    else\r
3450     {            \r
3451      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, iFilter); glError();\r
3452      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, iFilter); glError();\r
3453     }   \r
3454    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 512, 512, 0, GL_RGBA, GL_UNSIGNED_BYTE, texturebuffer); glError();\r
3455   }\r
3456  else glBindTexture(GL_TEXTURE_2D, gTexName); glError();\r
3457 \r
3458  glTexSubImage2D(GL_TEXTURE_2D, 0, XTexS<<1, YTexS<<1,\r
3459                  DXTexS<<1, DYTexS<<1,\r
3460                  GL_RGBA, GL_UNSIGNED_BYTE, texturebuffer); glError();\r
3461  //LOGE("DefineSubTextureSortHiRes x:%d y:%d",XTexS<<1,YTexS<<1);\r
3462 }\r
3463 \r
3464 /////////////////////////////////////////////////////////////////////////////\r
3465 \r
3466 void DefineSubTextureSort(void)\r
3467 {\r
3468 \r
3469  if(!gTexName)\r
3470   {\r
3471    glGenTextures(1, &gTexName); glError();\r
3472    glBindTexture(GL_TEXTURE_2D, gTexName); glError();\r
3473 \r
3474    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, iClampType); glError();\r
3475    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, iClampType); glError();\r
3476 \r
3477    if(iFilterType)\r
3478     {\r
3479      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glError();\r
3480      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glError();\r
3481     }\r
3482    else\r
3483     {\r
3484      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, iFilter); glError();\r
3485      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, iFilter); glError();\r
3486     }\r
3487    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0,GL_RGBA, GL_UNSIGNED_BYTE, texturepart); glError();\r
3488   }\r
3489  else glBindTexture(GL_TEXTURE_2D, gTexName); glError();\r
3490 \r
3491  glTexSubImage2D(GL_TEXTURE_2D, 0, XTexS, YTexS,\r
3492                  DXTexS, DYTexS,\r
3493                  GL_RGBA, GL_UNSIGNED_BYTE, texturepart); glError();\r
3494                                         //LOGE("DefineSubTextureSort x:%d y:%d w:%d h:%d",XTexS,YTexS,DXTexS,DYTexS);\r
3495 }\r
3496 \r
3497 /////////////////////////////////////////////////////////////////////////////\r
3498 \r
3499 /////////////////////////////////////////////////////////////////////////////\r
3500 /////////////////////////////////////////////////////////////////////////////\r
3501 /////////////////////////////////////////////////////////////////////////////\r
3502 //\r
3503 // texture cache garbage collection\r
3504 //\r
3505 /////////////////////////////////////////////////////////////////////////////\r
3506 /////////////////////////////////////////////////////////////////////////////\r
3507 /////////////////////////////////////////////////////////////////////////////\r
3508 \r
3509 void DoTexGarbageCollection(void)\r
3510 {\r
3511  static unsigned short LRUCleaned=0;\r
3512  unsigned short iC,iC1,iC2;\r
3513  int i,j,iMax;textureSubCacheEntryS * tsb;\r
3514 \r
3515  iC=4;//=iSortTexCnt/2,\r
3516  LRUCleaned+=iC;                                       // we clean different textures each time\r
3517  if((LRUCleaned+iC)>=iSortTexCnt) LRUCleaned=0;        // wrap? wrap!\r
3518  iC1=LRUCleaned;                                       // range of textures to clean\r
3519  iC2=LRUCleaned+iC;\r
3520 \r
3521  for(iC=iC1;iC<iC2;iC++)                               // make some textures available\r
3522   {\r
3523    pxSsubtexLeft[iC]->l=0;\r
3524   }\r
3525 \r
3526  for(i=0;i<3;i++)                                      // remove all references to that textures\r
3527   for(j=0;j<MAXTPAGES;j++)\r
3528    for(iC=0;iC<4;iC++)                                 // loop all texture rect info areas\r
3529     {\r
3530      tsb=pscSubtexStore[i][j]+(iC*SOFFB);\r
3531      iMax=tsb->pos.l;\r
3532      if(iMax)\r
3533       do\r
3534        {\r
3535         tsb++;\r
3536         if(tsb->cTexID>=iC1 && tsb->cTexID<iC2)        // info uses the cleaned textures? remove info\r
3537          tsb->ClutID=0;\r
3538        } \r
3539       while(--iMax);\r
3540      }\r
3541 \r
3542  usLRUTexPage=LRUCleaned;\r
3543 }\r
3544 \r
3545 /////////////////////////////////////////////////////////////////////////////\r
3546 /////////////////////////////////////////////////////////////////////////////\r
3547 /////////////////////////////////////////////////////////////////////////////\r
3548 //\r
3549 // search cache for existing (already used) parts\r
3550 //\r
3551 /////////////////////////////////////////////////////////////////////////////\r
3552 /////////////////////////////////////////////////////////////////////////////\r
3553 /////////////////////////////////////////////////////////////////////////////\r
3554 \r
3555 unsigned char * CheckTextureInSubSCache(long TextureMode,unsigned long GivenClutId,unsigned short * pCache)\r
3556 {\r
3557  textureSubCacheEntryS * tsx, * tsb, *tsg;//, *tse=NULL;\r
3558  int i,iMax;EXLong npos;\r
3559  unsigned char cx,cy;\r
3560  int iC,j,k;unsigned long rx,ry,mx,my;\r
3561  EXLong * ul=0, * uls;\r
3562  EXLong rfree;\r
3563  unsigned char cXAdj,cYAdj;\r
3564 \r
3565  npos.l=*((unsigned long *)&gl_ux[4]);\r
3566 \r
3567  //--------------------------------------------------------------//\r
3568  // find matching texturepart first... speed up...\r
3569  //--------------------------------------------------------------//\r
3570 \r
3571  tsg=pscSubtexStore[TextureMode][GlobalTexturePage];\r
3572  tsg+=((GivenClutId&CLUTCHK)>>CLUTSHIFT)*SOFFB;\r
3573 \r
3574  iMax=tsg->pos.l;\r
3575  if(iMax)\r
3576   {\r
3577    i=iMax;\r
3578    tsb=tsg+1;                 \r
3579    do\r
3580     {\r
3581      if(GivenClutId==tsb->ClutID &&\r
3582         (INCHECK(tsb->pos,npos)))\r
3583       {\r
3584         {\r
3585          cx=tsb->pos.c[3]-tsb->posTX;\r
3586          cy=tsb->pos.c[1]-tsb->posTY;\r
3587 \r
3588          gl_ux[0]-=cx;\r
3589          gl_ux[1]-=cx;\r
3590          gl_ux[2]-=cx;\r
3591          gl_ux[3]-=cx;\r
3592          gl_vy[0]-=cy;\r
3593          gl_vy[1]-=cy;\r
3594          gl_vy[2]-=cy;\r
3595          gl_vy[3]-=cy;\r
3596 \r
3597          ubOpaqueDraw=tsb->Opaque;\r
3598          *pCache=tsb->cTexID;\r
3599          return NULL;\r
3600         }\r
3601       } \r
3602      tsb++;\r
3603     }\r
3604    while(--i);\r
3605   }\r
3606 \r
3607  //----------------------------------------------------//\r
3608 \r
3609  cXAdj=1;cYAdj=1;\r
3610 \r
3611  rx=(int)gl_ux[6]-(int)gl_ux[7];\r
3612  ry=(int)gl_ux[4]-(int)gl_ux[5];\r
3613 \r
3614  tsx=NULL;tsb=tsg+1;\r
3615  for(i=0;i<iMax;i++,tsb++)\r
3616   {\r
3617    if(!tsb->ClutID) {tsx=tsb;break;}\r
3618   }\r
3619 \r
3620  if(!tsx) \r
3621   {\r
3622    iMax++;\r
3623    if(iMax>=SOFFB-2) \r
3624     {\r
3625      if(iTexGarbageCollection)                         // gc mode?\r
3626       {\r
3627        if(*pCache==0) \r
3628         {\r
3629          dwTexPageComp|=(1<<GlobalTexturePage);\r
3630          *pCache=0xffff;\r
3631          return 0;\r
3632         }\r
3633 \r
3634        iMax--;\r
3635        tsb=tsg+1;\r
3636 \r
3637        for(i=0;i<iMax;i++,tsb++)                       // 1. search other slots with same cluts, and unite the area\r
3638         if(GivenClutId==tsb->ClutID)\r
3639          {\r
3640           if(!tsx) {tsx=tsb;rfree.l=npos.l;}           // \r
3641           else      tsb->ClutID=0;\r
3642           rfree.c[3]=min(rfree.c[3],tsb->pos.c[3]);\r
3643           rfree.c[2]=max(rfree.c[2],tsb->pos.c[2]);\r
3644           rfree.c[1]=min(rfree.c[1],tsb->pos.c[1]);\r
3645           rfree.c[0]=max(rfree.c[0],tsb->pos.c[0]);\r
3646           MarkFree(tsb);\r
3647          }\r
3648 \r
3649        if(tsx)                                         // 3. if one or more found, create a new rect with bigger size\r
3650         {\r
3651          *((unsigned long *)&gl_ux[4])=npos.l=rfree.l;\r
3652          rx=(int)rfree.c[2]-(int)rfree.c[3];\r
3653          ry=(int)rfree.c[0]-(int)rfree.c[1];\r
3654          DoTexGarbageCollection();\r
3655        \r
3656          goto ENDLOOP3;\r
3657         }\r
3658       }\r
3659 \r
3660      iMax=1;\r
3661     }\r
3662    tsx=tsg+iMax;\r
3663    tsg->pos.l=iMax;\r
3664   }\r
3665 \r
3666  //----------------------------------------------------//\r
3667  // now get a free texture space\r
3668  //----------------------------------------------------//\r
3669 \r
3670  if(iTexGarbageCollection) usLRUTexPage=0;\r
3671 \r
3672 ENDLOOP3:\r
3673 \r
3674  rx+=3;if(rx>255) {cXAdj=0;rx=255;}\r
3675  ry+=3;if(ry>255) {cYAdj=0;ry=255;}\r
3676 \r
3677  iC=usLRUTexPage;\r
3678 \r
3679  for(k=0;k<iSortTexCnt;k++)\r
3680   {\r
3681    uls=pxSsubtexLeft[iC];\r
3682    iMax=uls->l;ul=uls+1;\r
3683 \r
3684    //--------------------------------------------------//\r
3685    // first time\r
3686 \r
3687    if(!iMax) \r
3688     {\r
3689      rfree.l=0;\r
3690 \r
3691      if(rx>252 && ry>252)\r
3692       {uls->l=1;ul->l=0xffffffff;ul=0;goto ENDLOOP;}\r
3693 \r
3694      if(rx<253)\r
3695       {\r
3696        uls->l=uls->l+1;\r
3697        ul->c[3]=rx;\r
3698        ul->c[2]=255-rx;\r
3699        ul->c[1]=0;\r
3700        ul->c[0]=ry;\r
3701        ul++;\r
3702       }\r
3703 \r
3704      if(ry<253)\r
3705       {\r
3706        uls->l=uls->l+1; \r
3707        ul->c[3]=0;\r
3708        ul->c[2]=255;\r
3709        ul->c[1]=ry;\r
3710        ul->c[0]=255-ry;\r
3711       }\r
3712      ul=0;\r
3713      goto ENDLOOP;\r
3714     }\r
3715                                                        \r
3716    //--------------------------------------------------//\r
3717    for(i=0;i<iMax;i++,ul++)\r
3718     {\r
3719      if(ul->l!=0xffffffff && \r
3720         ry<=ul->c[0]      && \r
3721         rx<=ul->c[2])\r
3722       {\r
3723        rfree=*ul;\r
3724        mx=ul->c[2]-2;\r
3725        my=ul->c[0]-2;\r
3726        if(rx<mx && ry<my)\r
3727         {\r
3728          ul->c[3]+=rx;\r
3729          ul->c[2]-=rx;\r
3730          ul->c[0]=ry;\r
3731 \r
3732          for(ul=uls+1,j=0;j<iMax;j++,ul++)\r
3733           if(ul->l==0xffffffff) break;\r
3734  \r
3735          if(j<CSUBSIZE-2)\r
3736           {\r
3737            if(j==iMax) uls->l=uls->l+1;\r
3738 \r
3739            ul->c[3]=rfree.c[3];\r
3740            ul->c[2]=rfree.c[2];\r
3741            ul->c[1]=rfree.c[1]+ry;\r
3742            ul->c[0]=rfree.c[0]-ry;\r
3743           }\r
3744         }\r
3745        else if(rx<mx)\r
3746         {\r
3747          ul->c[3]+=rx;\r
3748          ul->c[2]-=rx;\r
3749         }\r
3750        else if(ry<my)\r
3751         {\r
3752          ul->c[1]+=ry;\r
3753          ul->c[0]-=ry;\r
3754         }\r
3755        else\r
3756         {\r
3757          ul->l=0xffffffff;\r
3758         }\r
3759        ul=0;\r
3760        goto ENDLOOP;\r
3761       }\r
3762     }\r
3763 \r
3764    //--------------------------------------------------//\r
3765 \r
3766    iC++; if(iC>=iSortTexCnt) iC=0;\r
3767   }\r
3768 \r
3769  //----------------------------------------------------//\r
3770  // check, if free space got\r
3771  //----------------------------------------------------//\r
3772 \r
3773 ENDLOOP:\r
3774  if(ul)\r
3775   {\r
3776    //////////////////////////////////////////////////////\r
3777 \r
3778     {\r
3779      dwTexPageComp=0;\r
3780 \r
3781      for(i=0;i<3;i++)                                    // cleaning up\r
3782       for(j=0;j<MAXTPAGES;j++)\r
3783        {\r
3784         tsb=pscSubtexStore[i][j];\r
3785         (tsb+SOFFA)->pos.l=0;\r
3786         (tsb+SOFFB)->pos.l=0;\r
3787         (tsb+SOFFC)->pos.l=0;\r
3788         (tsb+SOFFD)->pos.l=0;\r
3789        }\r
3790      for(i=0;i<iSortTexCnt;i++)\r
3791       {ul=pxSsubtexLeft[i];ul->l=0;}\r
3792      usLRUTexPage=0;\r
3793     }\r
3794 \r
3795    //////////////////////////////////////////////////////\r
3796    iC=usLRUTexPage;\r
3797    uls=pxSsubtexLeft[usLRUTexPage];\r
3798    uls->l=0;ul=uls+1;\r
3799    rfree.l=0;\r
3800 \r
3801    if(rx>252 && ry>252)\r
3802     {uls->l=1;ul->l=0xffffffff;}\r
3803    else\r
3804     {\r
3805      if(rx<253)\r
3806       {\r
3807        uls->l=uls->l+1;\r
3808        ul->c[3]=rx;\r
3809        ul->c[2]=255-rx;\r
3810        ul->c[1]=0;\r
3811        ul->c[0]=ry;\r
3812        ul++;\r
3813       }\r
3814      if(ry<253)\r
3815       {\r
3816        uls->l=uls->l+1; \r
3817        ul->c[3]=0;\r
3818        ul->c[2]=255;\r
3819        ul->c[1]=ry;\r
3820        ul->c[0]=255-ry;\r
3821       }\r
3822     }\r
3823    tsg->pos.l=1;tsx=tsg+1;\r
3824   }\r
3825 \r
3826  rfree.c[3]+=cXAdj;\r
3827  rfree.c[1]+=cYAdj;\r
3828 \r
3829  tsx->cTexID   =*pCache=iC;\r
3830  tsx->pos      = npos;\r
3831  tsx->ClutID   = GivenClutId;\r
3832  tsx->posTX    = rfree.c[3];\r
3833  tsx->posTY    = rfree.c[1];\r
3834 \r
3835  cx=gl_ux[7]-rfree.c[3];\r
3836  cy=gl_ux[5]-rfree.c[1];\r
3837 \r
3838  gl_ux[0]-=cx;\r
3839  gl_ux[1]-=cx;\r
3840  gl_ux[2]-=cx;\r
3841  gl_ux[3]-=cx;\r
3842  gl_vy[0]-=cy;\r
3843  gl_vy[1]-=cy;\r
3844  gl_vy[2]-=cy;\r
3845  gl_vy[3]-=cy;\r
3846 \r
3847  XTexS=rfree.c[3];\r
3848  YTexS=rfree.c[1];\r
3849 \r
3850  return &tsx->Opaque;\r
3851 }\r
3852                    \r
3853 /////////////////////////////////////////////////////////////////////////////\r
3854 /////////////////////////////////////////////////////////////////////////////\r
3855 /////////////////////////////////////////////////////////////////////////////\r
3856 //\r
3857 // search cache for free place (on compress)\r
3858 //\r
3859 /////////////////////////////////////////////////////////////////////////////\r
3860 /////////////////////////////////////////////////////////////////////////////\r
3861 /////////////////////////////////////////////////////////////////////////////\r
3862 \r
3863 BOOL GetCompressTexturePlace(textureSubCacheEntryS * tsx)\r
3864 {\r
3865  int i,j,k,iMax,iC;unsigned long rx,ry,mx,my;\r
3866  EXLong * ul=0, * uls, rfree;\r
3867  unsigned char cXAdj=1,cYAdj=1;\r
3868 \r
3869  rx=(int)tsx->pos.c[2]-(int)tsx->pos.c[3];\r
3870  ry=(int)tsx->pos.c[0]-(int)tsx->pos.c[1];\r
3871 \r
3872  rx+=3;if(rx>255) {cXAdj=0;rx=255;}\r
3873  ry+=3;if(ry>255) {cYAdj=0;ry=255;}\r
3874 \r
3875  iC=usLRUTexPage;\r
3876 \r
3877  for(k=0;k<iSortTexCnt;k++)\r
3878   {\r
3879    uls=pxSsubtexLeft[iC];\r
3880    iMax=uls->l;ul=uls+1;\r
3881 \r
3882    //--------------------------------------------------//\r
3883    // first time\r
3884 \r
3885    if(!iMax)\r
3886     {\r
3887      rfree.l=0;\r
3888 \r
3889      if(rx>252 && ry>252)\r
3890       {uls->l=1;ul->l=0xffffffff;ul=0;goto TENDLOOP;}\r
3891 \r
3892      if(rx<253)\r
3893       {\r
3894        uls->l=uls->l+1;\r
3895        ul->c[3]=rx;\r
3896        ul->c[2]=255-rx;\r
3897        ul->c[1]=0;\r
3898        ul->c[0]=ry;\r
3899        ul++;\r
3900       }\r
3901 \r
3902      if(ry<253)\r
3903       {\r
3904        uls->l=uls->l+1;\r
3905        ul->c[3]=0;\r
3906        ul->c[2]=255;\r
3907        ul->c[1]=ry;\r
3908        ul->c[0]=255-ry;\r
3909       }\r
3910      ul=0;\r
3911      goto TENDLOOP;\r
3912     }\r
3913 \r
3914    //--------------------------------------------------//\r
3915    for(i=0;i<iMax;i++,ul++)\r
3916     {\r
3917      if(ul->l!=0xffffffff &&\r
3918         ry<=ul->c[0]      &&\r
3919         rx<=ul->c[2])\r
3920       {\r
3921        rfree=*ul;\r
3922        mx=ul->c[2]-2;\r
3923        my=ul->c[0]-2;\r
3924 \r
3925        if(rx<mx && ry<my)\r
3926         {\r
3927          ul->c[3]+=rx;\r
3928          ul->c[2]-=rx;\r
3929          ul->c[0]=ry;\r
3930 \r
3931          for(ul=uls+1,j=0;j<iMax;j++,ul++)\r
3932           if(ul->l==0xffffffff) break;\r
3933 \r
3934          if(j<CSUBSIZE-2)\r
3935           {\r
3936            if(j==iMax) uls->l=uls->l+1;\r
3937 \r
3938            ul->c[3]=rfree.c[3];\r
3939            ul->c[2]=rfree.c[2];\r
3940            ul->c[1]=rfree.c[1]+ry;\r
3941            ul->c[0]=rfree.c[0]-ry;\r
3942           }\r
3943         }\r
3944        else if(rx<mx)\r
3945         {\r
3946          ul->c[3]+=rx;\r
3947          ul->c[2]-=rx;\r
3948         }\r
3949        else if(ry<my)\r
3950         {\r
3951          ul->c[1]+=ry;\r
3952          ul->c[0]-=ry;\r
3953         }\r
3954        else\r
3955         {\r
3956          ul->l=0xffffffff;\r
3957         }\r
3958        ul=0;\r
3959        goto TENDLOOP;\r
3960       }\r
3961     }\r
3962 \r
3963    //--------------------------------------------------//\r
3964 \r
3965    iC++; if(iC>=iSortTexCnt) iC=0;\r
3966   }\r
3967 \r
3968  //----------------------------------------------------//\r
3969  // check, if free space got\r
3970  //----------------------------------------------------//\r
3971 \r
3972 TENDLOOP:\r
3973  if(ul) return FALSE;\r
3974 \r
3975  rfree.c[3]+=cXAdj;\r
3976  rfree.c[1]+=cYAdj;\r
3977 \r
3978  tsx->cTexID   = iC;\r
3979  tsx->posTX    = rfree.c[3];\r
3980  tsx->posTY    = rfree.c[1];\r
3981 \r
3982  XTexS=rfree.c[3];\r
3983  YTexS=rfree.c[1];\r
3984 \r
3985  return TRUE;\r
3986 }\r
3987 \r
3988 /////////////////////////////////////////////////////////////////////////////\r
3989 /////////////////////////////////////////////////////////////////////////////\r
3990 /////////////////////////////////////////////////////////////////////////////\r
3991 //\r
3992 // compress texture cache (to make place for new texture part, if needed)\r
3993 //\r
3994 /////////////////////////////////////////////////////////////////////////////\r
3995 /////////////////////////////////////////////////////////////////////////////\r
3996 /////////////////////////////////////////////////////////////////////////////\r
3997 \r
3998 void CompressTextureSpace(void)\r
3999 {\r
4000  textureSubCacheEntryS * tsx, * tsg, * tsb;\r
4001  int i,j,k,m,n,iMax;EXLong * ul, r,opos;\r
4002  short sOldDST=DrawSemiTrans,cx,cy;\r
4003  long  lOGTP=GlobalTexturePage;\r
4004  unsigned long l,row;\r
4005  unsigned long * lSRCPtr;\r
4006 \r
4007  opos.l=*((unsigned long *)&gl_ux[4]);\r
4008 \r
4009  // 1. mark all textures as free\r
4010  for(i=0;i<iSortTexCnt;i++)\r
4011   {ul=pxSsubtexLeft[i];ul->l=0;}\r
4012  usLRUTexPage=0;\r
4013 \r
4014  // 2. compress\r
4015  for(j=0;j<3;j++)\r
4016   {\r
4017    for(k=0;k<MAXTPAGES;k++)\r
4018     {\r
4019      tsg=pscSubtexStore[j][k];\r
4020 \r
4021      if((!(dwTexPageComp&(1<<k))))\r
4022       {\r
4023        (tsg+SOFFA)->pos.l=0;\r
4024        (tsg+SOFFB)->pos.l=0;\r
4025        (tsg+SOFFC)->pos.l=0;\r
4026        (tsg+SOFFD)->pos.l=0;\r
4027        continue;\r
4028       }\r
4029 \r
4030      for(m=0;m<4;m++,tsg+=SOFFB)\r
4031       {\r
4032        iMax=tsg->pos.l;\r
4033 \r
4034        tsx=tsg+1;\r
4035        for(i=0;i<iMax;i++,tsx++)\r
4036         {\r
4037          if(tsx->ClutID)\r
4038           {\r
4039            r.l=tsx->pos.l;\r
4040            for(n=i+1,tsb=tsx+1;n<iMax;n++,tsb++)\r
4041             {\r
4042              if(tsx->ClutID==tsb->ClutID)\r
4043               {\r
4044                r.c[3]=min(r.c[3],tsb->pos.c[3]);\r
4045                r.c[2]=max(r.c[2],tsb->pos.c[2]);\r
4046                r.c[1]=min(r.c[1],tsb->pos.c[1]);\r
4047                r.c[0]=max(r.c[0],tsb->pos.c[0]);\r
4048                tsb->ClutID=0;\r
4049               }\r
4050             }\r
4051 \r
4052 //           if(r.l!=tsx->pos.l)\r
4053             {\r
4054              cx=((tsx->ClutID << 4) & 0x3F0);          \r
4055              cy=((tsx->ClutID >> 6) & CLUTYMASK);\r
4056 \r
4057              if(j!=2)\r
4058               {\r
4059                // palette check sum\r
4060                l=0;lSRCPtr=(unsigned long *)(psxVuw+cx+(cy*1024));\r
4061                if(j==1) for(row=1;row<129;row++) l+=((*lSRCPtr++)-1)*row;\r
4062                else     for(row=1;row<9;row++)   l+=((*lSRCPtr++)-1)<<row;\r
4063                l=((l+HIWORD(l))&0x3fffL)<<16;\r
4064                if(l!=(tsx->ClutID&(0x00003fff<<16)))\r
4065                 {\r
4066                  tsx->ClutID=0;continue;\r
4067                 }\r
4068               }\r
4069 \r
4070              tsx->pos.l=r.l;\r
4071              if(!GetCompressTexturePlace(tsx))         // no place?\r
4072               {\r
4073                for(i=0;i<3;i++)                        // -> clean up everything\r
4074                 for(j=0;j<MAXTPAGES;j++)\r
4075                  {\r
4076                   tsb=pscSubtexStore[i][j];\r
4077                   (tsb+SOFFA)->pos.l=0;\r
4078                   (tsb+SOFFB)->pos.l=0;\r
4079                   (tsb+SOFFC)->pos.l=0;\r
4080                   (tsb+SOFFD)->pos.l=0;\r
4081                  }\r
4082                for(i=0;i<iSortTexCnt;i++)\r
4083                 {ul=pxSsubtexLeft[i];ul->l=0;}\r
4084                usLRUTexPage=0;\r
4085                DrawSemiTrans=sOldDST;\r
4086                GlobalTexturePage=lOGTP;\r
4087                *((unsigned long *)&gl_ux[4])=opos.l;\r
4088                dwTexPageComp=0;\r
4089 \r
4090                return;\r
4091               }\r
4092 \r
4093              if(tsx->ClutID&(1<<30)) DrawSemiTrans=1;\r
4094              else                    DrawSemiTrans=0;\r
4095              *((unsigned long *)&gl_ux[4])=r.l;\r
4096    \r
4097              gTexName=uiStexturePage[tsx->cTexID];\r
4098              LoadSubTexFn(k,j,cx,cy);\r
4099              uiStexturePage[tsx->cTexID]=gTexName;\r
4100              tsx->Opaque=ubOpaqueDraw;\r
4101             }\r
4102           }\r
4103         }\r
4104 \r
4105        if(iMax)  \r
4106         {\r
4107          tsx=tsg+iMax;\r
4108          while(!tsx->ClutID && iMax) {tsx--;iMax--;}\r
4109          tsg->pos.l=iMax;\r
4110         }\r
4111 \r
4112       }                      \r
4113     }\r
4114   }\r
4115 \r
4116  if(dwTexPageComp==0xffffffff) dwTexPageComp=0;\r
4117 \r
4118  *((unsigned long *)&gl_ux[4])=opos.l;\r
4119  GlobalTexturePage=lOGTP;\r
4120  DrawSemiTrans=sOldDST;\r
4121 }\r
4122 \r
4123 /////////////////////////////////////////////////////////////////////////////\r
4124 /////////////////////////////////////////////////////////////////////////////\r
4125 /////////////////////////////////////////////////////////////////////////////\r
4126 //\r
4127 // main entry for searching/creating textures, called from prim.c\r
4128 //\r
4129 /////////////////////////////////////////////////////////////////////////////\r
4130 /////////////////////////////////////////////////////////////////////////////\r
4131 /////////////////////////////////////////////////////////////////////////////\r
4132 \r
4133 GLuint SelectSubTextureS(long TextureMode, unsigned long GivenClutId) \r
4134 {\r
4135  unsigned char * OPtr;unsigned short iCache;short cx,cy;\r
4136 \r
4137  // sort sow/tow infos for fast access\r
4138 \r
4139  unsigned char ma1,ma2,mi1,mi2;\r
4140  if(gl_ux[0]>gl_ux[1]) {mi1=gl_ux[1];ma1=gl_ux[0];}\r
4141  else                  {mi1=gl_ux[0];ma1=gl_ux[1];}\r
4142  if(gl_ux[2]>gl_ux[3]) {mi2=gl_ux[3];ma2=gl_ux[2];}\r
4143  else                  {mi2=gl_ux[2];ma2=gl_ux[3];}\r
4144  if(mi1>mi2) gl_ux[7]=mi2; \r
4145  else        gl_ux[7]=mi1;\r
4146  if(ma1>ma2) gl_ux[6]=ma1; \r
4147  else        gl_ux[6]=ma2;\r
4148 \r
4149  if(gl_vy[0]>gl_vy[1]) {mi1=gl_vy[1];ma1=gl_vy[0];}\r
4150  else                  {mi1=gl_vy[0];ma1=gl_vy[1];}\r
4151  if(gl_vy[2]>gl_vy[3]) {mi2=gl_vy[3];ma2=gl_vy[2];}\r
4152  else                  {mi2=gl_vy[2];ma2=gl_vy[3];}\r
4153  if(mi1>mi2) gl_ux[5]=mi2; \r
4154  else        gl_ux[5]=mi1;\r
4155  if(ma1>ma2) gl_ux[4]=ma1; \r
4156  else        gl_ux[4]=ma2;\r
4157 \r
4158  // get clut infos in one 32 bit val\r
4159 \r
4160  if(TextureMode==2)                                    // no clut here\r
4161   {\r
4162    GivenClutId=CLUTUSED|(DrawSemiTrans<<30);cx=cy=0;\r
4163  \r
4164    if(iFrameTexType && Fake15BitTexture()) \r
4165     return (GLuint)gTexName;\r
4166   }           \r
4167  else \r
4168   {\r
4169    cx=((GivenClutId << 4) & 0x3F0);                    // but here\r
4170    cy=((GivenClutId >> 6) & CLUTYMASK);\r
4171    GivenClutId=(GivenClutId&CLUTMASK)|(DrawSemiTrans<<30)|CLUTUSED;\r
4172 \r
4173    // palette check sum.. removed MMX asm, this easy func works as well\r
4174     {\r
4175      unsigned long l=0,row;\r
4176 \r
4177      unsigned long * lSRCPtr=(unsigned long *)(psxVuw+cx+(cy*1024));\r
4178      if(TextureMode==1) for(row=1;row<129;row++) l+=((*lSRCPtr++)-1)*row;\r
4179      else               for(row=1;row<9;row++)   l+=((*lSRCPtr++)-1)<<row;\r
4180      l=(l+HIWORD(l))&0x3fffL;\r
4181      GivenClutId|=(l<<16);\r
4182     }\r
4183 \r
4184   }\r
4185 \r
4186  // search cache\r
4187  iCache=0;\r
4188  OPtr=CheckTextureInSubSCache(TextureMode,GivenClutId,&iCache);\r
4189 \r
4190  // cache full? compress and try again\r
4191  if(iCache==0xffff)\r
4192   {\r
4193    CompressTextureSpace();\r
4194    OPtr=CheckTextureInSubSCache(TextureMode,GivenClutId,&iCache);\r
4195   }\r
4196 \r
4197  // found? fine\r
4198  usLRUTexPage=iCache;\r
4199  if(!OPtr) return uiStexturePage[iCache];\r
4200 \r
4201  // not found? upload texture and store infos in cache\r
4202  gTexName=uiStexturePage[iCache];\r
4203  LoadSubTexFn(GlobalTexturePage,TextureMode,cx,cy);\r
4204  uiStexturePage[iCache]=gTexName;\r
4205  *OPtr=ubOpaqueDraw;\r
4206  return (GLuint) gTexName;\r
4207 }\r
4208 \r
4209 /////////////////////////////////////////////////////////////////////////////\r
4210 /////////////////////////////////////////////////////////////////////////////\r
4211 /////////////////////////////////////////////////////////////////////////////\r