486 lines
14 KiB
D
486 lines
14 KiB
D
/+
|
|
+ video/patterns.d
|
|
+
|
|
+ Copyright: 2007 Gerald Stocker
|
|
+
|
|
+ This file is part of Twoapple.
|
|
+
|
|
+ Twoapple is free software; you can redistribute it and/or modify
|
|
+ it under the terms of the GNU General Public License as published by
|
|
+ the Free Software Foundation; either version 2 of the License, or
|
|
+ (at your option) any later version.
|
|
+
|
|
+ Twoapple is distributed in the hope that it will be useful,
|
|
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
+ GNU General Public License for more details.
|
|
+
|
|
+ You should have received a copy of the GNU General Public License
|
|
+ along with Twoapple; if not, write to the Free Software
|
|
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
+/
|
|
|
|
import video.base;
|
|
import device.base;
|
|
import memory;
|
|
import timer;
|
|
|
|
static this()
|
|
{
|
|
initDoubleBits();
|
|
initReverseBits();
|
|
}
|
|
|
|
private:
|
|
|
|
ubyte[2][128] doubleBits;
|
|
ubyte[128] reverseBits;
|
|
|
|
void initDoubleBits()
|
|
{
|
|
for (int bits = 0; bits < 128; ++bits)
|
|
{
|
|
for (int newBit = 13; newBit >= 0; --newBit)
|
|
{
|
|
int index = 1 - (newBit / 7);
|
|
doubleBits[bits][index] <<= 1;
|
|
if (bits & (1 << (newBit / 2)))
|
|
doubleBits[bits][index] |= 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
void initReverseBits()
|
|
{
|
|
for (int bits = 0; bits < 128; ++bits)
|
|
{
|
|
for (int bitPos = 0; bitPos < 7 ; ++bitPos)
|
|
{
|
|
reverseBits[bits] <<= 1;
|
|
if ((bits & (1 << bitPos)) != 0)
|
|
reverseBits[bits] |= 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
final ubyte INVERSE = 0b01111111;
|
|
|
|
public:
|
|
|
|
class TextPatternGenerator : PatternGenerator
|
|
{
|
|
ubyte[2][8][256] flashOffPatterns;
|
|
ubyte[2][8][256] flashOnPatterns;
|
|
ubyte[2][8][256] flashNullPatterns;
|
|
ubyte[8][256] flashOffPatterns80;
|
|
ubyte[8][256] flashOnPatterns80;
|
|
ubyte[8][256] flashNullPatterns80;
|
|
|
|
ubyte[2][8][256]* patterns;
|
|
ubyte[8][256]* patterns80;
|
|
|
|
bool flash, altCharset;
|
|
|
|
SignalBase signal;
|
|
ScannerBase scanner;
|
|
ubyte delegate() kbdLatch;
|
|
|
|
this()
|
|
{
|
|
patterns = &flashOffPatterns;
|
|
patterns80 = &flashOffPatterns80;
|
|
}
|
|
|
|
bool toggleFlash()
|
|
{
|
|
flash = !flash;
|
|
if (!altCharset)
|
|
{
|
|
if (scanner.getMode() == Mode.TEXT)
|
|
{
|
|
signal.update();
|
|
}
|
|
applyFlash();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void altCharsetChange(bool newState)
|
|
{
|
|
if (altCharset == newState) return;
|
|
if (scanner.getMode() == Mode.TEXT)
|
|
{
|
|
signal.update();
|
|
}
|
|
altCharset = newState;
|
|
if (newState)
|
|
{
|
|
patterns = &flashNullPatterns;
|
|
patterns80 = &flashNullPatterns80;
|
|
}
|
|
else applyFlash();
|
|
}
|
|
|
|
void applyFlash()
|
|
{
|
|
patterns = (flash ? &flashOnPatterns : &flashOffPatterns);
|
|
patterns80 = (flash ? &flashOnPatterns80 : &flashOffPatterns80);
|
|
}
|
|
|
|
void update(ubyte* signal, int scanLine, int startCol, uint len)
|
|
{
|
|
uint screenPos = 0;
|
|
uint dotLine = scanLine % 8;
|
|
uint memByte;
|
|
ubyte* data = scanner.getData(scanLine, startCol + 25);
|
|
|
|
for (uint offset = 0; offset < len; ++offset)
|
|
{
|
|
memByte = data[offset];
|
|
signal[screenPos++] = (*patterns)[memByte][dotLine][0];
|
|
signal[screenPos++] = (*patterns)[memByte][dotLine][1];
|
|
}
|
|
}
|
|
|
|
void update80(ubyte* signal, int scanLine, int startCol, uint len)
|
|
{
|
|
uint screenPos = 0;
|
|
uint dotLine = scanLine % 8;
|
|
ubyte* data = scanner.getData(scanLine, startCol + 25);
|
|
ubyte* auxData = scanner.getData80(scanLine, startCol + 25);
|
|
|
|
for (uint offset = 0; offset < len; ++offset)
|
|
{
|
|
signal[screenPos++] = (*patterns80)[auxData[offset]][dotLine];
|
|
signal[screenPos++] = (*patterns80)[data[offset]][dotLine];
|
|
}
|
|
}
|
|
|
|
void reboot()
|
|
{
|
|
altCharsetChange(false);
|
|
}
|
|
|
|
mixin(EmptyInitSwitches());
|
|
|
|
abstract void init(Timer timer);
|
|
}
|
|
|
|
class TextPatternGenerator_II : TextPatternGenerator
|
|
{
|
|
mixin("static final ubyte[256] charsetUpper_II = "
|
|
~ import("charset_upper_ii"));
|
|
mixin("static final ubyte[256] charsetSymbol_II = "
|
|
~ import("charset_symbol_ii"));
|
|
|
|
void initPatterns()
|
|
{
|
|
ubyte[][] segments = new ubyte[][8];
|
|
segments[0] = segments[2] = segments[4] = segments[6] =
|
|
charsetUpper_II;
|
|
segments[1] = segments[3] = segments[5] = segments[7] =
|
|
charsetSymbol_II;
|
|
|
|
ubyte flashOff, flashOn;
|
|
for (int seg = 0; seg < 8; ++seg)
|
|
{
|
|
foreach(index, pattern; segments[seg])
|
|
{
|
|
uint ascii = (((index / 32) * 4) + (index % 4)) + (seg * 32);
|
|
uint dotLine = (index / 4) % 8;
|
|
switch (seg)
|
|
{
|
|
case 0, 1:
|
|
flashOff = flashOn = (pattern ^ INVERSE);
|
|
break;
|
|
case 2, 3:
|
|
flashOff = pattern;
|
|
flashOn = (pattern ^ INVERSE);
|
|
break;
|
|
default:
|
|
flashOff = flashOn = pattern;
|
|
break;
|
|
}
|
|
flashOffPatterns[ascii][dotLine][0] = doubleBits[flashOff][0];
|
|
flashOffPatterns[ascii][dotLine][1] = doubleBits[flashOff][1];
|
|
flashOnPatterns[ascii][dotLine][0] = doubleBits[flashOn][0];
|
|
flashOnPatterns[ascii][dotLine][1] = doubleBits[flashOn][1];
|
|
}
|
|
}
|
|
}
|
|
|
|
void initPatterns(ubyte[] rom)
|
|
{
|
|
/+ TODO: Initialize patterns from character generator rom +/
|
|
if (rom is null) initPatterns();
|
|
else initPatterns();
|
|
}
|
|
|
|
// XXX XXX INIT
|
|
void init(Timer timer)
|
|
{
|
|
timer.new Counter(timer.hertz / 2, &toggleFlash);
|
|
}
|
|
}
|
|
|
|
class TextPatternGenerator_IIe : TextPatternGenerator
|
|
{
|
|
mixin("static final ubyte[256] charsetUpper_IIe = "
|
|
~ import("charset_upper_iie"));
|
|
mixin("static final ubyte[256] charsetSymbol_IIe = "
|
|
~ import("charset_symbol_iie"));
|
|
mixin("static final ubyte[256] charsetLower = "
|
|
~ import("charset_lower"));
|
|
mixin("static final ubyte[256] charsetMouse = "
|
|
~ import("charset_mouse"));
|
|
|
|
void initPatterns()
|
|
{
|
|
ubyte[][] segments = new ubyte[][8];
|
|
segments[0] = segments[4] = segments[6] = charsetUpper_IIe;
|
|
segments[1] = segments[5] = charsetSymbol_IIe;
|
|
segments[2] = charsetMouse; // unenhanced: charsetUpper
|
|
segments[3] = segments[7] = charsetLower;
|
|
|
|
ubyte flashNull;
|
|
for (int seg = 0; seg < 8; ++seg)
|
|
{
|
|
foreach(index, pattern; segments[seg])
|
|
{
|
|
uint ascii = (((index / 32) * 4) + (index % 4)) + (seg * 32);
|
|
uint dotLine = (index / 4) % 8;
|
|
switch (seg)
|
|
{
|
|
case 0, 1, 3:
|
|
flashNull = pattern ^ INVERSE;
|
|
break;
|
|
case 2:
|
|
flashNull = pattern; // unenhanced: pattern ^ INVERSE
|
|
break;
|
|
default:
|
|
flashNull = pattern;
|
|
break;
|
|
}
|
|
flashNullPatterns[ascii][dotLine][0] =
|
|
doubleBits[flashNull][0];
|
|
flashNullPatterns[ascii][dotLine][1] =
|
|
doubleBits[flashNull][1];
|
|
flashNullPatterns80[ascii][dotLine] = flashNull;
|
|
}
|
|
}
|
|
|
|
ubyte flashOn, flashOff;
|
|
for (uint ascii = 0; ascii < 256; ++ascii)
|
|
{
|
|
for (uint dotLine = 0; dotLine < 8; ++dotLine)
|
|
{
|
|
if ((ascii >= 64) && (ascii < 128))
|
|
{
|
|
flashOn = flashNullPatterns80[ascii - 64][dotLine];
|
|
flashOff = flashNullPatterns80[ascii + 64][dotLine];
|
|
}
|
|
else
|
|
{
|
|
flashOn = flashOff = flashNullPatterns80[ascii][dotLine];
|
|
}
|
|
flashOffPatterns[ascii][dotLine][0] = doubleBits[flashOff][0];
|
|
flashOffPatterns[ascii][dotLine][1] = doubleBits[flashOff][1];
|
|
flashOffPatterns80[ascii][dotLine] = flashOff;
|
|
flashOnPatterns[ascii][dotLine][0] = doubleBits[flashOn][0];
|
|
flashOnPatterns[ascii][dotLine][1] = doubleBits[flashOn][1];
|
|
flashOnPatterns80[ascii][dotLine] = flashOn;
|
|
}
|
|
}
|
|
}
|
|
|
|
void initPatterns(ubyte[] rom)
|
|
{
|
|
/+ TODO: Initialize patterns from character generator rom +/
|
|
if (rom is null) initPatterns();
|
|
else initPatterns();
|
|
}
|
|
|
|
// XXX XXX INIT
|
|
void init(Timer timer)
|
|
{
|
|
timer.new Counter(32 * 262 * 65, &toggleFlash); // XXX PAL
|
|
}
|
|
|
|
void altCharsetOn()
|
|
{
|
|
altCharsetChange(true);
|
|
}
|
|
|
|
void altCharsetOff()
|
|
{
|
|
altCharsetChange(false);
|
|
}
|
|
|
|
ubyte readAltCharset()
|
|
{
|
|
return kbdLatch() | (altCharset ? 0x80 : 0x00);
|
|
}
|
|
|
|
// XXX XXX INIT
|
|
mixin(InitSwitches("", [
|
|
mixin(MakeSwitch([0xC00E], "W", "altCharsetOff")),
|
|
mixin(MakeSwitch([0xC00F], "W", "altCharsetOn")),
|
|
mixin(MakeSwitch([0xC01E], "R", "readAltCharset"))
|
|
]));
|
|
}
|
|
|
|
class LoresPatternGenerator : PatternGenerator
|
|
{
|
|
ubyte[2][2][16] patterns;
|
|
|
|
void initPatterns()
|
|
{
|
|
int[16] dhrBits4 = [
|
|
0x0, 0x8, 0x4, 0xC, 0x2, 0x5, 0x6, 0xE,
|
|
0x1, 0x9, 0xA, 0xD, 0x3, 0xB, 0x7, 0xF];
|
|
for (int bits4 = 0; bits4 < 16; ++bits4)
|
|
{
|
|
ubyte bits8 = (dhrBits4[bits4] << 4) | dhrBits4[bits4];
|
|
ushort bits16 = (bits8 << 8) | bits8;
|
|
uint bits32 = (bits16 << 16) | bits16;
|
|
patterns[bits4][0][0] = bits32 >> 25;
|
|
patterns[bits4][0][1] = (bits32 >> 18) & 0b01111111;
|
|
patterns[bits4][1][0] = (bits32 >> 11) & 0b01111111;
|
|
patterns[bits4][1][1] = (bits32 >> 4) & 0b01111111;
|
|
}
|
|
}
|
|
|
|
void initPatterns(ubyte[] rom)
|
|
{
|
|
/+ TODO: Initialize patterns from IIe video ROM +/
|
|
if (rom is null) initPatterns();
|
|
else initPatterns();
|
|
}
|
|
|
|
void update(ubyte* signal, int scanLine, int startCol, uint len)
|
|
{
|
|
uint screenPos = 0;
|
|
uint col = startCol;
|
|
int shiftAmt = (((scanLine % 8) / 4) == 0) ? 0 : 4;
|
|
ubyte* data = scanner.getData(scanLine, startCol + 25);
|
|
uint memNybble;
|
|
|
|
for (uint offset = 0; offset < len; ++offset)
|
|
{
|
|
memNybble = (data[offset] >> shiftAmt) & 0x0F;
|
|
signal[screenPos++] = patterns[memNybble][col & 1][0];
|
|
signal[screenPos++] = patterns[memNybble][col++ & 1][1];
|
|
}
|
|
}
|
|
|
|
void update80(ubyte* signal, int scanLine, int startCol, uint len)
|
|
{
|
|
uint screenPos = 0;
|
|
uint col = startCol;
|
|
int shiftAmt = (((scanLine % 8) / 4) == 0) ? 0 : 4;
|
|
ubyte* data = scanner.getData(scanLine, startCol + 25);
|
|
ubyte* auxData = scanner.getData80(scanLine, startCol + 25);
|
|
uint memNybble;
|
|
|
|
for (uint offset = 0; offset < len; ++offset)
|
|
{
|
|
memNybble = (auxData[offset] >> shiftAmt) & 0x0F;
|
|
signal[screenPos++] = patterns[memNybble][col & 1][0];
|
|
|
|
memNybble = (data[offset] >> shiftAmt) & 0x0F;
|
|
signal[screenPos++] = patterns[memNybble][col++ & 1][0];
|
|
}
|
|
}
|
|
}
|
|
|
|
class HiresPatternGenerator : PatternGenerator
|
|
{
|
|
ubyte[2][256] patterns;
|
|
ubyte[256] patterns80;
|
|
|
|
ubyte prevByte;
|
|
|
|
void initPatterns()
|
|
{
|
|
for (int bits = 0; bits < 256; ++bits)
|
|
{
|
|
ubyte leftPattern = doubleBits[reverseBits[bits & 0x7F]][0];
|
|
ubyte rightPattern = doubleBits[reverseBits[bits & 0x7F]][1];
|
|
if (bits > 0x7F)
|
|
{
|
|
patterns[bits][0] = leftPattern >> 1;
|
|
patterns[bits][1] = (rightPattern >> 1) |
|
|
((leftPattern & 1) << 6);
|
|
}
|
|
else
|
|
{
|
|
patterns[bits][0] = leftPattern;
|
|
patterns[bits][1] = rightPattern;
|
|
}
|
|
|
|
patterns80[bits] = reverseBits[bits & 0x7F] | (bits & 0x80);
|
|
}
|
|
}
|
|
|
|
void initPatterns(ubyte[] rom)
|
|
{
|
|
/+ TODO: Initialize patterns from IIe video ROM +/
|
|
if (rom is null) initPatterns();
|
|
else initPatterns();
|
|
}
|
|
|
|
void update(ubyte* signal, int scanLine, int startCol, uint len)
|
|
{
|
|
uint screenPos = 0;
|
|
uint vidClock = scanLine * 65 + startCol + 25;
|
|
ubyte* data = scanner.getData(vidClock);
|
|
uint memByte;
|
|
|
|
if (startCol == 0)
|
|
prevByte = *(scanner.getData(vidClock - 1)) & 0b01000000;
|
|
|
|
for (uint offset = 0; offset < len; ++offset)
|
|
{
|
|
memByte = data[offset];
|
|
|
|
if (memByte > 0x7F)
|
|
signal[screenPos++] = patterns[memByte][0] | prevByte;
|
|
else
|
|
signal[screenPos++] = patterns[memByte][0];
|
|
prevByte = memByte & 0b01000000;
|
|
signal[screenPos++] = patterns[memByte][1];
|
|
}
|
|
}
|
|
|
|
void update80(ubyte* signal, int scanLine, int startCol, uint len)
|
|
{
|
|
uint screenPos = 0;
|
|
ubyte* data = scanner.getData(scanLine, startCol + 25);
|
|
ubyte* auxData = scanner.getData80(scanLine, startCol + 25);
|
|
|
|
for (int offset = 0; offset < len; ++offset)
|
|
{
|
|
signal[screenPos++] = patterns80[auxData[offset]];
|
|
signal[screenPos++] = patterns80[data[offset]];
|
|
}
|
|
}
|
|
}
|
|
|
|
class HiresPatternGenerator_Revision0 : HiresPatternGenerator
|
|
{
|
|
void update(ubyte* signal, int scanLine, int startCol, uint len)
|
|
{
|
|
uint screenPos = 0;
|
|
ubyte* data = scanner.getData(scanLine, startCol);
|
|
uint memByte;
|
|
|
|
for (int offset = 0; offset < len; ++offset)
|
|
{
|
|
memByte = data[offset] & 0x7F;
|
|
signal[screenPos++] = patterns[memByte][0];
|
|
signal[screenPos++] = patterns[memByte][1];
|
|
}
|
|
}
|
|
}
|
|
|