molstar 3.0.0 → 3.0.1

package/lib/commonjs/mol-gl/shader-code.js

@@ -1,281 +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.addShaderDefines = exports.ImageShaderCode = exports.DirectVolumeShaderCode = exports.MeshShaderCode = exports.LinesShaderCode = exports.TextShaderCode = exports.CylindersShaderCode = exports.SpheresShaderCode = exports.PointsShaderCode = exports.ShaderCode = void 0;
-var id_factory_1 = require("../mol-util/id-factory");
-var compat_1 = require("./webgl/compat");
-var shaderCodeId = (0, id_factory_1.idFactory)();
-var apply_fog_glsl_1 = require("./shader/chunks/apply-fog.glsl");
-var apply_interior_color_glsl_1 = require("./shader/chunks/apply-interior-color.glsl");
-var apply_light_color_glsl_1 = require("./shader/chunks/apply-light-color.glsl");
-var apply_marker_color_glsl_1 = require("./shader/chunks/apply-marker-color.glsl");
-var assign_clipping_varying_glsl_1 = require("./shader/chunks/assign-clipping-varying.glsl");
-var assign_color_varying_glsl_1 = require("./shader/chunks/assign-color-varying.glsl");
-var assign_group_glsl_1 = require("./shader/chunks/assign-group.glsl");
-var assign_marker_varying_glsl_1 = require("./shader/chunks/assign-marker-varying.glsl");
-var assign_material_color_glsl_1 = require("./shader/chunks/assign-material-color.glsl");
-var assign_position_glsl_1 = require("./shader/chunks/assign-position.glsl");
-var assign_size_glsl_1 = require("./shader/chunks/assign-size.glsl");
-var check_picking_alpha_glsl_1 = require("./shader/chunks/check-picking-alpha.glsl");
-var clip_instance_glsl_1 = require("./shader/chunks/clip-instance.glsl");
-var clip_pixel_glsl_1 = require("./shader/chunks/clip-pixel.glsl");
-var color_frag_params_glsl_1 = require("./shader/chunks/color-frag-params.glsl");
-var color_vert_params_glsl_1 = require("./shader/chunks/color-vert-params.glsl");
-var common_clip_glsl_1 = require("./shader/chunks/common-clip.glsl");
-var common_frag_params_glsl_1 = require("./shader/chunks/common-frag-params.glsl");
-var common_vert_params_glsl_1 = require("./shader/chunks/common-vert-params.glsl");
-var common_glsl_1 = require("./shader/chunks/common.glsl");
-var float_to_rgba_glsl_1 = require("./shader/chunks/float-to-rgba.glsl");
-var light_frag_params_glsl_1 = require("./shader/chunks/light-frag-params.glsl");
-var matrix_scale_glsl_1 = require("./shader/chunks/matrix-scale.glsl");
-var normal_frag_params_glsl_1 = require("./shader/chunks/normal-frag-params.glsl");
-var read_from_texture_glsl_1 = require("./shader/chunks/read-from-texture.glsl");
-var rgba_to_float_glsl_1 = require("./shader/chunks/rgba-to-float.glsl");
-var size_vert_params_glsl_1 = require("./shader/chunks/size-vert-params.glsl");
-var texture3d_from_1d_trilinear_glsl_1 = require("./shader/chunks/texture3d-from-1d-trilinear.glsl");
-var texture3d_from_2d_linear_glsl_1 = require("./shader/chunks/texture3d-from-2d-linear.glsl");
-var texture3d_from_2d_nearest_glsl_1 = require("./shader/chunks/texture3d-from-2d-nearest.glsl");
-var wboit_write_glsl_1 = require("./shader/chunks/wboit-write.glsl");
-var ShaderChunks = {
-    apply_fog: apply_fog_glsl_1.apply_fog,
-    apply_interior_color: apply_interior_color_glsl_1.apply_interior_color,
-    apply_light_color: apply_light_color_glsl_1.apply_light_color,
-    apply_marker_color: apply_marker_color_glsl_1.apply_marker_color,
-    assign_clipping_varying: assign_clipping_varying_glsl_1.assign_clipping_varying,
-    assign_color_varying: assign_color_varying_glsl_1.assign_color_varying,
-    assign_group: assign_group_glsl_1.assign_group,
-    assign_marker_varying: assign_marker_varying_glsl_1.assign_marker_varying,
-    assign_material_color: assign_material_color_glsl_1.assign_material_color,
-    assign_position: assign_position_glsl_1.assign_position,
-    assign_size: assign_size_glsl_1.assign_size,
-    check_picking_alpha: check_picking_alpha_glsl_1.check_picking_alpha,
-    clip_instance: clip_instance_glsl_1.clip_instance,
-    clip_pixel: clip_pixel_glsl_1.clip_pixel,
-    color_frag_params: color_frag_params_glsl_1.color_frag_params,
-    color_vert_params: color_vert_params_glsl_1.color_vert_params,
-    common_clip: common_clip_glsl_1.common_clip,
-    common_frag_params: common_frag_params_glsl_1.common_frag_params,
-    common_vert_params: common_vert_params_glsl_1.common_vert_params,
-    common: common_glsl_1.common,
-    float_to_rgba: float_to_rgba_glsl_1.float_to_rgba,
-    light_frag_params: light_frag_params_glsl_1.light_frag_params,
-    matrix_scale: matrix_scale_glsl_1.matrix_scale,
-    normal_frag_params: normal_frag_params_glsl_1.normal_frag_params,
-    read_from_texture: read_from_texture_glsl_1.read_from_texture,
-    rgba_to_float: rgba_to_float_glsl_1.rgba_to_float,
-    size_vert_params: size_vert_params_glsl_1.size_vert_params,
-    texture3d_from_1d_trilinear: texture3d_from_1d_trilinear_glsl_1.texture3d_from_1d_trilinear,
-    texture3d_from_2d_linear: texture3d_from_2d_linear_glsl_1.texture3d_from_2d_linear,
-    texture3d_from_2d_nearest: texture3d_from_2d_nearest_glsl_1.texture3d_from_2d_nearest,
-    wboit_write: wboit_write_glsl_1.wboit_write
-};
-var reInclude = /^(?!\/\/)\s*#include\s+(\S+)/gm;
-var reUnrollLoop = /#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*\+\+i\s*\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;
-var reSingleLineComment = /[ \t]*\/\/.*\n/g;
-var reMultiLineComment = /[ \t]*\/\*[\s\S]*?\*\//g;
-var reMultipleLinebreaks = /\n{2,}/g;
-function addIncludes(text) {
-    return text
-        .replace(reInclude, function (_, p1) {
-        var chunk = ShaderChunks[p1];
-        if (!chunk)
-            throw new Error("empty chunk, '".concat(p1, "'"));
-        return chunk;
-    })
-        .trim()
-        .replace(reSingleLineComment, '\n')
-        .replace(reMultiLineComment, '\n')
-        .replace(reMultipleLinebreaks, '\n');
-}
-function unrollLoops(str) {
-    return str.replace(reUnrollLoop, loopReplacer);
-}
-function loopReplacer(match, start, end, snippet) {
-    var out = '';
-    for (var i = parseInt(start); i < parseInt(end); ++i) {
-        out += snippet
-            .replace(/\[\s*i\s*\]/g, "[".concat(i, "]"))
-            .replace(/UNROLLED_LOOP_INDEX/g, "".concat(i));
-    }
-    return out;
-}
-function replaceCounts(str, defines) {
-    if (defines.dLightCount)
-        str = str.replace(/dLightCount/g, "".concat(defines.dLightCount.ref.value));
-    if (defines.dClipObjectCount)
-        str = str.replace(/dClipObjectCount/g, "".concat(defines.dClipObjectCount.ref.value));
-    return str;
-}
-function preprocess(str, defines) {
-    return unrollLoops(replaceCounts(str, defines));
-}
-function ShaderCode(name, vert, frag, extensions, outTypes, ignoreDefine) {
-    if (extensions === void 0) { extensions = {}; }
-    if (outTypes === void 0) { outTypes = {}; }
-    return { id: shaderCodeId(), name: name, vert: addIncludes(vert), frag: addIncludes(frag), extensions: extensions, outTypes: outTypes, ignoreDefine: ignoreDefine };
-}
-exports.ShaderCode = ShaderCode;
-// Note: `drawBuffers` need to be 'optional' for wboit
-function ignoreDefine(name, variant, defines) {
-    var _a;
-    if (variant.startsWith('color')) {
-        if (name === 'dLightCount') {
-            return !!((_a = defines.dIgnoreLight) === null || _a === void 0 ? void 0 : _a.ref.value);
-        }
-    }
-    else {
-        return [
-            'dColorType', 'dUsePalette',
-            'dLightCount',
-            'dOverpaintType', 'dOverpaint',
-            'dSubstanceType', 'dSubstance',
-        ].includes(name);
-    }
-    return false;
-}
-;
-function ignoreDefineUnlit(name, variant, defines) {
-    if (name === 'dLightCount')
-        return true;
-    return ignoreDefine(name, variant, defines);
-}
-;
-var points_vert_1 = require("./shader/points.vert");
-var points_frag_1 = require("./shader/points.frag");
-exports.PointsShaderCode = ShaderCode('points', points_vert_1.points_vert, points_frag_1.points_frag, { drawBuffers: 'optional' }, {}, ignoreDefineUnlit);
-var spheres_vert_1 = require("./shader/spheres.vert");
-var spheres_frag_1 = require("./shader/spheres.frag");
-exports.SpheresShaderCode = ShaderCode('spheres', spheres_vert_1.spheres_vert, spheres_frag_1.spheres_frag, { fragDepth: 'required', drawBuffers: 'optional' }, {}, ignoreDefine);
-var cylinders_vert_1 = require("./shader/cylinders.vert");
-var cylinders_frag_1 = require("./shader/cylinders.frag");
-exports.CylindersShaderCode = ShaderCode('cylinders', cylinders_vert_1.cylinders_vert, cylinders_frag_1.cylinders_frag, { fragDepth: 'required', drawBuffers: 'optional' }, {}, ignoreDefine);
-var text_vert_1 = require("./shader/text.vert");
-var text_frag_1 = require("./shader/text.frag");
-exports.TextShaderCode = ShaderCode('text', text_vert_1.text_vert, text_frag_1.text_frag, { drawBuffers: 'optional' }, {}, ignoreDefineUnlit);
-var lines_vert_1 = require("./shader/lines.vert");
-var lines_frag_1 = require("./shader/lines.frag");
-exports.LinesShaderCode = ShaderCode('lines', lines_vert_1.lines_vert, lines_frag_1.lines_frag, { drawBuffers: 'optional' }, {}, ignoreDefineUnlit);
-var mesh_vert_1 = require("./shader/mesh.vert");
-var mesh_frag_1 = require("./shader/mesh.frag");
-exports.MeshShaderCode = ShaderCode('mesh', mesh_vert_1.mesh_vert, mesh_frag_1.mesh_frag, { drawBuffers: 'optional' }, {}, ignoreDefine);
-var direct_volume_vert_1 = require("./shader/direct-volume.vert");
-var direct_volume_frag_1 = require("./shader/direct-volume.frag");
-exports.DirectVolumeShaderCode = ShaderCode('direct-volume', direct_volume_vert_1.directVolume_vert, direct_volume_frag_1.directVolume_frag, { fragDepth: 'optional', drawBuffers: 'optional' }, {}, ignoreDefine);
-var image_vert_1 = require("./shader/image.vert");
-var image_frag_1 = require("./shader/image.frag");
-exports.ImageShaderCode = ShaderCode('image', image_vert_1.image_vert, image_frag_1.image_frag, { drawBuffers: 'optional' }, {}, ignoreDefineUnlit);
-function getDefinesCode(defines, ignore) {
-    var _a;
-    if (defines === undefined)
-        return '';
-    var variant = (((_a = defines.dRenderVariant) === null || _a === void 0 ? void 0 : _a.ref.value) || '');
-    var lines = [];
-    for (var name_1 in defines) {
-        if (ignore === null || ignore === void 0 ? void 0 : ignore(name_1, variant, defines))
-            continue;
-        var define = defines[name_1];
-        var v = define.ref.value;
-        if (v !== undefined) {
-            if (typeof v === 'string') {
-                lines.push("#define ".concat(name_1, "_").concat(v));
-            }
-            else if (typeof v === 'number') {
-                lines.push("#define ".concat(name_1, " ").concat(v));
-            }
-            else if (typeof v === 'boolean') {
-                if (v)
-                    lines.push("#define ".concat(name_1));
-            }
-            else {
-                throw new Error('unknown define type');
-            }
-        }
-    }
-    return lines.join('\n') + '\n';
-}
-function getGlsl100FragPrefix(extensions, shaderExtensions) {
-    var prefix = [
-        '#extension GL_OES_standard_derivatives : enable'
-    ];
-    if (shaderExtensions.fragDepth) {
-        if (extensions.fragDepth) {
-            prefix.push('#extension GL_EXT_frag_depth : enable');
-            prefix.push('#define enabledFragDepth');
-        }
-        else if (shaderExtensions.fragDepth === 'required') {
-            throw new Error("required 'GL_EXT_frag_depth' extension not available");
-        }
-    }
-    if (shaderExtensions.drawBuffers) {
-        if (extensions.drawBuffers) {
-            prefix.push('#extension GL_EXT_draw_buffers : require');
-            prefix.push('#define requiredDrawBuffers');
-            prefix.push('#define gl_FragColor gl_FragData[0]');
-        }
-        else if (shaderExtensions.drawBuffers === 'required') {
-            throw new Error("required 'GL_EXT_draw_buffers' extension not available");
-        }
-    }
-    if (shaderExtensions.shaderTextureLod) {
-        if (extensions.shaderTextureLod) {
-            prefix.push('#extension GL_EXT_shader_texture_lod : enable');
-            prefix.push('#define enabledShaderTextureLod');
-        }
-        else if (shaderExtensions.shaderTextureLod === 'required') {
-            throw new Error("required 'GL_EXT_shader_texture_lod' extension not available");
-        }
-    }
-    if (extensions.depthTexture) {
-        prefix.push('#define depthTextureSupport');
-    }
-    return prefix.join('\n') + '\n';
-}
-var glsl300VertPrefix = "#version 300 es\n#define attribute in\n#define varying out\n#define texture2D texture\n";
-var glsl300FragPrefixCommon = "\n#define varying in\n#define texture2D texture\n#define texture2DLodEXT textureLod\n\n#define gl_FragColor out_FragData0\n#define gl_FragDepthEXT gl_FragDepth\n\n#define depthTextureSupport\n";
-function getGlsl300FragPrefix(gl, extensions, shaderExtensions, outTypes) {
-    var prefix = [
-        '#version 300 es',
-        "layout(location = 0) out highp ".concat(outTypes[0] || 'vec4', " out_FragData0;")
-    ];
-    if (shaderExtensions.fragDepth) {
-        prefix.push('#define enabledFragDepth');
-    }
-    if (shaderExtensions.drawBuffers) {
-        prefix.push('#define requiredDrawBuffers');
-        var maxDrawBuffers = gl.getParameter(gl.MAX_DRAW_BUFFERS);
-        for (var i = 1, il = maxDrawBuffers; i < il; ++i) {
-            prefix.push("layout(location = ".concat(i, ") out highp ").concat(outTypes[i] || 'vec4', " out_FragData").concat(i, ";"));
-        }
-    }
-    if (shaderExtensions.shaderTextureLod) {
-        prefix.push('#define enabledShaderTextureLod');
-    }
-    prefix.push(glsl300FragPrefixCommon);
-    return prefix.join('\n') + '\n';
-}
-function transformGlsl300Frag(frag) {
-    return frag.replace(/gl_FragData\[([0-9]+)\]/g, 'out_FragData$1');
-}
-function addShaderDefines(gl, extensions, defines, shaders) {
-    var vertHeader = getDefinesCode(defines, shaders.ignoreDefine);
-    var fragHeader = getDefinesCode(defines, shaders.ignoreDefine);
-    var vertPrefix = (0, compat_1.isWebGL2)(gl) ? glsl300VertPrefix : '';
-    var fragPrefix = (0, compat_1.isWebGL2)(gl)
-        ? getGlsl300FragPrefix(gl, extensions, shaders.extensions, shaders.outTypes)
-        : getGlsl100FragPrefix(extensions, shaders.extensions);
-    var frag = (0, compat_1.isWebGL2)(gl) ? transformGlsl300Frag(shaders.frag) : shaders.frag;
-    return {
-        id: shaderCodeId(),
-        name: shaders.name,
-        vert: "".concat(vertPrefix).concat(vertHeader).concat(preprocess(shaders.vert, defines)),
-        frag: "".concat(fragPrefix).concat(fragHeader).concat(preprocess(frag, defines)),
-        extensions: shaders.extensions,
-        outTypes: shaders.outTypes
-    };
-}
-exports.addShaderDefines = addShaderDefines;
-//# sourceMappingURL=shader-code.js.map

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

@@ -1,67 +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 { ValueCell } from '../../mol-util';
-import { RenderableSchema } from '../renderable/schema';
-import { ValueOf } from '../../mol-util/type-helpers';
-import { GLRenderingContext } from './compat';
-import { WebGLExtensions } from './extensions';
-import { WebGLState } from './state';
-export declare type UsageHint = 'static' | 'dynamic' | 'stream';
-export declare type DataType = 'uint8' | 'int8' | 'uint16' | 'int16' | 'uint32' | 'int32' | 'float32';
-export declare type BufferType = 'attribute' | 'elements' | 'uniform';
-export declare type DataTypeArrayType = {
-    'uint8': Uint8Array;
-    'int8': Int8Array;
-    'uint16': Uint16Array;
-    'int16': Int16Array;
-    'uint32': Uint32Array;
-    'int32': Int32Array;
-    'float32': Float32Array;
-};
-export declare type ArrayType = ValueOf<DataTypeArrayType>;
-export declare type ArrayKind = keyof DataTypeArrayType;
-export declare function getUsageHint(gl: GLRenderingContext, usageHint: UsageHint): number;
-export declare function getDataType(gl: GLRenderingContext, dataType: DataType): number;
-export declare function getBufferType(gl: GLRenderingContext, bufferType: BufferType): number;
-export interface Buffer {
-    readonly id: number;
-    readonly _usageHint: number;
-    readonly _bufferType: number;
-    readonly _dataType: number;
-    readonly _bpe: number;
-    readonly length: number;
-    getBuffer: () => WebGLBuffer;
-    updateData: (array: ArrayType) => void;
-    updateSubData: (array: ArrayType, offset: number, count: number) => void;
-    reset: () => void;
-    destroy: () => void;
-}
-export declare type AttributeItemSize = 1 | 2 | 3 | 4 | 16;
-export declare type AttributeKind = 'float32' | 'int32';
-export declare function getAttribType(gl: GLRenderingContext, kind: AttributeKind, itemSize: AttributeItemSize): number;
-export declare type AttributeDefs = {
-    [k: string]: {
-        kind: AttributeKind;
-        itemSize: AttributeItemSize;
-        divisor: number;
-    };
-};
-export declare type AttributeValues = {
-    [k: string]: ValueCell<ArrayType>;
-};
-export declare type AttributeBuffers = [string, AttributeBuffer][];
-export interface AttributeBuffer extends Buffer {
-    bind: (location: number) => void;
-}
-export declare function createAttributeBuffer<T extends ArrayType, S extends AttributeItemSize>(gl: GLRenderingContext, state: WebGLState, extensions: WebGLExtensions, array: T, itemSize: S, divisor: number, usageHint?: UsageHint): AttributeBuffer;
-export declare function createAttributeBuffers(ctx: WebGLContext, schema: RenderableSchema, values: AttributeValues): AttributeBuffers;
-export declare type ElementsType = Uint16Array | Uint32Array;
-export declare type ElementsKind = 'uint16' | 'uint32';
-export interface ElementsBuffer extends Buffer {
-    bind: () => void;
-}
-export declare function createElementsBuffer(gl: GLRenderingContext, array: ElementsType, usageHint?: UsageHint): ElementsBuffer;

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

@@ -1,180 +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.createElementsBuffer = exports.createAttributeBuffers = exports.createAttributeBuffer = exports.getAttribType = exports.getBufferType = exports.getDataType = exports.getUsageHint = void 0;
-var tslib_1 = require("tslib");
-var id_factory_1 = require("../../mol-util/id-factory");
-var getNextBufferId = (0, id_factory_1.idFactory)();
-function getUsageHint(gl, usageHint) {
-    switch (usageHint) {
-        case 'static': return gl.STATIC_DRAW;
-        case 'dynamic': return gl.DYNAMIC_DRAW;
-        case 'stream': return gl.STREAM_DRAW;
-    }
-}
-exports.getUsageHint = getUsageHint;
-function getDataType(gl, dataType) {
-    switch (dataType) {
-        case 'uint8': return gl.UNSIGNED_BYTE;
-        case 'int8': return gl.BYTE;
-        case 'uint16': return gl.UNSIGNED_SHORT;
-        case 'int16': return gl.SHORT;
-        case 'uint32': return gl.UNSIGNED_INT;
-        case 'int32': return gl.INT;
-        case 'float32': return gl.FLOAT;
-    }
-}
-exports.getDataType = getDataType;
-function dataTypeFromArray(gl, array) {
-    if (array instanceof Uint8Array) {
-        return gl.UNSIGNED_BYTE;
-    }
-    else if (array instanceof Int8Array) {
-        return gl.BYTE;
-    }
-    else if (array instanceof Uint16Array) {
-        return gl.UNSIGNED_SHORT;
-    }
-    else if (array instanceof Int16Array) {
-        return gl.SHORT;
-    }
-    else if (array instanceof Uint32Array) {
-        return gl.UNSIGNED_INT;
-    }
-    else if (array instanceof Int32Array) {
-        return gl.INT;
-    }
-    else if (array instanceof Float32Array) {
-        return gl.FLOAT;
-    }
-    else {
-        throw new Error('Should nevver happen');
-    }
-}
-function getBufferType(gl, bufferType) {
-    switch (bufferType) {
-        case 'attribute': return gl.ARRAY_BUFFER;
-        case 'elements': return gl.ELEMENT_ARRAY_BUFFER;
-        case 'uniform': return gl.UNIFORM_BUFFER;
-    }
-}
-exports.getBufferType = getBufferType;
-function getBuffer(gl) {
-    var buffer = gl.createBuffer();
-    if (buffer === null) {
-        throw new Error('Could not create WebGL buffer');
-    }
-    return buffer;
-}
-function createBuffer(gl, array, usageHint, bufferType) {
-    var _buffer = getBuffer(gl);
-    var _usageHint = getUsageHint(gl, usageHint);
-    var _bufferType = getBufferType(gl, bufferType);
-    var _dataType = dataTypeFromArray(gl, array);
-    var _bpe = array.BYTES_PER_ELEMENT;
-    var _length = array.length;
-    function updateData(array) {
-        gl.bindBuffer(_bufferType, _buffer);
-        gl.bufferData(_bufferType, array, _usageHint);
-    }
-    updateData(array);
-    var destroyed = false;
-    return {
-        id: getNextBufferId(),
-        _usageHint: _usageHint,
-        _bufferType: _bufferType,
-        _dataType: _dataType,
-        _bpe: _bpe,
-        length: _length,
-        getBuffer: function () { return _buffer; },
-        updateData: updateData,
-        updateSubData: function (array, offset, count) {
-            gl.bindBuffer(_bufferType, _buffer);
-            if (count - offset === array.length) {
-                gl.bufferSubData(_bufferType, 0, array);
-            }
-            else {
-                gl.bufferSubData(_bufferType, offset * _bpe, array.subarray(offset, offset + count));
-            }
-        },
-        reset: function () {
-            _buffer = getBuffer(gl);
-            updateData(array);
-        },
-        destroy: function () {
-            if (destroyed)
-                return;
-            gl.deleteBuffer(_buffer);
-            destroyed = true;
-        }
-    };
-}
-function getAttribType(gl, kind, itemSize) {
-    switch (kind) {
-        case 'int32':
-            switch (itemSize) {
-                case 1: return gl.INT;
-                case 2: return gl.INT_VEC2;
-                case 3: return gl.INT_VEC3;
-                case 4: return gl.INT_VEC4;
-            }
-            break;
-        case 'float32':
-            switch (itemSize) {
-                case 1: return gl.FLOAT;
-                case 2: return gl.FLOAT_VEC2;
-                case 3: return gl.FLOAT_VEC3;
-                case 4: return gl.FLOAT_VEC4;
-                case 16: return gl.FLOAT_MAT4;
-            }
-            break;
-    }
-    throw new Error("unknown attribute type for kind '".concat(kind, "' and itemSize '").concat(itemSize, "'"));
-}
-exports.getAttribType = getAttribType;
-function createAttributeBuffer(gl, state, extensions, array, itemSize, divisor, usageHint) {
-    if (usageHint === void 0) { usageHint = 'dynamic'; }
-    var instancedArrays = extensions.instancedArrays;
-    var buffer = createBuffer(gl, array, usageHint, 'attribute');
-    var _bufferType = buffer._bufferType, _dataType = buffer._dataType, _bpe = buffer._bpe;
-    return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, buffer), { bind: function (location) {
-            gl.bindBuffer(_bufferType, buffer.getBuffer());
-            if (itemSize === 16) {
-                for (var i = 0; i < 4; ++i) {
-                    state.enableVertexAttrib(location + i);
-                    gl.vertexAttribPointer(location + i, 4, _dataType, false, 4 * 4 * _bpe, i * 4 * _bpe);
-                    instancedArrays.vertexAttribDivisor(location + i, divisor);
-                }
-            }
-            else {
-                state.enableVertexAttrib(location);
-                gl.vertexAttribPointer(location, itemSize, _dataType, false, 0, 0);
-                instancedArrays.vertexAttribDivisor(location, divisor);
-            }
-        } });
-}
-exports.createAttributeBuffer = createAttributeBuffer;
-function createAttributeBuffers(ctx, schema, values) {
-    var buffers = [];
-    Object.keys(schema).forEach(function (k) {
-        var spec = schema[k];
-        if (spec.type === 'attribute') {
-            buffers[buffers.length] = [k, ctx.resources.attribute(values[k].ref.value, spec.itemSize, spec.divisor)];
-        }
-    });
-    return buffers;
-}
-exports.createAttributeBuffers = createAttributeBuffers;
-function createElementsBuffer(gl, array, usageHint) {
-    if (usageHint === void 0) { usageHint = 'static'; }
-    var buffer = createBuffer(gl, array, usageHint, 'elements');
-    return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, buffer), { bind: function () {
-            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer.getBuffer());
-        } });
-}
-exports.createElementsBuffer = createElementsBuffer;
-//# sourceMappingURL=buffer.js.map

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

@@ -1,96 +0,0 @@
-/**
- * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-export declare type GLRenderingContext = WebGLRenderingContext | WebGL2RenderingContext;
-export declare function isWebGL(gl: any): gl is WebGLRenderingContext;
-export declare function isWebGL2(gl: any): gl is WebGL2RenderingContext;
-export interface COMPAT_instanced_arrays {
-    drawArraysInstanced(mode: number, first: number, count: number, primcount: number): void;
-    drawElementsInstanced(mode: number, count: number, type: number, offset: number, primcount: number): void;
-    vertexAttribDivisor(index: number, divisor: number): void;
-    readonly VERTEX_ATTRIB_ARRAY_DIVISOR: number;
-}
-export declare function getInstancedArrays(gl: GLRenderingContext): COMPAT_instanced_arrays | null;
-export interface COMPAT_standard_derivatives {
-    readonly FRAGMENT_SHADER_DERIVATIVE_HINT: number;
-}
-export declare function getStandardDerivatives(gl: GLRenderingContext): COMPAT_standard_derivatives | null;
-export interface COMPAT_element_index_uint {
-}
-export declare function getElementIndexUint(gl: GLRenderingContext): COMPAT_element_index_uint | null;
-export interface COMPAT_vertex_array_object {
-    readonly VERTEX_ARRAY_BINDING: number;
-    bindVertexArray(arrayObject: WebGLVertexArrayObject | null): void;
-    createVertexArray(): WebGLVertexArrayObject | null;
-    deleteVertexArray(arrayObject: WebGLVertexArrayObject): void;
-    isVertexArray(value: any): value is WebGLVertexArrayObject;
-}
-export declare function getVertexArrayObject(gl: GLRenderingContext): COMPAT_vertex_array_object | null;
-export interface COMPAT_texture_float {
-}
-export declare function getTextureFloat(gl: GLRenderingContext): COMPAT_texture_float | null;
-export interface COMPAT_texture_float_linear {
-}
-export declare function getTextureFloatLinear(gl: GLRenderingContext): COMPAT_texture_float_linear | null;
-export interface COMPAT_texture_half_float {
-    readonly HALF_FLOAT: number;
-}
-export declare function getTextureHalfFloat(gl: GLRenderingContext): COMPAT_texture_half_float | null;
-export interface COMPAT_texture_half_float_linear {
-}
-export declare function getTextureHalfFloatLinear(gl: GLRenderingContext): COMPAT_texture_half_float_linear | null;
-export interface COMPAT_blend_minmax {
-    readonly MIN: number;
-    readonly MAX: number;
-}
-export declare function getBlendMinMax(gl: GLRenderingContext): COMPAT_blend_minmax | null;
-export interface COMPAT_frag_depth {
-}
-export declare function getFragDepth(gl: GLRenderingContext): COMPAT_frag_depth | null;
-export interface COMPAT_color_buffer_float {
-    readonly RGBA32F: number;
-}
-export declare function getColorBufferFloat(gl: GLRenderingContext): COMPAT_color_buffer_float | null;
-export interface COMPAT_color_buffer_half_float {
-    readonly RGBA16F: number;
-}
-export declare function getColorBufferHalfFloat(gl: GLRenderingContext): COMPAT_color_buffer_half_float | null;
-export interface COMPAT_draw_buffers {
-    drawBuffers(buffers: number[]): void;
-    readonly COLOR_ATTACHMENT0: number;
-    readonly COLOR_ATTACHMENT1: number;
-    readonly COLOR_ATTACHMENT2: number;
-    readonly COLOR_ATTACHMENT3: number;
-    readonly COLOR_ATTACHMENT4: number;
-    readonly COLOR_ATTACHMENT5: number;
-    readonly COLOR_ATTACHMENT6: number;
-    readonly COLOR_ATTACHMENT7: number;
-    readonly DRAW_BUFFER0: number;
-    readonly DRAW_BUFFER1: number;
-    readonly DRAW_BUFFER2: number;
-    readonly DRAW_BUFFER3: number;
-    readonly DRAW_BUFFER4: number;
-    readonly DRAW_BUFFER5: number;
-    readonly DRAW_BUFFER6: number;
-    readonly DRAW_BUFFER7: number;
-    readonly MAX_COLOR_ATTACHMENTS: number;
-    readonly MAX_DRAW_BUFFERS: number;
-}
-export declare function getDrawBuffers(gl: GLRenderingContext): COMPAT_draw_buffers | null;
-export interface COMPAT_shader_texture_lod {
-}
-export declare function getShaderTextureLod(gl: GLRenderingContext): COMPAT_shader_texture_lod | null;
-export interface COMPAT_depth_texture {
-    readonly UNSIGNED_INT_24_8: number;
-}
-export declare function getDepthTexture(gl: GLRenderingContext): COMPAT_depth_texture | null;
-export interface COMPAT_sRGB {
-    readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: number;
-    readonly SRGB8_ALPHA8: number;
-    readonly SRGB8: number;
-    readonly SRGB: number;
-}
-export declare function getSRGB(gl: GLRenderingContext): COMPAT_sRGB | null;
-export declare function testColorBuffer(gl: GLRenderingContext, type: number): boolean;