@ringozz/godot 0.1.0

package/gen/classes/VisualShaderNodeIntOp.ts

@@ -0,0 +1,78 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNode } from './VisualShaderNode.ts';
+
+/**
+ * Applies {@link operator} to two integer inputs: `a` and `b`.
+ */
+export class VisualShaderNodeIntOp extends VisualShaderNode {
+    constructor(name = 877) { super(name); }
+
+    /**
+     * An operator to be applied to the inputs.
+     */
+    get operator(): Operator { return _C(this, 5728) as Operator; }
+    set operator(v: Operator) { _C(this, 12193, v); }
+
+    static readonly name = _R(877, VisualShaderNodeIntOp);
+}
+
+export const Operator = {
+    /**
+     * Sums two numbers using `a + b`.
+     */
+    OP_ADD: 0,
+    /**
+     * Subtracts two numbers using `a - b`.
+     */
+    OP_SUB: 1,
+    /**
+     * Multiplies two numbers using `a * b`.
+     */
+    OP_MUL: 2,
+    /**
+     * Divides two numbers using `a / b`.
+     */
+    OP_DIV: 3,
+    /**
+     * Calculates the remainder of two numbers using `a % b`.
+     */
+    OP_MOD: 4,
+    /**
+     * Returns the greater of two numbers. Translates to `max(a, b)` in the Godot Shader Language.
+     */
+    OP_MAX: 5,
+    /**
+     * Returns the lesser of two numbers. Translates to `max(a, b)` in the Godot Shader Language.
+     */
+    OP_MIN: 6,
+    /**
+     * Returns the result of bitwise `AND` operation on the integer. Translates to `a & b` in the Godot Shader Language.
+     */
+    OP_BITWISE_AND: 7,
+    /**
+     * Returns the result of bitwise `OR` operation for two integers. Translates to `a | b` in the Godot Shader Language.
+     */
+    OP_BITWISE_OR: 8,
+    /**
+     * Returns the result of bitwise `XOR` operation for two integers. Translates to `a ^ b` in the Godot Shader Language.
+     */
+    OP_BITWISE_XOR: 9,
+    /**
+     * Returns the result of bitwise left shift operation on the integer. Translates to `a << b` in the Godot Shader Language.
+     */
+    OP_BITWISE_LEFT_SHIFT: 10,
+    /**
+     * Returns the result of bitwise right shift operation on the integer. Translates to `a >> b` in the Godot Shader Language.
+     */
+    OP_BITWISE_RIGHT_SHIFT: 11,
+    /**
+     * Represents the size of the {@link Operator} enum.
+     */
+    OP_ENUM_SIZE: 12,
+} as const;
+
+export type Operator = (typeof Operator)[keyof typeof Operator];
+

package/gen/classes/VisualShaderNodeIntParameter.ts

@@ -0,0 +1,83 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNodeParameter } from './VisualShaderNodeParameter.ts';
+import type { PackedStringArray } from '../heap-types/index.ts';
+
+/**
+ * A {@link VisualShaderNodeParameter} of type {@link int}. Offers additional customization for range of accepted values.
+ */
+export class VisualShaderNodeIntParameter extends VisualShaderNodeParameter {
+    constructor(name = 878) { super(name); }
+
+    /**
+     * Range hint of this node. Use it to customize valid parameter range.
+     */
+    get hint(): Hint { return _C(this, 5038) as Hint; }
+    set hint(v: Hint) { _C(this, 11632, v); }
+
+    /**
+     * The minimum value this parameter can take. {@link hint} must be either {@link HINT_RANGE} or {@link HINT_RANGE_STEP} for this to take effect.
+     */
+    get min(): number { return _C(this, 5537) as number; }
+    set min(v: number) { _C(this, 12048, v); }
+
+    /**
+     * The maximum value this parameter can take. {@link hint} must be either {@link HINT_RANGE} or {@link HINT_RANGE_STEP} for this to take effect.
+     */
+    get max(): number { return _C(this, 5456) as number; }
+    set max(v: number) { _C(this, 11982, v); }
+
+    /**
+     * The step between parameter's values. Forces the parameter to be a multiple of the given value. {@link hint} must be {@link HINT_RANGE_STEP} for this to take effect.
+     */
+    get step(): number { return _C(this, 6553) as number; }
+    set step(v: number) { _C(this, 12891, v); }
+
+    /**
+     * The names used for the enum select in the editor. {@link hint} must be {@link HINT_ENUM} for this to take effect.
+     */
+    get enumNames(): PackedStringArray { return _C(this, 4677) as PackedStringArray; }
+    set enumNames(v: PackedStringArray) { _C(this, 11300, v); }
+
+    /**
+     * If `true`, the node will have a custom default value.
+     */
+    get defaultValueEnabled(): boolean { return _C(this, 7874) as boolean; }
+    set defaultValueEnabled(v: boolean) { _C(this, 11070, v); }
+
+    /**
+     * Default value of this parameter, which will be used if not set externally. {@link defaultValueEnabled} must be enabled; defaults to `0` otherwise.
+     */
+    get defaultValue(): number { return _C(this, 4456) as number; }
+    set defaultValue(v: number) { _C(this, 11069, v); }
+
+    static readonly name = _R(878, VisualShaderNodeIntParameter);
+}
+
+export const Hint = {
+    /**
+     * The parameter will not constrain its value.
+     */
+    HINT_NONE: 0,
+    /**
+     * The parameter's value must be within the specified {@link min}/{@link max} range.
+     */
+    HINT_RANGE: 1,
+    /**
+     * The parameter's value must be within the specified range, with the given {@link step} between values.
+     */
+    HINT_RANGE_STEP: 2,
+    /**
+     * The parameter uses an enum to associate preset values to names in the editor.
+     */
+    HINT_ENUM: 3,
+    /**
+     * Represents the size of the {@link Hint} enum.
+     */
+    HINT_MAX: 4,
+} as const;
+
+export type Hint = (typeof Hint)[keyof typeof Hint];
+

package/gen/classes/VisualShaderNodeIs.ts

@@ -0,0 +1,38 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNode } from './VisualShaderNode.ts';
+
+/**
+ * Returns the boolean result of the comparison between `INF` or `NaN` and a scalar parameter.
+ */
+export class VisualShaderNodeIs extends VisualShaderNode {
+    constructor(name = 879) { super(name); }
+
+    /**
+     * The comparison function.
+     */
+    get _function(): Function { return _C(this, 4911) as Function; }
+    set _function(v: Function) { _C(this, 11504, v); }
+
+    static readonly name = _R(879, VisualShaderNodeIs);
+}
+
+export const Function = {
+    /**
+     * Comparison with `INF` (Infinity).
+     */
+    FUNC_IS_INF: 0,
+    /**
+     * Comparison with `NaN` (Not a Number; indicates invalid numeric results, such as division by zero).
+     */
+    FUNC_IS_NAN: 1,
+    /**
+     * Represents the size of the {@link Function} enum.
+     */
+    FUNC_MAX: 2,
+} as const;
+
+export type Function = (typeof Function)[keyof typeof Function];
+

package/gen/classes/VisualShaderNodeLinearSceneDepth.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNode } from './VisualShaderNode.ts';
+
+/**
+ * This node can be used in fragment shaders.
+ */
+export class VisualShaderNodeLinearSceneDepth extends VisualShaderNode {
+    constructor(name = 880) { super(name); }
+
+    static readonly name = _R(880, VisualShaderNodeLinearSceneDepth);
+}

package/gen/classes/VisualShaderNodeMix.ts

@@ -0,0 +1,58 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNode } from './VisualShaderNode.ts';
+
+/**
+ * Translates to `mix(a, b, weight)` in the shader language.
+ */
+export class VisualShaderNodeMix extends VisualShaderNode {
+    constructor(name = 881) { super(name); }
+
+    /**
+     * A type of operands and returned value.
+     */
+    get opType(): OpType { return _C(this, 5721) as OpType; }
+    set opType(v: OpType) { _C(this, 12189, v); }
+
+    static readonly name = _R(881, VisualShaderNodeMix);
+}
+
+export const OpType = {
+    /**
+     * A floating-point scalar.
+     */
+    OP_TYPE_SCALAR: 0,
+    /**
+     * A 2D vector type.
+     */
+    OP_TYPE_VECTOR_2D: 1,
+    /**
+     * The `a` and `b` ports use a 2D vector type. The `weight` port uses a scalar type.
+     */
+    OP_TYPE_VECTOR_2D_SCALAR: 2,
+    /**
+     * A 3D vector type.
+     */
+    OP_TYPE_VECTOR_3D: 3,
+    /**
+     * The `a` and `b` ports use a 3D vector type. The `weight` port uses a scalar type.
+     */
+    OP_TYPE_VECTOR_3D_SCALAR: 4,
+    /**
+     * A 4D vector type.
+     */
+    OP_TYPE_VECTOR_4D: 5,
+    /**
+     * The `a` and `b` ports use a 4D vector type. The `weight` port uses a scalar type.
+     */
+    OP_TYPE_VECTOR_4D_SCALAR: 6,
+    /**
+     * Represents the size of the {@link OpType} enum.
+     */
+    OP_TYPE_MAX: 7,
+} as const;
+
+export type OpType = (typeof OpType)[keyof typeof OpType];
+

package/gen/classes/VisualShaderNodeMultiplyAdd.ts

@@ -0,0 +1,46 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNode } from './VisualShaderNode.ts';
+
+/**
+ * Uses three operands to compute `(a * b + c)` expression.
+ */
+export class VisualShaderNodeMultiplyAdd extends VisualShaderNode {
+    constructor(name = 882) { super(name); }
+
+    /**
+     * A type of operands and returned value.
+     */
+    get opType(): OpType { return _C(this, 5721) as OpType; }
+    set opType(v: OpType) { _C(this, 12189, v); }
+
+    static readonly name = _R(882, VisualShaderNodeMultiplyAdd);
+}
+
+export const OpType = {
+    /**
+     * A floating-point scalar type.
+     */
+    OP_TYPE_SCALAR: 0,
+    /**
+     * A 2D vector type.
+     */
+    OP_TYPE_VECTOR_2D: 1,
+    /**
+     * A 3D vector type.
+     */
+    OP_TYPE_VECTOR_3D: 2,
+    /**
+     * A 4D vector type.
+     */
+    OP_TYPE_VECTOR_4D: 3,
+    /**
+     * Represents the size of the {@link OpType} enum.
+     */
+    OP_TYPE_MAX: 4,
+} as const;
+
+export type OpType = (typeof OpType)[keyof typeof OpType];
+

package/gen/classes/VisualShaderNodeOuterProduct.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNode } from './VisualShaderNode.ts';
+
+/**
+ * `OuterProduct` treats the first parameter `c` as a column vector (matrix with one column) and the second parameter `r` as a row vector (matrix with one row) and does a linear algebraic matrix multiply `c * r`, yielding a matrix whose number of rows is the number of components in `c` and whose number of columns is the number of components in `r`.
+ */
+export class VisualShaderNodeOuterProduct extends VisualShaderNode {
+    constructor(name = 883) { super(name); }
+
+    static readonly name = _R(883, VisualShaderNodeOuterProduct);
+}

package/gen/classes/VisualShaderNodeOutput.ts

@@ -0,0 +1,13 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNode } from './VisualShaderNode.ts';
+
+/**
+ * This visual shader node is present in all shader graphs in form of "Output" block with multiple output value ports.
+ */
+export class VisualShaderNodeOutput extends VisualShaderNode {
+
+    static readonly name = _R(884, VisualShaderNodeOutput);
+}

package/gen/classes/VisualShaderNodeParameter.ts

@@ -0,0 +1,57 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNode } from './VisualShaderNode.ts';
+
+/**
+ * A parameter represents a variable in the shader which is set externally, i.e. from the {@link ShaderMaterial}. Parameters are exposed as properties in the {@link ShaderMaterial} and can be assigned from the Inspector or from a script.
+ */
+export class VisualShaderNodeParameter extends VisualShaderNode {
+
+    /**
+     * Name of the parameter, by which it can be accessed through the {@link ShaderMaterial} properties.
+     */
+    get parameterName(): string { return _C(this, 5818) as string; }
+    set parameterName(v: string) { _C(this, 12257, v); }
+
+    /**
+     * Defines the scope of the parameter.
+     */
+    get qualifier(): Qualifier { return _C(this, 6060) as Qualifier; }
+    set qualifier(v: Qualifier) { _C(this, 12459, v); }
+
+    /**
+     * The index within 0-15 range, which is used to avoid clashes when shader used on multiple materials.
+     */
+    get instanceIndex(): number { return _C(this, 5134) as number; }
+    set instanceIndex(v: number) { _C(this, 11727, v); }
+
+    static readonly name = _R(885, VisualShaderNodeParameter);
+}
+
+export const Qualifier = {
+    /**
+     * The parameter will be tied to the {@link ShaderMaterial} using this shader.
+     */
+    QUAL_NONE: 0,
+    /**
+     * The parameter will use a global value, defined in Project Settings.
+     */
+    QUAL_GLOBAL: 1,
+    /**
+     * The parameter will be tied to the node with attached {@link ShaderMaterial} using this shader.
+     */
+    QUAL_INSTANCE: 2,
+    /**
+     * The parameter will be tied to the node with attached {@link ShaderMaterial} using this shader. Enables setting a {@link instanceIndex} property.
+     */
+    QUAL_INSTANCE_INDEX: 3,
+    /**
+     * Represents the size of the {@link Qualifier} enum.
+     */
+    QUAL_MAX: 4,
+} as const;
+
+export type Qualifier = (typeof Qualifier)[keyof typeof Qualifier];
+

package/gen/classes/VisualShaderNodeParameterRef.ts

@@ -0,0 +1,23 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNode } from './VisualShaderNode.ts';
+
+/**
+ * Creating a reference to a {@link VisualShaderNodeParameter} allows you to reuse this parameter in different shaders or shader stages easily.
+ */
+export class VisualShaderNodeParameterRef extends VisualShaderNode {
+    constructor(name = 886) { super(name); }
+
+    /**
+     * The name of the parameter which this reference points to.
+     */
+    get parameterName(): string { return _C(this, 5818) as string; }
+    set parameterName(v: string) { _C(this, 12257, v); }
+
+    get paramType(): number { return _C(this, 1008) as number; }
+    set paramType(v: number) { _C(this, 1036, v); }
+
+    static readonly name = _R(886, VisualShaderNodeParameterRef);
+}

package/gen/classes/VisualShaderNodeParticleAccelerator.ts

@@ -0,0 +1,42 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNode } from './VisualShaderNode.ts';
+
+/**
+ * Particle accelerator can be used in "process" step of particle shader. It will accelerate the particles. Connect it to the Velocity output port.
+ */
+export class VisualShaderNodeParticleAccelerator extends VisualShaderNode {
+    constructor(name = 887) { super(name); }
+
+    /**
+     * Defines in what manner the particles will be accelerated.
+     */
+    get mode(): Mode { return _C(this, 5568) as Mode; }
+    set mode(v: Mode) { _C(this, 12073, v); }
+
+    static readonly name = _R(887, VisualShaderNodeParticleAccelerator);
+}
+
+export const Mode = {
+    /**
+     * The particles will be accelerated based on their velocity.
+     */
+    MODE_LINEAR: 0,
+    /**
+     * The particles will be accelerated towards or away from the center.
+     */
+    MODE_RADIAL: 1,
+    /**
+     * The particles will be accelerated tangentially to the radius vector from center to their position.
+     */
+    MODE_TANGENTIAL: 2,
+    /**
+     * Represents the size of the {@link Mode} enum.
+     */
+    MODE_MAX: 3,
+} as const;
+
+export type Mode = (typeof Mode)[keyof typeof Mode];
+

package/gen/classes/VisualShaderNodeParticleBoxEmitter.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNodeParticleEmitter } from './VisualShaderNodeParticleEmitter.ts';
+
+/**
+ * {@link VisualShaderNodeParticleEmitter} that makes the particles emitted in box shape with the specified extents.
+ */
+export class VisualShaderNodeParticleBoxEmitter extends VisualShaderNodeParticleEmitter {
+    constructor(name = 888) { super(name); }
+
+    static readonly name = _R(888, VisualShaderNodeParticleBoxEmitter);
+}

package/gen/classes/VisualShaderNodeParticleConeVelocity.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNode } from './VisualShaderNode.ts';
+
+/**
+ * This node can be used in "start" step of particle shader. It defines the initial velocity of the particles, making them move in cone shape starting from the center, with a given spread.
+ */
+export class VisualShaderNodeParticleConeVelocity extends VisualShaderNode {
+    constructor(name = 889) { super(name); }
+
+    static readonly name = _R(889, VisualShaderNodeParticleConeVelocity);
+}

package/gen/classes/VisualShaderNodeParticleEmit.ts

@@ -0,0 +1,46 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNode } from './VisualShaderNode.ts';
+
+/**
+ * This node internally calls `emit_subparticle` shader method. It will emit a particle from the configured sub-emitter and also allows to customize how its emitted. Requires a sub-emitter assigned to the particles node with this shader.
+ */
+export class VisualShaderNodeParticleEmit extends VisualShaderNode {
+    constructor(name = 890) { super(name); }
+
+    /**
+     * Flags used to override the properties defined in the sub-emitter's process material.
+     */
+    get flags(): EmitFlags { return _C(this, 4807) as EmitFlags; }
+    set flags(v: EmitFlags) { _C(this, 11412, v); }
+
+    static readonly name = _R(890, VisualShaderNodeParticleEmit);
+}
+
+export const EmitFlags = {
+    /**
+     * If enabled, the particle starts with the position defined by this node.
+     */
+    EMIT_FLAG_POSITION: 1,
+    /**
+     * If enabled, the particle starts with the rotation and scale defined by this node.
+     */
+    EMIT_FLAG_ROT_SCALE: 2,
+    /**
+     * If enabled,the particle starts with the velocity defined by this node.
+     */
+    EMIT_FLAG_VELOCITY: 4,
+    /**
+     * If enabled, the particle starts with the color defined by this node.
+     */
+    EMIT_FLAG_COLOR: 8,
+    /**
+     * If enabled, the particle starts with the `CUSTOM` data defined by this node.
+     */
+    EMIT_FLAG_CUSTOM: 16,
+} as const;
+
+export type EmitFlags = (typeof EmitFlags)[keyof typeof EmitFlags];
+

package/gen/classes/VisualShaderNodeParticleEmitter.ts

@@ -0,0 +1,19 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNode } from './VisualShaderNode.ts';
+
+/**
+ * Particle emitter nodes can be used in "start" step of particle shaders and they define the starting position of the particles. Connect them to the Position output port.
+ */
+export class VisualShaderNodeParticleEmitter extends VisualShaderNode {
+
+    /**
+     * If `true`, the result of this emitter is projected to 2D space. By default it is `false` and meant for use in 3D space.
+     */
+    get mode2d(): boolean { return _C(this, 8108) as boolean; }
+    set mode2d(v: boolean) { _C(this, 12074, v); }
+
+    static readonly name = _R(891, VisualShaderNodeParticleEmitter);
+}

package/gen/classes/VisualShaderNodeParticleMeshEmitter.ts

@@ -0,0 +1,33 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNodeParticleEmitter } from './VisualShaderNodeParticleEmitter.ts';
+import type { Mesh } from './Mesh.ts';
+
+/**
+ * {@link VisualShaderNodeParticleEmitter} that makes the particles emitted in a shape of the assigned {@link mesh}. It will emit from the mesh's surfaces, either all or only the specified one.
+ */
+export class VisualShaderNodeParticleMeshEmitter extends VisualShaderNodeParticleEmitter {
+    constructor(name = 892) { super(name); }
+
+    /**
+     * The {@link Mesh} that defines emission shape.
+     */
+    get mesh(): Mesh { return _C(this, 5511) as Mesh; }
+    set mesh(v: Mesh) { _C(this, 12024, v); }
+
+    /**
+     * If `true`, the particles will emit from all surfaces of the mesh.
+     */
+    get useAllSurfaces(): boolean { return _C(this, 8386) as boolean; }
+    set useAllSurfaces(v: boolean) { _C(this, 13193, v); }
+
+    /**
+     * Index of the surface that emits particles. {@link useAllSurfaces} must be `false` for this to take effect.
+     */
+    get surfaceIndex(): number { return _C(this, 6627) as number; }
+    set surfaceIndex(v: number) { _C(this, 12938, v); }
+
+    static readonly name = _R(892, VisualShaderNodeParticleMeshEmitter);
+}

package/gen/classes/VisualShaderNodeParticleMultiplyByAxisAngle.ts

@@ -0,0 +1,20 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNode } from './VisualShaderNode.ts';
+
+/**
+ * This node helps to multiply a position input vector by rotation using specific axis. Intended to work with emitters.
+ */
+export class VisualShaderNodeParticleMultiplyByAxisAngle extends VisualShaderNode {
+    constructor(name = 893) { super(name); }
+
+    /**
+     * If `true`, the angle will be interpreted in degrees instead of radians.
+     */
+    get degreesMode(): boolean { return _C(this, 7877) as boolean; }
+    set degreesMode(v: boolean) { _C(this, 11074, v); }
+
+    static readonly name = _R(893, VisualShaderNodeParticleMultiplyByAxisAngle);
+}

package/gen/classes/VisualShaderNodeParticleOutput.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNodeOutput } from './VisualShaderNodeOutput.ts';
+
+/**
+ * This node defines how particles are emitted. It allows to customize e.g. position and velocity. Available ports are different depending on which function this node is inside (start, process, collision) and whether custom data is enabled.
+ */
+export class VisualShaderNodeParticleOutput extends VisualShaderNodeOutput {
+    constructor(name = 894) { super(name); }
+
+    static readonly name = _R(894, VisualShaderNodeParticleOutput);
+}