@babylonjs/inspector 9.0.0 → 9.2.0

package/lib/components/properties/lights/lightProperties.d.ts

@@ -0,0 +1,7 @@
+import { type FunctionComponent } from "react";
+import { type Light } from "@babylonjs/core/index.js";
+import { type ISelectionService } from "../../../services/selectionService";
+export declare const LightGeneralProperties: FunctionComponent<{
+    light: Light;
+    selectionService: ISelectionService;
+}>;

package/lib/components/properties/lights/pointLightProperties.d.ts

@@ -0,0 +1,5 @@
+import { type PointLight } from "@babylonjs/core/index.js";
+import { type FunctionComponent } from "react";
+export declare const PointLightSetupProperties: FunctionComponent<{
+    context: PointLight;
+}>;

package/lib/components/properties/lights/shadowGeneratorProperties.d.ts

@@ -0,0 +1,6 @@
+import { type FunctionComponent } from "react";
+import { type ShadowLight } from "@babylonjs/core/index.js";
+import "@babylonjs/core/Lights/Shadows/shadowGeneratorSceneComponent.js";
+export declare const ShadowGeneratorSetupProperties: FunctionComponent<{
+    context: ShadowLight;
+}>;

package/lib/components/properties/lights/shadowLightProperties.d.ts

@@ -0,0 +1,5 @@
+import { type ShadowLight } from "@babylonjs/core/index.js";
+import { type FunctionComponent } from "react";
+export declare const ShadowsSetupProperties: FunctionComponent<{
+    context: ShadowLight;
+}>;

package/lib/components/properties/lights/spotLightProperties.d.ts

@@ -0,0 +1,5 @@
+import { type SpotLight } from "@babylonjs/core/index.js";
+import { type FunctionComponent } from "react";
+export declare const SpotLightSetupProperties: FunctionComponent<{
+    context: SpotLight;
+}>;

package/lib/components/properties/linkToEntityPropertyLine.d.ts

@@ -0,0 +1,27 @@
+import { type FunctionComponent } from "react";
+import { type Nullable } from "@babylonjs/core/types.js";
+import { type PropertyLineProps } from "@babylonjs/shared-ui-components/fluent/hoc/propertyLines/propertyLine.js";
+import { type ISelectionService } from "../../services/selectionService";
+/** Props for the LinkToEntity component */
+export type LinkToEntityProps = {
+    /** The entity to link to, or null if no entity is available */
+    entity: Nullable<{
+        name: string;
+        reservedDataStore?: Record<PropertyKey, unknown>;
+    }>;
+    /** The selection service used to navigate to the entity */
+    selectionService: ISelectionService;
+};
+/**
+ * A clickable link that navigates to a specific entity in the inspector.
+ * Renders nothing when the entity is null or hidden.
+ * @param props - The entity and selection service
+ * @returns A link component, or null
+ */
+export declare const LinkToEntity: FunctionComponent<LinkToEntityProps>;
+/**
+ * A property line that links to a specific entity in the scene.
+ * @param props an entity and a selection service
+ * @returns A link property line component.
+ */
+export declare const LinkToEntityPropertyLine: FunctionComponent<PropertyLineProps<string> & LinkToEntityProps>;

package/lib/components/properties/materials/materialProperties.d.ts

@@ -0,0 +1,11 @@
+import { type FunctionComponent } from "react";
+import { Material } from "@babylonjs/core/Materials/material.js";
+export declare const MaterialGeneralProperties: FunctionComponent<{
+    material: Material;
+}>;
+export declare const MaterialTransparencyProperties: FunctionComponent<{
+    material: Material;
+}>;
+export declare const MaterialStencilProperties: FunctionComponent<{
+    material: Material;
+}>;

package/lib/components/properties/materials/multiMaterialProperties.d.ts

@@ -0,0 +1,7 @@
+import { type FunctionComponent } from "react";
+import { type MultiMaterial } from "@babylonjs/core/Materials/multiMaterial.js";
+import { type ISelectionService } from "../../../services/selectionService";
+export declare const MultiMaterialChildrenProperties: FunctionComponent<{
+    multiMaterial: MultiMaterial;
+    selectionService: ISelectionService;
+}>;

package/lib/components/properties/materials/nodeMaterialProperties.d.ts

@@ -0,0 +1,8 @@
+import { type FunctionComponent } from "react";
+import { type NodeMaterial } from "@babylonjs/core/index.js";
+export declare const NodeMaterialGeneralProperties: FunctionComponent<{
+    material: NodeMaterial;
+}>;
+export declare const NodeMaterialInputProperties: FunctionComponent<{
+    material: NodeMaterial;
+}>;

package/lib/components/properties/materials/normalMapProperties.d.ts

@@ -0,0 +1,19 @@
+import { type FunctionComponent } from "react";
+type MaterialWithPublicNormalMaps = {
+    invertNormalMapX: boolean;
+    invertNormalMapY: boolean;
+};
+type MaterialWithInternalNormalMaps = {
+    _invertNormalMapX: boolean;
+    _invertNormalMapY: boolean;
+};
+export type MaterialWithNormalMaps = MaterialWithPublicNormalMaps | MaterialWithInternalNormalMaps;
+/**
+ * Displays the normal map properties of a standard material.
+ * @param props - The required properties
+ * @returns A JSX element representing the normal map properties.
+ */
+export declare const NormalMapProperties: FunctionComponent<{
+    material: MaterialWithNormalMaps;
+}>;
+export {};

package/lib/components/properties/materials/openpbrMaterialProperties.d.ts

@@ -0,0 +1,64 @@
+import { type FunctionComponent } from "react";
+import { type OpenPBRMaterial } from "@babylonjs/core/Materials/PBR/openpbrMaterial.js";
+/**
+ * Displays the base layer properties of an OpenPBR material.
+ * @param props - The required properties
+ * @returns A JSX element representing the base layer properties.
+ */
+export declare const OpenPBRMaterialBaseProperties: FunctionComponent<{
+    material: OpenPBRMaterial;
+}>;
+/**
+ * Displays the specular layer properties of an OpenPBR material.
+ * @param props - The required properties
+ * @returns A JSX element representing the specular layer properties.
+ */
+export declare const OpenPBRMaterialSpecularProperties: FunctionComponent<{
+    material: OpenPBRMaterial;
+}>;
+export declare const OpenPBRMaterialTransmissionProperties: FunctionComponent<{
+    material: OpenPBRMaterial;
+}>;
+export declare const OpenPBRMaterialSubsurfaceProperties: FunctionComponent<{
+    material: OpenPBRMaterial;
+}>;
+/**
+ * Displays the coat layer properties of an OpenPBR material.
+ * @param props - The required properties
+ * @returns A JSX element representing the coat layer properties.
+ */
+export declare const OpenPBRMaterialCoatProperties: FunctionComponent<{
+    material: OpenPBRMaterial;
+}>;
+/**
+ * Displays the fuzz layer properties of an OpenPBR material.
+ * @param props - The required properties
+ * @returns A JSX element representing the fuzz layer properties.
+ */
+export declare const OpenPBRMaterialFuzzProperties: FunctionComponent<{
+    material: OpenPBRMaterial;
+}>;
+/**
+ * Displays the emission properties of an OpenPBR material.
+ * @param props - The required properties
+ * @returns A JSX element representing the emission properties.
+ */
+export declare const OpenPBRMaterialEmissionProperties: FunctionComponent<{
+    material: OpenPBRMaterial;
+}>;
+/**
+ * Displays the thin film properties of an OpenPBR material.
+ * @param props - The required properties
+ * @returns A JSX element representing the thin film properties.
+ */
+export declare const OpenPBRMaterialThinFilmProperties: FunctionComponent<{
+    material: OpenPBRMaterial;
+}>;
+/**
+ * Displays the geometry properties of an OpenPBR material.
+ * @param props - The required properties
+ * @returns A JSX element representing the geometry properties.
+ */
+export declare const OpenPBRMaterialGeometryProperties: FunctionComponent<{
+    material: OpenPBRMaterial;
+}>;

package/lib/components/properties/materials/pbrBaseMaterialProperties.d.ts

@@ -0,0 +1,285 @@
+import { type FunctionComponent } from "react";
+import { PBRBaseMaterial } from "@babylonjs/core/Materials/PBR/pbrBaseMaterial.js";
+import { type ISelectionService } from "../../../services/selectionService";
+declare module "@babylonjs/core/Materials/PBR/pbrSheenConfiguration.js" {
+    interface PBRSheenConfiguration {
+        _useRoughness: boolean;
+    }
+}
+export declare const LightFalloffOptions: [{
+    readonly label: "Physical";
+    readonly value: 0;
+}, {
+    readonly label: "glTF";
+    readonly value: 1;
+}, {
+    readonly label: "Standard";
+    readonly value: 2;
+}];
+export declare const RealTimeFilteringQualityOptions: [{
+    readonly label: "Low";
+    readonly value: 8;
+}, {
+    readonly label: "Medium";
+    readonly value: 16;
+}, {
+    readonly label: "High";
+    readonly value: 64;
+}];
+export declare const BaseDiffuseModelOptions: [{
+    readonly label: "Lambert";
+    readonly value: 2;
+}, {
+    readonly label: "Burley";
+    readonly value: 1;
+}, {
+    readonly label: "OpenPBR";
+    readonly value: 0;
+}];
+export declare const DielectricSpecularModelOptions: [{
+    readonly label: "glTF";
+    readonly value: 0;
+}, {
+    readonly label: "OpenPBR";
+    readonly value: 1;
+}];
+export declare const ConductorSpecularModelOptions: [{
+    readonly label: "glTF";
+    readonly value: 0;
+}, {
+    readonly label: "OpenPBR";
+    readonly value: 1;
+}];
+export declare const DebugMode: [{
+    readonly label: "None";
+    readonly value: 0;
+}, {
+    readonly label: "Normalized position";
+    readonly value: 1;
+}, {
+    readonly label: "Normals";
+    readonly value: 2;
+}, {
+    readonly label: "Tangents";
+    readonly value: 3;
+}, {
+    readonly label: "Bitangents";
+    readonly value: 4;
+}, {
+    readonly label: "Bump Normals";
+    readonly value: 5;
+}, {
+    readonly label: "UV1";
+    readonly value: 6;
+}, {
+    readonly label: "UV2";
+    readonly value: 7;
+}, {
+    readonly label: "ClearCoat Normals";
+    readonly value: 8;
+}, {
+    readonly label: "ClearCoat Tangents";
+    readonly value: 9;
+}, {
+    readonly label: "ClearCoat Bitangents";
+    readonly value: 10;
+}, {
+    readonly label: "Anisotropic Normals";
+    readonly value: 11;
+}, {
+    readonly label: "Anisotropic Tangents";
+    readonly value: 12;
+}, {
+    readonly label: "Anisotropic Bitangents";
+    readonly value: 13;
+}, {
+    readonly label: "Albedo Map";
+    readonly value: 20;
+}, {
+    readonly label: "Ambient Map";
+    readonly value: 21;
+}, {
+    readonly label: "Opacity Map";
+    readonly value: 22;
+}, {
+    readonly label: "Emissive Map";
+    readonly value: 23;
+}, {
+    readonly label: "Light Map";
+    readonly value: 24;
+}, {
+    readonly label: "Metallic Map";
+    readonly value: 25;
+}, {
+    readonly label: "Reflectivity Map";
+    readonly value: 26;
+}, {
+    readonly label: "ClearCoat Map";
+    readonly value: 27;
+}, {
+    readonly label: "ClearCoat Tint Map";
+    readonly value: 28;
+}, {
+    readonly label: "Sheen Map";
+    readonly value: 29;
+}, {
+    readonly label: "Anisotropic Map";
+    readonly value: 30;
+}, {
+    readonly label: "Thickness Map";
+    readonly value: 31;
+}, {
+    readonly label: "Bump Map";
+    readonly value: 32;
+}, {
+    readonly label: "Env Refraction";
+    readonly value: 40;
+}, {
+    readonly label: "Env Reflection";
+    readonly value: 41;
+}, {
+    readonly label: "Env Clear Coat";
+    readonly value: 42;
+}, {
+    readonly label: "Direct Diffuse";
+    readonly value: 50;
+}, {
+    readonly label: "Direct Specular";
+    readonly value: 51;
+}, {
+    readonly label: "Direct Clear Coat";
+    readonly value: 52;
+}, {
+    readonly label: "Direct Sheen";
+    readonly value: 53;
+}, {
+    readonly label: "Env Irradiance";
+    readonly value: 54;
+}, {
+    readonly label: "Surface Albedo";
+    readonly value: 60;
+}, {
+    readonly label: "Reflectance 0";
+    readonly value: 61;
+}, {
+    readonly label: "Metallic";
+    readonly value: 62;
+}, {
+    readonly label: "Metallic F0";
+    readonly value: 71;
+}, {
+    readonly label: "Roughness";
+    readonly value: 63;
+}, {
+    readonly label: "AlphaG";
+    readonly value: 64;
+}, {
+    readonly label: "NdotV";
+    readonly value: 65;
+}, {
+    readonly label: "ClearCoat Color";
+    readonly value: 66;
+}, {
+    readonly label: "ClearCoat Roughness";
+    readonly value: 67;
+}, {
+    readonly label: "ClearCoat NdotV";
+    readonly value: 68;
+}, {
+    readonly label: "Transmittance";
+    readonly value: 69;
+}, {
+    readonly label: "Refraction Transmittance";
+    readonly value: 70;
+}, {
+    readonly label: "Glossiness";
+    readonly value: 72;
+}, {
+    readonly label: "Base Color";
+    readonly value: 73;
+}, {
+    readonly label: "Specular Color";
+    readonly value: 74;
+}, {
+    readonly label: "Emissive Color";
+    readonly value: 75;
+}, {
+    readonly label: "SEO";
+    readonly value: 80;
+}, {
+    readonly label: "EHO";
+    readonly value: 81;
+}, {
+    readonly label: "Energy Factor";
+    readonly value: 82;
+}, {
+    readonly label: "Specular Reflectance";
+    readonly value: 83;
+}, {
+    readonly label: "Clear Coat Reflectance";
+    readonly value: 84;
+}, {
+    readonly label: "Sheen Reflectance";
+    readonly value: 85;
+}, {
+    readonly label: "Luminance Over Alpha";
+    readonly value: 86;
+}, {
+    readonly label: "Alpha";
+    readonly value: 87;
+}, {
+    readonly label: "Albedo Alpha";
+    readonly value: 88;
+}, {
+    readonly label: "Ambient occlusion color";
+    readonly value: 89;
+}];
+export declare const PBRBaseMaterialGeneralProperties: FunctionComponent<{
+    material: PBRBaseMaterial;
+}>;
+export declare const PBRBaseMaterialTransparencyProperties: FunctionComponent<{
+    material: PBRBaseMaterial;
+}>;
+export declare const PBRBaseMaterialChannelsProperties: FunctionComponent<{
+    material: PBRBaseMaterial;
+    selectionService: ISelectionService;
+}>;
+export declare const PBRBaseMaterialLightingAndColorProperties: FunctionComponent<{
+    material: PBRBaseMaterial;
+}>;
+export declare const PBRBaseMaterialMetallicWorkflowProperties: FunctionComponent<{
+    material: PBRBaseMaterial;
+    selectionService: ISelectionService;
+}>;
+export declare const PBRBaseMaterialClearCoatProperties: FunctionComponent<{
+    material: PBRBaseMaterial;
+    selectionService: ISelectionService;
+}>;
+export declare const PBRBaseMaterialIridescenceProperties: FunctionComponent<{
+    material: PBRBaseMaterial;
+    selectionService: ISelectionService;
+}>;
+export declare const PBRBaseMaterialAnisotropicProperties: FunctionComponent<{
+    material: PBRBaseMaterial;
+    selectionService: ISelectionService;
+}>;
+export declare const PBRBaseMaterialSheenProperties: FunctionComponent<{
+    material: PBRBaseMaterial;
+    selectionService: ISelectionService;
+}>;
+export declare const PBRBaseMaterialSubSurfaceProperties: FunctionComponent<{
+    material: PBRBaseMaterial;
+    selectionService: ISelectionService;
+}>;
+export declare const PBRBaseMaterialLevelProperties: FunctionComponent<{
+    material: PBRBaseMaterial;
+}>;
+export declare const PBRBaseMaterialRenderingProperties: FunctionComponent<{
+    material: PBRBaseMaterial;
+}>;
+export declare const PBRBaseMaterialAdvancedProperties: FunctionComponent<{
+    material: PBRBaseMaterial;
+}>;
+export declare const PBRBaseMaterialDebugProperties: FunctionComponent<{
+    material: PBRBaseMaterial;
+}>;

package/lib/components/properties/materials/skyMaterialProperties.d.ts

@@ -0,0 +1,5 @@
+import { type FunctionComponent } from "react";
+import { type SkyMaterial } from "@babylonjs/materials/sky/skyMaterial.js";
+export declare const SkyMaterialProperties: FunctionComponent<{
+    material: SkyMaterial;
+}>;

package/lib/components/properties/materials/standardMaterialProperties.d.ts

@@ -0,0 +1,29 @@
+import { type FunctionComponent } from "react";
+import { type StandardMaterial } from "@babylonjs/core/Materials/standardMaterial.js";
+import { type ISelectionService } from "../../../services/selectionService";
+export declare const StandardMaterialGeneralProperties: FunctionComponent<{
+    material: StandardMaterial;
+}>;
+export declare const StandardMaterialTransparencyProperties: FunctionComponent<{
+    material: StandardMaterial;
+}>;
+export declare const StandardMaterialTexturesProperties: FunctionComponent<{
+    material: StandardMaterial;
+    selectionService: ISelectionService;
+}>;
+/**
+ * Displays the levels properties of a standard material.
+ * @param props - The required properties
+ * @returns A JSX element representing the levels properties.
+ */
+export declare const StandardMaterialLevelsProperties: FunctionComponent<{
+    standardMaterial: StandardMaterial;
+}>;
+/**
+ * Displays the lighting and color properties of a standard material.
+ * @param props - The required properties
+ * @returns A JSX element representing the lighting and color properties.
+ */
+export declare const StandardMaterialLightingAndColorProperties: FunctionComponent<{
+    standardMaterial: StandardMaterial;
+}>;

package/lib/components/properties/metadataProperties.d.ts

@@ -0,0 +1,12 @@
+import { type FunctionComponent } from "react";
+export interface IMetadataContainer {
+    metadata: unknown;
+}
+/**
+ * Component to display metadata properties of an entity.
+ * @param props - The properties for the component.
+ * @returns A React component that displays metadata properties.
+ */
+export declare const MetadataProperties: FunctionComponent<{
+    entity: IMetadataContainer;
+}>;

package/lib/components/properties/nodes/abstractMeshProperties.d.ts

@@ -0,0 +1,27 @@
+import { type FunctionComponent } from "react";
+import { type AbstractMesh } from "@babylonjs/core/index.js";
+import { type ISelectionService } from "../../../services/selectionService";
+import "@babylonjs/core/Rendering/edgesRenderer.js";
+import "@babylonjs/core/Rendering/outlineRenderer.js";
+export declare const AbstractMeshGeneralProperties: FunctionComponent<{
+    mesh: AbstractMesh;
+    selectionService: ISelectionService;
+}>;
+export declare const AbstractMeshDisplayProperties: FunctionComponent<{
+    mesh: AbstractMesh;
+}>;
+export declare const AbstractMeshAdvancedProperties: FunctionComponent<{
+    mesh: AbstractMesh;
+}>;
+export declare const AbstractMeshOutlineOverlayProperties: FunctionComponent<{
+    mesh: AbstractMesh;
+}>;
+export declare const AbstractMeshOcclusionsProperties: FunctionComponent<{
+    mesh: AbstractMesh;
+}>;
+export declare const AbstractMeshEdgeRenderingProperties: FunctionComponent<{
+    mesh: AbstractMesh;
+}>;
+export declare const AbstractMeshDebugProperties: FunctionComponent<{
+    mesh: AbstractMesh;
+}>;

package/lib/components/properties/nodes/gaussianSplattingProperties.d.ts

@@ -0,0 +1,5 @@
+import { type FunctionComponent } from "react";
+import { type GaussianSplattingMesh } from "@babylonjs/core/index.js";
+export declare const GaussianSplattingDisplayProperties: FunctionComponent<{
+    mesh: GaussianSplattingMesh;
+}>;

package/lib/components/properties/nodes/meshProperties.d.ts

@@ -0,0 +1,11 @@
+import { type FunctionComponent } from "react";
+import { type Mesh } from "@babylonjs/core/index.js";
+export declare const MeshGeneralProperties: FunctionComponent<{
+    mesh: Mesh;
+}>;
+export declare const MeshDisplayProperties: FunctionComponent<{
+    mesh: Mesh;
+}>;
+export declare const MeshMorphTargetsProperties: FunctionComponent<{
+    mesh: Mesh;
+}>;

package/lib/components/properties/nodes/nodeProperties.d.ts

@@ -0,0 +1,7 @@
+import { type FunctionComponent } from "react";
+import { type Node } from "@babylonjs/core/index.js";
+import { type ISelectionService } from "../../../services/selectionService";
+export declare const NodeGeneralProperties: FunctionComponent<{
+    node: Node;
+    selectionService: ISelectionService;
+}>;

package/lib/components/properties/particles/attractor.d.ts

@@ -0,0 +1,23 @@
+import { type StandardMaterial } from "@babylonjs/core/Materials/standardMaterial.js";
+import { type Color3 } from "@babylonjs/core/Maths/math.color.js";
+import { type AbstractMesh } from "@babylonjs/core/Meshes/abstractMesh.js";
+import { type Scene } from "@babylonjs/core/scene.js";
+import { type FunctionComponent } from "react";
+import { type IAttractorData } from "./attractorAdapter";
+type AttractorProps = {
+    attractorData: IAttractorData;
+    id: number;
+    impostorScale: number;
+    impostorColor: Color3;
+    impostorMaterial: StandardMaterial;
+    scene: Scene;
+    isControlled: (impostor: AbstractMesh) => boolean;
+    onControl: (impostor?: AbstractMesh) => void;
+};
+/**
+ * Represents the UX of an attractor, a sphere with a color/size whose position matches that of the underlying attractor
+ * @param props
+ * @returns
+ */
+export declare const AttractorComponent: FunctionComponent<AttractorProps>;
+export {};

package/lib/components/properties/particles/attractorAdapter.d.ts

@@ -0,0 +1,56 @@
+import { type Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { Attractor } from "@babylonjs/core/Particles/attractor.js";
+import { type ParticleSystem } from "@babylonjs/core/Particles/particleSystem.js";
+import { type NodeParticleSystemSet } from "@babylonjs/core/Particles/Node/nodeParticleSystemSet.js";
+import { UpdateAttractorBlock } from "@babylonjs/core/Particles/Node/Blocks/Update/updateAttractorBlock.js";
+/**
+ * Represents an attractor in a normalized way that works for both CPU and Node particle systems.
+ */
+export interface IAttractorData {
+    /** The position of the attractor */
+    position: Vector3;
+    /** The strength of the attractor (null if dynamically computed) */
+    strength: number | null;
+    /** Sets the strength of the attractor */
+    setStrength: (value: number) => void;
+    /** The original attractor object (CPU) or UpdateAttractorBlock (Node) */
+    source: Attractor | UpdateAttractorBlock;
+    /** Whether this attractor is read-only (position and strength cannot be edited in inspector) */
+    isReadOnly: boolean;
+}
+/**
+ * Interface for an attractor source that provides attractors from different particle system types.
+ */
+export interface IAttractorSource {
+    /** The attractors from the source */
+    attractors: IAttractorData[];
+    /** Add a new attractor (only for CPU particle systems) */
+    addAttractor?: (attractor?: Attractor) => void;
+    /** Remove an attractor (only for CPU particle systems) */
+    removeAttractor?: (attractor: Attractor) => void;
+}
+/**
+ * Creates an IAttractorData adapter from a CPU particle system Attractor.
+ * @param attractor The CPU particle system attractor
+ * @returns The IAttractorData adapter
+ */
+export declare function CreateCPUAttractorData(attractor: Attractor): IAttractorData;
+/**
+ * Creates an IAttractorData adapter from a Node particle system UpdateAttractorBlock.
+ * @param block The UpdateAttractorBlock from a Node particle system
+ * @returns The IAttractorData adapter
+ */
+export declare function CreateNodeAttractorData(block: UpdateAttractorBlock): IAttractorData;
+/**
+ * Creates an IAttractorSource for a CPU particle system.
+ * @param system The CPU particle system
+ * @param attractors The current attractors array (from useObservableArray hook)
+ * @returns The IAttractorSource adapter
+ */
+export declare function CreateCPUAttractorSource(system: ParticleSystem, attractors: Attractor[]): IAttractorSource;
+/**
+ * Creates an IAttractorSource for a Node particle system.
+ * @param nodeSet The NodeParticleSystemSet
+ * @returns The IAttractorSource adapter
+ */
+export declare function CreateNodeAttractorSource(nodeSet: NodeParticleSystemSet): IAttractorSource;

package/lib/components/properties/particles/attractorList.d.ts

@@ -0,0 +1,15 @@
+import { type FunctionComponent } from "react";
+import { type Scene } from "@babylonjs/core/scene.js";
+import { type IAttractorSource } from "./attractorAdapter";
+type AttractorListProps = {
+    scene: Scene;
+    attractorSource: IAttractorSource;
+};
+/**
+ * Component that displays a list of attractors with debug visualization and editing controls.
+ * Supports both CPU particle systems (editable) and Node particle systems (read-only).
+ * @param props The component props containing the scene and attractor source.
+ * @returns The rendered AttractorList component.
+ */
+export declare const AttractorList: FunctionComponent<AttractorListProps>;
+export {};