rustraight 0.6.4

A simple 2D game library for Rust, inspired by DXLib
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

// draw.rs — 図形描画の実装。GPU に渡す三角形頂点列を生成する(`verts_*`)。

use crate::geometry2d::Vec2;

/// RGBA カラー（各チャンネル 0-255）。
#[derive(Clone, Copy)]
pub struct Color {
    pub r: u8,
    pub g: u8,
    pub b: u8,
    pub a: u8,
}

impl Color {
    pub const fn rgb(r: u8, g: u8, b: u8) -> Self { Self { r, g, b, a: 255 } }
    pub const fn rgba(r: u8, g: u8, b: u8, a: u8) -> Self { Self { r, g, b, a } }

    pub const WHITE:   Color = Color::rgb(255, 255, 255);
    pub const BLACK:   Color = Color::rgb(0,   0,   0  );
    pub const RED:     Color = Color::rgb(255, 0,   0  );
    pub const GREEN:   Color = Color::rgb(0,   255, 0  );
    pub const BLUE:    Color = Color::rgb(0,   0,   255);
    pub const YELLOW:  Color = Color::rgb(255, 255, 0  );
    pub const CYAN:    Color = Color::rgb(0,   255, 255);
    pub const MAGENTA: Color = Color::rgb(255, 0,   255);
}

// ── GPU vertex generation ──────────────────────────────────────────────────────
// wgpu にそのまま流し込める三角形リストを生成する関数群。
// ピクセル座標 → NDC（正規化デバイス座標、-1..1）への変換は to_ndc() が担う。

#[repr(C)]
#[derive(Copy, Clone)]
pub(crate) struct ColorVert {
    pub pos:   [f32; 2],
    pub color: [f32; 4],
}

/// ピクセル座標 (px, py) をスクリーンサイズ (sw, sh) 基準で NDC 座標に変換する。
pub(crate) fn to_ndc(px: f32, py: f32, sw: u32, sh: u32) -> [f32; 2] {
    [px / sw as f32 * 2.0 - 1.0, 1.0 - py / sh as f32 * 2.0]
}

/// Color を 0.0-1.0 の浮動小数点 RGBA に変換する。
fn cf(c: Color) -> [f32; 4] {
    [c.r as f32 / 255.0, c.g as f32 / 255.0, c.b as f32 / 255.0, c.a as f32 / 255.0]
}

/// 矩形1つ分の頂点（2三角形=6頂点）を追加する。
fn push_quad(v: &mut Vec<ColorVert>, x0: f32, y0: f32, x1: f32, y1: f32, sw: u32, sh: u32, c: Color) {
    let col = cf(c);
    for (x, y) in [(x0,y0),(x1,y0),(x0,y1),(x1,y0),(x1,y1),(x0,y1)] {
        v.push(ColorVert { pos: to_ndc(x, y, sw, sh), color: col });
    }
}

/// 太さ1ピクセル相当の線分を、進行方向に垂直な矩形（2三角形）として追加する。
fn push_line(v: &mut Vec<ColorVert>, x0: f32, y0: f32, x1: f32, y1: f32, sw: u32, sh: u32, c: Color) {
    let p0 = Vec2::new(x0, y0);
    let p1 = Vec2::new(x1, y1);
    let dir = p1 - p0;
    if dir.length() < 0.5 { push_quad(v, x0, y0, x0+1.0, y0+1.0, sw, sh, c); return; }
    let n = dir.normalize().perp(); // 進行方向に垂直な単位法線ベクトル
    let col = cf(c);
    for p in [p0+n, p1+n, p0-n, p1+n, p1-n, p0-n] {
        v.push(ColorVert { pos: to_ndc(p.x, p.y, sw, sh), color: col });
    }
}

/// 画面全体を塗りつぶす矩形の頂点を生成する。
pub(crate) fn verts_fill(sw: u32, sh: u32, c: Color) -> Vec<ColorVert> {
    let mut v = Vec::with_capacity(6);
    push_quad(&mut v, 0.0, 0.0, sw as f32, sh as f32, sw, sh, c);
    v
}

/// 1ピクセル分の頂点を生成する。
pub(crate) fn verts_pixel(x: i32, y: i32, sw: u32, sh: u32, c: Color) -> Vec<ColorVert> {
    let mut v = Vec::with_capacity(6);
    push_quad(&mut v, x as f32, y as f32, x as f32 + 1.0, y as f32 + 1.0, sw, sh, c);
    v
}

/// 線分の頂点を生成する。
pub(crate) fn verts_line(x1: i32, y1: i32, x2: i32, y2: i32, sw: u32, sh: u32, c: Color) -> Vec<ColorVert> {
    let mut v = Vec::with_capacity(6);
    push_line(&mut v, x1 as f32, y1 as f32, x2 as f32, y2 as f32, sw, sh, c);
    v
}

/// 矩形の頂点を生成する（`filled` = true で塗りつぶし、false で4辺を1px幅の矩形として生成）。
pub(crate) fn verts_rectangle(x: i32, y: i32, w: i32, h: i32, sw: u32, sh: u32, c: Color, filled: bool) -> Vec<ColorVert> {
    let mut v = Vec::new();
    if filled {
        push_quad(&mut v, x as f32, y as f32, (x+w) as f32, (y+h) as f32, sw, sh, c);
    } else {
        push_quad(&mut v, x as f32,       y as f32,       (x+w) as f32,   y as f32 + 1.0,    sw, sh, c);
        push_quad(&mut v, x as f32,       (y+h-1) as f32, (x+w) as f32,   (y+h) as f32,       sw, sh, c);
        push_quad(&mut v, x as f32,       (y+1) as f32,   x as f32 + 1.0, (y+h-1) as f32,     sw, sh, c);
        push_quad(&mut v, (x+w-1) as f32, (y+1) as f32,   (x+w) as f32,   (y+h-1) as f32,     sw, sh, c);
    }
    v
}

/// 三角形の頂点を生成する（`filled` = true で塗りつぶし1枚、false で3辺の線分）。
pub(crate) fn verts_triangle(x1: i32, y1: i32, x2: i32, y2: i32, x3: i32, y3: i32, sw: u32, sh: u32, c: Color, filled: bool) -> Vec<ColorVert> {
    let col = cf(c);
    let mut v = Vec::new();
    if filled {
        for (x, y) in [(x1,y1),(x2,y2),(x3,y3)] {
            v.push(ColorVert { pos: to_ndc(x as f32, y as f32, sw, sh), color: col });
        }
    } else {
        push_line(&mut v, x1 as f32, y1 as f32, x2 as f32, y2 as f32, sw, sh, c);
        push_line(&mut v, x2 as f32, y2 as f32, x3 as f32, y3 as f32, sw, sh, c);
        push_line(&mut v, x3 as f32, y3 as f32, x1 as f32, y1 as f32, sw, sh, c);
    }
    v
}

/// 円の頂点を生成する。円周を n 個の線分に近似し、塗りつぶしは扇形三角形、
/// 枠線は各線分を push_line() で生成する。n は半径に応じて 16〜256 に調整する。
pub(crate) fn verts_circle(cx: i32, cy: i32, radius: i32, sw: u32, sh: u32, c: Color, filled: bool) -> Vec<ColorVert> {
    let col = cf(c);
    let center = Vec2::new(cx as f32, cy as f32);
    let r = radius.max(1) as f32;
    let n = (radius * 4).clamp(16, 256) as usize;
    let mut v = Vec::with_capacity(if filled { n * 3 } else { n * 6 });
    for i in 0..n {
        let a0 = i       as f32 / n as f32 * std::f32::consts::TAU;
        let a1 = (i + 1) as f32 / n as f32 * std::f32::consts::TAU;
        let p0 = center + Vec2::from_angle(a0) * r;
        let p1 = center + Vec2::from_angle(a1) * r;
        if filled {
            v.push(ColorVert { pos: to_ndc(center.x, center.y, sw, sh), color: col });
            v.push(ColorVert { pos: to_ndc(p0.x, p0.y, sw, sh), color: col });
            v.push(ColorVert { pos: to_ndc(p1.x, p1.y, sw, sh), color: col });
        } else {
            push_line(&mut v, p0.x, p0.y, p1.x, p1.y, sw, sh, c);
        }
    }
    v
}