# all files / src/compositor/ TexturePool.js

13.64% Statements 6/44
0% Branches 0/24
14.29% Functions 1/7
13.64% Lines 6/44

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110

    1×

    4×

    4×

    1×

    1×

    1×

     import Texture2D from '../Texture2D';
    import glenum from '../core/glenum';
    import util from '../core/util';

    var TexturePool = function () {

        this._pool = {};

        this._allocatedTextures = [];
    };

    TexturePool.prototype = {

        constructor: TexturePool,

        get: function (parameters) {
            var key = generateKey(parameters);
            if (!this._pool.hasOwnProperty(key)) {
                this._pool[key] = [];
            }
            var list = this._pool[key];
            if (!list.length) {
                var texture = new Texture2D(parameters);
                this._allocatedTextures.push(texture);
                return texture;
            }
            return list.pop();
        },

        put: function (texture) {
            var key = generateKey(texture);
            if (!this._pool.hasOwnProperty(key)) {
                this._pool[key] = [];
            }
            var list = this._pool[key];
            list.push(texture);
        },

        clear: function (renderer) {
            for (var i = 0; i < this._allocatedTextures.length; i++) {
                this._allocatedTextures[i].dispose(renderer);
            }
            this._pool = {};
            this._allocatedTextures = [];
        }
    };

    var defaultParams = {
        width: 512,
        height: 512,
        type: glenum.UNSIGNED_BYTE,
        format: glenum.RGBA,
        wrapS: glenum.CLAMP_TO_EDGE,
        wrapT: glenum.CLAMP_TO_EDGE,
        minFilter: glenum.LINEAR_MIPMAP_LINEAR,
        magFilter: glenum.LINEAR,
        useMipmap: true,
        anisotropic: 1,
        flipY: true,
        unpackAlignment: 4,
        premultiplyAlpha: false
    };

    var defaultParamPropList = Object.keys(defaultParams);

    function generateKey(parameters) {
        util.defaultsWithPropList(parameters, defaultParams, defaultParamPropList);
        fallBack(parameters);

        var key = '';
        for (var i = 0; i < defaultParamPropList.length; i++) {
            var name = defaultParamPropList[i];
            var chunk = parameters[name].toString();
            key += chunk;
        }
        return key;
    }

    function fallBack(target) {

        var IPOT = isPowerOfTwo(target.width, target.height);

        if (target.format === glenum.DEPTH_COMPONENT) {
            target.useMipmap = false;
        }

        if (!IPOT || !target.useMipmap) {
            if (target.minFilter == glenum.NEAREST_MIPMAP_NEAREST ||
                target.minFilter == glenum.NEAREST_MIPMAP_LINEAR) {
                target.minFilter = glenum.NEAREST;
            } else if (
                target.minFilter == glenum.LINEAR_MIPMAP_LINEAR ||
                target.minFilter == glenum.LINEAR_MIPMAP_NEAREST
            ) {
                target.minFilter = glenum.LINEAR;
            }
        }
        if (!IPOT) {
            target.wrapS = glenum.CLAMP_TO_EDGE;
            target.wrapT = glenum.CLAMP_TO_EDGE;
        }
    }

    function isPowerOfTwo(width, height) {
        return (width & (width-1)) === 0 &&
                (height & (height-1)) === 0;
    }

    export default TexturePool;