Return to sprite.cpp CVS log

Up to [Isaki's NoNo m68k/m88k emulator] / nono / vm

Annotation of nono/vm/sprite.cpp, revision 1.1

1.1     ! root        1: //
        !             2: // nono
        !             3: // Copyright (C) 2017 [email protected]
        !             4: //
        !             5: 
        !             6: #include "sprite.h"
        !             7: #include <sys/time.h>
        !             8: 
        !             9: SpriteDevice::SpriteDevice()
        !            10: {
        !            11:        logname = "sprite";
        !            12:        devname = "Sprite";
        !            13:        devaddr = baseaddr;
        !            14:        devlen  = 0x010000;
        !            15: 
        !            16:        mem = (uint8 *)malloc(4 * 8192);
        !            17: }
        !            18: 
        !            19: SpriteDevice::~SpriteDevice()
        !            20: {
        !            21:        free(mem);
        !            22: }
        !            23: 
        !            24: uint64
        !            25: SpriteDevice::Read8(uint32 addr)
        !            26: {
        !            27:        if (addr >= 0xeb8000) {
        !            28:                return mem[HB(addr - 0xeb8000)];
        !            29:        }
        !            30:        PANIC("not impl");
        !            31: }
        !            32: 
        !            33: uint64
        !            34: SpriteDevice::Read16(uint32 addr)
        !            35: {
        !            36:        if (addr >= 0xeb8000) {
        !            37:                return *(uint16 *)&mem[addr - 0xeb8000];
        !            38:        }
        !            39:        if (addr < 0xeb0400) {
        !            40:                int n = (addr - 0xeb0000) / 8;
        !            41:                switch (addr % 8) {
        !            42:                 case 0:
        !            43:                        return reg.sprite[n].xpos;
        !            44:                 case 2:
        !            45:                        return reg.sprite[n].ypos;
        !            46:                 case 4:
        !            47:                        return reg.sprite[n].col;
        !            48:                 case 6:
        !            49:                        return reg.sprite[n].prw;
        !            50:                }
        !            51:        }
        !            52:        if (0xeb0800 <= addr && addr < 0xeb0812) {
        !            53:                switch (addr) {
        !            54:                 case 0xeb0800:
        !            55:                        return reg.bg0x;
        !            56:                 case 0xeb0802:
        !            57:                        return reg.bg0y;
        !            58:                 case 0xeb0804:
        !            59:                        return reg.bg1x;
        !            60:                 case 0xeb0806:
        !            61:                        return reg.bg1y;
        !            62:                 case 0xeb0808:
        !            63:                        return reg.bgctrl;
        !            64:                 case 0xeb080a:
        !            65:                        return reg.htotal;
        !            66:                 case 0xeb080c:
        !            67:                        return reg.hdisp;
        !            68:                 case 0xeb080e:
        !            69:                        return reg.vdisp;
        !            70:                 case 0xeb0810:
        !            71:                        return reg.res;
        !            72:                }
        !            73:        }
        !            74: 
        !            75:        return (uint64)-1;
        !            76: }
        !            77: 
        !            78: uint64
        !            79: SpriteDevice::Write8(uint32 addr, uint32 data)
        !            80: {
        !            81:        if (addr >= 0xeb8000) {
        !            82:                mem[HB(addr - 0xeb8000)] = data;
        !            83:                return 0;
        !            84:        }
        !            85:        PANIC("not impl");
        !            86: }
        !            87: 
        !            88: uint64
        !            89: SpriteDevice::Write16(uint32 addr, uint32 data)
        !            90: {
        !            91:        putlog(2, "Write16 $%06x <- $%04x", addr, data);
        !            92:        if (addr >= 0xeb8000) {
        !            93:                *(uint16 *)&mem[addr - 0xeb8000] = data;
        !            94:                return 0;
        !            95:        }
        !            96:        if (addr < 0xeb0400) {
        !            97:                int n = (addr - 0xeb0000) / 8;
        !            98:                switch (addr % 8) {
        !            99:                 case 0:
        !           100:                        reg.sprite[n].xpos = data & 0x3ff;
        !           101:                        break;
        !           102:                 case 2:
        !           103:                        reg.sprite[n].ypos = data & 0x3ff;
        !           104:                        break;
        !           105:                 case 4:
        !           106:                        reg.sprite[n].col = data & 0xcfff;
        !           107:                        break;
        !           108:                 case 6:
        !           109:                        reg.sprite[n].prw = data & 0x3;
        !           110:                        break;
        !           111:                }
        !           112:                return 0;
        !           113:        }
        !           114:        if (0xeb0800 <= addr && addr < 0xeb0812) {
        !           115:                switch (addr) {
        !           116:                 case 0xeb0800:
        !           117:                        reg.bg0x = data & 0x3ff;
        !           118:                        break;
        !           119:                 case 0xeb0802:
        !           120:                        reg.bg0y = data & 0x3ff;
        !           121:                        break;
        !           122:                 case 0xeb0804:
        !           123:                        reg.bg1x = data & 0x3ff;
        !           124:                        break;
        !           125:                 case 0xeb0806:
        !           126:                        reg.bg1y = data & 0x3ff;
        !           127:                        break;
        !           128:                 case 0xeb0808:
        !           129:                        reg.bgctrl = data & 0x23f;
        !           130:                        break;
        !           131:                 case 0xeb080a:
        !           132:                        reg.htotal = data & 0xff;
        !           133:                        break;
        !           134:                 case 0xeb080c:
        !           135:                        reg.hdisp = data & 0x3f;
        !           136:                        break;
        !           137:                 case 0xeb080e:
        !           138:                        reg.vdisp = data & 0xff;
        !           139:                        break;
        !           140:                 case 0xeb0810:
        !           141:                        reg.res = data & 0x1f;
        !           142:                        break;
        !           143:                }
        !           144:                return 0;
        !           145:        }
        !           146: 
        !           147:        return (uint64)-1;
        !           148: }
        !           149: 
        !           150: uint64
        !           151: SpriteDevice::Peek8(uint32 addr)
        !           152: {
        !           153:        if (addr >= 0xeb8000) {
        !           154:                return mem[HB(addr - 0xeb8000)];
        !           155:        }
        !           156:        if (addr < 0xeb0400) {
        !           157:                int n = (addr - 0xeb0000) / 8;
        !           158:                switch (addr % 8) {
        !           159:                 case 0:
        !           160:                        return reg.sprite[n].xpos;
        !           161:                 case 2:
        !           162:                        return reg.sprite[n].ypos;
        !           163:                 case 4:
        !           164:                        return reg.sprite[n].col;
        !           165:                 case 6:
        !           166:                        return reg.sprite[n].prw;
        !           167:                }
        !           168:        }
        !           169:        if (0xeb0800 <= addr && addr < 0xeb0812) {
        !           170:                switch (addr) {
        !           171:                 case 0xeb0800:
        !           172:                        return reg.bg0x;
        !           173:                 case 0xeb0802:
        !           174:                        return reg.bg0y;
        !           175:                 case 0xeb0804:
        !           176:                        return reg.bg1x;
        !           177:                 case 0xeb0806:
        !           178:                        return reg.bg1y;
        !           179:                 case 0xeb0808:
        !           180:                        return reg.bgctrl;
        !           181:                 case 0xeb080a:
        !           182:                        return reg.htotal;
        !           183:                 case 0xeb080c:
        !           184:                        return reg.hdisp;
        !           185:                 case 0xeb080e:
        !           186:                        return reg.vdisp;
        !           187:                 case 0xeb0810:
        !           188:                        return reg.res;
        !           189:                }
        !           190:        }
        !           191: 
        !           192:        return (uint64)-1;
        !           193: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.