source/rice_gles/src/RenderBase.cpp

   1 /*
   2 Copyright (C) 2003 Rice1964
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17
  18 */
  19
  20 #include <cmath>
  21 #include <vector>
  22
  23 #include "osal_preproc.h"
  24 #include "float.h"
  25 #include "DeviceBuilder.h"
  26 #include "VertexShaderConstantDef.h"
  27 #include "Render.h"
  28 #include "Timing.h"
  29
  30 extern FiddledVtx * g_pVtxBase;
  31
  32 #define ENABLE_CLIP_TRI
  33 #define X_CLIP_MAX  0x1
  34 #define X_CLIP_MIN  0x2
  35 #define Y_CLIP_MAX  0x4
  36 #define Y_CLIP_MIN  0x8
  37 #define Z_CLIP_MAX  0x10
  38 #define Z_CLIP_MIN  0x20
  39
  40 #ifdef ENABLE_CLIP_TRI
  41
  42 inline void RSP_Vtx_Clipping(int i)
  43 {
  44     g_clipFlag[i] = 0;
  45     g_clipFlag2[i] = 0;
  46     if( g_vecProjected[i].w > 0 )
  47     {
  48         /*
  49         if( gRSP.bRejectVtx )
  50         {
  51             if( g_vecProjected[i].x > 1 )
  52             {
  53                 g_clipFlag2[i] |= X_CLIP_MAX;
  54                 if( g_vecProjected[i].x > gRSP.real_clip_ratio_posx )
  55                     g_clipFlag[i] |= X_CLIP_MAX;
  56             }
  57
  58             if( g_vecProjected[i].x < -1 )
  59             {
  60                 g_clipFlag2[i] |= X_CLIP_MIN;
  61                 if( g_vecProjected[i].x < gRSP.real_clip_ratio_negx )
  62                     g_clipFlag[i] |= X_CLIP_MIN;
  63             }
  64
  65             if( g_vecProjected[i].y > 1 )
  66             {
  67                 g_clipFlag2[i] |= Y_CLIP_MAX;
  68                 if( g_vecProjected[i].y > gRSP.real_clip_ratio_posy )
  69                     g_clipFlag[i] |= Y_CLIP_MAX;
  70             }
  71
  72             if( g_vecProjected[i].y < -1 )
  73             {
  74                 g_clipFlag2[i] |= Y_CLIP_MIN;
  75                 if( g_vecProjected[i].y < gRSP.real_clip_ratio_negy )
  76                     g_clipFlag[i] |= Y_CLIP_MIN;
  77             }
  78
  79             //if( g_vecProjected[i].z > 1.0f )
  80             //{
  81             //  g_clipFlag2[i] |= Z_CLIP_MAX;
  82             //  g_clipFlag[i] |= Z_CLIP_MAX;
  83             //}
  84
  85             //if( gRSP.bNearClip && g_vecProjected[i].z < -1.0f )
  86             //{
  87             //  g_clipFlag2[i] |= Z_CLIP_MIN;
  88             //  g_clipFlag[i] |= Z_CLIP_MIN;
  89             //}
  90         }
  91         else
  92         */
  93         {
  94             if( g_vecProjected[i].x > 1 )   g_clipFlag2[i] |= X_CLIP_MAX;
  95             if( g_vecProjected[i].x < -1 )  g_clipFlag2[i] |= X_CLIP_MIN;
  96             if( g_vecProjected[i].y > 1 )   g_clipFlag2[i] |= Y_CLIP_MAX;
  97             if( g_vecProjected[i].y < -1 )  g_clipFlag2[i] |= Y_CLIP_MIN;
  98             //if( g_vecProjected[i].z > 1.0f )  g_clipFlag2[i] |= Z_CLIP_MAX;
  99             //if( gRSP.bNearClip && g_vecProjected[i].z < -1.0f )   g_clipFlag2[i] |= Z_CLIP_MIN;
 100         }
 101
 102     }
 103 }
 104
 105 #else
 106 inline void RSP_Vtx_Clipping(int i) {}
 107 #endif
 108
 109 /*
 110  *  Global variables
 111  */
 112 ALIGN(16,RSP_Options gRSP)
 113 ALIGN(16,RDP_Options gRDP)
 114
 115 static ALIGN(16,XVECTOR4 g_normal)
 116 //static int norms[3];
 117
 118 ALIGN(16,XVECTOR4 g_vtxNonTransformed[MAX_VERTS])
 119 ALIGN(16,XVECTOR4 g_vecProjected[MAX_VERTS])
 120 ALIGN(16,XVECTOR4 g_vtxTransformed[MAX_VERTS])
 121
 122 float       g_vtxProjected5[1000][5];
 123 float       g_vtxProjected5Clipped[2000][5];
 124
 125 //uint32        g_dwVtxFlags[MAX_VERTS];            // Z_POS Z_NEG etc
 126 VECTOR2     g_fVtxTxtCoords[MAX_VERTS];
 127 uint32      g_dwVtxDifColor[MAX_VERTS];
 128 uint32      g_clipFlag[MAX_VERTS];
 129 uint32      g_clipFlag2[MAX_VERTS];
 130 RenderTexture g_textures[MAX_TEXTURES];
 131 float       g_fFogCoord[MAX_VERTS];
 132
 133 EXTERNAL_VERTEX g_vtxForExternal[MAX_VERTS];
 134
 135 TLITVERTEX          g_vtxBuffer[1000];
 136 TLITVERTEX          g_clippedVtxBuffer[2000];
 137 uint8               g_oglVtxColors[1000][4];
 138 int                 g_clippedVtxCount=0;
 139 TLITVERTEX          g_texRectTVtx[4];
 140 unsigned short      g_vtxIndex[1000];
 141 unsigned int        g_minIndex, g_maxIndex;
 142
 143 float               gRSPfFogMin;
 144 float               gRSPfFogMax;
 145 float               gRSPfFogDivider;
 146
 147 uint32          gRSPnumLights;
 148 Light   gRSPlights[16];
 149
 150 ALIGN(16,Matrix  gRSPworldProjectTransported)
 151 ALIGN(16,Matrix  gRSPworldProject)
 152 ALIGN(16,Matrix  gRSPmodelViewTop)
 153 ALIGN(16,Matrix  gRSPmodelViewTopTranspose)
 154 ALIGN(16,Matrix  dkrMatrixTransposed)
 155
 156 N64Light        gRSPn64lights[16];
 157
 158
 159 void (*ProcessVertexData)(uint32 dwAddr, uint32 dwV0, uint32 dwNum)=NULL;
 160
 161 /*
 162  *
 163  */
 164
 165
 166 /*n.x = (g_normal.x * matWorld.m00) + (g_normal.y * matWorld.m10) + (g_normal.z * matWorld.m20);
 167 n.y = (g_normal.x * matWorld.m01) + (g_normal.y * matWorld.m11) + (g_normal.z * matWorld.m21);
 168 n.z = (g_normal.x * matWorld.m02) + (g_normal.y * matWorld.m12) + (g_normal.z * matWorld.m22);*/
 169
 170 // Multiply (x,y,z,0) by matrix m, then normalize
 171 #if defined(__INTEL_COMPILER) && !defined(NO_ASM)
 172 #define Vec3TransformNormal(vec, m) __asm                   \
 173 {                                       \
 174     __asm fld   dword ptr [vec + 0]     \
 175     __asm fmul  dword ptr [m + 0]       \ /* x m00*/
 176     __asm fld   dword ptr [vec + 0]     \
 177     __asm fmul  dword ptr [m + 4]       \ /* x m01  x m00*/
 178     __asm fld   dword ptr [vec + 0]     \
 179     __asm fmul  dword ptr [m + 8]       \ /* x m02  x m01  x m00*/
 180                                         \
 181     __asm fld   dword ptr [vec + 4]     \
 182     __asm fmul  dword ptr [m + 16]      \ /* y m10  x m02  x m01  x m00*/
 183     __asm fld   dword ptr [vec + 4]     \
 184     __asm fmul  dword ptr [m + 20]      \ /* y m11  y m10  x m02  x m01  x m00*/
 185     __asm fld   dword ptr [vec + 4]     \
 186     __asm fmul  dword ptr [m + 24]      \ /* y m12  y m11  y m10  x m02  x m01  x m00*/
 187                                         \
 188     __asm fxch  st(2)                   \ /* y m10  y m11  y m12  x m02  x m01  x m00*/
 189     __asm faddp st(5), st(0)            \ /* y m11  y m12  x m02  x m01  (x m00 + y m10)*/
 190     __asm faddp st(3), st(0)            \ /* y m12  x m02  (x m01 + ym11)  (x m00 + y m10)*/
 191     __asm faddp st(1), st(0)            \ /* (x m02 + y m12) (x m01 + ym11)  (x m00 + y m10)*/
 192                                         \
 193     __asm fld   dword ptr [vec + 8]     \
 194     __asm fmul  dword ptr [m + 32]      \ /* z m20  (x m02 + y m12) (x m01 + ym11)  (x m00 + y m10)*/
 195     __asm fld   dword ptr [vec + 8]     \
 196     __asm fmul  dword ptr [m + 36]      \ /* z m21  z m20  (x m02 + y m12) (x m01 + ym11)  (x m00 + y m10)*/
 197     __asm fld   dword ptr [vec + 8]     \
 198     __asm fmul  dword ptr [m + 40]      \ /* z m22  z m21  z m20  (x m02 + y m12) (x m01 + ym11)  (x m00 + y m10)*/
 199                                         \
 200     __asm fxch  st(2)                   \ /* z m20  z m21  z m22  (x m02 + y m12) (x m01 + ym11)  (x m00 + y m10)*/
 201     __asm faddp st(5), st(0)            \ /* z m21  z m22  (x m02 + y m12) (x m01 + ym11)  (x m00 + y m10 + z m20)*/
 202     __asm faddp st(3), st(0)            \ /* z m22  (x m02 + y m12) (x m01 + ym11 + z m21)  (x m00 + y m10 + z m20)*/
 203     __asm faddp st(1), st(0)            \ /* (x m02 + y m12 + z m 22) (x m01 + ym11 + z m21)  (x m00 + y m10 + z m20)*/
 204                                         \
 205     __asm fxch  st(2)                   \ /* (x m00 + y m10 + z m20) (x m01 + ym11 + z m21) (x m02 + y m12 + z m 22) */
 206                                         \
 207     __asm fld1                          \ /* 1 x y z */
 208     __asm fld   st(1)                   \ /* x 1 x y z */
 209     __asm fmul  st(0),st(0)             \ /* xx 1 x y z */
 210     __asm fld   st(3)                   \ /* y xx 1 x y z */
 211     __asm fmul  st(0),st(0)             \ /* yy xx 1 x y z */
 212     __asm fld   st(5)                   \ /* z yy xx 1 x y z */
 213     __asm fmul  st(0),st(0)             \ /* zz yy xx 1 x y z */
 214                                         \
 215     __asm fxch  st(2)                   \ /* xx yy zz 1 x y z */
 216                                         \
 217     __asm faddp st(1),st(0)             \ /* (xx+yy) zz 1 x y z */
 218     __asm faddp st(1),st(0)             \ /* (xx+yy+zz) 1 x y z */
 219                                         \
 220     __asm ftst                          \ /* Compare ST to 0  */
 221     __asm fstsw ax                      \ /* Store FPU status word in a   */
 222     __asm sahf                          \ /* Transfer ax to flags register */
 223     __asm jz        l2                  \ /* Skip if length is zero   */
 224                                         \
 225     __asm fsqrt                         \ /* l 1 x y z */
 226                                         \
 227     __asm fdivp st(1),st(0)             \ /* (1/l) x y z */
 228                                         \
 229     __asm fmul  st(3),st(0)             \ /* f x y fz */
 230     __asm fmul  st(2),st(0)             \ /* f x fy fz */
 231     __asm fmulp st(1),st(0)             \ /* fx fy fz */
 232                                         \
 233     __asm fstp  dword ptr [vec + 0]     \ /* fy fz*/
 234     __asm fstp  dword ptr [vec + 4]     \ /* fz   */
 235     __asm fstp  dword ptr [vec + 8]     \ /* done */
 236     __asm jmp   l3                      \
 237 __asm l2:                               \
 238     __asm mov dword ptr [vec + 0], 0    \
 239     __asm mov dword ptr [vec + 4], 0    \
 240     __asm mov dword ptr [vec + 8], 0    \
 241 __asm l3:                               \
 242 }                                       \
 243
 244 //#else  // use C code in other cases, this is probably faster anyway
 245 #elif defined(__ARM_NEON__0)
 246 #define Vec3TransformNormal(vec, mtx) \
 247 { \
 248         asm volatile ( \
 249         "vld1.32                {d0}, [%0]                      \n\t" \
 250         "flds                   s2, [%0, #8]                    \n\t" \
 251         "vld1.32                {d18, d19}, [%1]                \n\t" \
 252         "vld1.32                {d20, d21}, [%1, #16]       \n\t" \
 253         "vld1.32                {d22, d23}, [%1, #32]       \n\t" \
 254  \
 255         "vmul.f32               q2, q9, d0[0]                   \n\t" \
 256         "vmla.f32               q2, q10, d0[1]                  \n\t" \
 257         "vmla.f32               q2, q11, d1[0]                  \n\t" \
 258  \
 259     "vmul.f32           d0, d4, d4                              \n\t" \
 260         "vpadd.f32              d0, d0, d0                              \n\t" \
 261     "vmla.f32           d0, d5, d5                              \n\t" \
 262  \
 263         "vmov.f32               d1, d0                                  \n\t" \
 264         "vrsqrte.f32    d0, d0                                  \n\t" \
 265         "vmul.f32               d2, d0, d1                              \n\t" \
 266         "vrsqrts.f32    d3, d2, d0                              \n\t" \
 267         "vmul.f32               d0, d0, d3                              \n\t" \
 268         "vmul.f32               d2, d0, d1                              \n\t" \
 269         "vrsqrts.f32    d3, d2, d0                              \n\t" \
 270         "vmul.f32               d0, d0, d3                              \n\t" \
 271  \
 272         "vmul.f32               q2, q2, d0[0]                   \n\t" \
 273  \
 274         "vst1.32                {d4}, [%0]                  \n\t" \
 275         "fsts                   s10, [%0, #8]           \n\t" \
 276         : :"r"(vec), "r"(&mtx._11) \
 277     : "d0","d1","d2","d3","d18","d19","d20","d21","d22", "d23", "memory" \
 278         ); \
 279 }
 280 #else
 281 #define Vec3TransformNormal(vec, m) \
 282    VECTOR3 temp; \
 283    temp.x = (vec.x * m._11) + (vec.y * m._21) + (vec.z * m._31); \
 284    temp.y = (vec.x * m._12) + (vec.y * m._22) + (vec.z * m._32); \
 285    temp.z = (vec.x * m._13) + (vec.y * m._23) + (vec.z * m._33); \
 286    float norm = sqrtf(temp.x*temp.x+temp.y*temp.y+temp.z*temp.z); \
 287    if (norm == 0.0) { vec.x = 0.0; vec.y = 0.0; vec.z = 0.0;} else \
 288    { float rep=1/norm;vec.x = temp.x*rep; vec.y = temp.y*rep; vec.z = temp.z*rep; }
 289 #endif
 290
 291
 292 #if !defined(__GNUC__) && !defined(NO_ASM)
 293 __declspec( naked ) void  __fastcall SSEVec3Transform(int i)
 294 {
 295     __asm
 296     {
 297         shl     ecx,4;      // ecx = i
 298
 299         movaps  xmm1,   DWORD PTR g_vtxNonTransformed [ecx];        // xmm1 as original vector
 300
 301         movaps  xmm4,   DWORD PTR gRSPworldProjectTransported;          // row1
 302         movaps  xmm5,   DWORD PTR gRSPworldProjectTransported[0x10];    // row2
 303         movaps  xmm6,   DWORD PTR gRSPworldProjectTransported[0x20];    // row3
 304         movaps  xmm7,   DWORD PTR gRSPworldProjectTransported[0x30];    // row4
 305
 306         mulps   xmm4, xmm1;     // row 1
 307         mulps   xmm5, xmm1;     // row 2
 308         mulps   xmm6, xmm1;     // row 3
 309         mulps   xmm7, xmm1;     // row 4
 310
 311         movhlps xmm0, xmm4;     // xmm4 high to xmm0 low
 312         movlhps xmm0, xmm5;     // xmm5 low to xmm0 high
 313
 314         addps   xmm4, xmm0;     // result of add are in xmm4 low
 315         addps   xmm5, xmm0;     // result of add are in xmm5 high
 316
 317         shufps  xmm0, xmm4, 0x44;   // move xmm4 low DWORDs to xmm0 high
 318         shufps  xmm4, xmm5, 0xe4;   // move xmm5 high DWORS to xmm4
 319         movhlps xmm5, xmm0;         // xmm4, xmm5 are mirrored
 320
 321         shufps  xmm4, xmm4, 0x08;   // move xmm4's 3rd uint32 to its 2nd uint32
 322         shufps  xmm5, xmm5, 0x0d;   // move xmm5's 4th uint32 to its 2nd uint32,
 323                                     // and move its 2nd uint32 to its 1st uint32
 324
 325         addps   xmm4, xmm5;     // results are in 1st and 2nd uint32
 326
 327
 328         movhlps xmm0, xmm6;     // xmm6 high to xmm0 low
 329         movlhps xmm0, xmm7;     // xmm7 low to xmm0 high
 330
 331         addps   xmm6, xmm0;     // result of add are in xmm6 low
 332         addps   xmm7, xmm0;     // result of add are in xmm7 high
 333
 334         shufps  xmm0, xmm6, 0x44;   // move xmm6 low DWORDs to xmm0 high
 335         shufps  xmm6, xmm7, 0xe4;   // move xmm7 high DWORS to xmm6
 336         movhlps xmm7, xmm0;         // xmm6, xmm7 are mirrored
 337
 338         shufps  xmm6, xmm6, 0x08;   // move xmm6's 3rd uint32 to its 2nd uint32
 339         shufps  xmm7, xmm7, 0x0d;   // move xmm7's 4th uint32 to its 2nd uint32,
 340                                     // and move its 2nd uint32 to its 1st uint32
 341
 342         addps   xmm6, xmm7;     // results are in 1st and 2nd uint32
 343
 344         movlhps xmm4, xmm6;     // final result is in xmm4
 345         movaps  DWORD PTR g_vtxTransformed [ecx], xmm4;
 346
 347         movaps  xmm0,xmm4;
 348         shufps  xmm0,xmm0,0xff;
 349         divps   xmm4,xmm0;
 350         rcpps   xmm0,xmm0;
 351         movhlps xmm0,xmm4;
 352         shufps  xmm0,xmm0,0xe8;
 353         movlhps xmm4,xmm0;
 354
 355         movaps  DWORD PTR g_vecProjected [ecx], xmm4;
 356
 357         emms;
 358         ret;
 359     }
 360 }
 361
 362 // Only used by DKR
 363 __declspec( naked ) void  __fastcall SSEVec3TransformDKR(XVECTOR4 &pOut, const XVECTOR4 &pV)
 364 {
 365     __asm
 366     {
 367         movaps  xmm1,   DWORD PTR [edx];        // xmm1 as original vector
 368
 369         movaps  xmm4,   DWORD PTR dkrMatrixTransposed;  // row1
 370         movaps  xmm5,   DWORD PTR dkrMatrixTransposed[0x10];    // row2
 371         movaps  xmm6,   DWORD PTR dkrMatrixTransposed[0x20];    // row3
 372         movaps  xmm7,   DWORD PTR dkrMatrixTransposed[0x30];    // row4
 373
 374         mulps   xmm4, xmm1;     // row 1
 375         mulps   xmm5, xmm1;     // row 2
 376         mulps   xmm6, xmm1;     // row 3
 377         mulps   xmm7, xmm1;     // row 4
 378
 379         movhlps xmm0, xmm4;     // xmm4 high to xmm0 low
 380         movlhps xmm0, xmm5;     // xmm5 low to xmm0 high
 381
 382         addps   xmm4, xmm0;     // result of add are in xmm4 low
 383         addps   xmm5, xmm0;     // result of add are in xmm5 high
 384
 385         shufps  xmm0, xmm4, 0x44;   // move xmm4 low DWORDs to xmm0 high
 386         shufps  xmm4, xmm5, 0xe4;   // move xmm5 high DWORS to xmm4
 387         movhlps xmm5, xmm0;         // xmm4, xmm5 are mirrored
 388
 389         shufps  xmm4, xmm4, 0x08;   // move xmm4's 3rd uint32 to its 2nd uint32
 390         shufps  xmm5, xmm5, 0x0d;   // move xmm5's 4th uint32 to its 2nd uint32,
 391         // and move its 2nd uint32 to its 1st uint32
 392
 393         addps   xmm4, xmm5;     // results are in 1st and 2nd uint32
 394
 395
 396         movhlps xmm0, xmm6;     // xmm6 high to xmm0 low
 397         movlhps xmm0, xmm7;     // xmm7 low to xmm0 high
 398
 399         addps   xmm6, xmm0;     // result of add are in xmm6 low
 400         addps   xmm7, xmm0;     // result of add are in xmm7 high
 401
 402         shufps  xmm0, xmm6, 0x44;   // move xmm6 low DWORDs to xmm0 high
 403         shufps  xmm6, xmm7, 0xe4;   // move xmm7 high DWORS to xmm6
 404         movhlps xmm7, xmm0;         // xmm6, xmm7 are mirrored
 405
 406         shufps  xmm6, xmm6, 0x08;   // move xmm6's 3rd uint32 to its 2nd uint32
 407         shufps  xmm7, xmm7, 0x0d;   // move xmm7's 4th uint32 to its 2nd uint32,
 408         // and move its 2nd uint32 to its 1st uint32
 409
 410         addps   xmm6, xmm7;     // results are in 1st and 2nd uint32
 411
 412         movlhps xmm4, xmm6;     // final result is in xmm4
 413         movaps  DWORD PTR [ecx], xmm4;
 414
 415         emms;
 416         ret;
 417     }
 418 }
 419 #elif defined(__GNUC__) && defined(__x86_64__) && !defined(NO_ASM)
 420 void SSEVec3Transform(int i)
 421 {
 422   asm volatile(" shl               $4,      %0   \n"
 423                " movslq           %k0,     %q0   \n"
 424                " movaps      (%1,%q0),  %%xmm1   \n"
 425                " movaps         0(%2),  %%xmm4   \n"
 426                " movaps        16(%2),  %%xmm5   \n"
 427                " movaps        32(%2),  %%xmm6   \n"
 428                " movaps        48(%2),  %%xmm7   \n"
 429                " mulps         %%xmm1,  %%xmm4   \n"
 430                " mulps         %%xmm1,  %%xmm5   \n"
 431                " mulps         %%xmm1,  %%xmm6   \n"
 432                " mulps         %%xmm1,  %%xmm7   \n"
 433                " movhlps       %%xmm4,  %%xmm0   \n"
 434                " movlhps       %%xmm5,  %%xmm0   \n"
 435                " addps         %%xmm0,  %%xmm4   \n"
 436                " addps         %%xmm0,  %%xmm5   \n"
 437                " shufps $0x44, %%xmm4,  %%xmm0   \n"
 438                " shufps $0xe4, %%xmm5,  %%xmm4   \n"
 439                " movhlps       %%xmm0,  %%xmm5   \n"
 440                " shufps $0x08, %%xmm4,  %%xmm4   \n"
 441                " shufps $0x0d, %%xmm5,  %%xmm5   \n"
 442                " addps         %%xmm5,  %%xmm4   \n"
 443                " movhlps       %%xmm6,  %%xmm0   \n"
 444                " movlhps       %%xmm7,  %%xmm0   \n"
 445                " addps         %%xmm0,  %%xmm6   \n"
 446                " addps         %%xmm0,  %%xmm7   \n"
 447                " shufps $0x44, %%xmm6,  %%xmm0   \n"
 448                " shufps $0xe4, %%xmm7,  %%xmm6   \n"
 449                " movhlps       %%xmm0,  %%xmm7   \n"
 450                " shufps $0x08, %%xmm6,  %%xmm6   \n"
 451                " shufps $0x0d, %%xmm7,  %%xmm7   \n"
 452                " addps         %%xmm7,  %%xmm6   \n"
 453                " movlhps       %%xmm6,  %%xmm4   \n"
 454                " movaps        %%xmm4, (%3,%q0)  \n"
 455                " movaps        %%xmm4,  %%xmm0   \n"
 456                " shufps $0xff, %%xmm0,  %%xmm0   \n"
 457                " divps         %%xmm0,  %%xmm4   \n"
 458                " rcpps         %%xmm0,  %%xmm0   \n"
 459                " movhlps       %%xmm4,  %%xmm0   \n"
 460                " shufps $0xe8, %%xmm0,  %%xmm0   \n"
 461                " movlhps       %%xmm0,  %%xmm4   \n"
 462                " movaps        %%xmm4, (%4,%q0)  \n"
 463                : "+r"(i)
 464                : "r"(g_vtxNonTransformed), "r"(&gRSPworldProjectTransported.m[0][0]), "r"(g_vtxTransformed), "r"(g_vecProjected)
 465                : "memory", "%xmm0", "%xmm1", "%xmm4", "%xmm5", "%xmm6", "%xmm7"
 466                );
 467 }
 468 #elif !defined(NO_ASM) // 32-bit GCC assumed
 469 void SSEVec3Transform(int i)
 470 {
 471   asm volatile(" shl               $4,      %0   \n"
 472                " movaps       (%1,%0),  %%xmm1   \n"
 473                " movaps         0(%2),  %%xmm4   \n"
 474                " movaps        16(%2),  %%xmm5   \n"
 475                " movaps        32(%2),  %%xmm6   \n"
 476                " movaps        48(%2),  %%xmm7   \n"
 477                " mulps         %%xmm1,  %%xmm4   \n"
 478                " mulps         %%xmm1,  %%xmm5   \n"
 479                " mulps         %%xmm1,  %%xmm6   \n"
 480                " mulps         %%xmm1,  %%xmm7   \n"
 481                " movhlps       %%xmm4,  %%xmm0   \n"
 482                " movlhps       %%xmm5,  %%xmm0   \n"
 483                " addps         %%xmm0,  %%xmm4   \n"
 484                " addps         %%xmm0,  %%xmm5   \n"
 485                " shufps $0x44, %%xmm4,  %%xmm0   \n"
 486                " shufps $0xe4, %%xmm5,  %%xmm4   \n"
 487                " movhlps       %%xmm0,  %%xmm5   \n"
 488                " shufps $0x08, %%xmm4,  %%xmm4   \n"
 489                " shufps $0x0d, %%xmm5,  %%xmm5   \n"
 490                " addps         %%xmm5,  %%xmm4   \n"
 491                " movhlps       %%xmm6,  %%xmm0   \n"
 492                " movlhps       %%xmm7,  %%xmm0   \n"
 493                " addps         %%xmm0,  %%xmm6   \n"
 494                " addps         %%xmm0,  %%xmm7   \n"
 495                " shufps $0x44, %%xmm6,  %%xmm0   \n"
 496                " shufps $0xe4, %%xmm7,  %%xmm6   \n"
 497                " movhlps       %%xmm0,  %%xmm7   \n"
 498                " shufps $0x08, %%xmm6,  %%xmm6   \n"
 499                " shufps $0x0d, %%xmm7,  %%xmm7   \n"
 500                " addps         %%xmm7,  %%xmm6   \n"
 501                " movlhps       %%xmm6,  %%xmm4   \n"
 502                " movaps        %%xmm4,  (%3,%0)  \n"
 503                " movaps        %%xmm4,  %%xmm0   \n"
 504                " shufps $0xff, %%xmm0,  %%xmm0   \n"
 505                " divps         %%xmm0,  %%xmm4   \n"
 506                " rcpps         %%xmm0,  %%xmm0   \n"
 507                " movhlps       %%xmm4,  %%xmm0   \n"
 508                " shufps $0xe8, %%xmm0,  %%xmm0   \n"
 509                " movlhps       %%xmm0,  %%xmm4   \n"
 510                " movaps        %%xmm4,  (%4,%0)  \n"
 511                : "+r"(i)
 512                : "r"(g_vtxNonTransformed), "r"(&gRSPworldProjectTransported.m[0][0]), "r"(g_vtxTransformed), "r"(g_vecProjected)
 513                : "memory", "%xmm0", "%xmm1", "%xmm4", "%xmm5", "%xmm6", "%xmm7"
 514                );
 515 }
 516 #endif
 517 float real255 = 255.0f;
 518 float real128 = 128.0f;
 519
 520 #if !defined(__GNUC__) && !defined(NO_ASM)
 521 __declspec( naked ) void  __fastcall SSEVec3TransformNormal()
 522 {
 523     __asm
 524     {
 525         mov     DWORD PTR [g_normal][12], 0;
 526
 527         movaps  xmm4,   DWORD PTR gRSPmodelViewTopTranspose;    // row1
 528         movaps  xmm5,   DWORD PTR gRSPmodelViewTopTranspose[0x10];  // row2
 529         movaps  xmm1,   DWORD PTR [g_normal];       // xmm1 as the normal vector
 530         movaps  xmm6,   DWORD PTR gRSPmodelViewTopTranspose[0x20];  // row3
 531
 532         mulps   xmm4, xmm1;     // row 1
 533         mulps   xmm5, xmm1;     // row 2
 534         mulps   xmm6, xmm1;     // row 3
 535
 536         movhlps xmm0, xmm4;     // xmm4 high to xmm0 low
 537         movlhps xmm0, xmm5;     // xmm5 low to xmm0 high
 538
 539         addps   xmm4, xmm0;     // result of add are in xmm4 low
 540         addps   xmm5, xmm0;     // result of add are in xmm5 high
 541
 542         shufps  xmm0, xmm4, 0x44;   // move xmm4 low DWORDs to xmm0 high
 543         shufps  xmm4, xmm5, 0xe4;   // move xmm5 high DWORS to xmm4
 544         movhlps xmm5, xmm0;         // xmm4, xmm5 are mirrored
 545
 546         shufps  xmm4, xmm4, 0x08;   // move xmm4's 3rd uint32 to its 2nd uint32
 547         shufps  xmm5, xmm5, 0x0d;   // move xmm5's 4th uint32 to its 2nd uint32,
 548
 549         addps   xmm4, xmm5;     // results are in 1st and 2nd uint32
 550
 551         movaps  xmm1,xmm4;
 552         mulps   xmm1,xmm1;  //square
 553         movlhps xmm7, xmm1;
 554         shufps  xmm7, xmm7,0x03;
 555         addss   xmm7, xmm1;
 556
 557         movhlps xmm0, xmm6;     // xmm6 high to xmm0 low
 558         addps   xmm6, xmm0;     // result of add are in xmm6 low
 559
 560         movlhps xmm0, xmm6;
 561         shufps  xmm0, xmm0, 0x03;
 562         addss   xmm0, xmm6;     // result of add is at xmm0's 1st uint32
 563
 564         movlhps xmm4, xmm0;
 565
 566         mulss   xmm0,xmm0;
 567         addss   xmm7,xmm0;      // xmm7 1st uint32 is the sum of squares
 568
 569 #ifdef DEBUGGER
 570         movaps  DWORD PTR [g_normal], xmm4;
 571         movss  DWORD PTR [g_normal][12], xmm7;
 572 #endif
 573         xorps   xmm0,xmm0;
 574         ucomiss xmm0,xmm7;
 575         jz      l2
 576
 577         rsqrtss xmm7,xmm7;
 578         shufps  xmm7,xmm7,0;
 579 #ifdef DEBUGGER
 580         movss  DWORD PTR [g_normal][12], xmm7;
 581 #endif
 582         mulps   xmm4,xmm7;
 583
 584         movaps  DWORD PTR [g_normal], xmm4;     // Normalized
 585         mov     DWORD PTR [g_normal][12], 0;
 586
 587         emms;
 588         ret;
 589 l2:
 590         movss   DWORD PTR [g_normal], xmm0;
 591         movss   DWORD PTR [g_normal][12], xmm0;
 592         emms;
 593         ret;
 594     }
 595 }
 596 #elif defined(__GNUC__) && !defined(NO_ASM)  // this code should compile for both 64-bit and 32-bit architectures
 597 void SSEVec3TransformNormal(void)
 598 {
 599   asm volatile(" movl              $0,  12(%0)    \n"
 600            " movaps          (%1),  %%xmm4    \n"
 601            " movaps        16(%1),  %%xmm5    \n"
 602            " movaps          (%0),  %%xmm1    \n"
 603            " movaps        32(%1),  %%xmm6    \n"
 604            " mulps         %%xmm1,  %%xmm4    \n"
 605            " mulps         %%xmm1,  %%xmm5    \n"
 606            " mulps         %%xmm1,  %%xmm6    \n"
 607            " movhlps       %%xmm4,  %%xmm0    \n"
 608            " movlhps       %%xmm5,  %%xmm0    \n"
 609            " addps         %%xmm0,  %%xmm4    \n"
 610            " addps         %%xmm0,  %%xmm5    \n"
 611            " shufps $0x44, %%xmm4,  %%xmm0    \n"
 612            " shufps $0xe4, %%xmm5,  %%xmm4    \n"
 613            " movhlps       %%xmm0,  %%xmm5    \n"
 614            " shufps $0x08, %%xmm4,  %%xmm4    \n"
 615            " shufps $0x0d, %%xmm5,  %%xmm5    \n"
 616            " addps         %%xmm5,  %%xmm4    \n"
 617            " movaps        %%xmm4,  %%xmm1    \n"
 618            " mulps         %%xmm1,  %%xmm1    \n"
 619            " movlhps       %%xmm1,  %%xmm7    \n"
 620            " shufps $0x03, %%xmm7,  %%xmm7    \n"
 621            " addss         %%xmm1,  %%xmm7    \n"
 622            " movhlps       %%xmm6,  %%xmm0    \n"
 623            " addps         %%xmm0,  %%xmm6    \n"
 624            " movlhps       %%xmm6,  %%xmm0    \n"
 625            " shufps $0x03, %%xmm0,  %%xmm0    \n"
 626            " addss         %%xmm6,  %%xmm0    \n"
 627            " movlhps       %%xmm0,  %%xmm4    \n"
 628            " mulss         %%xmm0,  %%xmm0    \n"
 629            " addss         %%xmm0,  %%xmm7    \n"
 630 #ifdef DEBUGGER
 631            " movaps        %%xmm4,    (%0)    \n"
 632            " movss         %%xmm7,  12(%0)    \n"
 633 #endif
 634            " xorps         %%xmm0,  %%xmm0    \n"
 635            " ucomiss       %%xmm7,  %%xmm0    \n"
 636            " jz                0f             \n"
 637            " rsqrtss       %%xmm7,  %%xmm7    \n"
 638            " shufps $0x00, %%xmm7,  %%xmm7    \n"
 639 #ifdef DEBUGGER
 640            " movss         %%xmm7,  12(%0)    \n"
 641 #endif
 642                " mulps         %%xmm7,  %%xmm4    \n"
 643                " movaps        %%xmm4,    (%0)    \n"
 644                " movl              $0,  12(%0)    \n"
 645                " jmp               1f             \n"
 646                "0:                                \n"
 647                " movss         %%xmm0,    (%0)    \n"
 648                " movss         %%xmm0,  12(%0)    \n"
 649                "1:                                \n"
 650                :
 651                : "r"(&g_normal.x), "r"(&gRSPmodelViewTopTranspose.m[0][0])
 652                : "memory", "cc", "%xmm0", "%xmm1", "%xmm4", "%xmm5", "%xmm6", "%xmm7"
 653                );
 654 }
 655 #endif
 656
 657 void NormalizeNormalVec()
 658 #ifdef __ARM_NEON__0
 659 {
 660         asm volatile (
 661         "vld1.32                {d4}, [%0]                      \n\t"   //d4={x,y}
 662         "flds                   s10, [%0, #8]                   \n\t"   //d5[0] = z
 663 //      "sub                    %0, %0, #8              \n\t"   //d5[0] = z
 664         "vmul.f32               d0, d4, d4                              \n\t"   //d0= d4*d4
 665         "vpadd.f32              d0, d0, d0                              \n\t"   //d0 = d[0] + d[1]
 666     "vmla.f32           d0, d5, d5                              \n\t"   //d0 = d0 + d5*d5
 667
 668         "vmov.f32               d1, d0                                  \n\t"   //d1 = d0
 669         "vrsqrte.f32    d0, d0                                  \n\t"   //d0 = ~ 1.0 / sqrt(d0)
 670         "vmul.f32               d2, d0, d1                              \n\t"   //d2 = d0 * d1
 671         "vrsqrts.f32    d3, d2, d0                              \n\t"   //d3 = (3 - d0 * d2) / 2
 672         "vmul.f32               d0, d0, d3                              \n\t"   //d0 = d0 * d3
 673         "vmul.f32               d2, d0, d1                              \n\t"   //d2 = d0 * d1
 674         "vrsqrts.f32    d3, d2, d0                              \n\t"   //d3 = (3 - d0 * d3) / 2
 675         "vmul.f32               d0, d0, d3                              \n\t"   //d0 = d0 * d4
 676
 677         "vmul.f32               q2, q2, d0[0]                   \n\t"   //d0= d2*d4
 678         "vst1.32                {d4}, [%0]                      \n\t"   //d2={x0,y0}, d3={z0, w0}
 679         "fsts                   s10, [%0, #8]                           \n\t"   //d2={x0,y0}, d3={z0, w0}
 680
 681         ::"r"(g_normal)
 682     : "d0", "d1", "d2", "d3", "d4", "d5", "memory"
 683         );
 684 }
 685 #else
 686 {
 687     float w = 1/sqrtf(g_normal.x*g_normal.x + g_normal.y*g_normal.y + g_normal.z*g_normal.z);
 688     g_normal.x *= w;
 689     g_normal.y *= w;
 690     g_normal.z *= w;
 691 }
 692 #endif
 693
 694 void InitRenderBase()
 695 {
 696 #if !defined(NO_ASM)
 697     if( status.isSSEEnabled && !g_curRomInfo.bPrimaryDepthHack && options.enableHackForGames != HACK_FOR_NASCAR)
 698     {
 699         ProcessVertexData = ProcessVertexDataSSE;
 700     }
 701     else
 702 #endif
 703     {
 704         ProcessVertexData = ProcessVertexDataNoSSE;
 705     }
 706
 707     gRSPfFogMin = gRSPfFogMax = 0.0f;
 708     windowSetting.fMultX = windowSetting.fMultY = 2.0f;
 709     windowSetting.vpLeftW = windowSetting.vpTopW = 0;
 710     windowSetting.vpRightW = windowSetting.vpWidthW = 640;
 711     windowSetting.vpBottomW = windowSetting.vpHeightW = 480;
 712     gRSP.maxZ = 0;
 713     gRSP.nVPLeftN = gRSP.nVPTopN = 0;
 714     gRSP.nVPRightN = 640;
 715     gRSP.nVPBottomN = 640;
 716     gRSP.nVPWidthN = 640;
 717     gRSP.nVPHeightN = 640;
 718     gRDP.scissor.left=gRDP.scissor.top=0;
 719     gRDP.scissor.right=gRDP.scissor.bottom=640;
 720
 721     gRSP.bLightingEnable = gRSP.bTextureGen = false;
 722     gRSP.curTile=gRSPnumLights=gRSP.ambientLightColor=gRSP.ambientLightIndex= 0;
 723     gRSP.fAmbientLightR=gRSP.fAmbientLightG=gRSP.fAmbientLightB=0;
 724     gRSP.projectionMtxTop = gRSP.modelViewMtxTop = 0;
 725     gRDP.fogColor = gRDP.primitiveColor = gRDP.envColor = gRDP.primitiveDepth = gRDP.primLODMin = gRDP.primLODFrac = gRDP.LODFrac = 0;
 726     gRDP.fPrimitiveDepth = 0;
 727     gRSP.numVertices = 0;
 728     gRSP.maxVertexID = 0;
 729     gRSP.bCullFront=false;
 730     gRSP.bCullBack=true;
 731     gRSP.bFogEnabled=gRDP.bFogEnableInBlender=false;
 732     gRSP.bZBufferEnabled=true;
 733     gRSP.shadeMode=SHADE_SMOOTH;
 734     gRDP.keyR=gRDP.keyG=gRDP.keyB=gRDP.keyA=gRDP.keyRGB=gRDP.keyRGBA = 0;
 735     gRDP.fKeyA = 0;
 736     gRSP.DKRCMatrixIndex = gRSP.dwDKRVtxAddr = gRSP.dwDKRMatrixAddr = 0;
 737     gRSP.DKRBillBoard = false;
 738
 739     gRSP.fTexScaleX = 1/32.0f;
 740     gRSP.fTexScaleY = 1/32.0f;
 741     gRSP.bTextureEnabled = FALSE;
 742
 743     gRSP.clip_ratio_left = 0;
 744     gRSP.clip_ratio_top = 0;
 745     gRSP.clip_ratio_right = 640;
 746     gRSP.clip_ratio_bottom = 480;
 747     gRSP.clip_ratio_negx = 1;
 748     gRSP.clip_ratio_negy = 1;
 749     gRSP.clip_ratio_posx = 1;
 750     gRSP.clip_ratio_posy = 1;
 751     gRSP.real_clip_scissor_left = 0;
 752     gRSP.real_clip_scissor_top = 0;
 753     gRSP.real_clip_scissor_right = 640;
 754     gRSP.real_clip_scissor_bottom = 480;
 755     windowSetting.clipping.left = 0;
 756     windowSetting.clipping.top = 0;
 757     windowSetting.clipping.right = 640;
 758     windowSetting.clipping.bottom = 480;
 759     windowSetting.clipping.width = 640;
 760     windowSetting.clipping.height = 480;
 761     windowSetting.clipping.needToClip = false;
 762     gRSP.real_clip_ratio_negx = 1;
 763     gRSP.real_clip_ratio_negy = 1;
 764     gRSP.real_clip_ratio_posx = 1;
 765     gRSP.real_clip_ratio_posy = 1;
 766
 767     gRSP.DKRCMatrixIndex=0;
 768     gRSP.DKRVtxCount=0;
 769     gRSP.DKRBillBoard = false;
 770     gRSP.dwDKRVtxAddr=0;
 771     gRSP.dwDKRMatrixAddr=0;
 772
 773
 774     gRDP.geometryMode   = 0;
 775     gRDP.otherModeL     = 0;
 776     gRDP.otherModeH     = 0;
 777     gRDP.fillColor      = 0xFFFFFFFF;
 778     gRDP.originalFillColor  =0;
 779
 780     gRSP.ucode      = 1;
 781     gRSP.vertexMult = 10;
 782     gRSP.bNearClip  = false;
 783     gRSP.bRejectVtx = false;
 784
 785     gRDP.texturesAreReloaded = false;
 786     gRDP.textureIsChanged = false;
 787     gRDP.colorsAreReloaded = false;
 788
 789     memset(&gRDP.otherMode,0,sizeof(RDP_OtherMode));
 790     memset(&gRDP.tiles,0,sizeof(Tile)*8);
 791
 792     for( int i=0; i<MAX_VERTS; i++ )
 793     {
 794         g_clipFlag[i] = 0;
 795         g_vtxNonTransformed[i].w = 1;
 796     }
 797
 798     memset(gRSPn64lights, 0, sizeof(N64Light)*16);
 799 }
 800
 801 void SetFogMinMax(float fMin, float fMax, float fMul, float fOffset)
 802 {
 803     if( fMin > fMax )
 804     {
 805         float temp = fMin;
 806         fMin = fMax;
 807         fMax = temp;
 808     }
 809
 810     {
 811         gRSPfFogMin = max(0,fMin/500-1);
 812         gRSPfFogMax = fMax/500-1;
 813     }
 814
 815     gRSPfFogDivider = 255/(gRSPfFogMax-gRSPfFogMin);
 816     CRender::g_pRender->SetFogMinMax(fMin, fMax);
 817 }
 818
 819 void InitVertexColors()
 820 {
 821 }
 822
 823 void InitVertexTextureConstants()
 824 {
 825     float scaleX;
 826     float scaleY;
 827
 828     RenderTexture &tex0 = g_textures[gRSP.curTile];
 829     //CTexture *surf = tex0.m_pCTexture;
 830     Tile &tile0 = gRDP.tiles[gRSP.curTile];
 831
 832     scaleX = gRSP.fTexScaleX;
 833     scaleY = gRSP.fTexScaleY;
 834
 835     gRSP.tex0scaleX = scaleX * tile0.fShiftScaleS/tex0.m_fTexWidth;
 836     gRSP.tex0scaleY = scaleY * tile0.fShiftScaleT/tex0.m_fTexHeight;
 837
 838     gRSP.tex0OffsetX = tile0.fhilite_sl/tex0.m_fTexWidth;
 839     gRSP.tex0OffsetY = tile0.fhilite_tl/tex0.m_fTexHeight;
 840
 841     if( CRender::g_pRender->IsTexel1Enable() )
 842     {
 843         RenderTexture &tex1 = g_textures[(gRSP.curTile+1)&7];
 844         //CTexture *surf = tex1.m_pCTexture;
 845         Tile &tile1 = gRDP.tiles[(gRSP.curTile+1)&7];
 846
 847         gRSP.tex1scaleX = scaleX * tile1.fShiftScaleS/tex1.m_fTexWidth;
 848         gRSP.tex1scaleY = scaleY * tile1.fShiftScaleT/tex1.m_fTexHeight;
 849
 850         gRSP.tex1OffsetX = tile1.fhilite_sl/tex1.m_fTexWidth;
 851         gRSP.tex1OffsetY = tile1.fhilite_tl/tex1.m_fTexHeight;
 852     }
 853
 854     gRSP.texGenXRatio = tile0.fShiftScaleS;
 855     gRSP.texGenYRatio = gRSP.fTexScaleX/gRSP.fTexScaleY*tex0.m_fTexWidth/tex0.m_fTexHeight*tile0.fShiftScaleT;
 856 }
 857
 858 void TexGen(float &s, float &t)
 859 {
 860     if (gRDP.geometryMode & G_TEXTURE_GEN_LINEAR)
 861     {
 862         s = acosf(g_normal.x) / 3.14159f;
 863         t = acosf(g_normal.y) / 3.14159f;
 864     }
 865     else
 866     {
 867         s = 0.5f * ( 1.0f + g_normal.x);
 868         t = 0.5f * ( 1.0f - g_normal.y);
 869     }
 870 }
 871
 872 void ComputeLOD(bool openGL)
 873 {
 874     TLITVERTEX &v0 = g_vtxBuffer[0];
 875     TLITVERTEX &v1 = g_vtxBuffer[1];
 876     RenderTexture &tex0 = g_textures[gRSP.curTile];
 877
 878     float d,dt;
 879     if( openGL )
 880     {
 881         float x = g_vtxProjected5[0][0] / g_vtxProjected5[0][4] - g_vtxProjected5[1][0] / g_vtxProjected5[1][4];
 882         float y = g_vtxProjected5[0][1] / g_vtxProjected5[0][4] - g_vtxProjected5[1][1] / g_vtxProjected5[1][4];
 883
 884         x = windowSetting.vpWidthW*x/windowSetting.fMultX/2;
 885         y = windowSetting.vpHeightW*y/windowSetting.fMultY/2;
 886         d = sqrtf(x*x+y*y);
 887     }
 888     else
 889     {
 890         float x = (v0.x - v1.x)/ windowSetting.fMultX;
 891         float y = (v0.y - v1.y)/ windowSetting.fMultY;
 892         d = sqrtf(x*x+y*y);
 893     }
 894
 895     float s0 = v0.tcord[0].u * tex0.m_fTexWidth;
 896     float t0 = v0.tcord[0].v * tex0.m_fTexHeight;
 897     float s1 = v1.tcord[0].u * tex0.m_fTexWidth;
 898     float t1 = v1.tcord[0].v * tex0.m_fTexHeight;
 899
 900     dt = sqrtf((s0-s1)*(s0-s1)+(t0-t1)*(t0-t1));
 901
 902     float lod = dt/d;
 903     float frac = log10f(lod)/log10f(2.0f);
 904     //DEBUGGER_IF_DUMP(pauseAtNext,{DebuggerAppendMsg("LOD frac = %f", frac);});
 905     frac = (lod / powf(2.0f,floorf(frac)));
 906     frac = frac - floorf(frac);
 907     //DEBUGGER_IF_DUMP(pauseAtNext,{DebuggerAppendMsg("LOD = %f, frac = %f", lod, frac);});
 908     gRDP.LODFrac = (uint32)(frac*255);
 909     CRender::g_pRender->SetCombinerAndBlender();
 910 }
 911
 912 bool bHalfTxtScale=false;
 913 extern uint32 lastSetTile;
 914
 915 void InitVertex(uint32 dwV, uint32 vtxIndex, bool bTexture, bool openGL)
 916 {
 917     VTX_DUMP(TRACE2("Init vertex (%d) to vtx buf[%d]:", dwV, vtxIndex));
 918
 919     TLITVERTEX &v = g_vtxBuffer[vtxIndex];
 920     VTX_DUMP(TRACE4("  Trans: x=%f, y=%f, z=%f, w=%f",  g_vtxTransformed[dwV].x,g_vtxTransformed[dwV].y,g_vtxTransformed[dwV].z,g_vtxTransformed[dwV].w));
 921     if( openGL )
 922     {
 923         g_vtxProjected5[vtxIndex][0] = g_vtxTransformed[dwV].x;
 924         g_vtxProjected5[vtxIndex][1] = g_vtxTransformed[dwV].y;
 925         g_vtxProjected5[vtxIndex][2] = g_vtxTransformed[dwV].z;
 926         g_vtxProjected5[vtxIndex][3] = g_vtxTransformed[dwV].w;
 927         g_vtxProjected5[vtxIndex][4] = g_vecProjected[dwV].z;
 928
 929         if( g_vtxTransformed[dwV].w < 0 )
 930             g_vtxProjected5[vtxIndex][4] = 0;
 931
 932         g_vtxIndex[vtxIndex] = vtxIndex;
 933     }
 934
 935     if( !openGL || options.bOGLVertexClipper == TRUE )
 936     {
 937         v.x = g_vecProjected[dwV].x*gRSP.vtxXMul+gRSP.vtxXAdd;
 938         v.y = g_vecProjected[dwV].y*gRSP.vtxYMul+gRSP.vtxYAdd;
 939         v.z = (g_vecProjected[dwV].z + 1.0f) * 0.5f;    // DirectX minZ=0, maxZ=1
 940         //v.z = g_vecProjected[dwV].z;  // DirectX minZ=0, maxZ=1
 941         v.rhw = g_vecProjected[dwV].w;
 942         VTX_DUMP(TRACE4("  Proj : x=%f, y=%f, z=%f, rhw=%f",  v.x,v.y,v.z,v.rhw));
 943
 944         if( gRSP.bProcessSpecularColor )
 945         {
 946             v.dcSpecular = CRender::g_pRender->PostProcessSpecularColor();
 947             if( gRSP.bFogEnabled )
 948             {
 949                 v.dcSpecular &= 0x00FFFFFF;
 950                 uint32  fogFct = 0xFF-(uint8)((g_fFogCoord[dwV]-gRSPfFogMin)*gRSPfFogDivider);
 951                 v.dcSpecular |= (fogFct<<24);
 952             }
 953         }
 954         else if( gRSP.bFogEnabled )
 955         {
 956             uint32  fogFct = 0xFF-(uint8)((g_fFogCoord[dwV]-gRSPfFogMin)*gRSPfFogDivider);
 957             v.dcSpecular = (fogFct<<24);
 958         }
 959     }
 960     VTX_DUMP(TRACE2("  (U,V): %f, %f",  g_fVtxTxtCoords[dwV].x,g_fVtxTxtCoords[dwV].y));
 961
 962     v.dcDiffuse = g_dwVtxDifColor[dwV];
 963     if( gRDP.otherMode.key_en )
 964     {
 965         v.dcDiffuse &= 0x00FFFFFF;
 966         v.dcDiffuse |= (gRDP.keyA<<24);
 967     }
 968     else if( gRDP.otherMode.aa_en && gRDP.otherMode.clr_on_cvg==0 )
 969     {
 970         v.dcDiffuse |= 0xFF000000;
 971     }
 972
 973     if( gRSP.bProcessDiffuseColor )
 974     {
 975         v.dcDiffuse = CRender::g_pRender->PostProcessDiffuseColor(v.dcDiffuse);
 976     }
 977     if( options.bWinFrameMode )
 978     {
 979         v.dcDiffuse = g_dwVtxDifColor[dwV];
 980     }
 981
 982     if( openGL )
 983     {
 984         g_oglVtxColors[vtxIndex][0] = v.r;
 985         g_oglVtxColors[vtxIndex][1] = v.g;
 986         g_oglVtxColors[vtxIndex][2] = v.b;
 987         g_oglVtxColors[vtxIndex][3] = v.a;
 988     }
 989
 990     if( bTexture )
 991     {
 992         // If the vert is already lit, then there is no normal (and hence we can't generate tex coord)
 993         // Only scale if not generated automatically
 994         if (gRSP.bTextureGen && gRSP.bLightingEnable)
 995         {
 996             // Correction for texGen result
 997             float u0,u1,v0,v1;
 998             RenderTexture &tex0 = g_textures[gRSP.curTile];
 999             u0 = g_fVtxTxtCoords[dwV].x * 32 * 1024 * gRSP.fTexScaleX / tex0.m_fTexWidth;
1000             v0 = g_fVtxTxtCoords[dwV].y * 32 * 1024 * gRSP.fTexScaleY / tex0.m_fTexHeight;
1001             u0 *= (gRDP.tiles[gRSP.curTile].fShiftScaleS);
1002             v0 *= (gRDP.tiles[gRSP.curTile].fShiftScaleT);
1003
1004             if( CRender::g_pRender->IsTexel1Enable() )
1005             {
1006                 RenderTexture &tex1 = g_textures[(gRSP.curTile+1)&7];
1007                 u1 = g_fVtxTxtCoords[dwV].x * 32 * 1024 * gRSP.fTexScaleX / tex1.m_fTexWidth;
1008                 v1 = g_fVtxTxtCoords[dwV].y * 32 * 1024 * gRSP.fTexScaleY / tex1.m_fTexHeight;
1009                 u1 *= gRDP.tiles[(gRSP.curTile+1)&7].fShiftScaleS;
1010                 v1 *= gRDP.tiles[(gRSP.curTile+1)&7].fShiftScaleT;
1011                 CRender::g_pRender->SetVertexTextureUVCoord(v, u0, v0, u1, v1);
1012             }
1013             else
1014             {
1015                 CRender::g_pRender->SetVertexTextureUVCoord(v, u0, v0);
1016             }
1017         }
1018         else
1019         {
1020             float tex0u = g_fVtxTxtCoords[dwV].x *gRSP.tex0scaleX - gRSP.tex0OffsetX ;
1021             float tex0v = g_fVtxTxtCoords[dwV].y *gRSP.tex0scaleY - gRSP.tex0OffsetY ;
1022
1023             if( CRender::g_pRender->IsTexel1Enable() )
1024             {
1025                 float tex1u = g_fVtxTxtCoords[dwV].x *gRSP.tex1scaleX - gRSP.tex1OffsetX ;
1026                 float tex1v = g_fVtxTxtCoords[dwV].y *gRSP.tex1scaleY - gRSP.tex1OffsetY ;
1027
1028                 CRender::g_pRender->SetVertexTextureUVCoord(v, tex0u, tex0v, tex1u, tex1v);
1029                 VTX_DUMP(TRACE2("  (tex0): %f, %f",  tex0u,tex0v));
1030                 VTX_DUMP(TRACE2("  (tex1): %f, %f",  tex1u,tex1v));
1031             }
1032             else
1033             {
1034                 CRender::g_pRender->SetVertexTextureUVCoord(v, tex0u, tex0v);
1035                 VTX_DUMP(TRACE2("  (tex0): %f, %f",  tex0u,tex0v));
1036             }
1037         }
1038
1039         // Check for txt scale hack
1040         if( !bHalfTxtScale && g_curRomInfo.bTextureScaleHack &&
1041             (gRDP.tiles[lastSetTile].dwSize == TXT_SIZE_32b || gRDP.tiles[lastSetTile].dwSize == TXT_SIZE_4b ) )
1042         {
1043             int width = ((gRDP.tiles[lastSetTile].sh-gRDP.tiles[lastSetTile].sl+1)<<1);
1044             int height = ((gRDP.tiles[lastSetTile].th-gRDP.tiles[lastSetTile].tl+1)<<1);
1045             if( g_fVtxTxtCoords[dwV].x*gRSP.fTexScaleX == width || g_fVtxTxtCoords[dwV].y*gRSP.fTexScaleY == height )
1046             {
1047                 bHalfTxtScale=true;
1048             }
1049         }
1050     }
1051
1052     if( g_curRomInfo.bEnableTxtLOD && vtxIndex == 1 && gRDP.otherMode.text_lod )
1053     {
1054         if( CRender::g_pRender->IsTexel1Enable() && CRender::g_pRender->m_pColorCombiner->m_pDecodedMux->isUsed(MUX_LODFRAC) )
1055         {
1056             ComputeLOD(openGL);
1057         }
1058         else
1059         {
1060             gRDP.LODFrac = 0;
1061         }
1062     }
1063
1064     VTX_DUMP(TRACE2("  DIF(%08X), SPE(%08X)",   v.dcDiffuse, v.dcSpecular));
1065     VTX_DUMP(TRACE0(""));
1066 }
1067
1068 uint32 LightVert(XVECTOR4 & norm, int vidx)
1069 {
1070     float fCosT;
1071
1072     // Do ambient
1073     register float r = gRSP.fAmbientLightR;
1074     register float g = gRSP.fAmbientLightG;
1075     register float b = gRSP.fAmbientLightB;
1076
1077     if( options.enableHackForGames != HACK_FOR_ZELDA_MM )
1078     {
1079         for (register unsigned int l=0; l < gRSPnumLights; l++)
1080         {
1081             fCosT = norm.x*gRSPlights[l].x + norm.y*gRSPlights[l].y + norm.z*gRSPlights[l].z;
1082
1083             if (fCosT > 0 )
1084             {
1085                 r += gRSPlights[l].fr * fCosT;
1086                 g += gRSPlights[l].fg * fCosT;
1087                 b += gRSPlights[l].fb * fCosT;
1088             }
1089         }
1090     }
1091     else
1092     {
1093         XVECTOR4 v;
1094         bool transformed = false;
1095
1096         for (register unsigned int l=0; l < gRSPnumLights; l++)
1097         {
1098             if( gRSPlights[l].range == 0 )
1099             {
1100                 // Regular directional light
1101                 fCosT = norm.x*gRSPlights[l].x + norm.y*gRSPlights[l].y + norm.z*gRSPlights[l].z;
1102
1103                 if (fCosT > 0 )
1104                 {
1105                     r += gRSPlights[l].fr * fCosT;
1106                     g += gRSPlights[l].fg * fCosT;
1107                     b += gRSPlights[l].fb * fCosT;
1108                 }
1109             }
1110             else //if( (gRSPlights[l].col&0x00FFFFFF) != 0x00FFFFFF )
1111             {
1112                 // Point light
1113                 if( !transformed )
1114                 {
1115                     Vec3Transform(&v, (XVECTOR3*)&g_vtxNonTransformed[vidx], &gRSPmodelViewTop);    // Convert to w=1
1116                     transformed = true;
1117                 }
1118
1119                 XVECTOR3 dir(gRSPlights[l].x - v.x, gRSPlights[l].y - v.y, gRSPlights[l].z - v.z);
1120                 //XVECTOR3 dir(v.x-gRSPlights[l].x, v.y-gRSPlights[l].y, v.z-gRSPlights[l].z);
1121                 float d2 = sqrtf(dir.x*dir.x+dir.y*dir.y+dir.z*dir.z);
1122                 dir.x /= d2;
1123                 dir.y /= d2;
1124                 dir.z /= d2;
1125
1126                 fCosT = norm.x*dir.x + norm.y*dir.y + norm.z*dir.z;
1127
1128                 if (fCosT > 0 )
1129                 {
1130                     //float f = d2/gRSPlights[l].range*50;
1131                     float f = d2/15000*50;
1132                     f = 1 - min(f,1);
1133                     fCosT *= f*f;
1134
1135                     r += gRSPlights[l].fr * fCosT;
1136                     g += gRSPlights[l].fg * fCosT;
1137                     b += gRSPlights[l].fb * fCosT;
1138                 }
1139             }
1140         }
1141     }
1142
1143     if (r > 255) r = 255;
1144     if (g > 255) g = 255;
1145     if (b > 255) b = 255;
1146     return ((0xff000000)|(((uint32)r)<<16)|(((uint32)g)<<8)|((uint32)b));
1147 }
1148
1149 uint32 LightVertNew(XVECTOR4 & norm)
1150 {
1151     float fCosT;
1152
1153     // Do ambient
1154     register float r = gRSP.fAmbientLightR;
1155     register float g = gRSP.fAmbientLightG;
1156     register float b = gRSP.fAmbientLightB;
1157
1158
1159     for (register unsigned int l=0; l < gRSPnumLights; l++)
1160     {
1161         fCosT = norm.x*gRSPlights[l].tx + norm.y*gRSPlights[l].ty + norm.z*gRSPlights[l].tz;
1162
1163         if (fCosT > 0 )
1164         {
1165             r += gRSPlights[l].fr * fCosT;
1166             g += gRSPlights[l].fg * fCosT;
1167             b += gRSPlights[l].fb * fCosT;
1168         }
1169     }
1170
1171     if (r > 255) r = 255;
1172     if (g > 255) g = 255;
1173     if (b > 255) b = 255;
1174     return ((0xff000000)|(((uint32)r)<<16)|(((uint32)g)<<8)|((uint32)b));
1175 }
1176
1177
1178 float zero = 0.0f;
1179 float onef = 1.0f;
1180 float fcosT;
1181
1182 #if !defined(__GNUC__) && !defined(NO_ASM)
1183 __declspec( naked ) uint32  __fastcall SSELightVert()
1184 {
1185     __asm
1186     {
1187         movaps      xmm3, DWORD PTR gRSP;   // loading Ambient colors, xmm3 is the result color
1188         movaps      xmm4, DWORD PTR [g_normal]; // xmm4 is the normal
1189
1190         mov         ecx, 0;
1191 loopback:
1192         cmp         ecx, DWORD PTR gRSPnumLights;
1193         jae         breakout;
1194         mov         eax,ecx;
1195         imul        eax,0x44;
1196         movups      xmm5, DWORD PTR gRSPlights[eax];        // Light Dir
1197         movups      xmm1, DWORD PTR gRSPlights[0x14][eax];  // Light color
1198         mulps       xmm5, xmm4;                 // Lightdir * normals
1199
1200         movhlps     xmm0,xmm5;
1201         addps       xmm0,xmm5;
1202         shufps      xmm5,xmm0,0x01;
1203         addps       xmm0,xmm5;
1204
1205         comiss      xmm0,zero;
1206         jc          endloop
1207
1208         shufps      xmm0,xmm0,0;                    // fcosT
1209         mulps       xmm1,xmm0;
1210         addps       xmm3,xmm1;
1211 endloop:
1212         inc         ecx;
1213         jmp         loopback;
1214 breakout:
1215
1216         movss       xmm0,DWORD PTR real255;
1217         shufps      xmm0,xmm0,0;
1218         minps       xmm0,xmm3;
1219
1220         // Without using a memory
1221         cvtss2si    eax,xmm0;       // move the 1st uint32 to eax
1222         shl         eax,10h;
1223         or          eax,0FF000000h;
1224         shufps      xmm0,xmm0,0E5h; // move the 2nd uint32 to the 1st uint32
1225         cvtss2si    ecx,xmm0;       // move the 1st uint32 to ecx
1226         shl         ecx,8;
1227         or          eax,ecx;
1228         shufps      xmm0,xmm0,0E6h; // Move the 3rd uint32 to the 1st uint32
1229         cvtss2si    ecx,xmm0;
1230         or          eax,ecx;
1231
1232         ret;
1233     }
1234 }
1235 #elif defined(__GNUC__) && defined(__x86_64__) && !defined(NO_ASM)
1236 uint32 SSELightVert(void)
1237 {
1238   uint32 rval;
1239   float f255 = 255.0, fZero = 0.0;
1240
1241   asm volatile(" movaps        %1,  %%xmm3    \n" // xmm3 == gRSP.fAmbientLight{RGBA}
1242            " movaps            %2,  %%xmm4    \n" // xmm4 == g_normal.{xyz}
1243            " xor            %%rcx,   %%rcx    \n"
1244            "0:                                \n"
1245            " cmpl              %3,   %%ecx    \n"
1246            " jae               2f             \n"
1247            " mov            %%rcx,   %%rax    \n"
1248            " imul    $0x44, %%rax,   %%rax    \n"
1249            " movups   (%4,%%rax,),  %%xmm5    \n"  // xmm5 == gRSPlights[l].{xyzr}
1250            " movups 20(%4,%%rax,),  %%xmm1    \n"  // xmm1 == gRSPlights[l].{frfgfbfa}
1251            " mulps         %%xmm4,  %%xmm5    \n"
1252            " movhlps       %%xmm5,  %%xmm0    \n"
1253            " addps         %%xmm5,  %%xmm0    \n"
1254            " shufps $0x01, %%xmm0,  %%xmm5    \n"
1255            " addps         %%xmm5,  %%xmm0    \n"
1256            " comiss            %6,  %%xmm0    \n"
1257            " jc                1f             \n"
1258            " shufps $0x00, %%xmm0,  %%xmm0    \n"
1259            " mulps         %%xmm0,  %%xmm1    \n"
1260            " addps         %%xmm1,  %%xmm3    \n"
1261            "1:                                \n"
1262            " inc            %%rcx             \n"
1263            " jmp               0b             \n"
1264            "2:                                \n"
1265            " movss             %5,  %%xmm0    \n"
1266            " shufps $0x00, %%xmm0,  %%xmm0    \n"
1267            " minps         %%xmm3,  %%xmm0    \n"
1268            " cvtss2si      %%xmm0,   %%eax    \n"
1269            " shll           $0x10,   %%eax    \n"
1270            " orl      $0xff000000,   %%eax    \n"
1271            " shufps $0xe5, %%xmm0,  %%xmm0    \n"
1272            " cvtss2si      %%xmm0,   %%ecx    \n"
1273            " shll              $8,   %%ecx    \n"
1274            " orl            %%ecx,   %%eax    \n"
1275            " shufps $0xe6, %%xmm0,  %%xmm0    \n"
1276            " cvtss2si      %%xmm0,   %%ecx    \n"
1277            " orl            %%ecx,   %%eax    \n"
1278            : "=&a"(rval)
1279            : "m"(gRSP), "m"(g_normal), "m"(gRSPnumLights), "r"(gRSPlights), "m"(f255), "m"(fZero)
1280            : "%rcx", "memory", "cc", "%xmm0", "%xmm1", "%xmm3", "%xmm4", "%xmm5"
1281            );
1282   return rval;
1283 }
1284 #elif !defined(NO_ASM) // 32-bit GCC assumed
1285 uint32 SSELightVert(void)
1286 {
1287   uint32 rval;
1288   float f255 = 255.0, fZero = 0.0;
1289
1290   asm volatile(" movaps            %1,  %%xmm3    \n"
1291                " movaps            %2,  %%xmm4    \n"
1292                " xor            %%ecx,   %%ecx    \n"
1293                "0:                                \n"
1294                " cmpl              %3,   %%ecx    \n"
1295                " jae               2f             \n"
1296                " mov            %%ecx,   %%eax    \n"
1297                " imul    $0x44, %%eax,   %%eax    \n"
1298                " movups   (%4,%%eax,),  %%xmm5    \n"
1299                " movups 20(%4,%%eax,),  %%xmm1    \n"
1300                " mulps         %%xmm4,  %%xmm5    \n"
1301                " movhlps       %%xmm5,  %%xmm0    \n"
1302                " addps         %%xmm5,  %%xmm0    \n"
1303                " shufps $0x01, %%xmm0,  %%xmm5    \n"
1304                " addps         %%xmm5,  %%xmm0    \n"
1305                " comiss            %6,  %%xmm0    \n"
1306                " jc                1f             \n"
1307                " shufps $0x00, %%xmm0,  %%xmm0    \n"
1308                " mulps         %%xmm0,  %%xmm1    \n"
1309                " addps         %%xmm1,  %%xmm3    \n"
1310                "1:                                \n"
1311                " inc            %%ecx             \n"
1312                " jmp               0b             \n"
1313                "2:                                \n"
1314                " movss             %5,  %%xmm0    \n"
1315                " shufps $0x00, %%xmm0,  %%xmm0    \n"
1316                " minps         %%xmm3,  %%xmm0    \n"
1317                " cvtss2si      %%xmm0,   %%eax    \n"
1318                " shll           $0x10,   %%eax    \n"
1319                " orl      $0xff000000,   %%eax    \n"
1320                " shufps $0xe5, %%xmm0,  %%xmm0    \n"
1321                " cvtss2si      %%xmm0,   %%ecx    \n"
1322                " shll              $8,   %%ecx    \n"
1323                " orl            %%ecx,   %%eax    \n"
1324                " shufps $0xe6, %%xmm0,  %%xmm0    \n"
1325                " cvtss2si      %%xmm0,   %%ecx    \n"
1326                " orl            %%ecx,   %%eax    \n"
1327                : "=&a"(rval)
1328                : "m"(gRSP), "m"(g_normal), "m"(gRSPnumLights), "r"(gRSPlights), "m"(f255), "m"(fZero)
1329                : "%rcx", "memory", "cc", "%xmm0", "%xmm1", "%xmm3", "%xmm4", "%xmm5"
1330                );
1331   return rval;
1332 }
1333 #endif
1334
1335 inline void ReplaceAlphaWithFogFactor(int i)
1336 {
1337     if( gRDP.geometryMode & G_FOG )
1338     {
1339         // Use fog factor to replace vertex alpha
1340         if( g_vecProjected[i].z > 1 )
1341             *(((uint8*)&(g_dwVtxDifColor[i]))+3) = 0xFF;
1342         if( g_vecProjected[i].z < 0 )
1343             *(((uint8*)&(g_dwVtxDifColor[i]))+3) = 0;
1344         else
1345             *(((uint8*)&(g_dwVtxDifColor[i]))+3) = (uint8)(g_vecProjected[i].z*255);
1346     }
1347 }
1348
1349
1350 // Bits
1351 // +-+-+-
1352 // xxyyzz
1353 #define Z_NEG  0x01
1354 #define Z_POS  0x02
1355 #define Y_NEG  0x04
1356 #define Y_POS  0x08
1357 #define X_NEG  0x10
1358 #define X_POS  0x20
1359
1360 // Assumes dwAddr has already been checked!
1361 // Don't inline - it's too big with the transform macros
1362
1363 #if !defined(NO_ASM)
1364 void ProcessVertexDataSSE(uint32 dwAddr, uint32 dwV0, uint32 dwNum)
1365 {
1366     UpdateCombinedMatrix();
1367
1368     // This function is called upon SPvertex
1369     // - do vertex matrix transform
1370     // - do vertex lighting
1371     // - do texture cooridinate transform if needed
1372     // - calculate normal vector
1373
1374     // Output:  - g_vecProjected[i]             -> transformed vertex x,y,z
1375     //          - g_vecProjected[i].w                       -> saved vertex 1/w
1376     //          - g_dwVtxFlags[i]               -> flags
1377     //          - g_dwVtxDifColor[i]            -> vertex color
1378     //          - g_fVtxTxtCoords[i]                -> vertex texture cooridinates
1379
1380     FiddledVtx * pVtxBase = (FiddledVtx*)(g_pRDRAMu8 + dwAddr);
1381     g_pVtxBase = pVtxBase;
1382
1383     for (uint32 i = dwV0; i < dwV0 + dwNum; i++)
1384     {
1385         SP_Timing(RSP_GBI0_Vtx);
1386
1387         FiddledVtx & vert = pVtxBase[i - dwV0];
1388
1389         g_vtxNonTransformed[i].x = (float)vert.x;
1390         g_vtxNonTransformed[i].y = (float)vert.y;
1391         g_vtxNonTransformed[i].z = (float)vert.z;
1392
1393         SSEVec3Transform(i);
1394
1395         if( gRSP.bFogEnabled )
1396         {
1397             g_fFogCoord[i] = g_vecProjected[i].z;
1398             if( g_vecProjected[i].w < 0 || g_vecProjected[i].z < 0 || g_fFogCoord[i] < gRSPfFogMin )
1399                 g_fFogCoord[i] = gRSPfFogMin;
1400         }
1401
1402         ReplaceAlphaWithFogFactor(i);
1403
1404
1405         VTX_DUMP(
1406         {
1407             uint32 *dat = (uint32*)(&vert);
1408             DebuggerAppendMsg("vtx %d: %08X %08X %08X %08X", i, dat[0],dat[1],dat[2],dat[3]);
1409             DebuggerAppendMsg("      : %f, %f, %f, %f",
1410                 g_vtxTransformed[i].x,g_vtxTransformed[i].y,g_vtxTransformed[i].z,g_vtxTransformed[i].w);
1411             DebuggerAppendMsg("      : %f, %f, %f, %f",
1412                 g_vecProjected[i].x,g_vecProjected[i].y,g_vecProjected[i].z,g_vecProjected[i].w);
1413         });
1414
1415         RSP_Vtx_Clipping(i);
1416
1417         if( gRSP.bLightingEnable )
1418         {
1419             g_normal.x = (float)vert.norma.nx;
1420             g_normal.y = (float)vert.norma.ny;
1421             g_normal.z = (float)vert.norma.nz;
1422
1423             SSEVec3TransformNormal();
1424             if( options.enableHackForGames != HACK_FOR_ZELDA_MM )
1425                 g_dwVtxDifColor[i] = SSELightVert();
1426             else
1427                 g_dwVtxDifColor[i] = LightVert(g_normal, i);
1428             *(((uint8*)&(g_dwVtxDifColor[i]))+3) = vert.rgba.a; // still use alpha from the vertex
1429         }
1430         else
1431         {
1432             if( (gRDP.geometryMode & G_SHADE) == 0 && gRSP.ucode < 5 )  //Shade is disabled
1433             {
1434                 //FLAT shade
1435                 g_dwVtxDifColor[i] = gRDP.primitiveColor;
1436             }
1437             else
1438             {
1439                 register IColor &color = *(IColor*)&g_dwVtxDifColor[i];
1440                 color.b = vert.rgba.r;
1441                 color.g = vert.rgba.g;
1442                 color.r = vert.rgba.b;
1443                 color.a = vert.rgba.a;
1444             }
1445         }
1446
1447         if( options.bWinFrameMode )
1448         {
1449             g_dwVtxDifColor[i] = COLOR_RGBA(vert.rgba.r, vert.rgba.g, vert.rgba.b, vert.rgba.a);
1450         }
1451
1452         // Update texture coords n.b. need to divide tu/tv by bogus scale on addition to buffer
1453
1454         // If the vert is already lit, then there is no normal (and hence we
1455         // can't generate tex coord)
1456         if (gRSP.bTextureGen && gRSP.bLightingEnable )
1457         {
1458             TexGen(g_fVtxTxtCoords[i].x, g_fVtxTxtCoords[i].y);
1459         }
1460         else
1461         {
1462             g_fVtxTxtCoords[i].x = (float)vert.tu;
1463             g_fVtxTxtCoords[i].y = (float)vert.tv;
1464         }
1465     }
1466
1467     VTX_DUMP(TRACE2("Setting Vertexes: %d - %d\n", dwV0, dwV0+dwNum-1));
1468     DEBUGGER_PAUSE_AND_DUMP(NEXT_VERTEX_CMD,{TRACE0("Paused at Vertex Cmd");});
1469 }
1470 #endif
1471
1472 void ProcessVertexDataNoSSE(uint32 dwAddr, uint32 dwV0, uint32 dwNum)
1473 {
1474
1475     UpdateCombinedMatrix();
1476
1477     // This function is called upon SPvertex
1478     // - do vertex matrix transform
1479     // - do vertex lighting
1480     // - do texture cooridinate transform if needed
1481     // - calculate normal vector
1482
1483     // Output:  - g_vecProjected[i]             -> transformed vertex x,y,z
1484     //          - g_vecProjected[i].w                       -> saved vertex 1/w
1485     //          - g_dwVtxFlags[i]               -> flags
1486     //          - g_dwVtxDifColor[i]            -> vertex color
1487     //          - g_fVtxTxtCoords[i]                -> vertex texture cooridinates
1488
1489     FiddledVtx * pVtxBase = (FiddledVtx*)(g_pRDRAMu8 + dwAddr);
1490     g_pVtxBase = pVtxBase;
1491
1492     for (uint32 i = dwV0; i < dwV0 + dwNum; i++)
1493     {
1494         SP_Timing(RSP_GBI0_Vtx);
1495
1496         FiddledVtx & vert = pVtxBase[i - dwV0];
1497
1498         g_vtxNonTransformed[i].x = (float)vert.x;
1499         g_vtxNonTransformed[i].y = (float)vert.y;
1500         g_vtxNonTransformed[i].z = (float)vert.z;
1501
1502         Vec3Transform(&g_vtxTransformed[i], (XVECTOR3*)&g_vtxNonTransformed[i], &gRSPworldProject); // Convert to w=1
1503
1504         g_vecProjected[i].w = 1.0f / g_vtxTransformed[i].w;
1505         g_vecProjected[i].x = g_vtxTransformed[i].x * g_vecProjected[i].w;
1506         g_vecProjected[i].y = g_vtxTransformed[i].y * g_vecProjected[i].w;
1507         if ((g_curRomInfo.bPrimaryDepthHack || options.enableHackForGames == HACK_FOR_NASCAR ) && gRDP.otherMode.depth_source )
1508         {
1509             g_vecProjected[i].z = gRDP.fPrimitiveDepth;
1510             g_vtxTransformed[i].z = gRDP.fPrimitiveDepth*g_vtxTransformed[i].w;
1511         }
1512         else
1513         {
1514             g_vecProjected[i].z = g_vtxTransformed[i].z * g_vecProjected[i].w;
1515         }
1516
1517         if( gRSP.bFogEnabled )
1518         {
1519             g_fFogCoord[i] = g_vecProjected[i].z;
1520             if( g_vecProjected[i].w < 0 || g_vecProjected[i].z < 0 || g_fFogCoord[i] < gRSPfFogMin )
1521                 g_fFogCoord[i] = gRSPfFogMin;
1522         }
1523
1524         VTX_DUMP(
1525         {
1526             uint32 *dat = (uint32*)(&vert);
1527             DebuggerAppendMsg("vtx %d: %08X %08X %08X %08X", i, dat[0],dat[1],dat[2],dat[3]);
1528             DebuggerAppendMsg("      : %f, %f, %f, %f",
1529                 g_vtxTransformed[i].x,g_vtxTransformed[i].y,g_vtxTransformed[i].z,g_vtxTransformed[i].w);
1530             DebuggerAppendMsg("      : %f, %f, %f, %f",
1531                 g_vecProjected[i].x,g_vecProjected[i].y,g_vecProjected[i].z,g_vecProjected[i].w);
1532         });
1533
1534         RSP_Vtx_Clipping(i);
1535
1536         if( gRSP.bLightingEnable )
1537         {
1538             g_normal.x = (float)vert.norma.nx;
1539             g_normal.y = (float)vert.norma.ny;
1540             g_normal.z = (float)vert.norma.nz;
1541
1542             Vec3TransformNormal(g_normal, gRSPmodelViewTop);
1543             g_dwVtxDifColor[i] = LightVert(g_normal, i);
1544             *(((uint8*)&(g_dwVtxDifColor[i]))+3) = vert.rgba.a; // still use alpha from the vertex
1545         }
1546         else
1547         {
1548             if( (gRDP.geometryMode & G_SHADE) == 0 && gRSP.ucode < 5 )  //Shade is disabled
1549             {
1550                 //FLAT shade
1551                 g_dwVtxDifColor[i] = gRDP.primitiveColor;
1552             }
1553             else
1554             {
1555                 register IColor &color = *(IColor*)&g_dwVtxDifColor[i];
1556                 color.b = vert.rgba.r;
1557                 color.g = vert.rgba.g;
1558                 color.r = vert.rgba.b;
1559                 color.a = vert.rgba.a;
1560             }
1561         }
1562
1563         if( options.bWinFrameMode )
1564         {
1565             g_dwVtxDifColor[i] = COLOR_RGBA(vert.rgba.r, vert.rgba.g, vert.rgba.b, vert.rgba.a);
1566         }
1567
1568         ReplaceAlphaWithFogFactor(i);
1569
1570         // Update texture coords n.b. need to divide tu/tv by bogus scale on addition to buffer
1571
1572         // If the vert is already lit, then there is no normal (and hence we
1573         // can't generate tex coord)
1574         if (gRSP.bTextureGen && gRSP.bLightingEnable )
1575         {
1576             TexGen(g_fVtxTxtCoords[i].x, g_fVtxTxtCoords[i].y);
1577         }
1578         else
1579         {
1580             g_fVtxTxtCoords[i].x = (float)vert.tu;
1581             g_fVtxTxtCoords[i].y = (float)vert.tv;
1582         }
1583     }
1584
1585     VTX_DUMP(TRACE2("Setting Vertexes: %d - %d\n", dwV0, dwV0+dwNum-1));
1586     DEBUGGER_PAUSE_AND_DUMP(NEXT_VERTEX_CMD,{TRACE0("Paused at Vertex Cmd");});
1587 }
1588
1589 bool PrepareTriangle(uint32 dwV0, uint32 dwV1, uint32 dwV2)
1590 {
1591     if( status.isVertexShaderEnabled || status.bUseHW_T_L )
1592     {
1593         g_vtxIndex[gRSP.numVertices++] = dwV0;
1594         g_vtxIndex[gRSP.numVertices++] = dwV1;
1595         g_vtxIndex[gRSP.numVertices++] = dwV2;
1596         status.dwNumTrisRendered++;
1597         gRSP.maxVertexID = max(gRSP.maxVertexID,max(dwV0,max(dwV1,dwV2)));
1598     }
1599     else
1600     {
1601         SP_Timing(SP_Each_Triangle);
1602
1603         bool textureFlag = (CRender::g_pRender->IsTextureEnabled() || gRSP.ucode == 6 );
1604         bool openGL = CDeviceBuilder::m_deviceGeneralType == OGL_DEVICE;
1605
1606         InitVertex(dwV0, gRSP.numVertices, textureFlag, openGL);
1607         InitVertex(dwV1, gRSP.numVertices+1, textureFlag, openGL);
1608         InitVertex(dwV2, gRSP.numVertices+2, textureFlag, openGL);
1609
1610         gRSP.numVertices += 3;
1611         status.dwNumTrisRendered++;
1612     }
1613
1614     return true;
1615 }
1616
1617
1618
1619 // Returns TRUE if it thinks the triangle is visible
1620 // Returns FALSE if it is clipped
1621 bool IsTriangleVisible(uint32 dwV0, uint32 dwV1, uint32 dwV2)
1622 {
1623     //return true;  //fix me
1624
1625     if( status.isVertexShaderEnabled || status.bUseHW_T_L ) return true;    // We won't have access to transformed vertex data
1626
1627     DEBUGGER_ONLY_IF( (!debuggerEnableTestTris || !debuggerEnableCullFace), {return TRUE;});
1628
1629 #ifdef DEBUGGER
1630     // Check vertices are valid!
1631     if (dwV0 >= MAX_VERTS || dwV1 >= MAX_VERTS || dwV2 >= MAX_VERTS)
1632         return false;
1633 #endif
1634
1635     // Here we AND all the flags. If any of the bits is set for all
1636     // 3 vertices, it means that all three x, y or z lie outside of
1637     // the current viewing volume.
1638     // Currently disabled - still seems a bit dodgy
1639     if ((gRSP.bCullFront || gRSP.bCullBack) && gRDP.otherMode.zmode != 3)
1640     {
1641         XVECTOR4 & v0 = g_vecProjected[dwV0];
1642         XVECTOR4 & v1 = g_vecProjected[dwV1];
1643         XVECTOR4 & v2 = g_vecProjected[dwV2];
1644
1645         // Only try to clip if the tri is onscreen. For some reason, this
1646         // method doesnt' work well when the z value is outside of screenspace
1647         //if (v0.z < 1 && v1.z < 1 && v2.z < 1)
1648         {
1649             float V1 = v2.x - v0.x;
1650             float V2 = v2.y - v0.y;
1651
1652             float W1 = v2.x - v1.x;
1653             float W2 = v2.y - v1.y;
1654
1655             float fDirection = (V1 * W2) - (V2 * W1);
1656             fDirection = fDirection * v1.w * v2.w * v0.w;
1657             //float fDirection = v0.x*v1.y-v1.x*v0.y+v1.x*v2.y-v2.x*v1.y+v2.x*v0.y-v0.x*v2.y;
1658
1659             if (fDirection < 0 && gRSP.bCullBack)
1660             {
1661                 status.dwNumTrisClipped++;
1662                 return false;
1663             }
1664             else if (fDirection > 0 && gRSP.bCullFront)
1665             {
1666                 status.dwNumTrisClipped++;
1667                 return false;
1668             }
1669         }
1670     }
1671
1672 #ifdef ENABLE_CLIP_TRI
1673     //if( gRSP.bRejectVtx && (g_clipFlag[dwV0]|g_clipFlag[dwV1]|g_clipFlag[dwV2]) )
1674     //  return;
1675     if( g_clipFlag2[dwV0]&g_clipFlag2[dwV1]&g_clipFlag2[dwV2] )
1676     {
1677         //DebuggerAppendMsg("Clipped");
1678         return false;
1679     }
1680 #endif
1681
1682     return true;
1683 }
1684
1685
1686 void SetPrimitiveColor(uint32 dwCol, uint32 LODMin, uint32 LODFrac)
1687 {
1688     gRDP.colorsAreReloaded = true;
1689     gRDP.primitiveColor = dwCol;
1690     gRDP.primLODMin = LODMin;
1691     gRDP.primLODFrac = LODFrac;
1692     if( gRDP.primLODFrac < gRDP.primLODMin )
1693     {
1694         gRDP.primLODFrac = gRDP.primLODMin;
1695     }
1696
1697     gRDP.fvPrimitiveColor[0] = ((dwCol>>16)&0xFF)/255.0f;  //r
1698     gRDP.fvPrimitiveColor[1] = ((dwCol>>8)&0xFF)/255.0f;   //g
1699     gRDP.fvPrimitiveColor[2] = ((dwCol)&0xFF)/255.0f;      //b
1700     gRDP.fvPrimitiveColor[3] = ((dwCol>>24)&0xFF)/255.0f;  //a
1701 }
1702
1703 void SetPrimitiveDepth(uint32 z, uint32 dwDZ)
1704 {
1705     gRDP.primitiveDepth = z & 0x7FFF;
1706     gRDP.fPrimitiveDepth = (float)(gRDP.primitiveDepth)/(float)0x8000;
1707
1708     //gRDP.fPrimitiveDepth = gRDP.fPrimitiveDepth*2-1;
1709     /*
1710     z=0xFFFF    ->  1   the farest
1711     z=0         ->  -1  the nearest
1712     */
1713
1714     //how to use dwDZ?
1715
1716 #ifdef DEBUGGER
1717     if( (pauseAtNext && (eventToPause == NEXT_VERTEX_CMD || eventToPause == NEXT_FLUSH_TRI )) )//&& logTriangles )
1718     {
1719         DebuggerAppendMsg("Set prim Depth: %f, (%08X, %08X)", gRDP.fPrimitiveDepth, z, dwDZ);
1720     }
1721 #endif
1722 }
1723
1724 void SetVertexXYZ(uint32 vertex, float x, float y, float z)
1725 {
1726     g_vecProjected[vertex].x = x;
1727     g_vecProjected[vertex].y = y;
1728     g_vecProjected[vertex].z = z;
1729
1730     g_vtxTransformed[vertex].x = x*g_vtxTransformed[vertex].w;
1731     g_vtxTransformed[vertex].y = y*g_vtxTransformed[vertex].w;
1732     g_vtxTransformed[vertex].z = z*g_vtxTransformed[vertex].w;
1733 }
1734
1735 void ModifyVertexInfo(uint32 where, uint32 vertex, uint32 val)
1736 {
1737     switch (where)
1738     {
1739     case RSP_MV_WORD_OFFSET_POINT_RGBA:     // Modify RGBA
1740         {
1741             uint32 r = (val>>24)&0xFF;
1742             uint32 g = (val>>16)&0xFF;
1743             uint32 b = (val>>8)&0xFF;
1744             uint32 a = val&0xFF;
1745             g_dwVtxDifColor[vertex] = COLOR_RGBA(r, g, b, a);
1746             LOG_UCODE("Modify vert %d color, 0x%08x", vertex, g_dwVtxDifColor[vertex]);
1747         }
1748         break;
1749     case RSP_MV_WORD_OFFSET_POINT_XYSCREEN:     // Modify X,Y
1750         {
1751             uint16 nX = (uint16)(val>>16);
1752             short x = *((short*)&nX);
1753             x /= 4;
1754
1755             uint16 nY = (uint16)(val&0xFFFF);
1756             short y = *((short*)&nY);
1757             y /= 4;
1758
1759             // Should do viewport transform.
1760
1761
1762             x -= windowSetting.uViWidth/2;
1763             y = windowSetting.uViHeight/2-y;
1764
1765             if( options.bEnableHacks && ((*g_GraphicsInfo.VI_X_SCALE_REG)&0xF) != 0 )
1766             {
1767                 // Tarzan
1768                 // I don't know why Tarzan is different
1769                 SetVertexXYZ(vertex, x/windowSetting.fViWidth, y/windowSetting.fViHeight, g_vecProjected[vertex].z);
1770             }
1771             else
1772             {
1773                 // Toy Story 2 and other games
1774                 SetVertexXYZ(vertex, x*2/windowSetting.fViWidth, y*2/windowSetting.fViHeight, g_vecProjected[vertex].z);
1775             }
1776
1777             LOG_UCODE("Modify vert %d: x=%d, y=%d", vertex, x, y);
1778             VTX_DUMP(TRACE3("Modify vert %d: (%d,%d)", vertex, x, y));
1779         }
1780         break;
1781     case RSP_MV_WORD_OFFSET_POINT_ZSCREEN:      // Modify C
1782         {
1783             int z = val>>16;
1784
1785             SetVertexXYZ(vertex, g_vecProjected[vertex].x, g_vecProjected[vertex].y, (((float)z/0x03FF)+0.5f)/2.0f );
1786             LOG_UCODE("Modify vert %d: z=%d", vertex, z);
1787             VTX_DUMP(TRACE2("Modify vert %d: z=%d", vertex, z));
1788         }
1789         break;
1790     case RSP_MV_WORD_OFFSET_POINT_ST:       // Texture
1791         {
1792             short tu = short(val>>16);
1793             short tv = short(val & 0xFFFF);
1794             float ftu = tu / 32.0f;
1795             float ftv = tv / 32.0f;
1796             LOG_UCODE("      Setting vertex %d tu/tv to %f, %f", vertex, (float)tu, (float)tv);
1797             CRender::g_pRender->SetVtxTextureCoord(vertex, ftu/gRSP.fTexScaleX, ftv/gRSP.fTexScaleY);
1798         }
1799         break;
1800     }
1801     DEBUGGER_PAUSE_AND_DUMP(NEXT_VERTEX_CMD,{TRACE0("Paused at ModVertex Cmd");});
1802 }
1803
1804 void ProcessVertexDataDKR(uint32 dwAddr, uint32 dwV0, uint32 dwNum)
1805 {
1806     UpdateCombinedMatrix();
1807
1808     long long pVtxBase = (long long) (g_pRDRAMu8 + dwAddr);
1809     g_pVtxBase = (FiddledVtx*)pVtxBase;
1810
1811     Matrix &matWorldProject = gRSP.DKRMatrixes[gRSP.DKRCMatrixIndex];
1812
1813     int nOff;
1814
1815     bool addbase=false;
1816     if ((!gRSP.DKRBillBoard) || (gRSP.DKRCMatrixIndex != 2) )
1817         addbase = false;
1818     else
1819         addbase = true;
1820
1821     if( addbase && gRSP.DKRVtxCount == 0 && dwNum > 1 )
1822     {
1823         gRSP.DKRVtxCount++;
1824     }
1825
1826     LOG_UCODE("    ProcessVertexDataDKR, CMatrix = %d, Add base=%s", gRSP.DKRCMatrixIndex, gRSP.DKRBillBoard?"true":"false");
1827     VTX_DUMP(TRACE2("DKR Setting Vertexes\nCMatrix = %d, Add base=%s", gRSP.DKRCMatrixIndex, gRSP.DKRBillBoard?"true":"false"));
1828
1829     nOff = 0;
1830     uint32 end = dwV0 + dwNum;
1831     for (uint32 i = dwV0; i < end; i++)
1832     {
1833         XVECTOR3 w;
1834
1835         g_vtxNonTransformed[i].x = (float)*(short*)((pVtxBase+nOff + 0) ^ 2);
1836         g_vtxNonTransformed[i].y = (float)*(short*)((pVtxBase+nOff + 2) ^ 2);
1837         g_vtxNonTransformed[i].z = (float)*(short*)((pVtxBase+nOff + 4) ^ 2);
1838
1839         //if( status.isSSEEnabled )
1840         //  SSEVec3TransformDKR(g_vtxTransformed[i], g_vtxNonTransformed[i]);
1841         //else
1842             Vec3Transform(&g_vtxTransformed[i], (XVECTOR3*)&g_vtxNonTransformed[i], &matWorldProject);  // Convert to w=1
1843
1844         if( gRSP.DKRVtxCount == 0 && dwNum==1 )
1845         {
1846             gRSP.DKRBaseVec.x = g_vtxTransformed[i].x;
1847             gRSP.DKRBaseVec.y = g_vtxTransformed[i].y;
1848             gRSP.DKRBaseVec.z = g_vtxTransformed[i].z;
1849             gRSP.DKRBaseVec.w = g_vtxTransformed[i].w;
1850         }
1851         else if( addbase )
1852         {
1853             g_vtxTransformed[i].x += gRSP.DKRBaseVec.x;
1854             g_vtxTransformed[i].y += gRSP.DKRBaseVec.y;
1855             g_vtxTransformed[i].z += gRSP.DKRBaseVec.z;
1856             g_vtxTransformed[i].w  = gRSP.DKRBaseVec.w;
1857         }
1858
1859         g_vecProjected[i].w = 1.0f / g_vtxTransformed[i].w;
1860         g_vecProjected[i].x = g_vtxTransformed[i].x * g_vecProjected[i].w;
1861         g_vecProjected[i].y = g_vtxTransformed[i].y * g_vecProjected[i].w;
1862         g_vecProjected[i].z = g_vtxTransformed[i].z * g_vecProjected[i].w;
1863
1864         gRSP.DKRVtxCount++;
1865
1866         VTX_DUMP(TRACE5("vtx %d: %f, %f, %f, %f", i,
1867             g_vtxTransformed[i].x,g_vtxTransformed[i].y,g_vtxTransformed[i].z,g_vtxTransformed[i].w));
1868
1869         if( gRSP.bFogEnabled )
1870         {
1871             g_fFogCoord[i] = g_vecProjected[i].z;
1872             if( g_vecProjected[i].w < 0 || g_vecProjected[i].z < 0 || g_fFogCoord[i] < gRSPfFogMin )
1873                 g_fFogCoord[i] = gRSPfFogMin;
1874         }
1875
1876         RSP_Vtx_Clipping(i);
1877
1878         short wA = *(short*)((pVtxBase+nOff + 6) ^ 2);
1879         short wB = *(short*)((pVtxBase+nOff + 8) ^ 2);
1880
1881         s8 r = (s8)(wA >> 8);
1882         s8 g = (s8)(wA);
1883         s8 b = (s8)(wB >> 8);
1884         s8 a = (s8)(wB);
1885
1886         if (gRSP.bLightingEnable)
1887         {
1888             g_normal.x = (char)r; //norma.nx;
1889             g_normal.y = (char)g; //norma.ny;
1890             g_normal.z = (char)b; //norma.nz;
1891
1892             Vec3TransformNormal(g_normal, matWorldProject)
1893 #if !defined(NO_ASM)
1894             if( status.isSSEEnabled )
1895                 g_dwVtxDifColor[i] = SSELightVert();
1896             else
1897 #endif
1898                 g_dwVtxDifColor[i] = LightVert(g_normal, i);
1899         }
1900         else
1901         {
1902             int nR, nG, nB, nA;
1903
1904             nR = r;
1905             nG = g;
1906             nB = b;
1907             nA = a;
1908             // Assign true vert colour after lighting/fogging
1909             g_dwVtxDifColor[i] = COLOR_RGBA(nR, nG, nB, nA);
1910         }
1911
1912         ReplaceAlphaWithFogFactor(i);
1913
1914         g_fVtxTxtCoords[i].x = g_fVtxTxtCoords[i].y = 1;
1915
1916         nOff += 10;
1917     }
1918
1919
1920     DEBUGGER_PAUSE_AND_DUMP(NEXT_VERTEX_CMD,{DebuggerAppendMsg("Paused at DKR Vertex Cmd, v0=%d, vn=%d, addr=%08X", dwV0, dwNum, dwAddr);});
1921 }
1922
1923
1924 extern uint32 dwPDCIAddr;
1925 void ProcessVertexDataPD(uint32 dwAddr, uint32 dwV0, uint32 dwNum)
1926 {
1927     UpdateCombinedMatrix();
1928
1929     N64VtxPD * pVtxBase = (N64VtxPD*)(g_pRDRAMu8 + dwAddr);
1930     g_pVtxBase = (FiddledVtx*)pVtxBase; // Fix me
1931
1932     for (uint32 i = dwV0; i < dwV0 + dwNum; i++)
1933     {
1934         N64VtxPD &vert = pVtxBase[i - dwV0];
1935
1936         g_vtxNonTransformed[i].x = (float)vert.x;
1937         g_vtxNonTransformed[i].y = (float)vert.y;
1938         g_vtxNonTransformed[i].z = (float)vert.z;
1939
1940 #if !defined(NO_ASM)
1941         if( status.isSSEEnabled )
1942             SSEVec3Transform(i);
1943         else
1944 #endif
1945         {
1946             Vec3Transform(&g_vtxTransformed[i], (XVECTOR3*)&g_vtxNonTransformed[i], &gRSPworldProject); // Convert to w=1
1947             g_vecProjected[i].w = 1.0f / g_vtxTransformed[i].w;
1948             g_vecProjected[i].x = g_vtxTransformed[i].x * g_vecProjected[i].w;
1949             g_vecProjected[i].y = g_vtxTransformed[i].y * g_vecProjected[i].w;
1950             g_vecProjected[i].z = g_vtxTransformed[i].z * g_vecProjected[i].w;
1951         }
1952
1953         g_fFogCoord[i] = g_vecProjected[i].z;
1954         if( g_vecProjected[i].w < 0 || g_vecProjected[i].z < 0 || g_fFogCoord[i] < gRSPfFogMin )
1955             g_fFogCoord[i] = gRSPfFogMin;
1956
1957         RSP_Vtx_Clipping(i);
1958
1959         uint8 *addr = g_pRDRAMu8+dwPDCIAddr+ (vert.cidx&0xFF);
1960         uint32 a = addr[0];
1961         uint32 r = addr[3];
1962         uint32 g = addr[2];
1963         uint32 b = addr[1];
1964
1965         if( gRSP.bLightingEnable )
1966         {
1967             g_normal.x = (char)r;
1968             g_normal.y = (char)g;
1969             g_normal.z = (char)b;
1970 #if !defined(NO_ASM)
1971             if( status.isSSEEnabled )
1972             {
1973                 SSEVec3TransformNormal();
1974                 g_dwVtxDifColor[i] = SSELightVert();
1975             }
1976             else
1977 #endif
1978             {
1979                 Vec3TransformNormal(g_normal, gRSPmodelViewTop);
1980                 g_dwVtxDifColor[i] = LightVert(g_normal, i);
1981             }
1982             *(((uint8*)&(g_dwVtxDifColor[i]))+3) = (uint8)a;    // still use alpha from the vertex
1983         }
1984         else
1985         {
1986             if( (gRDP.geometryMode & G_SHADE) == 0 && gRSP.ucode < 5 )  //Shade is disabled
1987             {
1988                 g_dwVtxDifColor[i] = gRDP.primitiveColor;
1989             }
1990             else    //FLAT shade
1991             {
1992                 g_dwVtxDifColor[i] = COLOR_RGBA(r, g, b, a);
1993             }
1994         }
1995
1996         if( options.bWinFrameMode )
1997         {
1998             g_dwVtxDifColor[i] = COLOR_RGBA(r, g, b, a);
1999         }
2000
2001         ReplaceAlphaWithFogFactor(i);
2002
2003         VECTOR2 & t = g_fVtxTxtCoords[i];
2004         if (gRSP.bTextureGen && gRSP.bLightingEnable )
2005         {
2006             // Not sure if we should transform the normal here
2007             //Matrix & matWV = gRSP.projectionMtxs[gRSP.projectionMtxTop];
2008             //Vec3TransformNormal(g_normal, matWV);
2009
2010             TexGen(g_fVtxTxtCoords[i].x, g_fVtxTxtCoords[i].y);
2011         }
2012         else
2013         {
2014             t.x = vert.s;
2015             t.y = vert.t;
2016         }
2017
2018
2019         VTX_DUMP(
2020         {
2021             DebuggerAppendMsg("vtx %d: %d %d %d", i, vert.x,vert.y,vert.z);
2022             DebuggerAppendMsg("      : %f, %f, %f, %f",
2023                 g_vtxTransformed[i].x,g_vtxTransformed[i].y,g_vtxTransformed[i].z,g_vtxTransformed[i].w);
2024             DebuggerAppendMsg("      : %X, %X, %X, %X", r,g,b,a);
2025             DebuggerAppendMsg("      : u=%f, v=%f", t.x, t.y);
2026         });
2027     }
2028
2029     VTX_DUMP(TRACE2("Setting Vertexes: %d - %d\n", dwV0, dwV0+dwNum-1));
2030     DEBUGGER_PAUSE_AND_DUMP(NEXT_VERTEX_CMD,{TRACE0("Paused at Vertex Cmd");});
2031 }
2032
2033 extern uint32 dwConkerVtxZAddr;
2034 void ProcessVertexDataConker(uint32 dwAddr, uint32 dwV0, uint32 dwNum)
2035 {
2036     UpdateCombinedMatrix();
2037
2038     FiddledVtx * pVtxBase = (FiddledVtx*)(g_pRDRAMu8 + dwAddr);
2039     g_pVtxBase = pVtxBase;
2040     //short *vertexColoraddr = (short*)(g_pRDRAMu8+dwConkerVtxZAddr);
2041
2042     for (uint32 i = dwV0; i < dwV0 + dwNum; i++)
2043     {
2044         SP_Timing(RSP_GBI0_Vtx);
2045
2046         FiddledVtx & vert = pVtxBase[i - dwV0];
2047
2048         g_vtxNonTransformed[i].x = (float)vert.x;
2049         g_vtxNonTransformed[i].y = (float)vert.y;
2050         g_vtxNonTransformed[i].z = (float)vert.z;
2051
2052 #if !defined(NO_ASM)
2053         if( status.isSSEEnabled )
2054             SSEVec3Transform(i);
2055         else
2056 #endif
2057         {
2058             Vec3Transform(&g_vtxTransformed[i], (XVECTOR3*)&g_vtxNonTransformed[i], &gRSPworldProject); // Convert to w=1
2059             g_vecProjected[i].w = 1.0f / g_vtxTransformed[i].w;
2060             g_vecProjected[i].x = g_vtxTransformed[i].x * g_vecProjected[i].w;
2061             g_vecProjected[i].y = g_vtxTransformed[i].y * g_vecProjected[i].w;
2062             g_vecProjected[i].z = g_vtxTransformed[i].z * g_vecProjected[i].w;
2063         }
2064
2065         g_fFogCoord[i] = g_vecProjected[i].z;
2066         if( g_vecProjected[i].w < 0 || g_vecProjected[i].z < 0 || g_fFogCoord[i] < gRSPfFogMin )
2067             g_fFogCoord[i] = gRSPfFogMin;
2068
2069         VTX_DUMP(
2070         {
2071             uint32 *dat = (uint32*)(&vert);
2072             DebuggerAppendMsg("vtx %d: %08X %08X %08X %08X", i, dat[0],dat[1],dat[2],dat[3]);
2073             DebuggerAppendMsg("      : %f, %f, %f, %f",
2074                 g_vtxTransformed[i].x,g_vtxTransformed[i].y,g_vtxTransformed[i].z,g_vtxTransformed[i].w);
2075             DebuggerAppendMsg("      : %f, %f, %f, %f",
2076                 g_vecProjected[i].x,g_vecProjected[i].y,g_vecProjected[i].z,g_vecProjected[i].w);
2077         });
2078
2079         RSP_Vtx_Clipping(i);
2080
2081         if( gRSP.bLightingEnable )
2082         {
2083             {
2084                 uint32 r= ((gRSP.ambientLightColor>>16)&0xFF);
2085                 uint32 g= ((gRSP.ambientLightColor>> 8)&0xFF);
2086                 uint32 b= ((gRSP.ambientLightColor    )&0xFF);
2087                 for( uint32 k=1; k<=gRSPnumLights; k++)
2088                 {
2089                     r += gRSPlights[k].r;
2090                     g += gRSPlights[k].g;
2091                     b += gRSPlights[k].b;
2092                 }
2093                 if( r>255 ) r=255;
2094                 if( g>255 ) g=255;
2095                 if( b>255 ) b=255;
2096                 r *= vert.rgba.r ;
2097                 g *= vert.rgba.g ;
2098                 b *= vert.rgba.b ;
2099                 r >>= 8;
2100                 g >>= 8;
2101                 b >>= 8;
2102                 g_dwVtxDifColor[i] = 0xFF000000;
2103                 g_dwVtxDifColor[i] |= (r<<16);
2104                 g_dwVtxDifColor[i] |= (g<< 8);
2105                 g_dwVtxDifColor[i] |= (b    );
2106             }
2107
2108             *(((uint8*)&(g_dwVtxDifColor[i]))+3) = vert.rgba.a; // still use alpha from the vertex
2109         }
2110         else
2111         {
2112             if( (gRDP.geometryMode & G_SHADE) == 0 && gRSP.ucode < 5 )  //Shade is disabled
2113             {
2114                 g_dwVtxDifColor[i] = gRDP.primitiveColor;
2115             }
2116             else    //FLAT shade
2117             {
2118                 g_dwVtxDifColor[i] = COLOR_RGBA(vert.rgba.r, vert.rgba.g, vert.rgba.b, vert.rgba.a);
2119             }
2120         }
2121
2122         if( options.bWinFrameMode )
2123         {
2124             //g_vecProjected[i].z = 0;
2125             g_dwVtxDifColor[i] = COLOR_RGBA(vert.rgba.r, vert.rgba.g, vert.rgba.b, vert.rgba.a);
2126         }
2127
2128         ReplaceAlphaWithFogFactor(i);
2129
2130         // Update texture coords n.b. need to divide tu/tv by bogus scale on addition to buffer
2131         //VECTOR2 & t = g_fVtxTxtCoords[i];
2132
2133         // If the vert is already lit, then there is no normal (and hence we
2134         // can't generate tex coord)
2135         if (gRSP.bTextureGen && gRSP.bLightingEnable )
2136         {
2137                 g_normal.x = (float)*(char*)(g_pRDRAMu8+ (((i<<1)+0)^3)+dwConkerVtxZAddr);
2138                 g_normal.y = (float)*(char*)(g_pRDRAMu8+ (((i<<1)+1)^3)+dwConkerVtxZAddr);
2139                 g_normal.z = (float)*(char*)(g_pRDRAMu8+ (((i<<1)+2)^3)+dwConkerVtxZAddr);
2140                 Vec3TransformNormal(g_normal, gRSPmodelViewTop);
2141                 TexGen(g_fVtxTxtCoords[i].x, g_fVtxTxtCoords[i].y);
2142         }
2143         else
2144         {
2145             g_fVtxTxtCoords[i].x = (float)vert.tu;
2146             g_fVtxTxtCoords[i].y = (float)vert.tv;
2147         }
2148     }
2149
2150     VTX_DUMP(TRACE2("Setting Vertexes: %d - %d\n", dwV0, dwV0+dwNum-1));
2151     DEBUGGER_PAUSE_AND_DUMP(NEXT_VERTEX_CMD,{DebuggerAppendMsg("Paused at Vertex Cmd");});
2152 }
2153
2154
2155 typedef struct{
2156     short y;
2157     short x;
2158     short flag;
2159     short z;
2160 } RS_Vtx_XYZ;
2161
2162 typedef union {
2163     struct {
2164         uint8 a;
2165         uint8 b;
2166         uint8 g;
2167         uint8 r;
2168     };
2169     struct {
2170         char na;    //a
2171         char nz;    //b
2172         char ny;    //g
2173         char nx;    //r
2174     };
2175 } RS_Vtx_Color;
2176
2177
2178 void ProcessVertexData_Rogue_Squadron(uint32 dwXYZAddr, uint32 dwColorAddr, uint32 dwXYZCmd, uint32 dwColorCmd)
2179 {
2180     UpdateCombinedMatrix();
2181
2182     uint32 dwV0 = 0;
2183     uint32 dwNum = (dwXYZCmd&0xFF00)>>10;
2184
2185     RS_Vtx_XYZ * pVtxXYZBase = (RS_Vtx_XYZ*)(g_pRDRAMu8 + dwXYZAddr);
2186     RS_Vtx_Color * pVtxColorBase = (RS_Vtx_Color*)(g_pRDRAMu8 + dwColorAddr);
2187
2188     uint32 i;
2189     for (i = dwV0; i < dwV0 + dwNum; i++)
2190     {
2191         RS_Vtx_XYZ & vertxyz = pVtxXYZBase[i - dwV0];
2192         RS_Vtx_Color & vertcolors = pVtxColorBase[i - dwV0];
2193
2194         g_vtxNonTransformed[i].x = (float)vertxyz.x;
2195         g_vtxNonTransformed[i].y = (float)vertxyz.y;
2196         g_vtxNonTransformed[i].z = (float)vertxyz.z;
2197
2198 #if !defined(NO_ASM)
2199         if( status.isSSEEnabled )
2200             SSEVec3Transform(i);
2201         else
2202 #endif
2203         {
2204             Vec3Transform(&g_vtxTransformed[i], (XVECTOR3*)&g_vtxNonTransformed[i], &gRSPworldProject); // Convert to w=1
2205             g_vecProjected[i].w = 1.0f / g_vtxTransformed[i].w;
2206             g_vecProjected[i].x = g_vtxTransformed[i].x * g_vecProjected[i].w;
2207             g_vecProjected[i].y = g_vtxTransformed[i].y * g_vecProjected[i].w;
2208             g_vecProjected[i].z = g_vtxTransformed[i].z * g_vecProjected[i].w;
2209         }
2210
2211         VTX_DUMP(
2212         {
2213             DebuggerAppendMsg("      : %f, %f, %f, %f",
2214                 g_vtxTransformed[i].x,g_vtxTransformed[i].y,g_vtxTransformed[i].z,g_vtxTransformed[i].w);
2215             DebuggerAppendMsg("      : %f, %f, %f, %f",
2216                 g_vecProjected[i].x,g_vecProjected[i].y,g_vecProjected[i].z,g_vecProjected[i].w);
2217         });
2218
2219         g_fFogCoord[i] = g_vecProjected[i].z;
2220         if( g_vecProjected[i].w < 0 || g_vecProjected[i].z < 0 || g_fFogCoord[i] < gRSPfFogMin )
2221             g_fFogCoord[i] = gRSPfFogMin;
2222
2223         RSP_Vtx_Clipping(i);
2224
2225         if( gRSP.bLightingEnable )
2226         {
2227             g_normal.x = (float)vertcolors.nx;
2228             g_normal.y = (float)vertcolors.ny;
2229             g_normal.z = (float)vertcolors.nz;
2230
2231 #if !defined(NO_ASM)
2232             if( status.isSSEEnabled )
2233             {
2234                 SSEVec3TransformNormal();
2235                 g_dwVtxDifColor[i] = SSELightVert();
2236             }
2237             else
2238 #endif
2239             {
2240                 Vec3TransformNormal(g_normal, gRSPmodelViewTop);
2241                 g_dwVtxDifColor[i] = LightVert(g_normal, i);
2242             }
2243             *(((uint8*)&(g_dwVtxDifColor[i]))+3) = vertcolors.a;    // still use alpha from the vertex
2244         }
2245         else
2246         {
2247             if( (gRDP.geometryMode & G_SHADE) == 0 && gRSP.ucode < 5 )  //Shade is disabled
2248             {
2249                 g_dwVtxDifColor[i] = gRDP.primitiveColor;
2250             }
2251             else    //FLAT shade
2252             {
2253                 g_dwVtxDifColor[i] = COLOR_RGBA(vertcolors.r, vertcolors.g, vertcolors.b, vertcolors.a);
2254             }
2255         }
2256
2257         if( options.bWinFrameMode )
2258         {
2259             g_dwVtxDifColor[i] = COLOR_RGBA(vertcolors.r, vertcolors.g, vertcolors.b, vertcolors.a);
2260         }
2261
2262         ReplaceAlphaWithFogFactor(i);
2263
2264         /*
2265         // Update texture coords n.b. need to divide tu/tv by bogus scale on addition to buffer
2266         VECTOR2 & t = g_fVtxTxtCoords[i];
2267
2268         // If the vert is already lit, then there is no normal (and hence we
2269         // can't generate tex coord)
2270         if (gRSP.bTextureGen && gRSP.bLightingEnable && g_textures[gRSP.curTile].m_bTextureEnable )
2271         {
2272             TexGen(g_fVtxTxtCoords[i].x, g_fVtxTxtCoords[i].y);
2273         }
2274         else
2275         {
2276             t.x = (float)vert.tu;
2277             t.y = (float)vert.tv;
2278         }
2279         */
2280     }
2281
2282     VTX_DUMP(TRACE2("Setting Vertexes: %d - %d\n", dwV0, dwV0+dwNum-1));
2283     DEBUGGER_PAUSE_AND_DUMP(NEXT_VERTEX_CMD,{TRACE0("Paused at Vertex Cmd");});
2284 }
2285
2286 void SetLightCol(uint32 dwLight, uint32 dwCol)
2287 {
2288     gRSPlights[dwLight].r = (uint8)((dwCol >> 24)&0xFF);
2289     gRSPlights[dwLight].g = (uint8)((dwCol >> 16)&0xFF);
2290     gRSPlights[dwLight].b = (uint8)((dwCol >>  8)&0xFF);
2291     gRSPlights[dwLight].a = 255;    // Ignore light alpha
2292     gRSPlights[dwLight].fr = (float)gRSPlights[dwLight].r;
2293     gRSPlights[dwLight].fg = (float)gRSPlights[dwLight].g;
2294     gRSPlights[dwLight].fb = (float)gRSPlights[dwLight].b;
2295     gRSPlights[dwLight].fa = 255;   // Ignore light alpha
2296
2297     //TRACE1("Set light %d color", dwLight);
2298     LIGHT_DUMP(TRACE2("Set Light %d color: %08X", dwLight, dwCol));
2299 }
2300
2301 void SetLightDirection(uint32 dwLight, float x, float y, float z, float range)
2302 {
2303     //gRSP.bLightIsUpdated = true;
2304
2305     //gRSPlights[dwLight].ox = x;
2306     //gRSPlights[dwLight].oy = y;
2307     //gRSPlights[dwLight].oz = z;
2308
2309     register float w = range == 0 ? (float)sqrt(x*x+y*y+z*z) : 1;
2310
2311     gRSPlights[dwLight].x = x/w;
2312     gRSPlights[dwLight].y = y/w;
2313     gRSPlights[dwLight].z = z/w;
2314     gRSPlights[dwLight].range = range;
2315     DEBUGGER_PAUSE_AND_DUMP(NEXT_SET_LIGHT,TRACE5("Set Light %d dir: %.4f, %.4f, %.4f, %.4f", dwLight, x, y, z, range));
2316 }
2317
2318 static float maxS0, maxT0;
2319 static float maxS1, maxT1;
2320 static bool validS0, validT0;
2321 static bool validS1, validT1;
2322
2323 void LogTextureCoords(float fTex0S, float fTex0T, float fTex1S, float fTex1T)
2324 {
2325     if( validS0 )
2326     {
2327         if( fTex0S<0 || fTex0S>maxS0 )  validS0 = false;
2328     }
2329     if( validT0 )
2330     {
2331         if( fTex0T<0 || fTex0T>maxT0 )  validT0 = false;
2332     }
2333     if( validS1 )
2334     {
2335         if( fTex1S<0 || fTex1S>maxS1 )  validS1 = false;
2336     }
2337     if( validT1 )
2338     {
2339         if( fTex1T<0 || fTex1T>maxT1 )  validT1 = false;
2340     }
2341 }
2342
2343 bool CheckTextureCoords(int tex)
2344 {
2345     if( tex==0 )
2346     {
2347         return validS0&&validT0;
2348     }
2349     else
2350     {
2351         return validS1&&validT1;
2352     }
2353 }
2354
2355 void ResetTextureCoordsLog(float maxs0, float maxt0, float maxs1, float maxt1)
2356 {
2357     maxS0 = maxs0;
2358     maxT0 = maxt0;
2359     maxS1 = maxs1;
2360     maxT1 = maxt1;
2361     validS0 = validT0 = true;
2362     validS1 = validT1 = true;
2363 }
2364
2365 void ForceMainTextureIndex(int dwTile)
2366 {
2367     if( dwTile == 1 && !(CRender::g_pRender->IsTexel0Enable()) && CRender::g_pRender->IsTexel1Enable() )
2368     {
2369         // Hack
2370         gRSP.curTile = 0;
2371     }
2372     else
2373     {
2374         gRSP.curTile = dwTile;
2375     }
2376 }
2377
2378 float HackZ2(float z)
2379 {
2380     z = (z+9)/10;
2381     return z;
2382 }
2383
2384 float HackZ(float z)
2385 {
2386     return HackZ2(z);
2387
2388     if( z < 0.1 && z >= 0 )
2389         z = (.1f+z)/2;
2390     else if( z < 0 )
2391         //return (10+z)/100;
2392         z = (expf(z)/20);
2393     return z;
2394 }
2395
2396 void HackZ(std::vector<XVECTOR3>& points)
2397 {
2398     int size = points.size();
2399     for( int i=0; i<size; i++)
2400     {
2401         XVECTOR3 &v = points[i];
2402         v.z = (float)HackZ(v.z);
2403     }
2404 }
2405
2406 void HackZAll()
2407 {
2408     if( CDeviceBuilder::m_deviceGeneralType == DIRECTX_DEVICE )
2409     {
2410         for( uint32 i=0; i<gRSP.numVertices; i++)
2411         {
2412             g_vtxBuffer[i].z = HackZ(g_vtxBuffer[i].z);
2413         }
2414     }
2415     else
2416     {
2417         for( uint32 i=0; i<gRSP.numVertices; i++)
2418         {
2419             float w = g_vtxProjected5[i][3];
2420             g_vtxProjected5[i][2] = HackZ(g_vtxProjected5[i][2]/w)*w;
2421         }
2422     }
2423 }
2424
2425
2426 extern XMATRIX reverseXY;
2427 extern XMATRIX reverseY;
2428
2429 void UpdateCombinedMatrix()
2430 {
2431     if( gRSP.bMatrixIsUpdated )
2432     {
2433         gRSPworldProject = gRSP.modelviewMtxs[gRSP.modelViewMtxTop] * gRSP.projectionMtxs[gRSP.projectionMtxTop];
2434         gRSP.bMatrixIsUpdated = false;
2435         gRSP.bCombinedMatrixIsUpdated = true;
2436     }
2437
2438     if( gRSP.bCombinedMatrixIsUpdated )
2439     {
2440         if( options.enableHackForGames == HACK_REVERSE_XY_COOR )
2441         {
2442             gRSPworldProject = gRSPworldProject * reverseXY;
2443         }
2444         if( options.enableHackForGames == HACK_REVERSE_Y_COOR )
2445         {
2446             gRSPworldProject = gRSPworldProject * reverseY;
2447         }
2448 #if !defined(NO_ASM)
2449         if( status.isSSEEnabled )
2450         {
2451             MatrixTranspose(&gRSPworldProjectTransported, &gRSPworldProject);
2452         }
2453 #endif
2454         gRSP.bCombinedMatrixIsUpdated = false;
2455     }
2456
2457     //if( gRSP.bWorldMatrixIsUpdated || gRSP.bLightIsUpdated )
2458     //{
2459     //  // Update lights with transported world matrix
2460     //  for( unsigned int l=0; l<gRSPnumLights; l++)
2461     //  {
2462     //      Vec3TransformCoord(&gRSPlights[l].td, &gRSPlights[l].od, &gRSPmodelViewTopTranspose);
2463     //      Vec3Normalize(&gRSPlights[l].td,&gRSPlights[l].td);
2464     //  }
2465
2466     //  gRSP.bWorldMatrixIsUpdated = false;
2467     //  gRSP.bLightIsUpdated = false;
2468     //}
2469 }
2470