分析

这里只考虑DEBUG包，我们看一张Xcode打包日志细节图

上图选中的为主要耗时的步骤，可以看出，编译成功后，还有下面步骤较为耗时

• Linking
• Embed Pod Frameworks
• Copy Pods Resources
• Custom Script（这里为自定义脚本，主要用于资源处理）
• Sign

还有一个较为耗时的时间是Deploy，但Xcode并不没有输出Deploy的时间，后面使用ideviceinstaller工具单独测试，时间总体上与Xcode基本一致

1
2
3
4
5
6
7
8
9
10

# 安装
# brew install ideviceinstaller

begin=`date '+%s'`
# 这里直接拿编译好的app文件安装即可
ideviceinstaller -i 'xxx.ipa'
end=`date '+%s'`

# 计算时间差，单位s
expr $begin - $end

分析

1. Linking: 合并静态资源与地址修正，考虑使用第三方更快的link工具zld
2. Embed Pod Frameworks: 主要是处理动态库，拷贝到目标路径，主要影响是动态库文件数量
3. Copy Pods Resources: 主要对文件资源拷贝，主要影响是文件IO
4. Custom Script：这里是自定义脚本，主要是的图片文件的处理，主要是对图片文件进行展开，文件多则文件IO耗时长
5. Sign：对整个包签名，主要影响是文件数量和大小，文件多则文件IO耗时长
6. Deploy：主要是拷贝文件和签名校验，主要影响是文件数量，文件多则文件IO耗时长，文件大小影响首次安装，而二次安装会做差异拷贝，有缓存，影响会减小

有上面可以看出，减少IO操作是一个可行的优化方向，项目中的图片资源是放到根目录的，由于项目中用到的图片非常多，直接使用目录管理，并且使用Custom Script脚本单独处理图片，把图片拷贝到包的根目录上，查看xx直播在编译完成后的包，总文件数为9297个, 其中8821个为图片，占95%，文件数量占比大，这意味着每次都要进行大量的IO操作，如果能减少文件的数量，就能减少整个流程的时间

优化

关于IO问题

对于图片，我们知道除了可以放到根目录，还有可以放到Images.xcassets，放到Images.xcassets的图片最终会被编译成Assets.car，这里考虑把png和jpg图片提前制作成Assets.car，在日常开发迭代过程中，项目中用到的图片不会频繁的变动，这里我们考虑提前把图片做成Assets.car，如果有变动，再重新编译一次，操作步骤如下

1. 如果项目已经存在Images.xcassets，则拷贝一份出来，在它的基础上添加图片
2. 通过工具把所有图片构造成xxx.imageset，放到Images.xcassets里面，如

把bottom_logo@2x.png和bottom_logo@3x.png构造成下面目录结构

1
2
3
4
├── bottom_logo.imageset
│   ├── Contents.json
│   ├── bottom_logo@2x.png
│   └── bottom_logo@3x.png

其中Content.json为

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
{
    "images" : [
        {
        "idiom" : "universal",
        "filename" : "bottom_logo@2x.png",
        "scale" : "2x"
        },
        {
        "idiom" : "universal",
        "filename" : "bottom_logo@3x.png",
        "scale" : "3x"
        }
    ],
    "info" : {
        "version" : 1,
        "author" : "xcode"
    }
}

2. 使用actool编译Images.xcassets

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 输入
xcassetPath="path/to/Images.xcassets"
# 输出文件夹
outputPath="path/to/outputpath"

dependenciesPath="path/to/outputpath/dependenciesPath"
generatedInfoPath="path/to/outputpath/generatedInfoPath"

/usr/bin/actool                                             \
      --output-format "human-readable-text"                 \
      --notices                                             \
      --export-dependency-info "$dependenciesPath"          \
      --output-partial-info-plist "$generatedInfoPath"      \
      --app-icon "AppIcon"                                  \
      --compress-pngs                                       \
      --enable-on-demand-resources "YES"                    \
      --development-region "English"                        \
      --target-device "iphone"                              \
      --minimum-deployment-target "9.0"                     \
      --platform "iphoneos"                                 \
      --compile "$outputPath" "$xcassetPath"

编译后得到Assets.car

3. 由于Images.xcassets已经编译好了，去掉工程对Images.xcassets的引用，并且把编译好的Assets.car引入工程，上面我们只把jpg/png图片编译进了Assets.car，对于其他文件（不多），这里我通过工具单独引入工程

4. 把Run Script中的图片拷贝去掉，我这里的是去掉Pods-xxx-resources.sh文件中对图片资源的引用

经过上面一番处理后，重新测试，数据对比如下

从上面的测试结果来看，速度提升效果显著

因为优化后的方案有前置处理时间，需要把编译图片为Assets.car，这个时间没算上，上面的对比仅供参考

需要注意的是，Assets.car的图片只能通过UIImage.named("xxx")读取，如果项目中是通过路径

上面的操作过于繁琐，这里我写了一个工具进行处理【一键操作】

关于Linking

有一个第三方的linking工具zld，优化的缓存策略，在Other Linker Flag添加-fuse-ld='/path/to/zld' -Wl,-zld_original_ld_path,$(DT_TOOLCHAIN_DIR)/usr/bin/ld即可

经测试，Linking时间从15s减少到10.1s，减少了32%

关于CodeSign

1. Xcode默认使用SHA-256签名，我们可以改成更快的SHA-1，由于只是本地开发调试使用，不会有安全性问题，在Other Code Signing Flags添加--digest-algorithm=sha1

2. iOS校验签名只会二进制的签名，其他文件不签名也不会报错，可以通过过滤文件减少签名的文件，在Other Code Signing Flags添加--resource-rules=/path/to/rule.plist，rule.plist文件如下

   1 2 3 4 5 6 7 8 9 10 11

   <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> <plist version="1.0"> <dict> <key>rules</key> <dict> <key>.*</key> <false/> </dict> </dict> </plist>

上面处理并不会影响正常开发，通过上面处理编译后的包_CodeSignature/CodeResources文件从2.88 MB减少到589 Byte，减少了99.98%
Sign时间从2.2s减少到0.5s，减少了77%

关于Deploy

由于APFS的特性，相同的文件不会深拷贝，省去拷贝的时间，由于文件数量大大减少，IO次数也大幅提高，如果不改动文件的话，基本可以达到秒启动，由于Xcode没有输出安装所有的时间，这里使用ideviceinstaller进行测试，这里把优化前后打出来的xxx.app安装到手机上（卸载），测试时间

1
2
3
4

# 安装ideviceinstaller
# brew install -HEAD libimobiledevice

ideviceinstaller -i xxx.ipa

优化前：40s，优化后：18s，时间减少了55%

综合统计

微观统计

数据来源：Xcode编译日志

宏观统计

为了减少编译时间的影响，工程中大多数组件都使用二进制库，数据来源为Xcode编译打包后显示的时间（不包含Deploy和Run），如下

测试设备：Mac Mini M1 16G

总结

经过一段时间的使用，上面所有操作都是基于对开发效率的提升（for DEBUG），通过一些细节优化，可以把项目入侵降到最小，可以做到提高效率的同时，基本不影响日常开发

市面上大多数App包里面都会带非常多图片资源，图片太多确实会影响调试性能，减少图片数量从而减少IO次数，提升开发体验明显

编译对于开发者可以说是最为频繁的操作，编译速度的快慢会极大的影响我们的开发效率，对于xx直播App来说，由于代码量大，加上代码结构设计不合理等原因，导致编译速度非常慢，每次启动App（即使不改动代码）需要3分钟的时间才能跑在手机上，而一次完整的编译，则需要15分钟，严重影响日常的业务开发和调试，现阶段编译速度的优化显得尤为重要，主要的时间消耗有

• Compile
• Linking
• Run Script
• Sign
• Install（文件多可能是主因）

其中Compile时间占用90%以上，这里只关注Compile

二、调研

Xcode是基于llvm编译的，llvm编译器的编译过程主要分为3个部分

• 前端（Frontend）：负责解析源码，检查错误，生成抽象语法树（AST），并把 AST 转化成类汇编中间代码
• 优化器（Optimizer）：对中间代码进行架构无关的优化，提高运行效率，减少代码体积，例如无效代码，无用变量等
• 后端（Backend）：把中间代码转换成目标平台的机器码

其中我们代码影响最大的前端，这里我们只关注前端，前端处理主要有

1. 预处理：这阶段的工作主要是
2. 头文件展开处理
3. 宏展开/替换，预编译指令处理
4. 注释去除处理
5. 编译：这阶段做的事情比较多
6. 词法分析（Lexical Analysis）：将代码转换成一系列 token
7. 语法分析（Semantic Analysis）：将token树抽象语法树 AST
8. 静态分析（Static Analysis）：检查代码错误，例如参数类型是否错误，调用对象方法是否有实现
9. 中间代码生成（Code Generation）：将语法树自顶向下遍历逐步翻译成 LLVM IR

llvm9.0之后添加了一个新的编译参数可以用于统计编译过程中各个阶段的耗时（-ftime-trace），利用该参数和编译器我们可以得到项目中所有文件编译的详细时间信息

2.1 -ftime-trace测试

1. 下载llvm编译器，9.0以上的版本均可，解压后得到clang+llvm-9.0.0，我这里放到（~/development/clang+llvm-9.0.0）

2. 在需要统计编译时间的Target中修改clang前端编译器（CC和CXX），和编译参数（OtherCFlag）

   1 2 3

   CC: /path/to/clang CXX: /path/to/clang++ Other C Flag: 添加-ftime-trace

3. 关闭INDEX：COMPILER_INDEX_STORE_ENABLE=NO

4. 编译后，在目标文件（xxx.o）同个目录下，会生成xxx.json文件，如

   • YYTimer.o
   • YYTimer.json

5. 整个json文件如下

   1

   {"traceEvents":[{"pid":1,"tid":0,"ph":"X","ts":21778,"dur":43204,"name":"Module Load","args":{"detail":"UIKit"}},{"pid":1,"tid":0,"ph":"X","ts":21329,"dur":44253,"name":"Source","args":{"detail":"/Users/bomo/Documents/Code/iOS/Work/Analyze/4986-02-header2/FanXing/Pods/Target Support Files/KGThirdParty/KGThirdParty-prefix.pch"}},{"pid":1,"tid":0,"ph":"X","ts":66818,"dur":1868,"name":"Source","args":{"detail":"/Users/bomo/Documents/Code/iOS/Work/Analyze/4986-02-header2/FanXing/Pods/KGThirdParty/KGThirdParty/YYKit/Utility/YYTimer.h"}},{"pid":1,"tid":0,"ph":"X","ts":20679,"dur":70778,"name":"Frontend"},{"pid":1,"tid":0,"ph":"X","ts":91457,"dur":595,"name":"Frontend"},{"pid":1,"tid":0,"ph":"X","ts":94811,"dur":617,"name":"RunPass","args":{"detail":"AArch64 Assembly Printer"}},{"pid":1,"tid":0,"ph":"X","ts":94084,"dur":1370,"name":"OptFunction","args":{"detail":"\u0001+[YYTimer timerWithTimeInterval:target:selector:repeats:]"}},{"pid":1,"tid":0,"ph":"X","ts":95456,"dur":526,"name":"OptFunction","args":{"detail":"\u0001-[YYTimer init]"}},{"pid":1,"tid":0,"ph":"X","ts":95983,"dur":1123,"name":"OptFunction","args":{"detail":"\u0001-[YYTimer initWithFireTime:interval:target:selector:repeats:]"}},{"pid":1,"tid":0,"ph":"X","ts":93022,"dur":6873,"name":"OptModule","args":{"detail":"/Users/bomo/Documents/Code/iOS/Work/Analyze/4986-02-header2/FanXing/Pods/KGThirdParty/KGThirdParty/YYKit/Utility/YYTimer.m"}},{"pid":1,"tid":0,"ph":"X","ts":93013,"dur":6977,"name":"CodeGenPasses"},{"pid":1,"tid":0,"ph":"X","ts":92061,"dur":8108,"name":"Backend"},{"pid":1,"tid":0,"ph":"X","ts":66,"dur":100526,"name":"ExecuteCompiler"},{"pid":1,"tid":1,"ph":"X","ts":0,"dur":100526,"name":"Total ExecuteCompiler","args":{"count":1,"avg ms":100}},{"pid":1,"tid":2,"ph":"X","ts":0,"dur":71372,"name":"Total Frontend","args":{"count":2,"avg ms":35}},{"pid":1,"tid":3,"ph":"X","ts":0,"dur":46121,"name":"Total Source","args":{"count":2,"avg ms":23}},{"pid":1,"tid":4,"ph":"X","ts":0,"dur":43318,"name":"Total Module Load","args":{"count":3,"avg ms":14}},{"pid":1,"tid":5,"ph":"X","ts":0,"dur":8108,"name":"Total Backend","args":{"count":1,"avg ms":8}},{"pid":1,"tid":6,"ph":"X","ts":0,"dur":7094,"name":"Total OptModule","args":{"count":2,"avg ms":3}},{"pid":1,"tid":7,"ph":"X","ts":0,"dur":6977,"name":"Total CodeGenPasses","args":{"count":1,"avg ms":6}},{"pid":1,"tid":8,"ph":"X","ts":0,"dur":5819,"name":"Total OptFunction","args":{"count":40,"avg ms":0}},{"pid":1,"tid":9,"ph":"X","ts":0,"dur":5585,"name":"Total RunPass","args":{"count":729,"avg ms":0}},{"pid":1,"tid":10,"ph":"X","ts":0,"dur":479,"name":"Total DebugType","args":{"count":88,"avg ms":0}},{"pid":1,"tid":11,"ph":"X","ts":0,"dur":279,"name":"Total CodeGen Function","args":{"count":1,"avg ms":0}},{"pid":1,"tid":12,"ph":"X","ts":0,"dur":223,"name":"Total PerModulePasses","args":{"count":1,"avg ms":0}},{"pid":1,"tid":13,"ph":"X","ts":0,"dur":56,"name":"Total Module LoadIndex","args":{"count":1,"avg ms":0}},{"pid":1,"tid":14,"ph":"X","ts":0,"dur":21,"name":"Total PerFunctionPasses","args":{"count":1,"avg ms":0}},{"pid":1,"tid":15,"ph":"X","ts":0,"dur":3,"name":"Total PerformPendingInstantiations","args":{"count":1,"avg ms":0}},{"cat":"","pid":1,"tid":0,"ts":0,"ph":"M","name":"process_name","args":{"name":"clang-10"}}]}

6. 可以用Chrome打开chrome://tracing，然后拖入该json文件，可以直观的看到各个阶段编译消耗的时间

   

7. 这里摘取YYTimer.json里面的一个片段

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

   { "pid": 1, "tid": 0, "ph": "X", "ts": 66818, "dur": 1868, "name": "Source", "args": { "detail": "/Users/bomo/Documents/Code/iOS/Work/FanXing/Pods/KGThirdParty/KGThirdParty/YYKit/Utility/YYTimer.h" } }, { "pid": 1, "tid": 1, "ph": "X", "ts": 0, "dur": 100526, "name": "Total ExecuteCompiler", "args": { "count": 1, "avg ms": 100 } }

   这里的name=Source为头文件YYTimer.h预编译处理的时间，dur为时间，单位为微秒，name=Total ExecuteCompiler为该文件的编译时间

三、项目测试

通过上面的方法，编译整个项目，并统计所有文件的预编译处理时间，我这里用python扫描所有编译文件，然后做汇总统计

3.1 各编译阶段耗时

从上面数据看出Source耗时最长，占用2479.86s，占比较大

3.2 头文件引用次数（TOP10）

通过上面生成的json文件可以得到

注：这里的引用，包含间接引用 * A引用C * B引用A * D引用B

则C被引用3次，会参与3次预编译处理，当D被引用100次时，A,B,C也会被引用处理100次，编译器在编译的时候会有其他优化策略，具体次数可能会细微差异

3.3 头文件单次预处理耗时（TOP10）

注：由于头文件会多级引用，所以处理时间会叠加，这里仅供参考

3.4 头文件预处理总耗时（TOP10）

注：xxxxCommon.h文件引用次数不是最多，但总耗时最长

4. 方案

通过上面测试数据可以看出，xxxxCommon.h预处理耗时最长，通过查看该文件可以看出

• 该文件引用了非常多头文件（500+），完全展开的话会非常大，符合耗时的预期
• 项目中很多地方引用xxxxCommon.h文件可能只是用到里面其中一个或几个类，而有些地方为了图方便，就引用了这个大而全的文件，而引用整个xxxxCommon.h导致而预处理却花去了大量非必要的时间

这里决定给xxxxCommon.h文件进行瘦身，逐步把引用迁移到更轻量的头文件引用，并在具体的文件中补齐其他缺失的头文件，**头文件按需引用，减少不必要的预编译处理**

5. 成效

• 机器：iMac (Retina 4K, 21.5-inch, 2019)，
• CPU: 3 GHz 六核Intel Core i5 * 内存：16 GB 2667 MHz DDR4 * 显卡：Radeon Pro 560X 4 GB
• Configuration: DEBUG
• 编译架构：arm64

5.1宏观统计（6核）（减少110.9s）

测试方法：

1. 关闭Xcode，关闭Chrome等大进程
2. 删除所有Xcode缓存文件（~/Library/Developer/Xcode/DerivedData/）
3. 打开Xcode编译
4. 编译完成后，查看Xcode显示的编译总时间
5. 测试结果去掉最高最低值

注：部分子库用了二进制，这里更多关注差值

5.2 微观统计（减少372.7s）

测试方法：

1. 使用上面提到的llvm自带统计工具，然后汇总结果统计所有文件的Total ExecuteCompiler
2. 测试结果去掉最高最低值
3. 去掉所有的clang插件

总结

1. 上面优化修改了2115个文件，工作量还是比较大的，主要还是编码习惯和长期未规范使用带来量变积累，导致质变，平时养成良好的编码习惯，减少量变积累
2. Xcode在编译的时候会把#import <AAA/BBB.h>自动转成@import AAA.BBB，为了统一风格，建议统一使用#import <AAA/BBB.h>方式引用，详情见WWDC2013-Advances in Objective-C
3. 坚持一个原则：按需引用，按需引用（最小import原则），请引用#import <FAFuncUnit/XXX.h>，而不是#import <LibA/LibA-umbrella.h>

安装

1
2
3
4
5

# 下载gitea
wget -O gitea https://dl.gitea.io/gitea/1.17.2/gitea-1.17.2-linux-arm64

# 添加权限
chmod +x gitea

启动

指定端口为8899

1

./gitea web -p 8899

访问http://192.168.2.11:8899就能进入gitea

由于是自己用，我这里选择SQLite，配置完成后，会跳转到http://localhost:3000/user/login，由于服务在树莓派上，我们需要把localhost改为树莓派的地址，配置完成后会custom/conf/app.ini生成配置文件，我们需要吧localhost换成对应的地址，如果绑定了域名，可以换成域名

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

APP_NAME = Gitea: Git with a cup of tea
RUN_USER = ubuntu
RUN_MODE = prod

[server]
LOCAL_ROOT_URL   = http://192.168.2.11:8899/
SSH_DOMAIN       = 192.168.2.11
DOMAIN           = 192.168.2.11
HTTP_PORT        = 8899
ROOT_URL         = http://192.168.2.11:8899/
DISABLE_SSH      = false
SSH_PORT         = 22222
LFS_START_SERVER = true
LFS_JWT_SECRET   = JU6s1q1kgPVDIIKHRzsUkjJ5HgUSBknJGN7FyKf-hgY
OFFLINE_MODE     = true

[database]
DB_TYPE  = sqlite3
HOST     = 127.0.0.1:3306
NAME     = gitea
USER     = gitea
PASSWD   =
SCHEMA   =
SSL_MODE = disable
CHARSET  = utf8
PATH     = /home/ubuntu/server/gitea/data/gitea.db
LOG_SQL  = false

[repository]
ROOT = /home/ubuntu/server/gitea/data/gitea-repositories

[lfs]
PATH = /home/ubuntu/server/gitea/data

[mailer]
ENABLED = false

[service]
REGISTER_EMAIL_CONFIRM            = false
ENABLE_NOTIFY_MAIL                = false
DISABLE_REGISTRATION              = false
ALLOW_ONLY_EXTERNAL_REGISTRATION  = false
ENABLE_CAPTCHA                    = false
REQUIRE_SIGNIN_VIEW               = false
DEFAULT_KEEP_EMAIL_PRIVATE        = false
DEFAULT_ALLOW_CREATE_ORGANIZATION = true
DEFAULT_ENABLE_TIMETRACKING       = true
NO_REPLY_ADDRESS                  = noreply.localhost

[picture]
DISABLE_GRAVATAR        = true
ENABLE_FEDERATED_AVATAR = false

[openid]
ENABLE_OPENID_SIGNIN = false
ENABLE_OPENID_SIGNUP = false

[session]
PROVIDER = file

[log]
MODE      = console
LEVEL     = info
ROOT_PATH = /home/ubuntu/server/gitea/log
ROUTER    = console

[repository.pull-request]
DEFAULT_MERGE_STYLE = merge

[repository.signing]
DEFAULT_TRUST_MODEL = committer

[security]
INSTALL_LOCK       = true
INTERNAL_TOKEN     = eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYmYiOjE2NjQ3NjIwMDR9.C0b_xPSiljfhuDChyKTnzKuVtvSMjZsFSr31RxRZYLA
PASSWORD_HASH_ALGO = pbkdf2

如果使用gitea内置的SSH服务器的话，需要添加START_SSH_SERVER开启服务

1
2
3

[server]
...
START_SSH_SERVER = true

开机启动

添加一个系统用户gitea用于执行gitea

1
2
3
4
5

# 创建用户gitea，用户组为watchdog
sudo adduser --system --ingroup watchdog --disabled-password --shell /bin/bash --no-create-home --gecos 'Git Version Control' gitea

# 给用户添加文件权限
sudo chown -R gitea:watchdog /home/ubuntu/server/gitea

添加开机启动脚本/etc/systemd/system/gitea.service

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

[Unit]
Description=Gitea (Git with a cup of tea)
After=syslog.target
After=network.target
#After=mysqld.service

[Service]
RestartSec=2s
User=gitea
Group=watchdog
UMask=0002
WorkingDirectory=/home/ubuntu/server/gitea
ExecStart=/home/ubuntu/server/gitea/gitea -c /home/ubuntu/server/gitea/custom/conf/app.ini -p 8899

[Install]
WantedBy=multi-user.target

开机启动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 重新加载配置文件
sudo systemctl daemon-reload

# 开机启动
sudo systemctl enable gitea
# 关闭开机启动
sudo systemctl disable gitea

# 启动
sudo systemctl start gitea
# 停止
sudo systemctl stop gitea
# 重启
sudo systemctl restart gitea

# 查看状态
sudo systemctl status gitea

接下来就可以直接在web页面玩耍了

下载安装

可道云是基于php开发的，这里需要先安装apache2和php

1
2
3
4
5
6
7
8
9
10

sudo apt update

# apache2
sudo apt install apache2

# 安装php
sudo apt install php

# 解压
sudo apt install unzip

安装php依赖

1

sudo apt install php-curl php-mbstring 

下载可道云

1
2
3
4
5
6
7
8
9
10
11

# 下载
wget https://static.kodcloud.com/update/download/kodexplorer4.46.zip

# 解压
unzip kodexplorer4.46.zip

# 移动
sudo mv kodexplorer /var/www/kodexplorer

# 设置权限
sudo chmod -R 777 /var/www/kodexplorer

配置apache2

修改apache2站点配置 /etc/apache2/sites-available/000-default.conf，添加端口8081用于可道云（也可以使用原来的80端口）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 这是apache默认的站点
<VirtualHost *:80>
        ServerAdmin webmaster@localhost
        DocumentRoot /var/www/html

        ErrorLog ${APACHE_LOG_DIR}/error.log
        CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

# 可道云
<VirtualHost *:8081>
        ServerAdmin webmaster@localhost
        DocumentRoot /var/www/kodexplorer
        
        ErrorLog ${APACHE_LOG_DIR}/error.log
        CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

添加端口监听 /etc/apache2/ports.conf

1
2
3
4
5
6
7
8
9
10
11
12
13

Listen 80

# 可道云端口
NameVirtualHost *:8081
Listen 8081

<IfModule ssl_module>
        Listen 443
</IfModule>

<IfModule mod_gnutls.c>
        Listen 443
</IfModule>

配置完成后，重启apache2

1

sudo systemctl restart apache2

这时候就可以访问可道云了 http://192.168.2.*:8081

权限

apache2默认使用的用户为www-data，这里给www-data添加组权限，这样管理文件方便点（这里我用的组是watchdog，可以根据自己的习惯或需要设置）

1
2
3
4
5

# 添加www-data到组watchdog
sudo gpasswd -a www-data watchdog

# 也可以www-data为watchdog组
sudo usermod -g watchdog www-data

其他设置

在可道云上默认的文件创建权限为755，可以到config/config.php修改，我自己是改为774，组内成员可以修改

1

define('DEFAULT_PERRMISSIONS',0755);//新建文件、解压文件默认权限，777 部分虚拟主机限制了777;

常用的文件共享工具有

• DLNA: 主要用于多媒体共享，没有权限管理，所有人都可以看到，由于视频是服务器解码，对于大码率（4K）视频支持比较好
• Samba: 主要用于局域网文件共享，支持权限控制，大码率视频支持较弱
• FTP: 速度比Samba快，支持权限控制

我这里还是选择用Samba，因为电视和手机支持比较好，而对于大码率视频，则使用DLNA（minidlna），这里介绍安装samba的过程

安装

1
2

sudo apt update
sudo apt install samba

配置

配置文件在/etc/samba/smb.conf，下面配置放到文件最后面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

[学习]
  comment = 学习，可读写，只有bomo可以查看
  path = /mnt/h1/learn
  browseable = yes
  writable = yes
  available = yes
  valid users = ubuntu,bomo
  guest ok = no
  
[视频]
  comment = 视频，所有人可以查看，只读
  path = /home/ubuntu/git
  browseable = yes
  writable = no
  available = yes
  guest ok = yes  

由于samba的用户必须是系统用户，这里我们创建用户bomo，并且不需要密码，不需要

1
2

# 添加系统用户bomo，属于组watchdog，无密码，不创建home目录
sudo adduser --system --ingroup watchdog --disabled-password --shell /bin/bash --no-create-home bomo

虽然samba的用户必须是系统用户，但是密码可以单独设置

1
2

# 设置用户samba密码
smbpasswd -a bomo

设置完成，重启samba

1
2

# 重启samba
sudo systemctl restart smbd

接下来就可以在其他支持samba的设备发现并登录了

设置文件权限

安装samba的时候，会自动添加开机启动服务/lib/systemd/system/smbd.service，这里我们添加UMask和Group，方便管理文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

[Unit]
Description=Samba SMB Daemon
Documentation=man:smbd(8) man:samba(7) man:smb.conf(5)
Wants=network-online.target
After=network.target network-online.target nmbd.service winbind.service

[Service]
Type=notify
NotifyAccess=all
PIDFile=/run/samba/smbd.pid
User=root
Group=watchdog
UMask=0002
LimitNOFILE=16384
EnvironmentFile=-/etc/default/samba
ExecStartPre=/usr/share/samba/update-apparmor-samba-profile
ExecStart=/usr/sbin/smbd --foreground --no-process-group $SMBDOPTIONS
ExecReload=/bin/kill -HUP $MAINPID
LimitCORE=infinity


[Install]
WantedBy=multi-user.target

刷新服务重启

1
2
3

sudo systemctl daemon-reload
# 启动
sudo systemctl restart smbd

挂载硬盘

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 查看硬盘，得到硬盘为/dev/sda1
sudo fdisk -l

# 需要确保挂载的目录是存在的，如果不存在则创建
mkdir /mnt/h1

# 1. 挂载硬盘
sudo mount /dev/sdb1 /mnt/h1

# 2. 挂载硬盘可以设置目录的所属用户所属组和umask
sudo mount -o umask=0002,gid=watchdog,uid=ubuntu /dev/sdb1 /mnt/h1

# 取消挂载
sudo umount /dev/sdb1

自动挂载硬盘

1. 查看硬盘UUID

   1 2 3 4 5

   # 1. 查看硬盘uuid sudo blkid # 输出得到下面信息 /dev/sda1: LABEL="pi" UUID="3E5F551D2B409931" TYPE="ntfs" PTTYPE="atari"

得到UUID为：3E5F551D2B409931

2. 开机挂载/etc/fstab

1
2
3
4

UUID="3E5F551D2B409931" /mnt/h1 ntfs defaults 0 1

# 添加所属用户，组，umask
UUID="3E5F551D2B409931" /mnt/h1 ntfs user,rw,umask=0002,uid=ubuntu,gid=watchdog 0 1

使用 df命令查看硬盘挂载情况

1
2
3
4
5
6
7

ubuntu@ubuntu:~$ df
Filesystem     1K-blocks    Used Available Use% Mounted on
tmpfs             189000    4080    184920   3% /run
tmpfs             944992       0    944992   0% /dev/shm
tmpfs               5120       0      5120   0% /run/lock
tmpfs               4096       0      4096   0% /sys/fs/cgroup
/dev/sda1      976760828 72838540 903922288   8% /mnt/h1

完成

默认情况下，风扇是随着电源开关控制的，即使关机了，风扇也会转，这里介绍使用三极管控制风扇开关的方法

接线引脚

树莓派4B的引脚如下图

买来的风扇的正负极接4, 6引脚

通过三极管添加控制线

风扇接上树莓派引脚后就会开启，随电源开关，无法进行控制，关机的时候也会转，通常有两种方式

1. 使用三极管接线从而达到控制风扇的目的
2. taobao买T9温控模块（https://item.taobao.com/item.htm?id=553295324487）

这里第一种方式，添加三极管

• 三极管，我这里用的是S8050（NPN型）的三极管
  我是在这里买的，2.8块钱50个
• 杜邦线-公对母: 2根
• 杜邦线-母对母: 2根

三极管三级

接线示意图（分别接到4，6，12号引脚上）

效果图

有朋友可能买到的是S8850（PNP型）的三极管，接线和上面不一样，需要注意，可以参考这个链接，不过我没试过，https://blog.csdn.net/Xxy605/article/details/115960846

接完之后开机，会发现风扇默认是不转的，我们需要手动控制风扇的开关

通过python脚本控制开关

安装依赖文件

1
2
3
4
5

sudo apt update
sudo apt install python3-pip

sudo apt -y install python3-rpi.gpio
sudo pip install RPi.GPIO

下面脚本控制风扇开关

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

import RPi.GPIO as GPIO

# 控制线接的是12号引脚
FAN = 12

GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)

# 设为输出模式
GPIO.setup(FAN, GPIO.OUT)

# 开风扇
GPIO.output(FAN, GPIO.HIGH)

# 关风扇
GPIO.output(FAN, GPIO.LOW)

# 设为输入模式
GPIO.setup(FAN, GPIO.IN, pull_up_down=GPIO.PUD_UP)

# 读取当前风扇状态
isOff = GPIO.input(FAN) == GPIO.LOW;

# 关闭
GPIO.cleanup()

可以PWM控制风扇的风速

1
2
3
4
5
6
7

pwm = GPIO.PWM(FAN, 50)

# 满速（0-100）
pwm.start(100)

# 关闭
pwm.stop()

查看CPU温度

通过读取文件/sys/class/thermal/thermal_zone0/temp获得CPU温度

1
2
3
4
5

# 查看当前CPU温度
cat /sys/class/thermal/thermal_zone0/temp

# 观察CPU温度，每秒更新一次
watch -n 1 cat /sys/class/thermal/thermal_zone0/temp

温控风扇脚本

下面是通过温度控制风扇开关的脚本（由于我的风扇比较小，就没有考虑控制风速，只做开关）

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

# -*- coding: utf-8 -*-
 
import RPi.GPIO as GPIO
import time
 
# 控制风扇的GPIO
FAN_GPIO = 12
# 低温阈值，低于它则关闭风扇
MIN_TEMP = 45
# 高温阈值，高于它则全速运转
MAX_TEMP = 50
# 多长时间读取一次CPU温度，单位秒
SAMPLING = 60
 
 
# 单位为千分之一度
def get_cpu_temp():
    with open('/sys/class/thermal/thermal_zone0/temp') as f:
        cpu_temp = int(f.read())
    return cpu_temp
 
def main():
    GPIO.setwarnings(False)
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(FAN_GPIO, GPIO.OUT)
    GPIO.output(FAN_GPIO, GPIO.LOW) 
    
    time.sleep(5)
 
    try:
        while 1:
            temp = get_cpu_temp()
            print('CPU temperature:', temp)
            if temp < MIN_TEMP * 1000:
                GPIO.output(FAN_GPIO, 0)
            elif temp > MAX_TEMP * 1000:
                GPIO.output(FAN_GPIO, 1)
            else:
                # 中间地带，开
                GPIO.output(FAN_GPIO, 1)
            time.sleep(SAMPLING)
    except KeyboardInterrupt:
        pass
 
    GPIO.cleanup()


if __name__ == '__main__':
    main()

脚本保存到/home/ubuntu/server/fan/autofan.py

开机启动

创建service（/etc/systemd/system/autofan.service）

1
2
3
4
5
6
7
8
9
10
11
12
13
14

[Unit]
Description=auto fan control
After=syslog.target
After=network.target

[Service]
RestartSec=2s
User=root
Group=root
WorkingDirectory=/home/ubuntu/server/fan/
ExecStart=/usr/bin/python3 /home/ubuntu/server/fan/autofan.py

[Install]
WantedBy=multi-user.target

刷新并加载

1
2
3
4
5
6
7
8

# 重新加载配置  
sudo systemctl daemon-reload
# 开机启动
sudo systemctl enable autofan
# 启动
sudo systemctl start autofan
# 状态
sudo systemctl status autofan

之后每次重启都会自动根据温度开关风扇了

安装系统

1. 下载镜像写入工具

用官方的Raspberry Pi Imager就行

2. 下载系统

• 官方系统: https://www.raspberrypi.org/software/operating-systems
• ubuntu: https://ubuntu.com/download/raspberry-pi
• 其他: https://www.raspberrypi.org/software/operating-systems

树莓派虽然很强大，但还是很难作为真正的生产力，大多数情况还是作为服务，我没有选择Desktop版本，而是选择Ubuntu Server 20.04 TLS

3. 写入TF卡

4. SSH连接

特别是没法外接显示器的，第一步只能通过SSH连接，烧录完成后，先不急着开机，会提示拔出卡，重新插入tf卡，可以看到system-boot分区，这里我们在里面新建一个空的文本文件，命名为SSH，这样开机后就可以通过SSH连接了

5. wifi设置

如果你没有网线，也没有外接屏幕，可以设置wifi信息，树莓派在启动后会自动连接wifi，在system-boot分区根目录有个network-config文件，可以配置无线网络，找到wifis相关配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#wifis:
#  wlan0:
#    dhcp4: true
#    optional: true
#    access-points:
#      myhomewifi:
#        password: "S3kr1t"
#      myworkwifi:
#        password: "correct battery horse staple"
#      workssid:
#        auth:
#          key-management: eap
#          method: peap
#          identity: "me@example.com"
#          password: "passw0rd"
#          ca-certificate: /etc/my_ca.pem

修改为（SSID: HomeWifi，密码：12345678）

1
2
3
4
5
6
7

wifis:
  wlan0:
    dhcp4: true
    optional: true
    access-points:
      "HomeWifi":
        password: "12345678"

6. 关闭LED指示灯

可以通过config.txt文件的[pi4]下面添加下面命令关闭

1
2
3
4
5
6
7
8
9
10
11

# 关闭电源指示灯(红色)
dtparam=pwr_led_trigger=none
dtparam=pwr_led_activelow=off

# 关闭活动指示灯(绿色)
dtparam=act_led_trigger=none
dtparam=act_led_activelow=off

# 关闭网线口指示灯
dtparam=eth_led0=4
dtparam=eth_led1=4

安装

TF卡插入树莓派通电即可，通过路由器可以看到树莓派连接的IP地址（如：192.168.2.*），通过ssh连接

• ubuntu系统默认用户名和密码都是ubuntu
• 官方系统的默认用户名和密码是pi和raspberry

1

ssh ubuntu@192.168.2.*

接下来就可以愉快的玩耍了

通过VNC连接

如果你安装的是官方的系统，则可以通过VNC连接到树莓派，而不用外接屏幕

通过ssh连接到树莓派后，进入设置

1

sudo raspi-config

选择Interfacing Options -> VNC-> （询问是否enabled）Yes

之后直接用VNC Viewer，就可以连接到树莓派了

黑屏

这里可能会遇到黑屏的情况，还是进入raspi-config，选择Advanced Options -> Resolution -> 1280x720（随便选择一个分辨率，不要选Default）

其他

查看硬件版本，我的是1.4版本的，另外还有1.1和1.2版本

1
2

cat /sys/firmware/devicetree/base/model
Raspberry Pi 4 Model B Rev 1.4

为了方便看出自转，这里只画三角形线，不进行填充

绘制图形

基于前面的案例4的基础上来绘制

绘制地板

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// 地板
GLBatch                floorBatch;

// 设置地板顶点数据
floorBatch.Begin(GL_LINES, 324);
for(GLfloat x = -20.0; x <= 20.0f; x+= 0.5) {
    floorBatch.Vertex3f(x, -0.55f, 20.0f);
    floorBatch.Vertex3f(x, -0.55f, -20.0f);

    floorBatch.Vertex3f(20.0f, -0.55f, x);
    floorBatch.Vertex3f(-20.0f, -0.55f, x);
}
floorBatch.End();

// 在renderSence绘制地板
shaderManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(), vGreen);
floorBatch.Draw();

大球和小球

自转公转小球

1
2
3
4
5

// 设置大球模型
gltMakeSphere(torusBatch, 0.4f, 20, 40);

// 设置小球模型
gltMakeSphere(sphereBatch, 0.2f, 8, 16);

随机小球

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// 随机球个数
#define NUM_SPHERES 50
// 记录随机球位置
GLFrame spheres[NUM_SPHERES];


// 随机生成位置放置小球
for (int i = 0; i < NUM_SPHERES; i++) {
    //y轴不变，X,Z产生随机值
    GLfloat x = ((GLfloat)((rand() % 400) - 200 ) * 0.1f);
    GLfloat z = ((GLfloat)((rand() % 400) - 200 ) * 0.1f);

    // 在y方向，将球体设置为0.0的位置，这使得它们看起来是飘浮在眼睛的高度
    // 对spheres数组中的每一个顶点，设置顶点数据
    spheres[i].SetOrigin(x, 0.0f, z);
}

renderSence

添加视图矩阵到矩阵堆栈

1
2
3
4
5
6
7
8

// 模型视图矩阵，push单元矩阵
modelViewMatrix.PushMatrix();

// 模型变换
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);
// push视图变换
modelViewMatrix.PushMatrix(mCamera);

由于地板不需要其他变换，这时候可以绘制地板

1
2

shaderManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(), vGreen);
floorBatch.Draw();

让大小球显示在观察者前面，这里添加一个视图变换

1
2

// 平移（z轴）让小球显示到观察者前面，
modelViewMatrix.Translate(0.0f, 0.0f, -3.0f);

然后绘制大球，这里使用点点光源着⾊器，可以看到球的光照效果

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

// 这里添加一个旋转角度(5°)，通过这个变量控制自转
float yRot = 5;

// 定义光源位置
M3DVector4f vLightPos = {0.0f,10.0f,5.0f,1.0f};

// 绘制随机球，这里直接用小球的批次类来绘制
for (int i = 0; i < NUM_SPHERES; i++) {
    modelViewMatrix.PushMatrix();
    modelViewMatrix.MultMatrix(spheres[i]);
    shaderManager.UseStockShader(
                                 GLT_SHADER_POINT_LIGHT_DIFF,
                                 transformPipeline.GetModelViewMatrix(),
                                 transformPipeline.GetProjectionMatrix(),
                                 vLightPos,
                                 vBlue);
    sphereBatch.Draw();
    modelViewMatrix.PopMatrix();
}

// 旋转（用于大球自转）
modelViewMatrix.PushMatrix();
modelViewMatrix.Rotate(yRot, 0.0f, 1.0f, 0.0f);

// 球上的三角形画线
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glLineWidth(2f);

// 指定合适的着色器(点光源着色器)
shaderManager.UseStockShader(
                             GLT_SHADER_POINT_LIGHT_DIFF,
                             transformPipeline.GetModelViewMatrix(),
                             transformPipeline.GetProjectionMatrix(),
                             vLightPos,
                             vRed);
// 画球
torusBatch.Draw();
// 弹出旋转矩阵（因为旋转只用于大球）
modelViewMatrix.PopMatrix();

接下来画小球，先旋转，再平移（先旋转到固定的角度，再移到外面）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// 旋转（公转）
modelViewMatrix.Rotate(yRot * -2.0f, 0.0f, 1.0f, 0.0f);
// 平移
modelViewMatrix.Translate(0.8f, 0.0f, 0.0f);
shaderManager.UseStockShader(
                             GLT_SHADER_POINT_LIGHT_DIFF,
                             transformPipeline.GetModelViewMatrix(),
                             transformPipeline.GetProjectionMatrix(),
                             vLightPos,
                             vBlue);
// 画小球
sphereBatch.Draw();

// 前面一共push了三个矩阵，用完后pop
modelViewMatrix.PopMatrix();
modelViewMatrix.PopMatrix();
modelViewMatrix.PopMatrix();

注意，这里的小球没有自转，只是跟随者Y轴旋转

定时器

接下来是控制刷新，主要是修改yRot，就能控制自转和公转了，这里通过CStopWatch获取一个时间间隔，来生成一个动态的值

1
2
3

static CStopWatch rotTimer;
// 可以通过流失的时间获取一个动态的值
float yRot = rotTimer.GetElapsedSeconds() * 60.0f;

完整代码见这里

内置图形

球

1
2
3
4
5

//参数1：sphereBatch，三角形批次类对象
//参数2：fRadius，球体半径
//参数3：iSlices，从球体底部堆叠到顶部的三角形带的数量；其实球体是一圈一圈三角形带组成
//参数4：iStacks，围绕球体一圈排列的三角形对数
gltMakeSphere(GLTriangleBatch& sphereBatch, GLfloat fRadius, GLint iSlices, GLint iStacks);

环

1
2
3
4
5
6

//参数1：torusBatch，三角形批次类对象
//参数2：majorRadius,甜甜圈中心到外边缘的半径
//参数3：minorRadius,甜甜圈中心到内边缘的半径
//参数4：numMajor,沿着主半径的三角形数量
//参数5：numMinor,沿着内部较小半径的三角形数量
gltMakeTorus(GLTriangleBatch& torusBatch, GLfloat majorRadius, GLfloat minorRadius, GLint numMajor, GLint numMinor);

圆柱/圆锥

设置顶部和底部面的半径，相同为圆住，其中一个面的半径为0则为圆锥，半径不同类似一把中间镂空的伞

1
2
3
4
5
6
7

//参数1：cylinderBatch，三角形批次类对象
//参数2：baseRadius,底部半径
//参数3：topRadius,头部半径
//参数4：fLength,圆形长度
//参数5：numSlices,围绕Z轴的三角形对的数量
//参数6：numStacks,圆柱底部堆叠到顶部圆环的三角形数量
void gltMakeCylinder(GLTriangleBatch& cylinderBatch, GLfloat baseRadius, GLfloat topRadius, GLfloat fLength, GLint numSlices, GLint numStacks);

磁盘

2D平面图形，有两个圆组成一个平面环

1
2
3
4
5
6

//参数1:diskBatch，三角形批次类对象
//参数2:innerRadius,内圆半径
//参数3:outerRadius,外圆半径
//参数4:nSlices,圆盘围绕Z轴的三角形对的数量
//参数5:nStacks,圆盘外网到内围的三角形数量
void gltMakeDisk(GLTriangleBatch& diskBatch, GLfloat innerRadius, GLfloat outerRadius, GLint nSlices, GLint nStacks);

立方体

1
2
3

//参数1:cubeBatch，立方体批次类对象
//参数2:fRadius，每个方向到原点距离都为20个单位长度的立方体
void gltMakeCube(GLBatch& cubeBatch, GLfloat fRadius);

案例

本案例基于案例3，原来的部分不做介绍，定义图形批次类

1
2
3
4
5
6
7
8
9
10
11
12

// 球
GLTriangleBatch     sphereBatch;
// 环
GLTriangleBatch     torusBatch;
// 圆柱
GLTriangleBatch     cylinderBatch;
// 锥
GLTriangleBatch     coneBatch;
// 磁盘
GLTriangleBatch     diskBatch;
// 立方体
GLBatch             cubeBatch;

生成批次类数据

1
2
3
4
5
6
7
8
9
10
11
12

// 球
gltMakeSphere(sphereBatch, 3.0, 10, 20);
// 环面
gltMakeTorus(torusBatch, 3.0f, 0.75f, 15, 15);
// 圆柱
gltMakeCylinder(cylinderBatch, 2.0f, 2.0f, 3.0f, 15, 2);
// 锥
gltMakeCylinder(coneBatch, 2.0f, 0.0f, 3.0f, 13, 2);
// 磁盘
gltMakeDisk(diskBatch, 1.5f, 3.0f, 13, 3);
// 正立方体
gltMakeCube(cubeBatch, 1);

在renderSence判断显示哪一个图形

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

switch(nStep) {
    case 0:
        drawWireFramedBatch(&sphereBatch);
        break;
    case 1:
        drawWireFramedBatch(&torusBatch);
        break;
    case 2:
        drawWireFramedBatch(&cylinderBatch);
        break;
    case 3:
        drawWireFramedBatch(&coneBatch);
        break;
    case 4:
        drawWireFramedBatch(&diskBatch);
        break;
    case 5:
        drawWireFramedBatch(&cubeBatch);
        break;
}

代码见这里

基础知识

OpenGL涉及到的基础变换主要有下面4种

其中对于同一个物体，使用视图变换和模型变换都能做到同样的效果，具体采用什么变换取决于实际情况

视图变换

视图变换是应用到场景中的第一种变换，通过物体/观察者在Z轴上的移动（默认是Z轴，也可以改为其他轴），确定场景中利于观察的位置。默认情况下，透视投影中的观察者位置处于原点（0，0，0），并沿着z轴负方向看向屏幕里面，一般通过moveForward方法来调整观察者位置，moveForward默认的朝向是-z轴，所以向屏幕里面移动传正数值，向屏幕外即+z轴，需要传负数值

1
2
3
4
5
6
7
8
9

// 定义一个参考证
GLFrame                cameraFrame;

// 向屏幕外（+z轴方向）移动15.0f
cameraFrame.MoveForward(-15.0f);

// 生成矩阵到mCamera，用于矩阵变换操作
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);

模型变换

模型变换，主要涉及三个函数，移动、旋转、缩放。有了这三个函数的组合，我们可以进行任意变换。

1
2
3
4
5
6
7
8
9
10
11

// 平移，沿x/y/z三个方向平移，矩阵结果放在第一个参数里面
void m3dTranslationMatrix44(M3DMatrix44f m, float x, float y, float z);

// 旋转
void m3dRotationMatrix44(M3DMatrix44f m, float angle, float x, float y, float z);

// 缩放
void m3dScaleMatrix44(M3DMatrix44f m, float xScale, float yScale, float zScale);

// 矩阵叉乘，结果放在product
void m3dMatrixMultiply44(M3DMatrix44f product, const M3DMatrix44f a, const M3DMatrix44f b);

翻转操作可以用旋转，也可以用缩放（缩放到-1）

投影变换

通常也在窗口改变的时候设置

1
2
3
4
5
6

GLFrustum              viewFrustum;
// 设置透视投影
viewFrustum.SetPerspective(35.0f, float(w) / float(h), 1.0f, 500.0f);

// 加载投影矩阵到矩阵堆栈projectionMatrix
projectionMatrix.LoadMatrix(viewFrustum.GetProjectionMatrix());

视口变换

视口变换相关函数为，通常在窗口大小改变的时候修改

1
2

// 修改glView视口
glViewport (GLint x, GLint y, GLsizei width, GLsizei height);

这里需要注意的是，矩阵变换叉乘不满足交换律，变换顺序会导致结果不一致

绘制

定义7个批次类，用于保存顶点

1
2
3
4
5
6
7

GLBatch                pointBatch;
GLBatch                lineBatch;
GLBatch                lineStripBatch;
GLBatch                lineLoopBatch;
GLBatch                triangleBatch;
GLBatch                triangleStripBatch;
GLBatch                triangleFanBatch;

在setupRC初始化顶点数据

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

// 定义三个点
GLfloat vCoast[] = {
    3,3,0,
    0,3,0,
    3,0,0
};

// 画点
pointBatch.Begin(GL_POINTS, 3);
pointBatch.CopyVertexData3f(vCoast);
pointBatch.End();

// 画线
lineBatch.Begin(GL_LINES, 3);
lineBatch.CopyVertexData3f(vCoast);
lineBatch.End();

// 画连续线段
lineStripBatch.Begin(GL_LINE_STRIP, 3);
lineStripBatch.CopyVertexData3f(vCoast);
lineStripBatch.End();

// 画闭合线段
lineLoopBatch.Begin(GL_LINE_LOOP, 3);
lineLoopBatch.CopyVertexData3f(vCoast);
lineLoopBatch.End();

// 3个三角形，构成金字塔形状
GLfloat vPyramid[12][3] = {
    -2.0f, 0.0f, -2.0f,
    2.0f, 0.0f, -2.0f,
    0.0f, 4.0f, 0.0f,

    2.0f, 0.0f, -2.0f,
    2.0f, 0.0f, 2.0f,
    0.0f, 4.0f, 0.0f,

    2.0f, 0.0f, 2.0f,
    -2.0f, 0.0f, 2.0f,
    0.0f, 4.0f, 0.0f,

    -2.0f, 0.0f, 2.0f,
    -2.0f, 0.0f, -2.0f,
    0.0f, 4.0f, 0.0f
};
triangleBatch.Begin(GL_TRIANGLES, 12);
triangleBatch.CopyVertexData3f(vPyramid);
triangleBatch.End();

// 三角形扇形--六边形
GLfloat vPoints[100][3];
int nVerts = 0;
// 半径
GLfloat r = 3.0f;
// 原点(x,y,z) = (0,0,0);
vPoints[nVerts][0] = 0.0f;
vPoints[nVerts][1] = 0.0f;
vPoints[nVerts][2] = 0.0f;

// M3D_2PI 就是2Pi 的意思，就一个圆的意思。 绘制圆形
for (GLfloat angle = 0; angle < M3D_2PI; angle += M3D_2PI / 6.0f) {
    // 数组下标自增（每自增1次就表示一个顶点）
    nVerts++;
    /*
        弧长=半径*角度,这里的角度是弧度制,不是平时的角度制
        既然知道了cos值,那么角度=arccos,求一个反三角函数就行了
        */
    // x点坐标 cos(angle) * 半径
    vPoints[nVerts][0] = float(cos(angle)) * r;
    // y点坐标 sin(angle) * 半径
    vPoints[nVerts][1] = float(sin(angle)) * r;
    // z点的坐标
    vPoints[nVerts][2] = -0.5f;
}

// 结束扇形 前面一共绘制7个顶点（包括圆心）
// 添加闭合的终点
// 课程添加演示：屏蔽177-180行代码，并把绘制节点改为7.则三角形扇形是无法闭合的。
nVerts++;
vPoints[nVerts][0] = r;
vPoints[nVerts][1] = 0;
vPoints[nVerts][2] = 0.0f;

// 加载！GL_TRIANGLE_FAN 以一个圆心为中心呈扇形排列，共用相邻顶点的一组三角形
triangleFanBatch.Begin(GL_TRIANGLE_FAN, 8);
triangleFanBatch.CopyVertexData3f(vPoints);
triangleFanBatch.End();

// 三角形条带，一个小环或圆柱段
// 顶点下标
int iCounter = 0;
// 半径
GLfloat radius = 3.0f;
// 从0度~360度，以0.3弧度为步长
for (GLfloat angle = 0.0f; angle <= (2.0f*M3D_PI); angle += 0.3f) {
    //或许圆形的顶点的X,Y
    GLfloat x = radius * sin(angle);
    GLfloat y = radius * cos(angle);

    //绘制2个三角形（他们的x,y顶点一样，只是z点不一样）
    vPoints[iCounter][0] = x;
    vPoints[iCounter][1] = y;
    vPoints[iCounter][2] = -0.5;
    iCounter++;

    vPoints[iCounter][0] = x;
    vPoints[iCounter][1] = y;
    vPoints[iCounter][2] = 0.5;
    iCounter++;
}

//结束循环，在循环位置生成2个三角形
vPoints[iCounter][0] = vPoints[0][0];
vPoints[iCounter][1] = vPoints[0][1];
vPoints[iCounter][2] = -0.5;
iCounter++;

vPoints[iCounter][0] = vPoints[1][0];
vPoints[iCounter][1] = vPoints[1][1];
vPoints[iCounter][2] = 0.5;
iCounter++;

// GL_TRIANGLE_STRIP 共用一个条带（strip）上的顶点的一组三角形
triangleStripBatch.Begin(GL_TRIANGLE_STRIP, iCounter);
triangleStripBatch.CopyVertexData3f(vPoints);
triangleStripBatch.End();

然后在renderSence里面，把对应的批次类draw出来就可以了

1
2
3
4
5
6
7
8
9

// 画点
glPointSize(4.0f);
pointBatch.Draw();
glPointSize(1.0f);

// 画三角形
glLineWidth(2.0f);
lineLoopBatch.Draw();
glLineWidth(1.0f);

矩阵堆栈

本案例涉及到3个矩阵，视图矩阵（修改观察者位置），模型矩阵（旋转），投影矩阵（透视投影）

这里我们定义两个矩阵堆栈，来计算

1
2
3
4
5

// 矩阵堆栈，用于设置投影矩阵
GLMatrixStack          projectionMatrix;

// 矩阵堆栈，用于设置视图矩阵，模型矩阵，
GLMatrixStack          modelViewMatrix;

为了方便计算，我们定义一个变换管道transformPipeline，用于合并2个矩阵堆栈（投影矩阵堆栈projectionMatrix和模型视图矩阵堆栈modelViewMatrix）

1
2
3
4
5

// 几何变换的管道
GLGeometryTransform    transformPipeline;

// 设置变换管线以使用两个矩阵堆栈
transformPipeline.SetMatrixStacks(modelViewMatrix, projectionMatrix);

对于投影矩阵，直接在changeSize的时候配置就可以

1
2
3
4
5
6
7

// 透视投影
GLFrustum              viewFrustum;

// 设置透视投影
viewFrustum.SetPerspective(35.0f, float(w) / float(h), 1.0f, 500.0f);
// 重新加载投影矩阵到矩阵堆栈projectionMatrix
projectionMatrix.LoadMatrix(viewFrustum.GetProjectionMatrix());

接下来我们在renderSence配置模型视图矩阵

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// 加载一个单元矩阵到栈顶
modelViewMatrix.LoadIdentity();

// 复制一份栈顶矩阵到栈顶
modelViewMatrix.PushMatrix();

// 获得视图矩阵
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);

// 与栈顶矩阵叉乘并覆盖栈顶矩阵
modelViewMatrix.MultMatrix(mCamera);

// 获得模型矩阵
M3DMatrix44f mObjectFrame;
objectFrame.GetMatrix(mObjectFrame);

// 与栈顶矩阵叉乘并覆盖栈顶矩阵
modelViewMatrix.MultMatrix(mObjectFrame);

最终通过变换管道，生成矩阵传递给着色器

1
2
3
4
5

// 生成最终的矩阵
M3DMatrix44f *fMatrix = transformPipeline.GetModelViewProjectionMatrix()

// 传给平面着色器处理，vBlack为填充颜色
shaderManager.UseStockShader(GLT_SHADER_FLAT, fMatrix, vBlack);

对于几何图形除了直接填充颜色，还需要绘制边框（glPolygonMode）

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

// 开启多边形偏移
glPolygonOffset(-1.0f, -1.0f);
glEnable(GL_POLYGON_OFFSET_LINE);

// 开启反锯齿
glEnable(GL_LINE_SMOOTH);

// 开启混合
glEnable(GL_BLEND);
// 混合方法
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

// 绘制线框几何黑色版 三种模式，实心，边框，点，可以作用在正面，背面，或者两面
//通过调用glPolygonMode将多边形正面或者背面设为线框模式，实现线框渲染
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
//设置线条宽度
glLineWidth(2.5f);

shaderManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(), vBlack);
pBatch->Draw();

// 复原原本的设置
//通过调用glPolygonMode将多边形正面或者背面设为全部填充模式
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glDisable(GL_POLYGON_OFFSET_LINE);
glLineWidth(1.0f);
glDisable(GL_BLEND);
glDisable(GL_LINE_SMOOTH);

关于矩阵堆栈的操作

完整代码在这里

先来看一张架构图

Client与Server

这里的端不同于我们平常开发的客户端服务端

客户端：通常指在CPU存储的代码，负责发送OpenGL命令，比如OpenGLAPI，底层的C/C++代码，运行在CPU上
服务端：负责接收OpenGL命令并调用GPU芯片执行相应的操作，运行在GPU上

服务器和客户端在功能上也是异步的。客户端不断的把数据块和命令块组合在⼀起输送到缓冲区，然后缓冲区就会发送到服务器执行

数据通道

从上面架构图可以看出，从client到server传递的数据有三种

• Attributes：属性
• Uniforms：渲染矩阵
• TextureData：纹理数据

Attributes

属性会从客户端内存中复制存储在图形硬件中的一个缓冲区（显存）上，然后会被传递到顶点着色器Vertex Shader，无法直接传递到片元着色器Fragment Shader（但可间接传递到片元着色器），数据有下面类型（这些属性通常是经常变化的）

• 顶点数据：四维向量（x, y, z, w）
• 纹理坐标 (图片映射坐标)，实际是通过Vertex Shader传递给Fragment Shader
• 颜色数据
• 光照法线

Uniform

Uniform通过既可以传递到顶点着色器，也可以传递到片元着色器，Uniform中传递的通常是比较统一的批次数据，通常用来传递一些不经常发生变动的数据，例如变换矩阵

Texture Data

Texture Data同Uniform一样，可以将数据传递到顶点着色器和片元着色器，正如名字一样，主要传递纹理数据，由于顶点着色器主要是处理顶点数据的，我们将纹理数据传过去并没有多大的意义。而纹理的处理的逻辑主要是在片元着色器中进行的。用于对光栅化后的图像填充颜色

着色器

• 着色器是使用GLSL编写的程序，看起来与C语言非常类似。着色器必须从源代码中编译和链接在一起。最终准备就绪的着色器程序
• 顶点着色器
处理从客户机输入的数据、应用变换、进行其他的类型的数学运算来计算关照效果、位移、颜色值等等。（例如对于三个顶点的三角形渲染，顶点着色器将执行3次，也就是为了每个顶点执行一次）在目前的硬件上有多个执行单元同时运行，处理是并发的
• 图元装配：在顶点着色器确定完所有顶点的位置后，根据传入的配置确定图元形状，然后会对三角形逐个片段进行了光栅化处理
• 片元着色器
光栅化后的每个片段通过执行片元着色器进行颜色填充

最终会输出我们将屏幕上变成我们最终看到的颜色

• 设置顶点数据和其他参数。
• 在顶点着色器中进行运算得到裁剪坐标。
• 细分着色器、几何着色器，不可自定义，跳过。
• 图元设置，根据设置构成点、线、三角形。
• 裁剪，裁剪掉超出显示区域的部分。
• 光栅化, 将图源栅格化为一个个的像素点。
• 片元着色器，将对应的栅格(像素)填充为具体的颜色。
• 渲染图像

OpenGL有两种投影方式

1
2
3
4
5
6
7
8
9

#include "GLFrustum.h"

// 投影矩阵
GLFrustum              viewFrustum;

// 设置透视投影
viewFrustum.SetPerspective(35.0f, float(w) / float(h), 1.0f, 500.0f);
// 获取投影矩阵
M3DMatrix44f *projectionMatrix = viewFrustum.GetProjectionMatrix();

图元装配方式

在OpenGL中，相同的顶点可以有不同的装配方式，如下图

其中GL_TRIANGLE_STRIP和GL_TRIANGLE_FAN共享三角形的一条边，在绘制大量三角形的时候，可以节省存储空间和提高性能

如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

GLfloat vCoast[] = {
    3,3,0,
    0,3,0,
    3,0,0
};
// 三个点
pointBatch.Begin(GL_POINTS, 3);
pointBatch.CopyVertexData3f(vCoast);
pointBatch.End();

// 一条线
lineBatch.Begin(GL_LINES, 3);
lineBatch.CopyVertexData3f(vCoast);
lineBatch.End();

// 闭合三角形线段
lineLoopBatch.Begin(GL_LINE_LOOP, 3);
lineLoopBatch.CopyVertexData3f(vCoast);
lineLoopBatch.End();

// 闭合三角形，可以填充颜色
triangleBatch.Begin(GL_TRIANGLES, 3);
triangleBatch.CopyVertexData3f(vCoast);
triangleBatch.End();

存储着色器/固定管线着色器

在使用存储着色器之前需要先进行初始化

1
2

GLShaderManager shaderManager;
shaderManager.InitializeStockShaders();

OpenGL内置了很多存储着色器可以使用

单元着色器

使⽤场景：绘制默认OpenGL 坐标系(-1,1)下图形。 图形所有片段都会以⼀种颜⾊填充。

1
2
3
4

// 参数1: 存储着⾊器种类-单元着⾊器
// 参数2: 颜⾊值
GLShaderManager::UserStockShader(GLT_SHADER_IDENTITY,
                                 GLfloat vColor[4]);

平面着色器

使⽤场景：在绘制图形时, 可以应⽤矩阵变换(模型/投影变化)。

1
2
3
4
5
6

// 参数1: 存储着⾊器种类-平⾯着⾊器
// 参数2: 允许变化的4*4矩阵
// 参数3: 颜⾊色值
GLShaderManager::UserStockShader(GLT_SHADER_FLAT,
                                 GLfloat mvp[16],
                                 GLfloat vColor[4]);

上⾊着⾊器

使⽤场景：在绘制图形时, 可以应⽤变换(模型/投影变化)。颜色将会平滑地插入到顶点之间，称为平滑着色。

1
2
3
4

// 参数1: 存储着⾊器种类-上⾊着⾊器
// 参数2: 允许变化的4*4矩阵
GLShaderManager::UserStockShader(GLT_SHADER_SHADED,
                                 GLfloat mvp[16]);

默认光源着色器

使⽤场景：在绘制图形时, 可以应⽤变换(模型/投影变化)。这种着⾊器会使绘制的图形产生阴影和光照的效果。

1
2
3
4
5
6
7
8

// 参数1: 存储着⾊器种类-默认光源着⾊器
// 参数2: 模型4*4矩阵
// 参数3: 投影4*4矩阵
// 参数4: 颜⾊值
GLShaderManager::UserStockShader(GLT_SHADER_DEFAULT_LIGHT,
                                 GLfloat mvMatrix[16],
                                 GLfloat pMatrix[16],
                                 GLfloat vColor[4]);

点光源着⾊器

使⽤场景：在绘制图形时, 可以应用变换(模型/投影变化)。这种着⾊器会使绘制的图形产⽣阴影和光照的效果。它与默认光源着⾊器⾮常类似，区别只是光源位置可能是特定的。

1
2
3
4
5
6
7
8
9
10

// 参数1: 存储着⾊器种类-点光源着⾊器
// 参数2: 模型4*4矩阵
// 参数3: 投影4*4矩阵
// 参数4: 点光源的位置
// 参数5: 漫反射颜⾊值
GLShaderManager::UserStockShader(GLT_SHADER_POINT_LIGHT_DIFF,
                                 GLfloat mvMatrix[16],
                                 GLfloat pMatrix[16],
                                 GLfloat vLightPos[3],
                                 GLfloat vColor[4]);