Publish VCC Plus OSS source distribution for 3.6.2 build 60

This commit is contained in:
Brian Holman committed 2026-11-13 00:14:03 -07:00
commit c652a5276d
1192 files changed
+272368

No files matched your search

+249
View File
@@ -0,0 +1,249 @@
// SPDX-License-Identifier: GPL-3.0-or-later
#include <vcc/gime.h>
typedef unsigned char byte;
#define REG(addr) (*(byte *)(addr))
#define FIRST_PAGE 0x20
#define SECOND_PAGE 0x24
#define WINDOW 0x8000
static byte back; // Zero when closed; otherwise an 8 KiB block number.
static byte palette[16];
static const byte *textImage;
// program_end is provided by CMOC's linker script. While bank 4 is mapped,
// neither an instruction fetch nor a stack access may land in the window.
static asm byte lowProgramAndStack(void)
{
asm {
program_end import
ldx #program_end
cmpx #$8000
bhi @reject
cmps #$8000
bhi @reject
tfr cc,b
bitb #$10
bne @reject
ldb #1
rts
@reject clrb
}
}
// A real 128 KiB GIME accepts the same MMU register writes as a 512 KiB
// machine, but blocks $20 and $30 alias. Change just one byte reversibly.
// An inactive window (for instance, wrong task) also fails this test.
static asm byte independentBanks(void)
{
asm {
pshs cc
orcc #$50
lda >$ffa4
pshs a
lda #$30
sta >$ffa4
lda >$9555
pshs a
lda #$20
sta >$ffa4
lda >$9555
pshs a
coma
sta >$9555
cmpa >$9555
bne @alias
lda #$30
sta >$ffa4
ldb >$9555
cmpb 1,s
bne @alias
ldb #1
bra @restore
@alias clrb
@restore
lda #$20
sta >$ffa4
puls a
sta >$9555
leas 1,s
puls a
sta >$ffa4
puls cc
}
}
// BASIC's 16-bit TIMER is incremented by its vertical interrupt handler.
// Poll the complete word, including through wraparound, with interrupts live.
// Aligned 32 KiB images share a zero low offset; flipping needs one store.
// The countdown makes missing IRQs a recoverable error.
static byte field(byte offsetHigh, byte flip)
{
asm {
ldd >$0112
ldx #$2000
@wait cmpd >$0112
bne @blank
leax -1,x
bne @wait
clrb
bra @done
@blank tst :flip
beq @success
ldb :offsetHigh
stb >$ff9d
@success
ldb #1
@done stb :flip
}
return flip;
}
// Paint at most one scan-line fragment in one bank. Preserve the other nibble
// at either edge. Mask interrupts only across the short-lived mapping: BASIC
// can take its normal 60 Hz interrupt between scan lines.
static void span(byte bank, unsigned address, byte lowFirst, byte pairs,
byte highLast, byte color)
{
byte packed = (color << 4) | color;
asm {
pshs cc
orcc #$50
lda >$ffa4
pshs a
lda :bank
sta >$ffa4
ldx :address
tst :lowFirst
beq @pairs
lda ,x
anda #$f0
ora :color
sta ,x+
@pairs ldb :pairs
beq @last
lda :packed
@loop sta ,x+
decb
bne @loop
@last tst :highLast
beq @done
lda :packed
anda #$f0
ldb ,x
andb #$0f
pshs b
ora ,s+
sta ,x
@done puls a
sta >$ffa4
puls cc
}
}
void gime_fill_rect(unsigned x, unsigned y, unsigned w, unsigned h, byte color)
{
unsigned rowPixel;
if (!back || color > 15 || x >= GIME_WIDTH || y >= GIME_HEIGHT || !w || !h)
return;
if (w > GIME_WIDTH - x) w = GIME_WIDTH - x;
if (h > GIME_HEIGHT - y) h = GIME_HEIGHT - y;
rowPixel = y * GIME_WIDTH + x;
while (h--) {
unsigned pixel = rowPixel;
unsigned remaining = w;
while (remaining) {
unsigned inBank = pixel & 0x3fff;
unsigned count = 0x4000 - inBank;
byte first = (byte)(pixel & 1);
if (count > remaining) count = remaining;
span((byte)(back + (pixel >> 14)), WINDOW + (inBank >> 1), first,
(byte)((count - first) >> 1), (byte)((count - first) & 1), color);
pixel += count;
remaining -= count;
}
rowPixel += GIME_WIDTH;
}
}
void gime_plot(unsigned x, unsigned y, byte color)
{
gime_fill_rect(x, y, 1, 1, color);
}
void gime_clear(byte color)
{
gime_fill_rect(0, 0, GIME_WIDTH, GIME_HEIGHT, color);
}
void gime_set_palette(byte slot, byte rgb)
{
if (back && slot < 16 && rgb < 64)
REG(0xffb0 + slot) = rgb;
}
byte gime_open(void)
{
byte i, width;
// Super Extended BASIC defines HRMODE at $E6 and HRWIDTH at $E7.
if (back || !lowProgramAndStack() || *(unsigned *)0xfff8 != 0xfef7 ||
REG(0xe6) != 0 || REG(0xe7) > 2)
return 0;
for (i = 0; i < 16; ++i) {
byte bank = REG(0xffa0 + i) & 0x3f;
if (bank >= FIRST_PAGE && bank < SECOND_PAGE + 4)
return 0;
}
if (!field(0, 0) || !independentBanks())
return 0;
width = REG(0xe7);
textImage = (const byte *)0xe032 + width * 9;
for (i = 0; i < 16; ++i)
palette[i] = REG(0xffb0 + i) & 0x3f;
back = FIRST_PAGE;
gime_clear(0);
back = SECOND_PAGE;
gime_clear(0);
if (!field(0, 0)) {
back = 0;
return 0;
}
// Super Extended BASIC keeps editable images of the write-only registers
// at $E032 (text tables) and $E070 (graphics). Keep the ROM's color phase.
REG(0xff90) = REG(0xe070);
REG(0xff98) = REG(0xe071);
REG(0xff99) = 0x1e; // 192 lines, 160 bytes per row, 16 colors.
REG(0xff9c) = 0;
REG(0xff9d) = FIRST_PAGE << 2;
REG(0xff9e) = 0;
REG(0xff9f) = 0;
return 1;
}
byte gime_present(void)
{
if (!back || !field(back << 2, 1))
return 0;
back = (back == SECOND_PAGE ? FIRST_PAGE : SECOND_PAGE);
return 1;
}
void gime_close(void)
{
byte i;
if (!back) return;
field(0, 0); // Even if the timer stops, always give the display back.
REG(0xff90) = textImage[0];
REG(0xff98) = textImage[1];
REG(0xff99) = textImage[2];
REG(0xff9c) = textImage[5];
REG(0xff9d) = textImage[6];
REG(0xff9e) = textImage[7];
REG(0xff9f) = textImage[8];
for (i = 0; i < 16; ++i)
REG(0xffb0 + i) = palette[i];
back = 0;
}