webglimpse
Version:
Webglimpse is a data visualization library for the web.
131 lines • 17.6 kB
JavaScript
/*
* Copyright (c) 2014, Metron, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
import { GL, getObjectId, hasval } from './util/util';
export function newStaticBuffer(data) {
return new StaticBufferImpl(data);
}
export function newDynamicBuffer(data = new Float32Array(0)) {
return new DynamicBufferImpl(data);
}
class BufferEntry {
constructor(gl, buffer) {
this.capacity = 0;
this.marker = null;
this.gl = gl;
this.buffer = buffer;
}
}
class AbstractBuffer {
constructor() {
this.buffers = {};
this.currentMarker = 0;
}
init(gl, target) {
throw new Error('Method is abstract');
}
update(gl, target, capacity) {
throw new Error('Method is abstract');
}
setDirty() {
this.currentMarker++;
}
bind(gl, target) {
const glId = getObjectId(gl);
if (this.buffers[glId] === undefined) {
const buffer = gl.createBuffer();
if (!hasval(buffer)) {
throw new Error('Failed to create buffer');
}
this.buffers[glId] = new BufferEntry(gl, buffer);
gl.bindBuffer(target, this.buffers[glId].buffer);
this.buffers[glId].capacity = this.init(gl, target);
this.buffers[glId].marker = this.currentMarker;
}
else if (this.buffers[glId].marker !== this.currentMarker) {
gl.bindBuffer(target, this.buffers[glId].buffer);
this.buffers[glId].capacity = this.update(gl, target, this.buffers[glId].capacity);
this.buffers[glId].marker = this.currentMarker;
}
else {
gl.bindBuffer(target, this.buffers[glId].buffer);
}
}
unbind(gl, target) {
gl.bindBuffer(target, null);
}
dispose() {
// XXX: Not sure this actually works ... may have to make each gl current or something
for (const glid in this.buffers) {
if (this.buffers.hasOwnProperty(glid)) {
const en = this.buffers[glid];
en.gl.deleteBuffer(en.buffer);
}
}
this.buffers = {};
}
}
class StaticBufferImpl extends AbstractBuffer {
constructor(data) {
super();
this._data = data;
}
init(gl, target) {
gl.bufferData(target, this._data, GL.STATIC_DRAW);
return this._data.byteLength;
}
update(gl, target, capacity) {
throw new Error('This buffer is static and should never need to be updated');
}
}
class DynamicBufferImpl extends AbstractBuffer {
constructor(data) {
super();
this._data = data;
}
setData(data) {
this._data = data;
this.setDirty();
}
init(gl, target) {
gl.bufferData(target, this._data, GL.DYNAMIC_DRAW);
return this._data.byteLength;
}
update(gl, target, capacity) {
if (this._data.byteLength <= capacity) {
gl.bufferSubData(target, 0, this._data);
return capacity;
}
else {
gl.bufferData(target, this._data, GL.DYNAMIC_DRAW);
return this._data.byteLength;
}
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"buffer.js","sourceRoot":"","sources":["../../../src/webglimpse/buffer.ts"],"names":[],"mappings":"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","sourcesContent":["/*\r\n * Copyright (c) 2014, Metron, Inc.\r\n * All rights reserved.\r\n *\r\n * Redistribution and use in source and binary forms, with or without modification,\r\n * are permitted provided that the following conditions are met:\r\n *\r\n * 1. Redistributions of source code must retain the above copyright notice, this\r\n *    list of conditions and the following disclaimer.\r\n *\r\n * 2. Redistributions in binary form must reproduce the above copyright notice,\r\n *    this list of conditions and the following disclaimer in the documentation\r\n *    and/or other materials provided with the distribution.\r\n *\r\n * 3. Neither the name of the copyright holder nor the names of its contributors\r\n *    may be used to endorse or promote products derived from this software without\r\n *    specific prior written permission.\r\n *\r\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\r\n * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\n * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR\r\n * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\n * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON\r\n * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\n * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n */\r\nimport { StringMap, GL, getObjectId, hasval } from './util/util';\r\n\r\nexport interface Buffer {\r\n    bind(gl: WebGLRenderingContext, target: number): void;\r\n    unbind(gl: WebGLRenderingContext, target: number): void;\r\n    dispose(): void;\r\n}\r\n\r\nexport interface DynamicBuffer extends Buffer {\r\n    setData(newData: Float32Array): void;\r\n}\r\n\r\nexport function newStaticBuffer(data: Float32Array): Buffer {\r\n    return new StaticBufferImpl(data);\r\n}\r\n\r\nexport function newDynamicBuffer(data: Float32Array = new Float32Array(0)): DynamicBuffer {\r\n    return new DynamicBufferImpl(data);\r\n}\r\n\r\n\r\nclass BufferEntry {\r\n    gl: WebGLRenderingContext;\r\n    buffer: WebGLBuffer;\r\n    capacity = 0;\r\n    marker: number = null;\r\n\r\n    constructor(gl: WebGLRenderingContext, buffer: WebGLBuffer) {\r\n        this.gl = gl;\r\n        this.buffer = buffer;\r\n    }\r\n}\r\n\r\nclass AbstractBuffer implements Buffer {\r\n    private buffers: StringMap<BufferEntry> = {};\r\n    private currentMarker = 0;\r\n\r\n    init(gl: WebGLRenderingContext, target: number): number {\r\n        throw new Error('Method is abstract');\r\n    }\r\n\r\n    update(gl: WebGLRenderingContext, target: number, capacity: number): number {\r\n        throw new Error('Method is abstract');\r\n    }\r\n\r\n    setDirty() {\r\n        this.currentMarker++;\r\n    }\r\n\r\n    bind(gl: WebGLRenderingContext, target: number) {\r\n        const glId = getObjectId(gl);\r\n        if (this.buffers[glId] === undefined) {\r\n            const buffer = gl.createBuffer();\r\n            if (!hasval(buffer)) {\r\n                throw new Error('Failed to create buffer');\r\n            }\r\n            this.buffers[glId] = new BufferEntry(gl, buffer);\r\n\r\n            gl.bindBuffer(target, this.buffers[glId].buffer);\r\n            this.buffers[glId].capacity = this.init(gl, target);\r\n            this.buffers[glId].marker = this.currentMarker;\r\n        }\r\n        else if (this.buffers[glId].marker !== this.currentMarker) {\r\n            gl.bindBuffer(target, this.buffers[glId].buffer);\r\n            this.buffers[glId].capacity = this.update(gl, target, this.buffers[glId].capacity);\r\n            this.buffers[glId].marker = this.currentMarker;\r\n        }\r\n        else {\r\n            gl.bindBuffer(target, this.buffers[glId].buffer);\r\n        }\r\n    }\r\n\r\n    unbind(gl: WebGLRenderingContext, target: number) {\r\n        gl.bindBuffer(target, null);\r\n    }\r\n\r\n    dispose() {\r\n        // XXX: Not sure this actually works ... may have to make each gl current or something\r\n        for (const glid in this.buffers) {\r\n            if (this.buffers.hasOwnProperty(glid)) {\r\n                const en = this.buffers[glid];\r\n                en.gl.deleteBuffer(en.buffer);\r\n            }\r\n        }\r\n        this.buffers = {};\r\n    }\r\n}\r\n\r\n\r\nclass StaticBufferImpl extends AbstractBuffer {\r\n    private _data: Float32Array;\r\n\r\n    constructor(data: Float32Array) {\r\n        super();\r\n        this._data = data;\r\n    }\r\n\r\n    init(gl: WebGLRenderingContext, target: number): number {\r\n        gl.bufferData(target, this._data, GL.STATIC_DRAW);\r\n        return this._data.byteLength;\r\n    }\r\n\r\n    update(gl: WebGLRenderingContext, target: number, capacity: number): number {\r\n        throw new Error('This buffer is static and should never need to be updated');\r\n    }\r\n}\r\n\r\n\r\nclass DynamicBufferImpl extends AbstractBuffer implements DynamicBuffer {\r\n    private _data: Float32Array;\r\n\r\n    constructor(data: Float32Array) {\r\n        super();\r\n        this._data = data;\r\n    }\r\n\r\n    setData(data: Float32Array) {\r\n        this._data = data;\r\n        this.setDirty();\r\n    }\r\n\r\n    init(gl: WebGLRenderingContext, target: number): number {\r\n        gl.bufferData(target, this._data, GL.DYNAMIC_DRAW);\r\n        return this._data.byteLength;\r\n    }\r\n\r\n    update(gl: WebGLRenderingContext, target: number, capacity: number): number {\r\n        if (this._data.byteLength <= capacity) {\r\n            gl.bufferSubData(target, 0, this._data);\r\n            return capacity;\r\n        }\r\n        else {\r\n            gl.bufferData(target, this._data, GL.DYNAMIC_DRAW);\r\n            return this._data.byteLength;\r\n        }\r\n    }\r\n}\r\n\r\n\r\n"]}