@scoova/mgl 1.0.0

package/src/gl/color_mode.ts

@@ -0,0 +1,31 @@
+import {Color} from '@maplibre/maplibre-gl-style-spec';
+
+import type {BlendFuncType, ColorMaskType} from './types';
+
+const ZERO = 0x0000;
+const ONE = 0x0001;
+const ONE_MINUS_SRC_ALPHA = 0x0303;
+
+export class ColorMode {
+    blendFunction: BlendFuncType;
+    blendColor: Color;
+    mask: ColorMaskType;
+
+    constructor(blendFunction: BlendFuncType, blendColor: Color, mask: ColorMaskType) {
+        this.blendFunction = blendFunction;
+        this.blendColor = blendColor;
+        this.mask = mask;
+    }
+
+    static Replace: BlendFuncType;
+
+    static disabled: Readonly<ColorMode>;
+    static unblended: Readonly<ColorMode>;
+    static alphaBlended: Readonly<ColorMode>;
+}
+
+ColorMode.Replace = [ONE, ZERO];
+
+ColorMode.disabled = new ColorMode(ColorMode.Replace, Color.transparent, [false, false, false, false]);
+ColorMode.unblended = new ColorMode(ColorMode.Replace, Color.transparent, [true, true, true, true]);
+ColorMode.alphaBlended = new ColorMode([ONE, ONE_MINUS_SRC_ALPHA], Color.transparent, [true, true, true, true]);

package/src/gl/context.ts

@@ -0,0 +1,321 @@
+import {IndexBuffer} from './index_buffer';
+
+import {VertexBuffer} from './vertex_buffer';
+import {Framebuffer} from './framebuffer';
+import {DepthMode} from './depth_mode';
+import {StencilMode} from './stencil_mode';
+import {ColorMode} from './color_mode';
+import {CullFaceMode} from './cull_face_mode';
+import {deepEqual} from '../util/util';
+import {ClearColor, ClearDepth, ClearStencil, ColorMask, DepthMask, StencilMask, StencilFunc, StencilOp, StencilTest, DepthRange, DepthTest, DepthFunc, Blend, BlendFunc, BlendColor, BlendEquation, CullFace, CullFaceSide, FrontFace, ProgramValue, ActiveTextureUnit, Viewport, BindFramebuffer, BindRenderbuffer, BindTexture, BindVertexBuffer, BindElementBuffer, BindVertexArray, PixelStoreUnpack, PixelStoreUnpackPremultiplyAlpha, PixelStoreUnpackFlipY} from './value';
+
+import type {TriangleIndexArray, LineIndexArray, LineStripIndexArray} from '../data/index_array_type';
+import type {
+    StructArray,
+    StructArrayMember
+} from '../util/struct_array';
+import type {Color} from '@maplibre/maplibre-gl-style-spec';
+import {isWebGL2} from './webgl2';
+
+type ClearArgs = {
+    color?: Color;
+    depth?: number;
+    stencil?: number;
+};
+
+/**
+ * @internal
+ * A webgl wrapper class to allow injection, mocking and abstaction
+ */
+export class Context {
+    gl: WebGLRenderingContext | WebGL2RenderingContext;
+
+    currentNumAttributes: number;
+    maxTextureSize: number;
+
+    clearColor: ClearColor;
+    clearDepth: ClearDepth;
+    clearStencil: ClearStencil;
+    colorMask: ColorMask;
+    depthMask: DepthMask;
+    stencilMask: StencilMask;
+    stencilFunc: StencilFunc;
+    stencilOp: StencilOp;
+    stencilTest: StencilTest;
+    depthRange: DepthRange;
+    depthTest: DepthTest;
+    depthFunc: DepthFunc;
+    blend: Blend;
+    blendFunc: BlendFunc;
+    blendColor: BlendColor;
+    blendEquation: BlendEquation;
+    cullFace: CullFace;
+    cullFaceSide: CullFaceSide;
+    frontFace: FrontFace;
+    program: ProgramValue;
+    activeTexture: ActiveTextureUnit;
+    viewport: Viewport;
+    bindFramebuffer: BindFramebuffer;
+    bindRenderbuffer: BindRenderbuffer;
+    bindTexture: BindTexture;
+    bindVertexBuffer: BindVertexBuffer;
+    bindElementBuffer: BindElementBuffer;
+    bindVertexArray: BindVertexArray;
+    pixelStoreUnpack: PixelStoreUnpack;
+    pixelStoreUnpackPremultiplyAlpha: PixelStoreUnpackPremultiplyAlpha;
+    pixelStoreUnpackFlipY: PixelStoreUnpackFlipY;
+
+    // eslint-disable-next-line camelcase
+    extTextureFilterAnisotropic: EXT_texture_filter_anisotropic | null;
+    extTextureFilterAnisotropicMax?: GLfloat;
+    HALF_FLOAT?: GLenum;
+    RGBA16F?: GLenum;
+    RGB16F?: GLenum;
+
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext) {
+        this.gl = gl;
+        this.clearColor = new ClearColor(this);
+        this.clearDepth = new ClearDepth(this);
+        this.clearStencil = new ClearStencil(this);
+        this.colorMask = new ColorMask(this);
+        this.depthMask = new DepthMask(this);
+        this.stencilMask = new StencilMask(this);
+        this.stencilFunc = new StencilFunc(this);
+        this.stencilOp = new StencilOp(this);
+        this.stencilTest = new StencilTest(this);
+        this.depthRange = new DepthRange(this);
+        this.depthTest = new DepthTest(this);
+        this.depthFunc = new DepthFunc(this);
+        this.blend = new Blend(this);
+        this.blendFunc = new BlendFunc(this);
+        this.blendColor = new BlendColor(this);
+        this.blendEquation = new BlendEquation(this);
+        this.cullFace = new CullFace(this);
+        this.cullFaceSide = new CullFaceSide(this);
+        this.frontFace = new FrontFace(this);
+        this.program = new ProgramValue(this);
+        this.activeTexture = new ActiveTextureUnit(this);
+        this.viewport = new Viewport(this);
+        this.bindFramebuffer = new BindFramebuffer(this);
+        this.bindRenderbuffer = new BindRenderbuffer(this);
+        this.bindTexture = new BindTexture(this);
+        this.bindVertexBuffer = new BindVertexBuffer(this);
+        this.bindElementBuffer = new BindElementBuffer(this);
+        this.bindVertexArray = new BindVertexArray(this);
+        this.pixelStoreUnpack = new PixelStoreUnpack(this);
+        this.pixelStoreUnpackPremultiplyAlpha = new PixelStoreUnpackPremultiplyAlpha(this);
+        this.pixelStoreUnpackFlipY = new PixelStoreUnpackFlipY(this);
+
+        this.extTextureFilterAnisotropic = (
+            gl.getExtension('EXT_texture_filter_anisotropic') ||
+            gl.getExtension('MOZ_EXT_texture_filter_anisotropic') ||
+            gl.getExtension('WEBKIT_EXT_texture_filter_anisotropic')
+        );
+
+        if (this.extTextureFilterAnisotropic) {
+            this.extTextureFilterAnisotropicMax = gl.getParameter(this.extTextureFilterAnisotropic.MAX_TEXTURE_MAX_ANISOTROPY_EXT);
+        }
+
+        this.maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);
+
+        if (isWebGL2(gl)) {
+            this.HALF_FLOAT = gl.HALF_FLOAT;
+            const extColorBufferHalfFloat = gl.getExtension('EXT_color_buffer_half_float');
+            this.RGBA16F = gl.RGBA16F ?? extColorBufferHalfFloat?.RGBA16F_EXT;
+            this.RGB16F = gl.RGB16F ?? extColorBufferHalfFloat?.RGB16F_EXT;
+            gl.getExtension('EXT_color_buffer_float');
+        } else {
+            gl.getExtension('EXT_color_buffer_half_float');
+            gl.getExtension('OES_texture_half_float_linear');
+            const extTextureHalfFloat = gl.getExtension('OES_texture_half_float');
+            this.HALF_FLOAT = extTextureHalfFloat?.HALF_FLOAT_OES;
+        }
+    }
+
+    setDefault() {
+        this.unbindVAO();
+
+        this.clearColor.setDefault();
+        this.clearDepth.setDefault();
+        this.clearStencil.setDefault();
+        this.colorMask.setDefault();
+        this.depthMask.setDefault();
+        this.stencilMask.setDefault();
+        this.stencilFunc.setDefault();
+        this.stencilOp.setDefault();
+        this.stencilTest.setDefault();
+        this.depthRange.setDefault();
+        this.depthTest.setDefault();
+        this.depthFunc.setDefault();
+        this.blend.setDefault();
+        this.blendFunc.setDefault();
+        this.blendColor.setDefault();
+        this.blendEquation.setDefault();
+        this.cullFace.setDefault();
+        this.cullFaceSide.setDefault();
+        this.frontFace.setDefault();
+        this.program.setDefault();
+        this.activeTexture.setDefault();
+        this.bindFramebuffer.setDefault();
+        this.pixelStoreUnpack.setDefault();
+        this.pixelStoreUnpackPremultiplyAlpha.setDefault();
+        this.pixelStoreUnpackFlipY.setDefault();
+    }
+
+    setDirty() {
+        this.clearColor.dirty = true;
+        this.clearDepth.dirty = true;
+        this.clearStencil.dirty = true;
+        this.colorMask.dirty = true;
+        this.depthMask.dirty = true;
+        this.stencilMask.dirty = true;
+        this.stencilFunc.dirty = true;
+        this.stencilOp.dirty = true;
+        this.stencilTest.dirty = true;
+        this.depthRange.dirty = true;
+        this.depthTest.dirty = true;
+        this.depthFunc.dirty = true;
+        this.blend.dirty = true;
+        this.blendFunc.dirty = true;
+        this.blendColor.dirty = true;
+        this.blendEquation.dirty = true;
+        this.cullFace.dirty = true;
+        this.cullFaceSide.dirty = true;
+        this.frontFace.dirty = true;
+        this.program.dirty = true;
+        this.activeTexture.dirty = true;
+        this.viewport.dirty = true;
+        this.bindFramebuffer.dirty = true;
+        this.bindRenderbuffer.dirty = true;
+        this.bindTexture.dirty = true;
+        this.bindVertexBuffer.dirty = true;
+        this.bindElementBuffer.dirty = true;
+        this.bindVertexArray.dirty = true;
+        this.pixelStoreUnpack.dirty = true;
+        this.pixelStoreUnpackPremultiplyAlpha.dirty = true;
+        this.pixelStoreUnpackFlipY.dirty = true;
+    }
+
+    createIndexBuffer(array: TriangleIndexArray | LineIndexArray | LineStripIndexArray, dynamicDraw?: boolean) {
+        return new IndexBuffer(this, array, dynamicDraw);
+    }
+
+    createVertexBuffer(array: StructArray, attributes: ReadonlyArray<StructArrayMember>, dynamicDraw?: boolean) {
+        return new VertexBuffer(this, array, attributes, dynamicDraw);
+    }
+
+    createRenderbuffer(storageFormat: number, width: number, height: number) {
+        const gl = this.gl;
+
+        const rbo = gl.createRenderbuffer();
+        this.bindRenderbuffer.set(rbo);
+        gl.renderbufferStorage(gl.RENDERBUFFER, storageFormat, width, height);
+        this.bindRenderbuffer.set(null);
+
+        return rbo;
+    }
+
+    createFramebuffer(width: number, height: number, hasDepth: boolean, hasStencil: boolean) {
+        return new Framebuffer(this, width, height, hasDepth, hasStencil);
+    }
+
+    clear({
+        color,
+        depth,
+        stencil
+    }: ClearArgs) {
+        const gl = this.gl;
+        let mask = 0;
+
+        if (color) {
+            mask |= gl.COLOR_BUFFER_BIT;
+            this.clearColor.set(color);
+            this.colorMask.set([true, true, true, true]);
+        }
+
+        if (typeof depth !== 'undefined') {
+            mask |= gl.DEPTH_BUFFER_BIT;
+
+            // Workaround for platforms where clearDepth doesn't seem to work
+            // without resetting the depthRange. See https://github.com/mapbox/mapbox-gl-js/issues/3437
+            this.depthRange.set([0, 1]);
+
+            this.clearDepth.set(depth);
+            this.depthMask.set(true);
+        }
+
+        if (typeof stencil !== 'undefined') {
+            mask |= gl.STENCIL_BUFFER_BIT;
+            this.clearStencil.set(stencil);
+            this.stencilMask.set(0xFF);
+        }
+
+        gl.clear(mask);
+    }
+
+    setCullFace(cullFaceMode: Readonly<CullFaceMode>) {
+        if (cullFaceMode.enable === false) {
+            this.cullFace.set(false);
+        } else {
+            this.cullFace.set(true);
+            this.cullFaceSide.set(cullFaceMode.mode);
+            this.frontFace.set(cullFaceMode.frontFace);
+        }
+    }
+
+    setDepthMode(depthMode: Readonly<DepthMode>) {
+        if (depthMode.func === this.gl.ALWAYS && !depthMode.mask) {
+            this.depthTest.set(false);
+        } else {
+            this.depthTest.set(true);
+            this.depthFunc.set(depthMode.func);
+            this.depthMask.set(depthMode.mask);
+            this.depthRange.set(depthMode.range);
+        }
+    }
+
+    setStencilMode(stencilMode: Readonly<StencilMode>) {
+        if (stencilMode.test.func === this.gl.ALWAYS && !stencilMode.mask) {
+            this.stencilTest.set(false);
+        } else {
+            this.stencilTest.set(true);
+            this.stencilMask.set(stencilMode.mask);
+            this.stencilOp.set([stencilMode.fail, stencilMode.depthFail, stencilMode.pass]);
+            this.stencilFunc.set({
+                func: stencilMode.test.func,
+                ref: stencilMode.ref,
+                mask: stencilMode.test.mask
+            });
+        }
+    }
+
+    setColorMode(colorMode: Readonly<ColorMode>) {
+        if (deepEqual(colorMode.blendFunction, ColorMode.Replace)) {
+            this.blend.set(false);
+        } else {
+            this.blend.set(true);
+            this.blendFunc.set(colorMode.blendFunction);
+            this.blendColor.set(colorMode.blendColor);
+        }
+
+        this.colorMask.set(colorMode.mask);
+    }
+
+    createVertexArray(): WebGLVertexArrayObject | undefined {
+        if (isWebGL2(this.gl))
+            return this.gl.createVertexArray();
+        return this.gl.getExtension('OES_vertex_array_object')?.createVertexArrayOES();
+    }
+
+    deleteVertexArray(x: WebGLVertexArrayObject | undefined) {
+        if (isWebGL2(this.gl))
+            return this.gl.deleteVertexArray(x);
+        return this.gl.getExtension('OES_vertex_array_object')?.deleteVertexArrayOES(x);
+    }
+
+    unbindVAO() {
+        // Unbinding the VAO prevents other things (custom layers, new buffer creation) from
+        // unintentionally changing the state of the last VAO used.
+        this.bindVertexArray.set(null);
+    }
+}

package/src/gl/cull_face_mode.ts

@@ -0,0 +1,22 @@
+import type {CullFaceModeType, FrontFaceType} from './types';
+
+const BACK = 0x0405;
+const CCW = 0x0901;
+
+export class CullFaceMode {
+    enable: boolean;
+    mode: CullFaceModeType;
+    frontFace: FrontFaceType;
+
+    constructor(enable: boolean, mode: CullFaceModeType, frontFace: FrontFaceType) {
+        this.enable = enable;
+        this.mode = mode;
+        this.frontFace = frontFace;
+    }
+
+    static disabled: Readonly<CullFaceMode>;
+    static backCCW: Readonly<CullFaceMode>;
+}
+
+CullFaceMode.disabled = new CullFaceMode(false, BACK, CCW);
+CullFaceMode.backCCW = new CullFaceMode(true, BACK, CCW);

package/src/gl/depth_mode.ts

@@ -0,0 +1,26 @@
+import type {DepthFuncType, DepthMaskType, DepthRangeType} from './types';
+
+const ALWAYS = 0x0207;
+
+export class DepthMode {
+    func: DepthFuncType;
+    mask: DepthMaskType;
+    range: DepthRangeType;
+
+    // DepthMask enums
+    static ReadOnly: boolean;
+    static ReadWrite: boolean;
+
+    constructor(depthFunc: DepthFuncType, depthMask: DepthMaskType, depthRange: DepthRangeType) {
+        this.func = depthFunc;
+        this.mask = depthMask;
+        this.range = depthRange;
+    }
+
+    static disabled: Readonly<DepthMode>;
+}
+
+DepthMode.ReadOnly = false;
+DepthMode.ReadWrite = true;
+
+DepthMode.disabled = new DepthMode(ALWAYS, DepthMode.ReadOnly, [0, 1]);

package/src/gl/framebuffer.ts

@@ -0,0 +1,48 @@
+import {ColorAttachment, DepthAttachment, DepthStencilAttachment} from './value';
+
+import type {Context} from './context';
+
+/**
+ * @internal
+ * A framebuffer holder object
+ */
+export class Framebuffer {
+    context: Context;
+    width: number;
+    height: number;
+    framebuffer: WebGLFramebuffer;
+    colorAttachment: ColorAttachment;
+    depthAttachment: DepthAttachment;
+
+    constructor(context: Context, width: number, height: number, hasDepth: boolean, hasStencil: boolean) {
+        this.context = context;
+        this.width = width;
+        this.height = height;
+        const gl = context.gl;
+        const fbo = this.framebuffer = gl.createFramebuffer();
+
+        this.colorAttachment = new ColorAttachment(context, fbo);
+        if (hasDepth) {
+            this.depthAttachment = hasStencil ? new DepthStencilAttachment(context, fbo) : new DepthAttachment(context, fbo);
+        } else if (hasStencil) {
+            throw new Error('Stencil cannot be set without depth');
+        }
+        if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) !== gl.FRAMEBUFFER_COMPLETE) {
+            throw new Error('Framebuffer is not complete');
+        }
+    }
+
+    destroy() {
+        const gl = this.context.gl;
+
+        const texture = this.colorAttachment.get();
+        if (texture) gl.deleteTexture(texture);
+
+        if (this.depthAttachment) {
+            const renderbuffer = this.depthAttachment.get();
+            if (renderbuffer) gl.deleteRenderbuffer(renderbuffer);
+        }
+
+        gl.deleteFramebuffer(this.framebuffer);
+    }
+}

package/src/gl/index_buffer.ts

@@ -0,0 +1,55 @@
+
+import type {StructArray} from '../util/struct_array';
+import type {TriangleIndexArray, LineIndexArray, LineStripIndexArray} from '../data/index_array_type';
+import type {Context} from '../gl/context';
+
+/**
+ * @internal
+ * an index buffer class
+ */
+export class IndexBuffer {
+    context: Context;
+    buffer: WebGLBuffer;
+    dynamicDraw: boolean;
+
+    constructor(context: Context, array: TriangleIndexArray | LineIndexArray | LineStripIndexArray, dynamicDraw?: boolean) {
+        this.context = context;
+        const gl = context.gl;
+        this.buffer = gl.createBuffer();
+        this.dynamicDraw = Boolean(dynamicDraw);
+
+        // The bound index buffer is part of vertex array object state. We don't want to
+        // modify whatever VAO happens to be currently bound, so make sure the default
+        // vertex array provided by the context is bound instead.
+        this.context.unbindVAO();
+
+        context.bindElementBuffer.set(this.buffer);
+        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, array.arrayBuffer, this.dynamicDraw ? gl.DYNAMIC_DRAW : gl.STATIC_DRAW);
+
+        if (!this.dynamicDraw) {
+            delete array.arrayBuffer;
+        }
+    }
+
+    bind() {
+        this.context.bindElementBuffer.set(this.buffer);
+    }
+
+    updateData(array: StructArray) {
+        const gl = this.context.gl;
+        if (!this.dynamicDraw) throw new Error('Attempted to update data while not in dynamic mode.');
+        // The right VAO will get this buffer re-bound later in VertexArrayObject#bind
+        // See https://github.com/mapbox/mapbox-gl-js/issues/5620
+        this.context.unbindVAO();
+        this.bind();
+        gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, 0, array.arrayBuffer);
+    }
+
+    destroy() {
+        const gl = this.context.gl;
+        if (this.buffer) {
+            gl.deleteBuffer(this.buffer);
+            delete this.buffer;
+        }
+    }
+}

package/src/gl/render_pool.test.ts

@@ -0,0 +1,69 @@
+import {Context} from './context';
+import {RenderPool} from './render_pool';
+
+describe('render pool', () => {
+    const POOL_SIZE = 3;
+
+    function createAndFillPool(): RenderPool {
+        const gl = document.createElement('canvas').getContext('webgl');
+        jest.spyOn(gl, 'checkFramebufferStatus').mockReturnValue(gl.FRAMEBUFFER_COMPLETE);
+        const pool = new RenderPool(new Context(gl), POOL_SIZE, 512);
+        for (let i = 0; i < POOL_SIZE; i++) {
+            pool.useObject(pool.getOrCreateFreeObject());
+        }
+        return pool;
+    }
+
+    test('create pool should not be full', () =>  {
+        const gl = document.createElement('canvas').getContext('webgl');
+        const pool = new RenderPool(new Context(gl), POOL_SIZE, 512);
+        expect(pool.isFull()).toBeFalsy();
+    });
+
+    test('create pool should be full', () =>  {
+        const pool = createAndFillPool();
+        expect(() => pool.getOrCreateFreeObject()).toThrow('No free RenderPool available, call freeAllObjects() required!');
+    });
+
+    test('create pool and fill it', () =>  {
+        const pool = createAndFillPool();
+        expect(pool.isFull()).toBeTruthy();
+    });
+
+    test('check recently used after using two objects', () =>  {
+        const pool = createAndFillPool();
+        pool.freeAllObjects();
+        const obj0 = pool.getObjectForId(0);
+        pool.useObject(obj0);
+        pool.freeAllObjects();
+        const obj1 = pool.getOrCreateFreeObject();
+        expect(obj1.id).toBe(1);
+    });
+
+    test('not full after freeing an object', () =>  {
+        const pool = createAndFillPool();
+        const obj = pool.getObjectForId(0);
+        pool.freeObject(obj);
+        expect(pool.isFull()).toBeFalsy();
+        expect(obj.stamp).toBe(-1);
+    });
+
+    test('stamp object should get stamped', () =>  {
+        const pool = createAndFillPool();
+        const obj = pool.getObjectForId(0);
+        pool.stampObject(obj);
+        expect(obj.stamp).toBe(1);
+    });
+
+    test('free all objects, first object should be the first free object', () =>  {
+        const pool = createAndFillPool();
+        pool.freeAllObjects();
+        expect(pool.getOrCreateFreeObject().id).toBe(0);
+    });
+
+    test('destruct should remove textures', () =>  {
+        const pool = createAndFillPool();
+        pool.destruct();
+        expect(pool.getObjectForId(0).texture.texture).toBeNull();
+    });
+});

package/src/gl/render_pool.ts

@@ -0,0 +1,93 @@
+import {Texture} from '../render/texture';
+import {Context} from './context';
+import {Framebuffer} from './framebuffer';
+
+export type PoolObject = {
+    id: number;
+    fbo: Framebuffer;
+    texture: Texture;
+    stamp: number;
+    inUse: boolean;
+};
+/**
+ * @internal
+ * `RenderPool` is a resource pool for textures and framebuffers
+ */
+export class RenderPool {
+    private _objects: Array<PoolObject>;
+    /**
+     * An index array of recently used pool objects.
+     * Items that are used recently are last in the array
+     */
+    private _recentlyUsed: Array<number>;
+    private _stamp: number;
+
+    constructor(
+        private readonly _context: Context,
+        private readonly _size: number,
+        private readonly _tileSize: number) {
+        this._objects = [];
+        this._recentlyUsed = [];
+        this._stamp = 0;
+    }
+
+    public destruct() {
+        for (const obj of this._objects) {
+            obj.texture.destroy();
+            obj.fbo.destroy();
+        }
+    }
+
+    private _createObject(id: number): PoolObject {
+        const fbo = this._context.createFramebuffer(this._tileSize, this._tileSize, true, true);
+        const texture = new Texture(this._context, {width: this._tileSize, height: this._tileSize, data: null}, this._context.gl.RGBA);
+        texture.bind(this._context.gl.LINEAR, this._context.gl.CLAMP_TO_EDGE);
+        fbo.depthAttachment.set(this._context.createRenderbuffer(this._context.gl.DEPTH_STENCIL, this._tileSize, this._tileSize));
+        fbo.colorAttachment.set(texture.texture);
+        return {id, fbo, texture, stamp: -1, inUse: false};
+    }
+
+    public getObjectForId(id: number): PoolObject {
+        return this._objects[id];
+    }
+
+    public useObject(obj: PoolObject) {
+        obj.inUse = true;
+        this._recentlyUsed = this._recentlyUsed.filter(id => obj.id !== id);
+        this._recentlyUsed.push(obj.id);
+    }
+
+    public stampObject(obj: PoolObject) {
+        obj.stamp = ++this._stamp;
+    }
+
+    public getOrCreateFreeObject(): PoolObject {
+        // check for free existing object
+        for (const id of this._recentlyUsed) {
+            if (!this._objects[id].inUse)
+                return this._objects[id];
+        }
+        if (this._objects.length >= this._size)
+            throw new Error('No free RenderPool available, call freeAllObjects() required!');
+        // create new object
+        const obj = this._createObject(this._objects.length);
+        this._objects.push(obj);
+        return obj;
+    }
+
+    public freeObject(obj: PoolObject) {
+        obj.inUse = false;
+    }
+
+    public freeAllObjects() {
+        for (const obj of this._objects)
+            this.freeObject(obj);
+    }
+
+    public isFull(): boolean {
+        if (this._objects.length < this._size) {
+            return false;
+        }
+        return this._objects.some(o => !o.inUse) === false;
+    }
+}