molstar 3.0.0 → 3.0.1

package/lib/commonjs/mol-gl/webgl/texture.d.ts

@@ -1,75 +0,0 @@
-/**
- * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-import { WebGLContext } from './context';
-import { TextureImage, TextureVolume } from '../renderable/util';
-import { ValueCell } from '../../mol-util';
-import { RenderableSchema } from '../renderable/schema';
-import { Framebuffer } from './framebuffer';
-import { GLRenderingContext } from './compat';
-import { ValueOf } from '../../mol-util/type-helpers';
-import { WebGLExtensions } from './extensions';
-export declare type TextureKindValue = {
-    'image-uint8': TextureImage<Uint8Array>;
-    'image-float32': TextureImage<Float32Array>;
-    'image-float16': TextureImage<Float32Array>;
-    'image-int32': TextureImage<Int32Array>;
-    'image-depth': TextureImage<Uint8Array>;
-    'volume-uint8': TextureVolume<Uint8Array>;
-    'volume-float32': TextureVolume<Float32Array>;
-    'volume-float16': TextureVolume<Float32Array>;
-    'texture': Texture;
-};
-export declare type TextureValueType = ValueOf<TextureKindValue>;
-export declare type TextureKind = keyof TextureKindValue;
-export declare type TextureType = 'ubyte' | 'ushort' | 'float' | 'fp16' | 'int';
-export declare type TextureFormat = 'alpha' | 'rgb' | 'rgba' | 'depth';
-/** Numbers are shortcuts for color attachment */
-export declare type TextureAttachment = 'depth' | 'stencil' | 'color0' | 'color1' | 'color2' | 'color3' | 'color4' | 'color5' | 'color6' | 'color7' | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
-export declare type TextureFilter = 'nearest' | 'linear';
-export declare function getTarget(gl: GLRenderingContext, kind: TextureKind): number;
-export declare function getFormat(gl: GLRenderingContext, format: TextureFormat, type: TextureType): number;
-export declare function getInternalFormat(gl: GLRenderingContext, format: TextureFormat, type: TextureType): number;
-export declare function getType(gl: GLRenderingContext, extensions: WebGLExtensions, type: TextureType): number;
-export declare function getFilter(gl: GLRenderingContext, type: TextureFilter): number;
-export declare function getAttachment(gl: GLRenderingContext, extensions: WebGLExtensions, attachment: TextureAttachment): number;
-export interface Texture {
-    readonly id: number;
-    readonly target: number;
-    readonly format: number;
-    readonly internalFormat: number;
-    readonly type: number;
-    readonly filter: number;
-    getWidth: () => number;
-    getHeight: () => number;
-    getDepth: () => number;
-    getByteCount: () => number;
-    define: (width: number, height: number, depth?: number) => void;
-    /**
-     * The `sub` option requires an existing allocation on the GPU, that is, either
-     * `define` or `load` without `sub` must have been called before.
-     */
-    load: (image: TextureImage<any> | TextureVolume<any> | HTMLImageElement, sub?: boolean) => void;
-    bind: (id: TextureId) => void;
-    unbind: (id: TextureId) => void;
-    /** Use `layer` to attach a z-slice of a 3D texture */
-    attachFramebuffer: (framebuffer: Framebuffer, attachment: TextureAttachment, layer?: number) => void;
-    detachFramebuffer: (framebuffer: Framebuffer, attachment: TextureAttachment) => void;
-    reset: () => void;
-    destroy: () => void;
-}
-export declare type TextureId = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15;
-export declare type TextureValues = {
-    [k: string]: ValueCell<TextureValueType>;
-};
-export declare type Textures = [string, Texture][];
-export declare function createTexture(gl: GLRenderingContext, extensions: WebGLExtensions, kind: TextureKind, _format: TextureFormat, _type: TextureType, _filter: TextureFilter): Texture;
-export declare function createTextures(ctx: WebGLContext, schema: RenderableSchema, values: TextureValues): Textures;
-/**
- * Loads an image from a url to a textures and triggers update asynchronously.
- * This will not work on node.js without a polyfill for `HTMLImageElement`.
- */
-export declare function loadImageTexture(src: string, cell: ValueCell<Texture>, texture: Texture): void;
-export declare function createNullTexture(gl?: GLRenderingContext): Texture;

package/lib/commonjs/mol-gl/webgl/texture.js

@@ -1,398 +0,0 @@
-"use strict";
-/**
- * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNullTexture = exports.loadImageTexture = exports.createTextures = exports.createTexture = exports.getAttachment = exports.getFilter = exports.getType = exports.getInternalFormat = exports.getFormat = exports.getTarget = void 0;
-var mol_util_1 = require("../../mol-util");
-var id_factory_1 = require("../../mol-util/id-factory");
-var compat_1 = require("./compat");
-var getNextTextureId = (0, id_factory_1.idFactory)();
-function getTarget(gl, kind) {
-    switch (kind) {
-        case 'image-uint8': return gl.TEXTURE_2D;
-        case 'image-float32': return gl.TEXTURE_2D;
-        case 'image-float16': return gl.TEXTURE_2D;
-        case 'image-depth': return gl.TEXTURE_2D;
-    }
-    if ((0, compat_1.isWebGL2)(gl)) {
-        switch (kind) {
-            case 'image-int32': return gl.TEXTURE_2D;
-            case 'volume-uint8': return gl.TEXTURE_3D;
-            case 'volume-float32': return gl.TEXTURE_3D;
-            case 'volume-float16': return gl.TEXTURE_3D;
-        }
-    }
-    throw new Error("unknown texture kind '".concat(kind, "'"));
-}
-exports.getTarget = getTarget;
-function getFormat(gl, format, type) {
-    switch (format) {
-        case 'alpha':
-            if ((0, compat_1.isWebGL2)(gl) && type === 'float')
-                return gl.RED;
-            else if ((0, compat_1.isWebGL2)(gl) && type === 'int')
-                return gl.RED_INTEGER;
-            else
-                return gl.ALPHA;
-        case 'rgb':
-            if ((0, compat_1.isWebGL2)(gl) && type === 'int')
-                return gl.RGB_INTEGER;
-            return gl.RGB;
-        case 'rgba':
-            if ((0, compat_1.isWebGL2)(gl) && type === 'int')
-                return gl.RGBA_INTEGER;
-            return gl.RGBA;
-        case 'depth': return gl.DEPTH_COMPONENT;
-    }
-}
-exports.getFormat = getFormat;
-function getInternalFormat(gl, format, type) {
-    if ((0, compat_1.isWebGL2)(gl)) {
-        switch (format) {
-            case 'alpha':
-                switch (type) {
-                    case 'ubyte': return gl.ALPHA;
-                    case 'float': return gl.R32F;
-                    case 'fp16': return gl.R16F;
-                    case 'int': return gl.R32I;
-                }
-            case 'rgb':
-                switch (type) {
-                    case 'ubyte': return gl.RGB;
-                    case 'float': return gl.RGB32F;
-                    case 'fp16': return gl.RGB16F;
-                    case 'int': return gl.RGB32I;
-                }
-            case 'rgba':
-                switch (type) {
-                    case 'ubyte': return gl.RGBA;
-                    case 'float': return gl.RGBA32F;
-                    case 'fp16': return gl.RGBA16F;
-                    case 'int': return gl.RGBA32I;
-                }
-            case 'depth':
-                switch (type) {
-                    case 'ushort': return gl.DEPTH_COMPONENT16;
-                    case 'float': return gl.DEPTH_COMPONENT32F;
-                }
-        }
-    }
-    return getFormat(gl, format, type);
-}
-exports.getInternalFormat = getInternalFormat;
-function getByteCount(format, type, width, height, depth) {
-    var bpe = getFormatSize(format) * getTypeSize(type);
-    return bpe * width * height * (depth || 1);
-}
-function getFormatSize(format) {
-    switch (format) {
-        case 'alpha': return 1;
-        case 'rgb': return 3;
-        case 'rgba': return 4;
-        case 'depth': return 4;
-    }
-}
-function getTypeSize(type) {
-    switch (type) {
-        case 'ubyte': return 1;
-        case 'ushort': return 2;
-        case 'float': return 4;
-        case 'fp16': return 2;
-        case 'int': return 4;
-    }
-}
-function getType(gl, extensions, type) {
-    switch (type) {
-        case 'ubyte': return gl.UNSIGNED_BYTE;
-        case 'ushort': return gl.UNSIGNED_SHORT;
-        case 'float': return gl.FLOAT;
-        case 'fp16':
-            if (extensions.textureHalfFloat)
-                return extensions.textureHalfFloat.HALF_FLOAT;
-            else
-                throw new Error('extension "texture_half_float" unavailable');
-        case 'int':
-            if ((0, compat_1.isWebGL2)(gl))
-                return gl.INT;
-            else
-                throw new Error('texture type "int" requires webgl2');
-    }
-}
-exports.getType = getType;
-function getFilter(gl, type) {
-    switch (type) {
-        case 'nearest': return gl.NEAREST;
-        case 'linear': return gl.LINEAR;
-    }
-}
-exports.getFilter = getFilter;
-function getAttachment(gl, extensions, attachment) {
-    switch (attachment) {
-        case 'depth': return gl.DEPTH_ATTACHMENT;
-        case 'stencil': return gl.STENCIL_ATTACHMENT;
-        case 'color0':
-        case 0: return gl.COLOR_ATTACHMENT0;
-    }
-    if (extensions.drawBuffers) {
-        switch (attachment) {
-            case 'color1':
-            case 1: return extensions.drawBuffers.COLOR_ATTACHMENT1;
-            case 'color2':
-            case 2: return extensions.drawBuffers.COLOR_ATTACHMENT2;
-            case 'color3':
-            case 3: return extensions.drawBuffers.COLOR_ATTACHMENT3;
-            case 'color4':
-            case 4: return extensions.drawBuffers.COLOR_ATTACHMENT4;
-            case 'color5':
-            case 5: return extensions.drawBuffers.COLOR_ATTACHMENT5;
-            case 'color6':
-            case 6: return extensions.drawBuffers.COLOR_ATTACHMENT6;
-            case 'color7':
-            case 7: return extensions.drawBuffers.COLOR_ATTACHMENT7;
-        }
-    }
-    throw new Error('unknown texture attachment');
-}
-exports.getAttachment = getAttachment;
-function isImage(x) {
-    return typeof HTMLImageElement !== 'undefined' && (x instanceof HTMLImageElement);
-}
-function isTexture2d(x, target, gl) {
-    return target === gl.TEXTURE_2D;
-}
-function isTexture3d(x, target, gl) {
-    return target === gl.TEXTURE_3D;
-}
-function getTexture(gl) {
-    var texture = gl.createTexture();
-    if (texture === null) {
-        throw new Error('Could not create WebGL texture');
-    }
-    return texture;
-}
-function createTexture(gl, extensions, kind, _format, _type, _filter) {
-    var id = getNextTextureId();
-    var texture = getTexture(gl);
-    // check texture kind and type compatability
-    if ((kind.endsWith('float32') && _type !== 'float') ||
-        (kind.endsWith('float16') && _type !== 'fp16') ||
-        (kind.endsWith('uint8') && _type !== 'ubyte') ||
-        (kind.endsWith('int32') && _type !== 'int') ||
-        (kind.endsWith('depth') && _type !== 'ushort' && _type !== 'float')) {
-        throw new Error("texture kind '".concat(kind, "' and type '").concat(_type, "' are incompatible"));
-    }
-    var target = getTarget(gl, kind);
-    var filter = getFilter(gl, _filter);
-    var format = getFormat(gl, _format, _type);
-    var internalFormat = getInternalFormat(gl, _format, _type);
-    var type = getType(gl, extensions, _type);
-    function init() {
-        gl.bindTexture(target, texture);
-        gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, filter);
-        gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, filter);
-        // clamp-to-edge needed for non-power-of-two textures in webgl
-        gl.texParameteri(target, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-        gl.texParameteri(target, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-        gl.bindTexture(target, null);
-    }
-    init();
-    var width = 0, height = 0, depth = 0;
-    var loadedData;
-    var destroyed = false;
-    function define(_width, _height, _depth) {
-        if (width === _width && height === _height && depth === (_depth || 0))
-            return;
-        width = _width, height = _height, depth = _depth || 0;
-        gl.bindTexture(target, texture);
-        if (target === gl.TEXTURE_2D) {
-            gl.texImage2D(target, 0, internalFormat, width, height, 0, format, type, null);
-        }
-        else if ((0, compat_1.isWebGL2)(gl) && target === gl.TEXTURE_3D && depth !== undefined) {
-            gl.texImage3D(target, 0, internalFormat, width, height, depth, 0, format, type, null);
-        }
-        else {
-            throw new Error('unknown texture target');
-        }
-    }
-    function load(data, sub) {
-        if (sub === void 0) { sub = false; }
-        gl.bindTexture(target, texture);
-        // unpack alignment of 1 since we use textures only for data
-        gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
-        gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, gl.NONE);
-        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, 0);
-        if (isImage(data)) {
-            gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
-            gl.bindTexture(gl.TEXTURE_2D, texture);
-            gl.texImage2D(gl.TEXTURE_2D, 0, internalFormat, format, type, data);
-        }
-        else if (isTexture2d(data, target, gl)) {
-            var _filter_1 = data.filter ? getFilter(gl, data.filter) : filter;
-            gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, _filter_1);
-            gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, _filter_1);
-            gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, !!data.flipY);
-            if (sub) {
-                gl.texSubImage2D(target, 0, 0, 0, data.width, data.height, format, type, data.array);
-            }
-            else {
-                width = data.width, height = data.height;
-                gl.texImage2D(target, 0, internalFormat, width, height, 0, format, type, data.array);
-            }
-        }
-        else if ((0, compat_1.isWebGL2)(gl) && isTexture3d(data, target, gl)) {
-            gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
-            if (sub) {
-                gl.texSubImage3D(target, 0, 0, 0, 0, data.width, data.height, data.depth, format, type, data.array);
-            }
-            else {
-                width = data.width, height = data.height, depth = data.depth;
-                gl.texImage3D(target, 0, internalFormat, width, height, depth, 0, format, type, data.array);
-            }
-        }
-        else {
-            throw new Error('unknown texture target');
-        }
-        gl.bindTexture(target, null);
-        loadedData = data;
-    }
-    function attachFramebuffer(framebuffer, attachment, layer) {
-        framebuffer.bind();
-        if (target === gl.TEXTURE_2D) {
-            gl.framebufferTexture2D(gl.FRAMEBUFFER, getAttachment(gl, extensions, attachment), gl.TEXTURE_2D, texture, 0);
-        }
-        else if ((0, compat_1.isWebGL2)(gl) && target === gl.TEXTURE_3D) {
-            if (layer === undefined)
-                throw new Error('need `layer` to attach 3D texture');
-            gl.framebufferTextureLayer(gl.FRAMEBUFFER, getAttachment(gl, extensions, attachment), texture, 0, layer);
-        }
-        else {
-            throw new Error('unknown/unsupported texture target');
-        }
-    }
-    return {
-        id: id,
-        target: target,
-        format: format,
-        internalFormat: internalFormat,
-        type: type,
-        filter: filter,
-        getWidth: function () { return width; },
-        getHeight: function () { return height; },
-        getDepth: function () { return depth; },
-        getByteCount: function () { return getByteCount(_format, _type, width, height, depth); },
-        define: define,
-        load: load,
-        bind: function (id) {
-            gl.activeTexture(gl.TEXTURE0 + id);
-            gl.bindTexture(target, texture);
-        },
-        unbind: function (id) {
-            gl.activeTexture(gl.TEXTURE0 + id);
-            gl.bindTexture(target, null);
-        },
-        attachFramebuffer: attachFramebuffer,
-        detachFramebuffer: function (framebuffer, attachment) {
-            framebuffer.bind();
-            if (target === gl.TEXTURE_2D) {
-                gl.framebufferTexture2D(gl.FRAMEBUFFER, getAttachment(gl, extensions, attachment), gl.TEXTURE_2D, null, 0);
-            }
-            else if ((0, compat_1.isWebGL2)(gl) && target === gl.TEXTURE_3D) {
-                gl.framebufferTextureLayer(gl.FRAMEBUFFER, getAttachment(gl, extensions, attachment), null, 0, 0);
-            }
-            else {
-                throw new Error('unknown texture target');
-            }
-        },
-        reset: function () {
-            texture = getTexture(gl);
-            init();
-            var _a = [width, height, depth], _width = _a[0], _height = _a[1], _depth = _a[2];
-            width = 0, height = 0, depth = 0; // set to zero to trigger resize
-            define(_width, _height, _depth);
-            if (loadedData)
-                load(loadedData);
-        },
-        destroy: function () {
-            if (destroyed)
-                return;
-            gl.deleteTexture(texture);
-            destroyed = true;
-        }
-    };
-}
-exports.createTexture = createTexture;
-function createTextures(ctx, schema, values) {
-    var resources = ctx.resources;
-    var textures = [];
-    Object.keys(schema).forEach(function (k) {
-        var spec = schema[k];
-        if (spec.type === 'texture') {
-            var value = values[k];
-            if (value) {
-                if (spec.kind === 'texture') {
-                    textures[textures.length] = [k, value.ref.value];
-                }
-                else {
-                    var texture = resources.texture(spec.kind, spec.format, spec.dataType, spec.filter);
-                    texture.load(value.ref.value);
-                    textures[textures.length] = [k, texture];
-                }
-            }
-        }
-    });
-    return textures;
-}
-exports.createTextures = createTextures;
-/**
- * Loads an image from a url to a textures and triggers update asynchronously.
- * This will not work on node.js without a polyfill for `HTMLImageElement`.
- */
-function loadImageTexture(src, cell, texture) {
-    var img = new Image();
-    img.onload = function () {
-        texture.load(img);
-        mol_util_1.ValueCell.update(cell, texture);
-    };
-    img.src = src;
-}
-exports.loadImageTexture = loadImageTexture;
-//
-function createNullTexture(gl) {
-    var _a;
-    var target = (_a = gl === null || gl === void 0 ? void 0 : gl.TEXTURE_2D) !== null && _a !== void 0 ? _a : 3553;
-    return {
-        id: getNextTextureId(),
-        target: target,
-        format: 0,
-        internalFormat: 0,
-        type: 0,
-        filter: 0,
-        getWidth: function () { return 0; },
-        getHeight: function () { return 0; },
-        getDepth: function () { return 0; },
-        getByteCount: function () { return 0; },
-        define: function () { },
-        load: function () { },
-        bind: function (id) {
-            if (gl) {
-                gl.activeTexture(gl.TEXTURE0 + id);
-                gl.bindTexture(target, null);
-            }
-        },
-        unbind: function (id) {
-            if (gl) {
-                gl.activeTexture(gl.TEXTURE0 + id);
-                gl.bindTexture(target, null);
-            }
-        },
-        attachFramebuffer: function () { },
-        detachFramebuffer: function () { },
-        reset: function () { },
-        destroy: function () { },
-    };
-}
-exports.createNullTexture = createNullTexture;
-//# sourceMappingURL=texture.js.map

package/lib/commonjs/mol-gl/webgl/uniform.d.ts

@@ -1,45 +0,0 @@
-/**
- * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-import { Mat3, Mat4, Vec2, Vec3, Vec4 } from '../../mol-math/linear-algebra';
-import { ValueCell } from '../../mol-util';
-import { GLRenderingContext } from './compat';
-import { RenderableSchema } from '../../mol-gl/renderable/schema';
-import { ValueOf } from '../../mol-util/type-helpers';
-export declare type UniformKindValue = {
-    'b': boolean;
-    'b[]': boolean[];
-    'f': number;
-    'f[]': number[];
-    'i': number;
-    'i[]': number[];
-    'v2': Vec2;
-    'v2[]': number[];
-    'v3': Vec3;
-    'v3[]': number[];
-    'v4': Vec4;
-    'v4[]': number[];
-    'm3': Mat3;
-    'm3[]': number[];
-    'm4': Mat4;
-    'm4[]': number[];
-    't': number;
-    't[]': number[];
-};
-export declare type UniformKind = keyof UniformKindValue;
-export declare type UniformType = ValueOf<UniformKindValue>;
-export declare type UniformValues = {
-    [k: string]: ValueCell<UniformType>;
-};
-export declare type UniformsList = [string, ValueCell<UniformType>][];
-export declare function getUniformType(gl: GLRenderingContext, kind: UniformKind): number | undefined;
-export declare type UniformSetter = (gl: GLRenderingContext, location: number, value: any) => void;
-export declare type UniformSetters = {
-    [k: string]: UniformSetter;
-};
-export declare function getUniformSetters(schema: RenderableSchema): UniformSetters;
-export declare function getUniformGlslType(kind: UniformKind): string;
-export declare function isUniformValueScalar(kind: UniformKind): boolean;
-export declare function cloneUniformValues(uniformValues: UniformValues): UniformValues;

package/lib/commonjs/mol-gl/webgl/uniform.js

@@ -1,112 +0,0 @@
-"use strict";
-/**
- * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cloneUniformValues = exports.isUniformValueScalar = exports.getUniformGlslType = exports.getUniformSetters = exports.getUniformType = void 0;
-var mol_util_1 = require("../../mol-util");
-var object_1 = require("../../mol-util/object");
-function getUniformType(gl, kind) {
-    switch (kind) {
-        case 'b':
-        case 'b[]': return gl.BOOL;
-        case 'f':
-        case 'f[]': return gl.FLOAT;
-        case 'i':
-        case 'i[]': return gl.INT;
-        case 'v2':
-        case 'v2[]': return gl.FLOAT_VEC2;
-        case 'v3':
-        case 'v3[]': return gl.FLOAT_VEC3;
-        case 'v4':
-        case 'v4[]': return gl.FLOAT_VEC4;
-        case 'm3':
-        case 'm3[]': return gl.FLOAT_MAT3;
-        case 'm4':
-        case 'm4[]': return gl.FLOAT_MAT4;
-        default: console.error("unknown uniform kind '".concat(kind, "'"));
-    }
-}
-exports.getUniformType = getUniformType;
-function uniform1f(gl, location, value) { gl.uniform1f(location, value); }
-function uniform1fv(gl, location, value) { gl.uniform1fv(location, value); }
-function uniform1i(gl, location, value) { gl.uniform1i(location, value); }
-function uniform1iv(gl, location, value) { gl.uniform1iv(location, value); }
-function uniform2fv(gl, location, value) { gl.uniform2fv(location, value); }
-function uniform3fv(gl, location, value) { gl.uniform3fv(location, value); }
-function uniform4fv(gl, location, value) { gl.uniform4fv(location, value); }
-function uniformMatrix3fv(gl, location, value) { gl.uniformMatrix3fv(location, false, value); }
-function uniformMatrix4fv(gl, location, value) { gl.uniformMatrix4fv(location, false, value); }
-function getUniformSetter(kind) {
-    switch (kind) {
-        case 'f': return uniform1f;
-        case 'f[]': return uniform1fv;
-        case 'i':
-        case 't':
-        case 'b': return uniform1i;
-        case 'i[]':
-        case 't[]':
-        case 'b[]': return uniform1iv;
-        case 'v2':
-        case 'v2[]': return uniform2fv;
-        case 'v3':
-        case 'v3[]': return uniform3fv;
-        case 'v4':
-        case 'v4[]': return uniform4fv;
-        case 'm3':
-        case 'm3[]': return uniformMatrix3fv;
-        case 'm4':
-        case 'm4[]': return uniformMatrix4fv;
-    }
-}
-function getUniformSetters(schema) {
-    var setters = {};
-    Object.keys(schema).forEach(function (k) {
-        var spec = schema[k];
-        if (spec.type === 'uniform') {
-            setters[k] = getUniformSetter(spec.kind);
-        }
-        else if (spec.type === 'texture') {
-            setters[k] = getUniformSetter('t');
-        }
-    });
-    return setters;
-}
-exports.getUniformSetters = getUniformSetters;
-function getUniformGlslType(kind) {
-    switch (kind) {
-        case 'f': return 'float';
-        case 'i': return 'int';
-        case 't': return 'sampler2D';
-        case 'b': return 'bool';
-        case 'v2': return 'vec2';
-        case 'v3': return 'vec3';
-        case 'v4': return 'vec4';
-        case 'm3': return 'mat3';
-        case 'm4': return 'mat4';
-    }
-    throw new Error("".concat(kind, " has no primitive GLSL type."));
-}
-exports.getUniformGlslType = getUniformGlslType;
-function isUniformValueScalar(kind) {
-    switch (kind) {
-        case 'f':
-        case 'i':
-        case 'b':
-            return true;
-        default:
-            return false;
-    }
-}
-exports.isUniformValueScalar = isUniformValueScalar;
-function cloneUniformValues(uniformValues) {
-    var clonedValues = {};
-    Object.keys(uniformValues).forEach(function (k) {
-        clonedValues[k] = mol_util_1.ValueCell.create((0, object_1.deepClone)(uniformValues[k].ref.value));
-    });
-    return clonedValues;
-}
-exports.cloneUniformValues = cloneUniformValues;
-//# sourceMappingURL=uniform.js.map

package/lib/commonjs/mol-gl/webgl/vertex-array.d.ts

@@ -1,17 +0,0 @@
-/**
- * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-import { Program } from './program';
-import { ElementsBuffer, AttributeBuffers } from './buffer';
-import { WebGLExtensions } from './extensions';
-import { GLRenderingContext } from './compat';
-export interface VertexArray {
-    readonly id: number;
-    bind: () => void;
-    update: () => void;
-    reset: () => void;
-    destroy: () => void;
-}
-export declare function createVertexArray(gl: GLRenderingContext, extensions: WebGLExtensions, program: Program, attributeBuffers: AttributeBuffers, elementsBuffer?: ElementsBuffer): VertexArray;