devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Unity中使用NewtonJson序列化继承类时报错解决方法参考_jsonserializationexception: self referencing loop

作者：我家小花儿 | 2024-07-21 18:08:52

赞

踩

jsonserializationexception: self referencing loop detected for property 'nor

        在Unity中使用NewtonJson时，如果要序列化的类继承了别的类，可能报如下错误：

JsonSerializationException: Self referencing loop detected for property......

        解决的方法是新建一个JsonSerializerSettings对象，并设置对象的ReferenceLoopHandling参数为：ReferenceLoopHandling.Ignore，然后在序列化时将这个对象作为参数添加进去。参考如下：

  1. var settings = new JsonSerializerSettings();
  2. settings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
  3. string json = JsonConvert.SerializeObject(infos, settings);

        如果我们要序列化一个基类的数组，由于子类可能会出现参数相同，但是类型不同的问题，最好在JsonSerializerSettings对象里面设置TypeNameHandling的值为TypeNameHandling.Auto，这样NewtonJson序列化时会在必要的情况下添加对象的类型信息。参考如下：

  1. var settings = new JsonSerializerSettings();
  2. settings.TypeNameHandling = TypeNameHandling.Auto;
  3. settings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
  4. string json = JsonConvert.SerializeObject(infos, settings);

        序列化的结果参考如下：

  1. [
  2.     {
  3.         "$type": "BoxColliderInfo, Assembly-CSharp",
  4.         "size": {
  5.             "x": 1.0,
  6.             "y": 1.0,
  7.             "z": 1.0,
  8.             "normalized": {
  9.                 "x": 0.577350259,
  10.                 "y": 0.577350259,
  11.                 "z": 0.577350259,
  12.                 "magnitude": 1.0,
  13.                 "sqrMagnitude": 0.99999994
  14.             },
  15.             "magnitude": 1.73205078,
  16.             "sqrMagnitude": 3.0
  17.         },
  18.         "center": {
  19.             "x": 0.0,
  20.             "y": 1.0,
  21.             "z": 0.0,
  22.             "magnitude": 1.0,
  23.             "sqrMagnitude": 1.0
  24.         },
  25.         "cip": "0"
  26.     },
  27.     {
  28.         "$type": "SphereColliderInfo, Assembly-CSharp",
  29.         "radius": 2.5,
  30.         "center": {
  31.             "x": 1.0,
  32.             "y": 0.0,
  33.             "z": 0.0,
  34.             "magnitude": 1.0,
  35.             "sqrMagnitude": 1.0
  36.         },
  37.         "cip": "1"
  38.     }
  39. ]

        需要注意的是，这里面添加了"$type"字段，这是为了在反序列化是能得到正确类型的对象。

        最后需要说的是，在序列化和反序列化时应该使用相同的JsonSerializerSettings对象设置。于是我写了一个类来简化使用NewtonJson的代码，参考如下：

  1. using Newtonsoft.Json;
  2.  
  3. public class JsonTool
  4. {
  5. 	static JsonSerializerSettings settings = new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.Auto, ReferenceLoopHandling = ReferenceLoopHandling.Ignore};
  6.  
  7. 	public static string ToJson(object obj) { return  JsonConvert.SerializeObject(obj, settings);}
  8. 	public static T FromJson<T>(string json) { return JsonConvert.DeserializeObject<T>(json, settings); }
  9. }

        现在，我们使用JsonTool.ToJson和JsonTool.FromJson就可以了。

        如果你之前使用的是Unity内置的JsonUtility，现在直接用JsonTool搜索并替换JsonUtility就可以了。

//----------------------------------------------------------------------------------------------------------------------------

        好吧，其实还是有问题。

        本来以为万事大吉了，结果发现NewtonJson有个很神奇的错误，如果我给一个Color变量赋值，如果里面的rgba值为0或者为1就没有问题，如果是0到1之间的浮点数，Unity就直接退出，出这个问题的时候一直以为是别的方面的错误，最后一行代码一行代码的测试，才发现居然是NewtonJson的问题，最后想了个别的办法，所有用于序列化的类里面的Color都改成自定义的Vector4D，这样就不会出错，只不过要重载一大堆运算符，尤其是Vector4D，既要重载Vector4D和Vector4之间的操作，又要重载Vector4D和Color之间的操作，本来还想重载Vector4D和Quaternion之间的操作，感觉不大可能序列化Quaternion方面的东西，算了。

        当时序列化的时候还发现一个问题，就是序列化Vector3的时候会把Vector3对象的magnitude和sqrMagnitude的值也序列化了，这个是没有必要的，所以干脆在用于序列化的类里面把Vector3用Vector3D替代，把Vector2用Vector2D替代，这样序列化出来的内容就简洁而且不报错了。就是上面代码中的那行

settings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;

可以不用写了。
 

所定义的Vector2D、Vector3D、Vector4D参考如下：

  1. using System;
  2. using UnityEngine;
  3.  
  4. [Serializable]
  5. public class TranP
  6. {
  7. 	public Vector3D position = Vector3.zero;
  8. 	public TranP(Vector3 position)
  9. 	{
  10. 		this.position = position;
  11. 	}
  12. 	public TranP() { position = Vector3.zero; }
  13. }
  14.  
  15. [Serializable]
  16. public class TranPR : TranP
  17. {
  18. 	public Vector3D euler = Vector3.zero;
  19. 	public TranPR(Vector3 position, Vector3 euler) : base(position)
  20. 	{
  21. 		this.euler = euler;
  22. 	}
  23.  
  24. 	public TranPR() : base() { euler = Vector3.zero; }
  25.  
  26. 	public Quaternion GetRotation() { return Quaternion.Euler(euler); }
  27. }
  28.  
  29. [Serializable]
  30. public class TranPRS : TranPR
  31. {
  32. 	public Vector3D scale = Vector3.one;
  33. 	public TranPRS(Vector3 position, Vector3 euler, Vector3 scale) : base(position, euler)
  34. 	{
  35. 		this.scale = scale;
  36. 	}
  37. 	public TranPRS() : base() { scale = Vector3.one; }
  38. }
  39.  
  40. [Serializable]
  41. public class TranNP : TranP
  42. {
  43. 	public string name;
  44. 	public TranNP(string name, Vector3 position) : base(position)
  45. 	{
  46. 		this.name = name;
  47. 	}
  48. }
  49.  
  50. [Serializable]
  51. public class TranNPR : TranPR
  52. {
  53. 	public string name;
  54. 	public TranNPR(string name, Vector3 position, Vector3 euler) : base(position, euler)
  55. 	{
  56. 		this.name = name;
  57. 	}
  58. }
  59.  
  60. [Serializable]
  61. public class TranNPRS : TranPRS
  62. {
  63. 	public string name;
  64. 	public TranNPRS(string name, Vector3 position, Vector3 euler, Vector3 scale) : base(position, euler, scale)
  65. 	{
  66. 		this.name = name;
  67. 	}
  68. }
  69.  
  70. [Serializable]
  71. public class CamRot
  72. {
  73. 	public float rotH;
  74. 	public float rotV;
  75. 	public CamRot(float rotH, float rotV) { this.rotH = rotH; this.rotV = rotV; }
  76. }
  77.  
  78. [Serializable]
  79. public class TranCam
  80. {
  81. 	public Vector3D position;
  82. 	public CamRot camRot;
  83. 	public TranCam(Vector3 position, CamRot camRot)
  84. 	{
  85. 		this.position = position;
  86. 		this.camRot = camRot;
  87. 	}
  88. }
  89.  
  90. [Serializable]
  91. public class Vector2D
  92. {
  93. 	public float x;
  94. 	public float y;
  95.  
  96. 	public Vector2D()
  97. 	{
  98. 		x = 0;
  99. 		y = 0;
  100. 	}
  101.  
  102. 	public Vector2D(float x, float y)
  103. 	{
  104. 		this.x = x;
  105. 		this.y = y;
  106. 	}
  107.  
  108. 	public float GetSqrtMagnitude()
  109. 	{
  110. 		return x * x + y * y;
  111. 	}
  112.  
  113. 	public float GetMagnitude()
  114. 	{
  115. 		return Mathf.Sqrt(GetSqrtMagnitude());
  116. 	}
  117.  
  118. 	public static implicit operator Vector2D(Vector2 v)
  119. 	{
  120. 		return new Vector2D(v.x, v.y);
  121. 	}
  122.  
  123. 	public static implicit operator Vector2(Vector2D v)
  124. 	{
  125. 		return new Vector2(v.x, v.y);
  126. 	}
  127.  
  128. 	public static Vector2D operator +(Vector2D v1, Vector2D v2)
  129. 	{
  130. 		return new Vector2D(v1.x + v2.x, v1.y + v2.y);
  131. 	}
  132.  
  133. 	public static Vector2D operator -(Vector2D v1, Vector2D v2)
  134. 	{
  135. 		return new Vector2D(v1.x - v2.x, v1.y - v2.y);
  136. 	}
  137.  
  138. 	public static Vector2D operator *(Vector2D v, float f)
  139. 	{
  140. 		return new Vector2D(v.x * f, v.y * f);
  141. 	}
  142.  
  143. 	public static Vector2D operator /(Vector2D v, float f)
  144. 	{
  145. 		return new Vector2D(v.x / f, v.y / f);
  146. 	}
  147.  
  148. 	public static Vector2D operator +(Vector2D v1, Vector2 v2)
  149. 	{
  150. 		return new Vector2D(v1.x + v2.x, v1.y + v2.y);
  151. 	}
  152.  
  153. 	public static Vector2D operator -(Vector2D v1, Vector2 v2)
  154. 	{
  155. 		return new Vector2D(v1.x - v2.x, v1.y - v2.y);
  156. 	}
  157.  
  158. 	public static Vector2D operator +(Vector2 v1, Vector2D v2)
  159. 	{
  160. 		return new Vector2D(v1.x + v2.x, v1.y + v2.y);
  161. 	}
  162.  
  163. 	public static Vector2D operator -(Vector2 v1, Vector2D v2)
  164. 	{
  165. 		return new Vector2D(v1.x - v2.x, v1.y - v2.y);
  166. 	}
  167. }
  168.  
  169. [Serializable]
  170. public class Vector3D
  171. {
  172. 	public float x;
  173. 	public float y;
  174. 	public float z;
  175.  
  176. 	public Vector3D()
  177. 	{
  178. 		x = 0;
  179. 		y = 0;
  180. 		z = 0;
  181. 	}
  182.  
  183. 	public Vector3D(float x, float y, float z)
  184. 	{
  185. 		this.x = x;
  186. 		this.y = y;
  187. 		this.z = z;
  188. 	}
  189.  
  190. 	public float GetSqrtMagnitude()
  191. 	{
  192. 		return x * x + y * y + z * z;
  193. 	}
  194.  
  195. 	public float GetMagnitude()
  196. 	{
  197. 		return Mathf.Sqrt(GetSqrtMagnitude());
  198. 	}
  199.  
  200. 	public static implicit operator Vector3D(Vector3 v)
  201. 	{
  202. 		return new Vector3D(v.x, v.y, v.z);
  203. 	}
  204.  
  205. 	public static implicit operator Vector3(Vector3D v)
  206. 	{
  207. 		return new Vector3(v.x, v.y, v.z);
  208. 	}
  209.  
  210. 	public static Vector3D operator +(Vector3D v1, Vector3D v2)
  211. 	{
  212. 		return new Vector3D(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
  213. 	}
  214.  
  215. 	public static Vector3D operator -(Vector3D v1, Vector3D v2)
  216. 	{
  217. 		return new Vector3D(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
  218. 	}
  219.  
  220. 	public static Vector3D operator *(Vector3D v, float f)
  221. 	{
  222. 		return new Vector3D(v.x * f, v.y * f, v.z * f);
  223. 	}
  224.  
  225. 	public static Vector3D operator /(Vector3D v, float f)
  226. 	{
  227. 		return new Vector3D(v.x / f, v.y / f, v.z / f);
  228. 	}
  229.  
  230. 	public static Vector3D operator +(Vector3D v1, Vector3 v2)
  231. 	{
  232. 		return new Vector3D(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
  233. 	}
  234.  
  235. 	public static Vector3D operator -(Vector3D v1, Vector3 v2)
  236. 	{
  237. 		return new Vector3D(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
  238. 	}
  239.  
  240. 	public static Vector3D operator +(Vector3 v1, Vector3D v2)
  241. 	{
  242. 		return new Vector3D(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
  243. 	}
  244.  
  245. 	public static Vector3D operator -(Vector3 v1, Vector3D v2)
  246. 	{
  247. 		return new Vector3D(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
  248. 	}
  249. }
  250.  
  251. [Serializable]
  252. public class Vector4D
  253. {
  254. 	public float r;
  255. 	public float g;
  256. 	public float b;
  257. 	public float a;
  258.  
  259. 	public Vector4D() { r = 1; g = 1; b = 1; a = 1; }
  260.  
  261. 	public Vector4D(float r, float g, float b, float a)
  262. 	{
  263. 		this.r = r;
  264. 		this.g = g;
  265. 		this.b = b;
  266. 		this.a = a;
  267. 	}
  268.  
  269. 	public static implicit operator Vector4D(Color c)
  270. 	{
  271. 		return new Vector4D(c.r, c.g, c.b, c.a);
  272. 	}
  273.  
  274. 	public static implicit operator Color(Vector4D c)
  275. 	{
  276. 		return new Color(c.r, c.g, c.b, c.a);
  277. 	}
  278.  
  279. 	public static Vector4D operator +(Vector4D v1, Vector4D v2)
  280. 	{
  281. 		return new Vector4D(v1.r + v2.r, v1.g + v2.g, v1.b + v2.b, v1.a + v2.a);
  282. 	}
  283.  
  284. 	public static Vector4D operator -(Vector4D v1, Vector4D v2)
  285. 	{
  286. 		return new Vector4D(v1.r - v2.r, v1.g - v2.g, v1.b - v2.b, v1.a - v2.a);
  287. 	}
  288.  
  289. 	public static Vector4D operator *(Vector4D v, float f)
  290. 	{
  291. 		return new Vector4D(v.r * f, v.g * f, v.b * f, v.a * f);
  292. 	}
  293.  
  294. 	public static Vector4D operator /(Vector4D v, float f)
  295. 	{
  296. 		return new Vector4D(v.r / f, v.g / f, v.b / f, v.a / f);
  297. 	}
  298.  
  299. 	public static Vector4D operator +(Vector4D v1, Vector4 v2)
  300. 	{
  301. 		return new Vector4D(v1.r + v2.x, v1.g + v2.y, v1.b + v2.z, v1.a + v2.w);
  302. 	}
  303.  
  304. 	public static Vector4D operator -(Vector4D v1, Vector4 v2)
  305. 	{
  306. 		return new Vector4D(v1.r - v2.x, v1.g - v2.y, v1.b - v2.z, v1.a - v2.w);
  307. 	}
  308.  
  309. 	public static Vector4D operator +(Vector4 v1, Vector4D v2)
  310. 	{
  311. 		return new Vector4D(v1.x + v2.r, v1.y + v2.g, v1.z + v2.b, v1.w + v2.a);
  312. 	}
  313.  
  314. 	public static Vector4D operator -(Vector4 v1, Vector4D v2)
  315. 	{
  316. 		return new Vector4D(v1.x - v2.r, v1.y - v2.g, v1.z - v2.b, v1.w - v2.a);
  317. 	}
  318. }

        希望这次没有问题了吧。

//----------------------------------------------------------------------------------------------------------------------------

        不是的，还有一些小问题，代码里面有些地方用的是Vector3的magnitude，但是Vector3D里面没有，关键是我不能加这个属性啊，一加这个属性，序列化又多出magnitude和sqrtMagnitude这个内容了，所以如果需要的化，就添加一个GetMagnitude()方法和GetSqrtMagnitude()方法替代，或者用Vector3.Distance方法解决吧，有些地方需要Quaternion对象作为返回属性的就写个GetQuaternion()方法替代吧。

        希望没问题了，呵呵。

//----------------------------------------------------------------------------------------------------------------------------

        好吧，我又幼稚了，原来的Vector3是struct，但是现在定义的Vector3D之类的都是class，由于class允许设置位null，但是struct不行，所以如果当Vector3D的对象为null的时候，如果赋值给一个Vector3对象，会出现莫名奇妙的运行错误，并且不提示！比如说for循环或者foreach循环执行到这个赋值的位置直接跳出去！疯了！！疯了！！！

        后来查看了一下相关代码，应该是这样的，当class的对象为null赋值给一个struct时，就会导致执行错误，比如说莫名其妙的跳出循环，因为struct不可能是null啊，关键是不报错，后面的还能正常执行，也是醉了。

        所以最终的代码应该是把class都换成struct，就像下面这样的：

  1. [Serializable]
  2. public struct Vector2D
  3. {
  4. 	public float x;
  5. 	public float y;
  6.  
  7. 	public Vector2D(float x, float y)
  8. 	{
  9. 		this.x = x;
  10. 		this.y = y;
  11. 	}
  12.  
  13. 	public readonly float GetSqrtMagnitude()
  14. 	{
  15. 		return x * x + y * y;
  16. 	}
  17.  
  18. 	public readonly float GetMagnitude()
  19. 	{
  20. 		return Mathf.Sqrt(GetSqrtMagnitude());
  21. 	}
  22.  
  23. 	public static implicit operator Vector2D(Vector2 v)
  24. 	{
  25. 		return new Vector2D(v.x, v.y);
  26. 	}
  27.  
  28. 	public static implicit operator Vector2(Vector2D v)
  29. 	{
  30. 		return new Vector2(v.x, v.y);
  31. 	}
  32.  
  33. 	public static Vector2D operator +(Vector2D v1, Vector2D v2)
  34. 	{
  35. 		return new Vector2D(v1.x + v2.x, v1.y + v2.y);
  36. 	}
  37.  
  38. 	public static Vector2D operator -(Vector2D v1, Vector2D v2)
  39. 	{
  40. 		return new Vector2D(v1.x - v2.x, v1.y - v2.y);
  41. 	}
  42.  
  43. 	public static Vector2D operator *(Vector2D v, float f)
  44. 	{
  45. 		return new Vector2D(v.x * f, v.y * f);
  46. 	}
  47.  
  48. 	public static Vector2D operator /(Vector2D v, float f)
  49. 	{
  50. 		return new Vector2D(v.x / f, v.y / f);
  51. 	}
  52.  
  53. 	public static Vector2D operator +(Vector2D v1, Vector2 v2)
  54. 	{
  55. 		return new Vector2D(v1.x + v2.x, v1.y + v2.y);
  56. 	}
  57.  
  58. 	public static Vector2D operator -(Vector2D v1, Vector2 v2)
  59. 	{
  60. 		return new Vector2D(v1.x - v2.x, v1.y - v2.y);
  61. 	}
  62.  
  63. 	public static Vector2D operator +(Vector2 v1, Vector2D v2)
  64. 	{
  65. 		return new Vector2D(v1.x + v2.x, v1.y + v2.y);
  66. 	}
  67.  
  68. 	public static Vector2D operator -(Vector2 v1, Vector2D v2)
  69. 	{
  70. 		return new Vector2D(v1.x - v2.x, v1.y - v2.y);
  71. 	}
  72. }
  73.  
  74. [Serializable]
  75. public struct Vector3D
  76. {
  77. 	public float x;
  78. 	public float y;
  79. 	public float z;
  80.  
  81. 	public Vector3D(float x, float y, float z)
  82. 	{
  83. 		this.x = x;
  84. 		this.y = y;
  85. 		this.z = z;
  86. 	}
  87.  
  88. 	public readonly float GetSqrtMagnitude()
  89. 	{
  90. 		return x * x + y * y + z * z;
  91. 	}
  92.  
  93. 	public readonly float GetMagnitude()
  94. 	{
  95. 		return Mathf.Sqrt(GetSqrtMagnitude());
  96. 	}
  97.  
  98. 	public static implicit operator Vector3D(Vector3 v)
  99. 	{
  100. 		return new Vector3D(v.x, v.y, v.z);
  101. 	}
  102.  
  103. 	public static implicit operator Vector3(Vector3D v)
  104. 	{
  105. 		return new Vector3(v.x, v.y, v.z);
  106. 	}
  107.  
  108. 	public static Vector3D operator +(Vector3D v1, Vector3D v2)
  109. 	{
  110. 		return new Vector3D(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
  111. 	}
  112.  
  113. 	public static Vector3D operator -(Vector3D v1, Vector3D v2)
  114. 	{
  115. 		return new Vector3D(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
  116. 	}
  117.  
  118. 	public static Vector3D operator *(Vector3D v, float f)
  119. 	{
  120. 		return new Vector3D(v.x * f, v.y * f, v.z * f);
  121. 	}
  122.  
  123. 	public static Vector3D operator /(Vector3D v, float f)
  124. 	{
  125. 		return new Vector3D(v.x / f, v.y / f, v.z / f);
  126. 	}
  127.  
  128. 	public static Vector3D operator +(Vector3D v1, Vector3 v2)
  129. 	{
  130. 		return new Vector3D(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
  131. 	}
  132.  
  133. 	public static Vector3D operator -(Vector3D v1, Vector3 v2)
  134. 	{
  135. 		return new Vector3D(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
  136. 	}
  137.  
  138. 	public static Vector3D operator +(Vector3 v1, Vector3D v2)
  139. 	{
  140. 		return new Vector3D(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
  141. 	}
  142.  
  143. 	public static Vector3D operator -(Vector3 v1, Vector3D v2)
  144. 	{
  145. 		return new Vector3D(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
  146. 	}
  147. }
  148.  
  149. [Serializable]
  150. public struct Vector4D
  151. {
  152. 	public float r;
  153. 	public float g;
  154. 	public float b;
  155. 	public float a;
  156.  
  157. 	public Vector4D(float r, float g, float b, float a)
  158. 	{
  159. 		this.r = r;
  160. 		this.g = g;
  161. 		this.b = b;
  162. 		this.a = a;
  163. 	}
  164.  
  165. 	public static implicit operator Vector4D(Color c)
  166. 	{
  167. 		return new Vector4D(c.r, c.g, c.b, c.a);
  168. 	}
  169.  
  170. 	public static implicit operator Color(Vector4D c)
  171. 	{
  172. 		return new Color(c.r, c.g, c.b, c.a);
  173. 	}
  174.  
  175. 	public static Vector4D operator +(Vector4D v1, Vector4D v2)
  176. 	{
  177. 		return new Vector4D(v1.r + v2.r, v1.g + v2.g, v1.b + v2.b, v1.a + v2.a);
  178. 	}
  179.  
  180. 	public static Vector4D operator -(Vector4D v1, Vector4D v2)
  181. 	{
  182. 		return new Vector4D(v1.r - v2.r, v1.g - v2.g, v1.b - v2.b, v1.a - v2.a);
  183. 	}
  184.  
  185. 	public static Vector4D operator *(Vector4D v, float f)
  186. 	{
  187. 		return new Vector4D(v.r * f, v.g * f, v.b * f, v.a * f);
  188. 	}
  189.  
  190. 	public static Vector4D operator /(Vector4D v, float f)
  191. 	{
  192. 		return new Vector4D(v.r / f, v.g / f, v.b / f, v.a / f);
  193. 	}
  194.  
  195. 	public static Vector4D operator +(Vector4D v1, Vector4 v2)
  196. 	{
  197. 		return new Vector4D(v1.r + v2.x, v1.g + v2.y, v1.b + v2.z, v1.a + v2.w);
  198. 	}
  199.  
  200. 	public static Vector4D operator -(Vector4D v1, Vector4 v2)
  201. 	{
  202. 		return new Vector4D(v1.r - v2.x, v1.g - v2.y, v1.b - v2.z, v1.a - v2.w);
  203. 	}
  204.  
  205. 	public static Vector4D operator +(Vector4 v1, Vector4D v2)
  206. 	{
  207. 		return new Vector4D(v1.x + v2.r, v1.y + v2.g, v1.z + v2.b, v1.w + v2.a);
  208. 	}
  209.  
  210. 	public static Vector4D operator -(Vector4 v1, Vector4D v2)
  211. 	{
  212. 		return new Vector4D(v1.x - v2.r, v1.y - v2.g, v1.z - v2.b, v1.w - v2.a);
  213. 	}
  214. }

        哈哈，这绝对是最后一次修改！！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/861806
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号