mirror of
https://github.com/exoticorn/microw8.git
synced 2026-01-20 11:16:42 +01:00
771 lines
18 KiB
Plaintext
771 lines
18 KiB
Plaintext
import "env.memory" memory(4);
|
||
|
||
import "env.sin" fn sin(f32) -> f32;
|
||
import "env.cos" fn cos(f32) -> f32;
|
||
import "env.pow" fn pow(f32, f32) -> f32;
|
||
import "env.exp" fn exp(f32) -> f32;
|
||
import "env.logChar" fn logChar(i32);
|
||
|
||
export fn time() -> f32 {
|
||
(0!64) as f32 / 1000 as f32
|
||
}
|
||
|
||
///////////
|
||
// INPUT //
|
||
///////////
|
||
|
||
export fn isButtonPressed(btn: i32) -> i32 {
|
||
(68!0 >> btn) & 1
|
||
}
|
||
|
||
export fn isButtonTriggered(btn: i32) -> i32 {
|
||
((68!0 & (-1 - 68!4)) >> btn) & 1
|
||
}
|
||
|
||
////////////
|
||
// RANDOM //
|
||
////////////
|
||
|
||
global mut randomState: i64 = 37i64;
|
||
|
||
export fn random() -> i32 {
|
||
(random64() >> 32i64) as i32
|
||
}
|
||
|
||
export fn random64() -> i64 {
|
||
let lazy state = randomState ^ (randomState #>> 12i64);
|
||
let lazy state = state ^ (state << 25i64);
|
||
randomState = state ^ (state #>> 27i64);
|
||
randomState * 0x2545f4914f6cdd1di64
|
||
}
|
||
|
||
export fn randomf() -> f32 {
|
||
f32.reinterpret_i32(0x3f800000 | (random() #>> 9)) - 1 as f32
|
||
}
|
||
|
||
export fn randomSeed(s: i32) {
|
||
randomState = (s as i64 << 32i64) ^ ((63 - s) as i64);
|
||
randomState = random64();
|
||
randomState = random64();
|
||
}
|
||
|
||
export fn fmod(a: f32, b: f32) -> f32 {
|
||
a - floor(a / b) * b
|
||
}
|
||
|
||
/////////////
|
||
// DRAWING //
|
||
/////////////
|
||
|
||
export fn cls(col: i32) {
|
||
let i: i32;
|
||
textCursorX = 0;
|
||
textCursorY = 0;
|
||
outputChannel = 0;
|
||
memory.fill(120, col, 320*240);
|
||
}
|
||
|
||
export fn setPixel(x: i32, y: i32, col: i32) {
|
||
if x #< 320 & y #< 240 {
|
||
(x + y * 320)?120 = col
|
||
}
|
||
}
|
||
|
||
export fn getPixel(x: i32, y: i32) -> i32 {
|
||
if x #< 320 & y #< 240 {
|
||
(x + y * 320)?120
|
||
} else {
|
||
0
|
||
}
|
||
}
|
||
|
||
fn clamp(v: i32, min: i32, max: i32) -> i32 {
|
||
select(v < min, min, select(v > max, max, v))
|
||
}
|
||
|
||
export fn hline(x1: i32, x2: i32, y: i32, col: i32) {
|
||
x1 = clamp(x1, 0, 320);
|
||
x2 = clamp(x2, 0, 320);
|
||
if y #>= 240 {
|
||
return;
|
||
}
|
||
let word_start = (x1 + 3) & -4;
|
||
let word_end = x2 & -4;
|
||
if word_end > word_start {
|
||
col = (col & 255) * 0x1010101;
|
||
let ptr = y * 320 + x1;
|
||
let end = ptr + word_start - x1;
|
||
if ptr + 2 <= end {
|
||
ptr?120 = col;
|
||
ptr?121 = col;
|
||
ptr += 2;
|
||
}
|
||
if ptr < end {
|
||
ptr?120 = col;
|
||
ptr += 1;
|
||
}
|
||
end += word_end - word_start;
|
||
loop words {
|
||
if ptr + 16 <= end {
|
||
ptr!120 = col;
|
||
ptr!124 = col;
|
||
ptr!128 = col;
|
||
ptr!132 = col;
|
||
ptr += 16;
|
||
branch words;
|
||
}
|
||
if ptr + 8 <= end {
|
||
ptr!120 = col;
|
||
ptr!124 = col;
|
||
ptr += 8;
|
||
}
|
||
if ptr < end {
|
||
ptr!120 = col;
|
||
ptr += 4;
|
||
}
|
||
}
|
||
end += x2 - word_end;
|
||
if ptr + 2 <= end {
|
||
ptr?120 = col;
|
||
ptr?121 = col;
|
||
ptr += 2;
|
||
}
|
||
if ptr < end {
|
||
ptr?120 = col;
|
||
}
|
||
} else {
|
||
let ptr = y * 320 + x1;
|
||
let end = ptr + x2 - x1;
|
||
if ptr + 4 <= end {
|
||
ptr?120 = col;
|
||
ptr?121 = col;
|
||
ptr?122 = col;
|
||
ptr?123 = col;
|
||
ptr += 4;
|
||
}
|
||
if ptr + 2 <= end {
|
||
ptr?120 = col;
|
||
ptr?121 = col;
|
||
ptr += 2;
|
||
}
|
||
if ptr < end {
|
||
ptr?120 = col;
|
||
}
|
||
}
|
||
}
|
||
|
||
export fn rectangle(x: f32, y: f32, w: f32, h: f32, col: i32) {
|
||
if abs(w) == w & abs(h) == h {
|
||
let x1 = nearest(x) as i32;
|
||
let y1 = clamp(nearest(y) as i32, 0, 240);
|
||
let x2 = nearest(x + w) as i32;
|
||
let y2 = clamp(nearest(y + h) as i32, 0, 240);
|
||
block done {
|
||
loop lines {
|
||
branch_if y1 >= y2: done;
|
||
hline(x1, x2, y1, col);
|
||
y1 = y1 + 1;
|
||
branch lines;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
export fn rectangleOutline(x: f32, y: f32, w: f32, h: f32, col: i32) {
|
||
let xl = nearest(x) as i32;
|
||
let xr = nearest(x + w) as i32;
|
||
let yt = nearest(y) as i32;
|
||
let yb = nearest(y + h) as i32;
|
||
|
||
hline(xl, xr, yt, col);
|
||
if yt < yb {
|
||
hline(xl, xr, yb - 1, col);
|
||
|
||
loop y {
|
||
setPixel(xl, yt, col);
|
||
if xl < xr {
|
||
setPixel(xr - 1, yt, col);
|
||
}
|
||
branch_if (yt := yt + 1) < yb: y;
|
||
}
|
||
}
|
||
}
|
||
|
||
export fn circle(cx: f32, cy: f32, radius: f32, col: i32) {
|
||
let y = clamp(nearest(cy - radius) as i32, 0, 240);
|
||
let maxY = clamp(nearest(cy + radius) as i32, 0, 240);
|
||
|
||
block done {
|
||
loop lines {
|
||
branch_if y >= maxY: done;
|
||
|
||
let lazy dy = y as f32 - cy + 0.5;
|
||
let lazy q = radius * radius - dy * dy;
|
||
if abs(q) == q {
|
||
let lazy w = sqrt(q);
|
||
hline(nearest(cx - w) as i32, nearest(cx + w) as i32, y, col);
|
||
}
|
||
|
||
y = y + 1;
|
||
branch lines;
|
||
}
|
||
}
|
||
}
|
||
|
||
export fn circleOutline(cx: f32, cy: f32, radius: f32, col: i32) {
|
||
let prev_w: f32;
|
||
let y = clamp(nearest(cy - radius) as i32, -1, 241);
|
||
let maxY = clamp(nearest(cy + radius) as i32, -1, 241);
|
||
|
||
loop lines {
|
||
let lazy dy = y as f32 - cy + 0.5;
|
||
let inline q = radius * radius - dy * dy;
|
||
let w = sqrt(max(0 as f32, q));
|
||
|
||
let xlp = nearest(cx - prev_w) as i32;
|
||
let xl = nearest(cx - w) as i32;
|
||
let xrp = nearest(cx + prev_w) as i32;
|
||
let xr = nearest(cx + w) as i32;
|
||
if w >= prev_w {
|
||
if xl < xlp {
|
||
hline(xl, xlp, y, col);
|
||
} else {
|
||
if xl < xr {
|
||
setPixel(xl, y, col);
|
||
}
|
||
}
|
||
if xr > xrp {
|
||
hline(xrp, xr, y, col);
|
||
} else {
|
||
if xl < xr {
|
||
setPixel(xr - 1, y, col);
|
||
}
|
||
}
|
||
} else {
|
||
if xl > xlp {
|
||
hline(xlp, xl, y - 1, col);
|
||
} else {
|
||
if xlp < xrp {
|
||
setPixel(xlp, y - 1, col);
|
||
}
|
||
}
|
||
if xr < xrp {
|
||
hline(xr, xrp, y - 1, col);
|
||
} else {
|
||
if xlp < xrp {
|
||
setPixel(xrp - 1, y - 1, col);
|
||
}
|
||
}
|
||
}
|
||
|
||
y = y + 1;
|
||
prev_w = w;
|
||
branch_if y <= maxY: lines;
|
||
}
|
||
}
|
||
|
||
export fn line(x1: f32, y1: f32, x2: f32, y2: f32, col: i32) {
|
||
let swapTmp: f32;
|
||
if x1 > x2 {
|
||
swapTmp = x1;
|
||
x1 = x2;
|
||
x2 = swapTmp;
|
||
swapTmp = y1;
|
||
y1 = y2;
|
||
y2 = swapTmp;
|
||
}
|
||
if x1 < 0 as f32 & x2 >= 0 as f32 {
|
||
y1 = y1 + (y2 - y1) * -x1 / (x2 - x1);
|
||
x1 = 0 as f32;
|
||
}
|
||
if x1 < 320 as f32 & x2 >= 320 as f32 {
|
||
y2 = y2 + (y2 - y1) * (320 as f32 - x2) / (x2 - x1);
|
||
x2 = 320 as f32;
|
||
}
|
||
|
||
if y1 > y2 {
|
||
swapTmp = x1;
|
||
x1 = x2;
|
||
x2 = swapTmp;
|
||
swapTmp = y1;
|
||
y1 = y2;
|
||
y2 = swapTmp;
|
||
}
|
||
if y1 < 0 as f32 & y2 >= 0 as f32 {
|
||
x1 = x1 + (x2 - x1) * -y1 / (y2 - y1);
|
||
y1 = 0 as f32;
|
||
}
|
||
if y1 < 240 as f32 & y2 >= 240 as f32 {
|
||
x2 = x2 + (x2 - x1) * (240 as f32 - y2) / (y2 - y1);
|
||
y2 = 240 as f32;
|
||
}
|
||
|
||
let lazy dx = x2 - x1;
|
||
let lazy dy = y2 - y1;
|
||
let max_axis: f32;
|
||
let p: f32;
|
||
if abs(dx) >= dy {
|
||
max_axis = dx;
|
||
p = x1;
|
||
} else {
|
||
max_axis = dy;
|
||
p = y1;
|
||
}
|
||
|
||
if max_axis == 0 as f32 {
|
||
setPixel(x1 as i32, y1 as i32, col);
|
||
return;
|
||
}
|
||
|
||
let steps = floor(p + max_axis) as i32 - floor(p) as i32;
|
||
p = floor(p) + 0.5 - p;
|
||
if max_axis < 0 as f32 {
|
||
steps = -steps;
|
||
p = -p;
|
||
max_axis = -max_axis;
|
||
}
|
||
dx = dx / max_axis;
|
||
dy = dy / max_axis;
|
||
|
||
let f = min(max_axis, max(0 as f32, p));
|
||
setPixel(i32.trunc_sat_f32_s(x1 + f * dx), i32.trunc_sat_f32_s(y1 + f * dy), col);
|
||
|
||
if !steps {
|
||
return;
|
||
}
|
||
|
||
x1 = x1 + (1 as f32 + p) * dx;
|
||
y1 = y1 + (1 as f32 + p) * dy;
|
||
|
||
p = p + steps as f32;
|
||
|
||
loop pixels {
|
||
if steps := steps - 1 {
|
||
setPixel(i32.trunc_sat_f32_s(x1), i32.trunc_sat_f32_s(y1), col);
|
||
x1 = x1 + dx;
|
||
y1 = y1 + dy;
|
||
branch pixels;
|
||
}
|
||
}
|
||
|
||
f = min(max_axis, p) - p;
|
||
setPixel(i32.trunc_sat_f32_s(x1 + f * dx), i32.trunc_sat_f32_s(y1 + f * dy), col);
|
||
}
|
||
|
||
export fn blitSprite(sprite: i32, size: i32, x: i32, y: i32, control: i32) {
|
||
let lazy width = size & 65535;
|
||
let lazy height = select(size >> 16, size >> 16, width);
|
||
|
||
let lazy x0 = select(x < 0, -x, 0);
|
||
let lazy x1 = select(x + width > 320, 320 - x, width);
|
||
let lazy y0 = select(y < 0, -y, 0);
|
||
let lazy y1 = select(y + height > 240, 240 - y, height);
|
||
|
||
let lazy numRows = y1 - y0;
|
||
let lazy numCols = x1 - x0;
|
||
if numRows <= 0 | numCols <= 0 {
|
||
return;
|
||
}
|
||
|
||
let trans = (control & 511) - 256;
|
||
let lazy flip_x = 1 - ((control >> 8) & 2);
|
||
let lazy flip_y = 1 - ((control >> 9) & 2);
|
||
if flip_x < 0 {
|
||
sprite += width - 1;
|
||
}
|
||
if flip_y < 0 {
|
||
sprite += (height - 1) * width;
|
||
}
|
||
|
||
let spriteRow = sprite + x0 * flip_x + y0 * flip_y * width;
|
||
let screenRow = x + x0 + (y + y0) * 320;
|
||
|
||
loop yloop {
|
||
let lx = 0;
|
||
loop xloop {
|
||
let lazy col = (spriteRow + lx * flip_x)?0;
|
||
if col != trans {
|
||
(screenRow + lx)?120 = col;
|
||
}
|
||
branch_if (lx +:= 1) < numCols: xloop;
|
||
}
|
||
spriteRow += width * flip_y;
|
||
screenRow += 320;
|
||
branch_if numRows -:= 1: yloop;
|
||
}
|
||
}
|
||
|
||
export fn grabSprite(sprite: i32, size: i32, x: i32, y: i32, control: i32) {
|
||
let lazy width = size & 65535;
|
||
let lazy height = select(size >> 16, size >> 16, width);
|
||
|
||
let lazy x0 = select(x < 0, -x, 0);
|
||
let lazy x1 = select(x + width > 320, 320 - x, width);
|
||
let lazy y0 = select(y < 0, -y, 0);
|
||
let lazy y1 = select(y + height > 240, 240 - y, height);
|
||
|
||
let lazy numRows = y1 - y0;
|
||
let lazy numCols = x1 - x0;
|
||
if numRows <= 0 | numCols <= 0 {
|
||
return;
|
||
}
|
||
|
||
let trans = (control & 511) - 256;
|
||
let lazy flip_x = 1 - ((control >> 8) & 2);
|
||
let lazy flip_y = 1 - ((control >> 9) & 2);
|
||
if flip_x < 0 {
|
||
sprite += width - 1;
|
||
}
|
||
if flip_y < 0 {
|
||
sprite += (height - 1) * width;
|
||
}
|
||
|
||
let spriteRow = sprite + x0 * flip_x + y0 * flip_y * width;
|
||
let screenRow = x + x0 + (y + y0) * 320;
|
||
|
||
loop yloop {
|
||
let lx = 0;
|
||
loop xloop {
|
||
let lazy col = (screenRow + lx)?120;
|
||
if col != trans {
|
||
(spriteRow + lx * flip_x)?0 = col;
|
||
}
|
||
branch_if (lx +:= 1) < numCols: xloop;
|
||
}
|
||
spriteRow += width * flip_y;
|
||
screenRow += 320;
|
||
branch_if numRows -:= 1: yloop;
|
||
}
|
||
}
|
||
|
||
//////////
|
||
// TEXT //
|
||
//////////
|
||
|
||
global mut textCursorX = 0;
|
||
global mut textCursorY = 0;
|
||
global mut textColor = 15;
|
||
global mut bgColor = 0;
|
||
global mut outputChannel = 0;
|
||
global mut textScale = 1;
|
||
|
||
export fn printChar(char: i32) {
|
||
loop chars {
|
||
printSingleChar(char & 255);
|
||
branch_if (char := char #>> 8): chars;
|
||
}
|
||
}
|
||
|
||
global mut controlCodeLength = 0;
|
||
|
||
fn printSingleChar(char: i32) {
|
||
let charSize = 8 * textScale;
|
||
|
||
if outputChannel >= 2 & (char < 4 | char > 6) {
|
||
logChar(char);
|
||
return;
|
||
}
|
||
|
||
controlCodeLength?0x12d20 = char;
|
||
controlCodeLength = controlCodeLength + 1;
|
||
char = 0x12d20?0;
|
||
if char < 32 & controlCodeLength < char?0x12d00 {
|
||
return;
|
||
}
|
||
controlCodeLength = 0;
|
||
|
||
if char == 1 {
|
||
drawChar(0x12d20?1);
|
||
return;
|
||
}
|
||
|
||
if char >= 4 & char <= 6 {
|
||
outputChannel = char - 4;
|
||
if !outputChannel {
|
||
textCursorX = 0;
|
||
textCursorY = 0;
|
||
}
|
||
return;
|
||
}
|
||
|
||
if char == 7 {
|
||
80?0 = 80?0 ^ 2;
|
||
return;
|
||
}
|
||
|
||
if char == 8 {
|
||
textCursorX = textCursorX - charSize;
|
||
if !outputChannel & textCursorX < 0 {
|
||
textCursorX = 320-charSize;
|
||
printSingleChar(11);
|
||
}
|
||
return;
|
||
}
|
||
|
||
if char == 9 {
|
||
if !outputChannel & textCursorX >= 320 {
|
||
printChar(0xd0a);
|
||
}
|
||
textCursorX = textCursorX + charSize;
|
||
return;
|
||
}
|
||
|
||
if char == 10 {
|
||
textCursorY = textCursorY + charSize;
|
||
if !outputChannel & textCursorY >= 240 {
|
||
textCursorY = 240 - charSize;
|
||
let i: i32;
|
||
loop scroll_copy {
|
||
i!120 = (i + 320 * charSize)!120;
|
||
branch_if (i := i + 4) < 320 * (240 - charSize): scroll_copy;
|
||
}
|
||
rectangle(0 as f32, (240 - charSize) as f32, 320 as f32, charSize as f32, bgColor);
|
||
}
|
||
return;
|
||
}
|
||
|
||
if char == 11 {
|
||
textCursorY = textCursorY - charSize;
|
||
if !outputChannel & textCursorY < 0 {
|
||
textCursorY = 0;
|
||
let i = 320 * (240 - charSize);
|
||
loop scroll_copy {
|
||
(i + 320 * charSize)!116 = i!116;
|
||
branch_if (i := i - 4): scroll_copy;
|
||
}
|
||
rectangle(0 as f32, 0 as f32, 320 as f32, charSize as f32, bgColor);
|
||
}
|
||
return;
|
||
}
|
||
|
||
if char == 12 {
|
||
cls(bgColor);
|
||
return;
|
||
}
|
||
|
||
if char == 13 {
|
||
textCursorX = 0;
|
||
return;
|
||
}
|
||
|
||
if char == 14 {
|
||
bgColor = 0x12d20?1;
|
||
return;
|
||
}
|
||
|
||
if char == 15 {
|
||
textColor = 0x12d20?1;
|
||
return;
|
||
}
|
||
|
||
if char == 24 {
|
||
let tmp = textColor;
|
||
textColor = bgColor;
|
||
bgColor = tmp;
|
||
return;
|
||
}
|
||
|
||
if char == 30 {
|
||
let scale = 0x12d20?1;
|
||
textScale = select(scale > 0 & scale <= 16, scale, 1);
|
||
return;
|
||
}
|
||
|
||
if char == 31 {
|
||
textCursorX = 0x12d20?1 * (8 - outputChannel * 6);
|
||
textCursorY = 0x12d20?2 * (8 - outputChannel * 7);
|
||
return;
|
||
}
|
||
|
||
if char < 31 {
|
||
return;
|
||
}
|
||
|
||
drawChar(char);
|
||
}
|
||
|
||
data(0x12d00) {
|
||
i8(
|
||
1, 2, 1, 1, // 0-3
|
||
1, 1, 1, 1, // 4-7
|
||
1, 1, 1, 1, // 8-11
|
||
1, 1, 2, 2, // 12-15,
|
||
1, 1, 1, 1, // 16-19,
|
||
1, 1, 1, 1, // 20-23,
|
||
1, 1, 1, 1, // 24-27,
|
||
1, 1, 2, 3 // 28-31
|
||
)
|
||
}
|
||
|
||
fn drawChar(char: i32) {
|
||
if !outputChannel & textCursorX >= 320 {
|
||
printChar(0xd0a);
|
||
}
|
||
|
||
let charSize = 8 * textScale;
|
||
|
||
let y: i32;
|
||
loop rows {
|
||
let bits = (char * 8 + y / textScale)?0x13400;
|
||
let x = 0;
|
||
if outputChannel {
|
||
loop pixels {
|
||
if (bits << (x / textScale)) & 128 {
|
||
setPixel(textCursorX + x, textCursorY + y, textColor);
|
||
}
|
||
branch_if (x := x + 1) < charSize: pixels;
|
||
}
|
||
} else {
|
||
loop pixels {
|
||
setPixel(textCursorX + x, textCursorY + y, select((bits << (x / textScale)) & 128, textColor, bgColor));
|
||
branch_if (x := x + 1) < charSize: pixels;
|
||
}
|
||
}
|
||
branch_if (y := y + 1) < charSize: rows;
|
||
}
|
||
textCursorX = textCursorX + charSize;
|
||
}
|
||
|
||
export fn printString(ptr: i32) {
|
||
loop chars {
|
||
let lazy char = ptr?0;
|
||
if char {
|
||
printChar(char);
|
||
ptr = ptr + 1;
|
||
branch chars;
|
||
}
|
||
}
|
||
}
|
||
|
||
export fn printInt(num: i32) {
|
||
let lazy p = 0x12fff;
|
||
p?0 = 0;
|
||
if num < 0 {
|
||
printChar(45);
|
||
num = -num;
|
||
}
|
||
loop digits {
|
||
(p := p - 1)?0 = 48 + num #% 10;
|
||
branch_if (num := num #/ 10): digits;
|
||
}
|
||
printString(p);
|
||
}
|
||
|
||
export fn setTextColor(col: i32) {
|
||
textColor = col;
|
||
}
|
||
|
||
export fn setBackgroundColor(col: i32) {
|
||
bgColor = col;
|
||
}
|
||
|
||
export fn setCursorPosition(x: i32, y: i32) {
|
||
let lazy scale = select(outputChannel, 1, 8);
|
||
textCursorX = x * scale;
|
||
textCursorY = y * scale;
|
||
}
|
||
|
||
///////////
|
||
// SOUND //
|
||
///////////
|
||
|
||
include "ges.cwa"
|
||
|
||
export fn playNote(channel: i32, note: i32) {
|
||
(channel * 6)?80 = (channel * 6)?80 & 0xfe ^ if note {
|
||
(channel * 6)?83 = note & 127;
|
||
2 | !(note >> 7)
|
||
} else {
|
||
0
|
||
};
|
||
}
|
||
|
||
data 80 {
|
||
i8(
|
||
0x80, 0xc0, 0, 81, 0xa0, 0x50,
|
||
0xc4, 0, 0, 69, 0x60, 0x40,
|
||
0x44, 0xb0, 0, 69, 0x90, 0x43,
|
||
0x4, 0xf0, 0, 69, 0xa4, 0x44,
|
||
0xff, 0xff,
|
||
1, 1, 0, 100, 0, 100
|
||
)
|
||
}
|
||
|
||
///////////
|
||
// SETUP //
|
||
///////////
|
||
|
||
export fn endFrame() {
|
||
68!4 = 68!0;
|
||
}
|
||
|
||
start fn setup() {
|
||
let i: i32 = 12*16*3-1;
|
||
let avg: f32;
|
||
loop gradients {
|
||
let lazy scale = (i % 48) as f32 / 48 as f32;
|
||
let inline angle = i as f32 * (3.1416 / 1.5 - 3.1416 / (11.0 * 16.0 * 1.5));
|
||
let lazy c = 0.4 - cos(angle);
|
||
let inline ulimit = avg + 0.8;
|
||
let inline llimit = avg - 0.8;
|
||
let lazy a = max(llimit, min(ulimit, c)) * (scale + 0.05);
|
||
let lazy b = scale * scale * 0.8;
|
||
let inline v = (select(i < 11*16*3, max(0 as f32, min(a + b - a * b, 1 as f32)), scale) * 255 as f32) as i32;
|
||
(i%3 + i/3*4)?0x13000 = v;
|
||
avg = (avg + c) * 0.5;
|
||
|
||
branch_if i := i - 1: gradients;
|
||
}
|
||
|
||
i = 255;
|
||
loop expand_sweetie {
|
||
let lazy channel = i & 3;
|
||
let lazy index = i >> 2;
|
||
let lazy first_step = index >= 32;
|
||
let inline src1 = select(first_step, index % 32 / 2, index * 2);
|
||
let inline src2 = select(first_step, (index + 1) % 32 / 2, index * 2 + 1);
|
||
let inline c1 = (src1 * 4 + channel)?(0x13000+192*4);
|
||
let inline c2 = (src2 * 4 + channel)?(0x13000+192*4);
|
||
i?(0x13000+192*4) = (c1 + c2) * (3 + first_step) / 8;
|
||
|
||
branch_if (i := i - 1) >= 0: expand_sweetie;
|
||
}
|
||
|
||
memory.fill(0, 0, 64);
|
||
memory.fill(112, 0, 8);
|
||
memory.fill(0x14000, 0, 0x2c000);
|
||
|
||
|
||
cls(0);
|
||
randomSeed(random());
|
||
}
|
||
|
||
data 0x12c78 {
|
||
i32(80)
|
||
}
|
||
|
||
data 0x13000+192*4 {
|
||
i32(
|
||
0x2c1c1a,
|
||
0x5d275d,
|
||
0x533eb1,
|
||
0x577def,
|
||
0x75cdff,
|
||
0x70f0a7,
|
||
0x64b738,
|
||
0x797125,
|
||
0x6f3629,
|
||
0xc95d3b,
|
||
0xf6a641,
|
||
0xf7ef73,
|
||
0xf4f4f4,
|
||
0xc2b094,
|
||
0x866c56,
|
||
0x573c33
|
||
)
|
||
}
|
||
|
||
data 0x13400 {
|
||
file("../target/font.bin")
|
||
}
|