Unity中播放GIF

作者：追风剑情 发布于：2021-5-10 9:54 分类：Unity3d

GIF文件格式介绍 https://www.jianshu.com/p/4fabac6b15b3
GIF文件格式介绍 https://blog.csdn.net/wzy198852/article/details/17266507
GIFLIB 项目

下载GIF播放插件 https://github.com/WestHillApps/UniGif

如果播放时GIF背景显示纯黑色，可以修改下源码让GIF的背景显示为透明色：

修改 UniGifDecoder.cs 中的 GetColorTableAndSetBgColor() 方法: 


  1. /// <summary>
  2. /// Get color table and set background color (local or global)
  3. /// </summary>
  4. private static List<byte[]> GetColorTableAndSetBgColor(GifData gifData, ImageBlock imgBlock, int transparentIndex, out Color32 bgColor)
  5. {
  6. 	List<byte[]> colorTable = imgBlock.m_localColorTableFlag ? imgBlock.m_localColorTable : gifData.m_globalColorTableFlag ? gifData.m_globalColorTable : null;
  7.  
  8. 	// 注释掉原来的代码
  9. 	//if (colorTable != null)
  10. 	//{
  11. 	//    // Set background color from color table
  12. 	//    byte[] bgRgb = colorTable[gifData.m_bgColorIndex];
  13. 	//    bgColor = new Color32(bgRgb[0], bgRgb[1], bgRgb[2], (byte)(transparentIndex == gifData.m_bgColorIndex ? 0 : 255));
  14. 	//}
  15. 	//else
  16. 	//{
  17. 	//    bgColor = Color.black;
  18. 	//}
  19.  
  20. 	// 直接修改成透明背景
  21. 	bgColor = Color.black;
  22. 	bgColor.a = 0;
  23.  
  24. 	return colorTable;
  25. }


GIF文件结构

11111.png

1111.png

图形控制器扩展(graphic control extension)中的透明颜色索引(transparent color index)对应全局颜色表(global color table)中的索引。

GIF辅助类 


  1. #define DEBUG_GIF_DECODE
  2. using System;
  3. using System.Text;
  4. using System.Collections;
  5. using System.Collections.Generic;
  6. using System.Diagnostics;
  7. using UnityEngine;
  8. /// <summary>
  9. /// GIF 辅助类
  10. /// GIF用的LZW压缩算法能将图像尺寸压缩20%～25%
  11. /// 字符=ASCII: 
  12. ///     'G'=71,'I'=73,'F'=70,'7'=55,'8'=56,'9'=57,'a'=97
  13. /// 参考 https://blog.csdn.net/Swallow_he/article/details/76165202
  14. /// </summary>
  15. public sealed class GIFHelper
  16. {
  17.     #region 文件头
  18.     //判断是否为GIF文件
  19.     public static bool IsGIF(byte[] bytes)
  20.     {
  21.         byte b0 = bytes[0];
  22.         byte b1 = bytes[1];
  23.         byte b2 = bytes[2];
  24.         return 71 == b0 && 73 == b1 && 70 == b2;
  25.     }
  26.  
  27.     //判断GIF版本是否为 GIF87a
  28.     public static bool IsGIF87a(byte[] bytes)
  29.     {
  30.         if (!IsGIF(bytes))
  31.             return false;
  32.  
  33.         byte b3 = bytes[3];
  34.         byte b4 = bytes[4];
  35.         byte b5 = bytes[5];
  36.         return 56 == b3 && 55 == b4 && 97 == b5;
  37.     }
  38.  
  39.     //判断GIF版本是否为 GIF89a
  40.     //这个版本才支持动画和透明背景
  41.     public static bool IsGIF89a(byte[] bytes)
  42.     {
  43.         if (!IsGIF(bytes))
  44.             return false;
  45.  
  46.         byte b3 = bytes[3];
  47.         byte b4 = bytes[4];
  48.         byte b5 = bytes[5];
  49.         return 56 == b3 && 57 == b4 && 97 == b5;
  50.     }
  51.  
  52.     //获取标记域和版本号
  53.     public static string SignatureVersion(byte[] bytes)
  54.     {
  55.         StringBuilder sb = new StringBuilder();
  56.         for (int i = 0; i < 6; i++)
  57.             sb.Append((char)bytes[i]);
  58.         return sb.ToString();
  59.     }
  60.     #endregion
  61.  
  62.     #region 逻辑描述块(LogicalScreen Descriptor), 包含7个字节
  63.  
  64.     #region 图片宽高
  65.     //获取逻辑显示屏宽度 (图片宽度), 2字节
  66.     public static ushort LogicalScreenWidth(byte[] bytes)
  67.     {
  68.         //byte b6 = bytes[6];
  69.         //byte b7 = bytes[7];
  70.         ////小端
  71.         //short width = (short)((b7 << 8) | (b6 & 0xff));
  72.         ushort width = BitConverter.ToUInt16(bytes, 6);
  73.         return width;
  74.     }
  75.  
  76.     //获取逻辑显示屏高度 (图片高度), 2字节
  77.     public static ushort LogicalScreenHeight(byte[] bytes)
  78.     {
  79.         //byte b8 = bytes[8];
  80.         //byte b9 = bytes[9];
  81.         ////小端
  82.         //short height = (short)((b9 << 8) | (b8 & 0xff));
  83.         ushort height = BitConverter.ToUInt16(bytes, 8);
  84.         return height;
  85.     }
  86.     #endregion
  87.  
  88.     #region 包装域(Packed Fields) (G CR S Size), 1字节
  89.     //Size of Global Color Table 占 3bit
  90.     //Sort Flag 占 1bit
  91.     //Color Resolution 占 3bit
  92.     //Global Color Table Flag 占 1bit
  93.  
  94.     //全局彩色表大小,代表每个像素的位数, 7bit可表示0～255
  95.     public static int SizeOfGlobalColorTable(byte[] bytes)
  96.     {
  97.         byte b10 = bytes[10];
  98.         byte size = (byte)(b10 & 7); //7: 00000111
  99.         //表项数目
  100.         int table_size = (int)Math.Pow(2, size + 1);
  101.         //每个表项由3个字节组成(R、G、B)
  102.         //彩色表的字节数等于 3 * table_size
  103.         return table_size;
  104.     }
  105.  
  106.     //彩色表排序标志
  107.     //Flag=1: 表示全局彩色表中的颜色存在重要性排序,重要的颜色被排在前面
  108.     public static byte SortFlag(byte[] bytes)
  109.     {
  110.         byte b10 = bytes[10];
  111.         byte flag = (byte)((b10 >> 3) & 1);//00001000
  112.         return flag;
  113.     }
  114.  
  115.     //调色板中的基色占几bit
  116.     //例如 CR=3, 表示占4bit
  117.     public static byte ColorResolution(byte[] bytes)
  118.     {
  119.         byte b10 = bytes[10];
  120.         byte cr = (byte)((b10 >> 4) & 7);//01110000
  121.         return cr;
  122.     }
  123.  
  124.     //全局彩色表标志
  125.     //G=1: 表示存在全局彩色表
  126.     public static byte GlobalColorTableFlag(byte[] bytes)
  127.     {
  128.         byte b10 = bytes[10];
  129.         byte G = (byte)(b10 >> 7);//?0000000
  130.         return G;
  131.     }
  132.     #endregion
  133.  
  134.     #region 背景颜色索引
  135.     //获取背景颜色索引(彩色表位置)
  136.     //如果Global Color Table Flag为0，则该值也设为0
  137.     public static byte BackgroundColorIndex(byte[] bytes)
  138.     {
  139.         byte b11 = bytes[11];
  140.         return b11;
  141.     }
  142.     #endregion
  143.  
  144.     #region 像素宽高比
  145.     //像素宽高比,是原始图像像素的宽高比的一个近似值
  146.     //宽高比计算公式: Aspect Ratio = (Pixel AspectRatio + 15) / 64
  147.     public static byte PixelAspectRatio(byte[] bytes)
  148.     {
  149.         byte b12 = bytes[12];
  150.         return b12;
  151.     }
  152.     #endregion
  153.  
  154.     #region 全局彩色表
  155.  
  156.     //获取全局彩色表
  157.     public static List<byte[]> GlobalColorTable(byte[] bytes)
  158.     {
  159.         var globalColorTable = new List<byte[]>();
  160.         if (GlobalColorTableFlag(bytes) == 0)
  161.             return globalColorTable;
  162.         
  163.         int byteIndex = 13;
  164.         int sizeOfGlobalColorTable = SizeOfGlobalColorTable(bytes);
  165.         // Global Color Table(0～255×3 Bytes)
  166.         for (int i = byteIndex; i < byteIndex + (sizeOfGlobalColorTable * 3); i += 3)
  167.         {
  168.             globalColorTable.Add(new byte[] { bytes[i], bytes[i + 1], bytes[i + 2] });
  169.         }
  170.         return globalColorTable;
  171.     }
  172.     #endregion
  173.  
  174.     #endregion
  175. }
  176.  
  177. /// <summary>
  178. /// GIF图像
  179. /// </summary>
  180. public class GIFImage
  181. {
  182.     //头信息
  183.     public GIFHeader Header { get; private set; }
  184.     //屏幕逻辑描述符
  185.     public GIFLogicalScreenDescriptor LogicalScreenDescriptor { get; private set; }
  186.     //全局颜色表
  187.     public GIFGlobalColorTable GlobalColorTable { get; private set; }
  188.     //图形控制扩展
  189.     public List<GIFGraphicControlExtension> graphicControlExtList { get; private set; }
  190.     //文本扩展
  191.     public List<GIFPlainTextExtension> plainTextExtList { get; private set; }
  192.     //应用程序扩展
  193.     public List<GIFApplicationExtension> applicationExtList { get; private set; }
  194.     //注释扩展
  195.     public List<GIFCommentExtension> commentExtList { get; private set; }
  196.     //图像描述符
  197.     public List<GIFImageDescriptor> imageDescriptorList { get; private set; }
  198.     //Texture2D 列表
  199.     public List<Texture2D> textures { 
  200.         get {
  201.             if (gifData == null)
  202.                 return new List<Texture2D>();
  203.             return gifData.textures; 
  204.         }
  205.     }
  206.  
  207.     private GIFData gifData;
  208.  
  209.     /// <summary>
  210.     /// 构造方法
  211.     /// </summary>
  212.     /// <param name="bytes">gif文件二进制数据</param>
  213.     public GIFImage(byte[] bytes)
  214.     {
  215.         LoadFileData(bytes);
  216.     }
  217.  
  218.     //载入GIF文件数据
  219.     public void LoadFileData(byte[] bytes)
  220.     {
  221.         GIFDebug.Log("<i><b>*** gif decode start... ***</b></i>");
  222.  
  223.         gifData = new GIFData();
  224.         int byteIndex = 0;
  225.         Header = new GIFHeader(bytes, ref byteIndex);
  226.         LogicalScreenDescriptor = new GIFLogicalScreenDescriptor(bytes, ref byteIndex);
  227.         if (LogicalScreenDescriptor.packedField.globalColorTableFlag == 1)
  228.         {
  229.             GlobalColorTable = new GIFGlobalColorTable(bytes, ref byteIndex,
  230.                 LogicalScreenDescriptor.packedField.sizeOfGlobalColorTable);
  231.             gifData.m_globalColorTable = GlobalColorTable;
  232.         }
  233.         gifData.m_logicalScreenDescriptor = LogicalScreenDescriptor;
  234.  
  235.         graphicControlExtList = new List<GIFGraphicControlExtension>();
  236.         plainTextExtList = new List<GIFPlainTextExtension>();
  237.         applicationExtList = new List<GIFApplicationExtension>();
  238.         commentExtList = new List<GIFCommentExtension>();
  239.         imageDescriptorList = new List<GIFImageDescriptor>();
  240.  
  241.         while (true)
  242.         {
  243.             //特殊标志
  244.             //0x21: 扩展入口(Extension Introducer)
  245.             //0x3b: GIF文件结束标志
  246.             byte specialFlag = bytes[byteIndex];
  247.             byteIndex++;
  248.  
  249.             //扩展入口
  250.             if (0x21 == specialFlag)
  251.             {
  252.                 //扩展类型
  253.                 byte extensionFlag = bytes[byteIndex];
  254.                 byteIndex++;
  255.                 switch (extensionFlag)
  256.                 {
  257.                     case 0xf9:// Graphic Control Extension(0x21 0xf9)
  258.                         var gExt = new GIFGraphicControlExtension(bytes, ref byteIndex);
  259.                         graphicControlExtList.Add(gExt);
  260.                         gifData.m_graphicControlExtension = gExt;
  261.                         break;
  262.                     case 0xfe:// Comment Extension(0x21 0xfe)
  263.                         var cExt = new GIFCommentExtension(bytes, ref byteIndex);
  264.                         commentExtList.Add(cExt);
  265.                         break;
  266.                     case 0x01:// Plain Text Extension(0x21 0x01)
  267.                         var pExt = new GIFPlainTextExtension(bytes, ref byteIndex);
  268.                         plainTextExtList.Add(pExt);
  269.                         break;
  270.                     case 0xff:// Application Extension(0x21 0xff)
  271.                         var aExt = new GIFApplicationExtension(bytes, ref byteIndex);
  272.                         applicationExtList.Add(aExt);
  273.                         break;
  274.                     default:
  275.                         break;
  276.                 }
  277.             }
  278.             //图像描述符(Image Descriptor)
  279.             else if (0x2c == specialFlag)
  280.             {
  281.                 var imgDes = new GIFImageDescriptor(bytes, ref byteIndex, gifData);
  282.                 imageDescriptorList.Add(imgDes);
  283.             }
  284.             //GIF结束
  285.             else if (0x3b == specialFlag)
  286.             {
  287.                 GIFDebug.Log("<i><b>*** gif decode completed (0x3b) ***</b></i>");
  288.                 break;
  289.             }
  290.         }
  291.     }
  292. }
  293.  
  294. /// <summary>
  295. /// GIF文件头
  296. /// </summary>
  297. public sealed class GIFHeader
  298. {
  299.     //"GIF"
  300.     public string signature;
  301.     //"87a" 或 "89a"
  302.     public string version;
  303.  
  304.     public GIFHeader(byte[] bytes, ref int byteIndex)
  305.     {
  306.         signature = BitConverter.ToString(bytes, byteIndex, 3);
  307.         byteIndex += 3;
  308.         version = BitConverter.ToString(bytes, byteIndex, 3);
  309.         byteIndex += 3;
  310.     }
  311. }
  312.  
  313. /// <summary>
  314. /// 逻辑屏幕描述符
  315. /// </summary>
  316. public sealed class GIFLogicalScreenDescriptor
  317. {
  318.     //画布宽度
  319.     public int canvasWidth;
  320.     //画布高度
  321.     public int canvasHeight;
  322.     public GIFPackedField packedField;
  323.     //表示 GIF 的背景色在 Global Color Table 中的索引
  324.     public byte backgroundColorIndex;
  325.     //表示用于计算原始图像中像素宽高比的近似因子，一般情况为 0
  326.     public byte pixelAspectRatio;
  327.  
  328.     public GIFLogicalScreenDescriptor(byte[] bytes, ref int byteIndex)
  329.     {
  330.         canvasWidth = BitConverter.ToInt16(bytes, byteIndex);
  331.         byteIndex += 2;
  332.         canvasHeight = BitConverter.ToInt16(bytes, byteIndex);
  333.         byteIndex += 2;
  334.         packedField = new GIFPackedField(bytes[byteIndex]);
  335.         byteIndex++;
  336.         backgroundColorIndex = bytes[byteIndex];
  337.         byteIndex++;
  338.         pixelAspectRatio = bytes[byteIndex];
  339.         byteIndex++;
  340.  
  341.         Print();
  342.         packedField.Print();
  343.     }
  344.  
  345.     public void Print()
  346.     {
  347.         GIFDebug.Log("<color=green>[GIFLogicalScreenDescriptor]</color>");
  348.         GIFDebug.LogFormat("->width={0}", canvasWidth);
  349.         GIFDebug.LogFormat("->height={0}", canvasHeight);
  350.         GIFDebug.LogFormat("->backgroundColorIndex={0}", backgroundColorIndex);
  351.         GIFDebug.LogFormat("->pixelAspectRatio={0}", pixelAspectRatio);
  352.     }
  353.  
  354.     /// <summary>
  355.     /// GIF包装域
  356.     /// </summary>
  357.     public sealed class GIFPackedField
  358.     {
  359.         //全局彩色表大小
  360.         public int sizeOfGlobalColorTable;
  361.         //彩色表排序标志
  362.         public byte sortFlag;
  363.         //彩色分辨率
  364.         public byte colorResolution;
  365.         //全局彩色表标志, 1:表示存在全局颜色表
  366.         public byte globalColorTableFlag;
  367.  
  368.         public GIFPackedField(byte b)
  369.         {
  370.             byte size = (byte)(b & 7); //7: 00000111
  371.                                        //表项数目
  372.             sizeOfGlobalColorTable = (int)Math.Pow(2, size + 1);
  373.             //每个表项由3个字节组成(R、G、B)
  374.             //彩色表的字节数等于 3 * table_size
  375.  
  376.             sortFlag = (byte)((b >> 3) & 1);//00001000
  377.             colorResolution = (byte)((b >> 4) & 7);//01110000
  378.             globalColorTableFlag = (byte)(b >> 7);//10000000
  379.         }
  380.  
  381.         public void Print()
  382.         {
  383.             GIFDebug.LogFormat("->sizeOfGlobalColorTable={0}", sizeOfGlobalColorTable);
  384.             GIFDebug.LogFormat("->sortFlag={0}", sortFlag);
  385.             GIFDebug.LogFormat("->colorResolution={0}", colorResolution);
  386.             GIFDebug.LogFormat("->globalColorTableFlag={0}", globalColorTableFlag);
  387.         }
  388.     }
  389. }
  390.  
  391. /// <summary>
  392. /// GIF全局颜色表
  393. /// </summary>
  394. public sealed class GIFGlobalColorTable
  395. {
  396.     public List<byte[]> Table { get; private set; }
  397.  
  398.     public GIFGlobalColorTable(byte[] bytes, ref int byteIndex, int sizeOfGlobalColorTable)
  399.     {
  400.         Table = new List<byte[]>();
  401.         // Global Color Table(0～255×3 Bytes)
  402.         for (int i = byteIndex; i < byteIndex + (sizeOfGlobalColorTable * 3); i += 3)
  403.         {
  404.             Table.Add(new byte[] { bytes[i], bytes[i + 1], bytes[i + 2] });
  405.         }
  406.         byteIndex += sizeOfGlobalColorTable * 3;
  407.     }
  408. }
  409.  
  410. /// <summary>
  411. /// GIF图形控制扩展
  412. /// </summary>
  413. public sealed class GIFGraphicControlExtension
  414. {
  415.     //表示接下来的有效数据字节数
  416.     public byte byteSize;
  417.     //是一个包装字段，内部不同位的意义也不同
  418.     public GIFPackedField packedField;
  419.     //表示 GIF 动图每一帧之间的间隔，单位为百分之一秒。当为 0 时间隔由解码器管理
  420.     public short delayTime;
  421.     //当 Transparent Flag 为 1 时，此字节有效，表示此索引在 Global Color Table 中对应的颜色将被当做透明色做处理。
  422.     public byte transparentColorIndex;
  423.     //表示 Extension 到此结束
  424.     public byte blockTerminator;//总是0
  425.  
  426.     public GIFGraphicControlExtension(byte[] bytes, ref int byteIndex)
  427.     {
  428.         GIFDebug.LogFormat("<color=green>GIFGraphicControlExtension</color> byteIndex={0}", byteIndex);
  429.         byteSize = bytes[byteIndex];
  430.         byteIndex++;
  431.         packedField = new GIFPackedField(bytes[byteIndex]);
  432.         byteIndex++;
  433.         delayTime = BitConverter.ToInt16(bytes, byteIndex);
  434.         byteIndex += 2;
  435.         transparentColorIndex = bytes[byteIndex];
  436.         byteIndex++;
  437.         blockTerminator = bytes[byteIndex];
  438.         byteIndex++;
  439.         //Debug.LogFormat("-- end byteIndex={0}", byteIndex);
  440.     }
  441.  
  442.     //包装字段
  443.     public sealed class GIFPackedField
  444.     {
  445.         //当该值为 1 时，后面的 Transparent Color Index 指定的颜色将被当做透明色处理。为 0 则不做处理。
  446.         public byte transparentColorFlag; //1bit
  447.         //表示是否需要在得到用户的输入时才进行下一帧的输入（具体用户输入指什么视应用而定）。
  448.         //0: 表示无需用户输入
  449.         //1: 表示需要用户输入
  450.         public byte userInputFlag; //1bit
  451.         //表示在进行逐帧渲染时，前一帧留下的图像作何处理:
  452.         //0: 不做任何处理
  453.         //1: 保留前一帧图像，在此基础上进行渲染
  454.         //2: 渲染前将图像置为背景色
  455.         //3: 将被下一帧覆盖的图像重置
  456.         public byte disposalMethod;//3bit
  457.         //保留位，暂无用处
  458.         public byte reservedForFutureUse;//3bit
  459.  
  460.         public GIFPackedField(byte b)
  461.         {
  462.             transparentColorFlag = (byte)(b & 1);//00000001
  463.             userInputFlag = (byte)((b >> 1) & 1);//00000010
  464.             disposalMethod = (byte)((b >> 2) & 7);//00011100
  465.             reservedForFutureUse = (byte)((b >> 5) & 7);//11100000
  466.         }
  467.     }
  468. }
  469.  
  470. /// <summary>
  471. /// GIF文本扩展 (存储额外信息)
  472. /// </summary>
  473. public sealed class GIFPlainTextExtension
  474. {
  475.     public GIFPlainTextExtension(byte[] bytes, ref int byteIndex)
  476.     {
  477.         GIFDebug.LogFormat("<color=green>GIFPlainTextExtension</color> byteIndex={0}", byteIndex);
  478.         //暂时不关心这部分数据，直接找结束标记0
  479.         while (bytes[byteIndex++] != 0) ;
  480.     }
  481. }
  482.  
  483. /// <summary>
  484. /// GIF应用扩展 (存储额外信息)
  485. /// </summary>
  486. public sealed class GIFApplicationExtension
  487. {
  488.     public GIFApplicationExtension(byte[] bytes, ref int byteIndex)
  489.     {
  490.         GIFDebug.LogFormat("<color=green>GIFApplicationExtension</color> byteIndex={0}", byteIndex);
  491.         //暂时不关心这部分数据，直接找结束标记0
  492.         while (bytes[byteIndex++] != 0) ;
  493.     }
  494. }
  495.  
  496. /// <summary>
  497. /// GIF注释扩展 (存储额外信息)
  498. /// </summary>
  499. public sealed class GIFCommentExtension
  500. {
  501.     public GIFCommentExtension(byte[] bytes, ref int byteIndex)
  502.     {
  503.         GIFDebug.LogFormat("<color=green>GIFCommentExtension</color> byteIndex={0}", byteIndex);
  504.         //暂时不关心这部分数据，直接找结束标记0
  505.         while (bytes[byteIndex++] != 0) ;
  506.     }
  507. }
  508.  
  509. /// <summary>
  510. /// GIF图像描述符
  511. /// </summary>
  512. public sealed class GIFImageDescriptor
  513. {
  514.     //该值表示当前帧图像渲染位置离画布左边的距离
  515.     public short left;
  516.     //该值表示当前帧图像渲染位置离画布上边的距离
  517.     public short top;
  518.     //该值表示当前帧图像的宽度
  519.     public short width;
  520.     //该值表示当前帧图像的高度
  521.     public short height;
  522.     //这是一个包装字段，内部不同位的意义也不同
  523.     public GIFPackedField packedField;
  524.     public GIFLocalColorTable localColorTable;
  525.     public GIFImageData imageData;
  526.     private GIFData gifData;
  527.  
  528.     public GIFImageDescriptor(byte[] bytes, ref int byteIndex, GIFData gifData)
  529.     {
  530.         GIFDebug.LogFormat("<color=green>GIFImageDescriptor</color> byteIndex={0}", byteIndex);
  531.         this.gifData = gifData;
  532.         left = BitConverter.ToInt16(bytes, byteIndex);
  533.         byteIndex += 2;
  534.         top = BitConverter.ToInt16(bytes, byteIndex);
  535.         byteIndex += 2;
  536.         width = BitConverter.ToInt16(bytes, byteIndex);
  537.         byteIndex += 2;
  538.         height = BitConverter.ToInt16(bytes, byteIndex);
  539.         byteIndex += 2;
  540.         packedField = new GIFPackedField(bytes[byteIndex]);
  541.         byteIndex++;
  542.  
  543.         if (packedField.localColorTableFlag == 1)
  544.         {
  545.             localColorTable = new GIFLocalColorTable(bytes, ref byteIndex, packedField.sizeOfLocalColorTable);
  546.         }
  547.  
  548.         bool interlaceFlag = (packedField.interlaceFlag == 1);
  549.         imageData = new GIFImageData(bytes, ref byteIndex, width, height, interlaceFlag);
  550.  
  551.         //利用解压出来的图像数据生成Texture2D
  552.         Texture2D tex = CreateTexture2D();
  553.         gifData.textures.Add(tex);
  554.     }
  555.  
  556.     private List<byte[]> GetColorTable()
  557.     {
  558.         //存在局部颜色表，则使用局部颜色表，否则使用全局颜色表
  559.         List<byte[]> colorTable = (packedField.localColorTableFlag == 1) ? localColorTable.Table : gifData.m_globalColorTable.Table;
  560.         return colorTable;
  561.     }
  562.  
  563.     public Texture2D CreateTexture2D()
  564.     {
  565.         List<byte[]> colorTable = GetColorTable();
  566.  
  567.         int canvasWidth = gifData.m_logicalScreenDescriptor.canvasWidth;
  568.         int canvasHeight = gifData.m_logicalScreenDescriptor.canvasHeight;
  569.         Texture2D tex = new Texture2D(canvasWidth, canvasHeight, TextureFormat.ARGB32, false);
  570.         tex.filterMode = FilterMode.Bilinear;
  571.         tex.wrapMode = TextureWrapMode.Clamp;
  572.  
  573.         //判断背景色
  574.         byte transparentIndex = gifData.m_graphicControlExtension.transparentColorIndex;
  575.         int bgColorIndex = gifData.m_logicalScreenDescriptor.backgroundColorIndex;
  576.         byte[] bgRgb = colorTable[bgColorIndex];
  577.         Color32 bgColor = new Color32(bgRgb[0], bgRgb[1], bgRgb[2], (byte)(transparentIndex == bgColorIndex ? 0 : 255));
  578.         Color32[] pix;
  579.         bool filledTexture = false;
  580.  
  581.         //初始化图像像素
  582.         byte disposalMethod = gifData.m_graphicControlExtension.packedField.disposalMethod;
  583.         GIFDebug.LogFormat("disposalMethod={0}", disposalMethod);
  584.         switch (disposalMethod)
  585.         {
  586.             case 0://不做任何处理
  587.  
  588.                 break;
  589.             case 1://保留前一帧图像，在此基础上进行渲染
  590.                 if (gifData.textures.Count > 0)
  591.                 {
  592.                     Texture2D preTex = gifData.textures[gifData.textures.Count - 1];
  593.                     pix = preTex.GetPixels32();
  594.                     tex.SetPixels32(pix);
  595.                     tex.Apply();
  596.                     filledTexture = true;
  597.                 }
  598.                 break;
  599.             case 2://渲染前将图像置为背景色
  600.                 pix = new Color32[tex.width * tex.height];
  601.                 for (int i = 0; i < pix.Length; i++)
  602.                 {
  603.                     pix[i] = bgColor;
  604.                 }
  605.                 tex.SetPixels32(pix);
  606.                 tex.Apply();
  607.                 filledTexture = true;
  608.                 break;
  609.             case 3://将被下一帧覆盖的图像重置
  610.  
  611.                 break;
  612.         }
  613.  
  614.         int dataIndex = 0;
  615.         //dataIndex是从图像的左上角开始存储的,图像的原点在左下角
  616.         for (int y = canvasHeight - 1; y >= 0; y--)
  617.         {
  618.             int row = canvasHeight - y - 1;
  619.  
  620.             for (int x = 0; x < canvasWidth; x++)
  621.             {
  622.                 //(left,top)左上角坐标
  623.                 if (x < left || x >= left + width ||
  624.                     row < top || row >= top + height)
  625.                 {
  626.                     if (!filledTexture)
  627.                         tex.SetPixel(x, y, bgColor);
  628.                     continue;
  629.                 }
  630.  
  631.                 //越界检测
  632.                 if (dataIndex >= imageData.decodedData.Count)
  633.                 {
  634.                     if (filledTexture == false)
  635.                     {
  636.                         tex.SetPixel(x, y, bgColor);
  637.                         if (dataIndex == imageData.decodedData.Count)
  638.                         {
  639.                             GIFDebug.LogError("dataIndex exceeded the size of decodedData. dataIndex:" + dataIndex + " decodedData.Length:" + imageData.decodedData.Count + " y:" + y + " x:" + x);
  640.                         }
  641.                     }
  642.                     dataIndex++;
  643.                     continue;
  644.                 }
  645.  
  646.                 //像素索引对应颜色表中的索引
  647.                 int colorIndex = imageData.decodedData[dataIndex];
  648.                 //越界检测
  649.                 if (colorTable == null || colorTable.Count <= colorIndex)
  650.                 {
  651.                     if (filledTexture == false)
  652.                     {
  653.                         tex.SetPixel(x, y, bgColor);
  654.                         if (colorTable == null)
  655.                         {
  656.                             GIFDebug.LogError("colorIndex exceeded the size of colorTable. colorTable is null. colorIndex:" + colorIndex);
  657.                         }
  658.                         else
  659.                         {
  660.                             GIFDebug.LogError("colorIndex exceeded the size of colorTable. colorTable.Count:" + colorTable.Count + " colorIndex:" + colorIndex);
  661.                         }
  662.                     }
  663.                     dataIndex++;
  664.                     continue;
  665.                 }
  666.  
  667.                 byte[] rgb = colorTable[colorIndex];
  668.                 //Alpha的判断规则
  669.                 byte alpha = transparentIndex >= 0 && transparentIndex == colorIndex ? (byte)0 : (byte)255;
  670.                 if (filledTexture == false || alpha != 0)
  671.                 {
  672.                     Color32 color = new Color32(rgb[0], rgb[1], rgb[2], alpha);
  673.                     tex.SetPixel(x, y, color);
  674.                 }
  675.  
  676.                 dataIndex++;
  677.             }
  678.         }
  679.         tex.Apply();
  680.         return tex;
  681.     }
  682.  
  683.     public sealed class GIFPackedField
  684.     {
  685.         //本地颜色表大小
  686.         public int sizeOfLocalColorTable;
  687.         //保留位
  688.         public byte reservedForFutureUse;
  689.         //如果需要 Local Color Table 的话，这个字段表示其排列顺序，同 Global Color Table
  690.         public byte sortFlag;
  691.         //表示是否需要隔行扫描。1 为需要，0 为不需要
  692.         public byte interlaceFlag;
  693.         //表示下一帧图像是否需要一个独立的颜色表。1 为需要，0 为不需要
  694.         public byte localColorTableFlag;
  695.  
  696.         public GIFPackedField(byte b)
  697.         {
  698.             byte size = (byte)(b & 7); //7: 00000111
  699.             //表项数目
  700.             sizeOfLocalColorTable = (int)Math.Pow(2, size + 1);
  701.             //每个表项由3个字节组成(R、G、B)
  702.             //彩色表的字节数等于 3 * table_size
  703.             reservedForFutureUse = (byte)((b >> 3) & 3);
  704.             sortFlag = (byte)((b >> 5) & 1);
  705.             interlaceFlag = (byte)((b >> 6) & 1);
  706.             localColorTableFlag = (byte)((b >> 7) & 1);
  707.         }
  708.     }
  709. }
  710.  
  711. /// <summary>
  712. /// GIF本地颜色表
  713. /// </summary>
  714. public sealed class GIFLocalColorTable
  715. {
  716.     public List<byte[]> Table { get; private set; }
  717.  
  718.     public GIFLocalColorTable(byte[] bytes, ref int byteIndex, int sizeOfLocalColorTable)
  719.     {
  720.         Table = new List<byte[]>();
  721.         // Global Color Table(0～255×3 Bytes)
  722.         for (int i = byteIndex; i < byteIndex + (sizeOfLocalColorTable * 3); i += 3)
  723.         {
  724.             Table.Add(new byte[] { bytes[i], bytes[i + 1], bytes[i + 2] });
  725.         }
  726.         byteIndex += (sizeOfLocalColorTable * 3);
  727.     }
  728. }
  729.  
  730. /// <summary>
  731. /// GIF图像数据
  732. /// </summary>
  733. public sealed class GIFImageData
  734. {
  735.     //LZW最小编码表大小
  736.     public byte lzwMinimumCodeSize;
  737.     //压缩数据(LZW Data)
  738.     public List<byte> lzwData;
  739.     //解压数据
  740.     public List<byte> decodedData;
  741.     //0x00 表示Image Data结束
  742.     public byte blockTerminator = 0;
  743.     private int width;
  744.     private int height;
  745.     private int needDataSize;//该帧有多少个像素
  746.     private bool interlaceFlag;
  747.  
  748.     public GIFImageData(byte[] bytes, ref int byteIndex, int width, int height, bool interlaceFlag)
  749.     {
  750.         this.width = width;
  751.         this.height = height;
  752.         this.needDataSize = width * height;
  753.         this.interlaceFlag = interlaceFlag;
  754.         lzwMinimumCodeSize = bytes[byteIndex];
  755.         GIFDebug.LogFormat("->>[GIFImageData] lzwMinimumCodeSize={0}", lzwMinimumCodeSize);
  756.         byteIndex++;
  757.         lzwData = new List<byte>();
  758.         //因为图像数据长度是用byte表示，所以可能有多个子块数据
  759.         while (ReadDataSubBlock(bytes, ref byteIndex) > 0) ;
  760.         //对图像数据解码
  761.         DecodeLZWData();
  762.     }
  763.  
  764.     private int ReadDataSubBlock(byte[] bytes, ref int byteIndex)
  765.     {
  766.         //size取值范围[0x1～0xFF]，0表示整个Image Data结束, 
  767.         byte size = bytes[byteIndex];
  768.         byteIndex++;
  769.         try
  770.         {
  771.             int length = byteIndex + size;
  772.             while (byteIndex < length)
  773.                 lzwData.Add(bytes[byteIndex++]);
  774.         }
  775.         catch (IndexOutOfRangeException e)
  776.         {
  777.             UnityEngine.Debug.LogErrorFormat("{0}\nbyteIndex={1}", e.Message, byteIndex);
  778.         }
  779.         return size;
  780.     }
  781.  
  782.     /// <summary>
  783.     /// 参考 https://www.pianshen.com/article/3347116142/
  784.     /// 对LZW数据解码 (参考 UniGif)
  785.     /// 1、gif中最大编码长度为12位，能表示的最大数字为4096，因此，编译表中序号不能超过4096
  786.     /// 2、gif最大支持256色
  787.     /// 3、gif定义了clear code，清除标记为原始数据长度+1
  788.     /// 4、gif定义了end code，结束标记的值为清除标记+1
  789.     /// </summary>
  790.     private void DecodeLZWData()
  791.     {
  792.         decodedData = new List<byte>();
  793.  
  794.         int lzwCodeSize = 0;//数据块大小，这是个变长值
  795.         int clearCode = 0;
  796.         int finishCode = 0;
  797.  
  798.         //初始化编码表
  799.         var dic = new Dictionary<int, string>();
  800.         InitDictionary(dic, lzwMinimumCodeSize, out lzwCodeSize, out clearCode, out finishCode);
  801.         
  802.         //转成bit数组
  803.         var bitData = new BitArray(lzwData.ToArray());
  804.         //用来保存解码后的字节数组
  805.         byte[] output = new byte[needDataSize];
  806.         int outputAddIndex = 0;
  807.  
  808.         bool dicInitFlag = false;
  809.         string prevEntry = null;
  810.         int bitDataIndex = 0;
  811.  
  812.         while (bitDataIndex < bitData.Length)
  813.         {
  814.             if (dicInitFlag)
  815.             {
  816.                 InitDictionary(dic, lzwMinimumCodeSize, out lzwCodeSize, out clearCode, out finishCode);
  817.                 dicInitFlag = false;
  818.             }
  819.  
  820.             string entry = null;//LZW算法中的后缀
  821.  
  822.             int key = bitData.GetInt(bitDataIndex, lzwCodeSize);
  823.  
  824.             //发现清除标记，说明当前数据块读取完毕
  825.             if (key == clearCode)
  826.             {
  827.                 // Clear (Initialize dictionary)
  828.                 dicInitFlag = true;
  829.                 bitDataIndex += lzwCodeSize;
  830.                 prevEntry = null;
  831.                 continue;
  832.             }
  833.             //发现结束标记，说明所有数据块已读取完毕
  834.             else if (key == finishCode)
  835.             {
  836.                 // Exit
  837.                 GIFDebug.LogWarning("early stop code. bitDataIndex:" + bitDataIndex + " lzwCodeSize:" + lzwCodeSize + " key:" + key + " dic.Count:" + dic.Count);
  838.                 break;
  839.             }
  840.             else if (dic.ContainsKey(key))
  841.             {
  842.                 // Output from dictionary
  843.                 entry = dic[key];
  844.             }
  845.             else if (key >= dic.Count)
  846.             {
  847.                 if (prevEntry != null)
  848.                 {
  849.                     // Output from estimation
  850.                     entry = prevEntry + prevEntry[0];
  851.                 }
  852.                 else
  853.                 {
  854.                     //读到一个不合理的数据，这里直接跳过此数据
  855.                     GIFDebug.LogWarning("It is strange that come here. bitDataIndex:" + bitDataIndex + " lzwCodeSize:" + lzwCodeSize + " key:" + key + " dic.Count:" + dic.Count);
  856.                     bitDataIndex += lzwCodeSize;
  857.                     continue;
  858.                 }
  859.             }
  860.             else
  861.             {
  862.                 //读到一个不合理的数据，这里直接跳过此数据
  863.                 GIFDebug.LogWarning("It is strange that come here. bitDataIndex:" + bitDataIndex + " lzwCodeSize:" + lzwCodeSize + " key:" + key + " dic.Count:" + dic.Count);
  864.                 bitDataIndex += lzwCodeSize;
  865.                 continue;
  866.             }
  867.  
  868.             // Output
  869.             // Take out 8 bits from the string.
  870.             // 将后缀字符(或字符串)转成字节数组并输出
  871.             byte[] temp = Encoding.Unicode.GetBytes(entry);
  872.             for (int i = 0; i < temp.Length; i++)
  873.             {
  874.                 //Unicode.GetBytes() API会将每个字符用两个字节表示,
  875.                 //跳过没用的高位字节
  876.                 if (i % 2 == 0)
  877.                 {
  878.                     output[outputAddIndex] = temp[i];
  879.                     outputAddIndex++;
  880.                 }
  881.             }
  882.  
  883.             if (outputAddIndex >= needDataSize)
  884.             {
  885.                 // Exit
  886.                 break;
  887.             }
  888.  
  889.             if (prevEntry != null)
  890.             {
  891.                 // Add to dictionary
  892.                 dic.Add(dic.Count, prevEntry + entry[0]);
  893.             }
  894.  
  895.             prevEntry = entry;
  896.             bitDataIndex += lzwCodeSize;
  897.  
  898.             //GIF中LZW算法采用变长参数记录后面数据块中每个数字(字符)用几个bit表示
  899.             //第1个数据块中的不同字符(或字符串)用3bit表示，总共能表示8种,当字典存满8项后，清空字典，后面的数据存入第2个数据块。
  900.             //第2个数据块中的不同字符(或字符串)用4bit表示，总共能表示16种,当字典存满16项后，清空字典，后面的数据存入第3个数据块。
  901.             //依此递推......
  902.  
  903.             if (lzwCodeSize == 3 && dic.Count >= 8)
  904.             {
  905.                 lzwCodeSize = 4;
  906.             }
  907.             else if (lzwCodeSize == 4 && dic.Count >= 16)
  908.             {
  909.                 lzwCodeSize = 5;
  910.             }
  911.             else if (lzwCodeSize == 5 && dic.Count >= 32)
  912.             {
  913.                 lzwCodeSize = 6;
  914.             }
  915.             else if (lzwCodeSize == 6 && dic.Count >= 64)
  916.             {
  917.                 lzwCodeSize = 7;
  918.             }
  919.             else if (lzwCodeSize == 7 && dic.Count >= 128)
  920.             {
  921.                 lzwCodeSize = 8;
  922.             }
  923.             else if (lzwCodeSize == 8 && dic.Count >= 256)
  924.             {
  925.                 lzwCodeSize = 9;
  926.             }
  927.             else if (lzwCodeSize == 9 && dic.Count >= 512)
  928.             {
  929.                 lzwCodeSize = 10;
  930.             }
  931.             else if (lzwCodeSize == 10 && dic.Count >= 1024)
  932.             {
  933.                 lzwCodeSize = 11;
  934.             }
  935.             else if (lzwCodeSize == 11 && dic.Count >= 2048)
  936.             {
  937.                 lzwCodeSize = 12;
  938.             }
  939.             //GIF的LZW规定最大使用12bit来表示1个字符(或字符串)
  940.             //字典存满后，则继续读下一个数据块, lzwCodeSize的值不再变化
  941.             else if (lzwCodeSize == 12 && dic.Count >= 4096)
  942.             {
  943.                 int nextKey = bitData.GetNumeral(bitDataIndex, lzwCodeSize);
  944.                 //字典已满，即便下一个字符不是清除标记，也要重置字典
  945.                 if (nextKey != clearCode)
  946.                 {
  947.                     dicInitFlag = true;
  948.                 }
  949.             }
  950.         }
  951.  
  952.         //是否需要交错排序
  953.         if (interlaceFlag)
  954.             output = SortInterlaceGifData(output, width);
  955.  
  956.         decodedData.AddRange(output);
  957.     }
  958.  
  959.     /// <summary>
  960.     /// 初始化字典 (代码引用 UniGif)
  961.     /// </summary>
  962.     /// <param name="dic">Dictionary</param>
  963.     /// <param name="lzwMinimumCodeSize">LZW minimum code size</param>
  964.     /// <param name="lzwCodeSize">out LZW code size</param>
  965.     /// <param name="clearCode">out Clear code</param>
  966.     /// <param name="finishCode">out Finish code</param>
  967.     private static void InitDictionary(Dictionary<int, string> dic, int lzwMinimumCodeSize, out int lzwCodeSize, out int clearCode, out int finishCode)
  968.     {
  969.         int dicLength = (int)Math.Pow(2, lzwMinimumCodeSize);
  970.  
  971.         clearCode = dicLength;
  972.         finishCode = clearCode + 1;
  973.  
  974.         dic.Clear();
  975.  
  976.         for (int i = 0; i < dicLength + 2; i++)
  977.         {
  978.             dic.Add(i, ((char)i).ToString());
  979.         }
  980.  
  981.         lzwCodeSize = lzwMinimumCodeSize + 1;
  982.     }
  983.  
  984.     /// <summary>
  985.     /// 代码引用 UniGif
  986.     /// 交错排序(Sort interlace GIF data)
  987.     /// </summary>
  988.     /// <param name="decodedData">Decoded GIF data</param>
  989.     /// <param name="xNum">Pixel number of horizontal row</param>
  990.     /// <returns>Sorted data</returns>
  991.     private byte[] SortInterlaceGifData(byte[] decodedData, int xNum)
  992.     {
  993.         int rowNo = 0;
  994.         int dataIndex = 0;
  995.         var newArr = new byte[decodedData.Length];
  996.         // Every 8th. row, starting with row 0.
  997.         for (int i = 0; i < newArr.Length; i++)
  998.         {
  999.             if (rowNo % 8 == 0)
  1000.             {
  1001.                 newArr[i] = decodedData[dataIndex];
  1002.                 dataIndex++;
  1003.             }
  1004.             if (i != 0 && i % xNum == 0)
  1005.             {
  1006.                 rowNo++;
  1007.             }
  1008.         }
  1009.         rowNo = 0;
  1010.         // Every 8th. row, starting with row 4.
  1011.         for (int i = 0; i < newArr.Length; i++)
  1012.         {
  1013.             if (rowNo % 8 == 4)
  1014.             {
  1015.                 newArr[i] = decodedData[dataIndex];
  1016.                 dataIndex++;
  1017.             }
  1018.             if (i != 0 && i % xNum == 0)
  1019.             {
  1020.                 rowNo++;
  1021.             }
  1022.         }
  1023.         rowNo = 0;
  1024.         // Every 4th. row, starting with row 2.
  1025.         for (int i = 0; i < newArr.Length; i++)
  1026.         {
  1027.             if (rowNo % 4 == 2)
  1028.             {
  1029.                 newArr[i] = decodedData[dataIndex];
  1030.                 dataIndex++;
  1031.             }
  1032.             if (i != 0 && i % xNum == 0)
  1033.             {
  1034.                 rowNo++;
  1035.             }
  1036.         }
  1037.         rowNo = 0;
  1038.         // Every 2nd. row, starting with row 1.
  1039.         for (int i = 0; i < newArr.Length; i++)
  1040.         {
  1041.             if (rowNo % 8 != 0 && rowNo % 8 != 4 && rowNo % 4 != 2)
  1042.             {
  1043.                 newArr[i] = decodedData[dataIndex];
  1044.                 dataIndex++;
  1045.             }
  1046.             if (i != 0 && i % xNum == 0)
  1047.             {
  1048.                 rowNo++;
  1049.             }
  1050.         }
  1051.  
  1052.         return newArr;
  1053.     }
  1054. }
  1055.  
  1056. //代码引用 UniGif
  1057. public static class BitArrayExtension
  1058. {
  1059.     public static int GetInt(this BitArray array, int startIndex, int bitLength)
  1060.     {
  1061.         var newArray = new BitArray(bitLength);
  1062.  
  1063.         for (int i = 0; i < bitLength; i++)
  1064.         {
  1065.             if (array.Length <= startIndex + i)
  1066.             {
  1067.                 newArray[i] = false;
  1068.             }
  1069.             else
  1070.             {
  1071.                 bool bit = array.Get(startIndex + i);
  1072.                 newArray[i] = bit;
  1073.             }
  1074.         }
  1075.  
  1076.         return newArray.ToInt();
  1077.     }
  1078.  
  1079.     public static int ToInt(this BitArray array)
  1080.     {
  1081.         if (array == null)
  1082.         {
  1083.             GIFDebug.LogError("array is nothing.");
  1084.             return 0;
  1085.         }
  1086.         if (array.Length > 32)
  1087.         {
  1088.             GIFDebug.LogError("must be at most 32 bits long.");
  1089.             return 0;
  1090.         }
  1091.  
  1092.         var result = new int[1];
  1093.         array.CopyTo(result, 0);
  1094.         return result[0];
  1095.     }
  1096. }
  1097.  
  1098. //保存解析完成后的GIF数据
  1099. public sealed class GIFData
  1100. {
  1101.     public GIFLogicalScreenDescriptor m_logicalScreenDescriptor;
  1102.     public GIFGraphicControlExtension m_graphicControlExtension;
  1103.     public GIFGlobalColorTable m_globalColorTable;
  1104.     public List<Texture2D> textures = new List<Texture2D>();
  1105. }
  1106.  
  1107. public sealed class GIFDebug
  1108. {
  1109.     [Conditional("UNITY_EDITOR")]
  1110.     public static void Log(string msg)
  1111.     {
  1112. #if DEBUG_GIF_DECODE
  1113.         UnityEngine.Debug.Log(msg);
  1114. #endif
  1115.     }
  1116.  
  1117.     [Conditional("UNITY_EDITOR")]
  1118.     public static void LogFormat(string format, params object[] args)
  1119.     {
  1120. #if DEBUG_GIF_DECODE
  1121.         UnityEngine.Debug.LogFormat(format, args);
  1122. #endif
  1123.     }
  1124.  
  1125.     public static void LogError(string msg)
  1126.     {
  1127.         UnityEngine.Debug.LogError(msg);
  1128.     }
  1129.  
  1130.     public static void LogErrorFormat(string format, params object[] args)
  1131.     {
  1132.         UnityEngine.Debug.LogErrorFormat(format, args);
  1133.     }
  1134.  
  1135.     public static void LogWarning(string msg)
  1136.     {
  1137.         UnityEngine.Debug.LogWarning(msg);
  1138.     }
  1139. }


使用 


  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class Test : MonoBehaviour
  6. {
  7.     public List<Texture2D> textures;
  8.  
  9.     void Start()
  10.     {
  11.         string path = string.Format("file:///{0}/test.gif", Application.streamingAssetsPath);
  12.         Debug.Log(path);
  13.         StartCoroutine(LoadGif(path));
  14.     }
  15.  
  16.     IEnumerator LoadGif(string url)
  17.     {
  18.         using (WWW www = new WWW(url))
  19.         {
  20.             yield return www;
  21.  
  22.             if (string.IsNullOrEmpty(www.error) == false)
  23.             {
  24.                 Debug.LogError("File load error.\n" + www.error);
  25.                 yield break;
  26.             }
  27.  
  28.             byte[] bytes = www.bytes;
  29.             GIFImage gif = new GIFImage(bytes);
  30.             textures = gif.textures;
  31.         }
  32.     }
  33. }


运行测试

111111.png

标签: Unity3d

« 地形(Terrain) | 常量和字段»
Powered by emlog  蜀ICP备18021003号-1   sitemap

川公网安备 51019002001593号