source/mupen64plus-video-arachnoid/src/ucodes/UCode0.cpp

   1 /******************************************************************************
   2  * Arachnoid Graphics Plugin for Mupen64Plus
   3  * http://bitbucket.org/wahrhaft/mupen64plus-video-arachnoid/
   4  *
   5  * Copyright (C) 2007 Kristofer Karlsson, Rickard Niklasson
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20  *****************************************************************************/
  21
  22 #include "UCode0.h"
  23 #include "GBI.h"
  24 #include "RSP.h"
  25 #include "RDP.h"
  26 #include "Memory.h"
  27 #include "UCodeDefs.h"
  28 #include "GBIDefs.h"
  29 #include "Logger.h"
  30 #include "DisplayListParser.h"
  31
  32 //-----------------------------------------------------------------------------
  33 // Static Variables
  34 //-----------------------------------------------------------------------------
  35 RSP* UCode0::m_rsp = 0;   //!< Pointer to Reality Signal Processor
  36 RDP* UCode0::m_rdp = 0;   //!< Pointer to Reality Drawing Processor
  37 DisplayListParser* UCode0::m_displayListParser = 0;
  38 Memory* UCode0::m_memory = 0;
  39
  40 //-----------------------------------------------------------------------------
  41 //! Constructor
  42 //-----------------------------------------------------------------------------
  43 UCode0::UCode0()
  44 {
  45 }
  46
  47 //-----------------------------------------------------------------------------
  48 //! Destructor
  49 //-----------------------------------------------------------------------------
  50 UCode0::~UCode0()
  51 {
  52 }
  53
  54 //-----------------------------------------------------------------------------
  55 // Initialize
  56 //-----------------------------------------------------------------------------
  57 void UCode0::initialize(RSP* rsp, RDP* rdp, Memory* memory, DisplayListParser* dlp)
  58 {
  59     m_rsp = rsp;
  60     m_rdp = rdp;
  61     m_memory = memory;
  62     m_displayListParser = dlp;
  63 }
  64
  65 //-----------------------------------------------------------------------------
  66 //* Initialize GBI
  67 //! Assigns functions to the GBI
  68 //-----------------------------------------------------------------------------
  69 void UCode0::initializeGBI(GBI* gbi)
  70 {
  71     // Set GeometryMode flags
  72     GBI_InitFlags( F3D );
  73
  74     //GBI Command                            Command Value         Target          Command Function
  75     GBI_SetGBI( GBI::G_SPNOOP,               F3D_SPNOOP,           gbi->m_cmds,    F3D_SPNoOp );
  76     GBI_SetGBI( GBI::G_MTX,                  F3D_MTX,              gbi->m_cmds,    F3D_Mtx );
  77     GBI_SetGBI( GBI::G_RESERVED0,            F3D_RESERVED0,        gbi->m_cmds,    F3D_Reserved0 );
  78     GBI_SetGBI( GBI::G_MOVEMEM,              F3D_MOVEMEM,          gbi->m_cmds,    F3D_MoveMem );
  79     GBI_SetGBI( GBI::G_VTX,                  F3D_VTX,              gbi->m_cmds,    F3D_Vtx );
  80     GBI_SetGBI( GBI::G_RESERVED1,            F3D_RESERVED1,        gbi->m_cmds,    F3D_Reserved1 );
  81     GBI_SetGBI( GBI::G_DL,                   F3D_DL,               gbi->m_cmds,    F3D_DList );
  82     GBI_SetGBI( GBI::G_RESERVED2,            F3D_RESERVED2,        gbi->m_cmds,    F3D_Reserved2 );
  83     GBI_SetGBI( GBI::G_RESERVED3,            F3D_RESERVED3,        gbi->m_cmds,    F3D_Reserved3 );
  84     GBI_SetGBI( GBI::G_SPRITE2D_BASE,        F3D_SPRITE2D_BASE,    gbi->m_cmds,    F3D_Sprite2D_Base );
  85     GBI_SetGBI( GBI::G_MOVEWORD,             F3D_MOVEWORD,         gbi->m_cmds,    F3D_MoveWord );
  86     GBI_SetGBI( GBI::G_TRI1,                 F3D_TRI1,             gbi->m_cmds,    F3D_Tri1 );
  87     GBI_SetGBI( GBI::G_CULLDL,               F3D_CULLDL,           gbi->m_cmds,    F3D_CullDL );
  88     GBI_SetGBI( GBI::G_POPMTX,               F3D_POPMTX,           gbi->m_cmds,    F3D_PopMtx );
  89     GBI_SetGBI( GBI::G_TEXTURE,              F3D_TEXTURE,          gbi->m_cmds,    F3D_Texture );
  90     GBI_SetGBI( GBI::G_SETOTHERMODE_H,       F3D_SETOTHERMODE_H,   gbi->m_cmds,    F3D_SetOtherMode_H );
  91     GBI_SetGBI( GBI::G_SETOTHERMODE_L,       F3D_SETOTHERMODE_L,   gbi->m_cmds,    F3D_SetOtherMode_L );
  92     GBI_SetGBI( GBI::G_ENDDL,                F3D_ENDDL,            gbi->m_cmds,    F3D_EndDL );
  93     GBI_SetGBI( GBI::G_SETGEOMETRYMODE,      F3D_SETGEOMETRYMODE,  gbi->m_cmds,    F3D_SetGeometryMode );
  94     GBI_SetGBI( GBI::G_CLEARGEOMETRYMODE,    F3D_CLEARGEOMETRYMODE,gbi->m_cmds,    F3D_ClearGeometryMode );
  95     GBI_SetGBI( GBI::G_QUAD,                 F3D_QUAD,             gbi->m_cmds,    F3D_Quad );
  96     GBI_SetGBI( GBI::G_RDPHALF_1,            F3D_RDPHALF_1,        gbi->m_cmds,    F3D_RDPHalf_1 );
  97     GBI_SetGBI( GBI::G_RDPHALF_2,            F3D_RDPHALF_2,        gbi->m_cmds,    F3D_RDPHalf_2 );
  98     GBI_SetGBI( GBI::G_RDPHALF_CONT,         F3D_RDPHALF_CONT,     gbi->m_cmds,    F3D_RDPHalf_Cont );
  99     GBI_SetGBI( GBI::G_TRI4,                 F3D_TRI4,             gbi->m_cmds,    F3D_Tri4 );
 100 }
 101
 102 //*****************************************************************************
 103 // Matrix Functions
 104 //*****************************************************************************
 105
 106 //-----------------------------------------------------------------------------
 107 //* Add Matrix
 108 //! @param ucode instruction from displaylist with input data
 109 //-----------------------------------------------------------------------------
 110 void UCode0::F3D_Mtx(MicrocodeArgument* ucode)
 111 {
 112     Logger::getSingleton().printMsg("F3D_Mtx", M64MSG_VERBOSE);
 113     RSPUCodeAddMatrix0* temp = (RSPUCodeAddMatrix0*)ucode;
 114
 115     //Add matrix
 116     m_rsp->RSP_Matrix( temp->segmentAddress, //Segment adress
 117                        temp->projection,     //Projection or view matrix?
 118                        temp->push,           //Save Current Matrix?
 119                        temp->load );         //Replace aka Load or Mult
 120 }
 121
 122 //-----------------------------------------------------------------------------
 123 //* Pop Matrix
 124 //! @param ucode instruction from displaylist with input data
 125 //-----------------------------------------------------------------------------
 126 void UCode0::F3D_PopMtx(MicrocodeArgument* ucode)
 127 {
 128     Logger::getSingleton().printMsg("F3D_PopMtx", M64MSG_VERBOSE);
 129
 130     //Pop Matrix
 131     m_rsp->RSP_PopMatrix();
 132 }
 133
 134 //*****************************************************************************
 135 // Vertex Functions
 136 //*****************************************************************************
 137
 138 //-----------------------------------------------------------------------------
 139 //* Add Vertex
 140 //! @param ucode instruction from displaylist with input data
 141 //-----------------------------------------------------------------------------
 142 void UCode0::F3D_Vtx(MicrocodeArgument* ucode)
 143 {
 144     Logger::getSingleton().printMsg("F3D_Vtx", M64MSG_VERBOSE);
 145     RSPUCodeAddVertices0* temp = (RSPUCodeAddVertices0*)ucode;
 146
 147     //Add vertex
 148     m_rsp->RSP_Vertex(temp->segmentAddress, temp->numVertices + 1, temp->firstVertex);
 149 }
 150
 151 //-----------------------------------------------------------------------------
 152 //* F3D Render 1 Triangle
 153 //! @param ucode instruction from displaylist with input data
 154 //! @todo Triangle flag?
 155 //-----------------------------------------------------------------------------
 156 void UCode0::F3D_Tri1(MicrocodeArgument* ucode)
 157 {
 158     Logger::getSingleton().printMsg("F3D_Tri1", M64MSG_VERBOSE);
 159     RSPUCodeAddOneTriangleF3D* temp = (RSPUCodeAddOneTriangleF3D*)ucode;
 160
 161     //Add one triangle  //TODO Flag?
 162     m_rsp->RSP_1Triangle(temp->index0 / 10, temp->index1 / 10, temp->index2 / 10);
 163 }
 164
 165 //-----------------------------------------------------------------------------
 166 //* F3D Render 4 Triangles
 167 //! @param ucode instruction from displaylist with input data
 168 //-----------------------------------------------------------------------------
 169 void UCode0::F3D_Tri4(MicrocodeArgument* ucode)
 170 {
 171     Logger::getSingleton().printMsg("F3D_Tri4", M64MSG_VERBOSE);
 172     RSPUCodeAddFourTrianglesF3D* temp = (RSPUCodeAddFourTrianglesF3D*)ucode;
 173
 174     //Add four triangles
 175     m_rsp->RSP_4Triangles( temp->v0, temp->v1, temp->v2,
 176                            temp->v3, temp->v4, temp->v5,
 177                            temp->v6, temp->v7, temp->v8,
 178                            temp->v9, temp->v10, temp->v11);
 179 }
 180
 181 //-----------------------------------------------------------------------------
 182 //* F3D Render 1 Quad
 183 //! @param ucode instruction from displaylist with input data
 184 //-----------------------------------------------------------------------------
 185 void UCode0::F3D_Quad(MicrocodeArgument* ucode)
 186 {
 187     Logger::getSingleton().printMsg("F3D_Quad", M64MSG_VERBOSE);
 188     RSPUCodeAddOneQuadF3D* temp = (RSPUCodeAddOneQuadF3D*)ucode;
 189
 190     //Add one Quad
 191     m_rsp->RSP_1Quadrangle(temp->index0 / 10, temp->index1 / 10, temp->index2 / 10, temp->index3 / 10);
 192 }
 193
 194 //*****************************************************************************
 195 // Display List Functions
 196 //*****************************************************************************
 197
 198 //-----------------------------------------------------------------------------
 199 //* Display List
 200 //! @param ucode instruction from displaylist with input data
 201 //-----------------------------------------------------------------------------
 202 void UCode0::F3D_DList(MicrocodeArgument* ucode)
 203 {
 204     Logger::getSingleton().printMsg("F3D_DList", M64MSG_VERBOSE);
 205     RSPUCodeDisplayList* temp = (RSPUCodeDisplayList*)ucode;
 206
 207     switch ( temp->param )
 208     {
 209         case G_DL_PUSH   : m_rsp->RSP_DisplayList( temp->segmentAddress ); break;
 210         case G_DL_NOPUSH : m_rsp->RSP_BranchList( temp->segmentAddress );  break;
 211     }
 212 }
 213
 214 //-----------------------------------------------------------------------------
 215 //* End Display List
 216 //! @param ucode instruction from displaylist with input data
 217 //-----------------------------------------------------------------------------
 218 void UCode0::F3D_EndDL(MicrocodeArgument* ucode)
 219 {
 220     Logger::getSingleton().printMsg("F3D_EndDL", M64MSG_VERBOSE);
 221
 222     //End Display List
 223     m_rsp->RSP_EndDisplayList();
 224 }
 225
 226 //-----------------------------------------------------------------------------
 227 // Cull Display List
 228 //! @todo Cull Display List
 229 //-----------------------------------------------------------------------------
 230 void UCode0::F3D_CullDL(MicrocodeArgument* ucode)
 231 {
 232     Logger::getSingleton().printMsg("F3D_CullDL", M64MSG_VERBOSE);
 233     //TODO
 234 }
 235
 236 //*****************************************************************************
 237 // Texturing
 238 //*****************************************************************************
 239
 240 //-----------------------------------------------------------------------------
 241 // Texture
 242 //-----------------------------------------------------------------------------
 243 void UCode0::F3D_Texture(MicrocodeArgument* ucode)
 244 {
 245     Logger::getSingleton().printMsg("F3D_Texture", M64MSG_VERBOSE);
 246     RSPUCodeTexture* temp = (RSPUCodeTexture*)ucode;
 247
 248     float scaleS  = _FIXED2FLOAT( _SHIFTR( ucode->w1, 16, 16 ), 16 );
 249     float scaleT  = _FIXED2FLOAT( _SHIFTR( ucode->w1, 0, 16 ), 16 );
 250     int on       = _SHIFTR( ucode->w0, 0, 8 );
 251
 252     m_rsp->RSP_Texture(scaleS, scaleT, (int)temp->level, (int)temp->tile, on);
 253 }
 254
 255 //*****************************************************************************
 256 // Half
 257 //*****************************************************************************
 258
 259 //-----------------------------------------------------------------------------
 260 //* Half 1
 261 //! @param ucode instruction from displaylist with input data
 262 //-----------------------------------------------------------------------------
 263 void UCode0::F3D_RDPHalf_1(MicrocodeArgument* ucode)
 264 {
 265     Logger::getSingleton().printMsg("F3D_RDPHalf_1", M64MSG_VERBOSE);
 266     m_rdp->setHalf1( ucode->w1 );
 267 }
 268
 269 //-----------------------------------------------------------------------------
 270 //* Half 2
 271 //! @param ucode instruction from displaylist with input data
 272 //-----------------------------------------------------------------------------
 273 void UCode0::F3D_RDPHalf_2(MicrocodeArgument* ucode)
 274 {
 275     Logger::getSingleton().printMsg("F3D_RDPHalf_2", M64MSG_VERBOSE);
 276     m_rdp->setHalf2( ucode->w1 );
 277 }
 278 //-----------------------------------------------------------------------------
 279 // Half Cont
 280 //-----------------------------------------------------------------------------
 281 void UCode0::F3D_RDPHalf_Cont(MicrocodeArgument* ucode)
 282 {
 283     Logger::getSingleton().printMsg("F3D_RDPHalf_Cont", M64MSG_VERBOSE);
 284     //Ignore
 285 }
 286
 287 //*****************************************************************************
 288 // Geometry Mode
 289 //*****************************************************************************
 290
 291 //-----------------------------------------------------------------------------
 292 // Set Geometry Mode
 293 //-----------------------------------------------------------------------------
 294 void UCode0::F3D_SetGeometryMode(MicrocodeArgument* ucode)
 295 {
 296     Logger::getSingleton().printMsg("F3D_SetGeometryMode", M64MSG_VERBOSE);
 297     m_rsp->RSP_SetGeometryMode(ucode->w1);
 298 }
 299
 300 //-----------------------------------------------------------------------------
 301 // Clear Geometry Mode
 302 //-----------------------------------------------------------------------------
 303 void UCode0::F3D_ClearGeometryMode(MicrocodeArgument* ucode)
 304 {
 305     Logger::getSingleton().printMsg("F3D_ClearGeometryMode", M64MSG_VERBOSE);
 306     m_rsp->RSP_ClearGeometryMode(ucode->w1);
 307 }
 308
 309 //*****************************************************************************
 310 // Set Other Modes
 311 //*****************************************************************************
 312
 313 //-----------------------------------------------------------------------------
 314 // Set Other Mode H
 315 //-----------------------------------------------------------------------------
 316 void UCode0::F3D_SetOtherMode_H(MicrocodeArgument* ucode)
 317 {
 318     Logger::getSingleton().printMsg("F3D_SetOtherMode_H", M64MSG_VERBOSE);
 319
 320     unsigned int otherModeType = _SHIFTR(ucode->w0, 8, 8);
 321     unsigned int w1             = ucode->w1;
 322
 323     switch ( otherModeType )
 324     {
 325         case G_MDSFT_PIPELINE:
 326             //gDPPipelineMode( w1 >> G_MDSFT_PIPELINE );
 327             break;
 328         case G_MDSFT_CYCLETYPE:
 329             m_rdp->setCycleType( G_CYCLE_TYPE(w1 >> G_MDSFT_CYCLETYPE) );
 330             break;
 331
 332         case G_MDSFT_TEXTPERSP:
 333             //gDPSetTexturePersp( w1 >> G_MDSFT_TEXTPERSP );
 334             break;
 335         case G_MDSFT_TEXTDETAIL:
 336             //gDPSetTextureDetail( w1 >> G_MDSFT_TEXTDETAIL );
 337             break;
 338         case G_MDSFT_TEXTLOD:
 339             //gDPSetTextureLOD( w1 >> G_MDSFT_TEXTLOD );
 340             break;
 341         case G_MDSFT_TEXTLUT:
 342             m_rdp->setTextureLUT( w1 >> G_MDSFT_TEXTLUT );
 343             break;
 344         case G_MDSFT_TEXTFILT:
 345             m_rdp->setTextureFiltering(w1 >> G_MDSFT_TEXTFILT);
 346             break;
 347         case G_MDSFT_TEXTCONV:
 348             //gDPSetTextureConvert( w1 >> G_MDSFT_TEXTCONV );
 349             break;
 350         case G_MDSFT_COMBKEY:
 351             //gDPSetCombineKey( w1 >> G_MDSFT_COMBKEY );
 352             break;
 353         case G_MDSFT_RGBDITHER:
 354             //gDPSetColorDither( w1 >> G_MDSFT_RGBDITHER );
 355             break;
 356         case G_MDSFT_ALPHADITHER:
 357             //gDPSetAlphaDither( w1 >> G_MDSFT_ALPHADITHER );
 358             break;
 359         default:
 360             unsigned int shift = _SHIFTR( ucode->w0, 8, 8 );
 361             unsigned int length = _SHIFTR( ucode->w0, 0, 8 );
 362             unsigned int mask = ((1 << length) - 1) << shift;
 363             m_rdp->m_otherMode.h &= ~mask;
 364             m_rdp->m_otherMode.h |= w1 & mask;
 365             m_rdp->setUpdateCombiner(true);
 366             break;
 367     }
 368 }
 369
 370 //-----------------------------------------------------------------------------
 371 // Set Other Mode L
 372 //-----------------------------------------------------------------------------
 373 void UCode0::F3D_SetOtherMode_L(MicrocodeArgument* ucode)
 374 {
 375     Logger::getSingleton().printMsg("F3D_SetOtherMode_L", M64MSG_VERBOSE);
 376
 377     switch (_SHIFTR( ucode->w0, 8, 8 ))
 378     {
 379         case G_MDSFT_ALPHACOMPARE:
 380             m_rdp->setAlphaCompareMode(ucode->w1 >> G_MDSFT_ALPHACOMPARE);
 381             break;
 382         case G_MDSFT_ZSRCSEL:
 383             m_rdp->setDepthSource( ucode->w1 >> G_MDSFT_ZSRCSEL );
 384             break;
 385         case G_MDSFT_RENDERMODE:
 386             m_rdp->setRenderMode(ucode->w1);
 387             break;
 388         default:
 389             unsigned int shift = _SHIFTR( ucode->w0, 8, 8 );
 390             unsigned int length = _SHIFTR( ucode->w0, 0, 8 );
 391             unsigned int mask = ((1 << length) - 1) << shift;
 392
 393             m_rdp->m_otherMode.l &= ~mask;
 394             m_rdp->m_otherMode.l |= ucode->w1 & mask;
 395             break;
 396     }
 397 }
 398
 399
 400 //*****************************************************************************
 401 // Other
 402 //*****************************************************************************
 403
 404 //-----------------------------------------------------------------------------
 405 //* Move Mem
 406 //! @todo Add more case in switch, Like Force Matrix
 407 //-----------------------------------------------------------------------------
 408 void UCode0::F3D_MoveMem(MicrocodeArgument* ucode)
 409 {
 410     Logger::getSingleton().printMsg("F3D_MoveMem", M64MSG_VERBOSE);
 411
 412     unsigned int type    = ((ucode->w0)>>16)&0xFF;
 413     unsigned int segmentAddress = ucode->w1;
 414
 415     switch (type)
 416     {
 417         //Viewport
 418         case F3D_MV_VIEWPORT:
 419             m_rsp->moveMemViewport(segmentAddress);
 420             break;
 421
 422         case G_MV_MATRIX_1:
 423             m_rsp->RSP_ForceMatrix(segmentAddress);
 424             m_displayListParser->increasePC(24); //// force matrix takes four commands
 425             break;
 426
 427         //Lights
 428         case G_MV_L0: m_rsp->RSP_Light(0, segmentAddress); break;
 429         case G_MV_L1: m_rsp->RSP_Light(1, segmentAddress); break;
 430         case G_MV_L2: m_rsp->RSP_Light(2, segmentAddress); break;
 431         case G_MV_L3: m_rsp->RSP_Light(3, segmentAddress); break;
 432         case G_MV_L4: m_rsp->RSP_Light(4, segmentAddress); break;
 433         case G_MV_L5: m_rsp->RSP_Light(5, segmentAddress); break;
 434         case G_MV_L6: m_rsp->RSP_Light(6, segmentAddress); break;
 435         case G_MV_L7: m_rsp->RSP_Light(7, segmentAddress); break;
 436
 437         //Look at
 438         case G_MV_LOOKATX:
 439             //IGNORE
 440             break;
 441         //Look at
 442         case G_MV_LOOKATY:
 443             //IGNORE
 444             break;
 445
 446         //case RSP_GBI1_MV_MEM_LOOKATY:
 447         //    //IGNORE
 448         //    break;
 449         //case RSP_GBI1_MV_MEM_LOOKATX:
 450         //    //IGNORE
 451         //    break;
 452
 453         //TODO?
 454         //case RSP_GBI1_MV_MEM_TXTATT:    break;
 455         //case RSP_GBI1_MV_MEM_MATRIX_1:
 456         //  RSP_GFX_Force_Matrix(addr);
 457         //    break;
 458         //case RSP_GBI1_MV_MEM_MATRIX_2: break;
 459         //case RSP_GBI1_MV_MEM_MATRIX_3: break;
 460         //case RSP_GBI1_MV_MEM_MATRIX_4: break;
 461
 462         default:
 463             Logger::getSingleton().printMsg("F3D_MoveMem: Unknown type", M64MSG_WARNING);
 464             break;
 465     }
 466 }
 467
 468 //-----------------------------------------------------------------------------
 469 //* F3D Sprite2D Base
 470 //! @todo F3D Sprite2D Base
 471 //-----------------------------------------------------------------------------
 472 void UCode0::F3D_Sprite2D_Base(MicrocodeArgument* ucode)
 473 {
 474     Logger::getSingleton().printMsg("F3D_Sprite2D_Base - Unimplemented", M64MSG_WARNING);
 475     //TODO
 476 }
 477
 478 //-----------------------------------------------------------------------------
 479 // Move Word
 480 //-----------------------------------------------------------------------------
 481 void UCode0::F3D_MoveWord(MicrocodeArgument* ucode)
 482 {
 483     Logger::getSingleton().printMsg("F3D_MoveWord");
 484     RSPUCodeMoveWordF3D* temp = (RSPUCodeMoveWordF3D*)ucode;
 485
 486     switch ( temp->type )
 487     {
 488         case G_MW_MATRIX:
 489             m_rsp->RSP_InsertMatrix(temp->offset, temp->value);
 490             break;
 491
 492         case G_MW_FOG:
 493             m_rsp->RSP_FogFactor( (short)temp->fm, (short)temp->fo );
 494             break;
 495
 496         case G_MW_NUMLIGHT:
 497             m_rsp->RSP_NumLights( (unsigned int)(((ucode->w1 - 0x80000000) >> 5) - 1) );
 498             break;
 499
 500         case G_MW_SEGMENT:
 501             m_rsp->moveSegment((temp->offset >> 2) & 0xF, temp->value);
 502             break;
 503
 504         case G_MW_LIGHTCOL:
 505             if ( (temp->offset & 0x7) == 0 )
 506             {
 507                 m_rsp->RSP_LightColor(temp->offset / 0x20, temp->value);
 508             }
 509             break;
 510
 511         case G_MW_POINTS:
 512             m_rsp->RSP_ModifyVertex( _SHIFTR( ucode->w0, 8, 16 ) / 40, _SHIFTR( ucode->w0, 0, 8 ) % 40, ucode->w1);
 513             break;
 514
 515         case G_MW_CLIP:
 516             //gSPClipRatio( w1 );
 517             break;
 518
 519         case G_MW_PERSPNORM:
 520             //gSPPerspNormalize( w1 );
 521             break;
 522     }
 523 }
 524
 525 //*****************************************************************************
 526 // Non important functions
 527 //*****************************************************************************
 528
 529 void UCode0::F3D_SPNoOp(MicrocodeArgument* ucode){
 530     Logger::getSingleton().printMsg("F3D_SPNoOp", M64MSG_VERBOSE);
 531
 532     //If next command is a no-operation then skip displaylist for some ucodes.
 533     //if( (ucode+1)->words.cmd == 0x00 && gRSP.ucode >= 17 )
 534     //{
 535     //  m_rsp->RSP_EndDisplayList();
 536     //}
 537 }
 538
 539 void UCode0::F3D_Reserved0(MicrocodeArgument* ucode) {
 540     Logger::getSingleton().printMsg("F3D_Reserved0", M64MSG_VERBOSE);
 541 }
 542
 543 void UCode0::F3D_Reserved1(MicrocodeArgument* ucode){
 544     Logger::getSingleton().printMsg("F3D_Reserved1", M64MSG_VERBOSE);
 545 }
 546
 547 void UCode0::F3D_Reserved2(MicrocodeArgument* ucode){
 548     Logger::getSingleton().printMsg("F3D_Reserved2", M64MSG_VERBOSE);
 549 }
 550
 551 void UCode0::F3D_Reserved3(MicrocodeArgument* ucode){
 552     Logger::getSingleton().printMsg("F3D_Reserved3", M64MSG_VERBOSE);
 553 }