threepipe
Version:
A modern 3D viewer framework built on top of three.js, written in TypeScript, designed to make creating high-quality, modular, and extensible 3D experiences on the web simple and enjoyable.
327 lines • 14 kB
TypeScript
import { IUniform, RenderTargetOptions, ShadowMapType, Vector2, Vector4, WebGLRenderer, WebGLRenderTarget, WebGLShadowMap } from 'three';
import { EffectComposer2, IPassID, IPipelinePass } from '../postprocessing';
import { IRenderTarget } from './RenderTarget';
import { RenderTargetManager } from './RenderTargetManager';
import { IShaderPropertiesUpdater } from '../materials';
import { IRenderManager, IRenderManagerOptions, IScene, IWebGLRenderer } from '../core';
import { Class } from 'ts-browser-helpers';
import { UiObjectConfig } from 'uiconfig.js';
import { BlobExt } from '../assetmanager';
import { IRenderManagerEventMap, RendererBlitOptions } from '../core/IRenderer';
export declare class RenderManager<TE extends IRenderManagerEventMap = IRenderManagerEventMap> extends RenderTargetManager<IRenderManagerEventMap & TE> implements IShaderPropertiesUpdater, IRenderManager<IRenderManagerEventMap & TE> {
private readonly _isWebGL2;
private readonly _composer;
private readonly _context;
private readonly _renderSize;
protected readonly _renderer: IWebGLRenderer<this>;
private _renderScale;
get renderScale(): number;
set renderScale(value: number);
shadowMapType: ShadowMapType;
shadowMap: WebGLShadowMap;
private _shadowMapTypeChanged;
private _passes;
private _pipeline;
private _passesNeedsUpdate;
private _frameCount;
private _lastTime;
private _totalFrameCount;
static readonly POWER_PREFERENCE: WebGLPowerPreference;
get renderer(): IWebGLRenderer<this>;
/**
* Use total frame count, if this is set to true, then frameCount won't be reset when the viewer is set to dirty.
* Which will generate different random numbers for each frame during postprocessing steps. With TAA set properly, this will give a smoother result.
*/
stableNoise: boolean;
frameWaitTime: number;
protected _dirty: boolean;
/**
* Set autoBuildPipeline = false to be able to set the pipeline manually.
*/
autoBuildPipeline: boolean;
rebuildPipeline(setDirty?: boolean): void;
/**
* Regenerates the render pipeline by resolving dependencies and sorting the passes.
* This is called automatically when the passes are changed.
*/
private _refreshPipeline;
animationLoop(time: number, frame?: XRFrame): void;
constructor({ canvas, alpha, renderScale, powerPreference, targetOptions }: IRenderManagerOptions);
protected _initWebGLRenderer(canvas: HTMLCanvasElement, alpha: boolean, stencil: boolean, powerPreference?: WebGLPowerPreference): IWebGLRenderer<this>;
setSize(width?: number, height?: number, force?: boolean): void;
/**
* Default value for renderToScreen in {@link render}
*/
defaultRenderToScreen: boolean;
render(scene: IScene, renderToScreen?: boolean): void;
incRenderToScreen(): void;
onPostFrame: () => void;
get needsRender(): boolean;
setDirty(reset?: boolean): void;
reset(): void;
resetShadows(): void;
refreshPasses(): void;
dispose(clear?: boolean): void;
updateShaderProperties(material: {
defines: Record<string, string | number | undefined>;
uniforms: {
[name: string]: IUniform;
};
}): this;
registerPass(pass: IPipelinePass, replaceId?: boolean): void;
unregisterPass(pass: IPipelinePass): void;
get frameCount(): number;
get totalFrameCount(): number;
resetTotalFrameCount(): void;
set pipeline(value: IPassID[]);
get pipeline(): IPassID[];
get composer(): EffectComposer2;
get passes(): IPipelinePass[];
get isWebGL2(): boolean;
get composerTarget(): IRenderTarget;
get composerTarget2(): IRenderTarget;
/**
* The size set in the three.js renderer.
* Final size is renderSize * renderScale
*/
get renderSize(): Vector2;
get context(): WebGLRenderingContext;
/**
* Same as {@link renderer}
*/
get webglRenderer(): WebGLRenderer;
/**
* @deprecated will be removed in the future
*/
get useLegacyLights(): boolean;
set useLegacyLights(v: boolean);
get clock(): import('three').Clock;
/**
* blit - blits a texture to the screen or another render target.
* @param destination - destination target, or screen if undefined or null
* @param source - source Texture
* @param viewport - viewport and scissor
* @param material - override material
* @param clear - clear before blit
* @param respectColorSpace - does color space conversion when reading and writing to the target
* @param blending - Note - Set to NormalBlending if transparent is set to false
* @param transparent
* @param opacity - opacity of the material, if not set, uses the material's opacity
* @param blendAlpha - custom blending factor, if set, overrides blending. The material will use CustomBlending with ConstantAlphaFactor and OneMinusConstantAlphaFactor, useful to blend between textures.
*/
blit(destination: IRenderTarget | undefined | null, { source, viewport, material, clear, respectColorSpace, blending, transparent, opacity, blendAlpha }?: RendererBlitOptions): void;
clearColor({ r, g, b, a, target, depth, stencil, viewport }: {
r?: number;
g?: number;
b?: number;
a?: number;
target?: IRenderTarget;
depth?: boolean;
stencil?: boolean;
viewport?: Vector4;
}): void;
/**
* Copies a render target to a new/existing canvas element.
* Note: this will clamp the values to [0, 1] and converts to srgb for float and half-float render targets.
* @param target
* @param textureIndex - index of the texture to use in the render target (only in case of multiple render target)
* @param canvas - optional canvas to render to, if not provided a new canvas will be created.
*/
renderTargetToCanvas(target: WebGLRenderTarget | IRenderTarget, textureIndex?: number, canvas?: HTMLCanvasElement): HTMLCanvasElement;
/**
* Converts a render target to a png/jpeg data url string.
* Note: this will clamp the values to [0, 1] and converts to srgb for float and half-float render targets.
* @param target
* @param mimeType
* @param quality
* @param textureIndex - index of the texture to use in the render target (only in case of multiple render target)
*/
renderTargetToDataUrl(target: WebGLRenderTarget | IRenderTarget, mimeType?: string, quality?: number, textureIndex?: number): string;
/**
* Rend pixels from a render target into a new Uint8Array|Uint16Array|Float32Array buffer
* @param target - render target to read from
* @param textureIndex - index of the texture to use in the render target (only in case of multiple render target)
*/
renderTargetToBuffer(target: WebGLRenderTarget, textureIndex?: number): Uint8Array | Uint16Array | Float32Array;
/**
* Exports a render target to a blob. The type is automatically picked from exr to png based on the render target.
* @param target - render target to export
* @param mimeType - mime type to use.
* If auto (default), then it will be picked based on the render target type.
* @param textureIndex - index of the texture to use in the render target (only in case of multiple render target)
*/
exportRenderTarget(target: WebGLRenderTarget, mimeType?: string, textureIndex?: number): BlobExt;
uiConfig?: UiObjectConfig;
private _updated;
protected _createTargetClass(clazz: Class<WebGLRenderTarget>, size: number[], options: RenderTargetOptions): IRenderTarget;
static ShaderChunk: {
alphahash_fragment: string;
alphahash_pars_fragment: string;
alphamap_fragment: string;
alphamap_pars_fragment: string;
alphatest_fragment: string;
alphatest_pars_fragment: string;
aomap_fragment: string;
aomap_pars_fragment: string;
batching_pars_vertex: string;
begin_vertex: string;
beginnormal_vertex: string;
bsdfs: string;
iridescence_fragment: string;
bumpmap_pars_fragment: string;
clipping_planes_fragment: string;
clipping_planes_pars_fragment: string;
clipping_planes_pars_vertex: string;
clipping_planes_vertex: string;
color_fragment: string;
color_pars_fragment: string;
color_pars_vertex: string;
color_vertex: string;
common: string;
cube_uv_reflection_fragment: string;
defaultnormal_vertex: string;
displacementmap_pars_vertex: string;
displacementmap_vertex: string;
emissivemap_fragment: string;
emissivemap_pars_fragment: string;
colorspace_fragment: string;
colorspace_pars_fragment: string;
envmap_fragment: string;
envmap_common_pars_fragment: string;
envmap_pars_fragment: string;
envmap_pars_vertex: string;
envmap_physical_pars_fragment: string;
envmap_vertex: string;
fog_vertex: string;
fog_pars_vertex: string;
fog_fragment: string;
fog_pars_fragment: string;
gradientmap_pars_fragment: string;
lightmap_fragment: string;
lightmap_pars_fragment: string;
lights_lambert_fragment: string;
lights_lambert_pars_fragment: string;
lights_pars_begin: string;
lights_toon_fragment: string;
lights_toon_pars_fragment: string;
lights_phong_fragment: string;
lights_phong_pars_fragment: string;
lights_physical_fragment: string;
lights_physical_pars_fragment: string;
lights_fragment_begin: string;
lights_fragment_maps: string;
lights_fragment_end: string;
logdepthbuf_fragment: string;
logdepthbuf_pars_fragment: string;
logdepthbuf_pars_vertex: string;
logdepthbuf_vertex: string;
map_fragment: string;
map_pars_fragment: string;
map_particle_fragment: string;
map_particle_pars_fragment: string;
metalnessmap_fragment: string;
metalnessmap_pars_fragment: string;
morphcolor_vertex: string;
morphnormal_vertex: string;
morphtarget_pars_vertex: string;
morphtarget_vertex: string;
normal_fragment_begin: string;
normal_fragment_maps: string;
normal_pars_fragment: string;
normal_pars_vertex: string;
normal_vertex: string;
normalmap_pars_fragment: string;
clearcoat_normal_fragment_begin: string;
clearcoat_normal_fragment_maps: string;
clearcoat_pars_fragment: string;
iridescence_pars_fragment: string;
opaque_fragment: string;
packing: string;
premultiplied_alpha_fragment: string;
project_vertex: string;
dithering_fragment: string;
dithering_pars_fragment: string;
roughnessmap_fragment: string;
roughnessmap_pars_fragment: string;
shadowmap_pars_fragment: string;
shadowmap_pars_vertex: string;
shadowmap_vertex: string;
shadowmask_pars_fragment: string;
skinbase_vertex: string;
skinning_pars_vertex: string;
skinning_vertex: string;
skinnormal_vertex: string;
specularmap_fragment: string;
specularmap_pars_fragment: string;
tonemapping_fragment: string;
tonemapping_pars_fragment: string;
transmission_fragment: string;
transmission_pars_fragment: string;
uv_pars_fragment: string;
uv_pars_vertex: string;
uv_vertex: string;
worldpos_vertex: string;
background_vert: string;
background_frag: string;
backgroundCube_vert: string;
backgroundCube_frag: string;
cube_vert: string;
cube_frag: string;
depth_vert: string;
depth_frag: string;
distanceRGBA_vert: string;
distanceRGBA_frag: string;
equirect_vert: string;
equirect_frag: string;
linedashed_vert: string;
linedashed_frag: string;
meshbasic_vert: string;
meshbasic_frag: string;
meshlambert_vert: string;
meshlambert_frag: string;
meshmatcap_vert: string;
meshmatcap_frag: string;
meshnormal_vert: string;
meshnormal_frag: string;
meshphong_vert: string;
meshphong_frag: string;
meshphysical_vert: string;
meshphysical_frag: string;
meshtoon_vert: string;
meshtoon_frag: string;
points_vert: string;
points_frag: string;
shadow_vert: string;
shadow_frag: string;
sprite_vert: string;
sprite_frag: string;
};
static ShaderLib: {
[name: string]: import('three').ShaderLibShader;
basic: import('three').ShaderLibShader;
lambert: import('three').ShaderLibShader;
phong: import('three').ShaderLibShader;
standard: import('three').ShaderLibShader;
matcap: import('three').ShaderLibShader;
points: import('three').ShaderLibShader;
dashed: import('three').ShaderLibShader;
depth: import('three').ShaderLibShader;
normal: import('three').ShaderLibShader;
sprite: import('three').ShaderLibShader;
background: import('three').ShaderLibShader;
cube: import('three').ShaderLibShader;
equirect: import('three').ShaderLibShader;
distanceRGBA: import('three').ShaderLibShader;
shadow: import('three').ShaderLibShader;
physical: import('three').ShaderLibShader;
};
/**
* @deprecated use renderScale instead
*/
get displayCanvasScaling(): number;
/**
* @deprecated use renderScale instead
*/
set displayCanvasScaling(value: number);
}
//# sourceMappingURL=../src/rendering/RenderManager.d.ts.map