@awayjs/stage/dist/lib/webgl/VertexBufferWebGL.js

Stage for AwayJS

import { Settings } from '../Settings';
import { BufferPool } from './BufferPool';
var VertexBufferWebGL = /** @class */ (function () {
    function VertexBufferWebGL(_context, numVertices, dataPerVertex) {
        this._context = _context;
        this._lastMemoryUsage = 0;
        this.instanced = false;
        this.dynamic = false;
        this.canUnload = true;
        this._gl = _context._gl;
        this._buffer = this._gl.createBuffer();
        this._numVertices = numVertices;
        this._dataPerVertex = dataPerVertex;
        _context.stats.counter.vertex++;
    }
    Object.defineProperty(VertexBufferWebGL, "pool", {
        get: function () {
            if (!Settings.ENABLE_BUFFER_POOLING)
                return null;
            return this._pool || (this._pool = new BufferPool(VertexBufferWebGL));
        },
        enumerable: false,
        configurable: true
    });
    VertexBufferWebGL.create = function (context, numVertices, dataPerVertex) {
        if (!Settings.ENABLE_BUFFER_POOLING) {
            return new VertexBufferWebGL(context, numVertices, dataPerVertex);
        }
        return this.pool.create(context, numVertices, dataPerVertex);
    };
    VertexBufferWebGL.prototype.initAsDynamic = function (numVertices) {
        if (numVertices === void 0) { numVertices = this._numVertices; }
        if (numVertices === 0) {
            return;
        }
        this._numVertices = numVertices;
        this.dynamic = true;
        this._context.stats.memory.vertex -= this._lastMemoryUsage;
        this._lastMemoryUsage = numVertices * this._dataPerVertex;
        this._context.stats.memory.vertex += this._lastMemoryUsage;
        this._gl.bindBuffer(this._gl.ARRAY_BUFFER, this._buffer);
        this._gl.bufferData(this._gl.ARRAY_BUFFER, numVertices * this._dataPerVertex, this._gl.DYNAMIC_DRAW);
    };
    VertexBufferWebGL.prototype.uploadFromArray = function (array, startVertex, _numVertices) {
        if (startVertex === void 0) { startVertex = 0; }
        if (_numVertices === void 0) { _numVertices = this._numVertices; }
        this.uploadFromByteArray(array, startVertex, _numVertices);
    };
    VertexBufferWebGL.prototype.uploadFromByteArray = function (data, startVertex, _numVertices) {
        var gl = this._gl;
        gl.bindBuffer(gl.ARRAY_BUFFER, this._buffer);
        // use subdata when buffer less that was and dynamic
        if ((startVertex || data.byteLength < this._numVertices * this._dataPerVertex) && this.dynamic) {
            gl.bufferSubData(gl.ARRAY_BUFFER, startVertex * this._dataPerVertex, data);
        }
        else {
            this._numVertices = data.byteLength / this._dataPerVertex;
            this._context.stats.memory.vertex -= this._lastMemoryUsage;
            this._lastMemoryUsage = data.byteLength;
            this._context.stats.memory.vertex += this._lastMemoryUsage;
            gl.bufferData(gl.ARRAY_BUFFER, data, this.dynamic ? gl.DYNAMIC_DRAW : gl.STATIC_DRAW);
        }
    };
    Object.defineProperty(VertexBufferWebGL.prototype, "numVertices", {
        get: function () {
            return this._numVertices;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(VertexBufferWebGL.prototype, "dataPerVertex", {
        get: function () {
            return this._dataPerVertex;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(VertexBufferWebGL.prototype, "glBuffer", {
        get: function () {
            return this._buffer;
        },
        enumerable: false,
        configurable: true
    });
    VertexBufferWebGL.prototype.dispose = function () {
        this.instanced = false;
        this.dynamic = false;
        if (Settings.ENABLE_BUFFER_POOLING && VertexBufferWebGL.pool.store(this)) {
            return;
        }
        this.unload();
    };
    VertexBufferWebGL.prototype.apply = function (_gl, numVertices, dataPerVertex) {
        this._numVertices = numVertices;
        this._dataPerVertex = dataPerVertex;
    };
    VertexBufferWebGL.prototype.unload = function () {
        Settings.ENABLE_BUFFER_POOLING && VertexBufferWebGL.pool.remove(this);
        this._gl.deleteBuffer(this._buffer);
        this._buffer = null;
        this._context.stats.counter.vertex--;
        this._context.stats.memory.vertex -= this._lastMemoryUsage;
    };
    return VertexBufferWebGL;
}());
export { VertexBufferWebGL };