116 lines
3.8 KiB
JavaScript
116 lines
3.8 KiB
JavaScript
'use strict';
|
|
|
|
var pow2 = require('../../../../maths/misc/pow2.js');
|
|
var TextureSource = require('./sources/TextureSource.js');
|
|
var Texture = require('./Texture.js');
|
|
|
|
"use strict";
|
|
let count = 0;
|
|
class TexturePoolClass {
|
|
/**
|
|
* @param textureOptions - options that will be passed to BaseRenderTexture constructor
|
|
* @param {SCALE_MODE} [textureOptions.scaleMode] - See {@link SCALE_MODE} for possible values.
|
|
*/
|
|
constructor(textureOptions) {
|
|
this._poolKeyHash = /* @__PURE__ */ Object.create(null);
|
|
this._texturePool = {};
|
|
this.textureOptions = textureOptions || {};
|
|
this.enableFullScreen = false;
|
|
}
|
|
/**
|
|
* Creates texture with params that were specified in pool constructor.
|
|
* @param pixelWidth - Width of texture in pixels.
|
|
* @param pixelHeight - Height of texture in pixels.
|
|
* @param antialias
|
|
*/
|
|
createTexture(pixelWidth, pixelHeight, antialias) {
|
|
const textureSource = new TextureSource.TextureSource({
|
|
...this.textureOptions,
|
|
width: pixelWidth,
|
|
height: pixelHeight,
|
|
resolution: 1,
|
|
antialias,
|
|
autoGarbageCollect: true
|
|
});
|
|
return new Texture.Texture({
|
|
source: textureSource,
|
|
label: `texturePool_${count++}`
|
|
});
|
|
}
|
|
/**
|
|
* Gets a Power-of-Two render texture or fullScreen texture
|
|
* @param frameWidth - The minimum width of the render texture.
|
|
* @param frameHeight - The minimum height of the render texture.
|
|
* @param resolution - The resolution of the render texture.
|
|
* @param antialias
|
|
* @returns The new render texture.
|
|
*/
|
|
getOptimalTexture(frameWidth, frameHeight, resolution = 1, antialias) {
|
|
let po2Width = Math.ceil(frameWidth * resolution - 1e-6);
|
|
let po2Height = Math.ceil(frameHeight * resolution - 1e-6);
|
|
po2Width = pow2.nextPow2(po2Width);
|
|
po2Height = pow2.nextPow2(po2Height);
|
|
const key = (po2Width << 17) + (po2Height << 1) + (antialias ? 1 : 0);
|
|
if (!this._texturePool[key]) {
|
|
this._texturePool[key] = [];
|
|
}
|
|
let texture = this._texturePool[key].pop();
|
|
if (!texture) {
|
|
texture = this.createTexture(po2Width, po2Height, antialias);
|
|
}
|
|
texture.source._resolution = resolution;
|
|
texture.source.width = po2Width / resolution;
|
|
texture.source.height = po2Height / resolution;
|
|
texture.source.pixelWidth = po2Width;
|
|
texture.source.pixelHeight = po2Height;
|
|
texture.frame.x = 0;
|
|
texture.frame.y = 0;
|
|
texture.frame.width = frameWidth;
|
|
texture.frame.height = frameHeight;
|
|
texture.updateUvs();
|
|
this._poolKeyHash[texture.uid] = key;
|
|
return texture;
|
|
}
|
|
/**
|
|
* Gets extra texture of the same size as input renderTexture
|
|
* @param texture - The texture to check what size it is.
|
|
* @param antialias - Whether to use antialias.
|
|
* @returns A texture that is a power of two
|
|
*/
|
|
getSameSizeTexture(texture, antialias = false) {
|
|
const source = texture.source;
|
|
return this.getOptimalTexture(texture.width, texture.height, source._resolution, antialias);
|
|
}
|
|
/**
|
|
* Place a render texture back into the pool.
|
|
* @param renderTexture - The renderTexture to free
|
|
*/
|
|
returnTexture(renderTexture) {
|
|
const key = this._poolKeyHash[renderTexture.uid];
|
|
this._texturePool[key].push(renderTexture);
|
|
}
|
|
/**
|
|
* Clears the pool.
|
|
* @param destroyTextures - Destroy all stored textures.
|
|
*/
|
|
clear(destroyTextures) {
|
|
destroyTextures = destroyTextures !== false;
|
|
if (destroyTextures) {
|
|
for (const i in this._texturePool) {
|
|
const textures = this._texturePool[i];
|
|
if (textures) {
|
|
for (let j = 0; j < textures.length; j++) {
|
|
textures[j].destroy(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this._texturePool = {};
|
|
}
|
|
}
|
|
const TexturePool = new TexturePoolClass();
|
|
|
|
exports.TexturePool = TexturePool;
|
|
exports.TexturePoolClass = TexturePoolClass;
|
|
//# sourceMappingURL=TexturePool.js.map
|