# 内存映射

## 杂

所有值都是小尾数，因此较小的数字存储在较小的地址上。

| 抵消   | 尺寸        | 描述                                                                |
|--------|-----------:|--------------------------------------------------------------------|
|  00000 |          1 | MEG-4 固件版本主要                                                   |
|  00001 |          1 | MEG-4 固件版本次要                                                   |
|  00002 |          1 | MEG-4 固件版本错误修正                                               |
|  00003 |          1 | 性能计数器，最后一帧的未花费时间（以 1/1000 秒为单位）                    |
|  00004 |          4 | 自通电以来的 1/1000 秒滴答数                                          |
|  00008 |          8 | UTC unix 时间戳                                                     |
|  00010 |          2 | 当前语言环境                                                         |

性能计数器显示生成最后一帧时未花费的时间。如果这是零或负数，那么这意味着你的loop()函数已经超出了它的可用时间范围。

## 指针

| 抵消   | 尺寸        | 描述                                                                |
|--------|-----------:|--------------------------------------------------------------------|
|  00012 |          2 | 指针按钮状态（请参阅[getbtn]和[getclk]）                               |
|  00014 |          2 | 指针精灵索引                                                         |
|  00016 |          2 | 指针X坐标                                                           |
|  00018 |          2 | 指针Y坐标                                                           |

指针按钮如下：

| 宏      | 位掩码     | 描述                                                                |
|---------|----------:|--------------------------------------------------------------------|
| `BTN_L` |         1 | 鼠标左键                                                            |
| `BTN_M` |         2 | 鼠标中键                                                            |
| `BTN_R` |         4 | 鼠标右键                                                            |
| `SCR_U` |         8 | 向上滑动                                                            |
| `SCR_D` |        16 | 向下滚动                                                            |
| `SCR_L` |        32 | 向左滚动                                                            |
| `SCR_R` |        64 | 向右滚动                                                            |

指针精灵索引的高位用于热点：位13-15热点Y、位10-12热点X、位0-9精灵。有一些预定义的内置游标：

| 宏           | 价值       | 描述                                                          |
|--------------|----------:|---------------------------------------------------------------|
| `PTR_NORM`   |      03fb | 正常（箭头）指针                                                |
| `PTR_TEXT`   |      03fc | 文本指针                                                       |
| `PTR_HAND`   |      0bfd | 链接指针                                                       |
| `PTR_ERR`    |      93fe | 错误指针                                                       |
| `PTR_NONE`   |      ffff | 指针被隐藏                                                     |

## 键盘

| 抵消   | 尺寸        | 描述                                                                |
|--------|-----------:|--------------------------------------------------------------------|
|  0001A |          1 | 键盘队列尾部                                                         |
|  0001B |          1 | 键盘队列头                                                          |
|  0001C |         64 | 键盘队列，16 个元素，每个 4 字节（参见[popkey]）                        |
|  0005C |         18 | 通过扫描码确定键盘按键的按下状态（参见[getkey]）                         |

从队列中弹出的键以 UTF-8 表示。一些无效的 UTF-8 序列表示特殊（不可打印）键，例如：

| 键盘代码 | 描述                                            |
|---------|-------------------------------------------------|
| `\x8`   | 字符8，<kbd>←Backspace</kbd> 键                  |
| `\x9`   | 字符9，<kbd>Tab</kbd> 键                         |
| `\n`    | 字符10，<kbd>⏎Enter</kbd> 键                     |
| `\x1b`  | 字符27，<kbd>Esc</kbd> 键                        |
| `Del`   | <kbd>Del</kbd> 键                               |
| `Up`    | 光标箭头<kbd>▴</kbd> 键                          |
| `Down`  | 光标箭头<kbd>▾</kbd> 键                          |
| `Left`  | 光标箭头<kbd>◂</kbd> 键                          |
| `Rght`  | 光标箭头<kbd>▸</kbd> 键                          |
| `Cut`   | 剪切键（或<kbd>Ctrl</kbd>+<kbd>X</kbd>）         |
| `Cpy`   | 复制键（或<kbd>Ctrl</kbd>+<kbd>C</kbd>）         |
| `Pst`   | 粘贴键（或<kbd>Ctrl</kbd>+<kbd>V</kbd>）         |

扫描码如下：

| 扫码      | 抵消     | 位掩码   | 宏                |
|---------:|---------|--------:|-------------------|
|        0 |   0005C |       1 | `KEY_CHEAT`       |
|        1 |   0005C |       2 | `KEY_F1`          |
|        2 |   0005C |       4 | `KEY_F2`          |
|        3 |   0005C |       8 | `KEY_F3`          |
|        4 |   0005C |      16 | `KEY_F4`          |
|        5 |   0005C |      32 | `KEY_F5`          |
|        6 |   0005C |      64 | `KEY_F6`          |
|        7 |   0005C |     128 | `KEY_F7`          |
|        8 |   0005D |       1 | `KEY_F8`          |
|        9 |   0005D |       2 | `KEY_F9`          |
|       10 |   0005D |       4 | `KEY_F10`         |
|       11 |   0005D |       8 | `KEY_F11`         |
|       12 |   0005D |      16 | `KEY_F12`         |
|       13 |   0005D |      32 | `KEY_PRSCR`       |
|       14 |   0005D |      64 | `KEY_SCRLOCK`     |
|       15 |   0005D |     128 | `KEY_PAUSE`       |
|       16 |   0005E |       1 | `KEY_BACKQUOTE`   |
|       17 |   0005E |       2 | `KEY_1`           |
|       18 |   0005E |       4 | `KEY_2`           |
|       19 |   0005E |       8 | `KEY_3`           |
|       20 |   0005E |      16 | `KEY_4`           |
|       21 |   0005E |      32 | `KEY_5`           |
|       22 |   0005E |      64 | `KEY_6`           |
|       23 |   0005E |     128 | `KEY_7`           |
|       24 |   0005F |       1 | `KEY_8`           |
|       25 |   0005F |       2 | `KEY_9`           |
|       26 |   0005F |       4 | `KEY_0`           |
|       27 |   0005F |       8 | `KEY_MINUS`       |
|       28 |   0005F |      16 | `KEY_EQUAL`       |
|       29 |   0005F |      32 | `KEY_BACKSPACE`   |
|       30 |   0005F |      64 | `KEY_TAB`         |
|       31 |   0005F |     128 | `KEY_Q`           |
|       32 |   00060 |       1 | `KEY_W`           |
|       33 |   00060 |       2 | `KEY_E`           |
|       34 |   00060 |       4 | `KEY_R`           |
|       35 |   00060 |       8 | `KEY_T`           |
|       36 |   00060 |      16 | `KEY_Y`           |
|       37 |   00060 |      32 | `KEY_U`           |
|       38 |   00060 |      64 | `KEY_I`           |
|       39 |   00060 |     128 | `KEY_O`           |
|       40 |   00061 |       1 | `KEY_P`           |
|       41 |   00061 |       2 | `KEY_LBRACKET`    |
|       42 |   00061 |       4 | `KEY_RBRACKET`    |
|       43 |   00061 |       8 | `KEY_ENTER`       |
|       44 |   00061 |      16 | `KEY_CAPSLOCK`    |
|       45 |   00061 |      32 | `KEY_A`           |
|       46 |   00061 |      64 | `KEY_S`           |
|       47 |   00061 |     128 | `KEY_D`           |
|       48 |   00062 |       1 | `KEY_F`           |
|       49 |   00062 |       2 | `KEY_G`           |
|       50 |   00062 |       4 | `KEY_H`           |
|       51 |   00062 |       8 | `KEY_J`           |
|       52 |   00062 |      16 | `KEY_K`           |
|       53 |   00062 |      32 | `KEY_L`           |
|       54 |   00062 |      64 | `KEY_SEMICOLON`   |
|       55 |   00062 |     128 | `KEY_APOSTROPHE`  |
|       56 |   00063 |       1 | `KEY_BACKSLASH`   |
|       57 |   00063 |       2 | `KEY_LSHIFT`      |
|       58 |   00063 |       4 | `KEY_LESS`        |
|       59 |   00063 |       8 | `KEY_Z`           |
|       60 |   00063 |      16 | `KEY_X`           |
|       61 |   00063 |      32 | `KEY_C`           |
|       62 |   00063 |      64 | `KEY_V`           |
|       63 |   00063 |     128 | `KEY_B`           |
|       64 |   00064 |       1 | `KEY_N`           |
|       65 |   00064 |       2 | `KEY_M`           |
|       66 |   00064 |       4 | `KEY_COMMA`       |
|       67 |   00064 |       8 | `KEY_PERIOD`      |
|       68 |   00064 |      16 | `KEY_SLASH`       |
|       69 |   00064 |      32 | `KEY_RSHIFT`      |
|       70 |   00064 |      64 | `KEY_LCTRL`       |
|       71 |   00064 |     128 | `KEY_LSUPER`      |
|       72 |   00065 |       1 | `KEY_LALT`        |
|       73 |   00065 |       2 | `KEY_SPACE`       |
|       74 |   00065 |       4 | `KEY_RALT`        |
|       75 |   00065 |       8 | `KEY_RSUPER`      |
|       76 |   00065 |      16 | `KEY_MENU`        |
|       77 |   00065 |      32 | `KEY_RCTRL`       |
|       78 |   00065 |      64 | `KEY_INS`         |
|       79 |   00065 |     128 | `KEY_HOME`        |
|       80 |   00066 |       1 | `KEY_PGUP`        |
|       81 |   00066 |       2 | `KEY_DEL`         |
|       82 |   00066 |       4 | `KEY_END`         |
|       83 |   00066 |       8 | `KEY_PGDN`        |
|       84 |   00066 |      16 | `KEY_UP`          |
|       85 |   00066 |      32 | `KEY_LEFT`        |
|       86 |   00066 |      64 | `KEY_DOWN`        |
|       87 |   00066 |     128 | `KEY_RIGHT`       |
|       88 |   00067 |       1 | `KEY_NUMLOCK`     |
|       89 |   00067 |       2 | `KEY_KP_DIV`      |
|       90 |   00067 |       4 | `KEY_KP_MUL`      |
|       91 |   00067 |       8 | `KEY_KP_SUB`      |
|       92 |   00067 |      16 | `KEY_KP_7`        |
|       93 |   00067 |      32 | `KEY_KP_8`        |
|       94 |   00067 |      64 | `KEY_KP_9`        |
|       95 |   00067 |     128 | `KEY_KP_ADD`      |
|       96 |   00068 |       1 | `KEY_KP_4`        |
|       97 |   00068 |       2 | `KEY_KP_5`        |
|       98 |   00068 |       4 | `KEY_KP_6`        |
|       99 |   00068 |       8 | `KEY_KP_1`        |
|      100 |   00068 |      16 | `KEY_KP_2`        |
|      101 |   00068 |      32 | `KEY_KP_3`        |
|      102 |   00068 |      64 | `KEY_KP_ENTER`    |
|      103 |   00068 |     128 | `KEY_KP_0`        |
|      104 |   00069 |       1 | `KEY_KP_DEC`      |
|      105 |   00069 |       2 | `KEY_INT1`        |
|      106 |   00069 |       4 | `KEY_INT2`        |
|      107 |   00069 |       8 | `KEY_INT3`        |
|      108 |   00069 |      16 | `KEY_INT4`        |
|      109 |   00069 |      32 | `KEY_INT5`        |
|      110 |   00069 |      64 | `KEY_INT6`        |
|      111 |   00069 |     128 | `KEY_INT7`        |
|      112 |   0006A |       1 | `KEY_INT8`        |
|      113 |   0006A |       2 | `KEY_LNG1`        |
|      114 |   0006A |       4 | `KEY_LNG2`        |
|      115 |   0006A |       8 | `KEY_LNG3`        |
|      116 |   0006A |      16 | `KEY_LNG4`        |
|      117 |   0006A |      32 | `KEY_LNG5`        |
|      118 |   0006A |      64 | `KEY_LNG6`        |
|      119 |   0006A |     128 | `KEY_LNG7`        |
|      120 |   0006B |       1 | `KEY_LNG8`        |
|      121 |   0006B |       2 | `KEY_APP`         |
|      122 |   0006B |       4 | `KEY_POWER`       |
|      123 |   0006B |       8 | `KEY_KP_EQUAL`    |
|      124 |   0006B |      16 | `KEY_EXEC`        |
|      125 |   0006B |      32 | `KEY_HELP`        |
|      126 |   0006B |      64 | `KEY_SELECT`      |
|      127 |   0006B |     128 | `KEY_STOP`        |
|      128 |   0006C |       1 | `KEY_AGAIN`       |
|      129 |   0006C |       2 | `KEY_UNDO`        |
|      130 |   0006C |       4 | `KEY_CUT`         |
|      131 |   0006C |       8 | `KEY_COPY`        |
|      132 |   0006C |      16 | `KEY_PASTE`       |
|      133 |   0006C |      32 | `KEY_FIND`        |
|      134 |   0006C |      64 | `KEY_MUTE`        |
|      135 |   0006C |     128 | `KEY_VOLUP`       |
|      136 |   0006D |       1 | `KEY_VOLDN`       |


## 游戏手柄

| 抵消   | 尺寸        | 描述                                                                |
|--------|-----------:|--------------------------------------------------------------------|
|  0006E |          2 | 游戏手柄操纵杆阈值（默认为 8000）                                       |
|  00070 |          8 | 主游戏手柄 - 键盘扫描码映射（请参阅[键盘]）                               |
|  00078 |          4 | 4 游戏手柄按钮按下状态（参见[getpad]）                                  |

游戏手柄按钮如下：

| 宏      | 位掩码     | 描述                                                                |
|---------|----------:|--------------------------------------------------------------------|
| `BTN_L` |         1 | `◁` 按钮或操纵杆向左                                                   |
| `BTN_U` |         2 | `△` 按钮或操纵杆向上                                                   |
| `BTN_R` |         4 | `▷` 按钮或操纵杆右侧                                                   |
| `BTN_D` |         8 | `▽` 按钮或操纵杆向下                                                   |
| `BTN_A` |        16 | `Ⓐ` 按钮                                                            |
| `BTN_B` |        32 | `Ⓑ` 按钮                                                            |
| `BTN_X` |        64 | `Ⓧ` 按钮                                                            |
| `BTN_Y` |       128 | `Ⓨ` 按钮                                                            |

`△△▽▽◁▷◁▷ⒷⒶ`序列使`KEY_CHEAT`“键”被按下。

## 图形处理单元

| 抵消   | 尺寸        | 描述                                                                |
|--------|-----------:|--------------------------------------------------------------------|
|  0007E |          1 | 用于字体字形映射的 UNICODE 代码点高位                                   |
|  0007F |          1 | 地图的精灵库选择器                                                    |
|  00080 |       1024 | 调色板，256 种颜色，每个条目 4 字节，RGBA                               |
|  00480 |          2 | x0 裁剪区域X以像素为单位开始（对于所有绘图功能）                         |
|  00482 |          2 | x1 裁剪区域X结束以像素为单位                                          |
|  00484 |          2 | y0 裁剪区域Y以像素为单位开始                                          |
|  00486 |          2 | y1 裁剪区域Y结束以像素为单位                                          |
|  00488 |          2 | 显示的视频内存X偏移量以像素为单位或0xffff                                |
|  0048A |          2 | 显示的视频内存Y偏移量以像素为单位或0xffff                                |
|  0048C |          1 | 乌龟笔下旗（参见[up]、[down]）                                        |
|  0048D |          1 | 海龟笔颜色，调色板索引 0 到 255（参见[color]）                          |
|  0048E |          2 | 海龟方向，以度为单位，0 到 359（参见[left]、[right]）                   |
|  00490 |          2 | 海龟X像素偏移（参见[move]）                                           |
|  00492 |          2 | 海龟Y像素偏移                                                        |
|  00494 |          2 | 迷宫行走速度（以 1/128 格为单位）（参见[maze]）                          |
|  00496 |          2 | 迷宫旋转速度（1 到 90）                                               |
|  00498 |          1 | 控制台前景色、调色板索引 0 到 255（参见[printf]）                        |
|  00499 |          1 | 控制台背景颜色、调色板索引 0 到 255                                     |
|  0049A |          2 | 控制台X偏移以像素为单位                                                |
|  0049C |          2 | 控制台Y偏移以像素为单位                                                |
|  0049E |          2 | [3D空间]中的相机X偏移（参见[tri3d]、[tritx]、[mesh]）                   |
|  004A0 |          2 | 相机Y偏移                                                           |
|  004A2 |          2 | 相机Z偏移                                                           |
|  004A4 |          2 | 摄像机方向、俯仰（0向上，90向前）                                       |
|  004A6 |          2 | 相机方向、偏航（0向左，90向前）                                         |
|  004A8 |          1 | 相机视野角度（45°，负数表示正交）                                       |
|  004AA |          2 | 光源位置X偏移（参见[tri3d]、[tritx]、[mesh]）                          |
|  004AC |          2 | 光源位置Y偏移                                                        |
|  004AE |          2 | 光源位置Z偏移                                                        |
|  00600 |      64000 | 地图、320 x 200 精灵索引（参见[map]和[maze]）                          |
|  10000 |      65536 | 精灵、256 x 256 调色板索引、1024 8 x 8 像素（参见[spr]）                |
|  28000 |       2048 | 4096 字体字形的窗口（参见0007E、[width]和[text]）                      |

## 数字信号处理器

| 抵消   | 尺寸        | 描述                                                                |
|--------|-----------:|--------------------------------------------------------------------|
|  0007C |          1 | 波形库选择器（1到31）                                                 |
|  0007D |          1 | 音乐曲目库选择器（0到7）                                               |
|  004BA |          1 | 当前节奏（以每行滴答声为单位，只读）                                     |
|  004BB |          1 | 当前正在播放的曲目（只读）                                             |
|  004BC |          2 | 当前正在播放的行（只读）                                               |
|  004BE |          2 | 当前轨道中的总行数（只读）                                             |
|  004C0 |         64 | 16个通道状态寄存器，每个4字节（只读）                                    |
|  00500 |        256 | 64个音效，每个4字节                                                   |
|  20000 |      16384 | 波形样本窗口（参见0007C）                                             |
|  24000 |      16384 | 音乐模式窗口（参见0007D）                                             |

DSP 状态寄存器都是只读的，对于每个通道，它们如下所示：

| 抵消   | 尺寸        | 描述                                                                |
|--------|-----------:|--------------------------------------------------------------------|
|      0 |          2 | 正在播放的波形中的当前位置                                             |
|      2 |          1 | 当前波形（1到31，如果通道静音则为0）                                    |
|      3 |          1 | 当前音量（0表示通道关闭）                                              |

前 4 个通道用于音乐，其余通道用于音效。

请注意，波形索引 0 表示“使用前一个波形”，因此索引 0 不能在选择器中使用。其他所有波形的格式：

| 抵消   | 尺寸        | 描述                                                                |
|--------|-----------:|--------------------------------------------------------------------|
|      0 |          2 | 样本数                                                              |
|      2 |          2 | 循环开始                                                            |
|      4 |          2 | 循环长度                                                            |
|      6 |          1 | 精确调谐值，-8到7                                                    |
|      7 |          1 | 音量，0到64                                                         |
|      8 |      16376 | 带符号的8位单声道样本                                                 |

音效和音乐轨的格式是一样的，唯一的区别是，音乐轨每行4个音符，每个通道一个，共有1024行； 而音效只有一个音符和 64 行。

| 抵消   | 尺寸        | 描述                                                                |
|--------|-----------:|--------------------------------------------------------------------|
|      0 |          1 | 音符编号，请参阅`NOTE_x`定义，0到96                                    |
|      1 |          1 | 波形索引，0到31                                                      |
|      2 |          1 | 效果类型，0到255（参见[声音特效]）                                      |
|      3 |          1 | 效果参数                                                            |

音符计数如下：0 表示没有音符设置。 接下来是 8 个八度，每个八度有 12 个音符，因此 1 等于 C-0，12 是 B-0（最低八度），13 是 C-1（高一个八度），
14 是 C#1（升 C， 半音更高）。 例如，第 4 个八度音阶上的 D 音符将为 1 + 4\*12 + 2 = 51。B-7 为 96，即最高八度音阶上的最高音符。 您还可以有内置定义，
例如 C-1 是`NOTE_C_1`，C#1 是`NOTE_Cs1`，如果您不想计数，那么您也可以在程序中使用它们。

## 声音特效

为简单起见，MEG-4 使用与 Amiga MOD 文件相同的代码（这样您将在内置编辑器以及第三方音乐跟踪器中看到相同的代码），但它并不支持所有这些代码。
如前所述，这些代码由三个十六进制数字表示，第一个是类型`t`，最后两个是参数`xy`（或`xx`）。 类型`E1`到`ED`都存储在类型字节中，
虽然看起来它们的半字节之一可能属于参数，但事实并非如此。

| 影响   | 代码  | 描述                                                        |
|--------|------|------------------------------------------------------------|
| ...    | 000  | 没有效果                                                    |
| Arp    | 0xy  | 琶音、演奏音符、音符+x半音和音符+y半音                          |
| Po/    | 1xx  | 滑音向上，滑动周期x 向上                                      |
| Po\\   | 2xx  | 滑音向下，滑动周期x 向下                                      |
| Ptn    | 3xx  | 滑音，滑音周期到周期x                                         |
| Vib    | 4xy  | 颤音，以x频率将音高振动y半音                                   |
| Ctv    | 5xy  | 继续音调滑音+音量向上x或向下y滑动                               |
| Cvv    | 6xy  | 继续颤音+音量向上x或向下y滑动                                  |
| Trm    | 7xy  | 颤音，以x频率使体积振荡y幅度                                   |
| Ofs    | 9xx  | 将样本偏移设置为 x \* 256                                     |
| Vls    | Axy  | 将音量向上滑动x或向下滑动y                                     |
| Jmp    | Bxx  | 位置跳转，设置行为x \* 64                                     |
| Vol    | Cxx  | 将音量设置为x                                                |
| Fp/    | E1x  | 精细滑音向上，周期增加x                                        |
| Fp\\   | E2x  | 精细滑音向下，周期减少x                                        |
| Svw    | E4x  | 设置颤音波形，0正弦波，1锯齿波，2方波，3噪声（4xx的）              |
| Ftn    | E5x  | 设置精确调音，按x（-8至7）更改调音                              |
| Stw    | E7x  | 设置颤音波形，0正弦波，1锯齿波，2方波，3噪声（7xx的）              |
| Rtg    | E9x  | 重新触发音符，每x个刻度触发当前样本                              |
| Fv/    | EAx  | 精细音量向上滑动，增加x                                        |
| Fv\\   | EBx  | 精细音量下滑，减少x                                           |
| Cut    | ECx  | 在x个刻度后剪切笔记                                           |
| Dly    | EDx  | x个刻度的延迟注释                                             |
| Tpr    | Fxx  | 将每行的刻度数设置为x（刻度默认为6）                             |

## 用户记忆

从 00000 到 2FFFF 的内存地址属于 MMIO，上面的所有内容（从 30000 或`MEM_USER`开始）都是可自由使用的用户内存。

| 抵消   | 尺寸        | 描述                                                                |
|--------|-----------:|--------------------------------------------------------------------|
|  30000 |          4 | （仅限BASIC）DATA的偏移量                                             |
|  30004 |          4 | （仅限BASIC）当前READ计数器                                           |
|  30008 |          4 | （仅限BASIC）最大READ，DATA数量                                       |

接下来是您在程序中声明的全局变量，然后是常量，例如字符串文字。如果是BASIC，则后面跟着实际的DATA记录。

初始化数据上方的内存地址可以通过[malloc]和[free]调用在程序中动态分配和释放。

最后是堆栈，它位于顶部（从 C0000 或`MEM_LIMIT`开始）并*向下*增长。 您的程序的局部变量（您在函数内声明的）位于此处。
堆栈的大小总是根据哪个函数调用程序中的其他函数而变化。

如果动态分配数据的顶部和堆栈底部有任何机会重叠，则 MEG-4会抛出“内存不足”错误。

## 格式串

某些函数，[printf]、[sprintf] 和 [trace] 使用可能包含特殊字符的格式字符串来引用参数并描述如何显示它们。 这些都是：

| 代码  | 描述                                                       |
|------|------------------------------------------------------------|
| `%%` | `%`字符                                                    |
| `%d` | 下一个参数为十进制数                                          |
| `%u` | 下一个参数为无符号十进制数                                     |
| `%x` | 下一个参数为十六进制数                                        |
| `%o` | 下一个参数为八进制数                                          |
| `%b` | 下一个参数为二进制数                                          |
| `%f` | 下一个参数为浮点数                                            |
| `%s` | 下一个参数为字符串                                            |
| `%c` | 下一个参数为UTF-8字符                                        |
| `%p` | 下一个参数作为地址（指针）                                     |
| `\t` | 选项卡，在继续之前固定垂直位置                                 |
| `\n` | 开始新的一行                                                |

您可以通过指定`%`和代码之间的长度来添加填充。 如果以`0`开头，则值将用零填充，否则用空格填充。 例如，`%4d`将用空格填充该值，
`%04x`将用零填充该值。`f`接受点后面的数字，它告诉小数部分的位数（最多8位），例如 `%.6f`。

## 3D空间

在 MEG-4 中，3 维空间根据右手定则处理：+X 在右侧，+Y 向上，+Z 朝向观察者。

```
  +Y
   |
   |__ +X
  /
+Z
```

每个点必须位于 -32767 到 +32767 的范围内。 这个3D世界如何投影到你的2D屏幕上取决于你如何配置相机（参见[图形处理单元]地址0049E）。
当然，你必须将相机放置在世界中，并具有 X、Y、Z 坐标。 然后你必须使用俯仰和偏航来判断相机正在看哪里。 最后，您还必须通过指定视场角来判断相机的镜头类型。
后者通常应在 30 度（非常窄）到 180 度（如鱼和鸟）之间。 MEG-4 支持最大 127 度，但有一个技巧。 正 FOV 值将被投影为透视（物体越远，物体越小），
但也可以处理负值，只是使用正交投影（无论距离多远，物体的大小都是相同的）。 透视多用于FPS游戏，而正交投影多用于策略游戏。

您可以使用[mesh]功能高效地显示一组三角形（完整的3D模型）。 因为模型可能具有局部坐标，所以这会将所有模型围绕原点绘制在另一个之上。 因此，
如果你想在世界上显示多个模型，首先你应该使用[trns]将它们转换（放置）到世界坐标，然后使用[mesh]转换后的顶点云（移动和旋转模型不会 更改三角形，仅更改其顶点坐标）。

## 代码编辑器快捷键

编辑源代码时，您还可以使用其他 [键盘] 快捷键：

| 键 | 说明 |
|------------------------------|-----------------------------------------------------------|
| <kbd>Ctrl</kbd>+<kbd>F</kbd> | 查找字符串 |
| <kbd>Ctrl</kbd>+<kbd>G</kbd> | 再次查找 |
| <kbd>Ctrl</kbd>+<kbd>H</kbd> | 搜索和替换（在选定的文本中，或者如果没有选定的文本，则在整个源代码中）|
| <kbd>Ctrl</kbd>+<kbd>J</kbd> | 转到行 |
| <kbd>Ctrl</kbd>+<kbd>D</kbd> | 转到函数定义 |
| <kbd>Ctrl</kbd>+<kbd>N</kbd> |列出书签 |
| <kbd>Ctrl</kbd>+<kbd>B</kbd> | 在当前行切换书签 |
| <kbd>Ctrl</kbd>+<kbd>▴</kbd> | 转到上一个书签 |
| <kbd>Ctrl</kbd>+<kbd>▾</kbd> | 转到下一个书签 |
| <kbd>Ctrl</kbd>+<kbd>◂</kbd> | 转到上一个单词的开头 |
| <kbd>Ctrl</kbd>+<kbd>▸</kbd> | 转到下一个单词的结尾 |
| <kbd>Ctrl</kbd>+<kbd>,</kbd> | 减少所选内容的缩进 |
| <kbd>Ctrl</kbd>+<kbd>.</kbd> | 增加所选内容的缩进 |
| <kbd>Home</kbd> | 将光标移动到行首 |
| <kbd>End</kbd> | 将光标移动到行末 |
| <kbd>PgUp</kbd> |将光标向上移动 42 行（一页） |
| <kbd>PgDown</kbd> | 将光标向下移动 42 行（一页） |
| <kbd>F1</kbd> | 如果光标位于 API 的参数列表中，则转到函数的内置帮助页面 |

无论平台的键盘布局如何，编程所需的所有字符（以及更多）始终都可以访问：

| 左 <kbd>Alt</kbd> + |
|---------------------|
| <kbd> </kbd> <kbd>(</kbd> <kbd>)</kbd> <kbd>{</kbd> <kbd>}</kbd> <kbd>〈</kbd> <kbd>〉</kbd> <kbd>!</kbd> <kbd>^</kbd> <kbd>_</kbd> <kbd>-</kbd> <kbd>=</kbd> |
| <kbd>⇥</kbd> <kbd> </kbd> <kbd> </kbd> <kbd>€</kbd> <kbd>₹</kbd> <kbd>~</kbd> <kbd>¥</kbd> <kbd> </kbd> <kbd> </kbd> <kbd>°</kbd> <kbd>"</kbd> <kbd>\[</kbd> <kbd>\]</kbd> |
| <kbd>↨</kbd> <kbd>&</kbd> <kbd>$</kbd> <kbd>@</kbd> <kbd>¦</kbd> <kbd> </kbd> <kbd>#</kbd> <kbd> </kbd> <kbd> </kbd> <kbd>£</kbd> <kbd>;</kbd> <kbd>'</kbd> <kbd>\\</kbd> |
| <kbd>⇮</kbd> <kbd>:</kbd> <kbd>?</kbd> <kbd> </kbd> <kbd>元</kbd> <kbd>%</kbd> <kbd>+</kbd> <kbd>✶</kbd> <kbd>,</kbd> <kbd>.</kbd> <kbd>/</kbd> |

另请参阅菜单以了解备选输入法及其键盘快捷键。

# 控制台

## putc

```c
void putc(uint32_t chr)
```
<dl>
<dt>描述</dt><dd>
打印一个字符到控制台。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| chr | UTF-8 字符 |
</dd>
</dl>
<hr>
## printf

```c
void printf(str_t fmt, ...)
```
<dl>
<dt>描述</dt><dd>
将文本打印到控制台。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| fmt | 要显示的字符串，[格式串] |
| ... | 可选参数 |
</dd>
</dl>
<hr>
## getc

```c
uint32_t getc(void)
```
<dl>
<dt>描述</dt><dd>
从控制台读取一个字符，在没有输入时阻止程序。
</dd>
<dt>返回值</dt><dd>
用户输入的 UTF-8 字符。
</dd>
<dt>另见</dt><dd>
[popkey]
</dd>
</dl>
<hr>
## gets

```c
str_t gets(void)
```
<dl>
<dt>描述</dt><dd>
从用户读取换行符终止的字符串（不返回换行符）。
</dd>
<dt>返回值</dt><dd>
在字符串中读取的字节。
</dd>
</dl>
<hr>
## trace

```c
void trace(str_t fmt, ...)
```
<dl>
<dt>描述</dt><dd>
通过打印到标准输出来跟踪执行情况。 仅当`meg4`以`-v`详细标志启动时才有效。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| fmt | [格式串] |
| ... | 可选参数 |
</dd>
</dl>
<hr>
## delay

```c
void delay(uint16_t msec)
```
<dl>
<dt>描述</dt><dd>
延迟程序执行。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| msec | 以毫秒为单位的延迟 |
</dd>
</dl>
<hr>
## exit

```c
void exit(void)
```
<dl>
<dt>描述</dt><dd>
退出程序。
</dd>
</dl>

# 音频

## sfx

```c
void sfx(uint8_t sfx, uint8_t channel, uint8_t volume)
```
<dl>
<dt>描述</dt><dd>
播放音效。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| sfx | 音效索引，0到63 |
| channel | 要使用的通道，0到11 |
| volume | 要使用的音量，0到255（0关闭通道） |
</dd>
</dl>
<hr>
## music

```c
void music(uint8_t track, uint16_t row, uint8_t volume)
```
<dl>
<dt>描述</dt><dd>
播放音乐曲目。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| track | 音乐曲目的索引，0到7 |
| row | 开始播放的行，0到1023（最大歌曲长度） |
| volume | 要使用的音量，0到255（0关闭音乐） |
</dd>
</dl>

# GPIO

## gpio_rev

```c
uint32_t gpio_rev(void)
```
<dl>
<dt>描述</dt><dd>
查询GPIO板的版本号。 如果平台不支持 GPIO，则返回 0。
</dd>
<dt>返回值</dt><dd>
主板的修订号或 0（如果不支持）。
</dd>
</dl>
<hr>
## gpio_get

```c
int gpio_get(uint8_t pin)
```
<dl>
<dt>描述</dt><dd>
读取 GPIO 引脚的值。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| pin | 物理引脚号，1到40 |
</dd>
<dt>返回值</dt><dd>
如果引脚为高电平则返回 1，如果为低电平则返回 0，如果出错则返回 -1（不支持 GPIO 引脚）。
</dd>
<dt>另见</dt><dd>
[gpio_set]
</dd>
</dl>
<hr>
## gpio_set

```c
int gpio_set(uint8_t pin, int value)
```
<dl>
<dt>描述</dt><dd>
将值写入 GPIO 引脚。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| pin | 物理引脚号，1到40 |
| value | 1设置引脚为高电平，0为低电平 |
</dd>
<dt>返回值</dt><dd>
成功时返回 0，错误时返回 -1（不支持 GPIO 引脚）。
</dd>
<dt>另见</dt><dd>
[gpio_get]
</dd>
</dl>

# 图形

## cls

```c
void cls(uint8_t palidx)
```
<dl>
<dt>描述</dt><dd>
清除整个屏幕并重置显示偏移，还设置控制台的背景颜色。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| palidx | 颜色，调色板索引 0到255 |
</dd>
<dt>另见</dt><dd>
[pget], [pset]
</dd>
</dl>
<hr>
## cget

```c
uint32_t cget(uint16_t x, uint16_t y)
```
<dl>
<dt>描述</dt><dd>
获取坐标处的像素并返回颜色 RGBA。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| x | 以像素为单位的X坐标 |
| y | 以像素为单位的Y坐标 |
</dd>
<dt>返回值</dt><dd>
带有RGBA通道的打包颜色（红色位于最低有效字节中）。
</dd>
<dt>另见</dt><dd>
[cls], [pget], [pset]
</dd>
</dl>
<hr>
## pget

```c
uint8_t pget(uint16_t x, uint16_t y)
```
<dl>
<dt>描述</dt><dd>
获取坐标处的像素并返回其调色板索引。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| x | 以像素为单位的X坐标 |
| y | 以像素为单位的Y坐标 |
</dd>
<dt>返回值</dt><dd>
调色板索引中的颜色，0到255。
</dd>
<dt>另见</dt><dd>
[cls], [pset], [cget]
</dd>
</dl>
<hr>
## pset

```c
void pset(uint8_t palidx, uint16_t x, uint16_t y)
```
<dl>
<dt>描述</dt><dd>
在坐标处绘制像素。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| palidx | 颜色，调色板索引 0到255 |
| x | 以像素为单位的X坐标 |
| y | 以像素为单位的Y坐标 |
</dd>
<dt>另见</dt><dd>
[cls], [pget]
</dd>
</dl>
<hr>
## width

```c
uint16_t width(int8_t type, str_t str)
```
<dl>
<dt>描述</dt><dd>
返回显示文本的宽度（以像素为单位）。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| type | 字体类型，-4到4 |
| str | 要测量的字符串 |
</dd>
<dt>返回值</dt><dd>
显示文本所需的像素数。
</dd>
<dt>另见</dt><dd>
[text]
</dd>
</dl>
<hr>
## text

```c
void text(uint8_t palidx, int16_t x, int16_t y, int8_t type, uint8_t shidx, uint8_t sha, str_t str)
```
<dl>
<dt>描述</dt><dd>
在屏幕上打印文本。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| palidx | 颜色，调色板索引 0到255 |
| x | 以像素为单位的X坐标 |
| y | 以像素为单位的Y坐标 |
| type | 字体类型，-4到-1 等宽字体，1到4 比例 |
| shidx | 阴影的颜色，调色板索引 0到255 |
| sha | 阴影的透明度，0（完全透明）到 255（完全不透明） |
| str | 要显示的字符串 |
</dd>
<dt>另见</dt><dd>
[width]
</dd>
</dl>
<hr>
## line

```c
void line(uint8_t palidx, int16_t x0, int16_t y0, int16_t x1, int16_t y1)
```
<dl>
<dt>描述</dt><dd>
绘制一条抗锯齿线。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| palidx | 颜色，调色板索引 0到255 |
| x0 | 以像素为单位的起始X坐标 |
| y0 | 以像素为单位的起始Y坐标 |
| x1 | 以像素为单位的结束X坐标 |
| y1 | 以像素为单位的结束Y坐标 |
</dd>
<dt>另见</dt><dd>
[qbez], [cbez]
</dd>
</dl>
<hr>
## qbez

```c
void qbez(uint8_t palidx, int16_t x0, int16_t y0, int16_t x1, int16_t y1,
    int16_t cx, int16_t cy)
```
<dl>
<dt>描述</dt><dd>
绘制二次贝塞尔曲线。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| palidx | 颜色，调色板索引 0到255 |
| x0 | 以像素为单位的起始X坐标 |
| y0 | 以像素为单位的起始Y坐标 |
| x1 | 以像素为单位的结束X坐标 |
| y1 | 以像素为单位的结束Y坐标 |
| cx | 控制点X坐标以像素为单位 |
| cy | 控制点Y坐标以像素为单位 |
</dd>
<dt>另见</dt><dd>
[line], [cbez]
</dd>
</dl>
<hr>
## cbez

```c
void cbez(uint8_t palidx, int16_t x0, int16_t y0, int16_t x1, int16_t y1,
    int16_t cx0, int16_t cy0, int16_t cx1, int16_t cy1)
```
<dl>
<dt>描述</dt><dd>
绘制三次贝塞尔曲线。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| palidx | 颜色，调色板索引 0到255 |
| x0 | 以像素为单位的起始X坐标 |
| y0 | 以像素为单位的起始Y坐标 |
| x1 | 以像素为单位的结束X坐标 |
| y1 | 以像素为单位的结束Y坐标 |
| cx0 | 第一个控制点X坐标以像素为单位 |
| cy0 | 第一个控制点Y坐标以像素为单位 |
| cx1 | 第二个控制点X坐标以像素为单位 |
| cy1 | 第二个控制点Y坐标以像素为单位 |
</dd>
<dt>另见</dt><dd>
[line], [qbez]
</dd>
</dl>
<hr>
## tri

```c
void tri(uint8_t palidx, int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2)
```
<dl>
<dt>描述</dt><dd>
绘制一个三角形。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| palidx | 颜色，调色板索引 0到255 |
| x0 | 第一个边缘X坐标以像素为单位 |
| y0 | 第一个边缘Y坐标以像素为单位 |
| x1 | 第二条边的X坐标以像素为单位 |
| y1 | 第二条边的Y坐标以像素为单位 |
| x2 | 第三条边的X坐标以像素为单位 |
| y2 | 第三条边的Y坐标以像素为单位 |
</dd>
<dt>另见</dt><dd>
[ftri], [tri2d], [tri3d], [tritx], [mesh], [trns]
</dd>
</dl>
<hr>
## ftri

```c
void ftri(uint8_t palidx, int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2)
```
<dl>
<dt>描述</dt><dd>
绘制一个实心三角形。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| palidx | 颜色，调色板索引 0到255 |
| x0 | 第一个边缘X坐标以像素为单位 |
| y0 | 第一个边缘Y坐标以像素为单位 |
| x1 | 第二条边的X坐标以像素为单位 |
| y1 | 第二条边的Y坐标以像素为单位 |
| x2 | 第三条边的X坐标以像素为单位 |
| y2 | 第三条边的Y坐标以像素为单位 |
</dd>
<dt>另见</dt><dd>
[tri], [tri2d], [tri3d], [tritx], [mesh], [trns]
</dd>
</dl>
<hr>
## tri2d

```c
void tri2d(uint8_t pi0, int16_t x0, int16_t y0,
    uint8_t pi1, int16_t x1, int16_t y1,
    uint8_t pi2, int16_t x2, int16_t y2)
```
<dl>
<dt>描述</dt><dd>
绘制一个带有颜色渐变的实心三角形。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| pi0 | 第一个边缘颜色，调色板索引 0到255 |
| x0 | 第一个边缘X坐标以像素为单位 |
| y0 | 第一个边缘Y坐标以像素为单位 |
| pi1 | 第二个边缘颜色，调色板索引 0到255 |
| x1 | 第二条边的X坐标以像素为单位 |
| y1 | 第二条边的Y坐标以像素为单位 |
| pi2 | 第三边颜色，调色板索引 0到255 |
| x2 | 第三条边的X坐标以像素为单位 |
| y2 | 第三条边的Y坐标以像素为单位 |
</dd>
<dt>另见</dt><dd>
[tri], [ftri], [tri3d], [tritx], [mesh], [trns]
</dd>
</dl>
<hr>
## tri3d

```c
void tri3d(uint8_t pi0, int16_t x0, int16_t y0, int16_t z0,
    uint8_t pi1, int16_t x1, int16_t y1, int16_t z1,
    uint8_t pi2, int16_t x2, int16_t y2, int16_t z2)
```
<dl>
<dt>描述</dt><dd>
在[3D空间]中绘制一个带有颜色渐变的实心三角形。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| pi0 | 第一个边缘颜色，调色板索引 0到255 |
| x0 | 空间中第一条边的X坐标 |
| y0 | 空间中第一条边的Y坐标 |
| z0 | 空间中第一条边的Z坐标 |
| pi1 | 第二个边缘颜色，调色板索引 0到255 |
| x1 | 第二条边的空间X坐标 |
| y1 | 第二条边的空间Y坐标 |
| z1 | 第二条边的空间Z坐标 |
| pi2 | 第三边颜色，调色板索引 0到255 |
| x2 | 第三条边的空间X坐标 |
| y2 | 第三条边的空间Y坐标 |
| z2 | 第三条边的空间Z坐标 |
</dd>
<dt>另见</dt><dd>
[tri], [ftri], [tri2d], [tritx], [mesh], [trns]
</dd>
</dl>
<hr>
## tritx

```c
void tritx(uint8_t u0, uint8_t v0, int16_t x0, int16_t y0, int16_t z0,
    uint8_t u1, uint8_t v1, int16_t x1, int16_t y1, int16_t z1,
    uint8_t u2, uint8_t v2, int16_t x2, int16_t y2, int16_t z2)
```
<dl>
<dt>描述</dt><dd>
在[3D空间]中绘制纹理三角形。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| u0 | 第一个边缘纹理X坐标 0到255 |
| v0 | 第一个边缘纹理Y坐标 0到255 |
| x0 | 空间中第一条边的X坐标 |
| y0 | 空间中第一条边的Y坐标 |
| z0 | 空间中第一条边的Z坐标 |
| u1 | 第二个边缘纹理X坐标 0到255 |
| v1 | 第二个边缘纹理Y坐标 0到255 |
| x1 | 第二条边的空间X坐标 |
| y1 | 第二条边的空间Y坐标 |
| z1 | 第二条边的空间Z坐标 |
| u2 | 第三个边缘纹理X坐标 0到255 |
| v2 | 第三个边缘纹理Y坐标 0到255 |
| x2 | 第三条边的空间X坐标 |
| y2 | 第三条边的空间Y坐标 |
| z2 | 第三条边的空间Z坐标 |
</dd>
<dt>另见</dt><dd>
[tri], [ftri], [tri2d], [tri3d], [mesh], [trns]
</dd>
</dl>
<hr>
## mesh

```c
void mesh(addr_t verts, addr_t uvs, uint16_t numtri, addr_t tris)
```
<dl>
<dt>描述</dt><dd>
使用顶点索引和纹理坐标（或调色板）在[3D空间]中绘制由三角形组成的网格。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| verts | 顶点数组的地址，每个 3 x 2 字节，X、Y、Z |
| uvs | UV 数组的地址（如果为 0，则使用调色板），每个 2 x 1 字节，纹理 X、Y |
| numtri | 三角形数量 |
| tris | 带有索引的三角形数组的地址，每个索引 6 x 1 字节， vi1、ui1/pi1、vi2、ui2/pi2、vi3、ui3/pi3 |
</dd>
<dt>另见</dt><dd>
[tri], [ftri], [tri2d], [tri3d], [tritx], [trns]
</dd>
</dl>
<hr>
## rect

```c
void rect(uint8_t palidx, int16_t x0, int16_t y0, int16_t x1, int16_t y1)
```
<dl>
<dt>描述</dt><dd>
绘制一个矩形。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| palidx | 颜色，调色板索引 0到255 |
| x0 | 左上角X坐标以像素为单位 |
| y0 | 左上角Y坐标以像素为单位 |
| x1 | 右下X坐标以像素为单位 |
| y1 | 右下Y坐标以像素为单位 |
</dd>
<dt>另见</dt><dd>
[frect]
</dd>
</dl>
<hr>
## frect

```c
void frect(uint8_t palidx, int16_t x0, int16_t y0, int16_t x1, int16_t y1)
```
<dl>
<dt>描述</dt><dd>
绘制一个填充的矩形。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| palidx | 颜色，调色板索引 0到255 |
| x0 | 左上角X坐标以像素为单位 |
| y0 | 左上角Y坐标以像素为单位 |
| x1 | 右下X坐标以像素为单位 |
| y1 | 右下Y坐标以像素为单位 |
</dd>
<dt>另见</dt><dd>
[rect]
</dd>
</dl>
<hr>
## circ

```c
void circ(uint8_t palidx, int16_t x, int16_t y, uint16_t r)
```
<dl>
<dt>描述</dt><dd>
画一个圆圈。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| palidx | 颜色，调色板索引 0到255 |
| x | 以像素为单位的中心X坐标 |
| y | 以像素为单位的中心Y坐标 |
| r | 以像素为单位的半径 |
</dd>
<dt>另见</dt><dd>
[fcirc], [ellip], [fellip]
</dd>
</dl>
<hr>
## fcirc

```c
void fcirc(uint8_t palidx, int16_t x, int16_t y, uint16_t r)
```
<dl>
<dt>描述</dt><dd>
绘制一个实心圆。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| palidx | 颜色，调色板索引 0到255 |
| x | 以像素为单位的中心X坐标 |
| y | 以像素为单位的中心Y坐标 |
| r | 以像素为单位的半径 |
</dd>
<dt>另见</dt><dd>
[circ], [ellip], [fellip]
</dd>
</dl>
<hr>
## ellip

```c
void ellip(uint8_t palidx, int16_t x0, int16_t y0, int16_t x1, int16_t y1)
```
<dl>
<dt>描述</dt><dd>
绘制一个椭圆。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| palidx | 颜色，调色板索引 0到255 |
| x0 | 左上角X坐标以像素为单位 |
| y0 | 左上角Y坐标以像素为单位 |
| x1 | 右下X坐标以像素为单位 |
| y1 | 右下Y坐标以像素为单位 |
</dd>
<dt>另见</dt><dd>
[circ], [fcirc], [fellip]
</dd>
</dl>
<hr>
## fellip

```c
void fellip(uint8_t palidx, int16_t x0, int16_t y0, int16_t x1, int16_t y1)
```
<dl>
<dt>描述</dt><dd>
绘制一个实心椭圆。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| palidx | 颜色，调色板索引 0到255 |
| x0 | 左上角X坐标以像素为单位 |
| y0 | 左上角Y坐标以像素为单位 |
| x1 | 右下X坐标以像素为单位 |
| y1 | 右下Y坐标以像素为单位 |
</dd>
<dt>另见</dt><dd>
[circ], [fcirc], [ellip]
</dd>
</dl>
<hr>
## move

```c
void move(int16_t x, int16_t y, uint16_t deg)
```
<dl>
<dt>描述</dt><dd>
将乌龟移动到屏幕上或迷宫中的给定位置。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| x | 以像素为单位的X坐标 （或 1/128 块带有 [maze]） |
| y | 以像素为单位的Y坐标 |
| deg | 方向以度为单位，0到359，0为屏幕向上，90为向右 |
</dd>
<dt>另见</dt><dd>
[left], [right], [up], [down], [color], [forw], [back]
</dd>
</dl>
<hr>
## left

```c
void left(uint16_t deg)
```
<dl>
<dt>描述</dt><dd>
向左转乌龟。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| deg | 度数变化，0到359 |
</dd>
<dt>另见</dt><dd>
[move], [right], [up], [down], [color], [forw], [back]
</dd>
</dl>
<hr>
## right

```c
void right(uint16_t deg)
```
<dl>
<dt>描述</dt><dd>
让乌龟向右转。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| deg | 度数变化，0到359 |
</dd>
<dt>另见</dt><dd>
[move], [left], [up], [down], [color], [forw], [back]
</dd>
</dl>
<hr>
## up

```c
void up(void)
```
<dl>
<dt>描述</dt><dd>
抬起乌龟的尾巴。 海龟会在不画线的情况下移动。
</dd>
<dt>另见</dt><dd>
[move], [left], [right], [down], [color], [forw], [back]
</dd>
</dl>
<hr>
## down

```c
void down(void)
```
<dl>
<dt>描述</dt><dd>
把乌龟的尾巴放下来。 海龟将移动画一条线（参见[color]）。
</dd>
<dt>另见</dt><dd>
[move], [left], [right], [up], [color], [forw], [back]
</dd>
</dl>
<hr>
## color

```c
void color(uint8_t palidx)
```
<dl>
<dt>描述</dt><dd>
设置乌龟油漆颜色。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| palidx | 颜色，调色板索引 0到255 |
</dd>
<dt>另见</dt><dd>
[move], [left], [right], [up], [down], [forw], [back]
</dd>
</dl>
<hr>
## forw

```c
void forw(uint16_t cnt)
```
<dl>
<dt>描述</dt><dd>
使乌龟向前移动。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| cnt | 以像素为单位的数量（或带有[maze]的 1/128 块） |
</dd>
<dt>另见</dt><dd>
[move], [left], [right], [up], [down], [color], [back]
</dd>
</dl>
<hr>
## back

```c
void back(uint16_t cnt)
```
<dl>
<dt>描述</dt><dd>
使乌龟向后移动。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| cnt | 以像素为单位的数量（或带有[maze]的 1/128 块） |
</dd>
<dt>另见</dt><dd>
[move], [left], [right], [up], [down], [color], [forw]
</dd>
</dl>
<hr>
## spr

```c
void spr(int16_t x, int16_t y, uint16_t sprite, uint8_t sw, uint8_t sh, int8_t scale, uint8_t type)
```
<dl>
<dt>描述</dt><dd>
显示一个精灵或多个相邻的精灵。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| x | 以像素为单位的X坐标 |
| y | 以像素为单位的Y坐标 |
| sprite | 精灵标识符，0到1023 |
| sw | 水平精灵数量 |
| sh | 垂直精灵数量 |
| scale | 规模，-3到4 |
| type | 变换, 0=正常, 1=旋转 90, 2=旋转 180, 3=旋转 270, 4=垂直翻转, 5=翻转+90, 6=水平翻转, 7=翻转+270 |
</dd>
<dt>另见</dt><dd>
[dlg], [stext]
</dd>
</dl>
<hr>
## dlg

```c
void dlg(int16_t x, int16_t y, uint16_t w, uint16_t h, int8_t scale,
    uint16_t tl, uint16_t tm, uint16_t tr,
    uint16_t ml, uint16_t bg, uint16_t mr,
    uint16_t bl, uint16_t bm, uint16_t br)
```
<dl>
<dt>描述</dt><dd>
使用精灵显示对话窗口。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| x | 以像素为单位的X坐标 |
| y | 以像素为单位的Y坐标 |
| w | 对话框宽度（以像素为单位） |
| h | 对话框高度（以像素为单位） |
| scale | 规模，-3到4 |
| tl | 左上角精灵标识符 |
| tm | 顶部中间精灵标识符 |
| tr | 右上角精灵标识符 |
| ml | 中间左侧精灵标识符 |
| bg | 背景精灵标识符 |
| mr | 中间右侧精灵标识符 |
| bl | 左下角精灵标识符 |
| bm | 底部中间精灵标识符 |
| br | 右下角精灵标识符 |
</dd>
<dt>另见</dt><dd>
[spr], [stext]
</dd>
</dl>
<hr>
## stext

```c
void stext(int16_t x, int16_t y, uint16_t fs, uint16_t fu, uint8_t sw, uint8_t sh, int8_t scale, str_t str)
```
<dl>
<dt>描述</dt><dd>
使用精灵在屏幕上显示文本。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| x | 以像素为单位的X坐标 |
| y | 以像素为单位的Y坐标 |
| fs | 用于显示的第一个精灵标识符 |
| fu | 字符串中的第一个 UNICODE（最小字符） |
| sw | 水平精灵数量 |
| sh | 垂直精灵数量 |
| scale | 规模，-3到4 |
| str | 以零结尾的 UTF-8 字符串 |
</dd>
<dt>另见</dt><dd>
[spr], [dlg]
</dd>
</dl>
<hr>
## remap

```c
void remap(addr_t replace)
```
<dl>
<dt>描述</dt><dd>
替换地图上的图块。 可用于为地图上的图块设置动画。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| replace | 256 个精灵标识符的数组 |
</dd>
<dt>另见</dt><dd>
[mget], [mset], [map], [maze]
</dd>
</dl>
<hr>
## mget

```c
uint16_t mget(uint16_t mx, uint16_t my)
```
<dl>
<dt>描述</dt><dd>
返回地图上的一个图块。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| mx | 地图上的X坐标（以图块为单位） |
| my | 地图上的Y坐标（以图块为单位） |
</dd>
<dt>返回值</dt><dd>
The sprite id of the tile at the given coordinate.
</dd>
<dt>另见</dt><dd>
[remap], [mset], [map], [maze]
</dd>
</dl>
<hr>
## mset

```c
void mset(uint16_t mx, uint16_t my, uint16_t sprite)
```
<dl>
<dt>描述</dt><dd>
Sets one tile on map.
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| mx | 地图上的X坐标（以图块为单位） |
| my | 地图上的Y坐标（以图块为单位） |
| sprite | 精灵标识符，0到1023 |
</dd>
<dt>另见</dt><dd>
[remap], [mget], [map], [maze]
</dd>
</dl>
<hr>
## map

```c
void map(int16_t x, int16_t y, uint16_t mx, uint16_t my, uint16_t mw, uint16_t mh, int8_t scale)
```
<dl>
<dt>描述</dt><dd>
绘制地图（部分）。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| x | 以像素为单位的X坐标 |
| y | 以像素为单位的Y坐标 |
| mx | 地图上的X坐标（以图块为单位） |
| my | 地图上的Y坐标（以图块为单位） |
| mw | 水平瓷砖数量 |
| mh | 垂直瓷砖数量 |
| scale | 规模，-3到4 |
</dd>
<dt>另见</dt><dd>
[remap], [mget], [mset], [maze]
</dd>
</dl>
<hr>
## maze

```c
void maze(uint16_t mx, uint16_t my, uint16_t mw, uint16_t mh, uint8_t scale,
    uint16_t sky, uint16_t grd, uint16_t door, uint16_t wall, uint16_t obj, uint8_t numnpc, addr_t npc)
```
<dl>
<dt>描述</dt><dd>
使用海龟的位置将地图显示为 3D 迷宫。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| mx | 地图上的X坐标（以图块为单位） |
| my | 地图上的Y坐标（以图块为单位） |
| mw | 水平瓷砖数量 |
| mh | 垂直瓷砖数量 |
| scale | 每个图块的精灵数量（2 的幂，0到3） |
| sky | 天空瓦片索引 |
| grd | 地面瓷砖索引 |
| door | 第一门瓷砖索引 |
| wall | 第一墙砖索引 |
| obj | 第一个对象图块索引 |
| numnpc | NPC记录数 |
| npc | 一个uint32_t数组，由numnpc乘以x、y、图块索引三元组组成 |
</dd>
<dt>另见</dt><dd>
[remap], [mget], [mset], [map]
</dd>
</dl>

# 用户输入

## getpad

```c
int getpad(int pad, int btn)
```
<dl>
<dt>描述</dt><dd>
获取游戏手柄按钮的当前状态。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| pad | 游戏手柄索引，0到3 |
| btn | [游戏手柄] 按钮之一`BTN_` |
</dd>
<dt>返回值</dt><dd>
如果未按下则为零，如果按下则非零。
</dd>
<dt>另见</dt><dd>
[prspad], [relpad], [getbtn], [getclk], [getkey]
</dd>
</dl>
<hr>
## prspad

```c
int prspad(int pad, int btn)
```
<dl>
<dt>描述</dt><dd>
如果自上次调用后按下了游戏手柄按钮，则返回 真的。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| pad | 游戏手柄索引，0到3 |
| btn | [游戏手柄] 按钮之一`BTN_` |
</dd>
<dt>返回值</dt><dd>
如果未按下则为零，如果按下则非零。
</dd>
<dt>另见</dt><dd>
[relpad], [getpad], [getbtn], [getclk], [getkey]
</dd>
</dl>
<hr>
## relpad

```c
int relpad(int pad, int btn)
```
<dl>
<dt>描述</dt><dd>
如果自上次调用后释放了游戏手柄按钮，则返回 真的。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| pad | 游戏手柄索引，0到3 |
| btn | [游戏手柄] 按钮之一`BTN_` |
</dd>
<dt>返回值</dt><dd>
如果未释放则为零，如果释放则非零。
</dd>
<dt>另见</dt><dd>
[prspad], [getpad], [getbtn], [getclk], [getkey]
</dd>
</dl>
<hr>
## getbtn

```c
int getbtn(int btn)
```
<dl>
<dt>描述</dt><dd>
获取鼠标按键状态。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| btn | [指针]按钮之一`BTN_`或`SCR_` |
</dd>
<dt>返回值</dt><dd>
如果未按下则为零，如果按下则非零。
</dd>
<dt>另见</dt><dd>
[prspad], [relpad], [getpad], [getclk], [getkey]
</dd>
</dl>
<hr>
## getclk

```c
int getclk(int btn)
```
<dl>
<dt>描述</dt><dd>
获取鼠标按钮点击。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| btn | [指针]按钮之一`BTN_` |
</dd>
<dt>返回值</dt><dd>
如果未单击则为零，如果单击则非零。
</dd>
<dt>另见</dt><dd>
[prspad], [relpad], [getpad], [getbtn], [getkey]
</dd>
</dl>
<hr>
## getkey

```c
int getkey(int sc)
```
<dl>
<dt>描述</dt><dd>
获取按键的当前状态。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| sc | 扫描码，1到144，参见[键盘] |
</dd>
<dt>返回值</dt><dd>
如果未按下则为零，如果按下则非零。
</dd>
<dt>另见</dt><dd>
[prspad], [relpad], [getpad], [getbtn], [getclk]
</dd>
</dl>
<hr>
## popkey

```c
uint32_t popkey(void)
```
<dl>
<dt>描述</dt><dd>
从键盘队列中弹出一个UTF-8键。 请参阅[键盘]，以及阻塞版本[getc]。
</dd>
<dt>返回值</dt><dd>
键的UTF-8表示形式，如果队列为空（无阻塞），则为 0。
</dd>
<dt>另见</dt><dd>
[pendkey], [lenkey], [speckey], [getc]
</dd>
</dl>
<hr>
## pendkey

```c
int pendkey(void)
```
<dl>
<dt>描述</dt><dd>
如果队列中有一个待处理的密钥，则返回 true（但将该密钥保留在队列中，不会将其删除）。
</dd>
<dt>返回值</dt><dd>
如果队列中有待处理的键，则返回 1。
</dd>
<dt>另见</dt><dd>
[popkey], [lenkey], [speckey]
</dd>
</dl>
<hr>
## lenkey

```c
int lenkey(uint32_t key)
```
<dl>
<dt>描述</dt><dd>
返回UTF-8密钥的长度（以字节为单位）。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| key | 密钥，从队列中弹出 |
</dd>
<dt>返回值</dt><dd>
UTF-8表示的长度（以字节为单位）。
</dd>
<dt>另见</dt><dd>
[popkey], [pendkey], [speckey]
</dd>
</dl>
<hr>
## speckey

```c
int speckey(uint32_t key)
```
<dl>
<dt>描述</dt><dd>
如果钥匙是特殊键，则返回真的。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| key | 密钥，从队列中弹出 |
</dd>
<dt>返回值</dt><dd>
如果是特殊键则返回 1，如果是可打印键则返回 0。
</dd>
<dt>另见</dt><dd>
[popkey], [pendkey], [lenkey]
</dd>
</dl>

# 数学

## rand

```c
uint32_t rand(void)
```
<dl>
<dt>描述</dt><dd>
随机应变。 使用`%`取模使其变小，例如`1 + rand() % 6`返回 1 到 6 之间的随机值，就像骰子一样。
</dd>
<dt>返回值</dt><dd>
0到2^^32^^-1 (4294967295) 之间的随机数。
</dd>
<dt>另见</dt><dd>
[rnd]
</dd>
</dl>
<hr>
## rnd

```c
float rnd(void)
```
<dl>
<dt>描述</dt><dd>
随机应变。 与[rand]相同，但返回浮点数。
</dd>
<dt>返回值</dt><dd>
0.0到1.0 之间的随机数。
</dd>
<dt>另见</dt><dd>
[rand]
</dd>
</dl>
<hr>
## float

```c
float float(int val)
```
<dl>
<dt>描述</dt><dd>
返回与整数等价的浮点值。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| val | 价值 |
</dd>
<dt>返回值</dt><dd>
浮点值。
</dd>
<dt>另见</dt><dd>
[int]
</dd>
</dl>
<hr>
## int

```c
int int(float val)
```
<dl>
<dt>描述</dt><dd>
返回浮点数的等效整数。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| val | 价值 |
</dd>
<dt>返回值</dt><dd>
值的整数。
</dd>
<dt>另见</dt><dd>
[float]
</dd>
</dl>
<hr>
## floor

```c
float floor(float val)
```
<dl>
<dt>描述</dt><dd>
返回不大于该值的最大整数。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| val | 价值 |
</dd>
<dt>返回值</dt><dd>
价值下限。
</dd>
<dt>另见</dt><dd>
[ceil]
</dd>
</dl>
<hr>
## ceil

```c
float ceil(float val)
```
<dl>
<dt>描述</dt><dd>
返回不小于该值的最小整数。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| val | 价值 |
</dd>
<dt>返回值</dt><dd>
价值的上限。
</dd>
<dt>另见</dt><dd>
[floor]
</dd>
</dl>
<hr>
## sgn

```c
float sgn(float val)
```
<dl>
<dt>描述</dt><dd>
返回值的符号。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| val | 价值 |
</dd>
<dt>返回值</dt><dd>
1.0或-1.0。
</dd>
<dt>另见</dt><dd>
[abs]
</dd>
</dl>
<hr>
## abs

```c
float abs(float val)
```
<dl>
<dt>描述</dt><dd>
返回值的绝对值。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| val | 价值 |
</dd>
<dt>返回值</dt><dd>
无论是 value 还是 -value，始终为正值。
</dd>
<dt>另见</dt><dd>
[sgn]
</dd>
</dl>
<hr>
## exp

```c
float exp(float val)
```
<dl>
<dt>描述</dt><dd>
返回值的指数，即自然对数的底数的幂。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| val | 价值 |
</dd>
<dt>返回值</dt><dd>
返回 e^^val^^。
</dd>
<dt>另见</dt><dd>
[log], [pow]
</dd>
</dl>
<hr>
## log

```c
float log(float val)
```
<dl>
<dt>描述</dt><dd>
返回值的自然对数。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| val | 价值 |
</dd>
<dt>返回值</dt><dd>
返回值的自然对数。
</dd>
<dt>另见</dt><dd>
[exp]
</dd>
</dl>
<hr>
## pow

```c
float pow(float val, float exp)
```
<dl>
<dt>描述</dt><dd>
返回指数次方的值。 这是一个缓慢的操作，尽量避免。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| val | 价值 |
| exp | 指数 |
</dd>
<dt>返回值</dt><dd>
返回 val^^exp^^。
</dd>
<dt>另见</dt><dd>
[exp], [sqrt], [rsqrt]
</dd>
</dl>
<hr>
## sqrt

```c
float sqrt(float val)
```
<dl>
<dt>描述</dt><dd>
返回值的平方根。 这是一个缓慢的操作，尽量避免。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| val | 价值 |
</dd>
<dt>返回值</dt><dd>
值的平方根。
</dd>
<dt>另见</dt><dd>
[pow], [rsqrt]
</dd>
</dl>
<hr>
## rsqrt

```c
float rsqrt(float val)
```
<dl>
<dt>描述</dt><dd>
返回值的平方根的倒数(`1 / sqrt(val)`)。 使用John Carmack的快速方法。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| val | 价值 |
</dd>
<dt>返回值</dt><dd>
值的平方根的倒数。
</dd>
<dt>另见</dt><dd>
[pow], [sqrt]
</dd>
</dl>
<hr>
## clamp

```c
float clamp(float val, float minv, float maxv)
```
<dl>
<dt>描述</dt><dd>
将值限制在限制之间。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| val | 价值 |
| minv | 最小值 |
| maxv | 最大值 |
</dd>
<dt>返回值</dt><dd>
钳位值。
</dd>
<dt>另见</dt><dd>
[clampv2], [clampv3], [clampv4]
</dd>
</dl>
<hr>
## lerp

```c
float lerp(float a, float b, float t)
```
<dl>
<dt>描述</dt><dd>
线性插值两个数字。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 第一个浮点数 |
| b | 第二个浮点数 |
| t | 0.0和1.0 之间的插值 |
</dd>
<dt>另见</dt><dd>
[lerpv2], [lerpv3], [lerpv4], [lerpq], [slerpq]
</dd>
</dl>
<hr>
## pi

```c
float pi(void)
```
<dl>
<dt>描述</dt><dd>
以浮点数形式返回 π。
</dd>
<dt>返回值</dt><dd>
值 3.14159265358979323846。
</dd>
</dl>
<hr>
## cos

```c
float cos(uint16_t deg)
```
<dl>
<dt>描述</dt><dd>
返回余弦值。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| deg | 度数，0到359，0在上，90在右 |
</dd>
<dt>返回值</dt><dd>
度数的余弦，介于 -1.0到1.0 之间。
</dd>
<dt>另见</dt><dd>
[sin], [tan], [acos], [asin], [atan], [atan2]
</dd>
</dl>
<hr>
## sin

```c
float sin(uint16_t deg)
```
<dl>
<dt>描述</dt><dd>
返回正弦值。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| deg | 度数，0到359，0在上，90在右 |
</dd>
<dt>返回值</dt><dd>
度数的正弦值，介于 -1.0到1.0 之间。
</dd>
<dt>另见</dt><dd>
[cos], [tan], [acos], [asin], [atan], [atan2]
</dd>
</dl>
<hr>
## tan

```c
float tan(uint16_t deg)
```
<dl>
<dt>描述</dt><dd>
返回正切值。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| deg | 度数，0到359，0在上，90在右 |
</dd>
<dt>返回值</dt><dd>
次数的正切，介于 -1.0到1.0 之间。
</dd>
<dt>另见</dt><dd>
[cos], [sin], [acos], [asin], [atan], [atan2]
</dd>
</dl>
<hr>
## acos

```c
uint16_t acos(float val)
```
<dl>
<dt>描述</dt><dd>
返回反余弦值。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| val | 值，-1.0到1.0 |
</dd>
<dt>返回值</dt><dd>
反余弦度数，0到359，0向上，90向右。
</dd>
<dt>另见</dt><dd>
[cos], [sin], [tan], [asin], [atan], [atan2]
</dd>
</dl>
<hr>
## asin

```c
uint16_t asin(float val)
```
<dl>
<dt>描述</dt><dd>
返回时不带弧线。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| val | 值，-1.0到1.0 |
</dd>
<dt>返回值</dt><dd>
正弦正弦度数，0到359，0向上，90向右。
</dd>
<dt>另见</dt><dd>
[cos], [sin], [tan], [acos], [atan], [atan2]
</dd>
</dl>
<hr>
## atan

```c
uint16_t atan(float val)
```
<dl>
<dt>描述</dt><dd>
返回反正切值。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| val | 值，-1.0到1.0 |
</dd>
<dt>返回值</dt><dd>
弧线切线的度数，0到359，0向上，90向右。
</dd>
<dt>另见</dt><dd>
[cos], [sin], [tan], [acos], [asin], [atan2]
</dd>
</dl>
<hr>
## atan2

```c
uint16_t atan2(float y, float x)
```
<dl>
<dt>描述</dt><dd>
返回y/x的反正切值，使用y和x的符号确定象限。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| y | Y坐标 |
| x | X坐标 |
</dd>
<dt>返回值</dt><dd>
弧线切线的度数，0到359，0向上，90向右。
</dd>
<dt>另见</dt><dd>
[cos], [sin], [tan], [acos], [asin]
</dd>
</dl>
<hr>
## dotv2

```c
float dotv2(addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
计算具有两个元素的两个向量的点积。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 两个浮点数的地址 |
| b | 两个浮点数的地址 |
</dd>
<dt>返回值</dt><dd>
向量的点积。
</dd>
<dt>另见</dt><dd>
[lenv2], [scalev2], [negv2], [addv2], [subv2], [mulv2], [divv2], [clampv2], [lerpv2], [normv2]
</dd>
</dl>
<hr>
## lenv2

```c
float lenv2(addr_t a)
```
<dl>
<dt>描述</dt><dd>
计算具有两个元素的向量的长度。 这很慢，请尽量避免（参见[normv2]）。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 两个浮点数的地址 |
</dd>
<dt>返回值</dt><dd>
矢量的长度。
</dd>
<dt>另见</dt><dd>
[dotv2], [scalev2], [negv2], [addv2], [subv2], [mulv2], [divv2], [clampv2], [lerpv2], [normv2]
</dd>
</dl>
<hr>
## scalev2

```c
void scalev2(addr_t a, float s)
```
<dl>
<dt>描述</dt><dd>
用两个元素缩放向量。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 两个浮点数的地址 |
| s | 定标器值 |
</dd>
<dt>另见</dt><dd>
[dotv2], [lenv2], [negv2], [addv2], [subv2], [mulv2], [divv2], [clampv2], [lerpv2], [normv2]
</dd>
</dl>
<hr>
## negv2

```c
void negv2(addr_t a)
```
<dl>
<dt>描述</dt><dd>
对具有两个元素的向量取反。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 两个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[dotv2], [lenv2], [scalev2], [addv2], [subv2], [mulv2], [divv2], [clampv2], [lerpv2], [normv2]
</dd>
</dl>
<hr>
## addv2

```c
void addv2(addr_t dst, addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
将带有两个元素的向量相加。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 两个浮点数的地址， 输出 |
| a | 两个浮点数的地址 |
| b | 两个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[dotv2], [lenv2], [scalev2], [negv2], [subv2], [mulv2], [divv2], [clampv2], [lerpv2], [normv2]
</dd>
</dl>
<hr>
## subv2

```c
void subv2(addr_t dst, addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
用两个元素减去向量。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 两个浮点数的地址， 输出 |
| a | 两个浮点数的地址 |
| b | 两个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[dotv2], [lenv2], [scalev2], [negv2], [addv2], [mulv2], [divv2], [clampv2], [lerpv2], [normv2]
</dd>
</dl>
<hr>
## mulv2

```c
void mulv2(addr_t dst, addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
将向量与两个元素相乘。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 两个浮点数的地址， 输出 |
| a | 两个浮点数的地址 |
| b | 两个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[dotv2], [lenv2], [scalev2], [negv2], [addv2], [subv2], [divv2], [clampv2], [lerpv2], [normv2]
</dd>
</dl>
<hr>
## divv2

```c
void divv2(addr_t dst, addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
将向量除以两个元素。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 两个浮点数的地址， 输出 |
| a | 两个浮点数的地址 |
| b | 两个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[dotv2], [lenv2], [scalev2], [negv2], [addv2], [subv2], [mulv2], [clampv2], [lerpv2], [normv2]
</dd>
</dl>
<hr>
## clampv2

```c
void clampv2(addr_t dst, addr_t v, addr_t minv, addr_t maxv)
```
<dl>
<dt>描述</dt><dd>
用两个元素钳位向量。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 两个浮点数的地址， 输出 |
| v | 两个浮点数的地址， 输入 |
| minv | 两个浮点数的地址， 最低限度 |
| maxv | 两个浮点数的地址， 最大限度 |
</dd>
<dt>另见</dt><dd>
[dotv2], [lenv2], [scalev2], [negv2], [addv2], [subv2], [mulv2], [divv2], [lerpv2], [normv2]
</dd>
</dl>
<hr>
## lerpv2

```c
void lerpv2(addr_t dst, addr_t a, addr_t b, float t)
```
<dl>
<dt>描述</dt><dd>
线性插值具有两个元素的向量。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 两个浮点数的地址， 输出 |
| a | 两个浮点数的地址 |
| b | 两个浮点数的地址 |
| t | 0.0和1.0 之间的插值 |
</dd>
<dt>另见</dt><dd>
[dotv2], [lenv2], [scalev2], [negv2], [addv2], [subv2], [mulv2], [divv2], [clampv2], [normv2]
</dd>
</dl>
<hr>
## normv2

```c
void normv2(addr_t a)
```
<dl>
<dt>描述</dt><dd>
用两个元素标准化向量。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 两个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[dotv2], [lenv2], [scalev2], [negv2], [addv2], [subv2], [mulv2], [divv2], [clampv2], [lerpv2]
</dd>
</dl>
<hr>
## dotv3

```c
float dotv3(addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
计算具有三个元素的两个向量的点积。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 三个浮点数的地址 |
| b | 三个浮点数的地址 |
</dd>
<dt>返回值</dt><dd>
向量的点积。
</dd>
<dt>另见</dt><dd>
[lenv3], [scalev3], [negv3], [addv3], [subv3], [mulv3], [divv3], [crossv3], [clampv3], [lerpv3], [normv3]
</dd>
</dl>
<hr>
## lenv3

```c
float lenv3(addr_t a)
```
<dl>
<dt>描述</dt><dd>
计算具有三个元素的向量的长度。 这很慢，尽量避免（参见[normv3]）。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 三个浮点数的地址 |
</dd>
<dt>返回值</dt><dd>
矢量的长度。
</dd>
<dt>另见</dt><dd>
[dotv3], [scalev3], [negv3], [addv3], [subv3], [mulv3], [divv3], [crossv3], [clampv3], [lerpv3], [normv3]
</dd>
</dl>
<hr>
## scalev3

```c
void scalev3(addr_t a, float s)
```
<dl>
<dt>描述</dt><dd>
用三个元素缩放向量。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 三个浮点数的地址 |
| s | 定标器值 |
</dd>
<dt>另见</dt><dd>
[dotv3], [lenv3], [negv3], [addv3], [subv3], [mulv3], [divv3], [crossv3], [clampv3], [lerpv3], [normv3]
</dd>
</dl>
<hr>
## negv3

```c
void negv3(addr_t a)
```
<dl>
<dt>描述</dt><dd>
对具有三个元素的向量取反。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 三个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[dotv3], [lenv3], [scalev3], [addv3], [subv3], [mulv3], [divv3], [crossv3], [clampv3], [lerpv3], [normv3]
</dd>
</dl>
<hr>
## addv3

```c
void addv3(addr_t dst, addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
将具有三个元素的向量相加。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 三个浮点数的地址， 输出 |
| a | 三个浮点数的地址 |
| b | 三个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[dotv3], [lenv3], [scalev3], [negv3], [subv3], [mulv3], [divv3], [crossv3], [clampv3], [lerpv3], [normv3]
</dd>
</dl>
<hr>
## subv3

```c
void subv3(addr_t dst, addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
用三个元素减去向量。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 三个浮点数的地址， 输出 |
| a | 三个浮点数的地址 |
| b | 三个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[dotv3], [lenv3], [scalev3], [negv3], [addv3], [mulv3], [divv3], [crossv3], [clampv3], [lerpv3], [normv3]
</dd>
</dl>
<hr>
## mulv3

```c
void mulv3(addr_t dst, addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
将向量与三个元素相乘。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 三个浮点数的地址， 输出 |
| a | 三个浮点数的地址 |
| b | 三个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[dotv3], [lenv3], [scalev3], [negv3], [addv3], [subv3], [divv3], [crossv3], [clampv3], [lerpv3], [normv3]
</dd>
</dl>
<hr>
## divv3

```c
void divv3(addr_t dst, addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
将向量除以三个元素。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 三个浮点数的地址， 输出 |
| a | 三个浮点数的地址 |
| b | 三个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[dotv3], [lenv3], [scalev3], [negv3], [addv3], [subv3], [mulv3], [crossv3], [clampv3], [lerpv3], [normv3]
</dd>
</dl>
<hr>
## crossv3

```c
void crossv3(addr_t dst, addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
计算具有三个元素的向量的叉积。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 三个浮点数的地址， 输出 |
| a | 三个浮点数的地址 |
| b | 三个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[dotv3], [lenv3], [scalev3], [negv3], [addv3], [subv3], [mulv3], [divv3], [clampv3], [lerpv3], [normv3]
</dd>
</dl>
<hr>
## clampv3

```c
void clampv3(addr_t dst, addr_t v, addr_t minv, addr_t maxv)
```
<dl>
<dt>描述</dt><dd>
钳位具有三个元素的向量。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 三个浮点数的地址， 输出 |
| v | 三个浮点数的地址， 输入 |
| minv | 三个浮点数的地址， 最低限度 |
| maxv | 三个浮点数的地址， 最大限度 |
</dd>
<dt>另见</dt><dd>
[dotv3], [lenv3], [scalev3], [negv3], [addv3], [subv3], [mulv3], [divv3], [crossv3], [lerpv3], [normv3]
</dd>
</dl>
<hr>
## lerpv3

```c
void lerpv3(addr_t dst, addr_t a, addr_t b, float t)
```
<dl>
<dt>描述</dt><dd>
线性插值具有三个元素的向量。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 三个浮点数的地址， 输出 |
| a | 三个浮点数的地址 |
| b | 三个浮点数的地址 |
| t | 0.0和1.0 之间的插值 |
</dd>
<dt>另见</dt><dd>
[dotv3], [lenv3], [scalev3], [negv3], [addv3], [subv3], [mulv3], [divv3], [crossv3], [clampv3], [normv3]
</dd>
</dl>
<hr>
## normv3

```c
void normv3(addr_t a)
```
<dl>
<dt>描述</dt><dd>
用三个元素标准化向量。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 三个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[dotv3], [lenv3], [scalev3], [negv3], [addv3], [subv3], [mulv3], [divv3], [crossv3], [clampv3], [lerpv3]
</dd>
</dl>
<hr>
## dotv4

```c
float dotv4(addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
计算具有四个元素的两个向量的点积。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 四个浮点数的地址 |
| b | 四个浮点数的地址 |
</dd>
<dt>返回值</dt><dd>
向量的点积。
</dd>
<dt>另见</dt><dd>
[lenv4], [scalev4], [negv4], [addv4], [subv4], [mulv4], [divv4], [clampv4], [lerpv4], [normv4]
</dd>
</dl>
<hr>
## lenv4

```c
float lenv4(addr_t a)
```
<dl>
<dt>描述</dt><dd>
计算具有四个元素的向量的长度。 这很慢，尽量避免（参见[normv4]）。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 四个浮点数的地址 |
</dd>
<dt>返回值</dt><dd>
矢量的长度。
</dd>
<dt>另见</dt><dd>
[dotv4], [scalev4], [negv4], [addv4], [subv4], [mulv4], [divv4], [clampv4], [lerpv4], [normv4]
</dd>
</dl>
<hr>
## scalev4

```c
void scalev4(addr_t a, float s)
```
<dl>
<dt>描述</dt><dd>
用四个元素缩放向量。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 四个浮点数的地址 |
| s | 定标器值 |
</dd>
<dt>另见</dt><dd>
[dotv4], [lenv4], [negv4], [addv4], [subv4], [mulv4], [divv4], [clampv4], [lerpv4], [normv4]
</dd>
</dl>
<hr>
## negv4

```c
void negv4(addr_t a)
```
<dl>
<dt>描述</dt><dd>
对具有四个元素的向量取反。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 四个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[dotv4], [lenv4], [scalev4], [addv4], [subv4], [mulv4], [divv4], [clampv4], [lerpv4], [normv4]
</dd>
</dl>
<hr>
## addv4

```c
void addv4(addr_t dst, addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
将具有四个元素的向量相加。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 四个浮点数的地址， 输出 |
| a | 四个浮点数的地址 |
| b | 四个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[dotv4], [lenv4], [negv4], [scalev4], [subv4], [mulv4], [divv4], [clampv4], [lerpv4], [normv4]
</dd>
</dl>
<hr>
## subv4

```c
void subv4(addr_t dst, addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
用四个元素减去向量。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 四个浮点数的地址， 输出 |
| a | 四个浮点数的地址 |
| b | 四个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[dotv4], [lenv4], [scalev4], [negv4], [addv4], [mulv4], [divv4], [clampv4], [lerpv4], [normv4]
</dd>
</dl>
<hr>
## mulv4

```c
void mulv4(addr_t dst, addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
将向量与四个元素相乘。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 四个浮点数的地址， 输出 |
| a | 四个浮点数的地址 |
| b | 四个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[dotv4], [lenv4], [scalev4], [negv4], [addv4], [subv4], [divv4], [clampv4], [lerpv4], [normv4]
</dd>
</dl>
<hr>
## divv4

```c
void divv4(addr_t dst, addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
将向量除以四个元素。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 四个浮点数的地址， 输出 |
| a | 四个浮点数的地址 |
| b | 四个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[dotv4], [lenv4], [scalev4], [negv4], [addv4], [subv4], [mulv4], [clampv4], [lerpv4], [normv4]
</dd>
</dl>
<hr>
## clampv4

```c
void clampv4(addr_t dst, addr_t v, addr_t minv, addr_t maxv)
```
<dl>
<dt>描述</dt><dd>
钳位具有四个元素的向量。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 四个浮点数的地址， 输出 |
| v | 四个浮点数的地址， 输入 |
| minv | 四个浮点数的地址， 最低限度 |
| maxv | 四个浮点数的地址， 最大限度 |
</dd>
<dt>另见</dt><dd>
[dotv4], [lenv4], [scalev4], [negv4], [addv4], [subv4], [mulv4], [divv4], [lerpv4], [normv4]
</dd>
</dl>
<hr>
## lerpv4

```c
void lerpv4(addr_t dst, addr_t a, addr_t b, float t)
```
<dl>
<dt>描述</dt><dd>
线性插值具有四个元素的向量。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 四个浮点数的地址， 输出 |
| a | 四个浮点数的地址 |
| b | 四个浮点数的地址 |
| t | 0.0和1.0 之间的插值 |
</dd>
<dt>另见</dt><dd>
[dotv4], [lenv4], [scalev4], [negv4], [addv4], [subv4], [mulv4], [divv4], [clampv4], [normv4]
</dd>
</dl>
<hr>
## normv4

```c
void normv4(addr_t a)
```
<dl>
<dt>描述</dt><dd>
用四个元素标准化向量。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 四个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[dotv4], [lenv4], [scalev4], [negv4], [addv4], [subv4], [mulv4], [divv4], [clampv4], [lerpv4]
</dd>
</dl>
<hr>
## idq

```c
void idq(addr_t a)
```
<dl>
<dt>描述</dt><dd>
加载单位四元数。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 四个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[eulerq], [dotq], [lenq], [scaleq], [negq], [addq], [subq], [mulq], [rotq], [lerpq], [slerpq], [normq]
</dd>
</dl>
<hr>
## eulerq

```c
void eulerq(addr_t dst, uint16_t pitch, uint16_t yaw, uint16_t roll)
```
<dl>
<dt>描述</dt><dd>
使用欧拉角加载四元数。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 四个浮点数的地址， 输出 |
| pitch | 绕X轴旋转（以度为单位），0到359 |
| yaw | 绕Y轴旋转（以度为单位），0到359 |
| roll | 绕Z轴旋转（以度为单位），0到359 |
</dd>
<dt>另见</dt><dd>
[idq], [dotq], [lenq], [scaleq], [negq], [addq], [subq], [mulq], [rotq], [lerpq], [slerpq], [normq]
</dd>
</dl>
<hr>
## dotq

```c
float dotq(addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
计算四元数的点积。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 四个浮点数的地址 |
| b | 四个浮点数的地址 |
</dd>
<dt>返回值</dt><dd>
四元数的点积。
</dd>
<dt>另见</dt><dd>
[idq], [eulerq], [lenq], [scaleq], [negq], [addq], [subq], [mulq], [rotq], [lerpq], [slerpq], [normq]
</dd>
</dl>
<hr>
## lenq

```c
float lenq(addr_t a)
```
<dl>
<dt>描述</dt><dd>
计算四元数的长度。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 四个浮点数的地址 |
</dd>
<dt>返回值</dt><dd>
四元数的长度。
</dd>
<dt>另见</dt><dd>
[idq], [eulerq], [dotq], [scaleq], [negq], [addq], [subq], [mulq], [rotq], [lerpq], [slerpq], [normq]
</dd>
</dl>
<hr>
## scaleq

```c
void scaleq(addr_t a, float s)
```
<dl>
<dt>描述</dt><dd>
缩放四元数。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 四个浮点数的地址 |
| s | 定标器值 |
</dd>
<dt>另见</dt><dd>
[idq], [eulerq], [dotq], [lenq], [negq], [addq], [subq], [mulq], [rotq], [lerpq], [slerpq], [normq]
</dd>
</dl>
<hr>
## negq

```c
void negq(addr_t a)
```
<dl>
<dt>描述</dt><dd>
对四元数求反。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 四个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[idq], [eulerq], [dotq], [lenq], [scaleq], [addq], [subq], [mulq], [rotq], [lerpq], [slerpq], [normq]
</dd>
</dl>
<hr>
## addq

```c
void addq(addr_t dst, addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
将四元数相加。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 四个浮点数的地址， 输出 |
| a | 四个浮点数的地址 |
| b | 四个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[idq], [eulerq], [dotq], [lenq], [scaleq], [negq], [subq], [mulq], [rotq], [lerpq], [slerpq], [normq]
</dd>
</dl>
<hr>
## subq

```c
void subq(addr_t dst, addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
减去四元数。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 四个浮点数的地址， 输出 |
| a | 四个浮点数的地址 |
| b | 四个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[idq], [eulerq], [dotq], [lenq], [scaleq], [negq], [addq], [mulq], [rotq], [lerpq], [slerpq], [normq]
</dd>
</dl>
<hr>
## mulq

```c
void mulq(addr_t dst, addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
乘以四元数。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 四个浮点数的地址， 输出 |
| a | 四个浮点数的地址 |
| b | 四个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[idq], [eulerq], [dotq], [lenq], [scaleq], [negq], [addq], [subq], [rotq], [lerpq], [slerpq], [normq]
</dd>
</dl>
<hr>
## rotq

```c
void rotq(addr_t dst, addr_t q, addr_t v)
```
<dl>
<dt>描述</dt><dd>
将具有三个元素的向量旋转四元数。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 三个浮点数的地址， 输出 |
| q | 四个浮点数的地址 |
| v | 三个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[idq], [eulerq], [dotq], [lenq], [scaleq], [negq], [addq], [subq], [mulq], [lerpq], [slerpq], [normq]
</dd>
</dl>
<hr>
## lerpq

```c
void lerpq(addr_t dst, addr_t a, addr_t b, float t)
```
<dl>
<dt>描述</dt><dd>
线性插值两个四元数。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 四个浮点数的地址， 输出 |
| a | 四个浮点数的地址 |
| b | 四个浮点数的地址 |
| t | 0.0和1.0 之间的插值 |
</dd>
<dt>另见</dt><dd>
[idq], [eulerq], [dotq], [lenq], [scaleq], [negq], [addq], [subq], [mulq], [rotq], [slerpq], [normq]
</dd>
</dl>
<hr>
## slerpq

```c
void slerpq(addr_t dst, addr_t a, addr_t b, float t)
```
<dl>
<dt>描述</dt><dd>
球面内插四元数。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 四个浮点数的地址， 输出 |
| a | 四个浮点数的地址 |
| b | 四个浮点数的地址 |
| t | 0.0和1.0 之间的插值 |
</dd>
<dt>另见</dt><dd>
[idq], [eulerq], [dotq], [lenq], [scaleq], [negq], [addq], [subq], [mulq], [rotq], [lerpq], [normq]
</dd>
</dl>
<hr>
## normq

```c
void normq(addr_t a)
```
<dl>
<dt>描述</dt><dd>
标准化四元数。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 四个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[idq], [eulerq], [dotq], [lenq], [scaleq], [negq], [addq], [subq], [mulq], [rotq], [lerpq], [slerpq]
</dd>
</dl>
<hr>
## idm4

```c
void idm4(addr_t a)
```
<dl>
<dt>描述</dt><dd>
加载 4 x 4 单位矩阵。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 16个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[trsm4], [detm4], [addm4], [subm4], [mulm4], [mulm4v3], [mulm4v4], [invm4], [trpm4]
</dd>
</dl>
<hr>
## trsm4

```c
void trsm4(addr_t dst, addr_t t, addr_t r, addr_t s)
```
<dl>
<dt>描述</dt><dd>
创建一个具有平移、旋转和缩放功能的 4 x 4 矩阵。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 16个浮点数的地址，目标矩阵 |
| t | 三个浮点数的地址，平移向量 |
| r | 四个浮点数的地址，旋转四元数 |
| s | 三个浮点数的地址，缩放向量 |
</dd>
<dt>另见</dt><dd>
[idm4], [detm4], [addm4], [subm4], [mulm4], [mulm4v3], [mulm4v4], [invm4], [trpm4]
</dd>
</dl>
<hr>
## detm4

```c
float detm4(addr_t a)
```
<dl>
<dt>描述</dt><dd>
返回矩阵的行列式。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| a | 16个浮点数的地址 |
</dd>
<dt>返回值</dt><dd>
矩阵的行列式。
</dd>
<dt>另见</dt><dd>
[idm4], [trsm4], [addm4], [subm4], [mulm4], [mulm4v3], [mulm4v4], [invm4], [trpm4]
</dd>
</dl>
<hr>
## addm4

```c
void addm4(addr_t dst, addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
将矩阵相加。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 16个浮点数的地址， 输出 |
| a | 16个浮点数的地址 |
| b | 16个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[idm4], [trsm4], [detm4], [subm4], [mulm4], [mulm4v3], [mulm4v4], [invm4], [trpm4]
</dd>
</dl>
<hr>
## subm4

```c
void subm4(addr_t dst, addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
矩阵相减。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 16个浮点数的地址， 输出 |
| a | 16个浮点数的地址 |
| b | 16个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[idm4], [trsm4], [detm4], [addm4], [mulm4], [mulm4v3], [mulm4v4], [invm4], [trpm4]
</dd>
</dl>
<hr>
## mulm4

```c
void mulm4(addr_t dst, addr_t a, addr_t b)
```
<dl>
<dt>描述</dt><dd>
矩阵相乘。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 16个浮点数的地址， 输出 |
| a | 16个浮点数的地址 |
| b | 16个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[idm4], [trsm4], [detm4], [addm4], [subm4], [mulm4v3], [mulm4v4], [invm4], [trpm4]
</dd>
</dl>
<hr>
## mulm4v3

```c
void mulm4v3(addr_t dst, addr_t m, addr_t v)
```
<dl>
<dt>描述</dt><dd>
将具有三个元素的向量乘以矩阵。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 三个浮点数的地址， 输出 |
| m | 16个浮点数的地址 |
| v | 三个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[idm4], [trsm4], [detm4], [addm4], [subm4], [mulm4], [mulm4v4], [invm4], [trpm4]
</dd>
</dl>
<hr>
## mulm4v4

```c
void mulm4v4(addr_t dst, addr_t m, addr_t v)
```
<dl>
<dt>描述</dt><dd>
将具有四个元素的向量乘以矩阵。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 四个浮点数的地址， 输出 |
| m | 16个浮点数的地址 |
| v | 四个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[idm4], [trsm4], [detm4], [addm4], [subm4], [mulm4], [mulm4v3], [invm4], [trpm4]
</dd>
</dl>
<hr>
## invm4

```c
void invm4(addr_t dst, addr_t a)
```
<dl>
<dt>描述</dt><dd>
计算逆矩阵。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 16个浮点数的地址， 输出 |
| a | 16个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[idm4], [trsm4], [detm4], [addm4], [subm4], [mulm4], [mulm4v3], [mulm4v4], [trpm4]
</dd>
</dl>
<hr>
## trpm4

```c
void trpm4(addr_t dst, addr_t a)
```
<dl>
<dt>描述</dt><dd>
转置矩阵。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 16个浮点数的地址， 输出 |
| a | 16个浮点数的地址 |
</dd>
<dt>另见</dt><dd>
[idm4], [trsm4], [detm4], [addm4], [subm4], [mulm4], [mulm4v3], [mulm4v4], [invm4]
</dd>
</dl>
<hr>
## trns

```c
void trns(addr_t dst, addr_t src, uint8_t num,
    int16_t x, int16_t y, int16_t z,
    uint16_t pitch, uint16_t yaw, uint16_t roll,
    float scale)
```
<dl>
<dt>描述</dt><dd>
又名平移顶点云。 将3D模型放置在[3D空间]中。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 目标顶点数组，每个 3 x 2 字节，X、Y、Z |
| src | 源顶点数组，每个 3 x 2 字节，X、Y、Z |
| num | 数组中顶点坐标三元组的数量 |
| x | 世界X坐标，-32767到32767 |
| y | 世界Y坐标，-32767到32767 |
| z | 世界Z坐标，-32767到32767 |
| pitch | 绕X轴旋转（以度为单位），0到359 |
| yaw | 绕Y轴旋转（以度为单位），0到359 |
| roll | 绕Z轴旋转（以度为单位），0到359 |
| scale | 比例，使用1.0保持原始尺寸 |
</dd>
<dt>另见</dt><dd>
[mesh]
</dd>
</dl>

# 记忆

## inb

```c
uint8_t inb(addr_t src)
```
<dl>
<dt>描述</dt><dd>
从内存中读入一个字节（byte）。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| src | 地址，0x00000到0xBFFFF |
</dd>
<dt>返回值</dt><dd>
返回该地址处的值。
</dd>
</dl>
<hr>
## inw

```c
uint16_t inw(addr_t src)
```
<dl>
<dt>描述</dt><dd>
从内存中读入一个字（word，两个字节）。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| src | 地址，0x00000到0xBFFFE |
</dd>
<dt>返回值</dt><dd>
返回该地址处的值。
</dd>
</dl>
<hr>
## ini

```c
uint32_t ini(addr_t src)
```
<dl>
<dt>描述</dt><dd>
从内存中读入一个整数（int，四个字节）。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| src | 地址，0x00000到0xBFFFC |
</dd>
<dt>返回值</dt><dd>
返回该地址处的值。
</dd>
</dl>
<hr>
## outb

```c
void outb(addr_t dst, uint8_t value)
```
<dl>
<dt>描述</dt><dd>
将一个字节（byte）写入内存。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 地址，0x00000到0xBFFFF |
| value | 要设置的值，0到255 |
</dd>
</dl>
<hr>
## outw

```c
void outw(addr_t dst, uint16_t value)
```
<dl>
<dt>描述</dt><dd>
将一个字（word，两个字节）写入内存。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 地址，0x00000到0xBFFFE |
| value | 要设置的值，0到65535 |
</dd>
</dl>
<hr>
## outi

```c
void outi(addr_t dst, uint32_t value)
```
<dl>
<dt>描述</dt><dd>
将一个整数（int，四个字节）写入内存。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 地址，0x00000到0xBFFFC |
| value | 要设置的值，0到4294967295 |
</dd>
</dl>
<hr>
## memsave

```c
int memsave(uint8_t overlay, addr_t src, uint32_t size)
```
<dl>
<dt>描述</dt><dd>
节省覆盖内存区域。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| overlay | 要写入的覆盖索引，0到255 |
| src | 要保存的内存偏移量，0x00000到0xBFFFF |
| size | 要保存的字节数 |
</dd>
<dt>返回值</dt><dd>
成功时返回 1，错误时返回 0。
</dd>
<dt>另见</dt><dd>
[memload]
</dd>
</dl>
<hr>
## memload

```c
int memload(addr_t dst, uint8_t overlay, uint32_t maxsize)
```
<dl>
<dt>描述</dt><dd>
将覆盖加载到指定的内存区域。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 要存储到的内存偏移量，0x00000到0xBFFFF |
| overlay | 要读取的叠加层索引，0到255 |
| maxsize | 加载的最大字节数 |
</dd>
<dt>返回值</dt><dd>
返回实际加载的字节数。
</dd>
<dt>另见</dt><dd>
[memsave]
</dd>
</dl>
<hr>
## memcpy

```c
void memcpy(addr_t dst, addr_t src, uint32_t len)
```
<dl>
<dt>描述</dt><dd>
复制内存区域。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 目标地址，0x00000到0xBFFFF |
| src | 源地址，0x00000到0xBFFFF |
| len | 要复制的字节数 |
</dd>
</dl>
<hr>
## memset

```c
void memset(addr_t dst, uint8_t value, uint32_t len)
```
<dl>
<dt>描述</dt><dd>
将内存区域设置为给定值。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 目标地址，0x00000到0xBFFFF |
| value | 要设置的值，0到255 |
| len | 要设置的字节数 |
</dd>
</dl>
<hr>
## memcmp

```c
int memcmp(addr_t addr0, addr_t addr1, uint32_t len)
```
<dl>
<dt>描述</dt><dd>
比较内存区域。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| addr0 | 第一个地址，0x00000到0xBFFFF |
| addr1 | 第二个地址，0x00000到0xBFFFF |
| len | 要比较的字节数 |
</dd>
<dt>返回值</dt><dd>
返回差值，如果两个内存区域匹配则返回 0。
</dd>
</dl>
<hr>
## deflate

```c
int deflate(addr_t dst, addr_t src, uint32_t len)
```
<dl>
<dt>描述</dt><dd>
使用 RFC1950 deflate (zlib) 压缩缓冲区。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 目标地址，0x30000到0xBFFFF |
| src | 源地址，0x30000到0xBFFFF |
| len | 要压缩的字节数 |
</dd>
<dt>返回值</dt><dd>
错误时为0或负数，否则为dst中压缩缓冲区和压缩数据的长度。
</dd>
<dt>另见</dt><dd>
[inflate]
</dd>
</dl>
<hr>
## inflate

```c
int inflate(addr_t dst, addr_t src, uint32_t len)
```
<dl>
<dt>描述</dt><dd>
使用 RFC1950 deflate (zlib) 压缩数据解压缩缓冲区。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| dst | 目标地址，0x30000到0xBFFFF |
| src | 源地址，0x30000到0xBFFFF |
| len | 压缩字节数 |
</dd>
<dt>返回值</dt><dd>
错误时为0或负数，否则为dst中未压缩缓冲区和未压缩数据的长度。
</dd>
<dt>另见</dt><dd>
[deflate]
</dd>
</dl>
<hr>
## time

```c
float time(void)
```
<dl>
<dt>描述</dt><dd>
返回自开机以来的滴答数。
</dd>
<dt>返回值</dt><dd>
自开机以来经过的时间（以毫秒为单位）。
</dd>
<dt>另见</dt><dd>
[now]
</dd>
</dl>
<hr>
## now

```c
uint32_t now(void)
```
<dl>
<dt>描述</dt><dd>
返回UNIX时间戳。 检查偏移0000C处的字节是否溢出。
</dd>
<dt>返回值</dt><dd>
自格林威治标准时间1970年1月1日午夜以来经过的时间（以秒为单位）。
</dd>
<dt>另见</dt><dd>
[time]
</dd>
</dl>
<hr>
## atoi

```c
int atoi(str_t src)
```
<dl>
<dt>描述</dt><dd>
将ASCII十进制字符串转换为整数。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| src | 字符串地址，0x00000到0xBFFFF |
</dd>
<dt>返回值</dt><dd>
字符串的数字值。
</dd>
<dt>另见</dt><dd>
[itoa], [str], [val]
</dd>
</dl>
<hr>
## itoa

```c
str_t itoa(int value)
```
<dl>
<dt>描述</dt><dd>
将整数转换为ASCII十进制字符串。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| value | 值，-2147483648到2147483647 |
</dd>
<dt>返回值</dt><dd>
转换后的字符串。
</dd>
<dt>另见</dt><dd>
[atoi], [str], [val]
</dd>
</dl>
<hr>
## val

```c
float val(str_t src)
```
<dl>
<dt>描述</dt><dd>
将ASCII十进制字符串转换为浮点数。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| src | 字符串地址，0x00000到0xBFFFF |
</dd>
<dt>返回值</dt><dd>
字符串的数字值。
</dd>
<dt>另见</dt><dd>
[itoa], [atoi], [str]
</dd>
</dl>
<hr>
## str

```c
str_t str(float value)
```
<dl>
<dt>描述</dt><dd>
将浮点数转换为ASCII十进制字符串。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| value | 值 |
</dd>
<dt>返回值</dt><dd>
转换后的字符串。
</dd>
<dt>另见</dt><dd>
[atoi], [itoa], [val]
</dd>
</dl>
<hr>
## sprintf

```c
str_t sprintf(str_t fmt, ...)
```
<dl>
<dt>描述</dt><dd>
返回使用格式和参数创建的以零结尾的UTF-8字符串。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| fmt | [格式串] |
| ... | 可选参数 |
</dd>
<dt>返回值</dt><dd>
构造好的字符串。
</dd>
</dl>
<hr>
## strlen

```c
int strlen(str_t src)
```
<dl>
<dt>描述</dt><dd>
返回字符串中的字节数（不带终止零）。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| src | 字符串地址，0x00000到0xBFFFF |
</dd>
<dt>返回值</dt><dd>
字符串中的字节数。
</dd>
<dt>另见</dt><dd>
[mblen]
</dd>
</dl>
<hr>
## mblen

```c
int mblen(str_t src)
```
<dl>
<dt>描述</dt><dd>
返回字符串中UTF-8多字节字符的数量（不带终止零）。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| src | 字符串地址，0x00000到0xBFFFF |
</dd>
<dt>返回值</dt><dd>
字符串中的字符数。
</dd>
<dt>另见</dt><dd>
[strlen]
</dd>
</dl>
<hr>
## malloc

```c
addr_t malloc(uint32_t size)
```
<dl>
<dt>描述</dt><dd>
动态分配用户内存。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| size | 要分配的字节数 |
</dd>
<dt>返回值</dt><dd>
新分配的缓冲区的地址或错误时为NULL。
</dd>
<dt>另见</dt><dd>
[realloc], [free]
</dd>
</dl>
<hr>
## realloc

```c
addr_t realloc(addr_t addr, uint32_t size)
```
<dl>
<dt>描述</dt><dd>
调整先前分配的缓冲区的大小。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| addr | 分配的缓冲区的地址 |
| size | 要调整大小的字节数 |
</dd>
<dt>返回值</dt><dd>
新分配的缓冲区的地址或错误时为NULL。
</dd>
<dt>另见</dt><dd>
[malloc], [free]
</dd>
</dl>
<hr>
## free

```c
int free(addr_t addr)
```
<dl>
<dt>描述</dt><dd>
释放动态分配的用户内存。
</dd>
<dt>参数</dt><dd>
| 争论t | 描述 |
| addr | 分配的缓冲区的地址 |
</dd>
<dt>返回值</dt><dd>
1表示成功，0表示错误。
</dd>
<dt>另见</dt><dd>
[malloc], [realloc]
</dd>
</dl>
