import type { GLProgram } from './GLProgram'; import { generateUniformsSync, unsafeEvalSupported } from './utils'; import type { ISystem } from '../system/ISystem'; import type { Renderer } from '../Renderer'; import type { Shader } from './Shader'; import type { Program } from './Program'; import type { UniformGroup } from './UniformGroup'; import type { Dict } from '@pixi/utils'; import type { UniformsSyncCallback } from './utils'; import { generateUniformBufferSync } from './utils/generateUniformBufferSync'; import { generateProgram } from './utils/generateProgram'; import type { IRenderingContext } from '../IRenderer'; import type { ExtensionMetadata } from '@pixi/extensions'; import { extensions, ExtensionType } from '@pixi/extensions'; let UID = 0; // default sync data so we don't create a new one each time! const defaultSyncData = { textureCount: 0, uboCount: 0 }; /** * System plugin to the renderer to manage shaders. * @memberof PIXI */ export class ShaderSystem implements ISystem { /** @ignore */ static extension: ExtensionMetadata = { type: ExtensionType.RendererSystem, name: 'shader', }; /** * The current WebGL rendering context. * @member {WebGLRenderingContext} */ protected gl: IRenderingContext; public shader: Shader; public program: Program; public id: number; public destroyed = false; /** Cache to holds the generated functions. Stored against UniformObjects unique signature. */ private cache: Dict; private _uboCache: Dict<{size: number, syncFunc: UniformsSyncCallback}>; private renderer: Renderer; /** @param renderer - The renderer this System works for. */ constructor(renderer: Renderer) { this.renderer = renderer; // Validation check that this environment support `new Function` this.systemCheck(); this.gl = null; this.shader = null; this.program = null; this.cache = {}; this._uboCache = {}; this.id = UID++; } /** * Overrideable function by `@pixi/unsafe-eval` to silence * throwing an error if platform doesn't support unsafe-evals. * @private */ private systemCheck(): void { if (!unsafeEvalSupported()) { throw new Error('Current environment does not allow unsafe-eval, ' + 'please use @pixi/unsafe-eval module to enable support.'); } } protected contextChange(gl: IRenderingContext): void { this.gl = gl; this.reset(); } /** * Changes the current shader to the one given in parameter. * @param shader - the new shader * @param dontSync - false if the shader should automatically sync its uniforms. * @returns the glProgram that belongs to the shader. */ bind(shader: Shader, dontSync?: boolean): GLProgram { shader.uniforms.globals = this.renderer.globalUniforms; const program = shader.program; const glProgram = program.glPrograms[this.renderer.CONTEXT_UID] || this.generateProgram(shader); this.shader = shader; // TODO - some current Pixi plugins bypass this.. so it not safe to use yet.. if (this.program !== program) { this.program = program; this.gl.useProgram(glProgram.program); } if (!dontSync) { defaultSyncData.textureCount = 0; defaultSyncData.uboCount = 0; this.syncUniformGroup(shader.uniformGroup, defaultSyncData); } return glProgram; } /** * Uploads the uniforms values to the currently bound shader. * @param uniforms - the uniforms values that be applied to the current shader */ setUniforms(uniforms: Dict): void { const shader = this.shader.program; const glProgram = shader.glPrograms[this.renderer.CONTEXT_UID]; shader.syncUniforms(glProgram.uniformData, uniforms, this.renderer); } /* eslint-disable @typescript-eslint/explicit-module-boundary-types */ /** * Syncs uniforms on the group * @param group - the uniform group to sync * @param syncData - this is data that is passed to the sync function and any nested sync functions */ syncUniformGroup(group: UniformGroup, syncData?: any): void { const glProgram = this.getGlProgram(); if (!group.static || group.dirtyId !== glProgram.uniformDirtyGroups[group.id]) { glProgram.uniformDirtyGroups[group.id] = group.dirtyId; this.syncUniforms(group, glProgram, syncData); } } /** * Overrideable by the @pixi/unsafe-eval package to use static syncUniforms instead. * @param group * @param glProgram * @param syncData */ syncUniforms(group: UniformGroup, glProgram: GLProgram, syncData: any): void { const syncFunc = group.syncUniforms[this.shader.program.id] || this.createSyncGroups(group); syncFunc(glProgram.uniformData, group.uniforms, this.renderer, syncData); } createSyncGroups(group: UniformGroup): UniformsSyncCallback { const id = this.getSignature(group, this.shader.program.uniformData, 'u'); if (!this.cache[id]) { this.cache[id] = generateUniformsSync(group, this.shader.program.uniformData); } group.syncUniforms[this.shader.program.id] = this.cache[id]; return group.syncUniforms[this.shader.program.id]; } /** * Syncs uniform buffers * @param group - the uniform buffer group to sync * @param name - the name of the uniform buffer */ syncUniformBufferGroup(group: UniformGroup, name?: string) { const glProgram = this.getGlProgram(); if (!group.static || group.dirtyId !== 0 || !glProgram.uniformGroups[group.id]) { group.dirtyId = 0; const syncFunc = glProgram.uniformGroups[group.id] || this.createSyncBufferGroup(group, glProgram, name); // TODO wrap update in a cache?? group.buffer.update(); syncFunc(glProgram.uniformData, group.uniforms, this.renderer, defaultSyncData, group.buffer ); } this.renderer.buffer.bindBufferBase(group.buffer, glProgram.uniformBufferBindings[name]); } /** * Will create a function that uploads a uniform buffer using the STD140 standard. * The upload function will then be cached for future calls * If a group is manually managed, then a simple upload function is generated * @param group - the uniform buffer group to sync * @param glProgram - the gl program to attach the uniform bindings to * @param name - the name of the uniform buffer (must exist on the shader) */ protected createSyncBufferGroup(group: UniformGroup, glProgram: GLProgram, name: string): UniformsSyncCallback { const { gl } = this.renderer; this.renderer.buffer.bind(group.buffer); // bind them... const uniformBlockIndex = this.gl.getUniformBlockIndex(glProgram.program, name); glProgram.uniformBufferBindings[name] = this.shader.uniformBindCount; gl.uniformBlockBinding(glProgram.program, uniformBlockIndex, this.shader.uniformBindCount); this.shader.uniformBindCount++; const id = this.getSignature(group, this.shader.program.uniformData, 'ubo'); let uboData = this._uboCache[id]; if (!uboData) { uboData = this._uboCache[id] = generateUniformBufferSync(group, this.shader.program.uniformData); } if (group.autoManage) { const data = new Float32Array(uboData.size / 4); group.buffer.update(data); } glProgram.uniformGroups[group.id] = uboData.syncFunc; return glProgram.uniformGroups[group.id]; } /** * Takes a uniform group and data and generates a unique signature for them. * @param group - The uniform group to get signature of * @param group.uniforms * @param uniformData - Uniform information generated by the shader * @param preFix * @returns Unique signature of the uniform group */ private getSignature(group: {uniforms: Dict}, uniformData: Dict, preFix: string): string { const uniforms = group.uniforms; const strings = [`${preFix}-`]; for (const i in uniforms) { strings.push(i); if (uniformData[i]) { strings.push(uniformData[i].type); } } return strings.join('-'); } /** * Returns the underlying GLShade rof the currently bound shader. * * This can be handy for when you to have a little more control over the setting of your uniforms. * @returns The glProgram for the currently bound Shader for this context */ getGlProgram(): GLProgram { if (this.shader) { return this.shader.program.glPrograms[this.renderer.CONTEXT_UID]; } return null; } /** * Generates a glProgram version of the Shader provided. * @param shader - The shader that the glProgram will be based on. * @returns A shiny new glProgram! */ generateProgram(shader: Shader): GLProgram { const gl = this.gl; const program = shader.program; const glProgram = generateProgram(gl, program); program.glPrograms[this.renderer.CONTEXT_UID] = glProgram; return glProgram; } /** Resets ShaderSystem state, does not affect WebGL state. */ reset(): void { this.program = null; this.shader = null; } /** Destroys this System and removes all its textures. */ destroy(): void { this.renderer = null; // TODO implement destroy method for ShaderSystem this.destroyed = true; } } extensions.add(ShaderSystem);