dan
/
TIC-80-guile
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
TIC-80-guile/src/tic.c

2222 lines
58 KiB
C
Raw Blame History

// MIT License
// Copyright (c) 2017 Vadim Grigoruk @nesbox // grigoruk@gmail.com
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <ctype.h>
#include <stddef.h>
#include <stddef.h>
#include "ticapi.h"
#include "tools.h"
#include "machine.h"
#include "ext/gif.h"
#define CLOCKRATE (TIC_FRAMERATE*30000)
#define MIN_PERIOD_VALUE 10
#define MAX_PERIOD_VALUE 4096
#define BASE_NOTE_FREQ 440.0
#define BASE_NOTE_POS 49.0
#define ENVELOPE_FREQ_SCALE 2
#define NOTES_PER_MUNUTE (TIC_FRAMERATE / NOTES_PER_BEET * 60)
#define min(a,b) ((a) < (b) ? (a) : (b))
#define max(a,b) ((a) > (b) ? (a) : (b))
typedef enum
{
CHUNK_DUMMY, // 0
CHUNK_TILES, // 1
CHUNK_SPRITES, // 2
CHUNK_COVER, // 3
CHUNK_MAP, // 4
CHUNK_CODE, // 5
CHUNK_TEMP, // 6
CHUNK_TEMP2, // 7
CHUNK_TEMP3, // 8
CHUNK_SAMPLES, // 9
CHUNK_WAVEFORM, // 10
CHUNK_TEMP4, // 11
CHUNK_PALETTE, // 12
CHUNK_PATTERNS, // 13
CHUNK_MUSIC, // 14
} ChunkType;
typedef struct
{
ChunkType type:5;
u32 bank:TIC_BANK_BITS;
u32 size:16; // max chunk size is 64K
u32 temp:8;
} Chunk;
STATIC_ASSERT(tic_bank_bits, TIC_BANK_BITS == 3);
STATIC_ASSERT(tic_chunk_size, sizeof(Chunk) == 4);
STATIC_ASSERT(tic_map, sizeof(tic_map) < 1024*32);
STATIC_ASSERT(tic_sample, sizeof(tic_sample) == 66);
STATIC_ASSERT(tic_track_pattern, sizeof(tic_track_pattern) == 3*MUSIC_PATTERN_ROWS);
STATIC_ASSERT(tic_track, sizeof(tic_track) == 3*MUSIC_FRAMES+3);
STATIC_ASSERT(tic_vram, sizeof(tic_vram) == TIC_VRAM_SIZE);
STATIC_ASSERT(tic_ram, sizeof(tic_ram) == TIC_RAM_SIZE);
STATIC_ASSERT(tic_sound_register, sizeof(tic_sound_register) == 16+2);
STATIC_ASSERT(tic80_input, sizeof(tic80_input) == 12);
static void update_amp(blip_buffer_t* blip, tic_sound_register_data* data, s32 new_amp )
{
s32 delta = new_amp - data->amp;
data->amp += delta;
blip_add_delta( blip, data->time, delta );
}
static inline double freq2note(double freq)
{
return (double)NOTES * log2(freq / BASE_NOTE_FREQ) + BASE_NOTE_POS;
}
static inline s32 note2freq(double note)
{
return round(pow(2, (note - BASE_NOTE_POS) / (double)NOTES) * BASE_NOTE_FREQ);
}
static inline s32 freq2period(double freq)
{
if(freq == 0.0) return MAX_PERIOD_VALUE;
enum {Rate = CLOCKRATE * ENVELOPE_FREQ_SCALE / ENVELOPE_VALUES};
s32 period = round((double)Rate / freq - 1.0);
if(period < MIN_PERIOD_VALUE) return MIN_PERIOD_VALUE;
if(period > MAX_PERIOD_VALUE) return MAX_PERIOD_VALUE;
return period;
}
static inline s32 getAmp(const tic_sound_register* reg, s32 amp)
{
enum {MaxAmp = (u16)-1 / (MAX_VOLUME * TIC_SOUND_CHANNELS)};
return amp * MaxAmp * reg->volume / MAX_VOLUME;
}
static void runEnvelope(blip_buffer_t* blip, tic_sound_register* reg, tic_sound_register_data* data, s32 end_time )
{
s32 period = freq2period(reg->freq * ENVELOPE_FREQ_SCALE);
for ( ; data->time < end_time; data->time += period )
{
data->phase = (data->phase + 1) % ENVELOPE_VALUES;
update_amp(blip, data, getAmp(reg, tic_tool_peek4(reg->waveform.data, data->phase)));
}
}
static void runNoise(blip_buffer_t* blip, tic_sound_register* reg, tic_sound_register_data* data, s32 end_time )
{
// phase is noise LFSR, which must never be zero
if ( data->phase == 0 )
data->phase = 1;
s32 period = freq2period(reg->freq);
for ( ; data->time < end_time; data->time += period )
{
data->phase = ((data->phase & 1) * (0b11 << 13)) ^ (data->phase >> 1);
update_amp(blip, data, getAmp(reg, (data->phase & 1) ? MAX_VOLUME : 0));
}
}
static void resetPalette(tic_mem* tic)
{
static const u8 DefaultMapping[] = {16, 50, 84, 118, 152, 186, 220, 254};
memcpy(tic->ram.vram.palette.data, tic->cart.bank0.palette.data, sizeof(tic_palette));
memcpy(tic->ram.vram.mapping, DefaultMapping, sizeof DefaultMapping);
}
static inline u8 mapColor(tic_mem* tic, u8 color)
{
return tic_tool_peek4(tic->ram.vram.mapping, color & 0xf);
}
static void setPixelDma(tic_mem* tic, s32 x, s32 y, u8 color)
{
tic_tool_poke4(tic->ram.vram.screen.data, y * TIC80_WIDTH + x, color);
}
static inline u32* getOvrAddr(tic_mem* tic, s32 x, s32 y)
{
enum {Top = (TIC80_FULLHEIGHT-TIC80_HEIGHT)/2};
enum {Left = (TIC80_FULLWIDTH-TIC80_WIDTH)/2};
return tic->screen + x + (y << TIC80_FULLWIDTH_BITS) + (Left + Top * TIC80_FULLWIDTH);
}
static void setPixelOvr(tic_mem* tic, s32 x, s32 y, u8 color)
{
tic_machine* machine = (tic_machine*)tic;
*getOvrAddr(tic, x, y) = *(machine->state.ovr.palette + color);
}
static u8 getPixelOvr(tic_mem* tic, s32 x, s32 y)
{
tic_machine* machine = (tic_machine*)tic;
u32 color = *getOvrAddr(tic, x, y);
u32* pal = machine->state.ovr.palette;
for(s32 i = 0; i < TIC_PALETTE_SIZE; i++, pal++)
if(*pal == color)
return i;
return 0;
}
static u8 getPixelDma(tic_mem* tic, s32 x, s32 y)
{
tic_machine* machine = (tic_machine*)tic;
return tic_tool_peek4(machine->memory.ram.vram.screen.data, y * TIC80_WIDTH + x);
}
static void setPixel(tic_machine* machine, s32 x, s32 y, u8 color)
{
if(x < machine->state.clip.l || y < machine->state.clip.t || x >= machine->state.clip.r || y >= machine->state.clip.b) return;
machine->state.setpix(&machine->memory, x, y, mapColor(&machine->memory, color));
}
static u8 getPixel(tic_machine* machine, s32 x, s32 y)
{
if(x < 0 || y < 0 || x >= TIC80_WIDTH || y >= TIC80_HEIGHT) return 0;
return machine->state.getpix(&machine->memory, x, y);
}
static void drawHLineDma(tic_mem* tic, s32 xl, s32 xr, s32 y, u8 color)
{
color = color << 4 | color;
if (xl >= xr) return;
if (xl & 1) {
tic_tool_poke4(&tic->ram.vram.screen.data, y * TIC80_WIDTH + xl, color);
xl++;
}
s32 count = (xr - xl) >> 1;
u8 *screen = tic->ram.vram.screen.data + ((y * TIC80_WIDTH + xl) >> 1);
for(s32 i = 0; i < count; i++) *screen++ = color;
if (xr & 1) {
tic_tool_poke4(&tic->ram.vram.screen.data, y * TIC80_WIDTH + xr - 1, color);
}
}
static void drawHLineOvr(tic_mem* tic, s32 x1, s32 x2, s32 y, u8 color)
{
tic_machine* machine = (tic_machine*)tic;
u32 final_color = *(machine->state.ovr.palette + color);
for(s32 x = x1; x < x2; ++x) {
*getOvrAddr(tic, x, y) = final_color;
}
}
static void drawHLine(tic_machine* machine, s32 x, s32 y, s32 width, u8 color)
{
if(y < machine->state.clip.t || machine->state.clip.b <= y) return;
u8 final_color = mapColor(&machine->memory, color);
s32 xl = max(x, machine->state.clip.l);
s32 xr = min(x + width, machine->state.clip.r);
machine->state.drawhline(&machine->memory, xl, xr, y, final_color);
}
static void drawVLine(tic_machine* machine, s32 x, s32 y, s32 height, u8 color)
{
if(x < 0 || x >= TIC80_WIDTH) return;
s32 yl = y < 0 ? 0 : y;
s32 yr = y + height >= TIC80_HEIGHT ? TIC80_HEIGHT : y + height;
for(s32 i = yl; i < yr; ++i)
setPixel(machine, x, i, color);
}
static void drawRect(tic_machine* machine, s32 x, s32 y, s32 width, s32 height, u8 color)
{
for(s32 i = y; i < y + height; ++i)
drawHLine(machine, x, i, width, color);
}
static void drawRectBorder(tic_machine* machine, s32 x, s32 y, s32 width, s32 height, u8 color)
{
drawHLine(machine, x, y, width, color);
drawHLine(machine, x, y + height - 1, width, color);
drawVLine(machine, x, y, height, color);
drawVLine(machine, x + width - 1, y, height, color);
}
#define DRAW_TILE_BODY(INDEX_EXPR) do {\
for(s32 py=sy; py < ey; py++, y++) \
{ \
s32 xx = x; \
for(s32 px=sx; px < ex; px++, xx++) \
{ \
u8 color = mapping[tic_tool_peek4(buffer, INDEX_EXPR)]; \
if(color != 255) machine->state.setpix(&machine->memory, xx, y, color); \
} \
} \
} while(0)
#define REVERT(X) (TIC_SPRITESIZE - 1 - (X))
#define INDEX_XY(X, Y) ((Y) * TIC_SPRITESIZE + (X))
static void drawTile(tic_machine* machine, const tic_tile* buffer, s32 x, s32 y, u8* colors, s32 count, s32 scale, tic_flip flip, tic_rotate rotate)
{
static u8 mapping[TIC_PALETTE_SIZE];
for (s32 i = 0; i < TIC_PALETTE_SIZE; i++) mapping[i] = tic_tool_peek4(machine->memory.ram.vram.mapping, i);
for (s32 i = 0; i < count; i++) mapping[colors[i]] = 255;
rotate &= 0b11;
u32 orientation = flip & 0b11;
if(rotate == tic_90_rotate) orientation ^= 0b001;
else if(rotate == tic_180_rotate) orientation ^= 0b011;
else if(rotate == tic_270_rotate) orientation ^= 0b010;
if (rotate == tic_90_rotate || rotate == tic_270_rotate) orientation |= 0b100;
if (scale == 1) {
// the most common path
s32 sx, sy, ex, ey;
sx = machine->state.clip.l - x; if (sx < 0) sx = 0;
sy = machine->state.clip.t - y; if (sy < 0) sy = 0;
ex = machine->state.clip.r - x; if (ex > TIC_SPRITESIZE) ex = TIC_SPRITESIZE;
ey = machine->state.clip.b - y; if (ey > TIC_SPRITESIZE) ey = TIC_SPRITESIZE;
y += sy;
x += sx;
switch (orientation) {
case 0b100: DRAW_TILE_BODY(INDEX_XY(py, px)); break;
case 0b110: DRAW_TILE_BODY(INDEX_XY(REVERT(py), px)); break;
case 0b101: DRAW_TILE_BODY(INDEX_XY(py, REVERT(px))); break;
case 0b111: DRAW_TILE_BODY(INDEX_XY(REVERT(py), REVERT(px))); break;
case 0b000: DRAW_TILE_BODY(INDEX_XY(px, py)); break;
case 0b010: DRAW_TILE_BODY(INDEX_XY(px, REVERT(py))); break;
case 0b001: DRAW_TILE_BODY(INDEX_XY(REVERT(px), py)); break;
case 0b011: DRAW_TILE_BODY(INDEX_XY(REVERT(px), REVERT(py))); break;
default: assert(!"Unknown value of orientation in drawTile");
}
return;
}
for(s32 py=0; py < TIC_SPRITESIZE; py++, y+=scale)
{
s32 xx = x;
for(s32 px=0; px < TIC_SPRITESIZE; px++, xx+=scale)
{
s32 i;
s32 ix = orientation & 0b001 ? TIC_SPRITESIZE - px - 1: px;
s32 iy = orientation & 0b010 ? TIC_SPRITESIZE - py - 1: py;
if(orientation & 0b100) {
i = ix * TIC_SPRITESIZE + iy;
} else {
i = iy * TIC_SPRITESIZE + ix;
}
u8 color = tic_tool_peek4(buffer, i);
if(mapping[color] != 255) drawRect(machine, xx, y, scale, scale, color);
}
}
}
static void drawMap(tic_machine* machine, const tic_map* src, const tic_tiles* tiles, s32 x, s32 y, s32 width, s32 height, s32 sx, s32 sy, u8 chromakey, s32 scale, RemapFunc remap, void* data)
{
const s32 size = TIC_SPRITESIZE * scale;
for(s32 j = y, jj = sy; j < y + height; j++, jj += size)
for(s32 i = x, ii = sx; i < x + width; i++, ii += size)
{
s32 mi = i;
s32 mj = j;
while(mi < 0) mi += TIC_MAP_WIDTH;
while(mj < 0) mj += TIC_MAP_HEIGHT;
while(mi >= TIC_MAP_WIDTH) mi -= TIC_MAP_WIDTH;
while(mj >= TIC_MAP_HEIGHT) mj -= TIC_MAP_HEIGHT;
s32 index = mi + mj * TIC_MAP_WIDTH;
RemapResult tile = { *(src->data + index), tic_no_flip, tic_no_rotate };
if (remap)
remap(data, mi, mj, &tile);
drawTile(machine, tiles->data + tile.index, ii, jj, &chromakey, 1, scale, tile.flip, tile.rotate);
}
}
static void resetSfx(Channel* channel)
{
memset(channel->pos.data, -1, sizeof(tic_sfx_pos));
channel->tick = -1;
}
static void channelSfx(tic_mem* tic, s32 index, s32 note, s32 octave, s32 duration, Channel* c, s32 volume, s32 speed)
{
tic_machine* machine = (tic_machine*)tic;
c->volume = volume;
if(index >= 0)
{
struct {s8 speed:SFX_SPEED_BITS;} temp = {speed};
c->speed = speed == temp.speed ? speed : machine->sound.sfx->samples.data[index].speed;
}
// start index of idealized piano
enum {PianoStart = -8};
s32 freq = note2freq(note + octave * NOTES + PianoStart);
c->duration = duration;
c->freq = freq;
c->index = index;
resetSfx(c);
}
static void musicSfx(tic_mem* tic, s32 index, s32 note, s32 octave, s32 volume, s32 channel)
{
tic_machine* machine = (tic_machine*)tic;
channelSfx(tic, index, note, octave, -1, &machine->state.music.channels[channel], MAX_VOLUME - volume, SFX_DEF_SPEED);
}
static void resetMusic(tic_mem* tic)
{
for (s32 c = 0; c < TIC_SOUND_CHANNELS; c++)
musicSfx(tic, -1, 0, 0, 0, c);
}
static void setMusic(tic_machine* machine, s32 index, s32 frame, s32 row, bool loop)
{
tic_mem* tic = (tic_mem*)machine;
tic->ram.music_pos.track = index;
if(index < 0)
{
machine->state.music.play = MusicStop;
resetMusic(tic);
}
else
{
tic->ram.music_pos.row = row;
tic->ram.music_pos.frame = frame < 0 ? 0 : frame;
tic->ram.music_pos.flag.loop = loop;
machine->state.music.play = MusicPlay;
const tic_track* track = &machine->sound.music->tracks.data[index];
machine->state.music.ticks = row >= 0 ? row * (track->speed + DEFAULT_SPEED) * NOTES_PER_MUNUTE / (track->tempo + DEFAULT_TEMPO) / DEFAULT_SPEED : 0;
}
}
static void api_music(tic_mem* tic, s32 index, s32 frame, s32 row, bool loop)
{
tic_machine* machine = (tic_machine*)tic;
setMusic(machine, index, frame, row, loop);
if(index >= 0)
machine->state.music.play = MusicPlay;
}
static void soundClear(tic_mem* tic)
{
{
tic_machine* machine = (tic_machine*)tic;
Channel channel =
{
.tick = -1,
.pos =
{
.volume = -1,
.wave = -1,
.arpeggio = -1,
.pitch = -1,
},
.index = -1,
.freq = 0,
.volume = MAX_VOLUME,
.speed = 0,
.duration = -1,
};
for(s32 i = 0; i < TIC_SOUND_CHANNELS; i++)
{
memcpy(machine->state.channels+i, &channel, sizeof channel);
memcpy(machine->state.music.channels+i, &channel, sizeof channel);
{
tic_sound_register* reg = &tic->ram.registers[i];
memset(reg, 0, sizeof(tic_sound_register));
}
{
tic_sound_register_data* data = &machine->state.registers[i];
memset(data, 0, sizeof(tic_sound_register_data));
}
}
api_music(tic, -1, 0, 0, false);
}
memset(tic->samples.buffer, 0, tic->samples.size);
}
static void updateSaveid(tic_mem* tic);
static void api_clip(tic_mem* tic, s32 x, s32 y, s32 width, s32 height)
{
tic_machine* machine = (tic_machine*)tic;
machine->state.clip.l = x;
machine->state.clip.t = y;
machine->state.clip.r = x + width;
machine->state.clip.b = y + height;
if(machine->state.clip.l < 0) machine->state.clip.l = 0;
if(machine->state.clip.t < 0) machine->state.clip.t = 0;
if(machine->state.clip.r > TIC80_WIDTH) machine->state.clip.r = TIC80_WIDTH;
if(machine->state.clip.b > TIC80_HEIGHT) machine->state.clip.b = TIC80_HEIGHT;
}
static void api_reset(tic_mem* tic)
{
resetPalette(tic);
memset(&tic->ram.vram.vars, 0, sizeof tic->ram.vram.vars);
api_clip(tic, 0, 0, TIC80_WIDTH, TIC80_HEIGHT);
soundClear(tic);
tic_machine* machine = (tic_machine*)tic;
machine->state.initialized = false;
machine->state.scanline = NULL;
machine->state.ovr.callback = NULL;
machine->state.setpix = setPixelDma;
machine->state.getpix = getPixelDma;
machine->state.drawhline = drawHLineDma;
updateSaveid(tic);
}
static void api_pause(tic_mem* tic)
{
tic_machine* machine = (tic_machine*)tic;
memcpy(&machine->pause.state, &machine->state, sizeof(MachineState));
memcpy(&machine->pause.ram, &tic->ram, sizeof(tic_ram));
machine->pause.time.start = machine->data->start;
machine->pause.time.paused = machine->data->counter();
}
static void api_resume(tic_mem* tic)
{
tic_machine* machine = (tic_machine*)tic;
if (machine->data)
{
memcpy(&machine->state, &machine->pause.state, sizeof(MachineState));
memcpy(&tic->ram, &machine->pause.ram, sizeof(tic_ram));
machine->data->start = machine->pause.time.start + machine->data->counter() - machine->pause.time.paused;
}
}
void tic_close(tic_mem* tic)
{
tic_machine* machine = (tic_machine*)tic;
machine->state.initialized = false;
#if defined(TIC_BUILD_WITH_LUA)
getLuaScriptConfig()->close(tic);
# if defined(TIC_BUILD_WITH_MOON)
getMoonScriptConfig()->close(tic);
# endif
# if defined(TIC_BUILD_WITH_FENNEL)
getFennelConfig()->close(tic);
# endif
#endif /* defined(TIC_BUILD_WITH_LUA) */
#if defined(TIC_BUILD_WITH_JS)
getJsScriptConfig()->close(tic);
#endif
#if defined(TIC_BUILD_WITH_WREN)
getWrenScriptConfig()->close(tic);
#endif
blip_delete(machine->blip);
free(tic->samples.buffer);
free(machine);
}
///////////////////////////////////////////////////////////////////////////////
// API ////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
static void api_rect(tic_mem* tic, s32 x, s32 y, s32 width, s32 height, u8 color)
{
tic_machine* machine = (tic_machine*)tic;
drawRect(machine, x, y, width, height, color);
}
static void api_clear(tic_mem* tic, u8 color)
{
static const Clip EmptyClip = {0, 0, TIC80_WIDTH, TIC80_HEIGHT};
tic_machine* machine = (tic_machine*)tic;
if(memcmp(&machine->state.clip, &EmptyClip, sizeof(Clip)) == 0)
{
color &= 0b00001111;
memset(tic->ram.vram.screen.data, color | (color << TIC_PALETTE_BPP), sizeof(tic->ram.vram.screen.data));
}
else
{
api_rect(tic, machine->state.clip.l, machine->state.clip.t, machine->state.clip.r - machine->state.clip.l, machine->state.clip.b - machine->state.clip.t, color);
}
}
static s32 drawChar(tic_mem* tic, u8 symbol, s32 x, s32 y, s32 width, s32 height, u8 color, s32 scale)
{
const u8* ptr = tic->font.data + symbol*BITS_IN_BYTE;
x += (BITS_IN_BYTE - 1)*scale;
for(s32 i = 0, ys = y; i < tic->font.height; i++, ptr++, ys += scale)
for(s32 col = BITS_IN_BYTE - tic->font.width, xs = x - col; col < BITS_IN_BYTE; col++, xs -= scale)
if(*ptr & 1 << col)
api_rect(tic, xs, ys, scale, scale, color);
return tic->font.width*scale;
}
static s32 api_draw_char(tic_mem* tic, u8 symbol, s32 x, s32 y, u8 color)
{
return drawChar(tic, symbol, x, y, tic->font.width, tic->font.height, color, 1);
}
s32 drawText(tic_mem* tic, const char* text, s32 x, s32 y, s32 width, s32 height, u8 color, s32 scale, DrawCharFunc* func)
{
s32 pos = x;
s32 max = x;
char sym = 0;
while((sym = *text++))
{
if(sym == '\n')
{
if(pos > max)
max = pos;
pos = x;
y += height * scale;
}
else pos += func(tic, sym, pos, y, width, height, color, scale);
}
return pos > max ? pos - x : max - x;
}
static s32 api_fixed_text(tic_mem* tic, const char* text, s32 x, s32 y, u8 color)
{
return drawText(tic, text, x, y, tic->font.width, tic->font.height, color, 1, drawChar);
}
static s32 drawNonFixedChar(tic_mem* tic, u8 symbol, s32 x, s32 y, s32 width, s32 height, u8 color, s32 scale)
{
const u8* ptr = tic->font.data + (symbol)*BITS_IN_BYTE;
s32 start = 0;
s32 end = tic->font.width;
s32 i = 0;
for(s32 col = 0; col < tic->font.width; col++)
{
for(i = 0; i < tic->font.height; i++)
if(*(ptr + i) & 0b10000000 >> col) break;
if(i < tic->font.height) break; else start++;
}
x -= start * scale;
for(s32 col = tic->font.width - 1; col >= start; col--)
{
for(i = 0; i < tic->font.height; i++)
if(*(ptr + i) & 0b10000000 >> col) break;
if(i < tic->font.height) break; else end--;
}
for(s32 ys = y, i = 0; i < tic->font.height; i++, ptr++, ys += scale)
for(s32 col = start, xs = x + start*scale; col < end; col++, xs += scale)
if(*ptr & 0b10000000 >> col)
api_rect(tic, xs, ys, scale, scale, color);
s32 size = end - start;
return (size ? size + 1 : tic->font.width - 2) * scale;
}
static s32 api_text(tic_mem* tic, const char* text, s32 x, s32 y, u8 color)
{
return drawText(tic, text, x, y, tic->font.width, tic->font.height, color, 1, drawNonFixedChar);
}
static s32 api_text_ex(tic_mem* tic, const char* text, s32 x, s32 y, u8 color, bool fixed, s32 scale)
{
return drawText(tic, text, x, y, tic->font.width, tic->font.height, color, scale, fixed ? drawChar : drawNonFixedChar);
}
static void drawSprite(tic_mem* tic, const tic_tiles* src, s32 index, s32 x, s32 y, u8* colors, s32 count, s32 scale, tic_flip flip, tic_rotate rotate)
{
if(index < TIC_SPRITES)
drawTile((tic_machine*)tic, src->data + index, x, y, colors, count, scale, flip, rotate);
}
static void api_sprite_ex(tic_mem* tic, const tic_tiles* src, s32 index, s32 x, s32 y, s32 w, s32 h, u8* colors, s32 count, s32 scale, tic_flip flip, tic_rotate rotate)
{
s32 step = TIC_SPRITESIZE * scale;
const tic_flip vert_horz_flip = tic_horz_flip | tic_vert_flip;
for(s32 i = 0; i < w; i++)
{
for(s32 j = 0; j < h; j++)
{
s32 mx = i;
s32 my = j;
if(flip == tic_horz_flip || flip == vert_horz_flip) mx = w-1-i;
if(flip == tic_vert_flip || flip == vert_horz_flip) my = h-1-j;
if (rotate == tic_180_rotate)
{
mx = w-1-mx;
my = h-1-my;
}
else if(rotate == tic_90_rotate)
{
if(flip == tic_no_flip || flip == vert_horz_flip) my = h-1-my;
else mx = w-1-mx;
}
else if(rotate == tic_270_rotate)
{
if(flip == tic_no_flip || flip == vert_horz_flip) mx = w-1-mx;
else my = h-1-my;
}
enum {Cols = TIC_SPRITESHEET_SIZE / TIC_SPRITESIZE};
if(rotate==0 || rotate==2)
drawSprite(tic, src, index + mx+my*Cols, x+i*step, y+j*step, colors, count, scale, flip, rotate);
else
drawSprite(tic, src, index + mx+my*Cols, x+j*step, y+i*step, colors, count, scale, flip, rotate);
}
}
}
s32 drawSpriteFont(tic_mem* tic, u8 symbol, s32 x, s32 y, s32 width, s32 height, u8 chromakey, s32 scale)
{
api_sprite_ex(tic, &tic->ram.sprites, symbol, x, y, 1, 1, &chromakey, 1, scale, tic_no_flip, tic_no_rotate);
return width * scale;
}
s32 drawFixedSpriteFont(tic_mem* tic, u8 index, s32 x, s32 y, s32 width, s32 height, u8 chromakey, s32 scale)
{
const u8* ptr = tic->ram.sprites.data[index].data;
enum {Size = TIC_SPRITESIZE};
s32 start = 0;
s32 end = Size;
s32 i = 0;
for(s32 col = 0; col < Size; col++)
{
for(i = 0; i < Size*Size; i += Size)
if(tic_tool_peek4(ptr, col + i) != chromakey) break;
if(i < Size*Size) break; else start++;
}
x -= start * scale;
for(s32 col = Size - 1; col >= start; col--)
{
for(i = 0; i < Size*Size; i += Size)
if(tic_tool_peek4(ptr, col + i) != chromakey) break;
if(i < Size*Size) break; else end--;
}
for(s32 row = 0, ys = y; row < Size; row++, ys += scale)
{
for(s32 col = start, xs = x + start*scale; col < end; col++, xs += scale)
{
u8 color = tic_tool_peek4(ptr, col + row * Size);
if(color != chromakey)
api_rect(tic, xs, ys, scale, scale, color);
}
}
s32 size = end - start;
return (size ? size + 1 : width) * scale;
}
static void api_pixel(tic_mem* tic, s32 x, s32 y, u8 color)
{
tic_machine* machine = (tic_machine*)tic;
setPixel(machine, x, y, color);
}
static u8 api_get_pixel(tic_mem* tic, s32 x, s32 y)
{
tic_machine* machine = (tic_machine*)tic;
return getPixel(machine, x, y);
}
static void api_rect_border(tic_mem* tic, s32 x, s32 y, s32 width, s32 height, u8 color)
{
tic_machine* machine = (tic_machine*)tic;
drawRectBorder(machine, x, y, width, height, color);
}
static struct
{
s16 Left[TIC80_HEIGHT];
s16 Right[TIC80_HEIGHT];
s32 ULeft[TIC80_HEIGHT];
s32 VLeft[TIC80_HEIGHT];
} SidesBuffer;
static void initSidesBuffer()
{
for(s32 i = 0; i < COUNT_OF(SidesBuffer.Left); i++)
SidesBuffer.Left[i] = TIC80_WIDTH, SidesBuffer.Right[i] = -1;
}
static void setSidePixel(s32 x, s32 y)
{
if(y >= 0 && y < TIC80_HEIGHT)
{
if(x < SidesBuffer.Left[y]) SidesBuffer.Left[y] = x;
if(x > SidesBuffer.Right[y]) SidesBuffer.Right[y] = x;
}
}
static void setSideTexPixel(s32 x, s32 y, float u, float v)
{
s32 yy = y;
if (yy >= 0 && yy < TIC80_HEIGHT)
{
if (x < SidesBuffer.Left[yy])
{
SidesBuffer.Left[yy] = x;
SidesBuffer.ULeft[yy] = u*65536.0f;
SidesBuffer.VLeft[yy] = v*65536.0f;
}
if (x > SidesBuffer.Right[yy])
{
SidesBuffer.Right[yy] = x;
}
}
}
static void api_circle(tic_mem* tic, s32 xm, s32 ym, s32 radius, u8 color)
{
tic_machine* machine = (tic_machine*)tic;
initSidesBuffer();
s32 r = radius;
s32 x = -r, y = 0, err = 2-2*r;
do
{
setSidePixel(xm-x, ym+y);
setSidePixel(xm-y, ym-x);
setSidePixel(xm+x, ym-y);
setSidePixel(xm+y, ym+x);
r = err;
if (r <= y) err += ++y*2+1;
if (r > x || err > y) err += ++x*2+1;
} while (x < 0);
s32 yt = max(machine->state.clip.t, ym-radius);
s32 yb = min(machine->state.clip.b, ym+radius+1);
u8 final_color = mapColor(&machine->memory, color);
for(s32 y = yt; y < yb; y++) {
s32 xl = max(SidesBuffer.Left[y], machine->state.clip.l);
s32 xr = min(SidesBuffer.Right[y]+1, machine->state.clip.r);
machine->state.drawhline(&machine->memory, xl, xr, y, final_color);
}
}
static void api_circle_border(tic_mem* tic, s32 xm, s32 ym, s32 radius, u8 color)
{
s32 r = radius;
s32 x = -r, y = 0, err = 2-2*r;
do {
api_pixel(tic, xm-x, ym+y, color);
api_pixel(tic, xm-y, ym-x, color);
api_pixel(tic, xm+x, ym-y, color);
api_pixel(tic, xm+y, ym+x, color);
r = err;
if (r <= y) err += ++y*2+1;
if (r > x || err > y) err += ++x*2+1;
} while (x < 0);
}
typedef void(*linePixelFunc)(tic_mem* tic, s32 x, s32 y, u8 color);
static void ticLine(tic_mem* tic, s32 x0, s32 y0, s32 x1, s32 y1, u8 color, linePixelFunc func)
{
s32 dx = abs(x1 - x0), sx = x0 < x1 ? 1 : -1;
s32 dy = abs(y1 - y0), sy = y0 < y1 ? 1 : -1;
s32 err = (dx > dy ? dx : -dy) / 2, e2;
for(;;)
{
func(tic, x0, y0, color);
if (x0 == x1 && y0 == y1) break;
e2 = err;
if (e2 >-dx) { err -= dy; x0 += sx; }
if (e2 < dy) { err += dx; y0 += sy; }
}
}
static void triPixelFunc(tic_mem* tic, s32 x, s32 y, u8 color)
{
setSidePixel(x, y);
}
static void api_tri(tic_mem* tic, s32 x1, s32 y1, s32 x2, s32 y2, s32 x3, s32 y3, u8 color)
{
tic_machine* machine = (tic_machine*)tic;
initSidesBuffer();
ticLine(tic, x1, y1, x2, y2, color, triPixelFunc);
ticLine(tic, x2, y2, x3, y3, color, triPixelFunc);
ticLine(tic, x3, y3, x1, y1, color, triPixelFunc);
u8 final_color = mapColor(&machine->memory, color);
s32 yt = max(machine->state.clip.t, min(y1, min(y2, y3)));
s32 yb = min(machine->state.clip.b, max(y1, max(y2, y3)) + 1);
for(s32 y = yt; y < yb; y++) {
s32 xl = max(SidesBuffer.Left[y], machine->state.clip.l);
s32 xr = min(SidesBuffer.Right[y]+1, machine->state.clip.r);
machine->state.drawhline(&machine->memory, xl, xr, y, final_color);
}
}
typedef struct
{
float x, y, u, v;
} TexVert;
static void ticTexLine(tic_mem* tic, TexVert *v0, TexVert *v1)
{
TexVert *top = v0;
TexVert *bot = v1;
if (bot->y < top->y)
{
top = v1;
bot = v0;
}
float dy = bot->y - top->y;
float step_x = (bot->x - top->x);
float step_u = (bot->u - top->u);
float step_v = (bot->v - top->v);
if ((s32)dy != 0)
{
step_x /= dy;
step_u /= dy;
step_v /= dy;
}
float x = top->x;
float y = top->y;
float u = top->u;
float v = top->v;
if(y < .0f)
{
y = .0f - y;
x += step_x * y;
u += step_u * y;
v += step_v * y;
y = .0f;
}
s32 botY = bot->y;
if(botY > TIC80_HEIGHT)
botY = TIC80_HEIGHT;
for (; y <botY; ++y)
{
setSideTexPixel(x, y, u, v);
x += step_x;
u += step_u;
v += step_v;
}
}
static void api_textri(tic_mem* tic, float x1, float y1, float x2, float y2, float x3, float y3, float u1, float v1, float u2, float v2, float u3, float v3, bool use_map, u8 chroma)
{
tic_machine* machine = (tic_machine*)tic;
TexVert V0, V1, V2;
const u8* ptr = tic->ram.tiles.data[0].data;
const u8* map = tic->ram.map.data;
V0.x = x1; V0.y = y1; V0.u = u1; V0.v = v1;
V1.x = x2; V1.y = y2; V1.u = u2; V1.v = v2;
V2.x = x3; V2.y = y3; V2.u = u3; V2.v = v3;
// calculate the slope of the surface
// use floats here
double denom = (V0.x - V2.x) * (V1.y - V2.y) - (V1.x - V2.x) * (V0.y - V2.y);
if (denom == 0.0)
{
return;
}
double id = 1.0 / denom;
float dudx, dvdx;
// this is the UV slope across the surface
dudx = ((V0.u - V2.u) * (V1.y - V2.y) - (V1.u - V2.u) * (V0.y - V2.y)) * id;
dvdx = ((V0.v - V2.v) * (V1.y - V2.y) - (V1.v - V2.v) * (V0.y - V2.y)) * id;
// convert to fixed
s32 dudxs = dudx * 65536.0f;
s32 dvdxs = dvdx * 65536.0f;
// fill the buffer
initSidesBuffer();
// parse each line and decide where in the buffer to store them ( left or right )
ticTexLine(tic, &V0, &V1);
ticTexLine(tic, &V1, &V2);
ticTexLine(tic, &V2, &V0);
for (s32 y = 0; y < TIC80_HEIGHT; y++)
{
// if it's backwards skip it
s32 width = SidesBuffer.Right[y] - SidesBuffer.Left[y];
// if it's off top or bottom , skip this line
if ((y < machine->state.clip.t) || (y > machine->state.clip.b))
width = 0;
if (width > 0)
{
s32 u = SidesBuffer.ULeft[y];
s32 v = SidesBuffer.VLeft[y];
s32 left = SidesBuffer.Left[y];
s32 right = SidesBuffer.Right[y];
// check right edge, and clamp it
if (right > machine->state.clip.r)
right = machine->state.clip.r;
// check left edge and offset UV's if we are off the left
if (left < machine->state.clip.l)
{
s32 dist = machine->state.clip.l - SidesBuffer.Left[y];
u += dudxs * dist;
v += dvdxs * dist;
left = machine->state.clip.l;
}
// are we drawing from the map . ok then at least check before the inner loop
if (use_map == true)
{
for (s32 x = left; x <= right; ++x)
{
enum { MapWidth = TIC_MAP_WIDTH * TIC_SPRITESIZE, MapHeight = TIC_MAP_HEIGHT * TIC_SPRITESIZE };
s32 iu = (u >> 16) % MapWidth;
s32 iv = (v >> 16) % MapHeight;
while (iu < 0) iu += MapWidth;
while (iv < 0) iv += MapHeight;
u8 tile = map[(iv >> 3) * TIC_MAP_WIDTH + (iu >> 3)];
const u8 *buffer = &ptr[tile << 5];
u8 color = tic_tool_peek4(buffer, (iu & 7) + ((iv & 7) << 3));
if (color != chroma)
setPixel(machine, x, y, color);
u += dudxs;
v += dvdxs;
}
}
else
{
// direct from tile ram
for (s32 x = left; x <= right; ++x)
{
enum{SheetWidth = TIC_SPRITESHEET_SIZE, SheetHeight = TIC_SPRITESHEET_SIZE * TIC_SPRITE_BANKS};
s32 iu = (u>>16) & (SheetWidth - 1);
s32 iv = (v>>16) & (SheetHeight - 1);
const u8 *buffer = &ptr[((iu >> 3) + ((iv >> 3) << 4)) << 5];
u8 color = tic_tool_peek4(buffer, (iu & 7) + ((iv & 7) << 3));
if (color != chroma)
setPixel(machine, x, y, color);
u += dudxs;
v += dvdxs;
}
}
}
}
}
static void api_sprite(tic_mem* tic, const tic_tiles* src, s32 index, s32 x, s32 y, u8* colors, s32 count)
{
drawSprite(tic, src, index, x, y, colors, count, 1, tic_no_flip, tic_no_rotate);
}
static void api_map(tic_mem* tic, const tic_map* src, const tic_tiles* tiles, s32 x, s32 y, s32 width, s32 height, s32 sx, s32 sy, u8 chromakey, s32 scale)
{
drawMap((tic_machine*)tic, src, tiles, x, y, width, height, sx, sy, chromakey, scale, NULL, NULL);
}
static void api_remap(tic_mem* tic, const tic_map* src, const tic_tiles* tiles, s32 x, s32 y, s32 width, s32 height, s32 sx, s32 sy, u8 chromakey, s32 scale, RemapFunc remap, void* data)
{
drawMap((tic_machine*)tic, src, tiles, x, y, width, height, sx, sy, chromakey, scale, remap, data);
}
static void api_map_set(tic_mem* tic, tic_map* src, s32 x, s32 y, u8 value)
{
if(x < 0 || x >= TIC_MAP_WIDTH || y < 0 || y >= TIC_MAP_HEIGHT) return;
*(src->data + y * TIC_MAP_WIDTH + x) = value;
}
static u8 api_map_get(tic_mem* tic, const tic_map* src, s32 x, s32 y)
{
if(x < 0 || x >= TIC_MAP_WIDTH || y < 0 || y >= TIC_MAP_HEIGHT) return 0;
return *(src->data + y * TIC_MAP_WIDTH + x);
}
static void api_line(tic_mem* tic, s32 x0, s32 y0, s32 x1, s32 y1, u8 color)
{
ticLine(tic, x0, y0, x1, y1, color, api_pixel);
}
static s32 calcLoopPos(const tic_sound_loop* loop, s32 pos)
{
s32 offset = 0;
if(loop->size > 0)
{
for(s32 i = 0; i < pos; i++)
{
if(offset < (loop->start + loop->size-1))
offset++;
else offset = loop->start;
}
}
else offset = pos >= SFX_TICKS ? SFX_TICKS - 1 : pos;
return offset;
}
static void sfx(tic_mem* tic, s32 index, s32 freq, Channel* channel, tic_sound_register* reg)
{
tic_machine* machine = (tic_machine*)tic;
if(channel->duration > 0)
channel->duration--;
if(index < 0 || channel->duration == 0)
{
resetSfx(channel);
return;
}
const tic_sample* effect = &machine->sound.sfx->samples.data[index];
s32 pos = ++channel->tick;
s8 speed = channel->speed;
if(speed)
{
if(speed > 0) pos *= 1 + speed;
else pos /= 1 - speed;
}
for(s32 i = 0; i < sizeof(tic_sfx_pos); i++)
*(channel->pos.data+i) = calcLoopPos(effect->loops + i, pos);
u8 volume = (MAX_VOLUME - effect->data[channel->pos.volume].volume) * channel->volume / MAX_VOLUME;
if(volume > 0)
{
s8 arp = effect->data[channel->pos.arpeggio].arpeggio * (effect->reverse ? -1 : 1);
if(arp) freq = note2freq(freq2note(freq)+arp);
freq += effect->data[channel->pos.pitch].pitch * (effect->pitch16x ? 16 : 1);
reg->freq = freq;
reg->volume = volume;
u8 wave = effect->data[channel->pos.wave].wave;
const tic_waveform* waveform = &machine->sound.sfx->waveform.envelopes[wave];
memcpy(reg->waveform.data, waveform->data, sizeof(tic_waveform));
}
}
static void processMusic(tic_mem* tic)
{
tic_machine* machine = (tic_machine*)tic;
if(machine->state.music.play == MusicStop) return;
const tic_track* track = &machine->sound.music->tracks.data[tic->ram.music_pos.track];
s32 row = machine->state.music.ticks * (track->tempo + DEFAULT_TEMPO) * DEFAULT_SPEED / (track->speed + DEFAULT_SPEED) / NOTES_PER_MUNUTE;
s32 rows = MUSIC_PATTERN_ROWS - track->rows;
if (row >= rows)
{
row = 0;
machine->state.music.ticks = 0;
resetMusic(tic);
if(machine->state.music.play == MusicPlay)
{
tic->ram.music_pos.frame++;
if(tic->ram.music_pos.frame >= MUSIC_FRAMES)
{
if(tic->ram.music_pos.flag.loop)
tic->ram.music_pos.frame = 0;
else
{
api_music(tic, -1, 0, 0, false);
return;
}
}
else
{
s32 val = 0;
for (s32 c = 0; c < TIC_SOUND_CHANNELS; c++)
val += tic_tool_get_pattern_id(track, tic->ram.music_pos.frame, c);
if(!val)
{
if(tic->ram.music_pos.flag.loop)
tic->ram.music_pos.frame = 0;
else
{
api_music(tic, -1, 0, 0, false);
return;
}
}
}
}
else if(machine->state.music.play == MusicPlayFrame)
{
if(!tic->ram.music_pos.flag.loop)
{
api_music(tic, -1, 0, 0, false);
return;
}
}
}
if (row != tic->ram.music_pos.row)
{
tic->ram.music_pos.row = row;
for (s32 channel = 0; channel < TIC_SOUND_CHANNELS; channel++)
{
s32 patternId = tic_tool_get_pattern_id(track, tic->ram.music_pos.frame, channel);
if (!patternId) continue;
const tic_track_pattern* pattern = &machine->sound.music->patterns.data[patternId - PATTERN_START];
s32 note = pattern->rows[tic->ram.music_pos.row].note;
if (note > NoteNone)
{
musicSfx(tic, -1, 0, 0, 0, channel);
if (note >= NoteStart)
{
s32 octave = pattern->rows[tic->ram.music_pos.row].octave;
s32 sfx = (pattern->rows[row].sfxhi << MUSIC_SFXID_LOW_BITS) | pattern->rows[row].sfxlow;
s32 volume = pattern->rows[tic->ram.music_pos.row].volume;
musicSfx(tic, sfx, note - NoteStart, octave, volume, channel);
}
}
}
}
for (s32 i = 0; i < TIC_SOUND_CHANNELS; ++i )
{
Channel* c = &machine->state.music.channels[i];
if(c->index >= 0)
sfx(tic, c->index, c->freq, c, &tic->ram.registers[i]);
}
machine->state.music.ticks++;
}
static bool isNoiseWaveform(const tic_waveform* wave)
{
static const tic_waveform NoiseWave = {.data = {0}};
return memcmp(&NoiseWave.data, &wave->data, sizeof(tic_waveform)) == 0;
}
static bool isKeyPressed(const tic80_keyboard* input, tic_key key)
{
for(s32 i = 0; i < TIC80_KEY_BUFFER; i++)
if(input->keys[i] == key)
return true;
return false;
}
static void api_tick_start(tic_mem* tic, const tic_sfx* sfxsrc, const tic_music* music)
{
tic_machine* machine = (tic_machine*)tic;
machine->sound.sfx = sfxsrc;
machine->sound.music = music;
for (s32 i = 0; i < TIC_SOUND_CHANNELS; ++i )
memset(&tic->ram.registers[i], 0, sizeof(tic_sound_register));
processMusic(tic);
for (s32 i = 0; i < TIC_SOUND_CHANNELS; ++i )
{
Channel* c = &machine->state.channels[i];
if(c->index >= 0)
sfx(tic, c->index, c->freq, c, &tic->ram.registers[i]);
}
// process gamepad
for(s32 i = 0; i < COUNT_OF(machine->state.gamepads.holds); i++)
{
u32 mask = 1 << i;
u32 prevDown = machine->state.gamepads.previous.data & mask;
u32 down = tic->ram.input.gamepads.data & mask;
u32* hold = &machine->state.gamepads.holds[i];
if(prevDown && prevDown == down) (*hold)++;
else *hold = 0;
}
// process keyboard
for(s32 i = 0; i < tic_keys_count; i++)
{
bool prevDown = isKeyPressed(&machine->state.keyboard.previous, i);
bool down = isKeyPressed(&tic->ram.input.keyboard, i);
u32* hold = &machine->state.keyboard.holds[i];
if(prevDown && down) (*hold)++;
else *hold = 0;
}
machine->state.setpix = setPixelDma;
machine->state.getpix = getPixelDma;
machine->state.synced = 0;
machine->state.drawhline = drawHLineDma;
}
static void api_tick_end(tic_mem* tic)
{
tic_machine* machine = (tic_machine*)tic;
machine->state.gamepads.previous.data = machine->memory.ram.input.gamepads.data;
machine->state.keyboard.previous.data = machine->memory.ram.input.keyboard.data;
enum {EndTime = CLOCKRATE / TIC_FRAMERATE};
for (s32 i = 0; i < TIC_SOUND_CHANNELS; ++i )
{
tic_sound_register* reg = &tic->ram.registers[i];
tic_sound_register_data* data = &machine->state.registers[i];
isNoiseWaveform(&reg->waveform)
? runNoise(machine->blip, reg, data, EndTime)
: runEnvelope(machine->blip, reg, data, EndTime);
data->time -= EndTime;
}
blip_end_frame(machine->blip, EndTime);
blip_read_samples(machine->blip, machine->memory.samples.buffer, machine->samplerate / TIC_FRAMERATE, 0);
machine->state.setpix = setPixelOvr;
machine->state.getpix = getPixelOvr;
machine->state.drawhline = drawHLineOvr;
}
static tic_sfx_pos api_sfx_pos(tic_mem* tic, s32 channel)
{
tic_machine* machine = (tic_machine*)tic;
Channel* c = &machine->state.channels[channel];
return c->pos;
}
static void api_sfx_ex(tic_mem* tic, s32 index, s32 note, s32 octave, s32 duration, s32 channel, s32 volume, s32 speed)
{
tic_machine* machine = (tic_machine*)tic;
channelSfx(tic, index, note, octave, duration, &machine->state.channels[channel], volume, speed);
}
static void api_sfx(tic_mem* tic, s32 index, s32 note, s32 octave, s32 duration, s32 channel)
{
api_sfx_ex(tic, index, note, octave, duration, channel, MAX_VOLUME, SFX_DEF_SPEED);
}
static void api_sfx_stop(tic_mem* tic, s32 channel)
{
api_sfx(tic, -1, 0, 0, -1, channel);
}
static void api_music_frame(tic_mem* tic, s32 index, s32 frame, s32 row, bool loop)
{
tic_machine* machine = (tic_machine*)tic;
setMusic(machine, index, frame, row, loop);
if(index >= 0)
machine->state.music.play = MusicPlayFrame;
}
static void initCover(tic_mem* tic)
{
const tic_cover_image* cover = &tic->cart.cover;
if(cover->size)
{
gif_image* image = gif_read_data(cover->data, cover->size);
if (image)
{
if (image->width == TIC80_WIDTH && image->height == TIC80_HEIGHT)
{
enum { Size = TIC80_WIDTH * TIC80_HEIGHT };
for (s32 i = 0; i < Size; i++)
{
const gif_color* c = &image->palette[image->buffer[i]];
tic_rgb rgb = { c->r, c->g, c->b };
u8 color = tic_tool_find_closest_color(tic->cart.bank0.palette.colors, &rgb);
tic_tool_poke4(tic->ram.vram.screen.data, i, color);
}
}
gif_close(image);
}
}
}
static void api_sync(tic_mem* tic, u32 mask, s32 bank, bool toCart)
{
tic_machine* machine = (tic_machine*)tic;
static const struct {s32 bank; s32 ram; s32 size;} Sections[] =
{
{offsetof(tic_bank, tiles), offsetof(tic_ram, tiles), sizeof(tic_tiles) },
{offsetof(tic_bank, sprites), offsetof(tic_ram, sprites), sizeof(tic_tiles) },
{offsetof(tic_bank, map), offsetof(tic_ram, map), sizeof(tic_map) },
{offsetof(tic_bank, sfx), offsetof(tic_ram, sfx), sizeof(tic_sfx) },
{offsetof(tic_bank, music), offsetof(tic_ram, music), sizeof(tic_music) },
{offsetof(tic_bank, palette), offsetof(tic_ram, vram.palette), sizeof(tic_palette) },
};
enum{Count = COUNT_OF(Sections), Mask = (1 << Count) - 1};
if(mask == 0) mask = Mask;
mask &= ~machine->state.synced & Mask;
assert(bank >= 0 && bank < TIC_BANKS);
for(s32 i = 0; i < Count; i++)
{
if(mask & (1 << i))
toCart
? memcpy((u8*)&tic->cart.banks[bank] + Sections[i].bank, (u8*)&tic->ram + Sections[i].ram, Sections[i].size)
: memcpy((u8*)&tic->ram + Sections[i].ram, (u8*)&tic->cart.banks[bank] + Sections[i].bank, Sections[i].size);
}
machine->state.synced |= mask;
}
static void cart2ram(tic_mem* tic)
{
api_sync(tic, 0, 0, false);
initCover(tic);
}
static const char* readMetatag(const char* code, const char* tag, const char* comment)
{
const char* start = NULL;
{
static char format[] = "%s %s:";
char* tagBuffer = malloc(strlen(format) + strlen(tag));
if(tagBuffer)
{
sprintf(tagBuffer, format, comment, tag);
if((start = strstr(code, tagBuffer)))
start += strlen(tagBuffer);
free(tagBuffer);
}
}
if(start)
{
const char* end = strstr(start, "\n");
if(end)
{
while(*start <= ' ' && start < end) start++;
while(*(end-1) <= ' ' && end > start) end--;
const s32 size = (s32)(end-start);
char* value = (char*)malloc(size+1);
if(value)
{
memset(value, 0, size+1);
memcpy(value, start, size);
return value;
}
}
}
return NULL;
}
static bool compareMetatag(const char* code, const char* tag, const char* value, const char* comment)
{
bool result = false;
const char* str = readMetatag(code, tag, comment);
if(str)
{
result = strcmp(str, value) == 0;
free((void*)str);
}
return result;
}
static const tic_script_config* getScriptConfig(const char* code)
{
#if defined(TIC_BUILD_WITH_MOON)
if(compareMetatag(code, "script", "moon", getMoonScriptConfig()->singleComment) ||
compareMetatag(code, "script", "moonscript", getMoonScriptConfig()->singleComment))
return getMoonScriptConfig();
#endif
#if defined(TIC_BUILD_WITH_FENNEL)
if(compareMetatag(code, "script", "fennel", getFennelConfig()->singleComment))
return getFennelConfig();
#endif
#if defined(TIC_BUILD_WITH_JS)
if(compareMetatag(code, "script", "js", getJsScriptConfig()->singleComment) ||
compareMetatag(code, "script", "javascript", getJsScriptConfig()->singleComment))
return getJsScriptConfig();
#endif
#if defined(TIC_BUILD_WITH_WREN)
if(compareMetatag(code, "script", "wren", getWrenScriptConfig()->singleComment))
return getWrenScriptConfig();
#endif
#if defined(TIC_BUILD_WITH_LUA)
return getLuaScriptConfig();
#elif defined(TIC_BUILD_WITH_JS)
return getJsScriptConfig();
#elif defined(TIC_BUILD_WITH_WREN)
return getWrenScriptConfig();
#endif
}
static const tic_script_config* api_get_script_config(tic_mem* tic)
{
return getScriptConfig(tic->cart.bank0.code.data);
}
static void updateSaveid(tic_mem* tic)
{
memset(tic->saveid, 0, sizeof tic->saveid);
const char* saveid = readMetatag(tic->cart.bank0.code.data, "saveid", api_get_script_config(tic)->singleComment);
if(saveid)
{
strncpy(tic->saveid, saveid, TIC_SAVEID_SIZE-1);
free((void*)saveid);
}
}
static void api_tick(tic_mem* tic, tic_tick_data* data)
{
tic_machine* machine = (tic_machine*)tic;
machine->data = data;
if(!machine->state.initialized)
{
enum{CodeSize = sizeof(tic_code) * TIC_BANKS};
char* code = malloc(CodeSize);
if(code)
{
memset(code, 0, CodeSize);
for(s32 i = TIC_BANKS - 1; i >= 0; i--)
{
const char* bankCode = tic->cart.banks[i].code.data;
if(strlen(bankCode))
strcat(code, bankCode);
}
if(data->preprocessor)
data->preprocessor(data->data, code);
bool done = false;
const tic_script_config* config = NULL;
if(strlen(code))
{
config = getScriptConfig(code);
cart2ram(tic);
machine->state.synced = 0;
tic->input.data = 0;
if(compareMetatag(code, "input", "mouse", config->singleComment))
tic->input.mouse = 1;
else if(compareMetatag(code, "input", "gamepad", config->singleComment))
tic->input.gamepad = 1;
else if(compareMetatag(code, "input", "keyboard", config->singleComment))
tic->input.keyboard = 1;
else tic->input.data = -1; // default is all enabled
data->start = data->counter();
done = config->init(tic, code);
}
else
{
machine->data->error(machine->data->data, "the code is empty");
}
free(code);
if(done)
{
machine->state.tick = config->tick;
machine->state.scanline = config->scanline;
machine->state.ovr.callback = config->overline;
machine->state.initialized = true;
}
else return;
}
}
machine->state.tick(tic);
}
static void api_scanline(tic_mem* tic, s32 row, void* data)
{
tic_machine* machine = (tic_machine*)tic;
if(machine->state.initialized)
machine->state.scanline(tic, row, data);
}
static void api_overline(tic_mem* tic, void* data)
{
tic_machine* machine = (tic_machine*)tic;
if(machine->state.initialized)
machine->state.ovr.callback(tic, data);
}
static double api_time(tic_mem* tic)
{
tic_machine* machine = (tic_machine*)tic;
return (double)((machine->data->counter() - machine->data->start)*1000)/machine->data->freq();
}
static u32 api_btnp(tic_mem* tic, s32 index, s32 hold, s32 period)
{
tic_machine* machine = (tic_machine*)tic;
if(index < 0)
{
return (~machine->state.gamepads.previous.data) & machine->memory.ram.input.gamepads.data;
}
else if(hold < 0 || period < 0)
{
return ((~machine->state.gamepads.previous.data) & machine->memory.ram.input.gamepads.data) & (1 << index);
}
tic80_gamepads previous;
previous.data = machine->state.gamepads.holds[index] >= hold
? period && machine->state.gamepads.holds[index] % period ? machine->state.gamepads.previous.data : 0
: machine->state.gamepads.previous.data;
return ((~previous.data) & machine->memory.ram.input.gamepads.data) & (1 << index);
}
static bool api_key(tic_mem* tic, tic_key key)
{
return key > tic_key_unknown
? isKeyPressed(&tic->ram.input.keyboard, key)
: tic->ram.input.keyboard.data;
}
static bool api_keyp(tic_mem* tic, tic_key key, s32 hold, s32 period)
{
tic_machine* machine = (tic_machine*)tic;
if(key > tic_key_unknown)
{
bool prevDown = hold >= 0 && period >= 0 && machine->state.keyboard.holds[key] >= hold
? period && machine->state.keyboard.holds[key] % period
? isKeyPressed(&machine->state.keyboard.previous, key)
: false
: isKeyPressed(&machine->state.keyboard.previous, key);
bool down = isKeyPressed(&tic->ram.input.keyboard, key);
return !prevDown && down;
}
for(s32 i = 0; i < TIC80_KEY_BUFFER; i++)
{
tic_key key = tic->ram.input.keyboard.keys[i];
if(key)
{
bool wasPressed = false;
for(s32 p = 0; p < TIC80_KEY_BUFFER; p++)
{
if(machine->state.keyboard.previous.keys[p] == key)
{
wasPressed = true;
break;
}
}
if(!wasPressed)
return true;
}
}
return false;
}
static void api_load(tic_cartridge* cart, const u8* buffer, s32 size, bool palette)
{
const u8* end = buffer + size;
memset(cart, 0, sizeof(tic_cartridge));
if(palette)
{
static const u8 DB16[] = {0x14, 0x0c, 0x1c, 0x44, 0x24, 0x34, 0x30, 0x34, 0x6d, 0x4e, 0x4a, 0x4e, 0x85, 0x4c, 0x30, 0x34, 0x65, 0x24, 0xd0, 0x46, 0x48, 0x75, 0x71, 0x61, 0x59, 0x7d, 0xce, 0xd2, 0x7d, 0x2c, 0x85, 0x95, 0xa1, 0x6d, 0xaa, 0x2c, 0xd2, 0xaa, 0x99, 0x6d, 0xc2, 0xca, 0xda, 0xd4, 0x5e, 0xde, 0xee, 0xd6};
memcpy(cart->bank0.palette.data, DB16, sizeof(tic_palette));
}
#define LOAD_CHUNK(to) memcpy(&to, buffer, min(sizeof(to), chunk.size))
while(buffer < end)
{
Chunk chunk;
memcpy(&chunk, buffer, sizeof(Chunk));
buffer += sizeof(Chunk);
switch(chunk.type)
{
case CHUNK_TILES: LOAD_CHUNK(cart->banks[chunk.bank].tiles); break;
case CHUNK_SPRITES: LOAD_CHUNK(cart->banks[chunk.bank].sprites); break;
case CHUNK_MAP: LOAD_CHUNK(cart->banks[chunk.bank].map); break;
case CHUNK_CODE: LOAD_CHUNK(cart->banks[chunk.bank].code); break;
case CHUNK_SAMPLES: LOAD_CHUNK(cart->banks[chunk.bank].sfx.samples); break;
case CHUNK_WAVEFORM: LOAD_CHUNK(cart->banks[chunk.bank].sfx.waveform); break;
case CHUNK_MUSIC: LOAD_CHUNK(cart->banks[chunk.bank].music.tracks); break;
case CHUNK_PATTERNS: LOAD_CHUNK(cart->banks[chunk.bank].music.patterns); break;
case CHUNK_PALETTE: LOAD_CHUNK(cart->banks[chunk.bank].palette); break;
case CHUNK_COVER:
LOAD_CHUNK(cart->cover.data);
cart->cover.size = chunk.size;
break;
default: break;
}
buffer += chunk.size;
}
#undef LOAD_CHUNK
}
static s32 calcBufferSize(const void* buffer, s32 size)
{
const u8* ptr = (u8*)buffer + size - 1;
const u8* end = (u8*)buffer;
while(ptr >= end)
{
if(*ptr) break;
ptr--;
size--;
}
return size;
}
static u8* saveFixedChunk(u8* buffer, ChunkType type, const void* from, s32 size, s32 bank)
{
if(size)
{
Chunk chunk = {.type = type, .bank = bank, .size = size, .temp = 0};
memcpy(buffer, &chunk, sizeof(Chunk));
buffer += sizeof(Chunk);
memcpy(buffer, from, size);
buffer += size;
}
return buffer;
}
static u8* saveChunk(u8* buffer, ChunkType type, const void* from, s32 size, s32 bank)
{
s32 chunkSize = calcBufferSize(from, size);
return saveFixedChunk(buffer, type, from, chunkSize, bank);
}
static s32 api_save(const tic_cartridge* cart, u8* buffer)
{
u8* start = buffer;
#define SAVE_CHUNK(ID, FROM, BANK) saveChunk(buffer, ID, &FROM, sizeof(FROM), BANK)
for(s32 i = 0; i < TIC_BANKS; i++)
{
buffer = SAVE_CHUNK(CHUNK_TILES, cart->banks[i].tiles, i);
buffer = SAVE_CHUNK(CHUNK_SPRITES, cart->banks[i].sprites, i);
buffer = SAVE_CHUNK(CHUNK_MAP, cart->banks[i].map, i);
buffer = SAVE_CHUNK(CHUNK_CODE, cart->banks[i].code, i);
buffer = SAVE_CHUNK(CHUNK_SAMPLES, cart->banks[i].sfx.samples, i);
buffer = SAVE_CHUNK(CHUNK_WAVEFORM, cart->banks[i].sfx.waveform, i);
buffer = SAVE_CHUNK(CHUNK_PATTERNS, cart->banks[i].music.patterns, i);
buffer = SAVE_CHUNK(CHUNK_MUSIC, cart->banks[i].music.tracks, i);
buffer = SAVE_CHUNK(CHUNK_PALETTE, cart->banks[i].palette, i);
}
buffer = saveFixedChunk(buffer, CHUNK_COVER, cart->cover.data, cart->cover.size, 0);
#undef SAVE_CHUNK
return (s32)(buffer - start);
}
// copied from SDL2
static inline void memset4(void *dst, u32 val, u32 dwords)
{
#if defined(__GNUC__) && defined(i386)
s32 u0, u1, u2;
__asm__ __volatile__ (
"cld \n\t"
"rep ; stosl \n\t"
: "=&D" (u0), "=&a" (u1), "=&c" (u2)
: "0" (dst), "1" (val), "2" (dwords)
: "memory"
);
#else
u32 _n = (dwords + 3) / 4;
u32 *_p = (u32*)dst;
u32 _val = (val);
if (dwords == 0)
return;
switch (dwords % 4)
{
case 0: do { *_p++ = _val;
case 3: *_p++ = _val;
case 2: *_p++ = _val;
case 1: *_p++ = _val;
} while ( --_n );
}
#endif
}
static void api_blit(tic_mem* tic, tic_scanline scanline, tic_overline overline, void* data)
{
const u32* pal = tic_palette_blit(&tic->ram.vram.palette);
{
tic_machine* machine = (tic_machine*)tic;
memcpy(machine->state.ovr.palette, pal, sizeof machine->state.ovr.palette);
}
if(scanline)
{
scanline(tic, 0, data);
pal = tic_palette_blit(&tic->ram.vram.palette);
}
enum {Top = (TIC80_FULLHEIGHT-TIC80_HEIGHT)/2, Bottom = Top};
enum {Left = (TIC80_FULLWIDTH-TIC80_WIDTH)/2, Right = Left};
u32* out = tic->screen;
memset4(&out[0 * TIC80_FULLWIDTH], pal[tic->ram.vram.vars.border], TIC80_FULLWIDTH*Top);
u32* rowPtr = out + (Top*TIC80_FULLWIDTH);
for(s32 r = 0; r < TIC80_HEIGHT; r++, rowPtr += TIC80_FULLWIDTH)
{
u32 *colPtr = rowPtr + Left;
memset4(rowPtr, pal[tic->ram.vram.vars.border], Left);
s32 pos = (r + tic->ram.vram.vars.offset.y + TIC80_HEIGHT) % TIC80_HEIGHT * TIC80_WIDTH >> 1;
u32 x = (-tic->ram.vram.vars.offset.x + TIC80_WIDTH) % TIC80_WIDTH;
for(s32 c = 0; c < TIC80_WIDTH / 2; c++)
{
u8 val = ((u8*)tic->ram.vram.screen.data)[pos + c];
*(colPtr + (x++ % TIC80_WIDTH)) = pal[val & 0xf];
*(colPtr + (x++ % TIC80_WIDTH)) = pal[val >> 4];
}
memset4(rowPtr + (TIC80_FULLWIDTH-Right), pal[tic->ram.vram.vars.border], Right);
if(scanline && (r < TIC80_HEIGHT-1))
{
scanline(tic, r+1, data);
pal = tic_palette_blit(&tic->ram.vram.palette);
}
}
memset4(&out[(TIC80_FULLHEIGHT-Bottom) * TIC80_FULLWIDTH], pal[tic->ram.vram.vars.border], TIC80_FULLWIDTH*Bottom);
if(overline)
overline(tic, data);
}
static void initApi(tic_api* api)
{
#define INIT_API(func) api->func = api_##func
INIT_API(draw_char);
INIT_API(text);
INIT_API(fixed_text);
INIT_API(text_ex);
INIT_API(clear);
INIT_API(pixel);
INIT_API(get_pixel);
INIT_API(line);
INIT_API(rect);
INIT_API(rect_border);
INIT_API(sprite);
INIT_API(sprite_ex);
INIT_API(map);
INIT_API(remap);
INIT_API(map_set);
INIT_API(map_get);
INIT_API(circle);
INIT_API(circle_border);
INIT_API(tri);
INIT_API(textri);
INIT_API(clip);
INIT_API(sfx);
INIT_API(sfx_stop);
INIT_API(sfx_ex);
INIT_API(sfx_pos);
INIT_API(music);
INIT_API(music_frame);
INIT_API(time);
INIT_API(tick);
INIT_API(scanline);
INIT_API(overline);
INIT_API(reset);
INIT_API(pause);
INIT_API(resume);
INIT_API(sync);
INIT_API(btnp);
INIT_API(key);
INIT_API(keyp);
INIT_API(load);
INIT_API(save);
INIT_API(tick_start);
INIT_API(tick_end);
INIT_API(blit);
INIT_API(get_script_config);
#undef INIT_API
}
tic_mem* tic_create(s32 samplerate)
{
tic_machine* machine = (tic_machine*)malloc(sizeof(tic_machine));
memset(machine, 0, sizeof(tic_machine));
if(machine != (tic_machine*)&machine->memory)
return NULL;
machine->sound.sfx = &machine->memory.ram.sfx;
machine->sound.music = &machine->memory.ram.music;
initApi(&machine->memory.api);
machine->samplerate = samplerate;
machine->memory.samples.size = samplerate / TIC_FRAMERATE * sizeof(s16);
machine->memory.samples.buffer = malloc(machine->memory.samples.size);
machine->blip = blip_new(samplerate / 10);
blip_set_rates(machine->blip, CLOCKRATE, samplerate);
machine->memory.api.reset(&machine->memory);
return &machine->memory;
}
static inline bool islineend(char c) {return c == '\n' || c == '\0';}
static inline bool isalpha_(char c) {return isalpha(c) || c == '_';}
static inline bool isalnum_(char c) {return isalnum(c) || c == '_';}
void parseCode(const tic_script_config* config, const char* start, u8* color, const tic_code_theme* theme)
{
const char* ptr = start;
const char* blockCommentStart = NULL;
const char* blockStringStart = NULL;
const char* blockStdStringStart = NULL;
const char* singleCommentStart = NULL;
const char* wordStart = NULL;
const char* numberStart = NULL;
while(true)
{
char c = ptr[0];
if(blockCommentStart)
{
const char* end = strstr(ptr, config->blockCommentEnd);
ptr = end ? end + strlen(config->blockCommentEnd) : blockCommentStart + strlen(blockCommentStart);
memset(color + (blockCommentStart - start), theme->comment, ptr - blockCommentStart);
blockCommentStart = NULL;
continue;
}
else if(blockStringStart)
{
const char* end = strstr(ptr, config->blockStringEnd);
ptr = end ? end + strlen(config->blockStringEnd) : blockStringStart + strlen(blockStringStart);
memset(color + (blockStringStart - start), theme->string, ptr - blockStringStart);
blockStringStart = NULL;
continue;
}
else if(blockStdStringStart)
{
const char* blockStart = blockStdStringStart+1;
while(true)
{
const char* pos = strchr(blockStart, *blockStdStringStart);
if(pos)
{
if(*(pos-1) == '\\' && *(pos-2) != '\\') blockStart = pos + 1;
else
{
ptr = pos + 1;
break;
}
}
else
{
ptr = blockStdStringStart + strlen(blockStdStringStart);
break;
}
}
memset(color + (blockStdStringStart - start), theme->string, ptr - blockStdStringStart);
blockStdStringStart = NULL;
continue;
}
else if(singleCommentStart)
{
while(!islineend(*ptr))ptr++;
memset(color + (singleCommentStart - start), theme->comment, ptr - singleCommentStart);
singleCommentStart = NULL;
continue;
}
else if(wordStart)
{
while(!islineend(*ptr) && isalnum_(*ptr)) ptr++;
s32 len = ptr - wordStart;
bool keyword = false;
{
for(s32 i = 0; i < config->keywordsCount; i++)
if(len == strlen(config->keywords[i]) && memcmp(wordStart, config->keywords[i], len) == 0)
{
memset(color + (wordStart - start), theme->keyword, len);
keyword = true;
break;
}
}
if(!keyword)
{
for(s32 i = 0; i < config->apiCount; i++)
if(len == strlen(config->api[i]) && memcmp(wordStart, config->api[i], len) == 0)
{
memset(color + (wordStart - start), theme->api, len);
break;
}
}
wordStart = NULL;
continue;
}
else if(numberStart)
{
while(!islineend(*ptr))
{
char c = *ptr;
if(isdigit(c)) ptr++;
else if(numberStart[0] == '0'
&& (numberStart[1] == 'x' || numberStart[1] == 'X')
&& isxdigit(numberStart[2]))
{
if((ptr - numberStart < 2) || (ptr - numberStart >= 2 && isxdigit(c))) ptr++;
else break;
}
else if(c == '.' || c == 'e' || c == 'E')
{
if(isdigit(ptr[1])) ptr++;
else break;
}
else break;
}
memset(color + (numberStart - start), theme->number, ptr - numberStart);
numberStart = NULL;
continue;
}
else
{
if(config->blockCommentStart && memcmp(ptr, config->blockCommentStart, strlen(config->blockCommentStart)) == 0)
{
blockCommentStart = ptr;
ptr += strlen(config->blockCommentStart);
continue;
}
if(config->blockStringStart && memcmp(ptr, config->blockStringStart, strlen(config->blockStringStart)) == 0)
{
blockStringStart = ptr;
ptr += strlen(config->blockStringStart);
continue;
}
else if(c == '"' || c == '\'')
{
blockStdStringStart = ptr;
ptr++;
continue;
}
else if(config->singleComment && memcmp(ptr, config->singleComment, strlen(config->singleComment)) == 0)
{
singleCommentStart = ptr;
ptr += strlen(config->singleComment);
continue;
}
else if(isalpha_(c))
{
wordStart = ptr;
ptr++;
continue;
}
else if(isdigit(c) || (c == '.' && isdigit(ptr[1])))
{
numberStart = ptr;
ptr++;
continue;
}
else if(ispunct(c)) color[ptr - start] = theme->sign;
else if(iscntrl(c)) color[ptr - start] = theme->other;
}
if(!c) break;
ptr++;
}
}
Reference in New Issue View Git Blame Copy Permalink