【游戏开发创新】Unity狗屁不通文章生成器阐述点赞的意义，可生成文字长图保存到本地（Unity | 附源码 | Text转Texture长图 | 详细教程）

超、凢脫俗 2022-08-29 10:59 11阅读 0赞

![请添加图片描述][34a618727ba54190b2e3a759f159346c.gif]  
![请添加图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70]

### 文章目录 ###

*   *   *  一、前言
         *  二、流程概览
         *  三、BullshitGenerator项目测试
         *   *  1、项目下载
             *  2、测试JavaScript版
             *  3、测试Python版
         *  四、BullshitGenerator源码分析
         *   *  1、JavaScript版源码分析
             *   *  1.1、定义变量（配置表）
                 *  1.2、随便取一句
                 *  1.3、随便取一个数
                 *  1.4、来点名人名言
                 *  1.5、来点论述
                 *  1.6、增加段落
                 *  1.7、生成文章
             *  2、Python版源码分析
             *   *  2.1、读取配置
                 *  2.2、对废话和名人名言进行洗牌
                 *  2.3、来点名人名言
                 *  2.4、另起一段
                 *  2.5、main入口：生成文章
         *  五、界面设计
         *  六、UI素材获取
         *  七、创建Unity工程
         *  八、制作界面预设：MainPanel.prefab
         *  九、配置表：data.json
         *  十、程序代码
         *   *  1、BullshitGenerator.cs脚本
             *   *  1.1、使用LitJson解析配置
                 *  1.2、List洗牌
                 *  1.3、另起一段
                 *  1.4、获取一句名人名言
                 *  1.5、获取一句废话
                 *  1.6、段首空两格
                 *  1.7、生成文章
             *  2、MainPanel.cs脚本
             *   *  2.1、UI成员变量
                 *  2.2、初始化
                 *  2.3、生成文章按钮的点击逻辑
             *  3、测试文章生成
         *  十一、UGUI的Text如何转成Texture2D长图
         *   *  1、制作字体
             *  2、获取字体纹理贴图
             *  3、根据字符获取对应纹理uv、宽高信息等
             *  4、判断字符纹理是否是上下颠倒和顺时针90度
             *  5、获取字符的宽高
             *  6、获取字符的像素信息
             *  7、如何给Texture2D写入像素
             *  8、最终Utils的TextToTexture2D接口
         *  十二、Texture2D长图存为本地jpg文件
         *  十三、测试文字长图的生成
         *  十四、工程源码
         *  十五、完毕

### 一、前言 ###

嗨，大家好，我是新发。  
我在`GitHub`上看到了一个名字叫`BullshitGenerator`（狗屁不通文章生成器）的项目，地址：[https://github.com/menzi11/BullshitGenerator][https_github.com_menzi11_BullshitGenerator]  
有接近`1.5k`的星星，我下载下来玩了一下，有点意思，不过它是使用`Python`和`JavaScript`写的，嘛，那我来做一个`Unity`版的吧，顺便把文字生成长图的功能也做一下~

### 二、流程概览 ###

首先，我们要测试一下`BullshitGenerator`的功能，看它做了什么；  
接着，查看`BullshitGenerator`的源码，看它是怎么做的；  
最后，我们使用`Unity`来实现，并进行拓展，比如生成文字长图。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 1]

### 三、BullshitGenerator项目测试 ###

#### 1、项目下载 ####

`BullshitGenerator`项目地址：[https://github.com/menzi11/BullshitGenerator][https_github.com_menzi11_BullshitGenerator]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 2]  
下载下来后，可以看到它提供了两个版本的实现：`Python`和`JavaScript`，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 3]

#### 2、测试JavaScript版 ####

我们先来玩一下`JavaScript`版的，使用浏览器打开`index.html`，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 4]  
在主题输入框中输入文章主题，点击生成按钮，它就可以生成一篇狗屁不通的文章，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 5]

#### 3、测试Python版 ####

现在我们来玩下`python`版的，使用`python`执行这个`自动狗屁不通文章生成器.py`，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 6]  
输入文章主题，按回车，即可生成一篇狗屁不通的文章，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 7]

### 四、BullshitGenerator源码分析 ###

#### 1、JavaScript版源码分析 ####

我们使用文本编辑器打开`index.html`，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 8]

##### 1.1、定义变量（配置表） #####

它首先定义了几个列表，其实就是配置表，

> 注：作者使用`中文`做为`变量名`和`函数名`，一开始看有点不大习惯~

let 论述 = [ 
    	"现在，解决主题的问题，是非常非常重要的。 所以， ",
    	...
    	]
    let 名人名言 = [
    	"伏尔泰曾经说过，不经巨大的困难，不会有伟大的事业。这不禁令我深思",
    	...
    	]
    let 后面垫话 = [
    	"这不禁令我深思。 ",
    	...
    	]
    let 前面垫话 = [
    	"曾经说过",
    	...
    	]

接着封装一些必要的函数，我来一一讲解一下~

##### 1.2、随便取一句 #####

使用一个`Math.random`函数生成一个`0~1`的随机数，乘以列表长度，再使用`Math.floor`函数向下取整，得到一个列表的随机索引，最后根据索引从列表中取值。

function 随便取一句(列表){
        
        let 坐标 = Math.floor( Math.random() * 列表.length );
        return 列表[坐标];
    }

##### 1.3、随便取一个数 #####

从最小值和最大值之间随机取一个数，这个是用来做概率随机的，

function 随便取一个数(最小值 = 0,最大值 = 100){
        
        let 数字 = Math.random()*( 最大值 - 最小值 ) + 最小值;
        return 数字;
    }

##### 1.4、来点名人名言 #####

先从`名人名言`列表中随机取一句，然后把这句话中的关键字`“曾经说过”`替换为`前面垫话`列表的随机一句，再把关键字`“这不禁令我深思”`替换为`后面垫话`列表的随机一句话，

function 来点名人名言(){
        
        let 名言 = 随便取一句(名人名言)
        名言 = 名言.replace("曾经说过", 随便取一句(前面垫话) )
        名言 = 名言.replace("这不禁令我深思", 随便取一句(后面垫话) )
        return 名言
    }

画成图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 9]

##### 1.5、来点论述 #####

从`论述`列表中随机取一句，把关键字`"主题"`替换为我们的`主题变量`，注意这里用到了正则表达式，`RegExp("主题", "g")`是一个正则表达式，`g`表示全局匹配，即把句子中所有的关键字`"主题"`都进行匹配，比如我们取到一句论述：`"主题的发生，到底需要如何做到，不主题的发生，又会如何产生。 "`，这句论述中是有两个`"主题"`关键字的，我们将其替换为我们的`主题变量`，假设我们的`主题变量`为：`"一天掉多少根头发"`，那么替换后的句子就是：`"一天掉多少根头发的发生，到底需要如何做到，不一天掉多少根头发的发生，又会如何产生。 "`。

function 来点论述(){
        
        let 句子 = 随便取一句(论述);
        句子 = 句子.replace(RegExp("主题", "g"),主题);
        return 句子;
    }

画个图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 10]

##### 1.6、增加段落 #####

检查当前章节的文本的最后是否是一个空格，如果是，把章节的最后两个字符去掉：`章节.slice(0,-2)`，为什么要这样做呢？因为配置的`论述`和`后面垫话`的末尾都是一个标点符号然后留一个空格，比如：`"每个人都不得不面对这些问题。 在面对这种问题时， "`，如果在以此句作为章节的最后一句，则需要把`,(空格)`替换为句号`。`，章节的开头要空两个空格：`"　　" + 章节 + "。 "`。

function 增加段落(章节){
        
        if(章节[章节.length-1] === " "){
        
            章节 = 章节.slice(0,-2)
        }
        return "　　" + 章节 + "。 "
    }

画个图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 11]

##### 1.7、生成文章 #####

获取`input`的输入作为主体变量，  
文章文字长度小于`6000`字的情况下一直循环执行：  
`5%`的概率且文章字数大于`200`字时，生成新的章节；  
`15%`的概率随机一句名人名言；  
`80%`的概率随机一句论述；  
每个章节都塞入到文章中；  
最后显示文章文本到浏览器中。

function 生成文章(){
        
        主题 = $('input').value
        let 文章 = []
        for(let 空 in 主题){
        
            let 章节 = "";
            let 章节长度 = 0;
            while( 章节长度 < 6000 ){
        
                let 随机数 = 随便取一个数();
                if(随机数 < 5 && 章节.length > 200){
        
                    章节 = 增加段落(章节);
                    文章.push(章节); 
                    章节 = "";
                }else if(随机数 < 20){
        
                    let 句子 = 来点名人名言();
                    章节长度 = 章节长度 + 句子.length;
                    章节 = 章节 + 句子;
                }else{
        
                    let 句子 = 来点论述();
                    章节长度 = 章节长度 + 句子.length;
                    章节 = 章节 + 句子;
                }
            }
            章节 = 增加段落(章节);
            文章.push(章节);
        }
        let 排版 = "<div>" + 文章.join("</div><div>") + "</div>";
        $("#论文").innerHTML = 排版;
    }

画个图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 12]

到这里，`JavaScript`的源码我们就分析完了，其实整个逻辑很直接，不饶弯子，相信大家看一看就能看懂。下面我们再来看看`Python`版的源码吧~

#### 2、Python版源码分析 ####

我们使用文本编辑器打开`自动狗屁不通文章生成器.py`。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 13]

##### 2.1、读取配置 #####

可以看到，开头是使用`readJSON`模块来读取`data.json`配置，存到变量中，

import os, re
    import random,readJSON
    
    data = readJSON.读JSON文件("data.json")
    名人名言 = data["famous"] # a 代表前面垫话，b代表后面垫话
    前面垫话 = data["before"] # 在名人名言前面弄点废话
    后面垫话 = data['after']  # 在名人名言后面弄点废话
    废话 = data['bosh'] # 代表文章主要废话来源

我们可以打开`data.json`看看，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 14]

格式是这样的：

{
        
        "title":"主题",
        "famous":[
    		"爱迪生a，天才是百分之一的勤奋加百分之九十九的汗水。b",
    		"查尔斯·史a，一个人几乎可以在任何他怀有无限热忱的事情上成功。b",
    		...
    	],	
        "bosh":[
    		"现在，解决x的问题，是非常非常重要的。所以，",
    		"我们不得不面对一个非常尴尬的事实，那就是，",
    		...
    	],		
        "before":[
    		"这不禁令我深思。",
    		"带着这句话，我们还要更加慎重的审视这个问题：",
    		...
    	],	
        "after":[
    		"曾经说过",
    		"在不经意间这样说过",
    		...
    	],		
    }

我们再看回`readJSON.py`脚本，只有一个函数，就是先判断一下配置文件是不是`.json`结尾的，然后`open`配置文件，把文件内容`read`进来，最后`json.loads`把配置的文本(`json`格式的字符串)转为`python`的字典并`return`，

def 读JSON文件(fileName=""):
        import json
        if fileName!='':
            strList = fileName.split(".")
            if strList[len(strList)-1].lower() == "json":
                with open(fileName,mode='r',encoding="utf-8") as file:
                    return json.loads(file.read())

画个图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 15]

##### 2.2、对废话和名人名言进行洗牌 #####

定义一个洗牌方法，然后对废话和名人名言进行洗牌，并返回迭代器，方便后续使用迭代器进行`next`操作，

重复度 = 2
    
    def 洗牌遍历(列表):
        global 重复度
        池 = list(列表) * 重复度
        while True:
            random.shuffle(池)
            for 元素 in 池:
                yield 元素
    
    下一句废话 = 洗牌遍历(废话)
    下一句名人名言 = 洗牌遍历(名人名言)

注意，上面首先是把列表进行了`2`次重复，再进行洗牌。  
例：

a = [1,2,3]
    b = list(a) * 2
    print(b)
    # 输出[1, 2, 3, 1, 2, 3]

另外，上面用到了`random.shuffle`函数，它是将序列的所有元素随机排序（即洗牌）。

##### 2.3、来点名人名言 #####

使用`next`取出迭代器的下一个项，即下一句名人名言，然后对名言中的关键字`"a"`和`"b"`做替换：  
`"a"`替换为随机一句`前面垫话`；  
`"b"`替换为随机一句`后面垫话`；

def 来点名人名言():
        global 下一句名人名言
        xx = next(下一句名人名言)
        xx = xx.replace("a", random.choice(前面垫话))
        xx = xx.replace("b", random.choice(后面垫话))
        return xx

注意，`data.json`配置表中的名人名(`famous`)言格式为：  
`"名人a，名言。b"`，  
例：

"爱迪生a，天才是百分之一的勤奋加百分之九十九的汗水。b",
    "查尔斯·史a，一个人几乎可以在任何他怀有无限热忱的事情上成功。b",
    "培根说过，深窥自己的心，而后发觉一切的奇迹在你自己。b",
    ...

##### 2.4、另起一段 #####

另起一段就是给文章追加句号`.`，换行`"\r\n"`，新段落开头空四个空格，

def 另起一段():
        xx = ". "
        xx += "\r\n"
        xx += "    "
        return xx

##### 2.5、main入口：生成文章 #####

提示输入文章主题，当文章字数小于`1000`字时循环执行：`5%`的概率另起一段，`15%`的概率随机一句名人名言，`80%`的概率随机一句废话。  
最后替换关键字`"x"`为主题，输出文章内容。

if __name__ == "__main__":
        xx = input("请输入文章主题:")
        for x in xx:
            tmp = str()
            while ( len(tmp) < 1000 ) :
                分支 = random.randint(0,100)
                if 分支 < 5:
                    tmp += 另起一段()
                elif 分支 < 20 :
                    tmp += 来点名人名言()
                else:
                    tmp += next(下一句废话)
            tmp = tmp.replace("x",xx)
            print(tmp)

画个图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 16]

### 五、界面设计 ###

好了，现在我们开始动手制作`Unity`版本的狗屁不通文章生成器吧~  
我们先使用`axure`快速原型设计工具先简单设计一下界面，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 17]

### 六、UI素材获取 ###

简单的`UI`素材资源我是在阿里巴巴矢量图库上找，地址：[https://www.iconfont.cn/][https_www.iconfont.cn]  
比如搜索按钮，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 18]  
找一个形状合适的，可以进行调色，我一般是调成白色，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 19]  
因为`Unity`中可以设置`Color`，这样我们只需要一个白色按钮就可以在`Unity`中创建不同颜色的按钮了。  
弄点基础的美术资源，  
![在这里插入图片描述][ae4e5ed3812f472086d201f04692941c.png]

### 七、创建Unity工程 ###

创建一个`2D`模板的`Unity`工程，工程名我定为`UnityBullshitGenerator`，如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 20]  
我想做成竖版的，`Game`视图分辨率设置为`720*1280`，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 21]

### 八、制作界面预设：MainPanel.prefab ###

把上面我们获取的`UI`素材导入到`Unity`工程中，放在`Assets / Textures`目录中，如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 22]  
注意图片类型设置为`Sprite (2D and UI)`，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 23]  
对部分特定的`UI`素材使用`Sprite Editor`进行九宫格切割，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 24]  
接着，使用`UGUI`制作界面预设：`MainPanel.prefab`，保存到`Assets /Prefabs`目录中，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 25]  
预设节点结构如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 26]  
预设显示如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 27]

### 九、配置表：data.json ###

创建`data.json`，内容格式如下，可自行往配置中添加句子（注意有些句子是带可替换的字符的，比如`a、b、x`）

将`data.json`保存到`Unity`工程的`Assets/Resources`目录中：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 28]

### 十、程序代码 ###

程序部分，分为`Logic`和`View`，`Logic`实现逻辑，`View`实现界面交互。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 29]  
`BullshitGenerator.cs`和`MainPanel.cs`都很好写，难点是`Utils.cs`：文字如何转`Texture2D`（文字长图）。不要怕，稍作研究就可以做出来滴，我们先把简单的做了~

#### 1、BullshitGenerator.cs脚本 ####

在`Assets / Scripts / Logic`目录中创建`BullshitGenerator.cs`脚本，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 30]

`BullshitGenerator.cs`脚本要具体做什么呢？首先画一下思维导图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 31]

##### 1.1、使用LitJson解析配置 #####

我们要解析`json`格式的配置表，需要使用`Json`库，我推荐使用`LitJson`开源库，可以从`GitHub`上下载，`LitJson`开源项目地址：[https://hub.fastgit.org/LitJSON/litjson][https_hub.fastgit.org_LitJSON_litjson]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 32]  
我们下载下来后，把`src`目录中的`LitJson`文件夹整个拷贝到我们`Unity`工程中，如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 33]

接着我们就可以在代码中使用`LitJson`了，使用时引用命名空间

using LitJson;

我们先定义一些容器，用于存放配置表的内容，

// BullshitGenerator.cs
    
    /// <summary>
    /// 名人名言
    /// </summary>
    private List<string> m_famous = new List<string>();
    /// <summary>
    /// 废话
    /// </summary>
    private List<string> m_bosh = new List<string>();
    /// <summary>
    /// 前面垫话
    /// </summary>
    private List<string> m_after = new List<string>();
    /// <summary>
    /// 后面垫话
    /// </summary>
    private List<string> m_before = new List<string>();

封装一个`LoadCfg`方法，实现配置表读取的逻辑，

// BullshitGenerator.cs
    
    /// <summary>
    /// 读取配置表
    /// </summary>
    public void LoadCfg()
    {
        
        // 读取配置文件（json格式的字符串）
        var jsonText = Resources.Load<TextAsset>("data").text;
        // 转为JsonData
        var jd = JsonMapper.ToObject(jsonText);
        // 名人名言
        m_famous = JsonMapper.ToObject<List<string>>(jd["famous"].ToJson());
        // 废话
        m_bosh = JsonMapper.ToObject<List<string>>(jd["bosh"].ToJson());
        // 前垫话
        m_before = JsonMapper.ToObject<List<string>>(jd["before"].ToJson());
        // 后垫话
        m_after = JsonMapper.ToObject<List<string>>(jd["after"].ToJson());
      
    }

##### 1.2、List洗牌 #####

为了让名人名言和废话的获取具有随机性，我们写一个洗牌函数：

// BullshitGenerator.cs
    
    /// <summary>
    /// 对List进行洗牌
    /// </summary>
    private void Shuffle(ref List<string> list)
    {
        
        var r = new System.Random();
        for (int i = list.Count - 1; i >= 0; i--)
        {
        
            int cardIndex = r.Next(i);
            var temp = list[cardIndex];
            list[cardIndex] = list[i];
            list[i] = temp;
        }
    }

对名人名言和废话执行一次洗牌：

// BullshitGenerator.cs
    
    // 对名人名言进行洗牌
    Shuffle(ref m_famous);
    // 对废话进行洗牌
    Shuffle(ref m_bosh);

##### 1.3、另起一段 #####

封装一个`StartNewLine`函数，实现另起一段的功能（末尾标点符号替换为句号`。`并追加一个换行符`\n`），

// BullshitGenerator.cs
    
    /// <summary>
    /// 开始新的一行，会将传入的文本的最后一个标点符号替换为句号然后换行(\n)
    /// </summary>
    /// <param name="txt">传入的文本</param>
    /// <returns>处理后的文本</returns>
    private string StartNewLine(string txt)
    {
        
        if (txt.Length > 1)
            return txt.Substring(0, txt.Length - 1) + "。\n";
        return txt;
    }

##### 1.4、获取一句名人名言 #####

封装一个`GetFamous`方法，实现获取下一句名人名言的功能，

/// <summary>
    /// 获取一句名人名言
    /// </summary>
    private string GetFamous()
    {
        
        // 取下一句名人名言
        var txt = Next(m_famous, ref m_curFamousIndex);
        // 替换前垫话
        txt = txt.Replace("a", RandomChoice(m_before));
        // 替换后垫话
        txt = txt.Replace("b", RandomChoice(m_after));
        return txt;
    }
    
    /// <summary>
    /// 当前名人名言索引
    /// </summary>
    private int m_curFamousIndex = 0;

其中`Next`方法如下，实现从`List`中取下一个索引的值，

// BullshitGenerator.cs
    
    /// <summary>
    /// 取List的下一个索引的值
    /// </summary>
    /// <param name="list">List对象</param>
    /// <param name="index">当前索引</param>
    /// <returns></returns>
    private string Next(List<string> list, ref int index)
    {
        
        if (index < list.Count - 1)
        {
        
            ++index;
        }
        else
        {
        
            index = 0;
        }
        var result = list[index];
        return result;
    }

`RandomChoice`方法如下，实现从`List`随机取一个值的功能，

// BullshitGenerator.cs
    
    /// <summary>
    /// 对List进行随机获取一个值
    /// </summary>
    /// <param name="list">List对象</param>
    /// <returns></returns>
    private string RandomChoice(List<string> list)
    {
        
        return list[Random.Range(0, list.Count)];
    }

##### 1.5、获取一句废话 #####

// BullshitGenerator.cs
    
    /// <summary>
    /// 当前废话索引
    /// </summary>
    private int m_curBoshIndex = 0;
    
    // ...
    
    // 获取一句废话
    var bosh = Next(m_bosh, ref m_curBoshIndex);

##### 1.6、段首空两格 #####

我们需要对文字段落进行格式化，把英文的空格替换为中文的空格符`\u3000`，否则文字排版可能会出问题，如下：

// BullshitGenerator.cs
    
    /// <summary>
    /// 格式化空格（替换为中文的空格符：\u3000，并处理段首自动空两格）
    /// </summary>
    /// <param name="text">要处理的文本</param>
    /// <returns>处理后的文本</returns>
    private string FormatSpace(string text)
    {
        
        // 开头两个空白符
        var temp_content = "\u3000\u3000" + text;
        // 新的一行缩进两个空白符
        temp_content = temp_content.Replace("\n", "\n\u3000\u3000");
        // 英文空格转中文空白符
        temp_content = temp_content.Replace(" ", "\u3000");
        return temp_content;
    }

##### 1.7、生成文章 #####

封装一个`DoGen`函数，实现生成文章的功能，

/// <summary>
    /// 根据标题生成狗屁不通文章
    /// </summary>
    /// <param name="title">标题</param>
    /// <returns>生成的文章</returns>
    public string DoGen(string title)
    {
        
    	string tmp = "";
    	while (tmp.Length < 1000)
    	{
        
    	    var rd = Random.Range(0, 100);
    	
    	    if (rd < 5)
    	    {
        
    	        // 下一行
    	        tmp = StartNewLine(tmp);
    	    }
    	    else if (rd < 20)
    	    {
        
    	        // 取一句名人名言
    	        tmp += GetFamous();
    	
    	    }
    	    else
    	    {
        
    	        // 下一句废话
    	        tmp += Next(m_bosh, ref m_curBoshIndex);
    	    }
    	}
    	// 文末空一行
    	tmp = StartNewLine(tmp);
    	// 给标题关键字标注颜色
    	tmp = tmp.Replace("x", "<color=#960000ff>" + title + "</color>");
    	// 格式化空格
    	tmp = FormatSpace(tmp);
    	return tmp;
    }

#### 2、MainPanel.cs脚本 ####

在`Assets / Scripts / View`目录中创建`MainPanel.cs`脚本，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 34]

##### 2.1、UI成员变量 #####

先定义一些必要的`UI`成员变量，

using System.Collections;
    using UnityEngine;
    using UnityEngine.UI;
    
    public class MainPanel : MonoBehaviour
    {
        
        /// <summary>
        /// 主题输入框
        /// </summary>
        public InputField titleInput;
        /// <summary>
        /// 生成文章按钮
        /// </summary>
        public Button generateBtn;
        /// <summary>
        /// 保存图片按钮
        /// </summary>
        public Button saveBtn;
        /// <summary>
        /// 文章Text
        /// </summary>
        public Text articleText;
    
    	// ...
    }

##### 2.2、初始化 #####

在`Awake`中做一下初始化，调用配置加载接口，

// MainPanel.cs
    
    /// <summary>
    /// 文章生成器
    /// </summary>
    private BullshitGenerator m_generator;
    
    private void Awake()
    {
        
        m_generator = new BullshitGenerator();
        // 加载配置
        m_generator.LoadCfg();
    }

##### 2.3、生成文章按钮的点击逻辑 #####

在`Start`函数中，实现生成文章按钮的点击逻辑，调用`BullshitGenerator`的`DoGen`来生成文章，

// MainPanel.cs
    
    void Start()
    {
        
        string generateText = "";
    
        // 生成文章
        generateBtn.onClick.AddListener(() =>
        {
        
            generateText = m_generator.DoGen(titleInput.text);
            articleText.text = generateText;
        });
    }

#### 3、测试文章生成 ####

把`MainPanel.cs`脚本挂到`MainPanel.prefab`预设上，并赋值成员变量。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 35]  
运行`Unity`，测试效果如下，可以正常生成狗屁不通的文章~  
![请添加图片描述][175b78cb3f2a45bd849b55f817ada6da.gif]

### 十一、UGUI的Text如何转成Texture2D长图 ###

现在，我们要将文字保存为长图，也就是把`UGUI`的`Text`转成`Texture2D`，再把`Texture2D`存为本地的`jpg`文件。  
我的思路利用自定义字体生成字体纹理贴图，通过文字的`uv`坐标信息获取文字的像素信息，然后绘制到我们动态生成的`Texture2D`对象上。

#### 1、制作字体 ####

首先，我们找一个`ttf`字体，放到`Unity`工程的`Assets / Fonts`文件夹中，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 36]  
将字体的`Character`设置为`Custom Set`，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 37]  
在字体统计目录中创建一个`character.txt`，  
![在这里插入图片描述][af8e11adeaeb49aba2f361992e848d62.png]  
把英文字母、数字、标点符号、常用汉字放到这个`character.txt`文件中，如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 38]  
然后把整个文本内容复制，回到`Unity`中，粘贴到`Font`的`Custom Chars`中，点击`Apply`，

> 注：上面存为`character.txt`文件不是必要的，但建议你存成文件，方便你查找或修改字符。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 39]  
此时字体会生成一个材质和纹理贴图，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 40]  
字太多了，这样看看不大清，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 41]  
我们先弄少一点字符，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 42]  
看它生成的纹理贴图，我们可以看到，我们的字有的是上下颠倒的，有的是顺时针旋转了`90`度，（经过我多次测试，发现它只有这两种情况），这个我们后面写文字长图生成的时候需要小心了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 43]

#### 2、获取字体纹理贴图 ####

var fontTexture = (Texture2D)font.material.mainTexture;

不过字体纹理本身不可读，我们无法对其调用`GetPixels`函数，所以我们需要拷贝一份可读的，

// 字体贴图不可读，需要创建一个新的可读的
    var fontTexture = (Texture2D)font.material.mainTexture;
    var readableFontTexture = new Texture2D(fontTexture.width, 
    	fontTexture.height, 
    	fontTexture.format, 
    	fontTexture.mipmapCount, 
    	true);
    Graphics.CopyTexture(fontTexture, readableFontTexture);

#### 3、根据字符获取对应纹理uv、宽高信息等 ####

char charitem = "哈";
    font.GetCharacterInfo(charitem, out CharacterInfo info);

从`CharacterInfo`中我们就可以获取到字符的详细信息，包括`uv`、宽高等信息，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 44]

#### 4、判断字符纹理是否是上下颠倒和顺时针90度 ####

我们上面可以看到，字符纹理有的是上下颠倒的，我们可以使用`uvTopLeft`和`uvBottomRight`来判断

if (info.uvTopLeft.y < info.uvBottomRight.y)
    {
        
    	// 字符是上下颠倒的
    }
    else
    {
        
    	// 顺时针旋转90度的
    }

#### 5、获取字符的宽高 ####

字符的实际宽高的获取要小心了，如果是顺时针旋转`90`度的字符，则宽和高是对调的，

int charWidth, charHeight;// 字符宽高
     
    if (info.uvTopLeft.y < info.uvBottomRight.y)
    {
        
    	// 字符是上下颠倒的
    	charWidth = info.glyphWidth;
        charHeight = info.glyphHeight;
    }
    else
    {
        
    	// 顺时针旋转90度的
    	charWidth = info.glyphHeight;
        charHeight = info.glyphWidth;
    }

#### 6、获取字符的像素信息 ####

我们上面已经得到了可读的字体纹理贴图（`Texture2D`），又拿到了字符的`uv`坐标、字符宽高信息，那么，我们就可以通过`Texture2D`的`GetPixels`接口获取到字符的像素信息了，

public Color[] GetPixels(int x, int y, int blockWidth, int blockHeight);

上下颠倒的字符的像素信息的获取：

Color[] charColor = readableFontTexture.GetPixels(
                        (int)(readableFontTexture.width * info.uvTopLeft.x),
                        (int)(readableFontTexture.height * info.uvTopLeft.y),
                        charWidth, charHeight);

顺时针旋转`90`度的字符的像素信息的获取：

charColor = readableFontTexture.GetPixels(
                        (int)(readableFontTexture.width * info.uvBottomRight.x),
                        (int)(readableFontTexture.height * info.uvBottomRight.y),
                        charWidth, charHeight);

#### 7、如何给Texture2D写入像素 ####

我们要创建一个长图（背景白色），然后给这个长图挨个字挨个字写入像素，所以，我们先创建一个`Texture2D`，并填充背景色，

// 背景色
    Color backgroundColor = Color.white;
    // 创建Texture2D
    var textTexture = new Texture2D(textureWidth, textureHeight, TextureFormat.ARGB32, true);
    // 填充背景色
    Color[] emptyColor = new Color[textureWidth * textureHeight];
    for (int i = 0; i < emptyColor.Length; i++)
    {
        
        emptyColor[i] = backgroundColor;
    }
    textTexture.SetPixels(emptyColor);

接着我们就可以使用`SetPixels`接口给这个长图`Texture2D`挨个字挨个字写入字符像素了，

// 逐个字符绘制
    foreach (var charitem in text.ToCharArray())
    {
        
    	// ...
    	
    	textTexture.SetPixel(x, y, color);
    }

这里我们需要自己维护一个光标坐标，要控制好光标坐标不能超过`Texture2D`外面，还有每个字符的像素尺寸是有大有小的，我们需要计算中心对齐，不然字符就会高高低低（标点符号除外，否则比如逗号就会和文字是中心对齐的，实际上逗号要在文字的脚下）

#### 8、最终Utils的TextToTexture2D接口 ####

在`Assets / Scripts / Logic`目录中新建一个`Utils.cs`脚本，封装一个`TextToTexture2D`接口，如下：

// Utils.cs
    
    /// <summary>
    /// UGUI的Text转Texture2D
    /// </summary>
    /// <param name="font">字体</param>
    /// <param name="text">Text的文本</param>
    /// <param name="textureWidth">图片的宽</param>
    /// <param name="textureHeight">图片的高（最终会以字体的排版而裁剪掉多余的空白部分）</param>
    /// <param name="drawOffsetX">要渲染的文字的x坐标偏移</param>
    /// <param name="drawOffsetY">要渲染的文字的y坐标偏移</param>
    /// <param name="textGap">每个字之间的间隔</param>
    /// <param name="spaceGap">空白符的间隔</param>
    /// <param name="fontSize">字体大小</param>
    /// <param name="textColor">文字颜色</param>
    /// <param name="backgroundColor">背景图颜色</param>
    /// <returns></returns>
    public static Texture2D TextToTexture2D(
        Font font,
        string text,
        int textureWidth, int textureHeight,
        int drawOffsetX, int drawOffsetY,
        int textGap, int spaceGap, int fontSize,
        Color textColor,
        Color backgroundColor)
    {
        
    
        // 创建返回的Texture
        var textTexture = new Texture2D(textureWidth, textureHeight, TextureFormat.ARGB32, true);
        Color[] emptyColor = new Color[textureWidth * textureHeight];
        for (int i = 0; i < emptyColor.Length; i++)
        {
        
            emptyColor[i] = backgroundColor;
        }
        textTexture.SetPixels(emptyColor);
    
        // 字体贴图不可读，需要创建一个新的可读的
        var fontTexture = (Texture2D)font.material.mainTexture;
        var readableFontTexture = new Texture2D(fontTexture.width, fontTexture.height, fontTexture.format, fontTexture.mipmapCount, true);
        Graphics.CopyTexture(fontTexture, readableFontTexture);
    
        // 调整偏移量
        var originalDrawOffsetX = drawOffsetX; // 记录一下，换行用
        drawOffsetY = textureHeight - drawOffsetY - fontSize; // 从上方开始画
    
        // 逐个字符绘制
        foreach (var charitem in text.ToCharArray())
        {
        
            if ('\u3000' == charitem || ' ' == charitem)
            {
        
                drawOffsetX += spaceGap;
                continue;
            }
    
            if ('\n' == charitem)
            {
        
                // 换行
                drawOffsetX = originalDrawOffsetX;
                drawOffsetY -= fontSize;
    
                continue;
            }
    
            // 判断是否是中文
            bool isChinese = false;
            if (charitem >= 0x4e00 && charitem <= 0x9fbb)
            {
        
                isChinese = true;
            }
    
            if (drawOffsetX >= textTexture.width - fontSize)
            {
        
                // 换行
                drawOffsetX = originalDrawOffsetX;
                drawOffsetY -= fontSize;
            }
    
            int charWidth, charHeight;// 字符宽高
            Color[] charColor;// 字符颜色，数组内颜色的顺序为从左至右，从下至上
    
            font.GetCharacterInfo(charitem, out CharacterInfo info);
    
            if (info.uvTopLeft.y < info.uvBottomRight.y)// 处理被垂直翻转的字符
            {
        
                charWidth = info.glyphWidth;
                charHeight = info.glyphHeight;
                charColor = readableFontTexture.GetPixels(
                    (int)(readableFontTexture.width * info.uvTopLeft.x),
                    (int)(readableFontTexture.height * info.uvTopLeft.y),
                    charWidth, charHeight);
    
                for (int j = 0; j < charHeight; j++)
                {
        
                    for (int i = 0; i < charWidth; i++)
                    {
        
                        if (charColor[j * charWidth + i].a != 0)
                        {
        
                            // 从上往下画，把字符颠倒过来
                            textTexture.SetPixel(
                                drawOffsetX + i,
                                drawOffsetY + charHeight - j + (isChinese ? ((int)((fontSize - charHeight) / 2f)) : 0),
                                textColor);
                        }
                    }
                }
    
                drawOffsetX += charWidth + textGap;
            }
            else // 处理被顺时针旋转90度的字符
            {
        
                charWidth = info.glyphHeight;
                charHeight = info.glyphWidth;
                charColor = readableFontTexture.GetPixels(
                    (int)(readableFontTexture.width * info.uvBottomRight.x),
                    (int)(readableFontTexture.height * info.uvBottomRight.y),
                    charWidth, charHeight);
    
                for (int j = 0; j < charHeight; j++)
                {
        
                    for (int i = 0; i < charWidth; i++)
                    {
        
                        if (charColor[j * charWidth + i].a != 0)
                        {
        
    
                            // 旋转
                            textTexture.SetPixel(
                                drawOffsetX + charHeight - j,
                                drawOffsetY + i + (isChinese ? ((int)((fontSize - charWidth) / 2f)) : 0),
                                textColor);
                        }
                    }
                }
                drawOffsetX += charHeight + textGap;
            }
        }
        var realTextureHeight = textureHeight - drawOffsetY;
        textTexture.Apply();
        var finalTexture = new Texture2D(textureWidth, realTextureHeight, TextureFormat.ARGB32, true);
        Graphics.CopyTexture(textTexture, 0, 0, 0, drawOffsetY, textureWidth, realTextureHeight, finalTexture, 0, 0, 0, 0);
        Object.Destroy(textTexture);
        Object.Destroy(readableFontTexture);
        return finalTexture;
    }

### 十二、Texture2D长图存为本地jpg文件 ###

我们在`Utils`脚本中封装一个`SaveTextureToLocal`方法，这个比较简单，就不细讲了~

// Utils.cs
    
    /// <summary>
    /// 将Texture2D保存到本地文件
    /// </summary>
    /// <param name="texture">Texture2D对象</param>
    /// <param name="fileName">要保存的文件名</param>
    public static string SaveTextureToLocal(Texture2D texture, string fileName)
    {
        
        var bytes = texture.EncodeToJPG();
        var savePath = Application.persistentDataPath + "/" + fileName;
    #if UNITY_EDITOR
        savePath = Application.dataPath + "/" + fileName;
    #endif
        File.WriteAllBytes(savePath, bytes);
    
        Debug.Log("SaveTextureToLocal: " + savePath);
        return savePath;
    }

### 十三、测试文字长图的生成 ###

在`MainPanel.cs`脚本中的保存图片按钮的响应中添加`Utils`的调用，

// MainPanel.cs
    
    public GameObject waitObj;
    public GameObject tipsObj;
    public Text tipsText;
    private Coroutine saveTextureCoroutine;
    
    private void Start()
    {
        
    	// ...
    	
    	// 保存为图片
    	saveBtn.onClick.AddListener(() =>
    	{
        
    	    if (null != saveTextureCoroutine)
    	        StopCoroutine(saveTextureCoroutine);
    	    saveTextureCoroutine = StartCoroutine(SaveTexture(generateText));
    	});
    }
    
    private IEnumerator SaveTexture(string generateText)
    {
        
        waitObj.SetActive(true);
        yield return null;
        // 对文字做些处理
        generateText = generateText.Replace("<color=#960000ff>", "").Replace("</color>", "");
        generateText = string.Format("题目：{0}\n{1}\n博主:林新发\n博客：https://blog.csdn.net/linxinfa\n", titleInput.text, generateText);
        // 文字转Texture2D
        var texture2D = Utils.TextToTexture2D(articleText.font, generateText,
            (int)articleText.rectTransform.rect.width,
            (int)articleText.rectTransform.rect.height, 10, 10, 1,
            articleText.fontSize, articleText.fontSize, Color.black, Color.white);
        // 保存为jpg
        var savePath = Utils.SaveTextureToLocal(texture2D, "article.jpg");
        // 提示保存路径
        tipsObj.SetActive(true);
        tipsText.text = "保存成功，路径：\n" + savePath;
        waitObj.SetActive(false);
        // 2秒后自动隐藏提示
        yield return new WaitForSeconds(2);
        tipsObj.SetActive(false);
    }

把`MainPanel.prefab`中显示文章文本的`Text`的字体设置为我们自定义的字体，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 45]  
运行`Unity`，生成文章，点击保存图片，

![请添加图片描述][34a618727ba54190b2e3a759f159346c.gif]  
生成的长图如下（如果觉得不错，记得给我点个赞呀，我可是调试测试了好多次`T_T`）：  
![请添加图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70]

### 十四、工程源码 ###

本文工程源码我一上传到`CODE CHINA`，感兴趣的同学可自行下载下来学习。  
地址：[https://codechina.csdn.net/linxinfa/unitybullshitgenerator][https_codechina.csdn.net_linxinfa_unitybullshitgenerator]  
注：我使用的`Unity`版本为：`2021.1.7f1c1`  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 46]

### 十五、完毕 ###

好了，就写到这里吧~  
我是林新发：[https://blog.csdn.net/linxinfa][https_blog.csdn.net_linxinfa]  
原创不易，若转载请注明出处，感谢大家~  
喜欢我的可以点赞、关注、收藏，如果有什么技术上的疑问，欢迎留言或私信~

[34a618727ba54190b2e3a759f159346c.gif]: /images/20220829/c304617f3848480f93bc38a33571c837.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70]: /images/20220829/92633f7a6e2d4241a58d7463d8c34b91.png
[https_github.com_menzi11_BullshitGenerator]: https://github.com/menzi11/BullshitGenerator
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 1]: /images/20220829/8fdf5247266b4457b0831fbd458737f1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 2]: /images/20220829/0ccb3c52a1184399a581f5d9690dbf7b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 3]: /images/20220829/f433ee1ca3ab4e3eb07e3b9cccf76e1b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 4]: /images/20220829/a55904d84b554852bb71aad9ae61f6a8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 5]: /images/20220829/14507846061f452fa4f3e45349d55ba4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 6]: /images/20220829/9e7d6d138dfc4e35a7177868b9377273.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 7]: /images/20220829/2161d6e3f2df4747a968cd1f5f3666c5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 8]: /images/20220829/e988b57ff6a04ba98bcedb69142cbdc6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 9]: /images/20220829/a4111b52099c419dab0f2254672ed098.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 10]: /images/20220829/7d8d4513a3b640f1b561418521f3f511.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 11]: /images/20220829/f8a1b3a19e6048468257a25cf252a0fb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 12]: /images/20220829/84f8b48b57b346d8a78205d15f7768d0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 13]: /images/20220829/f49ab43866fc4b42bc89a65ccb3d76ac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 14]: /images/20220829/9b50c7f47f7d4915ba851998d56a029d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 15]: /images/20220829/92ae6e5c730641b589e013b2a7129ec8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 16]: /images/20220829/51021869fc7845c287022ae56cdf3408.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 17]: /images/20220829/f52f66fbf42e4ace80cbe8485b83f5ed.png
[https_www.iconfont.cn]: https://www.iconfont.cn/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 18]: /images/20220829/3c00b2ecddd546db87add99b1c8abb76.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 19]: /images/20220829/fa3394891b3b49319f85c51ed8e7c830.png
[ae4e5ed3812f472086d201f04692941c.png]: /images/20220829/8a5d4713584449a68c50104e93cbb920.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 20]: /images/20220829/ba4629091bf24b20b12b4211ab141d1a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 21]: /images/20220829/1195952545e74bebb6bbc2744352c5b9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 22]: /images/20220829/163487fa50524368b6b44af21a92a969.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 23]: /images/20220829/4d5ae29e39cf4a1dbf8078dc7a9ee517.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 24]: /images/20220829/11e65bc049504dd4b14f25247a96b351.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 25]: /images/20220829/10a0519b306347409fd093ed568cedee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 26]: /images/20220829/161d9af82d024c7aa7b896afd5eccb91.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 27]: /images/20220829/079f18915cec41aa980e773c70d14d4d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 28]: /images/20220829/b62ef1b97c7b4ecf926fc24f2bb199af.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 29]: /images/20220829/9611cba2db444715b74d38c274d914e0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 30]: /images/20220829/a5fd8a68bfd844e8b41e78fffe6c7bf3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 31]: /images/20220829/55a833c48a0349ac85795b7c0f4160ba.png
[https_hub.fastgit.org_LitJSON_litjson]: https://hub.fastgit.org/LitJSON/litjson
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 32]: /images/20220829/ffb8452b2383476d8c99ff5eccb57a2b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 33]: /images/20220829/9d530f1a492f442d982a44661fea9174.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 34]: /images/20220829/7839bbe848bf493ca1ad83c86af3e6fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 35]: /images/20220829/f7ed08e8e28a40c1900fa1e3f392ce6b.png
[175b78cb3f2a45bd849b55f817ada6da.gif]: /images/20220829/22893b3c4d584f0b8b922faf2a5dac4c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 36]: /images/20220829/ea733be0decd401f8f44e9fe3e2ea096.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 37]: /images/20220829/7583d0419ba04863a3be4397d1855d84.png
[af8e11adeaeb49aba2f361992e848d62.png]: /images/20220829/d0b37574bdda414295df719895e25c72.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 38]: /images/20220829/bac9f65613a1438aacb48497d08c267d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 39]: /images/20220829/5bf684a1aee24f789fad3c0da15afd70.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 40]: /images/20220829/f54bff1fea5f4a8bb5a277bb1eaf57b1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 41]: /images/20220829/2d96ac68465941448286447fc4ab4a31.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 42]: /images/20220829/8761c9a9d82b47ff92e9a2a4a36a6880.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 43]: /images/20220829/6d5fc02666d14826b53ddd1e9eb1bbce.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 44]: /images/20220829/9b7aea54e81948ecb40a816dd97f5757.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 45]: /images/20220829/0896e006c05a4c4984a004e4aeffab7d.png
[https_codechina.csdn.net_linxinfa_unitybullshitgenerator]: https://codechina.csdn.net/linxinfa/unitybullshitgenerator
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 46]: /images/20220829/6b3155950e9b40dbb6914745d3e92705.png
[https_blog.csdn.net_linxinfa]: https://blog.csdn.net/linxinfa