@pirireis/webglobeplugins 0.9.9 → 0.9.11

package/util/account/single-attribute-buffer-management/object-store.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectStore = void 0;
+var ObjectStore = /** @class */ (function () {
+    function ObjectStore(_a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.initialCapcity, initialCapcity = _c === void 0 ? 10 : _c;
+        this._container = this._createEmptyList(initialCapcity);
+    }
+    ObjectStore.prototype.resetWithCapacity = function (capacity) {
+        this._container = this._createEmptyList(capacity);
+    };
+    ObjectStore.prototype.deleteBulk = function (offsets) {
+        for (var i = 0; i < offsets.length; i++) {
+            var offset = offsets[i];
+            if (offset !== undefined) {
+                this._container[offset] = null;
+            }
+        }
+    };
+    ObjectStore.prototype.insertBulk = function (objects, offsets) {
+        for (var i = 0; i < objects.length; i++) {
+            var object = objects[i];
+            var offset = offsets[i];
+            if (offset !== undefined) {
+                this._container[offset] = object;
+            }
+        }
+    };
+    ObjectStore.prototype.defrag = function (offsetValues, occupiedCapacity, newCapacity) {
+        var hold = this._createEmptyList(newCapacity);
+        for (var i = 0; i < offsetValues.length; i++) {
+            var offset = offsetValues[i];
+            if (offset !== undefined) {
+                hold[i] = this._container[offset];
+            }
+        }
+        this._container = hold;
+    };
+    ObjectStore.prototype.extendBuffer = function (occupiedCapacity, newCapacity) {
+        var oldCapacity = this._container.length;
+        this._container = this._container.concat(this._createEmptyList(newCapacity - oldCapacity));
+    };
+    ObjectStore.prototype._createEmptyList = function (size) {
+        return new Array(size).fill(null);
+    };
+    ObjectStore.prototype.get = function (index) {
+        return this._container[index];
+    };
+    ObjectStore.prototype.free = function () {
+    };
+    return ObjectStore;
+}());
+exports.ObjectStore = ObjectStore;

package/util/account/single-attribute-buffer-management/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/util/account/util.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vaoAttributeLoader = void 0;
+var vaoAttributeLoader = function (gl, buffer, index, size, stride, offset, divisor, type) {
+    if (divisor === void 0) { divisor = null; }
+    if (type === void 0) { type = null; }
+    if (!gl || !buffer) {
+        throw new Error("Invalid WebGL context or buffer");
+    }
+    if (index < 0) {
+        throw new Error("Attribute index must be non-negative");
+    }
+    if (stride < 0 || offset < 0) {
+        throw new Error("Stride and offset must be non-negative");
+    }
+    var attribType = type === null ? gl.FLOAT : type;
+    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+    gl.enableVertexAttribArray(index);
+    gl.vertexAttribPointer(index, size, attribType, false, stride, offset);
+    if (divisor !== null) {
+        gl.vertexAttribDivisor(index, divisor);
+    }
+};
+exports.vaoAttributeLoader = vaoAttributeLoader;

package/util/algorithms/index.js

@@ -0,0 +1 @@
+"use strict";

package/util/algorithms/search-binary.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * @typedef {Array<number>} ListLike
+ * @typedef {number || null} Index
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findFirstIndexInRange = void 0;
+/**
+ * @param {ListLike} container
+ * @param {number} value
+ * @returns {Index}
+ */
+var findFirstIndexInRange = function (container, value) {
+    var start = 0;
+    var end = container.length - 1;
+    var mid = 0;
+    while (start <= end) {
+        mid = Math.floor((start + end) / 2);
+        if (container[mid] <= value && value <= container[mid + 1])
+            return mid;
+        if (container[mid] < value)
+            start = mid + 1;
+        else
+            end = mid - 1;
+    }
+    return null;
+};
+exports.findFirstIndexInRange = findFirstIndexInRange;

package/util/check/get.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapGetOrThrow = void 0;
+var mapGetOrThrow = function (errorNote) {
+    return function (mapInstance, ids) {
+        if (!ids)
+            throw new Error("There is no map keys to get");
+        var result = [];
+        for (var i = 0; i < ids.length; i++) {
+            var e = mapInstance.get(ids[i]);
+            if (e === undefined)
+                throw new Error(errorNote + " " + ids[i]);
+            result.push(e);
+        }
+        return result;
+    };
+};
+exports.mapGetOrThrow = mapGetOrThrow;

package/util/check/index.js

@@ -0,0 +1 @@
+"use strict";

package/util/check/typecheck.js

@@ -0,0 +1,51 @@
+"use strict";
+// Generic
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBoolean = exports.constraintFloat = exports.isTextFont = exports.opacityCheck = exports.isHexColorWithOpacity = exports.isHexColor = void 0;
+var doesOwnProperties = function (properties, errorMessage) {
+    return function (object) {
+        properties.forEach(function (element) {
+            if (!Object.hasOwn(object, element))
+                throw new TypeError(errorMessage + ':' + element);
+        });
+    };
+};
+var isHexColor = function (hexColor) { return /^#[0-9A-F]{6}$/i.test(hexColor); };
+exports.isHexColor = isHexColor;
+var isHexColorWithOpacity = function (hexColor) { return /^#[0-9A-F]{6}[0-9a-f]{0,2}$/i.test(hexColor); };
+exports.isHexColorWithOpacity = isHexColorWithOpacity;
+var opacityCheck = function (opacity) {
+    if (typeof opacity !== "number")
+        throw new TypeError("style.opacity must a number");
+    if (opacity < 0 || 1 < opacity)
+        throw new RangeError("Opacity Range Must be 0-1");
+};
+exports.opacityCheck = opacityCheck;
+// Text Related 
+var fontCheckTypes = doesOwnProperties(["name", "textColor", "hollowColor", "size", "bold", "italic"], "font does not have");
+var fontCheckColors = function (textColor, hollowColor) { return (0, exports.isHexColor)(textColor) && (0, exports.isHexColor)(hollowColor); };
+var isTextFont = function (textFont) {
+    fontCheckTypes(textFont);
+    fontCheckColors(textFont.textColor, textFont.hollowColor);
+    if (typeof textFont.size !== "number")
+        throw new TypeError("textFont size is not a number");
+};
+exports.isTextFont = isTextFont;
+var constraintFloat = function (x, lowerBound, upperBound) {
+    if (lowerBound === void 0) { lowerBound = null; }
+    if (upperBound === void 0) { upperBound = null; }
+    if (typeof x !== "number")
+        throw new Error("type must be numberic");
+    if (lowerBound === null && upperBound === null)
+        return;
+    if (lowerBound !== null && lowerBound > x)
+        throw new Error("input must be greater than ".concat(lowerBound));
+    if (upperBound !== null && x > upperBound)
+        throw new Error("input must be less than ".concat(upperBound));
+};
+exports.constraintFloat = constraintFloat;
+var isBoolean = function (x) {
+    if (typeof x !== "boolean")
+        throw new TypeError("type must be boolean");
+};
+exports.isBoolean = isBoolean;

package/util/geometry/index.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBBoxMatrix = createBBoxMatrix;
+exports.latLongToPixelXY = latLongToPixelXY;
+exports.latLongBboxtoPixelXYBbox = latLongBboxtoPixelXYBbox;
+exports.sphereCoord = sphereCoord;
+exports.normalize = normalize;
+function latLongToPixelXY(latitude, longitude) {
+    return {
+        x: (longitude + 180) / 360,
+        y: (90 - latitude) / 180
+    };
+}
+/**
+ * createBBoxMatrix( minX, maxX, minY, maxY)
+ * use this matrix to transform a point from 0 to 1 range to the bounding box
+ * for example: Transform image coordinates to map coordinates
+ * glsl`vec3 pos = u_bbox_matrix * vec3(v_particle_pos.x, v_particle_pos.y, 1.0);`
+ */
+function createBBoxMatrix(minX, maxX, minY, maxY) {
+    return new Float32Array([
+        maxX - minX, 0, 0,
+        0, maxY - minY, 0,
+        minX, minY, 1
+    ]);
+}
+function latLongBboxtoPixelXYBbox(minX, minY, maxX, maxY) {
+    var minXY = latLongToPixelXY(minY, minX);
+    var maxXY = latLongToPixelXY(maxY, maxX);
+    return createBBoxMatrix(minXY.x, maxXY.x, minXY.y, maxXY.y);
+}
+/**
+ *
+ * @param {Float32List} array
+ * @returns {Float32Array}
+ */
+function normalize(array, newLength) {
+    if (newLength === void 0) { newLength = 1; }
+    var total = 0;
+    for (var i = 0; i < array.length; i++) {
+        total += array[i] * array[i];
+    }
+    var len = newLength / Math.sqrt(total);
+    var result = new Float32Array(array.length);
+    for (var i = 0; i < array.length; i++) {
+        result[i] = array[i] * len;
+    }
+    return result;
+}
+function sphereCoord(long, lat, globe, height) {
+    if (height === void 0) { height = 0; }
+    return normalize(globe.api_GetCartesian3DPoint(long, lat, 0, 0), 6378.137 + height);
+}

package/util/gl-util/buffer/attribute-loader.js

@@ -0,0 +1,81 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBufferAndReadInfo = exports.attributeLoader = void 0;
+require("./types");
+/**
+ * @typedef BufferAndReadInfo Buffers can be intertwined or interleaved.
+ * This object forces user to adapt generic convention of buffer and read information.
+ * @type {Object}
+ * @property {WebGLBuffer} buffer
+ * @property {number} stride
+ * @property {number} offset
+ */
+/**
+ *
+ * @param {WebGLBuffer} gl
+ * @param {BufferAndReadInfo} bufferAndReadInfo
+ * @param {number} index
+ * @param {number} size
+ * @param {Object} options
+ * @param {*} options.type | default gl.FLOAT, gl.UNSIGNED_BYTE, gl.SHORT, gl.UNSIGNED_SHORT, gl.INT, gl.UNSIGNED_INT
+ * @param {number} options.divisor
+ * @param {Array<number>} options.escapeValues
+ * @returns
+ */
+var attributeLoader = function (gl, bufferAndReadInfo, index, size, _a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.divisor, divisor = _c === void 0 ? null : _c, _d = _b.type, type = _d === void 0 ? null : _d, _e = _b.escapeValues, escapeValues = _e === void 0 ? null : _e, _f = _b.normalized, normalized = _f === void 0 ? false : _f;
+    if (size < 1 || size > 4)
+        throw new Error("Size must be between 1 and 4");
+    if (bufferAndReadInfo == null) {
+        if (escapeValues !== null)
+            constantFunction(gl, index, size, escapeValues);
+        return;
+    }
+    var buffer = bufferAndReadInfo.buffer, stride = bufferAndReadInfo.stride, offset = bufferAndReadInfo.offset;
+    if (!gl || !buffer) {
+        throw new Error("Invalid WebGL context or buffer");
+    }
+    if (index < 0) {
+        throw new Error("Attribute index must be non-negative");
+    }
+    if (stride < 0 || offset < 0) {
+        throw new Error("Stride and offset must be non-negative");
+    }
+    var attribType = type === null ? gl.FLOAT : type;
+    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+    gl.enableVertexAttribArray(index);
+    gl.vertexAttribPointer(index, size, attribType, normalized, stride, offset);
+    if (divisor !== null) {
+        gl.vertexAttribDivisor(index, divisor);
+    }
+};
+exports.attributeLoader = attributeLoader;
+/**
+ *
+ * @param {WebGLBuffer} buffer
+ * @param {number} stride
+ * @param {number} offset
+ * @returns {BufferAndReadInfo}
+ */
+var createBufferAndReadInfo = function (buffer, stride, offset) {
+    if (stride === void 0) { stride = 0; }
+    if (offset === void 0) { offset = 0; }
+    if (buffer == null)
+        return null;
+    return { buffer: buffer, stride: stride, offset: offset };
+};
+exports.createBufferAndReadInfo = createBufferAndReadInfo;
+var constantFunction = function (gl, index, size, escapeValues) {
+    var func = "vertexAttrib".concat(size, "f");
+    // @ts-ignore
+    gl[func].apply(gl, __spreadArray([index], escapeValues, false));
+};

package/util/gl-util/buffer/index.js

@@ -0,0 +1,6 @@
+"use strict";
+// import './types';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attributeLoader = void 0;
+var attribute_loader_1 = require("./attribute-loader");
+Object.defineProperty(exports, "attributeLoader", { enumerable: true, get: function () { return attribute_loader_1.attributeLoader; } });

package/util/gl-util/buffer/types.js

@@ -0,0 +1 @@
+"use strict";

package/util/gl-util/draw-options/methods.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.drawInstanced = exports.drawArrays = void 0;
+require("./types");
+/**
+ * Draws instanced geometry using WebGL2.
+ */
+var drawInstanced = function (gl, mode, drawOptions, vertexCount) {
+    var _a;
+    var drawRange = drawOptions.drawRange, _b = drawOptions.elementBufferIndexType, elementBufferIndexType = _b === void 0 ? gl.UNSIGNED_INT : _b;
+    var _c = drawRange.first, first = _c === void 0 ? 0 : _c, _d = drawRange.count, instanceCount = _d === void 0 ? 1 : _d;
+    if (first > 0 || drawOptions.elementBuffer) {
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, (_a = drawOptions.elementBuffer) !== null && _a !== void 0 ? _a : null);
+        gl.drawElementsInstanced(mode, vertexCount, elementBufferIndexType, first, instanceCount);
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+    }
+    else {
+        gl.drawArraysInstanced(mode, first, vertexCount, instanceCount);
+    }
+};
+exports.drawInstanced = drawInstanced;
+/**
+ * Draws geometry using WebGL2.
+ */
+var drawArrays = function (gl, defaultMode, drawOptions) {
+    var drawRange = drawOptions.drawRange, elementBuffer = drawOptions.elementBuffer, _a = drawOptions.elementBufferIndexType, elementBufferIndexType = _a === void 0 ? gl.UNSIGNED_INT : _a, _b = drawOptions.drawMode, drawMode = _b === void 0 ? null : _b;
+    var _c = drawRange.first, first = _c === void 0 ? 0 : _c, count = drawRange.count;
+    var mode = drawMode !== null && drawMode !== void 0 ? drawMode : defaultMode;
+    if (elementBuffer) {
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, elementBuffer);
+        gl.drawElements(mode, count, elementBufferIndexType, first);
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+    }
+    else {
+        gl.drawArrays(mode, first, count);
+    }
+};
+exports.drawArrays = drawArrays;

package/util/gl-util/draw-options/types.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * @typedef DrawRange
+ * @type {Object}
+ * @property {int} first
+ * @property {int} count
+ *
+ * @typedef DrawRangeIndexParams
+ * @type {Object}
+ * @property {null|DrawRange} drawRange
+ * @property {null|ElementBuffer} elementBuffer
+ * @property {null|indexType} indexType
+ * @property {null|int} drawMode
+ *
+ */

package/util/gl-util/uniform-block/manager.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniformBlockManager = void 0;
+require("./types");
+var typeSizes = {
+    'float': 4,
+    'vec2': 8,
+    'vec3': 16, // vec3 takes up same space as vec4 due to alignment
+    'vec4': 16,
+    'mat2': 32, // 2 vec4s (16 * 2)
+    'mat3': 48, // 3 vec4s (16 * 3)
+    'mat4': 64, // 4 vec4s (16 * 4)
+    'int': 4,
+    'ivec2': 8,
+    'ivec3': 16,
+    'ivec4': 16,
+    'bool': 4
+};
+var typeAlignments = {
+    'float': 4,
+    'vec2': 8,
+    'vec3': 16,
+    'vec4': 16,
+    'mat2': 16, // aligns to vec4 boundary
+    'mat3': 16, // aligns to vec4 boundary
+    'mat4': 16, // aligns to vec4 boundary
+    'int': 4,
+    'ivec2': 8,
+    'ivec3': 16,
+    'ivec4': 16,
+    'bool': 4
+};
+var typeArrayConstructors = {
+    'float': Float32Array,
+    'vec2': Float32Array,
+    'vec3': Float32Array,
+    'vec4': Float32Array,
+    'mat2': Float32Array,
+    'mat3': Float32Array,
+    'mat4': Float32Array,
+    'int': Int32Array,
+    'ivec2': Int32Array,
+    'ivec3': Int32Array,
+    'ivec4': Int32Array,
+    'bool': Float32Array
+};
+var UniformBlockManager = /** @class */ (function () {
+    function UniformBlockManager(blockName, blockMembers, bindingPoint, prefix) {
+        if (prefix === void 0) { prefix = ""; }
+        this.blockName = blockName;
+        this.blockMembers = blockMembers;
+        this.bindingPoint = bindingPoint;
+        this.prefix = prefix;
+        this.offsetMap = this.__create_LayoutSTD140_OffsetMap();
+        this.size = this.__calculateSize();
+    }
+    UniformBlockManager.prototype.glslCode = function () {
+        var code = "layout(std140) uniform ".concat(this.blockName, " {");
+        for (var _i = 0, _a = this.blockMembers; _i < _a.length; _i++) {
+            var member = _a[_i];
+            var name_1 = member.name, type = member.type;
+            code += "".concat(type, " ").concat(this.prefix).concat(name_1, ";");
+        }
+        if (this.prefix) {
+            code += "} ".concat(this.prefix, ";");
+        }
+        else {
+            code += "};";
+        }
+        return code;
+    };
+    UniformBlockManager.prototype.createUBO = function (gl, bufferWriteType) {
+        var _this = this;
+        if (bufferWriteType === void 0) { bufferWriteType = "STATIC_DRAW"; }
+        var ubo = gl.createBuffer();
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        // @ts-ignore
+        gl.bufferData(gl.UNIFORM_BUFFER, this.size, gl[bufferWriteType]);
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, 0, ubo);
+        for (var _i = 0, _a = this.blockMembers; _i < _a.length; _i++) {
+            var member = _a[_i];
+            var name_2 = member.name, type = member.type, _b = member.value, value = _b === void 0 ? null : _b;
+            ;
+            var offset = this.offsetMap.get(name_2);
+            var data = (value === null) ? new typeArrayConstructors[type](typeSizes[type] / 4).fill(NaN) : value;
+            gl.bufferSubData(gl.UNIFORM_BUFFER, offset, data);
+        }
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+        return {
+            ubo: ubo,
+            update: function (nameValueMap) { return _this.updateUBO(gl, ubo, nameValueMap); },
+            bind: function () { return _this.bind(gl, ubo); },
+            unbind: function () { return _this.unbind(gl); },
+            free: function () { return gl.deleteBuffer(ubo); },
+        };
+    };
+    UniformBlockManager.prototype.updateUBO = function (gl, ubo, nameValueMap) {
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        var _loop_1 = function (name_3, value) {
+            var offset = this_1.offsetMap.get(name_3);
+            if (offset === undefined) {
+                throw new Error("Uniform block member ".concat(name_3, " not found in offset map."));
+            }
+            // @ts-ignore
+            var type = this_1.blockMembers.find(function (member) { return member.name === name_3; }).type;
+            var data = void 0;
+            if (Array.isArray(value)) {
+                data = new typeArrayConstructors[type](value);
+            }
+            else if (typeof value === 'number') {
+                data = new typeArrayConstructors[type]([value]);
+            }
+            else if (value instanceof ArrayBuffer) {
+                data = new typeArrayConstructors[type](value);
+            }
+            else if (ArrayBuffer.isView(value) && !(value instanceof DataView))
+                data = (typeof value === 'number') ? new typeArrayConstructors[type]([value]) : new typeArrayConstructors[type](value);
+            else {
+                throw new Error("Unsupported value type for ".concat(name_3, ": ").concat(typeof value));
+            }
+            console.log("Data to be uploaded:", data);
+            gl.bufferSubData(gl.UNIFORM_BUFFER, offset, data);
+        };
+        var this_1 = this;
+        for (var _i = 0, _a = nameValueMap.entries(); _i < _a.length; _i++) {
+            var _b = _a[_i], name_3 = _b[0], value = _b[1];
+            _loop_1(name_3, value);
+        }
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    };
+    // call this after linking the program
+    UniformBlockManager.prototype.assignBindingPoint = function (gl, program) {
+        var blockIndex = gl.getUniformBlockIndex(program, this.blockName);
+        gl.uniformBlockBinding(program, blockIndex, this.bindingPoint);
+    };
+    // call this before drawing
+    UniformBlockManager.prototype.bind = function (gl, ubo) {
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, this.bindingPoint, ubo);
+    };
+    // call this right after drawing
+    UniformBlockManager.prototype.unbind = function (gl) {
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, this.bindingPoint, null);
+    };
+    // implicit methods
+    UniformBlockManager.prototype.__create_LayoutSTD140_OffsetMap = function () {
+        var offset = 0;
+        var offsetMap = new Map();
+        for (var _i = 0, _a = this.blockMembers; _i < _a.length; _i++) {
+            var member = _a[_i];
+            var name_4 = member.name, type = member.type;
+            var size = typeSizes[type];
+            var alignment = typeAlignments[type];
+            var padding = (alignment - (offset % alignment)) % alignment;
+            offset += padding;
+            offsetMap.set(name_4, offset);
+            offset += size;
+        }
+        return offsetMap;
+    };
+    // __create_LayoutSTD140_OffsetMap() should be called before this
+    UniformBlockManager.prototype.__calculateSize = function () {
+        var lastOffset = Array.from(this.offsetMap.values()).pop() || 0;
+        var lastItemAlignment = typeAlignments[this.blockMembers[this.blockMembers.length - 1].type];
+        return lastOffset + lastItemAlignment;
+    };
+    return UniformBlockManager;
+}());
+exports.UniformBlockManager = UniformBlockManager;

package/util/gl-util/uniform-block/shader.js

@@ -0,0 +1 @@
+"use strict";

package/util/gl-util/uniform-block/types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * @typedef {string} UniformBlockName
+ *
+ * @typedef {string} GLSLType | mat4, mat3, vec4, vec3, vec2, float, int, bool
+ * @typedef {{name: string, type: GLSLType, value: null|Float32Array}} UniformBlockMember
+ *
+ */