threepipe
Version:
A 3D viewer framework built on top of three.js in TypeScript with a focus on quality rendering, modularity and extensibility.
180 lines • 6.31 kB
TypeScript
import type { Color, Event, IUniform, Material, MaterialParameters, Shader } from 'three';
import type { IDisposable, IJSONSerializable } from 'ts-browser-helpers';
import type { MaterialExtension } from '../materials';
import type { ChangeEvent, IUiConfigContainer } from 'uiconfig.js';
import type { SerializationMetaType } from '../utils';
import type { IObject3D } from './IObject';
import { ISetDirtyCommonOptions } from './IObject';
import type { ITexture } from './ITexture';
import type { IImportResultUserData } from '../assetmanager';
export type IMaterialParameters = MaterialParameters & {
customMaterialExtensions?: MaterialExtension[];
};
export type IMaterialEventTypes = 'dispose' | 'materialUpdate' | 'beforeRender' | 'beforeCompile' | 'afterRender' | 'textureUpdate' | 'beforeDeserialize';
export type IMaterialEvent<T extends string = IMaterialEventTypes> = Event & {
type: T;
bubbleToObject?: boolean;
bubbleToParent?: boolean;
material?: IMaterial;
texture?: ITexture;
oldTexture?: ITexture;
uiChangeEvent?: ChangeEvent;
};
export interface IMaterialSetDirtyOptions extends ISetDirtyCommonOptions {
/**
* @default true
*/
bubbleToObject?: boolean;
/**
* @default true
*/
needsUpdate?: boolean;
[key: string]: any;
}
export interface IMaterialUserData extends IImportResultUserData {
uuid?: string;
/**
* Automatically dispose material when not used by any object in the scene
* @default true
*/
disposeOnIdle?: boolean;
renderToGBuffer?: boolean;
/**
* Same as {@link renderToGBuffer} but for depth only, not normal or flags etc
*/
renderToDepth?: boolean;
/**
* Flag to tell the scene to prefer `material.envMapIntensity` over `scene.envMapIntensity`
* only for materials that have envMapIntensity
*/
separateEnvMapIntensity?: boolean;
/**
* The environment map to use in the `RootScene`. To use this, object with the material must be in the RootScene, and the key should exist in the `RootScene`'s `textureSlots`.
*
* only for materials that have envMap
*/
envMapSlotKey?: string;
cloneId?: string;
cloneCount?: number;
__envIntensity?: number;
__isVariation?: boolean;
inverseAlphaMap?: boolean;
/**
* See {@link MaterialManager.dispose} as {@link BaseGroundPlugin._refreshMaterial}
*/
runtimeMaterial?: boolean;
/**
* See {@link GBufferPlugin}
*/
gBufferData?: {
materialId?: number;
/**
* @default true
*/
tonemapEnabled?: boolean;
[key: string]: any;
};
/**
* Force a depth value in GBuffer.
* This is useful to force center values like 0 to the depth.
*/
forcedLinearDepth?: number;
/**
* General flag to disable multiple plugins on the material at once, like SSAO, SSR, Bloom etc.
*/
pluginsDisabled?: boolean;
/**
* For SSCSPlugin
*/
sscsDisabled?: boolean;
/**
* For SSRPlugin
*/
ssreflDisabled?: boolean;
/**
* For SSRPlugin
*/
ssreflNonPhysical?: boolean;
[key: string]: any;
/**
* @deprecated
*/
setDirty?: (options?: IMaterialSetDirtyOptions) => void;
/**
* @deprecated Use {@link postTonemap.tonemapEnabled} instead. This is kept because used in old files.
*/
postTonemap?: boolean;
}
export interface IMaterial<E extends IMaterialEvent = IMaterialEvent, ET = IMaterialEventTypes> extends Material<E, ET>, IJSONSerializable, IDisposable, IUiConfigContainer {
constructor: {
TYPE: string;
TypeSlug: string;
MaterialProperties?: Record<string, any>;
MaterialTemplate?: IMaterialTemplate;
};
assetType: 'material';
setDirty(options?: IMaterialSetDirtyOptions): void;
needsUpdate: boolean;
setValues(parameters: Material | (MaterialParameters & {
type?: string;
}), allowInvalidType?: boolean, clearCurrentUserData?: boolean): this;
toJSON(meta?: SerializationMetaType, _internal?: boolean): any;
fromJSON(json: any, meta?: SerializationMetaType, _internal?: boolean): this | null;
extraUniformsToUpload: Record<string, IUniform>;
materialExtensions: MaterialExtension[];
registerMaterialExtensions: (customMaterialExtensions: MaterialExtension[]) => void;
unregisterMaterialExtensions: (customMaterialExtensions: MaterialExtension[]) => void;
/**
* Managed internally, do not change manually
*/
generator?: IMaterialGenerator;
/**
* Managed internally, do not change manually
*/
appliedMeshes: Set<IObject3D>;
lastShader?: Shader;
userData: IMaterialUserData;
/**
* Disposes the material from the GPU.
* Set force to false if not sure the material is used by any object in the scene.
* // todo add check for visible in scene also? or is that overkill
* @param force - when true, same as three.js dispose. when false, only disposes if disposeOnIdle not false and not used by any object in the scene. default: true
*/
dispose(force?: boolean): void;
flatShading?: boolean;
map?: ITexture | null;
alphaMap?: ITexture | null;
envMap?: ITexture | null;
envMapIntensity?: number;
aoMap?: ITexture | null;
lightMap?: ITexture | null;
normalMap?: ITexture | null;
bumpMap?: ITexture | null;
displacementMap?: ITexture | null;
aoMapIntensity?: number;
lightMapIntensity?: number;
roughnessMap?: ITexture | null;
metalnessMap?: ITexture | null;
roughness?: number;
metalness?: number;
transmissionMap?: ITexture | null;
transmission?: number;
color?: Color;
wireframe?: boolean;
linewidth?: number;
isRawShaderMaterial?: boolean;
isPhysicalMaterial?: boolean;
isUnlitMaterial?: boolean;
isGBufferMaterial?: boolean;
}
export type IMaterialGenerator<T extends IMaterial = IMaterial> = (params: any) => T;
export interface IMaterialTemplate<T extends IMaterial = IMaterial, TP = any> {
templateUUID?: string;
name: string;
typeSlug?: string;
alias?: string[];
materialType: string;
generator?: IMaterialGenerator<T>;
params?: TP;
}
//# sourceMappingURL=IMaterial.d.ts.map