@polygonjs/polygonjs
Version:
node-based WebGL 3D engine https://polygonjs.com
236 lines (235 loc) • 10.3 kB
TypeScript
import { PolyScene } from '../scene/PolyScene';
import { CoreGraphNode } from '../../core/graph/CoreGraphNode';
import { UIData } from './utils/UIData';
import { FlagsController, FlagsControllerD } from './utils/FlagsController';
import { NodeStatesController } from './utils/StatesController';
import { HierarchyParentController } from './utils/hierarchy/ParentController';
import { HierarchyChildrenController, NodeCreateOptions } from './utils/hierarchy/ChildrenController';
import { NodeLifeCycleController } from './utils/LifeCycleController';
import { TypedContainerController } from './utils/ContainerController';
import { NodeCookController, OnCookCompleteHook } from './utils/CookController';
import { NameController } from './utils/NameController';
import { CoreNodeSerializer, NodeSerializerData } from './utils/CoreNodeSerializer';
import { ParamsController } from './utils/params/ParamsController';
import { ParamConstructorMap } from '../params/types/ParamConstructorMap';
import { ParamInitValuesTypeMap } from '../params/types/ParamInitValuesTypeMap';
import { NodeParamsConfig } from './utils/params/ParamsConfig';
import { ParamsValueAccessorType } from './utils/params/ParamsValueAccessor';
import { IOController } from './utils/io/IOController';
import { NodeEvent } from '../poly/NodeEvent';
import { BaseNodeByContextMap, NodeContext } from '../poly/NodeContext';
import { ParamsAccessorType } from './utils/params/ParamsAccessor';
import { ContainableMap } from '../containers/utils/ContainableMap';
import { ParamOptions } from '../params/utils/OptionsController';
import { ParamType } from '../poly/ParamType';
import { DisplayNodeController } from './utils/DisplayNodeController';
import { ParamInitValueSerialized } from '../params/types/ParamInitValueSerialized';
import { ModuleName } from '../poly/registers/modules/Common';
import { BasePersistedConfig } from './utils/BasePersistedConfig';
import { AssemblerName } from '../poly/registers/assemblers/_BaseRegister';
import { PolyNodeController } from './utils/poly/PolyNodeController';
import { CoreGraphNodeId } from '../../core/graph/CoreGraph';
import { PolyDictionary } from '../../types/GlobalTypes';
import { SetInputsOptions } from './utils/io/InputsController';
import { OnNodeRegisterCallback } from '../poly/registers/nodes/NodesRegister';
import { EventDispatcher, BaseEvent, EventListener } from 'three';
import { CoreObjectType, ObjectContent } from '../../core/geometry/ObjectContent';
export interface NodeDeletedEmitData {
parent_id: CoreGraphNodeId;
}
export interface NodeCreatedEmitData {
child_node_json: NodeSerializerData;
}
type EmitDataByNodeEventMapGeneric = {
[key in NodeEvent]: any;
};
export interface EmitDataByNodeEventMap extends EmitDataByNodeEventMapGeneric {
[NodeEvent.CREATED]: NodeCreatedEmitData;
[NodeEvent.DELETED]: NodeDeletedEmitData;
[NodeEvent.ERROR_UPDATED]: undefined;
}
export interface IntegrationData {
name: string;
data: PolyDictionary<string>;
}
export interface BaseNodeEvent extends BaseEvent {
target?: BaseNodeType;
}
export type NodeEventListener = EventListener<BaseNodeEvent, string, EventDispatcher<BaseNodeEvent>>;
export declare const DEFAULT_DATA_TYPE = "default";
/**
*
*
* TypedNode is the base class that all nodes inherit from. This inherits from [CoreGraphNode](/docs/api/CoreGraphNode).
*
*/
export declare class TypedNode<NC extends NodeContext, K extends NodeParamsConfig> extends CoreGraphNode {
createOptions?: NodeCreateOptions | undefined;
containerController: TypedContainerController<NC>;
private _parentController;
private _uiData;
private _states;
private _lifecycle;
private _serializer;
private _cookController;
readonly flags: FlagsController | undefined;
readonly displayNodeController: DisplayNodeController | undefined;
readonly persisted_config: BasePersistedConfig | undefined;
private _paramsController;
readonly paramsConfig: K | undefined;
readonly pv: ParamsValueAccessorType<K>;
readonly p: ParamsAccessorType<K>;
copy_param_values(node: TypedNode<NC, K>): void;
dataType(): string;
private _nameController;
get parentController(): HierarchyParentController;
static displayedInputNames(): string[] | undefined;
displayedInputNames(): string[] | undefined;
private _childrenController;
protected _childrenControllerContext: NodeContext | undefined;
childrenControllerContext(): NodeContext | undefined;
private _create_childrenController;
get childrenController(): HierarchyChildrenController | undefined;
childrenAllowed(): boolean;
sceneReadonly(): boolean;
get uiData(): UIData;
get states(): NodeStatesController<NC>;
get lifecycle(): NodeLifeCycleController;
get serializer(): CoreNodeSerializer | undefined;
get cookController(): NodeCookController<NC>;
protected _io: IOController<NC> | undefined;
get io(): IOController<NC>;
get nameController(): NameController;
/**
* sets the name of a node. Note that if a sibling node already has that name, it will be updated to be unique.
*
*/
setName(name: string): void;
_setCoreName(name: string): void;
get params(): ParamsController;
constructor(scene: PolyScene, nodeName?: string, createOptions?: NodeCreateOptions | undefined);
private _initialized;
initializeBaseAndNode(): void;
protected initializeBaseNode(): void;
protected initializeNode(): void;
static type(): string;
static onRegister: OnNodeRegisterCallback | undefined;
/**
* returns the type of the node.
*
*/
type(): string;
static context(): NodeContext;
/**
* returns the context.
*
*/
context(): NodeContext;
static requireWebGL2(): boolean;
requireWebGL2(): boolean;
setParent(parent: BaseNodeType | null): void;
/**
* returns the parent.
*
*/
parent(): BaseNodeType | null;
insideALockedParent(): boolean;
lockedOrInsideALockedParent(): boolean;
selfOrLockedParent(): BaseNodeType | null;
lockedParent(): BaseNodeType | null;
firstAncestorWithContext<N extends NodeContext>(context: N): BaseNodeByContextMap[N] | null;
root(): import("./manager/Root").RootManagerNode;
/**
* returns the path.
*
*/
path(relative_to_parent?: BaseNodeType): string;
createParams(): void;
addParam<T extends ParamType>(type: T, name: string, default_value: ParamInitValuesTypeMap[T], options?: ParamOptions): ParamConstructorMap[T] | undefined;
paramDefaultValue(name: string): ParamInitValueSerialized;
cook(inputContents: any[]): any;
/**
* registers a callback that will be run every time the node finishes cooking.
*
*/
onCookEnd(callbackName: string, callback: OnCookCompleteHook): void;
/**
* returns a promise that will be resolved when the node finishes cooking.
*
*/
compute(): Promise<import("../containers/utils/ContainerMap").ContainerMap[NC]>;
_setContainer(content: ContainableMap[NC]): void;
/**
* create a node.
*
*/
createNode(nodeClass: any, options?: NodeCreateOptions): BaseNodeType | undefined;
createOperationContainer(type: string, operation_container_name: string, options?: NodeCreateOptions): import("../operations/container/_Base").BaseOperationContainer<any> | undefined;
/**
* removes a child node
*
*/
removeNode(node: BaseNodeType): void;
dispose(): void;
/**
* returns the list of children
*
*/
children(): Readonly<BaseNodeType[]>;
/**
* returns a child node
*
*/
node(path: string): BaseNodeType | null;
/**
* returns a sibling node
*
*/
nodeSibling(name: string): BaseNodeByContextMap[NC] | null;
/**
* returns the children matching the type
*
*/
nodesByType(type: string): BaseNodeType[];
/**
* sets a node as input
*
*/
setInput(inputIndexOrName: number | string, node: BaseNodeByContextMap[NC] | null, outputIndexOrName?: number | string, options?: SetInputsOptions): void;
emit(event_name: NodeEvent.CREATED, data: EmitDataByNodeEventMap[NodeEvent.CREATED]): void;
emit(event_name: NodeEvent.DELETED, data: EmitDataByNodeEventMap[NodeEvent.DELETED]): void;
emit(event_name: NodeEvent.NAME_UPDATED): void;
emit(event_name: NodeEvent.OVERRIDE_CLONABLE_STATE_UPDATE): void;
emit(event_name: NodeEvent.NAMED_INPUTS_UPDATED): void;
emit(event_name: NodeEvent.NAMED_OUTPUTS_UPDATED): void;
emit(event_name: NodeEvent.INPUTS_UPDATED): void;
emit(event_name: NodeEvent.PARAMS_UPDATED): void;
emit(event_name: NodeEvent.UI_DATA_POSITION_UPDATED): void;
emit(event_name: NodeEvent.UI_DATA_COMMENT_UPDATED): void;
emit(event_name: NodeEvent.ERROR_UPDATED): void;
emit(event_name: NodeEvent.FLAG_BYPASS_UPDATED): void;
emit(event_name: NodeEvent.FLAG_DISPLAY_UPDATED): void;
emit(event_name: NodeEvent.FLAG_OPTIMIZE_UPDATED): void;
emit(event_name: NodeEvent.SELECTION_UPDATED): void;
emit(event_name: NodeEvent.POLY_NODE_LOCK_STATE_UPDATED): void;
private __eventsDispatcher;
private _eventsDispatcher;
dispatchEvent(event: BaseEvent<string>): void;
addEventListener(type: string, listener: NodeEventListener): void;
removeEventListener(type: string, listener: NodeEventListener): void;
toJSON(includeParamComponents?: boolean): NodeSerializerData | undefined;
requiredModules(): ModuleName[] | void;
usedAssembler(): AssemblerName | void;
integrationData(): IntegrationData | void;
readonly polyNodeController: PolyNodeController | undefined;
processError(e: unknown): unknown;
updateObjectOnAdd(object: ObjectContent<CoreObjectType>, parent: ObjectContent<CoreObjectType>): void;
updateObjectOnRemove(object: ObjectContent<CoreObjectType>, parent: ObjectContent<CoreObjectType>): void;
}
export type BaseNodeType = TypedNode<any, any>;
export declare class BaseNodeClass extends TypedNode<any, any> {
}
export declare class BaseNodeClassWithDisplayFlag extends TypedNode<any, any> {
readonly flags: FlagsControllerD;
}
export {};