1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
use sdl2;
use fmt;
use io;
use endian;
use math::random;
// 2d position, x and y
export type pos = (i32, i32);
export type drawing_state = struct {
// is the mouse button held down?
drawing: bool,
pos: pos,
pictures: []picture,
// hack. change this
conn: io::file,
};
export type picture = struct {
// the surface data as u32s
d: *[*]u32,
w: size,
h: size,
// backreference to the surface whose data we're using
surf: *sdl2::SDL_Surface,
pos: pos,
};
// Returns array index of the pixel at position pos.
// Bounds check happens in here instead of using a slice type, so
// that it's easier to remove later.
export fn pidx(pic: *picture, pos: pos) size = {
const (x,y) = pos;
const (xs,ys) = (x:size, y:size);
assert(0 <= x, "x position must not be less than 0");
assert(0 <= y, "y position must not be less than 0");
assert(xs < pic.w, "x position must be less than picture width");
assert(ys < pic.h, "y position must be less than picture height");
return xs + pic.w*ys;
};
export fn pic_set(pic: *picture, pos: pos, val: u32) void =
pic.d[pidx(pic,pos)] = val;
export fn picture_from_surface(surf: *sdl2::SDL_Surface, pos: pos) picture = picture {
w = surf.w: size,
h = surf.h: size,
d = (surf.pixels as *opaque: *[*]u32),
surf = surf,
pos = pos,
};
export fn clear_picture(pic: *picture, color: u32) void = {
for (let i = 0z; i < pic.w*pic.h; i+=1) pic.d[i] = color;
};
export fn outline_picture(pic: *picture) void = {
for (let x = 0; x:size < pic.w; x+=1) {
pic_set(pic, (x, 0), 0);
pic_set(pic, (x, pic.h:int-1), 0);
};
for (let y = 0; y:size < pic.h; y+=1) {
pic_set(pic, (0, y), 0);
pic_set(pic, (pic.w:int-1, y), 0);
};
};
fn min(a: i32, b: i32) i32 = if (a<b) a else b;
fn max(a: i32, b: i32) i32 = if (a<b) b else a;
// Draws a circle onto the picture, at given position radius color
// Clips at the boundaries of the picture to avoid overflow.
export fn circle(picture: *picture, c: pos, r: i32, color: u32) void = {
// fmt::printfln("C {} {} {} {:x}",c.0,c.1,r,color)!;
const (cx,cy) = c;
const ymin = max(0, cy-r);
const ymax = min(picture.h:i32-1, cy+r);
const xmin = max(0, cx-r);
const xmax = min(picture.w:i32-1, cx+r);
const r2 = r*r + r;
for (let y = ymin; y<=ymax; y+=1) {
const yd = y-cy;
for (let x = xmin; x<=xmax; x+=1) {
const xd = x-cx;
if (yd*yd + xd*xd <= r2) {
pic_set(picture, (x,y), color);
};
};
};
};
export fn do_drawing(dstate: *drawing_state) void = {
if (dstate.drawing) {
for (let i = 0z; i < 4; i+=1) {
const pic = &dstate.pictures[i];
const p = (dstate.pos.0 - pic.pos.0, dstate.pos.1 - pic.pos.1);
circle(pic, p, 20, 0xff0088);
};
// hack, change this
// let buf: [8]u8 = [0...];
// fmt::printfln("C {},{}",dstate.pos.0,dstate.pos.1)!;
// endian::leputu32(buf[0..4],dstate.pos.0: u32);
// endian::leputu32(buf[4..8],dstate.pos.1: u32);
// io::write(dstate.conn, buf)!;
static let rand: u64 = 12345;
static let cur = 0;
let buf: [20]u8 = [0...];
const n = random::u32n(&rand, 10) : int;
for (let i = 0; i < n; i += 1) {
buf[i] = (cur+i) : u8;
};
cur += n;
fmt::println(n)!;
io::writeall(dstate.conn, buf[..n])!;
};
};
|
