1     object MeshMemory =
2         def create (positions : Slice<Vector3>
3                     normals : Slice<Vector3>
4                     uv0 : Slice<Vector2>
5                     colors : Slice<Vector3>
6                     indices : Array<u32>) =
7             let count = positions.size
8             let vertices = Array count
9             for i = 0 until count do
10                vertices[i] = Vertex
11                    position = positions[i]
12                    normal = normals[i]
13                    color = colors[i]
14                    uv0 = uv0[i]
15    
16            MeshMemory MeshFormat/Regular vertices.as_bytes indices
17    
18        def skinned (positions : Slice<Vector3>
19                     normals : Slice<Vector3>
20                     uv0 : Slice<Vector2>
21                     colors : Slice<Vector3>
22                     joints : Slice<ByteVector4>
23                     weights : Slice<Vector4>
24                     indices : Array<u32>) =
25            let count = positions.size
26            let vertices = Array count
27            for i = 0 until count do
28                vertices[i] = SkinnedVertex
29                    position = positions[i]
30                    normal = normals[i]
31                    color = colors[i]
32                    uv0 = uv0[i]
33                    joints = joints[i]
34                    weights = weights[i]
35    
36            MeshMemory MeshFormat/Skinned vertices.as_bytes indices
37    
38        let from_quads_triangles (quads : Slice<Quad>) (triangles : Slice<Triangle>) =
39            let count = quads.size * 4 + triangles.size * 3
40            let positions = Array count
41            let normals = Array count
42            let uv0 = Array count
43            let colors = Array count
44            let indices_count = quads.size * Quad.indices.size
45                                + triangles.size * Triangle.indices.size
46    
47            let indices = Array indices_count
48            let mut offset = 0
49            let mut indices_offset = 0
50            for quad in quads do
51                positions[offset] = quad.up_left
52                positions[offset + 1] = quad.up_right
53                positions[offset + 2] = quad.down_left
54                positions[offset + 3] = quad.down_right
55    
56                for i = 0 to 3 do
57                    let normal = quad.normal
58                    normals[offset + i] = normal
59    
60                uv0[offset] = quad.uv_up_left
61                uv0[offset + 1] = quad.uv_up_right
62                uv0[offset + 2] = quad.uv_down_left
63                uv0[offset + 3] = quad.uv_down_right
64    
65                for i = 0 to 3 do
66                    colors[offset + i] = quad.color
67    
68                for i = 0 until Quad.indices.size do
69                    indices[indices_offset + i] = Quad.indices[i] + offset
70    
71                offset += 4
72                indices_offset += 6
73    
74            for triangle in triangles do
75                positions[offset] = triangle.up_left
76                positions[offset + 1] = triangle.down_left
77                positions[offset + 2] = triangle.down_right
78    
79                for i = 0 to 2 do
80                    let normal = triangle.get_normal
81                    normals[offset + i] = normal
82    
83                uv0[offset] = triangle.uv_up_left
84                uv0[offset + 1] = triangle.uv_down_left
85                uv0[offset + 2] = triangle.uv_down_right
86    
87                for i = 0 to 2 do
88                    colors[offset + i] = triangle.color
89    
90                for i = 0 to Triangle.indices.size do
91                    indices[offset + i] = Triangle.indices[i] + offset
92    
93                offset += 3
94    
95            let memory = MeshMemory.create positions.as_slice
96                                           normals.as_slice
97                                           uv0.as_slice
98                                           colors.as_slice
99                                           indices
100           positions.discard
101           normals.discard
102           uv0.discard
103           colors.discard
104   
105           memory
106   
107       def from_quads (quads : Slice<Quad>) =
108           from_quads_triangles quads Slice<Triangle>.empty
109   
110       def from_quad (quad : Quad) =
111           let positions = [quad.up_left, quad.up_right, quad.down_left, quad.down_right]
112           let normals = [quad.normal; 4]
113           let uv0 = [quad.uv_up_left
114                      quad.uv_up_right
115                      quad.uv_down_left
116                      quad.uv_down_right]
117   
118           let colors = [quad.color; 4]
119   
120           MeshMemory.create positions normals uv0 colors Quad.indices.to_array
121   
122       def from_triangle (triangle : Triangle) =
123           let positions = [triangle.up_left, triangle.down_left, triangle.down_right]
124           let normals = [triangle.get_normal; 3]
125           let uv0 = [triangle.uv_up_left
126                      triangle.uv_down_left
127                      triangle.uv_down_right]
128   
129           let colors = [triangle.color; 3]
130   
131           MeshMemory.create positions normals uv0 colors Triangle.indices.to_array
132