@polygonjs/polygonjs/dist/src/engine/nodes/js/code/assemblers/_Base.d.ts

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

import { ShaderMaterial } from 'three';
import { LineType } from '../utils/LineType';
import { VariableConfig } from '../configs/VariableConfig';
import { JsCodeBuilder, CodeBuilderSetCodeLinesOptions } from '../utils/CodeBuilder';
import { BaseJsNodeType } from '../../_Base';
import { JsShaderConfig } from '../configs/ShaderConfig';
import { TypedAssembler } from '../../../utils/shaders/BaseAssembler';
import { JsFunctionName } from '../../../utils/shaders/ShaderName';
import { OutputJsNode } from '../../Output';
import { JsConnectionPoint, JsConnectionPointType } from '../../../utils/io/connections/Js';
import { GlobalsJsNode } from '../../Globals';
import { AttributeJsNode } from '../../Attribute';
import { AssemblerControllerNode } from '../Controller';
import { GlobalsJsBaseController } from '../globals/_Base';
import { JsLinesCollectionController } from '../utils/JsLinesCollectionController';
import { NodeContext } from '../../../../poly/NodeContext';
import { BaseNamedFunction } from '../../../../functions/_Base';
import { RegisterableVariable } from './_BaseJsPersistedConfigUtils';
import { NamedFunctionMap } from '../../../../poly/registers/functions/All';
import { JsParamConfig } from '../utils/JsParamConfig';
import { ParamType } from '../../../../poly/ParamType';
import { ParamOptions } from '../../../../params/utils/OptionsController';
type StringArrayByJsFunctionName = Map<JsFunctionName, string[]>;
export interface SpareParamOptions {
    type: ParamType;
}
export interface BaseFunctionData {
    variableNames: string[];
    variablesByName: Record<string, RegisterableVariable>;
    functionNames: Array<keyof NamedFunctionMap>;
    functionsByName: Record<string, Function>;
    paramConfigs: JsParamConfig<ParamType>[];
}
export interface VelocityColliderFunctionBody {
    velocity: string;
    collider: string;
}
export interface SingleBodyFunctionData extends BaseFunctionData {
    functionBody: string;
}
export interface VelocityColliderFunctionData extends BaseFunctionData {
    functionBody: VelocityColliderFunctionBody;
}
interface JsTemplateShader {
    main?: string;
    velocity?: string;
    collider?: string;
}
export declare const INSERT_MEMBERS_AFTER = "// insert members";
export declare const INSERT_DEFINE_AFTER = "// insert defines";
export declare const INSERT_CONSTRUCTOR_AFTER = "// insert after constructor";
export declare const INSERT_BODY_AFTER = "// insert body";
export declare abstract class BaseJsShaderAssembler extends TypedAssembler<NodeContext.JS> {
    protected _jsParentNode: AssemblerControllerNode<BaseJsShaderAssembler>;
    protected _shaders_by_name: Map<JsFunctionName, string>;
    protected _lines: StringArrayByJsFunctionName;
    protected _codeBuilder: JsCodeBuilder | undefined;
    private _param_config_owner;
    protected _root_nodes: BaseJsNodeType[];
    protected _leaf_nodes: BaseJsNodeType[];
    protected _material: ShaderMaterial | undefined;
    private _shader_configs;
    private _variable_configs;
    private _uniformsTimeDependent;
    private _uniformsResolutionDependent;
    private _computedVarNames;
    constructor(_jsParentNode: AssemblerControllerNode<BaseJsShaderAssembler>);
    perPoint(): boolean;
    protected _overridenJsParentNode: AssemblerControllerNode<BaseJsShaderAssembler> | undefined;
    setJsParentNode(parentNode: AssemblerControllerNode<BaseJsShaderAssembler>): void;
    currentJsParentNode(): AssemblerControllerNode<BaseJsShaderAssembler>;
    abstract makeFunctionNodeDirtyOnChange(): boolean;
    addComputedVarName(varName: string): void;
    registeredAsComputed(varName: string): boolean;
    computedVariablesAllowed(): boolean;
    memberReference(varName: string): string;
    abstract spareParamsOptions(options: SpareParamOptions): ParamOptions;
    compile(): void;
    abstract defaultObjectVariable(): string;
    abstract defaultObject3DMaterialVariable(): string;
    abstract defaultPrimitiveGraph(): string;
    protected _template_shader_for_shader_name(shaderName: JsFunctionName): string | undefined;
    globalsHandler(): GlobalsJsBaseController | undefined;
    compileAllowed(): boolean;
    shaders_by_name(): Map<JsFunctionName, string>;
    protected _buildLines(): void;
    set_root_nodes(root_nodes: BaseJsNodeType[]): void;
    protected templateShader(): JsTemplateShader | undefined;
    protected _reset(): void;
    updateFunction(): void;
    rootNodesByShaderName(shaderName: JsFunctionName, rootNodes: BaseJsNodeType[]): BaseJsNodeType[];
    setNodeLinesGlobals(globalsNode: GlobalsJsNode, linesController: JsLinesCollectionController): void;
    setNodeLinesOutput(outputNode: OutputJsNode, linesController: JsLinesCollectionController): void;
    setNodeLinesAttribute(attributeNode: AttributeJsNode, linesController: JsLinesCollectionController): void;
    codeBuilder(): JsCodeBuilder;
    private _createCodeBuilder;
    protected buildCodeFromNodes(rootNodes: BaseJsNodeType[], codeBuilderOptions?: CodeBuilderSetCodeLinesOptions): void;
    allow_new_param_configs(): void;
    disallow_new_param_configs(): void;
    builder_param_configs(): readonly JsParamConfig<ParamType>[];
    builder_lines(shader_name: JsFunctionName, line_type: LineType): string[];
    all_builder_lines(): Map<JsFunctionName, Map<LineType, string[]>>;
    param_configs(): readonly JsParamConfig<ParamType>[];
    set_param_configs_owner(param_config_owner: JsCodeBuilder): void;
    static output_input_connection_points(): JsConnectionPoint<JsConnectionPointType>[];
    add_output_inputs(output_child: OutputJsNode): void;
    static create_globals_node_output_connections(): never[];
    create_globals_node_output_connections(): never[];
    add_globals_outputs(globals_node: GlobalsJsNode): void;
    allow_attribute_exports(): boolean;
    resetConfigs(): void;
    shaderConfigs(): JsShaderConfig[];
    set_shader_configs(shader_configs: JsShaderConfig[]): void;
    shaderNames(): JsFunctionName[];
    protected _reset_shader_configs(): void;
    create_shader_configs(): JsShaderConfig[];
    shader_config(name: string): JsShaderConfig | undefined;
    variable_configs(): VariableConfig[];
    set_variable_configs(variable_configs: VariableConfig[]): void;
    variable_config(name: string): VariableConfig;
    static create_variable_configs(): VariableConfig[];
    create_variable_configs(): VariableConfig[];
    protected _reset_variable_configs(): void;
    inputNamesForShaderName(rootNode: BaseJsNodeType, shaderName: JsFunctionName): string[];
    protected _resetUniformsTimeDependency(): void;
    setUniformsTimeDependent(): void;
    uniformsTimeDependent(): boolean;
    protected _resetUniformsResolutionDependency(): void;
    setUniformsResolutionDependent(): void;
    uniformsResolutionDependent(): boolean;
    protected _raymarchingLightsWorldCoordsDependent(): boolean;
    protected insertMemberAfter(shaderName: JsFunctionName): string | undefined;
    protected insertDefineAfter(shaderName: JsFunctionName): string | undefined;
    protected insertConstructorAfter(shaderName: JsFunctionName): string | undefined;
    protected insertBodyAfter(shaderName: JsFunctionName): string | undefined;
    protected linesToRemove(shaderName: JsFunctionName): string[] | undefined;
    private _replaceTemplate;
    private _insertLines;
    private _registeredVariables;
    private _registeredVariablesCountByNode;
    addVariable(node: BaseJsNodeType, variable: RegisterableVariable, varName?: string): string;
    traverseRegisteredVariables(callback: (variable: RegisterableVariable, varName: string) => void): void;
    protected _resetRegisteredVariables(): void;
    private _registeredFunctions;
    addFunction(node: BaseJsNodeType, namedFunction: BaseNamedFunction): void;
    traverseRegisteredFunctions(callback: (variable: BaseNamedFunction) => void): void;
    protected _resetRegisteredFunctions(): void;
}
export {};