API tools faq
paste
Guest User

Untitled

a guest
Jan 22nd, 2018
85
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 27.42 KB | None | 0 0
raw download clone embed print report
  1. #include "emu.h"
  2. #include "includes/n64.h"
  3. #include "video/n64.h"
  4.  
  5. namespace N64
  6. {
  7.  
  8. namespace RDP
  9. {
  10.  
  11. #define RELATIVE(x, y)  ((((x) >> 3) - (y)) << 3) | (x & 7);
  12.  
  13. void TexturePipe::SetMachine(running_machine &machine)
  14. {
  15.     _n64_state *state = machine.driver_data<_n64_state>();
  16.  
  17.     m_machine = &machine;
  18.     m_rdp = &state->m_rdp;
  19.     m_other_modes = m_rdp->GetOtherModes();
  20.     m_misc_state = m_rdp->GetMiscState();
  21. }
  22.  
  23. void TexturePipe::Mask(INT32* S, INT32* T, INT32 num)
  24. {
  25.     Tile* tile = m_rdp->GetTiles();
  26.  
  27.     if (tile[num].mask_s)
  28.     {
  29.         INT32 wrap = *S >> (tile[num].mask_s > 10 ? 10 : tile[num].mask_s);
  30.         wrap &= 1;
  31.         if (tile[num].ms && wrap)
  32.         {
  33.             *S = (~(*S));
  34.         }
  35.         *S &= m_maskbits_table[tile[num].mask_s];
  36.     }
  37.  
  38.     if (tile[num].mask_t)
  39.     {
  40.         INT32 wrap = *T >> (tile[num].mask_t > 10 ? 10 : tile[num].mask_t);
  41.         wrap &= 1;
  42.         if (tile[num].mt && wrap)
  43.         {
  44.             *T = (~(*T));
  45.         }
  46.         *T &= m_maskbits_table[tile[num].mask_t];
  47.     }
  48. }
  49.  
  50. void TexturePipe::MaskCoupled(INT32* S, INT32* S1, INT32* T, INT32* T1, INT32 num)
  51. {
  52.     Tile* tile = m_rdp->GetTiles();
  53.  
  54.     if (tile[num].mask_s)
  55.     {
  56.         INT32 maskbits_s = m_maskbits_table[tile[num].mask_s];
  57.         if (tile[num].ms)
  58.         {
  59.             INT32 swrapthreshold = tile[num].mask_s > 10 ? 10 : tile[num].mask_s;
  60.             INT32 wrap = (*S >> swrapthreshold) & 1;
  61.             INT32 wrap1 = (*S1 >> swrapthreshold) & 1;
  62.             if (wrap)
  63.             {
  64.                 *S = (~(*S));
  65.             }
  66.             if (wrap1)
  67.             {
  68.                 *S1 = (~(*S1));
  69.             }
  70.         }
  71.         *S &= maskbits_s;
  72.         *S1 &= maskbits_s;
  73.     }
  74.  
  75.     if (tile[num].mask_t)
  76.     {
  77.         INT32 maskbits_t = m_maskbits_table[tile[num].mask_t];
  78.         if (tile[num].mt)
  79.         {
  80.             INT32 twrapthreshold = tile[num].mask_t > 10 ? 10 : tile[num].mask_t;
  81.             INT32 wrap = (*T >> twrapthreshold) & 1;
  82.             INT32 wrap1 = (*T1 >> twrapthreshold) & 1;
  83.             if (wrap)
  84.             {
  85.                 *T = (~(*T));
  86.             }
  87.             if (wrap1)
  88.             {
  89.                 *T1 = (~(*T1));
  90.             }
  91.         }
  92.         *T &= maskbits_t;
  93.         *T1 &= maskbits_t;
  94.     }
  95. }
  96.  
  97. void TexturePipe::ShiftCycle(INT32* S, INT32* T, INT32* maxs, INT32* maxt, UINT32 num)
  98. {
  99.     Tile* tile = m_rdp->GetTiles();
  100.     *S = SIGN16(*S);
  101.     *T = SIGN16(*T);
  102.     if (tile[num].shift_s < 11)
  103.     {
  104.         *S >>= tile[num].shift_s;
  105.     }
  106.     else
  107.     {
  108.         *S <<= (16 - tile[num].shift_s);
  109.     }
  110.     *S = SIGN16(*S);
  111.     if (tile[num].shift_t < 11)
  112.     {
  113.         *T >>= tile[num].shift_t;
  114.     }
  115.     else
  116.     {
  117.         *T <<= (16 - tile[num].shift_t);
  118.     }
  119.     *T = SIGN16(*T);
  120.  
  121.     *maxs = ((*S >> 3) >= tile[num].sh);
  122.     *maxt = ((*T >> 3) >= tile[num].th);
  123. }
  124.  
  125. void TexturePipe::ShiftCopy(INT32* S, INT32* T, UINT32 num)
  126. {
  127.     Tile* tile = m_rdp->GetTiles();
  128.     *S = SIGN16(*S);
  129.     *T = SIGN16(*T);
  130.     if (tile[num].shift_s < 11)//?-? tcu_tile
  131.     {
  132.         *S >>= tile[num].shift_s;
  133.     }
  134.     else
  135.     {
  136.         *S <<= (16 - tile[num].shift_s);
  137.     }
  138.     *S = SIGN16(*S);
  139.     if (tile[num].shift_t < 11)
  140.     {
  141.         *T >>= tile[num].shift_t;
  142.     }
  143.     else
  144.     {
  145.         *T <<= (16 - tile[num].shift_t);
  146.     }
  147.     *T = SIGN16(*T);
  148. }
  149.  
  150. void TexturePipe::ClampCycle(INT32* S, INT32* T, INT32* SFRAC, INT32* TFRAC, INT32 maxs, INT32 maxt, INT32 num)
  151. {
  152.     Tile* tile = m_rdp->GetTiles();
  153.     int dos = tile[num].cs || !tile[num].mask_s;
  154.     int dot = tile[num].ct || !tile[num].mask_t;
  155.  
  156.     if (dos)
  157.     {
  158.         if (*S & 0x10000)
  159.         {
  160.             *S = 0;
  161.             *SFRAC = 0;
  162.         }
  163.         else if (maxs)
  164.         {
  165.             *S = m_clamp_s_diff[num];
  166.             *SFRAC = 0;
  167.         }
  168.         else
  169.         {
  170.             *S = (SIGN17(*S) >> 5) & 0x1fff;
  171.         }
  172.     }
  173.     else
  174.     {
  175.         *S = (SIGN17(*S) >> 5) & 0x1fff;
  176.     }
  177.  
  178.     if (dot)
  179.     {
  180.         if (*T & 0x10000)
  181.         {
  182.             *T = 0;
  183.             *TFRAC = 0;
  184.         }
  185.         else if (maxt)
  186.         {
  187.             *T = m_clamp_t_diff[num];
  188.             *TFRAC = 0;
  189.         }
  190.         else
  191.         {
  192.             *T = (SIGN17(*T) >> 5) & 0x1fff;
  193.         }
  194.     }
  195.     else
  196.     {
  197.         *T = (SIGN17(*T) >> 5) & 0x1fff;
  198.     }
  199. }
  200.  
  201. void TexturePipe::ClampCycleLight(INT32* S, INT32* T, bool maxs, bool maxt, INT32 num)
  202. {
  203.     Tile* tile = m_rdp->GetTiles();
  204.     int dos = tile[num].cs || !tile[num].mask_s;
  205.     int dot = tile[num].ct || !tile[num].mask_t;
  206.  
  207.     if (dos)
  208.     {
  209.         if (*S & 0x10000)
  210.         {
  211.             *S = 0;
  212.         }
  213.         else if (maxs)
  214.         {
  215.             *S = m_clamp_s_diff[num];
  216.         }
  217.         else
  218.         {
  219.             *S = (SIGN17(*S) >> 5) & 0x1fff;
  220.         }
  221.     }
  222.     else
  223.     {
  224.         *S = (SIGN17(*S) >> 5) & 0x1fff;
  225.     }
  226.  
  227.     if (dot)
  228.     {
  229.         if (*T & 0x10000)
  230.         {
  231.             *T = 0;
  232.         }
  233.         else if (maxt)
  234.         {
  235.             *T = m_clamp_t_diff[num];
  236.         }
  237.         else
  238.         {
  239.             *T = (SIGN17(*T) >> 5) & 0x1fff;
  240.         }
  241.     }
  242.     else
  243.     {
  244.         *T = (SIGN17(*T) >> 5) & 0x1fff;
  245.     }
  246. }
  247.  
  248. void TexturePipe::Cycle(Color* TEX, Color* prev, INT32 SSS, INT32 SST, UINT32 tilenum, UINT32 cycle)
  249. {
  250.     Tile* tile = m_rdp->GetTiles();
  251.  
  252. #define TRELATIVE(x, y)     ((((x) >> 3) - (y)) << 3) | (x & 7);
  253.     INT32 bilerp = cycle ? m_other_modes->bi_lerp1 : m_other_modes->bi_lerp0;
  254.     int convert = m_other_modes->convert_one && cycle;
  255.     Color t0;
  256.     Color t1;
  257.     Color t2;
  258.     Color t3;
  259.     if (m_other_modes->sample_type)
  260.     {
  261.         int sss1, sst1, sss2, sst2;
  262.  
  263.         INT32 invsf = 0;
  264.         INT32 invtf = 0;
  265.         int center = 0;
  266.  
  267.         sss1 = SSS;
  268.         sst1 = SST;
  269.  
  270.         INT32 maxs;
  271.         INT32 maxt;
  272.  
  273.         ShiftCycle(&sss1, &sst1, &maxs, &maxt, tilenum);
  274.  
  275.         sss1 = TRELATIVE(sss1, tile[tilenum].sl);
  276.         sst1 = TRELATIVE(sst1, tile[tilenum].tl);
  277.  
  278.         INT32 sfrac = sss1 & 0x1f;
  279.         INT32 tfrac = sst1 & 0x1f;
  280.  
  281.         ClampCycle(&sss1, &sst1, &sfrac, &tfrac, maxs, maxt, tilenum);
  282.  
  283.         sss2 = sss1 + 1;
  284.         sst2 = sst1 + 1;
  285.  
  286.         MaskCoupled(&sss1, &sss2, &sst1, &sst2, tilenum);
  287.  
  288.         bool upper = ((sfrac + tfrac) >= 0x20);
  289.  
  290.         if (upper)
  291.         {
  292.             invsf = 0x20 - sfrac;
  293.             invtf = 0x20 - tfrac;
  294.         }
  295.  
  296.         center = (sfrac == 0x10) && (tfrac == 0x10) && m_other_modes->mid_texel;
  297.  
  298.         invsf <<= 3;
  299.         invtf <<= 3;
  300.         sfrac <<= 3;
  301.         tfrac <<= 3;
  302.  
  303.         t0.c = Fetch(sss1, sst1, tilenum);
  304.  
  305.         if (bilerp)
  306.         {
  307.             t1.c = Fetch(sss2, sst1, tilenum);
  308.             t2.c = Fetch(sss1, sst2, tilenum);
  309.             t3.c = Fetch(sss2, sst2, tilenum);
  310.             if (!center)
  311.             {
  312.                 if (upper)
  313.                 {
  314.                     TEX->i.r = t3.i.r + (((invsf * (t2.i.r - t3.i.r)) + (invtf * (t1.i.r - t3.i.r)) + 0x80) >> 8);
  315.                     TEX->i.g = t3.i.g + (((invsf * (t2.i.g - t3.i.g)) + (invtf * (t1.i.g - t3.i.g)) + 0x80) >> 8);
  316.                     TEX->i.b = t3.i.b + (((invsf * (t2.i.b - t3.i.b)) + (invtf * (t1.i.b - t3.i.b)) + 0x80) >> 8);
  317.                     TEX->i.a = t3.i.a + (((invsf * (t2.i.a - t3.i.a)) + (invtf * (t1.i.a - t3.i.a)) + 0x80) >> 8);
  318.                 }
  319.                 else
  320.                 {
  321.                     TEX->i.r = t0.i.r + (((sfrac * (t1.i.r - t0.i.r)) + (tfrac * (t2.i.r - t0.i.r)) + 0x80) >> 8);
  322.                     TEX->i.g = t0.i.g + (((sfrac * (t1.i.g - t0.i.g)) + (tfrac * (t2.i.g - t0.i.g)) + 0x80) >> 8);
  323.                     TEX->i.b = t0.i.b + (((sfrac * (t1.i.b - t0.i.b)) + (tfrac * (t2.i.b - t0.i.b)) + 0x80) >> 8);
  324.                     TEX->i.a = t0.i.a + (((sfrac * (t1.i.a - t0.i.a)) + (tfrac * (t2.i.a - t0.i.a)) + 0x80) >> 8);
  325.                 }
  326.                 TEX->i.r &= 0x1ff;
  327.                 TEX->i.g &= 0x1ff;
  328.                 TEX->i.b &= 0x1ff;
  329.                 TEX->i.a &= 0x1ff;
  330.             }
  331.             else//tf.c,24
  332.             {
  333.                 TEX->i.r = (t0.i.r + t1.i.r + t2.i.r + t3.i.r) >> 2;
  334.                 TEX->i.g = (t0.i.g + t1.i.g + t2.i.g + t3.i.g) >> 2;
  335.                 TEX->i.b = (t0.i.b + t1.i.b + t2.i.b + t3.i.b) >> 2;
  336.                 TEX->i.a = (t0.i.a + t1.i.a + t2.i.a + t3.i.a) >> 2;
  337.             }
  338.         }
  339.         else
  340.         {
  341.             INT32 newk0 = SIGN9(m_rdp->GetK0());
  342.             INT32 newk1 = SIGN9(m_rdp->GetK1());
  343.             INT32 newk2 = SIGN9(m_rdp->GetK2());
  344.             INT32 newk3 = SIGN9(m_rdp->GetK3());
  345.             INT32 invk0 = ~newk0;
  346.             INT32 invk1 = ~newk1;
  347.             INT32 invk2 = ~newk2;
  348.             INT32 invk3 = ~newk3;
  349.             if (convert)
  350.             {
  351.                 t0 = *prev;
  352.             }
  353.             t0.i.r = SIGN9(t0.i.r); t0.i.g = SIGN9(t0.i.g); t0.i.b = SIGN9(t0.i.b);
  354.             TEX->i.r = t0.i.b + (((newk0 - invk0) * t0.i.g + 0x80) >> 8);
  355.             TEX->i.g = t0.i.b + (((newk1 - invk1) * t0.i.r + (newk2 - invk2) * t0.i.g + 0x80) >> 8);
  356.             TEX->i.b = t0.i.b + (((newk3 - invk3) * t0.i.r + 0x80) >> 8);
  357.             TEX->i.a = t0.i.b;
  358.             TEX->i.r &= 0x1ff;
  359.             TEX->i.g &= 0x1ff;
  360.             TEX->i.b &= 0x1ff;
  361.             TEX->i.a &= 0x1ff;
  362.         }
  363.     }
  364.     else
  365.     {
  366.         INT32 sss1 = SSS;
  367.         INT32 sst1 = SST;
  368.  
  369.         INT32 maxs;
  370.         INT32 maxt;
  371.  
  372.         ShiftCycle(&sss1, &sst1, &maxs, &maxt, tilenum);
  373.         sss1 = TRELATIVE(sss1, tile[tilenum].sl);
  374.         sst1 = TRELATIVE(sst1, tile[tilenum].tl);
  375.  
  376.         ClampCycleLight(&sss1, &sst1, maxs, maxt, tilenum);
  377.  
  378.         Mask(&sss1, &sst1, tilenum);
  379.  
  380.         t0.c = Fetch(sss1, sst1, tilenum);
  381.         if (bilerp)
  382.         {
  383.             *TEX = t0;
  384.         }
  385.         else
  386.         {
  387.             INT32 newk0 = SIGN9(m_rdp->GetK0());
  388.             INT32 newk1 = SIGN9(m_rdp->GetK1());
  389.             INT32 newk2 = SIGN9(m_rdp->GetK2());
  390.             INT32 newk3 = SIGN9(m_rdp->GetK3());
  391.             INT32 invk0 = ~newk0;
  392.             INT32 invk1 = ~newk1;
  393.             INT32 invk2 = ~newk2;
  394.             INT32 invk3 = ~newk3;
  395.             if (convert)
  396.             {
  397.                 t0 = *prev;
  398.             }
  399.             t0.i.r = SIGN9(t0.i.r);
  400.             t0.i.g = SIGN9(t0.i.g);
  401.             t0.i.b = SIGN9(t0.i.b);
  402.             TEX->i.r = t0.i.b + (((newk0 - invk0) * t0.i.g + 0x80) >> 8);
  403.             TEX->i.g = t0.i.b + (((newk1 - invk1) * t0.i.r + (newk2 - invk2) * t0.i.g + 0x80) >> 8);
  404.             TEX->i.b = t0.i.b + (((newk3 - invk3) * t0.i.r + 0x80) >> 8);
  405.             TEX->i.a = t0.i.b;
  406.             TEX->i.r &= 0x1ff;
  407.             TEX->i.g &= 0x1ff;
  408.             TEX->i.b &= 0x1ff;
  409.             TEX->i.a &= 0x1ff;
  410.         }
  411.     }
  412. }
  413.  
  414. void TexturePipe::Copy(Color* TEX, INT32 SSS, INT32 SST, UINT32 tilenum)
  415. {
  416.     Tile* tile = m_rdp->GetTiles();
  417.     INT32 sss1 = SSS;
  418.     INT32 sst1 = SST;
  419.     ShiftCopy(&sss1, &sst1, tilenum);
  420.     sss1 = TRELATIVE(sss1, tile[tilenum].sl);
  421.     sst1 = TRELATIVE(sst1, tile[tilenum].tl);
  422.     sss1 = (SIGN17(sss1) >> 5) & 0x1fff;
  423.     sst1 = (SIGN17(sst1) >> 5) & 0x1fff;
  424.     Mask(&sss1, &sst1, tilenum);
  425.     TEX->c = Fetch(sss1, sst1, tilenum);
  426. }
  427.  
  428. void TexturePipe::LOD1Cycle(INT32* sss, INT32* sst, INT32 s, INT32 t, INT32 w, INT32 dsinc, INT32 dtinc, INT32 dwinc)
  429. {
  430.     INT32 nextsw = (w + dwinc) >> 16;
  431.     INT32 nexts = (s + dsinc) >> 16;
  432.     INT32 nextt = (t + dtinc) >> 16;
  433.  
  434.     if (m_other_modes->persp_tex_en)
  435.     {
  436.         m_rdp->TCDiv(nexts, nextt, nextsw, &nexts, &nextt);
  437.     }
  438.     else
  439.     {
  440.         m_rdp->TCDivNoPersp(nexts, nextt, nextsw, &nexts, &nextt);
  441.     }
  442.  
  443.     m_start_span = false;
  444.     m_precomp_s = nexts;
  445.     m_precomp_t = nextt;
  446.  
  447.     int tempanded;
  448.     if (*sss & 0x40000)
  449.     {
  450.         *sss = 0x7fff;
  451.     }
  452.     else if (*sss & 0x20000)
  453.     {
  454.         *sss = 0x8000;
  455.     }
  456.     else
  457.     {
  458.         tempanded = *sss & 0x18000;
  459.         if (tempanded == 0x8000)
  460.         {
  461.             *sss = 0x7fff;
  462.         }
  463.         else if (tempanded == 0x10000)
  464.         {
  465.             *sss = 0x8000;
  466.         }
  467.         else
  468.         {
  469.             *sss &= 0xffff;
  470.         }
  471.     }
  472.  
  473.     if (*sst & 0x40000)
  474.     {
  475.         *sst = 0x7fff;
  476.     }
  477.     else if (*sst & 0x20000)
  478.     {
  479.         *sst = 0x8000;
  480.     }
  481.     else
  482.     {
  483.         tempanded = *sst & 0x18000;
  484.         if (tempanded == 0x8000)
  485.         {
  486.             *sst = 0x7fff;
  487.         }
  488.         else if (tempanded == 0x10000)
  489.         {
  490.             *sst = 0x8000;
  491.         }
  492.         else
  493.         {
  494.             *sst &= 0xffff;
  495.         }
  496.     }
  497. }
  498.  
  499. void TexturePipe::LOD2Cycle(INT32* sss, INT32* sst, INT32 s, INT32 t, INT32 w, INT32 dsinc, INT32 dtinc, INT32 dwinc, INT32 prim_tile, INT32* t1, INT32* t2)
  500. {
  501.     INT32 nextsw = (w + dwinc) >> 16;
  502.     INT32 nexts = (s + dsinc) >> 16;
  503.     INT32 nextt = (t + dtinc) >> 16;
  504.  
  505.     if (m_other_modes->persp_tex_en)
  506.     {
  507.         m_rdp->TCDiv(nexts, nextt, nextsw, &nexts, &nextt);
  508.     }
  509.     else
  510.     {
  511.         m_rdp->TCDivNoPersp(nexts, nextt, nextsw, &nexts, &nextt);
  512.     }
  513.  
  514.     m_start_span = false;
  515.     m_precomp_s = nexts;
  516.     m_precomp_t = nextt;
  517.  
  518.     INT32 lodclamp = (((*sst & 0x60000) > 0) | ((nextt & 0x60000) > 0)) || (((*sss & 0x60000) > 0) | ((nexts & 0x60000) > 0));
  519.  
  520.     INT32 horstep = SIGN17(nexts & 0x1ffff) - SIGN17(*sss & 0x1ffff);
  521.     INT32 vertstep = SIGN17(nextt & 0x1ffff) - SIGN17(*sst & 0x1ffff);
  522.     if (horstep & 0x20000)
  523.     {
  524.         horstep = ~horstep & 0x1ffff;
  525.     }
  526.     if (vertstep & 0x20000)
  527.     {
  528.         vertstep = ~vertstep & 0x1ffff;
  529.     }
  530.  
  531.     INT32 lod = (horstep >= vertstep) ? horstep : vertstep;
  532.  
  533.     INT32 temp_anded;
  534.  
  535.     if (*sss & 0x40000)
  536.     {
  537.         *sss = 0x7fff;
  538.     }
  539.     else if (*sss & 0x20000)
  540.     {
  541.         *sss = 0x8000;
  542.     }
  543.     else
  544.     {
  545.         temp_anded = *sss & 0x18000;
  546.         if (temp_anded == 0x8000)
  547.         {
  548.             *sss = 0x7fff;
  549.         }
  550.         else if (temp_anded == 0x10000)
  551.         {
  552.             *sss = 0x8000;
  553.         }
  554.         else
  555.         {
  556.             *sss &= 0xffff;
  557.         }
  558.     }
  559.  
  560.     if (*sst & 0x40000)
  561.     {
  562.         *sst = 0x7fff;
  563.     }
  564.     else if (*sst & 0x20000)
  565.     {
  566.         *sst = 0x8000;
  567.     }
  568.     else
  569.     {
  570.         temp_anded = *sst & 0x18000;
  571.         if (temp_anded == 0x8000)
  572.         {
  573.             *sst = 0x7fff;
  574.         }
  575.         else if (temp_anded == 0x10000)
  576.         {
  577.             *sst = 0x8000;
  578.         }
  579.         else
  580.         {
  581.             *sst &= 0xffff;
  582.         }
  583.     }
  584.  
  585.     if ((lod & 0x4000) || lodclamp)
  586.     {
  587.         lod = 0x7fff;
  588.     }
  589.     else if (lod < m_misc_state->m_min_level)
  590.     {
  591.         lod = m_misc_state->m_min_level;
  592.     }
  593.  
  594.     bool magnify = (lod < 32);
  595.     INT32 l_tile = m_rdp->GetLog2((lod >> 5) & 0xff);
  596.     bool distant = ((lod & 0x6000) || (l_tile >= m_misc_state->m_max_level));
  597.  
  598.     m_rdp->SetLODFrac(((lod << 3) >> l_tile) & 0xff);
  599.  
  600.     if(!m_other_modes->sharpen_tex_en && !m_other_modes->detail_tex_en)
  601.     {
  602.         if (distant)
  603.         {
  604.             m_rdp->SetLODFrac(0xff);
  605.         }
  606.         else if (magnify)
  607.         {
  608.             m_rdp->SetLODFrac(0);
  609.         }
  610.     }
  611.  
  612.     if(m_other_modes->sharpen_tex_en && magnify)
  613.     {
  614.         m_rdp->SetLODFrac(m_rdp->GetLODFrac() | 0x100);
  615.     }
  616.  
  617.     if (m_other_modes->tex_lod_en)
  618.     {
  619.         if (distant)
  620.         {
  621.             l_tile = m_misc_state->m_max_level;
  622.         }
  623.         if (!m_other_modes->detail_tex_en)
  624.         {
  625.             *t1 = (prim_tile + l_tile) & 7;
  626.             if (!(distant || (!m_other_modes->sharpen_tex_en && magnify)))
  627.             {
  628.                 *t2 = (*t1 + 1) & 7;
  629.             }
  630.             else
  631.             {
  632.                 *t2 = *t1; // World Driver Championship, Stunt Race 64, Beetle Adventure Racing
  633.             }
  634.         }
  635.         else // Beetle Adventure Racing, World Driver Championship (ingame_, NFL Blitz 2001, Pilotwings
  636.         {
  637.             if (!magnify)
  638.             {
  639.                 *t1 = (prim_tile + l_tile + 1);
  640.             }
  641.             else
  642.             {
  643.                 *t1 = (prim_tile + l_tile);
  644.             }
  645.             *t1 &= 7;
  646.             if (!distant && !magnify)
  647.             {
  648.                 *t2 = (prim_tile + l_tile + 2) & 7;
  649.             }
  650.             else
  651.             {
  652.                 *t2 = (prim_tile + l_tile + 1) & 7;
  653.             }
  654.         }
  655.     }
  656. }
  657.  
  658. void TexturePipe::LOD2CycleLimited(INT32* sss, INT32* sst, INT32 s, INT32 t, INT32 w, INT32 dsinc, INT32 dtinc, INT32 dwinc, INT32 prim_tile, INT32* t1)
  659. {
  660.     INT32 nextsw = (w + dwinc) >> 16;
  661.     INT32 nexts = (s + dsinc) >> 16;
  662.     INT32 nextt = (t + dtinc) >> 16;
  663.  
  664.     if (m_other_modes->persp_tex_en)
  665.     {
  666.         m_rdp->TCDiv(nexts, nextt, nextsw, &nexts, &nextt);
  667.     }
  668.     else
  669.     {
  670.         m_rdp->TCDivNoPersp(nexts, nextt, nextsw, &nexts, &nextt);
  671.     }
  672.  
  673.     INT32 lodclamp = (((*sst & 0x60000) > 0) | ((nextt & 0x60000) > 0)) || (((*sss & 0x60000) > 0) | ((nexts & 0x60000) > 0));
  674.  
  675.     INT32 horstep = SIGN17(nexts & 0x1ffff) - SIGN17(*sss & 0x1ffff);
  676.     INT32 vertstep = SIGN17(nextt & 0x1ffff) - SIGN17(*sst & 0x1ffff);
  677.     if (horstep & 0x20000)
  678.     {
  679.         horstep = ~horstep & 0x1ffff;
  680.     }
  681.     if (vertstep & 0x20000)
  682.     {
  683.         vertstep = ~vertstep & 0x1ffff;
  684.     }
  685.  
  686.     INT32 lod = (horstep >= vertstep) ? horstep : vertstep;
  687.  
  688.     INT32 tempanded;
  689.     if (*sss & 0x40000)
  690.     {
  691.         *sss = 0x7fff;
  692.     }
  693.     else if (*sss & 0x20000)
  694.     {
  695.         *sss = 0x8000;
  696.     }
  697.     else
  698.     {
  699.         tempanded = *sss & 0x18000;
  700.         if (tempanded == 0x8000)
  701.         {
  702.             *sss = 0x7fff;
  703.         }
  704.         else if (tempanded == 0x10000)
  705.         {
  706.             *sss = 0x8000;
  707.         }
  708.         else
  709.         {
  710.             *sss &= 0xffff;
  711.         }
  712.     }
  713.  
  714.     if (*sst & 0x40000)
  715.     {
  716.         *sst = 0x7fff;
  717.     }
  718.     else if (*sst & 0x20000)
  719.     {
  720.         *sst = 0x8000;
  721.     }
  722.     else
  723.     {
  724.         tempanded = *sst & 0x18000;
  725.         if (tempanded == 0x8000)
  726.         {
  727.             *sst = 0x7fff;
  728.         }
  729.         else if (tempanded == 0x10000)
  730.         {
  731.             *sst = 0x8000;
  732.         }
  733.         else
  734.         {
  735.             *sst &= 0xffff;
  736.         }
  737.     }
  738.  
  739.     if ((lod & 0x4000) || lodclamp)
  740.     {
  741.         lod = 0x7fff;
  742.     }
  743.     else if (lod < m_misc_state->m_min_level)
  744.     {
  745.         lod = m_misc_state->m_min_level;
  746.     }
  747.  
  748.     bool magnify = (lod < 32);
  749.     INT32 l_tile = m_rdp->GetLog2((lod >> 5) & 0xff);
  750.     bool distant = (lod & 0x6000) || (l_tile >= m_misc_state->m_max_level);
  751.  
  752.     if (m_other_modes->tex_lod_en)
  753.     {
  754.         if (distant)
  755.         {
  756.             l_tile = m_misc_state->m_max_level;
  757.         }
  758.         if (!m_other_modes->detail_tex_en)
  759.         {
  760.             *t1 = (prim_tile + l_tile) & 7;
  761.         }
  762.         else
  763.         {
  764.             if (!magnify)
  765.             {
  766.                 *t1 = (prim_tile + l_tile + 1);
  767.             }
  768.             else
  769.             {
  770.                 *t1 = (prim_tile + l_tile);
  771.             }
  772.             *t1 &= 7;
  773.         }
  774.     }
  775. }
  776.  
  777. void TexturePipe::CalculateClampDiffs(UINT32 prim_tile)
  778. {
  779.     Tile* tile = m_rdp->GetTiles();
  780.     if (m_other_modes->cycle_type == CYCLE_TYPE_2)
  781.     {
  782.         if (m_other_modes->tex_lod_en)
  783.         {
  784.             int start = 0;
  785.             int end = 7;
  786.             for (; start <= end; start++)
  787.             {
  788.                 m_clamp_s_diff[start] = (tile[start].sh >> 2) - (tile[start].sl >> 2);
  789.                 m_clamp_t_diff[start] = (tile[start].th >> 2) - (tile[start].tl >> 2);
  790.             }
  791.         }
  792.         else
  793.         {
  794.             int start = prim_tile;
  795.             int end = (prim_tile + 1) & 7;
  796.             m_clamp_s_diff[start] = (tile[start].sh >> 2) - (tile[start].sl >> 2);
  797.             m_clamp_t_diff[start] = (tile[start].th >> 2) - (tile[start].tl >> 2);
  798.             m_clamp_s_diff[end] = (tile[end].sh >> 2) - (tile[end].sl >> 2);
  799.             m_clamp_t_diff[end] = (tile[end].th >> 2) - (tile[end].tl >> 2);
  800.         }
  801.     }
  802.     else//1-cycle or copy
  803.     {
  804.         m_clamp_s_diff[prim_tile] = (tile[prim_tile].sh >> 2) - (tile[prim_tile].sl >> 2);
  805.         m_clamp_t_diff[prim_tile] = (tile[prim_tile].th >> 2) - (tile[prim_tile].tl >> 2);
  806.     }
  807. }
  808.  
  809. UINT32 TexturePipe::Fetch(INT32 s, INT32 t, INT32 tilenum)
  810. {
  811.     Tile* tile = m_rdp->GetTiles();
  812.     Color color;
  813.     UINT32 tbase = (tile[tilenum].line * t) & 0x1ff;
  814.     UINT32 tformat = tile[tilenum].format;
  815.     UINT32 tsize =  tile[tilenum].size;
  816.     tbase += tile[tilenum].tmem;
  817.     UINT32 tpal = tile[tilenum].palette;
  818.  
  819.     if (tformat == FORMAT_I && tsize > PIXEL_SIZE_8BIT)
  820.     {
  821.         tformat = FORMAT_RGBA; // Used by Supercross 2000 (in-game)
  822.     }
  823.     if (tformat == FORMAT_CI && tsize > PIXEL_SIZE_8BIT)
  824.     {
  825.         tformat = FORMAT_RGBA; // Used by Clay Fighter - Sculptor's Cut
  826.     }
  827.  
  828.     if (tformat == FORMAT_RGBA && tsize < PIXEL_SIZE_16BIT)
  829.     {
  830.         tformat = FORMAT_CI; // Used by Exterem-G2, Madden Football 64, and Rat Attack
  831.     }
  832.  
  833.     UINT16 *tc16 = m_rdp->GetTMEM16();
  834.  
  835.     switch (tformat)
  836.     {
  837.         case FORMAT_RGBA:
  838.         {
  839.             switch (tsize)
  840.             {
  841.                 case PIXEL_SIZE_4BIT:
  842.                     break;
  843.                 case PIXEL_SIZE_8BIT:
  844.                     break;
  845.                 case PIXEL_SIZE_16BIT:
  846.                 {
  847.                     int taddr = (tbase << 2) + s;
  848.                     taddr ^= ((t & 1) ? WORD_XOR_DWORD_SWAP : WORD_ADDR_XOR);
  849.                     taddr &= 0x7ff;
  850.  
  851.                     if (!m_other_modes->en_tlut)
  852.                     {
  853.                         UINT16 c = tc16[taddr];
  854.                         color.i.r = GET_HI_RGBA16_TMEM(c);
  855.                         color.i.g = GET_MED_RGBA16_TMEM(c);
  856.                         color.i.b = GET_LOW_RGBA16_TMEM(c);
  857.                         color.i.a = (c & 1) ? 0xff : 0;
  858.                     }
  859.                     else
  860.                     {
  861.                         UINT16 c = tc16[taddr];
  862.                         c = m_rdp->GetTLUT()[(c >> 8) << 2];
  863.                         if (m_other_modes->tlut_type == 0) // Used by Goldeneye 007 (ocean in Frigate)
  864.                         {
  865.                             color.i.r = GET_HI_RGBA16_TMEM(c);
  866.                             color.i.g = GET_MED_RGBA16_TMEM(c);
  867.                             color.i.b = GET_LOW_RGBA16_TMEM(c);
  868.                             color.i.a = (c & 1) ? 0xff : 0;
  869.                         }
  870.                         else // Used by Beetle Adventure Racing (Mount Mayhem level)
  871.                         {
  872.                             color.i.r = color.i.g = color.i.b = (c >> 8) & 0xff;
  873.                             color.i.a = c & 0xff;
  874.                         }
  875.                     }
  876.                     break;
  877.                 }
  878.                 case PIXEL_SIZE_32BIT:
  879.                 {
  880.                     UINT32 *tc = m_rdp->GetTMEM32();
  881.                     int taddr = (tbase << 2) + s;
  882.                     taddr ^= ((t & 1) ? WORD_XOR_DWORD_SWAP : WORD_ADDR_XOR);
  883.  
  884.                     if (!m_other_modes->en_tlut)
  885.                     {
  886.                         taddr &= 0x3ff;
  887.                         UINT32 c = tc16[taddr];
  888.                         color.i.r = (c >> 8) & 0xff;
  889.                         color.i.g = c & 0xff;
  890.                         c = tc16[taddr | 0x400];
  891.                         color.i.b = (c >>  8) & 0xff;
  892.                         color.i.a = c & 0xff;
  893.                     }
  894.                     else // Used by California Speed, attract mode
  895.                     {
  896.                         taddr &= 0x3ff;
  897.                         UINT32 c = tc[taddr];
  898.                         c = m_rdp->GetTLUT()[(c >> 24) << 2];
  899.                         if (m_other_modes->tlut_type == 0)
  900.                         {
  901.                             color.i.r = GET_HI_RGBA16_TMEM(c);
  902.                             color.i.g = GET_MED_RGBA16_TMEM(c);
  903.                             color.i.b = GET_LOW_RGBA16_TMEM(c);
  904.                             color.i.a = (c & 1) ? 0xff : 0;
  905.                         }
  906.                         else
  907.                         {
  908.                             color.i.r = color.i.g = color.i.b = (c >> 8) & 0xff;
  909.                             color.i.a = c & 0xff;
  910.                         }
  911.                     }
  912.  
  913.                     break;
  914.                 }
  915.                 default:
  916.                     fatalerror("FETCH_TEXEL: unknown RGBA texture size %d\n", tsize);
  917.                     break;
  918.             }
  919.             break;
  920.         }
  921.         case FORMAT_YUV: // Used by: Bottom of the 9th, Pokemon Stadium, Ogre Battle, Major League Baseball, Ken Griffey Jr.'s Slugfest, Vigilante 8 Second Offense
  922.         {
  923.             switch(tsize)
  924.             {
  925.             case PIXEL_SIZE_16BIT:
  926.                 {
  927.                     UINT16 *tc = m_rdp->GetTMEM16();
  928.  
  929.                     int taddr = (tbase << 3) + s;
  930.                     int taddrlow = taddr >> 1;
  931.  
  932.                     taddr ^= ((t & 1) ? BYTE_XOR_DWORD_SWAP : BYTE_ADDR_XOR);
  933.                     taddrlow ^= ((t & 1) ? WORD_XOR_DWORD_SWAP : WORD_ADDR_XOR);
  934.  
  935.                     taddr &= 0x7ff;
  936.                     taddrlow &= 0x3ff;
  937.  
  938.                     UINT16 c = tc[taddrlow];
  939.  
  940.                     INT32 y = m_rdp->GetTMEM()[taddr | 0x800];
  941.                     INT32 u = c >> 8;
  942.                     INT32 v = c & 0xff;
  943.  
  944.                     v ^= 0x80; u ^= 0x80;
  945.                     if (v & 0x80)
  946.                     {
  947.                         v |= 0x100;
  948.                     }
  949.                     if (u & 0x80)
  950.                     {
  951.                         u |= 0x100;
  952.                     }
  953.  
  954.                     color.i.r = u;
  955.                     color.i.g = v;
  956.                     color.i.b = y;
  957.                     color.i.a = y;
  958.                     break;
  959.                 }
  960.             default:
  961.                 fatalerror("FETCH_TEXEL: unknown YUV texture size %d\n",tsize);
  962.                 break;
  963.             }
  964.             break;
  965.         }
  966.         case FORMAT_CI:
  967.         {
  968.             switch (tsize)
  969.             {
  970.                 case PIXEL_SIZE_4BIT: // Madden Football 64, Bust-A-Move 2
  971.                 {
  972.                     UINT8 *tc = m_rdp->GetTMEM();
  973.                     int taddr = ((tbase << 4) + s) >> 1;
  974.                     taddr ^= ((t & 1) ? BYTE_XOR_DWORD_SWAP : BYTE_ADDR_XOR);
  975.                     taddr &= 0xfff;
  976.  
  977.                     if (m_other_modes->en_tlut)
  978.                     {
  979.                         taddr &= 0x7ff;
  980.                         UINT8 p = (s & 1) ? (tc[taddr] & 0xf) : (tc[taddr] >> 4);
  981.                         UINT16 c = m_rdp->GetTLUT()[((tpal << 4) | p) << 2];
  982.  
  983.                         if (m_other_modes->tlut_type == 0)
  984.                         {
  985.                             color.i.r = GET_HI_RGBA16_TMEM(c);
  986.                             color.i.g = GET_MED_RGBA16_TMEM(c);
  987.                             color.i.b = GET_LOW_RGBA16_TMEM(c);
  988.                             color.i.a = (c & 1) ? 0xff : 0;
  989.                         }
  990.                         else
  991.                         {
  992.                             color.i.r = color.i.g = color.i.b = (c >> 8) & 0xff;
  993.                             color.i.a = c & 0xff;
  994.                         }
  995.                     }
  996.                     else
  997.                     {
  998.                         UINT8 p = (s & 1) ? (tc[taddr] & 0xf) : (tc[taddr] >> 4);
  999.                         p = (tpal << 4) | p;
  1000.                         color.i.r = color.i.g = color.i.b = color.i.a = p;
  1001.                     }
  1002.  
  1003.                     break;
  1004.                 }
  1005.                 case PIXEL_SIZE_8BIT:
  1006.                 {
  1007.                     UINT8 *tc = m_rdp->GetTMEM();
  1008.                     int taddr = (tbase << 3) + s;
  1009.                     taddr ^= ((t & 1) ? BYTE_XOR_DWORD_SWAP : BYTE_ADDR_XOR);
  1010.                     taddr &= 0xfff;
  1011.  
  1012.                     if (m_other_modes->en_tlut)
  1013.                     {
  1014.                         taddr &= 0x7ff;
  1015.                         UINT8 p = tc[taddr];
  1016.                         UINT16 c = m_rdp->GetTLUT()[p << 2];
  1017.  
  1018.                         if (m_other_modes->tlut_type == 0)
  1019.                         {
  1020.                             color.i.r = GET_HI_RGBA16_TMEM(c);
  1021.                             color.i.g = GET_MED_RGBA16_TMEM(c);
  1022.                             color.i.b = GET_LOW_RGBA16_TMEM(c);
  1023.                             color.i.a = (c & 1) ? 0xff : 0;
  1024.                         }
  1025.                         else
  1026.                         {
  1027.                             color.i.r = color.i.g = color.i.b = (c >> 8) & 0xff;
  1028.                             color.i.a = c & 0xff;
  1029.                         }
  1030.                     }
  1031.                     else
  1032.                     {
  1033.                         UINT8 p = tc[taddr];
  1034.                         color.i.r = p;
  1035.                         color.i.g = p;
  1036.                         color.i.b = p;
  1037.                         color.i.a = p;
  1038.                     }
  1039.                     break;
  1040.                 }
  1041.                 default:
  1042.                     fatalerror("FETCH_TEXEL: unknown CI texture size %d\n", tsize);
  1043.                     break;
  1044.             }
  1045.             break;
  1046.         }
  1047.         case FORMAT_IA:
  1048.         {
  1049.             switch (tsize)
  1050.             {
  1051.                 case PIXEL_SIZE_4BIT:
  1052.                 {
  1053.                     UINT8 *tc = m_rdp->GetTMEM();
  1054.                     int taddr = ((tbase << 4) + s) >> 1;
  1055.                     taddr ^= ((t & 1) ? BYTE_XOR_DWORD_SWAP : BYTE_ADDR_XOR);
  1056.                     taddr &= 0xfff;
  1057.  
  1058.                     if (!m_other_modes->en_tlut)
  1059.                     {
  1060.                         UINT8 p = ((s) & 1) ? (tc[taddr] & 0xf) : (tc[taddr] >> 4);
  1061.                         UINT8 i = p & 0xe;
  1062.                         i = (i << 4) | (i << 1) | (i >> 2);
  1063.                         color.i.r = i;
  1064.                         color.i.g = i;
  1065.                         color.i.b = i;
  1066.                         color.i.a = (p & 0x1) ? 0xff : 0;
  1067.                     }
  1068.                     else
  1069.                     {
  1070.                         taddr &= 0x7ff;
  1071.                         UINT8 p = ((s) & 1) ? (tc[taddr] & 0xf) : (tc[taddr] >> 4);
  1072.                         UINT16 c = m_rdp->GetTLUT()[((tpal << 4) | p) << 2];
  1073.                         if (!m_other_modes->tlut_type)
  1074.                         {
  1075.                             color.i.r = GET_HI_RGBA16_TMEM(c);
  1076.                             color.i.g = GET_MED_RGBA16_TMEM(c);
  1077.                             color.i.b = GET_LOW_RGBA16_TMEM(c);
  1078.                             color.i.a = (c & 1) ? 0xff : 0;
  1079.                         }
  1080.                         else
  1081.                         {
  1082.                             color.i.r = color.i.g = color.i.b = (c >> 8) & 0xff;
  1083.                             color.i.a = c & 0xff;
  1084.                         }
  1085.                     }
  1086.                     break;
  1087.                 }
  1088.                 case PIXEL_SIZE_8BIT:
  1089.                 {
  1090.                     UINT8 *tc = m_rdp->GetTMEM();
  1091.                     int taddr = (tbase << 3) + s;
  1092.                     taddr ^= ((t & 1) ? BYTE_XOR_DWORD_SWAP : BYTE_ADDR_XOR);
  1093.                     taddr &= 0xfff;
  1094.                     if (!m_other_modes->en_tlut)
  1095.                     {
  1096.                         UINT8 p = tc[taddr];
  1097.                         UINT8 i = p & 0xf0;
  1098.                         i |= (i >> 4);
  1099.                         color.i.r = i;
  1100.                         color.i.g = i;
  1101.                         color.i.b = i;
  1102.                         color.i.a = ((p & 0xf) << 4) | (p & 0xf);
  1103.                     }
  1104.                     else
  1105.                     {
  1106.                         UINT8 p = tc[taddr & 0x7ff];
  1107.                         UINT16 c = m_rdp->GetTLUT()[p << 2];
  1108.                         if (!m_other_modes->tlut_type)
  1109.                         {
  1110.                             color.i.r = GET_HI_RGBA16_TMEM(c);
  1111.                             color.i.g = GET_MED_RGBA16_TMEM(c);
  1112.                             color.i.b = GET_LOW_RGBA16_TMEM(c);
  1113.                             color.i.a = (c & 1) ? 0xff : 0;
  1114.                         }
  1115.                         else
  1116.                         {
  1117.                             color.i.r = color.i.g = color.i.b = (c >> 8) & 0xff;
  1118.                             color.i.a = c & 0xff;
  1119.                         }
  1120.                     }
  1121.                     break;
  1122.                 }
  1123.                 case PIXEL_SIZE_16BIT:
  1124.                 {
  1125.                     UINT16 *tc = m_rdp->GetTMEM16();
  1126.                     int taddr = (tbase << 2) + s;
  1127.                     taddr ^= ((t & 1) ? WORD_XOR_DWORD_SWAP : WORD_ADDR_XOR);
  1128.                     taddr &= 0x7ff;
  1129.  
  1130.                     if (!m_other_modes->en_tlut)
  1131.                     {
  1132.                         UINT16 c = tc[taddr];
  1133.                         UINT8 i = (c >> 8);
  1134.                         color.i.r = i;
  1135.                         color.i.g = i;
  1136.                         color.i.b = i;
  1137.                         color.i.a = c & 0xff;
  1138.                     }
  1139.                     else
  1140.                     {
  1141.                         UINT16 c = tc[taddr & 0x3ff];
  1142.                         c = m_rdp->GetTLUT()[(c >> 8) << 2];
  1143.                         if (m_other_modes->tlut_type == 1)
  1144.                         {
  1145.                             color.i.r = c >> 8;
  1146.                             color.i.g = c >> 8;
  1147.                             color.i.b = c >> 8;
  1148.                             color.i.a = c & 0xff;
  1149.                         }
  1150.                         else
  1151.                         {
  1152.                             color.i.r = GET_HI_RGBA16_TMEM(c);
  1153.                             color.i.g = GET_MED_RGBA16_TMEM(c);
  1154.                             color.i.b = GET_LOW_RGBA16_TMEM(c);
  1155.                             color.i.a = (c & 1) ? 0xff : 0;
  1156.                         }
  1157.                     }
  1158.                     break;
  1159.                 }
  1160.                 default:
  1161.                     color.i.r = color.i.g = color.i.b = color.i.a = 0xff;
  1162.                     fatalerror("FETCH_TEXEL: unknown IA texture size %d\n", tsize);
  1163.                     break;
  1164.             }
  1165.             break;
  1166.         }
  1167.         case FORMAT_I:
  1168.         {
  1169.             switch (tsize)
  1170.             {
  1171.                 case PIXEL_SIZE_4BIT:
  1172.                 {
  1173.                     UINT8 *tc = m_rdp->GetTMEM();
  1174.                     int taddr = ((tbase << 4) + s) >> 1;
  1175.                     taddr ^= ((t & 1) ? BYTE_XOR_DWORD_SWAP : BYTE_ADDR_XOR);
  1176.                     taddr &= 0xfff;
  1177.  
  1178.                     if (!m_other_modes->en_tlut)
  1179.                     {
  1180.                         UINT8 byteval = tc[taddr];
  1181.                         UINT8 c = ((s & 1)) ? (byteval & 0xf) : ((byteval >> 4) & 0xf);
  1182.                         c |= (c << 4);
  1183.                         color.i.r = c;
  1184.                         color.i.g = c;
  1185.                         color.i.b = c;
  1186.                         color.i.a = c;
  1187.                     }
  1188.                     else
  1189.                     {
  1190.                         UINT8 byteval = tc[taddr & 0x7ff];
  1191.                         UINT8 c = ((s & 1)) ? (byteval & 0xf) : ((byteval >> 4) & 0xf);
  1192.                         UINT16 k = m_rdp->GetTLUT()[((tpal << 4) | c) << 2];
  1193.                         if (!m_other_modes->tlut_type)
  1194.                         {
  1195.                             color.i.r = GET_HI_RGBA16_TMEM(k);
  1196.                             color.i.g = GET_MED_RGBA16_TMEM(k);
  1197.                             color.i.b = GET_LOW_RGBA16_TMEM(k);
  1198.                             color.i.a = (k & 1) ? 0xff : 0;
  1199.                         }
  1200.                         else
  1201.                         {
  1202.                             color.i.r = color.i.g = color.i.b = (k >> 8) & 0xff;
  1203.                             color.i.a = k & 0xff;
  1204.                         }
  1205.                     }
  1206.                     break;
  1207.                 }
  1208.                 case PIXEL_SIZE_8BIT:
  1209.                 {
  1210.                     UINT8 *tc = m_rdp->GetTMEM();
  1211.                     int taddr = (tbase << 3) + s;
  1212.                     taddr ^= ((t & 1) ? BYTE_XOR_DWORD_SWAP : BYTE_ADDR_XOR);
  1213.                     taddr &= 0xfff;
  1214.  
  1215.                     if (!m_other_modes->en_tlut)
  1216.                     {
  1217.                         UINT8 c = tc[taddr];
  1218.                         color.i.r = c;
  1219.                         color.i.g = c;
  1220.                         color.i.b = c;
  1221.                         color.i.a = c;
  1222.                     }
  1223.                     else
  1224.                     {
  1225.                         UINT8 c = tc[taddr & 0x7ff];
  1226.                         UINT16 k = m_rdp->GetTLUT()[c << 2];
  1227.                         if (!m_other_modes->tlut_type)
  1228.                         {
  1229.                             color.i.r = GET_HI_RGBA16_TMEM(k);
  1230.                             color.i.g = GET_MED_RGBA16_TMEM(k);
  1231.                             color.i.b = GET_LOW_RGBA16_TMEM(k);
  1232.                             color.i.a = (k & 1) ? 0xff : 0;
  1233.                         }
  1234.                         else
  1235.                         {
  1236.                             color.i.r = color.i.g = color.i.b = (k >> 8) & 0xff;
  1237.                             color.i.a = k & 0xff;
  1238.                         }
  1239.                     }
  1240.  
  1241.                     break;
  1242.                 }
  1243.                 default:
  1244.                     fatalerror("FETCH_TEXEL: unknown I texture size %d\n", tsize);
  1245.                     break;
  1246.             }
  1247.             break;
  1248.         }
  1249.         default:
  1250.         {
  1251.             fatalerror("FETCH_TEXEL: unknown texture format %d, tilenum %d\n", tformat, tilenum);
  1252.             break;
  1253.         }
  1254.     }
  1255.  
  1256.     return color.c;
  1257. }
  1258.  
  1259. } // namespace RDP
  1260.  
  1261. } // namespace N64
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!