@polygonjs/polygonjs/dist/src/engine/params/_Base.d.ts

node-based WebGL 3D engine https://polygonjs.com

import { CoreGraphNode } from '../../core/graph/CoreGraphNode';
import { BaseNodeType } from '../nodes/_Base';
import { OptionsController } from './utils/OptionsController';
import { ExpressionController } from './utils/ExpressionController';
import { EmitController } from './utils/EmitController';
import { CoreParamSerializer } from './utils/CoreParamSerializer';
import { ParamStatesController } from './utils/StatesController';
import { TypedMultipleParam } from './_Multiple';
import { FloatParam } from './Float';
import { ParamType } from '../poly/ParamType';
import { ParamEvent } from '../poly/ParamEvent';
import { PolyScene } from '../scene/PolyScene';
import { ParamInitValuesTypeMap } from '../params/types/ParamInitValuesTypeMap';
import { ParamValuesTypeMap } from '../params/types/ParamValuesTypeMap';
import { ParamValueSerializedTypeMap, ParamValuePreConversionSerializedTypeMap } from '../params/types/ParamValueSerializedTypeMap';
import { ParamInitValueSerializedTypeMap } from './types/ParamInitValueSerializedTypeMap';
type ComputeCallback = (value: void) => void;
type OnDisposeCallback = () => void;
export interface ParamOptions<T extends ParamType> {
    serializerClass?: typeof CoreParamSerializer<T>;
}
export declare abstract class TypedParam<T extends ParamType> extends CoreGraphNode {
    protected _default_value: ParamInitValuesTypeMap[T];
    protected _raw_input: ParamInitValuesTypeMap[T];
    protected _value: ParamValuesTypeMap[T];
    protected _node: BaseNodeType | undefined;
    protected _parent_param: TypedMultipleParam<any> | undefined;
    protected _components: FloatParam[] | undefined;
    protected _computeResolves: ComputeCallback[] | undefined;
    private _options;
    get options(): OptionsController;
    private _emitController;
    get emitController(): EmitController;
    protected _expression_controller: ExpressionController<T> | undefined;
    get expressionController(): ExpressionController<T> | undefined;
    expressionParsedAsString(): boolean;
    protected _serializer: CoreParamSerializer<T> | undefined;
    get serializer(): CoreParamSerializer<T> | undefined;
    private _states;
    get states(): ParamStatesController;
    constructor(scene: PolyScene, node: BaseNodeType, options: ParamOptions<T>);
    dispose(): void;
    protected _initializeParam(): void;
    postOptionsInitialize(): void;
    static type(): ParamType;
    type(): T;
    isNumeric(): boolean;
    setName(name: string): void;
    get value(): ParamValuesTypeMap[T];
    abstract defaultValueSerialized(): ParamInitValueSerializedTypeMap[T];
    abstract rawInputSerialized(): ParamInitValueSerializedTypeMap[T];
    abstract valueSerialized(): ParamValueSerializedTypeMap[T];
    copyValue(param: BaseParamType): void;
    protected _copyValue(param: TypedParam<T>): void;
    valuePreConversionSerialized(): ParamValuePreConversionSerializedTypeMap[T];
    convert(rawVal: any): ParamValuesTypeMap[T] | null;
    static areRawInputEqual(val1: any, val2: any): boolean;
    isRawInputEqual(other_raw_input: ParamInitValuesTypeMap[T]): any;
    isDefaultValueEqual(other_default_value: ParamInitValuesTypeMap[T]): any;
    static areValuesEqual(val1: any, val2: any): boolean;
    isValueEqual(other_val: ParamValuesTypeMap[T]): any;
    protected _cloneRawInput(raw_input: ParamInitValuesTypeMap[T]): ParamInitValuesTypeMap[T];
    set(raw_input: ParamInitValuesTypeMap[T]): void;
    protected _prefilterInvalidRawInput(raw_input: any): ParamInitValuesTypeMap[T];
    defaultValue(): ParamInitValuesTypeMap[T];
    isDefault(): boolean;
    rawInput(): ParamInitValuesTypeMap[T];
    protected processRawInput(): void;
    private _isComputing;
    isComputing(): boolean;
    compute(): Promise<void>;
    protected processComputation(): Promise<void>;
    setInitValue(init_value: ParamInitValuesTypeMap[T]): void;
    _setupNodeDependencies(node: BaseNodeType | null): void;
    get node(): BaseNodeType;
    parent(): BaseNodeType;
    set_parent_param(param: TypedMultipleParam<any>): void;
    parentParam(): TypedMultipleParam<any> | undefined;
    has_parent_param(): boolean;
    path(): string;
    pathRelativeTo(node: BaseNodeType): string;
    emit(eventName: ParamEvent): void;
    get components(): FloatParam[] | undefined;
    componentNames(): Readonly<string[]>;
    isMultiple(): boolean;
    initComponents(): void;
    hasExpression(): boolean;
    toJSON(): import("./utils/CoreParamSerializer").ParamSerializerData<T> | undefined;
    private _onDisposeCallbacks;
    onDispose(callback: OnDisposeCallback): void;
    deregisterOnDispose(callback: OnDisposeCallback): void;
    private _runOnDisposeCallbacks;
}
export type BaseParamType = TypedParam<ParamType>;
export declare class BaseParamClass extends TypedParam<ParamType> {
    defaultValueSerialized(): string;
    rawInputSerialized(): string;
    valueSerialized(): string;
}
export {};