@lightningjs/renderer
Version:
Lightning 3 Renderer
128 lines • 6.24 kB
JavaScript
import { DefaultShader } from './renderers/webgl/shaders/DefaultShader.js';
import { DefaultShaderBatched } from './renderers/webgl/shaders/DefaultShaderBatched.js';
import { DynamicShader, } from './renderers/webgl/shaders/DynamicShader.js';
import { RoundedRectangle } from './renderers/webgl/shaders/RoundedRectangle.js';
import { SdfShader } from './renderers/webgl/shaders/SdfShader.js';
import { RadiusEffect } from './renderers/webgl/shaders/effects/RadiusEffect.js';
import { BorderEffect } from './renderers/webgl/shaders/effects/BorderEffect.js';
import { LinearGradientEffect, } from './renderers/webgl/shaders/effects/LinearGradientEffect.js';
import { GrayscaleEffect, } from './renderers/webgl/shaders/effects/GrayscaleEffect.js';
import { BorderRightEffect } from './renderers/webgl/shaders/effects/BorderRightEffect.js';
import { BorderTopEffect } from './renderers/webgl/shaders/effects/BorderTopEffect.js';
import { BorderBottomEffect } from './renderers/webgl/shaders/effects/BorderBottomEffect.js';
import { BorderLeftEffect } from './renderers/webgl/shaders/effects/BorderLeftEffect.js';
import { GlitchEffect, } from './renderers/webgl/shaders/effects/GlitchEffect.js';
import { FadeOutEffect, } from './renderers/webgl/shaders/effects/FadeOutEffect.js';
import { RadialGradientEffect, } from './renderers/webgl/shaders/effects/RadialGradientEffect.js';
import { RadialProgressEffect, } from './renderers/webgl/shaders/effects/RadialProgressEffect.js';
import { HolePunchEffect, } from './renderers/webgl/shaders/effects/HolePunchEffect.js';
import { WebGlCoreShader } from './renderers/webgl/WebGlCoreShader.js';
import { UnsupportedShader } from './renderers/canvas/shaders/UnsupportedShader.js';
import { ShaderController } from '../main-api/ShaderController.js';
import { DynamicShaderController, } from '../main-api/DynamicShaderController.js';
export class CoreShaderManager {
shCache = new Map();
shConstructors = {};
attachedShader = null;
effectConstructors = {};
renderer;
constructor() {
this.registerShaderType('DefaultShader', DefaultShader);
this.registerShaderType('DefaultShaderBatched', DefaultShaderBatched);
this.registerShaderType('RoundedRectangle', RoundedRectangle);
this.registerShaderType('DynamicShader', DynamicShader);
this.registerShaderType('SdfShader', SdfShader);
this.registerEffectType('border', BorderEffect);
this.registerEffectType('borderBottom', BorderBottomEffect);
this.registerEffectType('borderLeft', BorderLeftEffect);
this.registerEffectType('borderRight', BorderRightEffect);
this.registerEffectType('borderTop', BorderTopEffect);
this.registerEffectType('fadeOut', FadeOutEffect);
this.registerEffectType('linearGradient', LinearGradientEffect);
this.registerEffectType('radialGradient', RadialGradientEffect);
this.registerEffectType('grayscale', GrayscaleEffect);
this.registerEffectType('glitch', GlitchEffect);
this.registerEffectType('radius', RadiusEffect);
this.registerEffectType('radialProgress', RadialProgressEffect);
this.registerEffectType('holePunch', HolePunchEffect);
}
registerShaderType(shType, shClass) {
this.shConstructors[shType] = shClass;
}
registerEffectType(effectType, effectClass) {
this.effectConstructors[effectType] = effectClass;
}
getRegisteredEffects() {
return this.effectConstructors;
}
getRegisteredShaders() {
return this.shConstructors;
}
/**
* Loads a shader (if not already loaded) and returns a controller for it.
*
* @param shType
* @param props
* @returns
*/
loadShader(shType, props) {
if (!this.renderer) {
throw new Error(`Renderer is not been defined`);
}
const ShaderClass = this.shConstructors[shType];
if (!ShaderClass) {
throw new Error(`Shader type "${shType}" is not registered`);
}
if (this.renderer.mode === 'canvas' &&
ShaderClass.prototype instanceof WebGlCoreShader) {
return this._createShaderCtr(shType, new UnsupportedShader(shType), props);
}
if (shType === 'DynamicShader') {
return this.loadDynamicShader(props);
}
const resolvedProps = ShaderClass.resolveDefaults(props);
const cacheKey = ShaderClass.makeCacheKey(resolvedProps) || ShaderClass.name;
if (cacheKey && this.shCache.has(cacheKey)) {
return this._createShaderCtr(shType, this.shCache.get(cacheKey), resolvedProps);
}
// @ts-expect-error ShaderClass WILL accept a Renderer
const shader = new ShaderClass(this.renderer, props);
if (cacheKey) {
this.shCache.set(cacheKey, shader);
}
return this._createShaderCtr(shType, shader, resolvedProps);
}
loadDynamicShader(props) {
if (!this.renderer) {
throw new Error(`Renderer is not been defined`);
}
const resolvedProps = DynamicShader.resolveDefaults(props, this.effectConstructors);
const cacheKey = DynamicShader.makeCacheKey(resolvedProps, this.effectConstructors);
if (cacheKey && this.shCache.has(cacheKey)) {
return this._createDynShaderCtr(this.shCache.get(cacheKey), resolvedProps);
}
const shader = new DynamicShader(this.renderer, props, this.effectConstructors);
if (cacheKey) {
this.shCache.set(cacheKey, shader);
}
return this._createDynShaderCtr(shader, resolvedProps);
}
_createShaderCtr(type, shader, props) {
return new ShaderController(type, shader, props, this.renderer.stage);
}
_createDynShaderCtr(shader, props) {
shader.bindUniformMethods(props);
return new DynamicShaderController(shader, props, this);
}
useShader(shader) {
if (this.attachedShader === shader) {
return;
}
if (this.attachedShader) {
this.attachedShader.detach();
}
shader.attach();
this.attachedShader = shader;
}
}
//# sourceMappingURL=CoreShaderManager.js.map