GPU.c

int RGBCOLOR(int r, int g, int b)
{
  return ((r / 8) << 11) | ((g / 4) << 5) | (b / 8);
}

void putImageData(const void* datar, int x, int y, int width, int height) {
   color_t*data = (color_t*) datar;
   color_t* VRAM = (color_t*)0xA8000000;
   VRAM += LCD_WIDTH_PX*y + x;
   for(int j=y; j<y+height; j++) {
      for(int i=x; i<x+width; i++) {
         *(VRAM++) = *(data++);
     }
     VRAM += LCD_WIDTH_PX-width;
   }
}

 void GPU_reset() {
    for(int i=0; i<8192; i++) {
      GPU_vram[i] = 0;
    }
    for(int i=0; i<160; i++) {
      GPU_oam[i] = 0;
    }
    for(int i=0; i<4; i++) {
      GPU_palettebg[i] = 255;
      GPU_paletteobj0[i] = 255;
      GPU_paletteobj1[i] = 255;
    }
    for(int i=0;i<512;i++)
    {
      for(int j=0;j<8;j++)
      {
        for(int k=0;k<8;k++)
        {
          GPU_tilemap[i][j][k] = 0;
        }
      }
    }
    //GPU_scrn = {'width':160, 'height':144, 'data':new Array(160*144*4)};
    GPU_scrnwidth = 160;
    GPU_scrnheight = 144;

    for(int i=0; i<(160 * 144); i++)
        GPU_scrndata[i]=RGBCOLOR(255, 255, 255);
    putImageData(GPU_scrndata, 0, 0, GPU_scrnwidth, GPU_scrnheight);

    GPU_curline=0;
    GPU_curscan=0;
    GPU_linemode=2;
    GPU_modeclocks=0;
    GPU_yscrl=0;
    GPU_xscrl=0;
    GPU_raster=0;
    GPU_ints = 0;

    GPU_lcdon = 0;
    GPU_bgon = 0;
    GPU_objon = 0;
    GPU_winon = 0;

    GPU_objsize = 0;
    for(int i=0; i<160; i++) GPU_scanrow[i] = 0;

    for(int i=0; i<40; i++)
    {
      //GPU_objdata[i] = {'y':-16, 'x':-8, 'tile':0, 'palette':0, 'yflip':0, 'xflip':0, 'prio':0, 'num':i};
      GPU_objdatax[i] = -8;
      GPU_objdatay[i] = -16;
      GPU_objdatatile[i] = 0;
      GPU_objdatapalette[i] = 0;
      GPU_objdatayflip[i] = 0;
      GPU_objdataxflip[i] = 0;
      GPU_objdataprio[i] = 0;
      GPU_objdatanum[i] = i;
    }

    // Set to values expected by BIOS, to start
    GPU_bgtilebase = 0x0000;
    GPU_bgmapbase = 0x1800;
    GPU_wintilebase = 0x1800;
};

void GPU_checkline() {
    GPU_modeclocks += r_m;
    switch(GPU_linemode)
    {
      // In hblank
      case 0:
        if(GPU_modeclocks >= 51)
        {
          // End of hblank for last scanline; render screen
          if(GPU_curline == 143)
          {
            GPU_linemode = 1;
            putImageData(GPU_scrndata, 0, 0, GPU_scrnwidth, GPU_scrnheight);
            MMU_if |= 1;
          }
          else
          {
            GPU_linemode = 2;
          }
          GPU_curline++;
          GPU_curscan += 640;
          GPU_modeclocks=0;
        }
        break;

      // In vblank
      case 1:
        if(GPU_modeclocks >= 114)
        {
          GPU_modeclocks = 0;
          GPU_curline++;
          if(GPU_curline > 153)
          {
            GPU_curline = 0;
        GPU_curscan = 0;
            GPU_linemode = 2;
          }
        }
        break;

      // In OAM-read mode
      case 2:
        if(GPU_modeclocks >= 20)
        {
          GPU_modeclocks = 0;
          GPU_linemode = 3;
        }
        break;

      // In VRAM-read mode
      case 3:
        // Render scanline at end of allotted time
        if(GPU_modeclocks >= 43)
        {
          GPU_modeclocks = 0;
          GPU_linemode = 0;
          if(GPU_lcdon)
          {
            if(GPU_bgon)
            {
              int linebase = GPU_curscan;
              int mapbase = GPU_bgmapbase + ((((GPU_curline+GPU_yscrl)&255)>>3)<<5);
              int y = (GPU_curline+GPU_yscrl)&7;
              int x = GPU_xscrl&7;
              int t = (GPU_xscrl>>3)&31;
              int pixel;
              int w=160;

              if(GPU_bgtilebase)
              {
            int tile = GPU_vram[mapbase+t];
        if(tile<128) tile=256+tile;
                int *tilerow = GPU_tilemap[tile][y];
                do
                {
          GPU_scanrow[160-x] = tilerow[x];
                  GPU_scrndata[linebase+3] = GPU_palettebg[tilerow[x]];
                  x++;
                  if(x==8) { t=(t+1)&31; x=0; tile=GPU_vram[mapbase+t]; if(tile<128) tile=256+tile; tilerow = GPU_tilemap[tile][y]; }
                  linebase+=4;
                } while(--w);
              }
              else
              {
                int *tilerow=GPU_tilemap[GPU_vram[mapbase+t]][y];
                do
                {
          GPU_scanrow[160-x] = tilerow[x];
                  GPU_scrndata[linebase+3] = GPU_palettebg[tilerow[x]];
                  x++;
                  if(x==8) { t=(t+1)&31; x=0; tilerow=GPU_tilemap[GPU_vram[mapbase+t]][y]; }
                  linebase+=4;
                } while(--w);
          }
            }
            if(GPU_objon)
            {
              int cnt = 0;
              if(GPU_objsize)
              {
                for(int i=0; i<40; i++)
                {
                }
              }
              else
              {
                int *tilerow;
                int objx;
                int objy;
                int objtile;
                int objpalette;
                int objyflip;
                int objxflip;
                int objprio;
                int *pal;
                int pixel;
                int x;
                int linebase = GPU_curscan;
                for(int i=0; i<40; i++)
                {
                  objx = GPU_objdatax[i];
                  objy = GPU_objdatay[i];
                  objtile = GPU_objdatatile[i];
                  objpalette = GPU_objdatapalette[i];
                  objyflip = GPU_objdatayflip[i];
                  objxflip = GPU_objdataxflip[i];
                  objprio = GPU_objdataprio[i];

                  if(objy <= GPU_curline && (objy+8) > GPU_curline)
                  {
                    if(objyflip)
                      tilerow = GPU_tilemap[objtile][7-(GPU_curline-objy)];
                    else
                      tilerow = GPU_tilemap[objtile][GPU_curline-objy];

                    if(objpalette) pal=GPU_paletteobj1;
                    else pal=GPU_paletteobj0;

                    linebase = (GPU_curline*160+objx)*4;
                    if(objxflip)
                    {
                      for(x=0; x<8; x++)
                      {
                        if(objx+x >=0 && objx+x < 160)
                        {
                          if(tilerow[7-x] && (objprio || !GPU_scanrow[x]))
                          {
                            GPU_scrndata[linebase+3] = pal[tilerow[7-x]];
                          }
                        }
                        linebase+=4;
                      }
                    }
                    else
                    {
                      for(x=0; x<8; x++)
                      {
                        if(objx+x >=0 && objx+x < 160)
                        {
                          if(tilerow[x] && (objprio || !GPU_scanrow[x]))
                          {
                            GPU_scrndata[linebase+3] = pal[tilerow[x]];
                          }
                        }
                        linebase+=4;
                      }
                    }
                    cnt++; if(cnt>10) break;
                  }
                }
              }
            }
          }
        }
        break;
    }
};

void GPU_updatetile(int addr, int val) {
    int saddr = addr;
    if(addr&1) { saddr--; addr--; }
    int tile = (addr>>4)&511;
    int y = (addr>>1)&7;
    int sx;
    for(int x=0;x<8;x++)
    {
      sx=1<<(7-x);
      GPU_tilemap[tile][y][x] = ((GPU_vram[saddr]&sx)?1:0) | ((GPU_vram[saddr+1]&sx)?2:0);
    }
};

 void GPU_updateoam(int addr, int val) {
    addr-=0xFE00;
    int obj=addr>>2;
    if(obj<40)
    {
      switch(addr&3)
      {
        case 0: GPU_objdatay[obj]=val-16; break;
        case 1: GPU_objdatax[obj]=val-8; break;
        case 2:
          if(GPU_objsize) GPU_objdatatile[obj] = (val&0xFE);
          else GPU_objdatatile[obj] = val;
          break;
        case 3:
          GPU_objdatapalette[obj] = (val&0x10)?1:0;
          GPU_objdataxflip[obj] = (val&0x20)?1:0;
          GPU_objdatayflip[obj] = (val&0x40)?1:0;
          GPU_objdataprio[obj] = (val&0x80)?1:0;
          break;
     }
    }
};

 int GPU_rb(int addr) {
    int gaddr = addr-0xFF40;
    switch(gaddr)
    {
      case 0:
        return (GPU_lcdon?0x80:0)|
               ((GPU_bgtilebase==0x0000)?0x10:0)|
               ((GPU_bgmapbase==0x1C00)?0x08:0)|
               (GPU_objsize?0x04:0)|
               (GPU_objon?0x02:0)|
               (GPU_bgon?0x01:0);

      case 1:
        return (GPU_curline==GPU_raster?4:0)|GPU_linemode;

      case 2:
        return GPU_yscrl;

      case 3:
        return GPU_xscrl;

      case 4:
        return GPU_curline;

      case 5:
        return GPU_raster;

      default:
        return GPU_reg[gaddr];
    }
  };

void GPU_wb(int addr, int val) {
    int gaddr = addr-0xFF40;
    GPU_reg[gaddr] = val;
    switch(gaddr)
    {
      case 0:
        GPU_lcdon = (val&0x80)?1:0;
        GPU_bgtilebase = (val&0x10)?0x0000:0x0800;
        GPU_bgmapbase = (val&0x08)?0x1C00:0x1800;
        GPU_objsize = (val&0x04)?1:0;
        GPU_objon = (val&0x02)?1:0;
        GPU_bgon = (val&0x01)?1:0;
        break;

      case 2:
        GPU_yscrl = val;
        break;

      case 3:
        GPU_xscrl = val;
        break;

      case 5:
        GPU_raster = val;

      // OAM DMA
      case 6: ;
        int v;
        for(int i=0; i<160; i++)
        {
          v = MMU_rb((val<<8)+i);
          GPU_oam[i] = v;
          GPU_updateoam(0xFE00+i, v);
        }
        break;

      // BG palette mapping
      case 7:
        for(int i=0;i<4;i++)
        {
          switch((val>>(i*2))&3)
          {
            case 0: GPU_palettebg[i] = 255; break;
            case 1: GPU_palettebg[i] = 192; break;
            case 2: GPU_palettebg[i] = 96; break;
            case 3: GPU_palettebg[i] = 0; break;
          }
        }
        break;

      // OBJ0 palette mapping
      case 8:
        for(int i=0;i<4;i++)
        {
          switch((val>>(i*2))&3)
          {
            case 0: GPU_paletteobj0[i] = 255; break;
            case 1: GPU_paletteobj0[i] = 192; break;
            case 2: GPU_paletteobj0[i] = 96; break;
            case 3: GPU_paletteobj0[i] = 0; break;
          }
        }
        break;

      // OBJ1 palette mapping
      case 9:
        for(int i=0;i<4;i++)
        {
          switch((val>>(i*2))&3)
          {
            case 0: GPU_paletteobj1[i] = 255; break;
            case 1: GPU_paletteobj1[i] = 192; break;
            case 2: GPU_paletteobj1[i] = 96; break;
            case 3: GPU_paletteobj1[i] = 0; break;
          }
        }
        break;
    }
};