├── images
    └── screenshot.png
├── .gitignore
├── .npmignore
├── example
    └── example.js
├── LICENSE
├── package.json
├── lib
    └── mesh.js
├── README.md
└── index.js


/images/screenshot.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stackgl/gl-mesh/HEAD/images/screenshot.png


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | lib-cov
 2 | *.DS_Store
 3 | *.seed
 4 | *.log
 5 | *.csv
 6 | *.dat
 7 | *.out
 8 | *.pid
 9 | *.gz
10 | 
11 | pids
12 | logs
13 | results
14 | 
15 | npm-debug.log
16 | node_modules/*


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
 1 | lib-cov
 2 | *.DS_Store
 3 | *.seed
 4 | *.log
 5 | *.csv
 6 | *.dat
 7 | *.out
 8 | *.pid
 9 | *.gz
10 | 
11 | pids
12 | logs
13 | results
14 | 
15 | npm-debug.log
16 | node_modules/*
17 | example/*
18 | images/*


--------------------------------------------------------------------------------
/example/example.js:
--------------------------------------------------------------------------------
 1 | "use strict"
 2 | 
 3 | var shell = require("gl-now")()
 4 | var createMesh = require("../index.js")
 5 | var simple2DShader = require("simple-2d-shader")
 6 | 
 7 | var mesh, shader
 8 | 
 9 | shell.on("gl-init", function() {
10 |   shader = simple2DShader(shell.gl)
11 |   mesh = createMesh(shell.gl,
12 |       [[0, 1, 2],
13 |        [2, 1, 3]],
14 |       { "position": [[-1,-1],   [0, 1],    [0, 0],    [1, -1]],
15 |         "color":    [[1, 0, 0], [0, 1, 0], [0, 0, 1], [1, 1, 1]] })
16 | })
17 | 
18 | shell.on("gl-render", function(t) {
19 |   shader.bind()
20 |   mesh.bind(shader)
21 |   mesh.draw()
22 |   mesh.unbind()
23 | })


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | 
 2 | The MIT License (MIT)
 3 | 
 4 | Copyright (c) 2013 Mikola Lysenko
 5 | 
 6 | Permission is hereby granted, free of charge, to any person obtaining a copy
 7 | of this software and associated documentation files (the "Software"), to deal
 8 | in the Software without restriction, including without limitation the rights
 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | copies of the Software, and to permit persons to whom the Software is
11 | furnished to do so, subject to the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be included in
14 | all copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | THE SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "gl-mesh",
 3 |   "version": "0.1.0",
 4 |   "description": "Static indexed mesh drawing for WebGL",
 5 |   "main": "index.js",
 6 |   "directories": {
 7 |     "example": "example"
 8 |   },
 9 |   "dependencies": {
10 |     "gl-vao": "~0.0.1",
11 |     "ndarray-ops": "^1.2.2",
12 |     "typedarray-pool": "~0.1.1",
13 |     "webglew": "~0.0.0",
14 |     "ndarray": "~1.0.0",
15 |     "gl-buffer": "~0.1.0"
16 |   },
17 |   "devDependencies": {
18 |     "gl-now": "~0.0.0",
19 |     "simple-2d-shader": "~0.0.0"
20 |   },
21 |   "scripts": {
22 |     "test": "echo \"Error: no test specified\" && exit 1"
23 |   },
24 |   "repository": {
25 |     "type": "git",
26 |     "url": "git://github.com/mikolalysenko/gl-mesh.git"
27 |   },
28 |   "keywords": [
29 |     "webgl",
30 |     "mesh",
31 |     "static",
32 |     "indexed",
33 |     "triangle",
34 |     "point",
35 |     "line",
36 |     "wrapper",
37 |     "gl",
38 |     "drawing",
39 |     "cell",
40 |     "complex",
41 |     "simplicial",
42 |     "complex"
43 |   ],
44 |   "author": "Mikola Lysenko",
45 |   "license": "MIT",
46 |   "readmeFilename": "README.md",
47 |   "gitHead": "529cb8e9b5634304847a3e0f810db777c1235986",
48 |   "bugs": {
49 |     "url": "https://github.com/mikolalysenko/gl-mesh/issues"
50 |   }
51 | }
52 | 


--------------------------------------------------------------------------------
/lib/mesh.js:
--------------------------------------------------------------------------------
 1 | "use strict"
 2 | 
 3 | function Mesh(gl, mode, numElements, vao, elements, attributes, attributeNames) {
 4 |   this.gl = gl
 5 |   this.mode = mode
 6 |   this.numElements = numElements
 7 |   this.vao = vao
 8 |   this.elements = elements
 9 |   this.attributes = attributes
10 |   this.attributeNames = attributeNames
11 | }
12 | 
13 | Mesh.prototype.bind = function(shader) {
14 |   this.vao.bind()
15 |   var attributeNames = this.attributeNames
16 |   var nattribs = attributeNames.length
17 |   for(var i=0; i<nattribs; ++i) {
18 |     var sattrib = shader.attributes[attributeNames[i]]
19 |     if(sattrib) {
20 |       sattrib.location = i
21 |     }
22 |   }
23 | }
24 | 
25 | Mesh.prototype.unbind = function() {
26 |   this.vao.unbind()
27 | }
28 | 
29 | Mesh.prototype.dispose = function() {
30 |   this.vao.dispose()
31 |   if(this.elements) {
32 |     this.elements.dispose()
33 |   }
34 |   var attributes = this.attributes
35 |   var n = attributes.length
36 |   for(var i=0; i<n; ++i) {
37 |     var attrib = attributes[i]
38 |     if(attrib.buffer) {
39 |       attrib.buffer.dispose()
40 |     }
41 |   }  
42 | }
43 | 
44 | Mesh.prototype.draw = function() {
45 |   if (this.numElements === 0) return;
46 |   if(this.elements) {
47 |     this.elements.draw(this.mode, this.numElements)
48 |   } else {
49 |     this.gl.drawArrays(this.mode, 0, this.numElements)
50 |   }
51 | }
52 | 
53 | module.exports = Mesh


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | gl-mesh
  2 | =======
  3 | WebGL class for rendering static indexed geometry
  4 | 
  5 | # Example
  6 | 
  7 | [Try this demo in your browser](http://mikolalysenko.github.io/gl-mesh/)
  8 | 
  9 | ```javascript
 10 | var shell = require("gl-now")()
 11 | var createMesh = require("gl-mesh")
 12 | var simple2DShader = require("simple-2d-shader")
 13 | 
 14 | var mesh, shader
 15 | 
 16 | shell.on("gl-init", function() {
 17 |   shader = simple2DShader(shell.gl)
 18 |   mesh = createMesh(shell.gl,
 19 |       [[0, 1, 2],
 20 |        [2, 1, 3]],
 21 |       { "position": [[-1,-1],   [0, 1],    [0, 0],    [1, -1]],
 22 |         "color":    [[1, 0, 0], [0, 1, 0], [0, 0, 1], [1, 1, 1]] })
 23 | })
 24 | 
 25 | shell.on("gl-render", function(t) {
 26 |   shader.bind()
 27 |   mesh.bind(shader)
 28 |   mesh.draw()
 29 |   mesh.unbind()
 30 | })
 31 | ```
 32 | 
 33 | And here is what it should look like:
 34 | 
 35 | <img src=https://raw.github.com/mikolalysenko/gl-mesh/master/images/screenshot.png>
 36 | 
 37 | # Install
 38 | 
 39 | Use [npm](https://npmjs.org/) to install it locally:
 40 | 
 41 |     npm install gl-mesh
 42 |     
 43 | Then you can build/run the client using any tool that compiles CommonJS modules, for example [browserify](https://github.com/substack/node-browserify) or [beefy](https://github.com/chrisdickinson/beefy).
 44 | 
 45 | # API
 46 | 
 47 | ```javascript
 48 | var createMesh = require("gl-mesh")
 49 | ```
 50 | 
 51 | ## Constructor
 52 | 
 53 | ### `var mesh = createMesh(gl, cells, attributes)`
 54 | Creates a static mesh.
 55 | 
 56 | * `gl` is a webgl context
 57 | * `cells` is a list of representing indices into the geometry
 58 | * `attributes` is an object of attributes to pass to the mesh
 59 | 
 60 | Each of these objects can be encoded as either an array-of-native-arrays or as a typed array using [ndarrays](https://github.com/mikolalysenko/ndarray).  The first dimension in the shape is interepreted as the number of vertices in the attribute while the second dimension is interpreted as the size.  For example, to pass in a packed array of 3d vertices in a typed array you could do:
 61 | 
 62 | ```javascript
 63 | var mesh = createMesh(gl, cells, { "positions": ndarray(position_data, [numVertices, 3]) })
 64 | ```
 65 | 
 66 | The drawing mode for the mesh is determined by the shape of the cells according to the following rule:
 67 | 
 68 | * `cells.length == 0` : empty mesh
 69 | * `cells[0].length == 1` : `gl.POINTS`
 70 | * `cells[0].length == 2` : `gl.LINES`
 71 | * `cells[0].length == 3` : `gl.TRIANGLES`
 72 | 
 73 | You can also skip the `cells` parameter, in which case the resulting mesh is drawn as a point cloud.
 74 | 
 75 | 
 76 | Also you can pass a single object with a `cells` field.  For example, here is the quickest way to create a Stanford bunny test mesh:
 77 | 
 78 | ```javascript
 79 | var bunnyMesh = createMesh(gl, require("bunny"))
 80 | ```
 81 | 
 82 | Where the module comes from the [`bunny`](https://npmjs.org/package/bunny) package
 83 | 
 84 | **Returns** A `Mesh` object
 85 | 
 86 | ## Methods
 87 | Each `Mesh` object has the following methods:
 88 | 
 89 | ### `mesh.bind(shader)`
 90 | Binds the mesh to the given shader updating attributes accordingly.
 91 | 
 92 | * `shader` is an instance of a shader created using [`gl-shader`](https://github.com/mikolalysenko/gl-shader)
 93 | 
 94 | ### `mesh.draw()`
 95 | Draws an instance of the mesh once it is bound to a shader
 96 | 
 97 | ### `mesh.unbind()`
 98 | Unbinds the mesh releasing the current vertex attribute state
 99 | 
100 | ### `mesh.dispose()`
101 | Destroys the mesh and releases all of its associated resources
102 | 
103 | # Credits
104 | (c) 2013 Mikola Lysenko. MIT License


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
  1 | "use strict"
  2 | 
  3 | var webglew = require("webglew")
  4 | var createBuffer = require("gl-buffer")
  5 | var createVAO = require("gl-vao")
  6 | var ndarray = require("ndarray")
  7 | var ops = require("ndarray-ops")
  8 | var pool = require("typedarray-pool")
  9 | 
 10 | var Mesh = require("./lib/mesh.js")
 11 | 
 12 | function EmptyMesh(gl) {
 13 |   this.gl = gl
 14 |   this.mode = gl.POINTS
 15 |   this.numElements = 0
 16 |   this.elements = null
 17 |   this.attributes = {}
 18 | }
 19 | EmptyMesh.prototype.dispose = function() {}
 20 | EmptyMesh.prototype.bind = function() {}
 21 | EmptyMesh.prototype.unbind = function() {}
 22 | EmptyMesh.prototype.draw = function() {}
 23 | 
 24 | 
 25 | function MeshAttribute(buffer, size, type, normalized) {
 26 |   this.buffer = buffer
 27 |   this.size = size
 28 |   this.type = type
 29 |   this.normalized = normalized
 30 | }
 31 | 
 32 | function getGLType(gl, array) {
 33 |   if((array instanceof Uint8Array) ||
 34 |      (array instanceof Uint8ClampedArray)) {
 35 |     return gl.UNSIGNED_BYTE
 36 |   } else if(array instanceof Int8Array) {
 37 |     return gl.BYTE
 38 |   } else if(array instanceof Uint16Array) {
 39 |     return gl.UNSIGNED_SHORT
 40 |   } else if(array instanceof Int16Array) {
 41 |     return gl.SHORT
 42 |   } else if(array instanceof Uint32Array) {
 43 |     return gl.UNSIGNED_INT
 44 |   } else if(array instanceof Int32Array) {
 45 |     return gl.INT
 46 |   } else if(array instanceof Float32Array) {
 47 |     return gl.FLOAT
 48 |   }
 49 |   return 0
 50 | }
 51 | 
 52 | function createTmpArray(gl, type, n) {
 53 |   if(type === gl.UNSIGNED_BYTE) {
 54 |     return pool.mallocUint8(n)
 55 |   } else if(type === gl.BYTE) {
 56 |     return pool.mallocInt8(n)
 57 |   } else if(type === gl.UNSIGNED_SHORT) {
 58 |     return pool.mallocUint16(n)
 59 |   } else if(type === gl.SHORT) {
 60 |     return pool.mallocInt16(n)
 61 |   } else if(type === gl.UNSIGNED_INT) {
 62 |     return pool.mallocUint32(n)
 63 |   } else if(type === gl.INT) {
 64 |     return pool.mallocInt32(n)
 65 |   }
 66 |   return pool.mallocFloat32(n)
 67 | }
 68 | 
 69 | function packAttributes(gl, numVertices, attributes) {
 70 |   var attrNames = []
 71 |   var attrVals = []
 72 |   for(var name in attributes) {
 73 |     var attr = attributes[name]
 74 |     var buffer, type, normalized, size
 75 |     if(typeof attr.length === "number") {
 76 |       if(attr.length !== numVertices) {
 77 |         throw new Error("Incorrect vertex count for attribute " + name)
 78 |       }
 79 |       if(typeof attr[0] === "number") {
 80 |         var gltype = getGLType(attr)
 81 |         if(gltype) {
 82 |           //Case: typed array
 83 |           size = 1
 84 |           type = gltype
 85 |           normalized = (gltype === gl.BYTE || gltype === gl.UNSIGNED_BYTE)
 86 |           buffer = createBuffer(gl, attr)
 87 |         } else {
 88 |           //Case: native array of numbers
 89 |           var tmp_buf = pool.mallocFloat32(numVertices)
 90 |           for(var i=0; i<numVertices; ++i) {
 91 |             tmp_buf[i] = attr[i]
 92 |           }
 93 |           size = 1
 94 |           type = gl.FLOAT
 95 |           normalized = false
 96 |           buffer = createBuffer(gl, tmp_buf.subarray(0, numVertices))
 97 |           pool.freeUint32(tmp_buf)
 98 |         }
 99 |       } else if(attr[0].length) {
100 |         //Case: native array of arrays
101 |         size = attr[0].length|0
102 |         var ptr = 0
103 |         var tmp_buf = pool.mallocFloat32(size * numVertices)
104 |         for(var i=0; i<numVertices; ++i) {
105 |           var vert = attr[i]
106 |           for(var j=0; j<size; ++j) {
107 |             tmp_buf[ptr++] = vert[j]
108 |           }
109 |         }
110 |         type = gl.FLOAT
111 |         normalized = false
112 |         buffer = createBuffer(gl, tmp_buf.subarray(0, ptr))
113 |         pool.freeFloat32(tmp_buf)
114 |       }
115 |     } else if(attr.shape) {
116 |       if(attr.shape[0] !== numVertices) {
117 |         throw new Error("Invalid shape for attribute " + name)
118 |       }
119 |       //Convert 1D array to 2D
120 |       if(attr.shape.length === 1) {
121 |         attr = ndarray(attr.data, [attr.shape[0], 1], [attr.stride[0], 1], attr.offset)
122 |       }
123 |       //Check if type is compatible
124 |       var packed = true
125 |       type = getGLType(gl, attr.data)
126 |       if(!type) {
127 |         packed = false
128 |         type = gl.FLOAT
129 |       }
130 |       if(stride[0] !== 1 || (shape[1] > 1 && stride[1] !== 1)) {
131 |         packed = false
132 |       }
133 |       //Check if array has to be normalized
134 |       normalized = (type === gl.BYTE || type === gl.UNSIGNED_BYTE)
135 |       size = attr.shape[1]
136 |       if(packed) {
137 |         //Case: packed ndarray, directly blit into buffer
138 |         if(attr.offset === 0 && attr.data.length === size*numVertices) {
139 |           buffer = createBuffer(gl, attr.data)
140 |         } else {
141 |           buffer = createBuffer(gl, attr.data.subarray(0, size*numVertices))
142 |         }
143 |       } else {
144 |         //Case: unpacked ndarray, create new array and blit
145 |         var tmp_buf = createTmpArray(gl, type, size*numVertices)
146 |         var tmp = ndarray(tmp_buf, attr.shape)
147 |         ops.assign(tmp, attr)
148 |         buffer = createBuffer(gl, tmp.data.subarray(0, size*numVertices))
149 |         pool.free(tmp_buf)
150 |       }
151 |     } else {
152 |       throw new Error("Invalid vertex attribute " + name)
153 |     }
154 |     attrNames.push(name)
155 |     attrVals.push(new MeshAttribute(buffer, size, type, normalized))
156 |   }
157 |   return {
158 |     names: attrNames,
159 |     values: attrVals
160 |   }
161 | }
162 | 
163 | function packAttributesFromNDArray(gl, numVertices, attributes, elements) {
164 |   var n = elements.shape[0]|0
165 |   var d = elements.shape[1]|0
166 |   var numElements = (n*d)|0
167 |   var attrNames = [], attrVals = []
168 |   for(var name in attributes) {
169 |     var attr = attributes[name]
170 |     var type, size, normalized, buffer
171 |     if(typeof attr.length === "number") {
172 |       if(attr.length !== numVertices) {
173 |         throw new Error("Invalid attribute size for attribute " + name)
174 |       }
175 |       if(typeof attr[0] === "number") {
176 |         //Case: 1D array attribute
177 |         size = 1
178 |         type = getGLType(gl, attr)
179 |         var pack_buf
180 |         if(!type) {
181 |           type = gl.FLOAT
182 |         }
183 |         normalized = (type === gl.BYTE || gl.UNSIGNED_BYTE)
184 |         pack_buf = createTmpArray(gl, type, numElements)
185 |         var ptr = 0
186 |         for(var i=0; i<n; ++i) {
187 |           for(var j=0; j<d; ++j) {
188 |             pack_buf[ptr++] = attr[elements.get(i,j)]
189 |           }
190 |         }
191 |         buffer = createBuffer(gl, pack_buf.subarray(0, ptr))
192 |         pool.free(pack_buf)
193 |       } else {
194 |         //Case: Array-of-arrays attribute
195 |         size = attr[0].length|0
196 |         if(size < 1 || size > 4) {
197 |           throw new Error("Invalid attribute size for attribute " + name)
198 |         }
199 |         type = gl.FLOAT
200 |         normalized = false
201 |         var pack_buf = pool.mallocFloat32(numElements * size)
202 |         var ptr = 0
203 |         for(var i=0; i<n; ++i) {
204 |           for(var j=0; j<d; ++j) {
205 |             var vert = attr[elements.get(i,j)]
206 |             for(var k=0; k<size; ++k) {
207 |               pack_buf[ptr++] = vert[k]
208 |             }
209 |           }
210 |         }
211 |         buffer = createBuffer(gl, pack_buf.subarray(0, numElements*size))
212 |         pool.freeFloat32(pack_buf)
213 |       }
214 |     } else if(attr.shape) {
215 |       //Case: ndarray attribute
216 |       if(attr.shape[0] !== numVertices) {
217 |         throw new Error("Invalid number of vertices for attribute " + name)
218 |       }
219 |       if(attr.shape.length === 1) {
220 |         //Case: 1D ndarray
221 |         size = 1
222 |         type = getGLType(gl, array.data)
223 |         if(!type) {
224 |           type = gl.FLOAT
225 |         }
226 |         normalized = (type === gl.BYTE || type === gl.UNSIGNED_BYTE)
227 |         var pack_buf = createTmpArray(gl, type, numElements)
228 |         var ptr = 0
229 |         for(var i=0; i<n; ++i) {
230 |           for(var j=0; j<d; ++j) {
231 |             pack_buf[ptr++] = attr.get(elements.get(i,j))
232 |           }
233 |         }
234 |         buffer = createBuffer(gl, pack_buf.subarray(0, ptr))
235 |         pool.free(pack_buf)
236 |       } else if(attr.shape.length === 2) {
237 |         //Case: 2D ndarray
238 |         size = attr.shape[1]|0
239 |         if(size < 1 || size > 4) {
240 |           throw new Error("Invalid attribute size for attribute " + name)
241 |         }
242 |         type = getGLType(gl, array.data)
243 |         if(!type) {
244 |           type = gl.FLOAT
245 |         }
246 |         normalized = (type === gl.BYTE || gl.UNSIGNED_BYTE)
247 |         var pack_buf = createTmpArray(gl, type, numElements * size)
248 |         var ptr = 0
249 |         for(var i=0; i<n; ++i) {
250 |           for(var j=0; j<d; ++j) {
251 |             var vert_num = elements.get(i,j)
252 |             for(var k=0; k<size; ++k) {
253 |               pack_buf[ptr++] = attr.get(vert_num, k)
254 |             }
255 |           }
256 |         }
257 |         buffer = createBuffer(gl, pack_buf.subarray(0, ptr))
258 |         pool.free(pack_buf)
259 |       } else {
260 |         throw new Error("Invalid attribute " + name + ", shape is too big")
261 |       }
262 |     } else {
263 |       throw new Error("Invalid attribute " + name + ", unrecognized type")
264 |     }
265 |     attrNames.push(name)
266 |     attrVals.push(new MeshAttribute(buffer, size, type, normalized))
267 |   }
268 |   return {
269 |     names: attrNames,
270 |     values: attrVals
271 |   }
272 | }
273 | 
274 | function packAttributesFrom1DArray(gl, numVertices, attributes, elements) {
275 |   var n = elements.length|0
276 |   var buf = pool.mallocUint32(n)
277 |   for(var i=0; i<n; ++i) {
278 |     buf[i] = elements[i]
279 |   }
280 |   var result = packAttributesFromNDArray(gl, numVertices, attributes, ndarray(buf, [n, 1]))
281 |   pool.freeUint32(buf)
282 |   return result
283 | }
284 | 
285 | function packAttributesFromArray(gl, numVertices, attributes, elements) {
286 |   var n = elements.length|0
287 |   var d = elements[0].length|0
288 |   var ptr = 0
289 |   var buf = pool.mallocUint32(n*d)
290 |   for(var i=0; i<n; ++i) {
291 |     var list = elements[i]
292 |     for(var j=0; j<d; ++j) {
293 |       buf[ptr++] = list[j]
294 |     }
295 |   }
296 |   var result = packAttributesFromNDArray(gl, numVertices, attributes, ndarray(buf, [n, d]))
297 |   pool.freeUint32(buf)
298 |   return result
299 | }
300 | 
301 | //Builds the actual mesh object, selecting appropriate implementation depending on if vertex attribute objects are supported
302 | function buildMeshObject(gl, mode, numElements, elements, attributes) {
303 |   if(numElements === 0) {
304 |     return new EmptyMesh(gl)
305 |   }
306 |   var vao = createVAO(gl, elements, attributes.values)
307 |   return new Mesh(gl, mode, numElements, vao, elements, attributes.values, attributes.names)
308 | }
309 | 
310 | //Creates a mesh
311 | function createMesh(gl, elements, attributes) {
312 | 
313 |   //Special case: handle object with cells/positions/etc. for attributes
314 |   if(arguments.length === 2) {
315 |     if(elements.cells) {
316 |       attributes = {}
317 |       for(var id in elements) {
318 |         if(id === "cells") {
319 |           continue
320 |         }
321 |         attributes[id] = elements[id]
322 |       }
323 |       elements = elements.cells
324 |     }
325 |   }
326 |   
327 |   //First figure out what mode we are using (POINTS, LINES or TRIANGLES)
328 |   var mode
329 |   if(attributes === undefined) {
330 |     //Special case for point clouds
331 |     attributes = elements
332 |     elements = undefined
333 |     mode = gl.POINTS
334 |   } else if(elements instanceof Array) {
335 |     if(elements.length === 0) {
336 |       //Empty array, return empty mesh
337 |       return buildMeshObject(gl, gl.POINTS, 0, null, [])
338 |     } else if(typeof elements[0] === "number" || elements[0].length === 1) {
339 |       mode = gl.POINTS
340 |     } else if(elements[0].length === 2) {
341 |       mode = gl.LINES
342 |     } else if(elements[0].length === 3) {
343 |       mode = gl.TRIANGLES
344 |     } else {
345 |       throw new Error("Invalid shape for element array")
346 |     }
347 |   } else if(elements.shape) {
348 |     if(elements.shape.length === 1) {
349 |       mode = gl.POINTS
350 |       //Special case: convert to 2d element array for point cloud automatically to simplify things later on
351 |       elements = ndarray(elements.data, [elements.shape[0], 1], [elements.stride[0], 1], elements.offset)
352 |     } else if(elements.shape.length !== 2) {
353 |       throw new Error("Invalid shape for element array")
354 |     } else if(elements.shape[1] === 1) {
355 |       mode = gl.POINTS
356 |     } else if(elements.shape[1] === 2) {
357 |       mode = gl.LINES
358 |     } else if(elements.shape[1] === 3) {
359 |       mode = gl.TRIANGLES
360 |     } else {
361 |       throw new Error("Invalid shape for elment array")
362 |     }
363 |     //Special case for empty meshes
364 |     if(elements.shape[0] === 0) {
365 |       return buildMeshObject(gl, mode, 0, null, [])
366 |     }
367 |   } else {
368 |     throw new Error("Invalid data type for element array")
369 |   }
370 |   
371 |   //Next figure out how many vertices we are using
372 |   var attr_names = Object.keys(attributes)
373 |   if(attr_names.length < 1) {
374 |     throw new Error("Invalid number of vertex attributes")
375 |   }
376 |   var numVertices, attr0 = attributes[attr_names[0]]
377 |   if(attr0.length) {
378 |     numVertices = attr0.length
379 |   } else if(attr0.shape) {
380 |     numVertices = attr0.shape[0]
381 |   } else {
382 |     throw new Error("Invalid vertex attribute: " + attr_names[0])
383 |   }
384 |   
385 |   //We now have three basic cases:
386 |   if(elements === undefined) {
387 |     //First special case is a point cloud: this is easy
388 |     return buildMeshObject(gl, gl.POINTS, numVertices, null, packAttributes(gl, numVertices, attributes))
389 |     
390 |   } else if((numVertices <= 1<<16) && mode !== gl.POINTS) {
391 |     //Indices fit in 16-bit unsigned int, so we can use gl.drawElements
392 |   
393 |     //First thing is to repackage element buffer
394 |     var element_buffer, element_count
395 |     if(elements instanceof Array) {
396 |     //    1a. elements is array    => coerce to ndarray
397 |       if(typeof elements[0] === "number") {
398 |         //Special case: point cloud
399 |         element_count = elements.length|0
400 |         var point_buf = pool.mallocUint16(element_count)
401 |         for(var i=0; i<element_count; ++i) {
402 |           point_buf[i] = elements[i]
403 |         }
404 |         element_buffer = createBuffer(gl, gl.ELEMENT_ARRAY_BUFFER, point_buf.subarray(0, element_count))
405 |         pool.freeUint16(point_buf)
406 |       } else {
407 |         //Otherwise we pack data into a uint16 array
408 |         var n = elements.length|0
409 |         var d = elements[0].length|0
410 |         var ptr = 0
411 |         element_count = (n*d)|0
412 |         var packed_buf = pool.mallocUint16(element_count)
413 |         for(var i=0; i<n; ++i) {
414 |           var prim = elements[i]
415 |           for(var j=0; j<d; ++j) {
416 |             packed_buf[ptr++] = prim[j]
417 |           }
418 |         }
419 |         element_buffer = createBuffer(gl, gl.ELEMENT_ARRAY_BUFFER, packed_buf.subarray(0, element_count))
420 |         pool.freeUint16(packed_buf)
421 |       }
422 |     } else {
423 |       element_count = elements.shape[0] * elements.shape[1]
424 |     //    1b. elements is ndarray  => check packing:
425 |       if(elements.stride[1] === 1 &&
426 |          elements.stride[0] === elements.shape[1] &&
427 |          elements.data instanceof Uint16Array) {
428 |       //        1b.1  array is packed   => use directly
429 |         if(elements.offset === 0 &&
430 |            elements.data.length === element_count) {
431 |           element_buffer = createBuffer(gl, gl.ELEMENT_ARRAY_BUFFER, elements.data)
432 |         } else {
433 |           element_buffer = createBuffer(gl, gl.ELEMENT_ARRAY_BUFFER, elements.data.subarray(elements.offset, elements.offset + element_count))
434 |         }
435 |       } else {
436 |       //        1b.2  array not packed  => copy to packed array
437 |         var packed_buf = pool.mallocUint16(element_count)
438 |         var packed_view = ndarray(packed_buf, elements.shape)
439 |         ops.assign(packed_view, elements)
440 |         element_buffer = createBuffer(gl, gl.ELEMENT_ARRAY_BUFFER, packed_buf.subarray(0, element_count))
441 |         pool.freeUint16(packed_buf)
442 |       }
443 |     }
444 |     
445 |     //Finally we are done
446 |     return buildMeshObject(gl, mode, element_count, element_buffer, packAttributes(gl, numVertices, attributes))
447 |     
448 |   } else {
449 |     //Otherwise we have to use gl.drawArrays, and so the mesh needs to be repacked
450 |     if(elements instanceof Array) {
451 |       if(typeof elements[0] === "number") {
452 |         return buildMeshObject(gl, mode, elements.length, null, packAttributesFrom1DArray(gl, numVertices, attributes, elements))
453 |       } else {
454 |         return buildMeshObject(gl, mode, elements.length * elements[0].length, null, packAttributesFromArray(gl, numVertices, attributes, elements))
455 |       }
456 |     } else {
457 |       return buildMeshObject(gl, mode, elements.shape[0] * elements.shape[1], null, packAttributesFromNDArray(gl, numVertices, attributes, elements))
458 |     }
459 |   }
460 |   throw new Error("Error building mesh object")
461 | }
462 | 
463 | module.exports = createMesh


--------------------------------------------------------------------------------