A game about forced loneliness, made by TACStudios
tacstudios.tngl.sh
1using System;
2using System.Collections.Generic;
3using Unity.Collections;
4using Unity.Collections.LowLevel.Unsafe;
5using Unity.Burst;
6using Unity.Mathematics;
7using UnityEngine;
8using ModuleHandle = UnityEngine.U2D.Common.UTess.ModuleHandle;
9using Unity.Jobs;
10
11namespace UnityEditor.U2D.Animation
12{
13
14 [BurstCompile]
15 internal struct TriangulateJob : IJob
16 {
17 // Input Dataset
18 [DeallocateOnJobCompletion]
19 internal NativeArray<float2> inputVertices;
20 [DeallocateOnJobCompletion]
21 internal NativeArray<int2> inputEdges;
22
23 // Output Dataset.
24 internal NativeArray<int> outputIndices;
25 internal NativeArray<int2> outputEdges;
26 internal NativeArray<float2> outputVertices;
27 internal NativeArray<int4> result;
28
29 public void Execute()
30 {
31 int outputVertexCount = 0, outputIndexCount = 0, outputEdgeCount = 0;
32 ModuleHandle.Tessellate(Allocator.Temp, inputVertices, inputEdges, ref outputVertices, out outputVertexCount, ref outputIndices, out outputIndexCount, ref outputEdges, out outputEdgeCount, true);
33 result[0] = new int4(outputVertexCount, outputIndexCount, outputEdgeCount, 0);
34 }
35 }
36
37 [BurstCompile]
38 internal struct TessellateJob : IJob
39 {
40 // Input Parameters.
41 internal int refineIterations;
42 internal int smoothIterations;
43 internal float minAngle;
44 internal float maxAngle;
45 internal float meshArea;
46 internal float targetArea;
47 internal float largestTriangleAreaFactor;
48
49 // Input Dataset
50 [DeallocateOnJobCompletion]
51 internal NativeArray<float2> inputVertices;
52 [DeallocateOnJobCompletion]
53 internal NativeArray<int2> inputEdges;
54
55 // Output Dataset.
56 internal NativeArray<int> outputIndices;
57 internal NativeArray<int2> outputEdges;
58 internal NativeArray<float2> outputVertices;
59 internal NativeArray<int4> result;
60
61 public void Execute()
62 {
63 int outputVertexCount = 0, outputIndexCount = 0, outputEdgeCount = 0;
64 ModuleHandle.Subdivide(Allocator.Temp, inputVertices, inputEdges, ref outputVertices, ref outputVertexCount, ref outputIndices, ref outputIndexCount, ref outputEdges, ref outputEdgeCount, largestTriangleAreaFactor, targetArea, refineIterations, smoothIterations);
65 result[0] = new int4(outputVertexCount, outputIndexCount, outputEdgeCount, 0);
66 }
67 }
68
69 [BurstCompile]
70 internal class TriangulationUtility
71 {
72
73 // Adjust Tolerance for Collinear Check.
74 static readonly float k_CollinearTolerance = 0.0001f;
75
76 [BurstCompile]
77 static unsafe int ValidateCollinear(float2* points, int pointCount, float epsilon)
78 {
79 if (pointCount < 3)
80 return 0;
81
82 for (int i = 0; i < pointCount - 2; ++i)
83 {
84 double2 a = points[i];
85 double2 b = points[i + 1];
86 double2 c = points[i + 2];
87
88 // Just check area of triangle and see if its non-zero.
89 var x = math.abs(a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y));
90 if (x > epsilon)
91 return 1;
92 }
93
94 return 0;
95 }
96
97 [BurstCompile]
98 static unsafe void TessellateBurst(Allocator allocator, float2* points, int pointCount, int2* edges, int edgeCount, float2* outVertices, int* outIndices, int2* outEdges, int arrayCount, int3* result)
99 {
100
101 var _edges = new NativeArray<int2>(edgeCount, allocator);
102 for (int i = 0; i < _edges.Length; ++i)
103 _edges[i] = edges[i];
104
105 var _points = new NativeArray<float2>(pointCount, allocator);
106 for (int i = 0; i < _points.Length; ++i)
107 _points[i] = points[i];
108
109 var _outIndices = new NativeArray<int>(arrayCount, allocator);
110 var _outEdges = new NativeArray<int2>(arrayCount, allocator);
111 var _outVertices = new NativeArray<float2>(arrayCount, allocator);
112
113 var outEdgeCount = 0;
114 var outIndexCount = 0;
115 var outVertexCount = 0;
116
117 var check = ValidateCollinear((float2*)_points.GetUnsafeReadOnlyPtr(), pointCount, k_CollinearTolerance);
118 if (0 != check)
119 ModuleHandle.Tessellate(allocator, in _points, in _edges, ref _outVertices, out outVertexCount, ref _outIndices, out outIndexCount, ref _outEdges, out outEdgeCount, true);
120
121 for (var i = 0; i < outEdgeCount; ++i)
122 outEdges[i] = _outEdges[i];
123 for (var i = 0; i < outIndexCount; ++i)
124 outIndices[i] = _outIndices[i];
125 for (var i = 0; i < outVertexCount; ++i)
126 outVertices[i] = _outVertices[i];
127
128 result->x = outVertexCount;
129 result->y = outIndexCount;
130 result->z = outEdgeCount;
131
132 _outVertices.Dispose();
133 _outEdges.Dispose();
134 _outIndices.Dispose();
135 _points.Dispose();
136 _edges.Dispose();
137
138 }
139
140 [BurstCompile]
141 static unsafe void SubdivideBurst(Allocator allocator, float2* points, int pointCount, int2* edges, int edgeCount, float2* outVertices, int* outIndices, int2* outEdges, int arrayCount, float areaFactor, float areaThreshold, int refineIterations, int smoothenIterations, int3* result)
142 {
143 var _edges = new NativeArray<int2>(edgeCount, allocator);
144 for (int i = 0; i < _edges.Length; ++i)
145 _edges[i] = edges[i];
146
147 var _points = new NativeArray<float2>(pointCount, allocator);
148 for (int i = 0; i < _points.Length; ++i)
149 _points[i] = points[i];
150
151 var _outIndices = new NativeArray<int>(arrayCount, allocator);
152 var _outEdges = new NativeArray<int2>(arrayCount, allocator);
153 var _outVertices = new NativeArray<float2>(arrayCount, allocator);
154 var outEdgeCount = 0;
155 var outIndexCount = 0;
156 var outVertexCount = 0;
157
158 ModuleHandle.Subdivide(allocator, _points, _edges, ref _outVertices, ref outVertexCount, ref _outIndices, ref outIndexCount, ref _outEdges, ref outEdgeCount, areaFactor, areaThreshold, refineIterations, smoothenIterations);
159
160 for (var i = 0; i < outEdgeCount; ++i)
161 outEdges[i] = _outEdges[i];
162 for (var i = 0; i < outIndexCount; ++i)
163 outIndices[i] = _outIndices[i];
164 for (var i = 0; i < outVertexCount; ++i)
165 outVertices[i] = _outVertices[i];
166
167 result->x = outVertexCount;
168 result->y = outIndexCount;
169 result->z = outEdgeCount;
170
171 _outVertices.Dispose();
172 _outEdges.Dispose();
173 _outIndices.Dispose();
174 _points.Dispose();
175 _edges.Dispose();
176 }
177
178 static bool TessellateSafe(in NativeArray<float2> points, in NativeArray<int2> edges, ref NativeArray<float2> outVertices, ref int outVertexCount, ref NativeArray<int> outIndices, ref int outIndexCount, ref NativeArray<int2> outEdges, ref int outEdgeCount)
179 {
180 unsafe
181 {
182 var check = ValidateCollinear((float2*)points.GetUnsafeReadOnlyPtr(), points.Length, k_CollinearTolerance);
183 if (0 == check)
184 return false;
185 }
186
187 try
188 {
189 ModuleHandle.Tessellate(Allocator.Persistent, in points, in edges, ref outVertices, out outVertexCount, ref outIndices, out outIndexCount, ref outEdges, out outEdgeCount, true);
190 }
191 catch (Exception)
192 {
193 return false;
194 }
195 return true;
196 }
197 static bool SubdivideSafe(NativeArray<float2> points, NativeArray<int2> edges, ref NativeArray<float2> outVertices, ref int outVertexCount, ref NativeArray<int> outIndices, ref int outIndexCount, ref NativeArray<int2> outEdges, ref int outEdgeCount, float areaFactor, float areaThreshold, int refineIterations, int smoothenIterations)
198 {
199 try
200 {
201 ModuleHandle.Subdivide(Allocator.Persistent, points, edges, ref outVertices, ref outVertexCount, ref outIndices, ref outIndexCount, ref outEdges, ref outEdgeCount, areaFactor, areaThreshold, refineIterations, smoothenIterations);
202 }
203 catch (Exception)
204 {
205 return false;
206 }
207 return true;
208 }
209
210 internal static void Quad(IList<Vector2> vertices, IList<Vector2Int> edges, IList<int> indices, Allocator allocator)
211 {
212 if (vertices.Count < 3)
213 return;
214
215 var points = new NativeArray<float2>(vertices.Count, allocator);
216 for (var i = 0; i < vertices.Count; ++i)
217 points[i] = vertices[i];
218
219 var arrayCount = vertices.Count * vertices.Count * 4;
220 int vertexCount = 0, indexCount = 0, edgeCount = 0;
221 var outputIndices = new NativeArray<int>(arrayCount, allocator);
222 var outputEdges = new NativeArray<int2>(arrayCount, allocator);
223 var outputVertices = new NativeArray<float2>(arrayCount, allocator);
224
225 var fallback = new NativeArray<int2>(0, allocator);
226 TessellateSafe(in points, in fallback, ref outputVertices, ref vertexCount, ref outputIndices,
227 ref indexCount, ref outputEdges, ref edgeCount);
228 fallback.Dispose();
229
230 vertices.Clear();
231 for (var i = 0; i < vertexCount; ++i)
232 vertices.Add(outputVertices[i]);
233 indices.Clear();
234 for (var i = 0; i < indexCount; ++i)
235 indices.Add(outputIndices[i]);
236 edges.Clear();
237 for (var i = 0; i < edgeCount; ++i)
238 edges.Add(new Vector2Int(outputEdges[i].x, outputEdges[i].y));
239
240 outputEdges.Dispose();
241 outputIndices.Dispose();
242 outputVertices.Dispose();
243 points.Dispose();
244 }
245
246 internal static void Triangulate(ref int2[] edges, ref float2[] vertices, out int[] indices, Allocator allocator)
247 {
248 if (vertices.Length < 3)
249 {
250 indices = new int[0];
251 return;
252 }
253
254 var points = new NativeArray<float2>(vertices, allocator);
255 var inputEdges = new NativeArray<int2>(edges, allocator);
256
257 var arrayCount = vertices.Length * vertices.Length * 4;
258 int vertexCount = 0, indexCount = 0, edgeCount = 0;
259 var outputIndices = new NativeArray<int>(arrayCount, allocator);
260 var outputEdges = new NativeArray<int2>(arrayCount, allocator);
261 var outputResult = new NativeArray<int3>(1, allocator);
262 var outputVertices = new NativeArray<float2>(arrayCount, allocator);
263
264 unsafe
265 {
266 TessellateBurst(allocator, (float2*)points.GetUnsafePtr(), points.Length, (int2*)inputEdges.GetUnsafePtr(), inputEdges.Length, (float2*)outputVertices.GetUnsafePtr(), (int*)outputIndices.GetUnsafePtr(), (int2*)outputEdges.GetUnsafePtr(), arrayCount, (int3*)outputResult.GetUnsafePtr());
267 vertexCount = outputResult[0].x;
268 indexCount = outputResult[0].y;
269 edgeCount = outputResult[0].z;
270 }
271 // Fallback on numerical precision errors.
272 if (vertexCount <= 8 || indexCount == 0)
273 TessellateSafe(in points, in inputEdges, ref outputVertices, ref vertexCount, ref outputIndices, ref indexCount, ref outputEdges, ref edgeCount);
274
275 vertices = new float2[vertexCount];
276 for (var i = 0; i < vertexCount; ++i)
277 vertices[i] = outputVertices[i];
278 indices = new int[indexCount];
279 for (var i = 0; i < indexCount; ++i)
280 indices[i] = outputIndices[i];
281 edges = new int2[edgeCount];
282 for (var i = 0; i < edgeCount; ++i)
283 edges[i] = outputEdges[i];
284
285 outputEdges.Dispose();
286 outputResult.Dispose();
287 outputIndices.Dispose();
288 outputVertices.Dispose();
289 inputEdges.Dispose();
290 points.Dispose();
291 }
292
293 internal static bool TriangulateSafe(ref float2[] vertices, ref int2[] edges, out int[] indices)
294 {
295 indices = new int[0];
296
297 if (vertices.Length < 3)
298 return false;
299
300 var points = new NativeArray<float2>(vertices, Allocator.Persistent);
301 var inputEdges = new NativeArray<int2>(edges, Allocator.Persistent);
302
303 var arrayCount = vertices.Length * vertices.Length * 4;
304 int vertexCount = 0, indexCount = 0, edgeCount = 0;
305 var outputIndices = new NativeArray<int>(arrayCount, Allocator.Persistent);
306 var outputEdges = new NativeArray<int2>(arrayCount, Allocator.Persistent);
307 var outputVertices = new NativeArray<float2>(arrayCount, Allocator.Persistent);
308 var ok = TessellateSafe(in points, in inputEdges, ref outputVertices, ref vertexCount, ref outputIndices, ref indexCount, ref outputEdges, ref edgeCount);
309
310 if (ok)
311 {
312 vertices = new float2[vertexCount];
313 for (var i = 0; i < vertexCount; ++i)
314 vertices[i] = outputVertices[i];
315 edges = new int2[edgeCount];
316 for (var i = 0; i < edgeCount; ++i)
317 edges[i] = outputEdges[i];
318 indices = new int[indexCount];
319 for (var i = 0; i < indexCount; ++i)
320 indices[i] = outputIndices[i];
321 }
322
323 outputEdges.Dispose();
324 outputIndices.Dispose();
325 outputVertices.Dispose();
326 inputEdges.Dispose();
327 points.Dispose();
328 return ok;
329 }
330
331 public static void Tessellate(float minAngle, float maxAngle, float meshAreaFactor, float largestTriangleAreaFactor, float targetArea, int refineIterations, int smoothenIterations, ref float2[] vertices, ref int2[] edges, out int[] indices, Allocator allocator)
332 {
333 indices = new int[0];
334
335 if (vertices.Length < 3)
336 return;
337
338 largestTriangleAreaFactor = Mathf.Clamp01(largestTriangleAreaFactor);
339
340 var points = new NativeArray<float2>(vertices.Length, allocator);
341 for (var i = 0; i < vertices.Length; ++i)
342 points[i] = vertices[i];
343 var inputEdges = new NativeArray<int2>(edges.Length, allocator);
344 for (var i = 0; i < edges.Length; ++i)
345 inputEdges[i] = new int2(edges[i].x, edges[i].y);
346
347 const int maxDataCount = 65536;
348 int vertexCount = 0, indexCount = 0, edgeCount = 0;
349 var outputIndices = new NativeArray<int>(maxDataCount, allocator);
350 var outputEdges = new NativeArray<int2>(maxDataCount, allocator);
351 var outputResult = new NativeArray<int3>(1, allocator);
352 var outputVertices = new NativeArray<float2>(maxDataCount, allocator);
353
354 unsafe
355 {
356 SubdivideBurst(allocator, (float2*)points.GetUnsafePtr(), points.Length, (int2*)inputEdges.GetUnsafePtr(), inputEdges.Length, (float2*)outputVertices.GetUnsafePtr(), (int*)outputIndices.GetUnsafePtr(), (int2*)outputEdges.GetUnsafePtr(), maxDataCount, largestTriangleAreaFactor, targetArea, refineIterations, smoothenIterations, (int3*)outputResult.GetUnsafePtr());
357 vertexCount = outputResult[0].x;
358 indexCount = outputResult[0].y;
359 edgeCount = outputResult[0].z;
360 }
361 // Fallback on numerical precision errors.
362 if (vertexCount <= 8)
363 SubdivideSafe(points, inputEdges, ref outputVertices, ref vertexCount, ref outputIndices, ref indexCount, ref outputEdges, ref edgeCount, largestTriangleAreaFactor, targetArea, refineIterations, smoothenIterations);
364
365 vertices = new float2[vertexCount];
366 for (var i = 0; i < vertexCount; ++i)
367 vertices[i] = outputVertices[i];
368 edges = new int2[edgeCount];
369 for (var i = 0; i < edgeCount; ++i)
370 edges[i] = outputEdges[i];
371 indices = new int[indexCount];
372 for (var i = 0; i < indexCount; ++i)
373 indices[i] = outputIndices[i];
374
375 outputEdges.Dispose();
376 outputResult.Dispose();
377 outputIndices.Dispose();
378 outputVertices.Dispose();
379 inputEdges.Dispose();
380 points.Dispose();
381 }
382
383 public static JobHandle ScheduleTriangulate(in float2[] vertices, in int2[] edges, ref NativeArray<float2> outputVertices, ref NativeArray<int2> outputEdges, ref NativeArray<int> outputIndices, ref NativeArray<int4> result)
384 {
385 if (vertices.Length < 3)
386 return default(JobHandle);
387
388 var inputVertices = new NativeArray<float2>(vertices.Length, Allocator.TempJob);
389 for (var i = 0; i < vertices.Length; ++i)
390 inputVertices[i] = vertices[i];
391 var inputEdges = new NativeArray<int2>(edges.Length, Allocator.TempJob);
392 for (var i = 0; i < edges.Length; ++i)
393 inputEdges[i] = new int2(edges[i].x, edges[i].y);
394
395 var tessAsJob = new TriangulateJob();
396 tessAsJob.inputVertices = inputVertices;
397 tessAsJob.inputEdges = inputEdges;
398 tessAsJob.outputVertices = outputVertices;
399 tessAsJob.outputIndices = outputIndices;
400 tessAsJob.outputEdges = outputEdges;
401 tessAsJob.result = result;
402 return tessAsJob.Schedule();
403 }
404
405 public static JobHandle ScheduleTessellate(float minAngle, float maxAngle, float meshAreaFactor, float largestTriangleAreaFactor, float targetArea, int refineIterations, int smoothenIterations, in float2[] vertices, in int2[] edges, ref NativeArray<float2> outputVertices, ref NativeArray<int2> outputEdges, ref NativeArray<int> outputIndices, ref NativeArray<int4> result)
406 {
407 if (vertices.Length < 3)
408 return default(JobHandle);
409
410 largestTriangleAreaFactor = Mathf.Clamp01(largestTriangleAreaFactor);
411
412 var inputVertices = new NativeArray<float2>(vertices.Length, Allocator.TempJob);
413 for (var i = 0; i < vertices.Length; ++i)
414 inputVertices[i] = vertices[i];
415 var inputEdges = new NativeArray<int2>(edges.Length, Allocator.TempJob);
416 for (var i = 0; i < edges.Length; ++i)
417 inputEdges[i] = new int2(edges[i].x, edges[i].y);
418
419 var tessAsJob = new TessellateJob();
420 tessAsJob.minAngle = minAngle;
421 tessAsJob.maxAngle = maxAngle;
422 tessAsJob.meshArea = meshAreaFactor;
423 tessAsJob.largestTriangleAreaFactor = largestTriangleAreaFactor;
424 tessAsJob.targetArea = targetArea;
425 tessAsJob.refineIterations = refineIterations;
426 tessAsJob.smoothIterations = smoothenIterations;
427 tessAsJob.inputVertices = inputVertices;
428 tessAsJob.inputEdges = inputEdges;
429 tessAsJob.outputVertices = outputVertices;
430 tessAsJob.outputIndices = outputIndices;
431 tessAsJob.outputEdges = outputEdges;
432 tessAsJob.result = result;
433 return tessAsJob.Schedule();
434 }
435
436 public static void TessellateSafe(float largestTriangleAreaFactor, float targetArea, int refineIterations, int smoothenIterations, ref float2[] vertices, ref int2[] edges, out int[] indices)
437 {
438 indices = new int[0];
439
440 if (vertices.Length < 3)
441 return;
442
443 largestTriangleAreaFactor = Mathf.Clamp01(largestTriangleAreaFactor);
444
445 var points = new NativeArray<float2>(vertices, Allocator.Persistent);
446 var inputEdges = new NativeArray<int2>(edges, Allocator.Persistent);
447
448 int vertexCount = 0, indexCount = 0, edgeCount = 0, maxDataCount = 65536;
449 var outputVertices = new NativeArray<float2>(maxDataCount, Allocator.Persistent);
450 var outputIndices = new NativeArray<int>(maxDataCount, Allocator.Persistent);
451 var outputEdges = new NativeArray<int2>(maxDataCount, Allocator.Persistent);
452 var ok = SubdivideSafe(points, inputEdges, ref outputVertices, ref vertexCount, ref outputIndices, ref indexCount, ref outputEdges, ref edgeCount, largestTriangleAreaFactor, targetArea, refineIterations, smoothenIterations) ;
453
454 if (ok)
455 {
456 vertices = new float2[vertexCount];
457 for (var i = 0; i < vertices.Length; ++i)
458 vertices[i] = outputVertices[i];
459 indices = new int[indexCount];
460 for (var i = 0; i < indices.Length; ++i)
461 indices[i] = outputIndices[i];
462 edges = new int2[edgeCount];
463 for (var i = 0; i < edges.Length; ++i)
464 edges[i] = outputEdges[i];
465 }
466
467 outputEdges.Dispose();
468 outputIndices.Dispose();
469 outputVertices.Dispose();
470 inputEdges.Dispose();
471 points.Dispose();
472 }
473
474 // Triangulate Bone Samplers. todo: Burst it.
475 internal static void TriangulateSamplers(in float2[] samplers, ref List<float2> triVertices, ref List<int> triIndices)
476 {
477 foreach(var v in samplers)
478 {
479 var vertexCount = triVertices.Count;
480
481 for (var i = 0; i < triIndices.Count / 3; ++i)
482 {
483 var i1 = triIndices[0 + (i * 3)];
484 var i2 = triIndices[1 + (i * 3)];
485 var i3 = triIndices[2 + (i * 3)];
486 var v1 = triVertices[i1];
487 var v2 = triVertices[i2];
488 var v3 = triVertices[i3];
489 var inside = ModuleHandle.IsInsideTriangle(v, v1, v2, v3);
490 if (inside)
491 {
492 triVertices.Add(v);
493 triIndices.Add(i1); triIndices.Add(i2); triIndices.Add(vertexCount);
494 triIndices.Add(i2); triIndices.Add(i3); triIndices.Add(vertexCount);
495 triIndices.Add(i3); triIndices.Add(i1); triIndices.Add(vertexCount);
496 break;
497 }
498 }
499 }
500 }
501
502
503 // Triangulate Skipped Original Points. These points are discarded during PlanarGrapg cleanup. But bbw only cares if these are part of any geometry. So just insert them. todo: Burst it.
504 internal static void TriangulateInternal(in int[] internalIndices, in float2[] triVertices, ref List<int> triIndices)
505 {
506 var triangleCount = triIndices.Count / 3;
507
508 foreach(var index in internalIndices)
509 {
510 var v = triVertices[index];
511 for (var i = 0; i < triangleCount; ++i)
512 {
513 var i1 = triIndices[0 + (i * 3)];
514 var i2 = triIndices[1 + (i * 3)];
515 var i3 = triIndices[2 + (i * 3)];
516 var v1 = triVertices[i1];
517 var v2 = triVertices[i2];
518 var v3 = triVertices[i3];
519 var c1 = (float)Math.Round(ModuleHandle.OrientFast(v1, v2, v), 2);
520 if (c1 == 0)
521 {
522 triIndices[0 + (i * 3)] = i1; triIndices[1 + (i * 3)] = index; triIndices[2 + (i * 3)] = i3;
523 triIndices.Add(index); triIndices.Add(i2); triIndices.Add(i3);
524 }
525 else
526 {
527 var c2 = (float)Math.Round(ModuleHandle.OrientFast(v2, v3, v), 2);
528 if (c2 == 0)
529 {
530 triIndices[0 + (i * 3)] = i2; triIndices[1 + (i * 3)] = index; triIndices[2 + (i * 3)] = i1;
531 triIndices.Add(index); triIndices.Add(i3); triIndices.Add(i1);
532 }
533 else
534 {
535 var c3 = (float)Math.Round(ModuleHandle.OrientFast(v3, v1, v), 2);
536 if (c3 == 0)
537 {
538 triIndices[0 + (i * 3)] = i3; triIndices[1 + (i * 3)] = index; triIndices[2 + (i * 3)] = i2;
539 triIndices.Add(index); triIndices.Add(i1); triIndices.Add(i2);
540 }
541 }
542 }
543 }
544 }
545 }
546
547 }
548}