222 lines
15 KiB
JavaScript
222 lines
15 KiB
JavaScript
shadow$provide.module$node_modules$pixi_DOT_js$lib$rendering$renderers$gl$texture$GlTextureSystem = function(global, require, module, exports) {
|
|
var adapter = require("module$node_modules$pixi_DOT_js$lib$environment$adapter");
|
|
global = require("module$node_modules$pixi_DOT_js$lib$extensions$Extensions");
|
|
var GCManagedHash = require("module$node_modules$pixi_DOT_js$lib$utils$data$GCManagedHash"), Texture = require("module$node_modules$pixi_DOT_js$lib$rendering$renderers$shared$texture$Texture"), GlTexture = require("module$node_modules$pixi_DOT_js$lib$rendering$renderers$gl$texture$GlTexture"), glUploadBufferImageResource = require("module$node_modules$pixi_DOT_js$lib$rendering$renderers$gl$texture$uploaders$glUploadBufferImageResource"), glUploadCompressedTextureResource = require("module$node_modules$pixi_DOT_js$lib$rendering$renderers$gl$texture$uploaders$glUploadCompressedTextureResource"),
|
|
glUploadCubeTextureResource = require("module$node_modules$pixi_DOT_js$lib$rendering$renderers$gl$texture$uploaders$glUploadCubeTextureResource"), glUploadImageResource = require("module$node_modules$pixi_DOT_js$lib$rendering$renderers$gl$texture$uploaders$glUploadImageResource"), glUploadVideoResource = require("module$node_modules$pixi_DOT_js$lib$rendering$renderers$gl$texture$uploaders$glUploadVideoResource"), applyStyleParams = require("module$node_modules$pixi_DOT_js$lib$rendering$renderers$gl$texture$utils$applyStyleParams"),
|
|
mapFormatToGlFormat = require("module$node_modules$pixi_DOT_js$lib$rendering$renderers$gl$texture$utils$mapFormatToGlFormat"), mapFormatToGlInternalFormat = require("module$node_modules$pixi_DOT_js$lib$rendering$renderers$gl$texture$utils$mapFormatToGlInternalFormat"), mapFormatToGlType = require("module$node_modules$pixi_DOT_js$lib$rendering$renderers$gl$texture$utils$mapFormatToGlType"), mapViewDimensionToGlTarget = require("module$node_modules$pixi_DOT_js$lib$rendering$renderers$gl$texture$utils$mapViewDimensionToGlTarget");
|
|
require("module$node_modules$pixi_DOT_js$lib$rendering$renderers$gl$texture$utils$unpremultiplyAlpha");
|
|
"use strict";
|
|
const node_modules$pixi_DOT_js$lib$rendering$renderers$gl$texture$GlTextureSystem$classdecl$var27 = class {
|
|
constructor(renderer) {
|
|
this._glSamplers = Object.create(null);
|
|
this._boundTextures = [];
|
|
this._activeTextureLocation = -1;
|
|
this._boundSamplers = Object.create(null);
|
|
this._useSeparateSamplers = this._premultiplyAlpha = !1;
|
|
this._renderer = renderer;
|
|
this._managedTextures = new GCManagedHash.GCManagedHash({renderer, type:"resource", onUnload:this.onSourceUnload.bind(this), name:"glTexture"});
|
|
renderer = {image:glUploadImageResource.glUploadImageResource, buffer:glUploadBufferImageResource.glUploadBufferImageResource, video:glUploadVideoResource.glUploadVideoResource, compressed:glUploadCompressedTextureResource.glUploadCompressedTextureResource, ...node_modules$pixi_DOT_js$lib$rendering$renderers$gl$texture$GlTextureSystem$classdecl$var27.uploadExtensions};
|
|
this._uploads = {...renderer, cube:glUploadCubeTextureResource.createGlUploadCubeTextureResource(renderer)};
|
|
}
|
|
get managedTextures() {
|
|
return Object.values(this._managedTextures.items);
|
|
}
|
|
contextChange(gl) {
|
|
this._gl = gl;
|
|
this._mapFormatToInternalFormat || (this._mapFormatToInternalFormat = mapFormatToGlInternalFormat.mapFormatToGlInternalFormat(gl, this._renderer.context.extensions), this._mapFormatToType = mapFormatToGlType.mapFormatToGlType(gl), this._mapFormatToFormat = mapFormatToGlFormat.mapFormatToGlFormat(gl), this._mapViewDimensionToGlTarget = mapViewDimensionToGlTarget.mapViewDimensionToGlTarget(gl));
|
|
this._managedTextures.removeAll(!0);
|
|
this._glSamplers = Object.create(null);
|
|
this._boundSamplers = Object.create(null);
|
|
this._premultiplyAlpha = !1;
|
|
for (gl = 0; 16 > gl; gl++) {
|
|
this.bind(Texture.Texture.EMPTY, gl);
|
|
}
|
|
}
|
|
initSource(source) {
|
|
this.bind(source);
|
|
}
|
|
bind(texture, location = 0) {
|
|
const source = texture.source;
|
|
texture ? (this.bindSource(source, location), this._useSeparateSamplers && this._bindSampler(source.style, location)) : (this.bindSource(null, location), this._useSeparateSamplers && this._bindSampler(null, location));
|
|
}
|
|
bindSource(source, location = 0) {
|
|
const gl = this._gl;
|
|
source._gcLastUsed = this._renderer.gc.now;
|
|
this._boundTextures[location] !== source && (this._boundTextures[location] = source, this._activateLocation(location), source || (source = Texture.Texture.EMPTY.source), source = this.getGlSource(source), gl.bindTexture(source.target, source.texture));
|
|
}
|
|
_bindSampler(style, location = 0) {
|
|
const gl = this._gl;
|
|
style ? (style = this._getGlSampler(style), this._boundSamplers[location] !== style && (this._boundSamplers[location] = style, gl.bindSampler(location, style))) : (this._boundSamplers[location] = null, gl.bindSampler(location, null));
|
|
}
|
|
unbind(texture) {
|
|
texture = texture.source;
|
|
const boundTextures = this._boundTextures, gl = this._gl;
|
|
for (let i = 0; i < boundTextures.length; i++) {
|
|
if (boundTextures[i] === texture) {
|
|
this._activateLocation(i);
|
|
const glTexture = this.getGlSource(texture);
|
|
gl.bindTexture(glTexture.target, null);
|
|
boundTextures[i] = null;
|
|
}
|
|
}
|
|
}
|
|
_activateLocation(location) {
|
|
this._activeTextureLocation !== location && (this._activeTextureLocation = location, this._gl.activeTexture(this._gl.TEXTURE0 + location));
|
|
}
|
|
_initSource(source) {
|
|
const gl = this._gl, glTexture = new GlTexture.GlTexture(gl.createTexture());
|
|
glTexture.type = this._mapFormatToType[source.format];
|
|
glTexture.internalFormat = this._mapFormatToInternalFormat[source.format];
|
|
glTexture.format = this._mapFormatToFormat[source.format];
|
|
glTexture.target = this._mapViewDimensionToGlTarget[source.viewDimension];
|
|
if (null === glTexture.target) {
|
|
throw Error(`Unsupported view dimension: ${source.viewDimension} with this webgl version: ${this._renderer.context.webGLVersion}`);
|
|
}
|
|
"cube" === source.uploadMethodId && (glTexture.target = gl.TEXTURE_CUBE_MAP);
|
|
source.autoGenerateMipmaps && (this._renderer.context.supports.nonPowOf2mipmaps || source.isPowerOfTwo) && (source.mipLevelCount = Math.floor(Math.log2(Math.max(source.width, source.height))) + 1);
|
|
source._gpuData[this._renderer.uid] = glTexture;
|
|
this._managedTextures.add(source) && (source.on("update", this.onSourceUpdate, this), source.on("resize", this.onSourceUpdate, this), source.on("styleChange", this.onStyleChange, this), source.on("updateMipmaps", this.onUpdateMipmaps, this));
|
|
this.onSourceUpdate(source);
|
|
this.updateStyle(source, !1);
|
|
return glTexture;
|
|
}
|
|
onStyleChange(source) {
|
|
this.updateStyle(source, !1);
|
|
}
|
|
updateStyle(source, firstCreation) {
|
|
const gl = this._gl, glTexture = this.getGlSource(source);
|
|
gl.bindTexture(glTexture.target, glTexture.texture);
|
|
this._boundTextures[this._activeTextureLocation] = source;
|
|
applyStyleParams.applyStyleParams(source.style, gl, 1 < source.mipLevelCount, this._renderer.context.extensions.anisotropicFiltering, "texParameteri", glTexture.target, !this._renderer.context.supports.nonPowOf2wrapping && !source.isPowerOfTwo, firstCreation);
|
|
}
|
|
onSourceUnload(source, contextLost = !1) {
|
|
const glTexture = source._gpuData[this._renderer.uid];
|
|
glTexture && (contextLost || (this.unbind(source), this._gl.deleteTexture(glTexture.texture)), source.off("update", this.onSourceUpdate, this), source.off("resize", this.onSourceUpdate, this), source.off("styleChange", this.onStyleChange, this), source.off("updateMipmaps", this.onUpdateMipmaps, this));
|
|
}
|
|
onSourceUpdate(source) {
|
|
const gl = this._gl, glTexture = this.getGlSource(source);
|
|
gl.bindTexture(glTexture.target, glTexture.texture);
|
|
this._boundTextures[this._activeTextureLocation] = source;
|
|
const premultipliedAlpha = "premultiply-alpha-on-upload" === source.alphaMode;
|
|
this._premultiplyAlpha !== premultipliedAlpha && (this._premultiplyAlpha = premultipliedAlpha, gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, premultipliedAlpha));
|
|
if (this._uploads[source.uploadMethodId]) {
|
|
this._uploads[source.uploadMethodId].upload(source, glTexture, gl, this._renderer.context.webGLVersion);
|
|
} else if (glTexture.target === gl.TEXTURE_2D) {
|
|
this._initEmptyTexture2D(glTexture, source);
|
|
} else if (glTexture.target === gl.TEXTURE_2D_ARRAY) {
|
|
this._initEmptyTexture2DArray(glTexture, source);
|
|
} else if (glTexture.target === gl.TEXTURE_CUBE_MAP) {
|
|
this._initEmptyTextureCube(glTexture, source);
|
|
} else {
|
|
throw Error("[GlTextureSystem] Unsupported texture target for empty allocation.");
|
|
}
|
|
this._applyMipRange(glTexture, source);
|
|
if (source.autoGenerateMipmaps && 1 < source.mipLevelCount) {
|
|
this.onUpdateMipmaps(source, !1);
|
|
}
|
|
}
|
|
onUpdateMipmaps(source, bind = !0) {
|
|
bind && this.bindSource(source, 0);
|
|
source = this.getGlSource(source);
|
|
this._gl.generateMipmap(source.target);
|
|
}
|
|
_initEmptyTexture2D(glTexture, source) {
|
|
const gl = this._gl;
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, glTexture.internalFormat, source.pixelWidth, source.pixelHeight, 0, glTexture.format, glTexture.type, null);
|
|
let w = Math.max(source.pixelWidth >> 1, 1), h = Math.max(source.pixelHeight >> 1, 1);
|
|
for (let level = 1; level < source.mipLevelCount; level++) {
|
|
gl.texImage2D(gl.TEXTURE_2D, level, glTexture.internalFormat, w, h, 0, glTexture.format, glTexture.type, null), w = Math.max(w >> 1, 1), h = Math.max(h >> 1, 1);
|
|
}
|
|
}
|
|
_initEmptyTexture2DArray(glTexture, source) {
|
|
if (2 !== this._renderer.context.webGLVersion) {
|
|
throw Error("[GlTextureSystem] TEXTURE_2D_ARRAY requires WebGL2.");
|
|
}
|
|
const gl2 = this._gl, depth = Math.max(source.arrayLayerCount | 0, 1);
|
|
gl2.texImage3D(gl2.TEXTURE_2D_ARRAY, 0, glTexture.internalFormat, source.pixelWidth, source.pixelHeight, depth, 0, glTexture.format, glTexture.type, null);
|
|
let w = Math.max(source.pixelWidth >> 1, 1), h = Math.max(source.pixelHeight >> 1, 1);
|
|
for (let level = 1; level < source.mipLevelCount; level++) {
|
|
gl2.texImage3D(gl2.TEXTURE_2D_ARRAY, level, glTexture.internalFormat, w, h, depth, 0, glTexture.format, glTexture.type, null), w = Math.max(w >> 1, 1), h = Math.max(h >> 1, 1);
|
|
}
|
|
}
|
|
_initEmptyTextureCube(glTexture, source) {
|
|
const gl = this._gl;
|
|
for (var face$jscomp$0 = 0; 6 > face$jscomp$0; face$jscomp$0++) {
|
|
gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + face$jscomp$0, 0, glTexture.internalFormat, source.pixelWidth, source.pixelHeight, 0, glTexture.format, glTexture.type, null);
|
|
}
|
|
face$jscomp$0 = Math.max(source.pixelWidth >> 1, 1);
|
|
let h = Math.max(source.pixelHeight >> 1, 1);
|
|
for (let level = 1; level < source.mipLevelCount; level++) {
|
|
for (let face = 0; 6 > face; face++) {
|
|
gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + face, level, glTexture.internalFormat, face$jscomp$0, h, 0, glTexture.format, glTexture.type, null);
|
|
}
|
|
face$jscomp$0 = Math.max(face$jscomp$0 >> 1, 1);
|
|
h = Math.max(h >> 1, 1);
|
|
}
|
|
}
|
|
_applyMipRange(glTexture, source) {
|
|
if (2 === this._renderer.context.webGLVersion && !(1 >= source.mipLevelCount)) {
|
|
var gl = this._gl;
|
|
source = Math.max((source.mipLevelCount | 0) - 1, 0);
|
|
gl.texParameteri(glTexture.target, gl.TEXTURE_BASE_LEVEL, 0);
|
|
gl.texParameteri(glTexture.target, gl.TEXTURE_MAX_LEVEL, source);
|
|
}
|
|
}
|
|
_initSampler(style) {
|
|
const gl = this._gl, glSampler = this._gl.createSampler();
|
|
this._glSamplers[style._resourceId] = glSampler;
|
|
applyStyleParams.applyStyleParams(style, gl, 1 < this._boundTextures[this._activeTextureLocation].mipLevelCount, this._renderer.context.extensions.anisotropicFiltering, "samplerParameteri", glSampler, !1, !0);
|
|
return this._glSamplers[style._resourceId];
|
|
}
|
|
_getGlSampler(sampler) {
|
|
return this._glSamplers[sampler._resourceId] || this._initSampler(sampler);
|
|
}
|
|
getGlSource(source) {
|
|
source._gcLastUsed = this._renderer.gc.now;
|
|
return source._gpuData[this._renderer.uid] || this._initSource(source);
|
|
}
|
|
generateCanvas(texture) {
|
|
const {pixels, width, height} = this.getPixels(texture);
|
|
texture = adapter.DOMAdapter.get().createCanvas();
|
|
texture.width = width;
|
|
texture.height = height;
|
|
const ctx = texture.getContext("2d");
|
|
if (ctx) {
|
|
const imageData = ctx.createImageData(width, height);
|
|
imageData.data.set(pixels);
|
|
ctx.putImageData(imageData, 0, 0);
|
|
}
|
|
return texture;
|
|
}
|
|
getPixels(texture) {
|
|
const resolution = texture.source.resolution, frame = texture.frame, width = Math.max(Math.round(frame.width * resolution), 1), height = Math.max(Math.round(frame.height * resolution), 1), pixels = new Uint8Array(4 * width * height);
|
|
var renderer = this._renderer;
|
|
texture = renderer.renderTarget.getRenderTarget(texture);
|
|
texture = renderer.renderTarget.getGpuRenderTarget(texture);
|
|
renderer = renderer.gl;
|
|
renderer.bindFramebuffer(renderer.FRAMEBUFFER, texture.resolveTargetFramebuffer);
|
|
renderer.readPixels(Math.round(frame.x * resolution), Math.round(frame.y * resolution), width, height, renderer.RGBA, renderer.UNSIGNED_BYTE, pixels);
|
|
return {pixels:new Uint8ClampedArray(pixels.buffer), width, height};
|
|
}
|
|
destroy() {
|
|
this._managedTextures.destroy();
|
|
this._renderer = this._uploads = this._mapFormatToFormat = this._mapFormatToType = this._mapFormatToInternalFormat = this._boundSamplers = this._boundTextures = this._glSamplers = null;
|
|
}
|
|
resetState() {
|
|
this._activeTextureLocation = -1;
|
|
this._boundTextures.fill(Texture.Texture.EMPTY.source);
|
|
this._boundSamplers = Object.create(null);
|
|
const gl = this._gl;
|
|
this._premultiplyAlpha = !1;
|
|
gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, this._premultiplyAlpha);
|
|
}
|
|
};
|
|
require = node_modules$pixi_DOT_js$lib$rendering$renderers$gl$texture$GlTextureSystem$classdecl$var27;
|
|
require.extension = {type:[global.ExtensionType.WebGLSystem], name:"texture"};
|
|
require.uploadExtensions = Object.create(null);
|
|
global.extensions.handleByMap(global.ExtensionType.TextureUploaderWebGL, require.uploadExtensions);
|
|
exports.GlTextureSystem = require;
|
|
};
|
|
|
|
//# sourceMappingURL=module$node_modules$pixi_DOT_js$lib$rendering$renderers$gl$texture$GlTextureSystem.js.map
|