simple-circuit-engine 0.0.11 → 0.0.12

package/dist/scene/shared/utils/GeometryUtils.d.ts

@@ -0,0 +1,261 @@
+import { Position, Rotation } from '../../../core/index.ts';
+import { ExtrudeGeometry } from 'three';
+/**
+ * Geometry Utilities
+ * @module scene/shared/utils/GeometryUtils
+ *
+ * Helper functions for creating Three.js geometries for grid and circuit elements
+ */
+import * as THREE from 'three';
+/**
+ * convenience to control standard rotations of meshes on X-Z plan
+ */
+export type Direction2D = 'right' | 'bottom' | 'left' | 'top';
+/**
+ * Create a grid helper for the scene
+ *
+ * @param size - Size of the grid
+ * @param divisions - Number of grid divisions
+ * @param colorCenterLine - Color for center lines
+ * @param colorGrid - Color for grid lines
+ * @returns GridHelper object
+ */
+export declare function createGridHelper(size: number, divisions: number, colorCenterLine: number, colorGrid: number): THREE.GridHelper;
+/**
+ * optimal number of grid divisions for a given size
+ * @param size
+ */
+export declare function computeDivisionsForSize(size: number): number;
+/**
+ * Components, branching points and wires intermediate points snap to the nearest integer grid point.
+ * @param position
+ * @constructor
+ */
+export declare function nearestWorldSnapPosition(position: THREE.Vector3): THREE.Vector3;
+/**
+ * Converts a world 3D position to the snapped 2D model grid position.
+ * @param position
+ * @constructor
+ */
+export declare function worldToGridPosition(position: THREE.Vector3): Position;
+/**
+ * Converts a model grid 2D position to the world 3D position.
+ * @param position
+ * @constructor
+ */
+export declare function gridToWorldPosition(position: Position): THREE.Vector3;
+/**
+ * Converts a world 3D rotation to the model grid 2D rotation.
+ * @param rotation
+ * @constructor
+ */
+export declare function worldToGridRotation(rotation: THREE.Euler): Rotation;
+/**
+ * Converts model grid 2D rotation to the world 3D rotation.
+ * @param rotation
+ * @constructor
+ */
+export declare function gridToWorldRotation(rotation: Rotation): THREE.Euler;
+/**
+ * Get the bounding box of a Three.js object in world space
+ *
+ * @param object - The Three.js object to get bounds for
+ * @returns Box3 representing the world-space bounding box
+ */
+export declare function getObjectBoundingBox(object: THREE.Object3D): THREE.Box3;
+/**
+ * Project a 3D world position to 2D screen coordinates
+ *
+ * @param worldPosition - Position in world space
+ * @param camera - Camera to use for projection
+ * @param width - Viewport width in pixels
+ * @param height - Viewport height in pixels
+ * @returns Screen coordinates {x, y} where (0,0) is top-left
+ */
+export declare function worldToScreenPosition(worldPosition: THREE.Vector3, camera: THREE.Camera, width: number, height: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Check if a 3D point (projected to screen space) is inside a 2D screen rectangle
+ *
+ * @param worldPosition - Position in world space
+ * @param camera - Camera to use for projection
+ * @param width - Viewport width in pixels
+ * @param height - Viewport height in pixels
+ * @param rect - Screen rectangle with min/max coordinates
+ * @returns true if the projected point is inside the rectangle
+ */
+export declare function isPointInScreenRect(worldPosition: THREE.Vector3, camera: THREE.Camera, width: number, height: number, rect: {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}): boolean;
+/**
+ * Check if an object's center point is inside a screen rectangle
+ * Used for rectangle selection of components and branching points
+ *
+ * @param object - The Three.js object to check
+ * @param camera - Camera to use for projection
+ * @param width - Viewport width in pixels
+ * @param height - Viewport height in pixels
+ * @param rect - Screen rectangle with min/max coordinates
+ * @returns true if object's center is inside the rectangle
+ */
+export declare function isObjectInScreenRect(object: THREE.Object3D, camera: THREE.Camera, width: number, height: number, rect: {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}): boolean;
+/**
+ * Create a ring geometry with given inner/outer radius and depth (y axis)
+ * @param innerRadius
+ * @param outerRadius
+ * @param depth
+ * @param steps
+ * @constructor
+ */
+export declare function RingGeometry(innerRadius: number, outerRadius: number, depth: number, steps: number): ExtrudeGeometry;
+/**
+ * Create an ExtrudeGeometry for the body of an AND gate.
+ * Shape is centered at origin: flat side on the left, semicircle on the right,
+ * matching the standard logic gate schematic representation.
+ * Handles both standard (width > height / 2) and tall (width ≤ height / 2) proportions.
+ *
+ * Input pins attach on the left flat side (x = -width/2).
+ * Output pin attaches at the rightmost point of the arc (x = +width/2).
+ *
+ * The thickness parameter controls a visual state trick:
+ * - LOW state:         thin thickness → gate appears as an empty shell
+ * - HIGH state:        thick thickness → gate appears filled
+ * - TRANSITIONING:     medium thickness → gate appears half-filled
+ *
+ * @param width     - Total width, from left flat edge to rightmost arc point
+ * @param height    - Total height; also determines the arc radius (= height / 2)
+ * @param thickness - Wall thickness of the gate shell
+ * @param depth     - Extrusion depth
+ * @param steps     - Number of extrusion steps
+ * @constructor
+ */
+export declare function AndGateGeometry(width: number, height: number, thickness: number, depth: number, steps?: number): ExtrudeGeometry;
+/**
+ * Create an ExtrudeGeometry for the inner hole of an AND gate body.
+ * Returns null when thickness is large enough that the gate has no hole.
+ * Handles both standard (width > height / 2) and tall (width ≤ height / 2) proportions.
+ *
+ * @param width     - Total width, from left flat edge to rightmost arc point
+ * @param height    - Total height
+ * @param thickness - Wall thickness of the gate shell
+ * @param depth     - Extrusion depth
+ * @param steps     - Number of extrusion steps
+ */
+export declare function AndGateHoleGeometry(width: number, height: number, thickness: number, depth: number, steps?: number): ExtrudeGeometry | null;
+/**
+ * Create an ExtrudeGeometry for the body of an OR gate.
+ * Same structure as AndGateGeometry but the left side is a concave arc (curves inward)
+ * instead of a flat edge, matching the standard logic gate schematic representation.
+ * Handles both standard (width > height / 2) and tall (width ≤ height / 2) proportions.
+ *
+ * Input pins attach on the left curved side (nominally at x = -width/2).
+ * Output pin attaches at the rightmost point of the right arc (x = +width/2).
+ *
+ * The thickness parameter controls the same visual state trick as AndGateGeometry:
+ * - LOW state:         thin thickness → gate appears as an empty shell
+ * - HIGH state:        thick thickness → gate appears filled
+ * - TRANSITIONING:     medium thickness → gate appears half-filled
+ *
+ * Back arc geometry: the concave left side bows inward (rightward) by backInset = halfH * 0.4.
+ * The arc center sits far to the left; u_b is its x-distance to the back-left corners.
+ * The inner hole back arc is concentric with the outer (same center, radius += 0.1), giving a
+ * truly constant perpendicular wall thickness of 0.1 along the entire back curve, independent
+ * of the thickness parameter.
+ *
+ * @param width     - Total width, from leftmost back curve point to rightmost arc point
+ * @param height    - Total height; also determines the right arc radius (= height / 2)
+ * @param thickness - Wall thickness of the gate shell
+ * @param depth     - Extrusion depth
+ * @param steps     - Number of extrusion steps
+ * @constructor
+ */
+export declare function OrGateGeometry(width: number, height: number, thickness: number, depth: number, steps?: number): ExtrudeGeometry;
+/**
+ * Create an ExtrudeGeometry for the inner hole of an OR gate body.
+ * Returns null when thickness is large enough that the gate has no hole.
+ * Handles both standard (width > height / 2) and tall (width ≤ height / 2) proportions.
+ *
+ * @param width     - Total width
+ * @param height    - Total height
+ * @param thickness - Wall thickness of the gate shell
+ * @param depth     - Extrusion depth
+ * @param steps     - Number of extrusion steps
+ */
+export declare function OrGateHoleGeometry(width: number, height: number, thickness: number, depth: number, steps?: number): ExtrudeGeometry | null;
+/**
+ * Create an ExtrudeGeometry for the XOR gate tail — the distinctive extra curved bar
+ * placed to the left of an OrGateGeometry body to form the full XOR gate symbol.
+ *
+ * Back-arc parameters (backInset, u_b, cx_b, r_b, angle_b) are identical to those in
+ * OrGateGeometry so this geometry aligns correctly when placed at the same centre.
+ *
+ * Note: the tail arc's centre is shifted left by tailWidth (radius stays constant = r_b), so
+ * the tail always spans the full gate height regardless of tailWidth.
+ * For bars to be visible, barsSeparation must be less than orHeight − 2 × thickness.
+ *
+ * @param orWidth        - Width of the paired OR gate body
+ * @param orHeight       - Height of the paired OR gate body
+ * @param tailWidth      - How far left the tail arc's corners are from the OR gate's left corners
+ * @param thickness      - Wall thickness of the arc shell AND height of each bar
+ * @param barsSeparation - Vertical gap between the two bars (centred on y = 0)
+ * @param depth          - Extrusion depth
+ * @param steps          - Number of extrusion steps
+ */
+export declare function XorGateTailGeometry(orWidth: number, orHeight: number, tailWidth: number, thickness: number, barsSeparation: number, depth: number, steps?: number): ExtrudeGeometry;
+/**
+ * Create an ExtrudeGeometry shaped like an L (or mirrored L) with a configurable
+ * angle between the two arms.
+ *
+ * Default orientation (`invert = false`) produces a `|_`-like shape:
+ *   base arm extends to the right, stem arm extends upward at the given angle.
+ * When `invert = true` the shape is mirrored horizontally (`_|`-like):
+ *   base arm extends to the left, stem arm mirrors accordingly.
+ *
+ * The `angle` parameter (in degrees) controls the inner angle between the two arms:
+ *   - 90°  → standard right-angle L
+ *   - 120° → obtuse junction (`\_`-like)
+ *   - 60°  → acute junction
+ *
+ * Both the inner (concave) and outer (convex) junction corners are rounded
+ * equally with `junctionRadius` (similar to CSS border-radius).
+ * When 0 both corners are sharp. The arc sweep adapts to the angle: (180° − angle).
+ *
+ * The geometry is centered on its bounding box.
+ *
+ * At 90°, `width` and `height` correspond exactly to the bounding box dimensions.
+ * At other angles the bounding box changes but the arm lengths remain consistent:
+ * base inner arm = width − thickness, stem inner arm = height − thickness.
+ *
+ * @param width           - Base arm length (bounding-box width at 90°)
+ * @param height          - Stem arm length (bounding-box height at 90°)
+ * @param thickness       - Arm thickness of the L
+ * @param angle           - Inner angle between the two arms, in degrees (typically 30–150)
+ * @param invert          - If true, mirror horizontally
+ * @param junctionRadius  - Radius of the rounded junction corners, inner and outer (0 = sharp)
+ * @param depth           - Extrusion depth
+ * @param steps           - Number of extrusion steps
+ */
+export declare function LGeometry(width: number, height: number, thickness: number, angle: number, invert: boolean, junctionRadius: number, depth: number, steps?: number): ExtrudeGeometry;
+export declare function CyclicTrapezoidGeometry(width: number, tailHeight: number, headHeight: number, thickness: number, depth: number, steps?: number): ExtrudeGeometry;
+/**
+ * Create an ExtrudeGeometry for the inner hole of a cyclic trapezoid.
+ * Returns null when the geometry should be solid (no hole).
+ *
+ * @param width      - Total width
+ * @param tailHeight - Height of the left (tail) side
+ * @param headHeight - Height of the right (head) side (0 for triangle)
+ * @param thickness  - Wall thickness
+ * @param depth      - Extrusion depth
+ * @param steps      - Number of extrusion steps
+ */
+export declare function CyclicTrapezoidHoleGeometry(width: number, tailHeight: number, headHeight: number, thickness: number, depth: number, steps?: number): ExtrudeGeometry | null;

package/dist/scene/shared/utils/LayerConstants.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Three.js Layer Constants for Hitbox Organization
+ * @module scene/shared/utils/LayerConstants
+ *
+ * Defines layer assignments for priority-based raycasting and rendering.
+ */
+/**
+ * Three.js layer assignments for hitbox meshes and rendering
+ *
+ * Layers enable priority-based raycasting by querying layers sequentially.
+ * Lower layer numbers = higher priority for hover detection.
+ *
+ * @remarks
+ * - Layer 0 is reserved for default visual rendering
+ * - Hitbox layers (1-3) are invisible but raycastable
+ * - Camera.layers should include only layer 0 for rendering
+ * - Raycaster.layers is set per-query based on priority
+ *
+ * @example
+ * ```typescript
+ * import { HitboxLayers } from './LayerConstants';
+ *
+ * // Assign hitbox to component layer
+ * hitboxMesh.layers.set(HitboxLayers.COMPONENT);
+ *
+ * // Raycast only enode hitboxes
+ * raycaster.layers.set(HitboxLayers.ENODE);
+ * ```
+ */
+export declare const HitboxLayers: {
+    /** Default layer for visual rendering (do not use for hitboxes) */
+    readonly DEFAULT: 0;
+    /** Enode hitboxes - highest hover priority */
+    readonly ENODE: 1;
+    /** Component hitboxes - medium hover priority */
+    readonly COMPONENT: 2;
+    /** Wire hitboxes - lowest hover priority */
+    readonly WIRE: 3;
+};
+export type HitboxLayerValue = (typeof HitboxLayers)[keyof typeof HitboxLayers];

package/dist/scene/shared/utils/LightingUtils.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Lighting Utilities
+ * @module scene/shared/utils/LightingUtils
+ *
+ * Helper functions for setting up scene lighting
+ */
+import * as THREE from 'three';
+/**
+ * Create an ambient light with default intensity
+ *
+ * @param color - Light color (hex)
+ * @param intensity - Light intensity (0-1)
+ * @returns AmbientLight
+ */
+export declare function createAmbientLight(color?: number, intensity?: number): THREE.AmbientLight;
+/**
+ * Create a directional light with default positioning
+ *
+ * @param color - Light color (hex)
+ * @param intensity - Light intensity
+ * @param position - Light position
+ * @returns DirectionalLight
+ */
+export declare function createDirectionalLight(color?: number, intensity?: number, position?: THREE.Vector3): THREE.DirectionalLight;
+/**
+ * Setup standard scene lighting (ambient + directional)
+ *
+ * @param scene - Scene to add lights to
+ * @returns Array of created lights
+ */
+export declare function setupSceneLights(scene: THREE.Scene): THREE.Light[];

package/dist/scene/shared/utils/MaterialUtils.d.ts

@@ -0,0 +1,73 @@
+import { LineMaterial } from 'three/examples/jsm/lines/LineMaterial.js';
+/**
+ * Material Utilities
+ * @module scene/shared/utils/MaterialUtils
+ *
+ * Helper functions for creating and managing Three.js materials
+ */
+import * as THREE from 'three';
+/**
+ * Create a standard material with common defaults
+ *
+ * @param color - Base color (hex)
+ * @param options - Additional material options
+ * @returns MeshStandardMaterial
+ */
+export declare function createStandardMaterial(color: number, options?: {
+    emissive?: number;
+    emissiveIntensity?: number;
+    metalness?: number;
+    roughness?: number;
+    transparent?: boolean;
+    opacity?: number;
+}): THREE.MeshStandardMaterial;
+/**
+ * Create a material for wire lines
+ *
+ * @param color - Line color (hex)
+ * @param linewidth - Line width (note: may not work on all platforms)
+ * @returns LineBasicMaterial
+ */
+export declare function createLineMaterial(color?: number, linewidth?: number): THREE.LineBasicMaterial;
+/**
+ * Create a LineMaterial for Line2 rendering with consistent line width
+ *
+ * Note: Resolution must be set after creation using material.resolution.set(width, height)
+ *
+ * @param color - Line color (hex, default: 0xffffff/white)
+ * @param linewidth - Line width in pixels (default: 2)
+ * @returns LineMaterial for Line2 objects
+ *
+ * @example
+ * ```typescript
+ * const material = createLine2Material(0xffffff, 2);
+ * material.resolution.set(window.innerWidth, window.innerHeight);
+ * ```
+ */
+export declare function createLine2Material(color?: number, linewidth?: number): LineMaterial;
+/**
+ * Update material state for component state changes
+ *
+ * @param material - Material to update
+ * @param state - Component state data
+ */
+export declare function updateMaterialState(material: THREE.MeshStandardMaterial, state: {
+    isActive?: boolean;
+    isHighlighted?: boolean;
+    customColor?: number;
+    emissiveIntensity?: number;
+}): void;
+/**
+ * Create a semi-transparent preview material
+ *
+ * @param baseColor - Base color
+ * @param opacity - Transparency level (0-1)
+ * @returns MeshStandardMaterial configured for preview
+ */
+export declare function createPreviewMaterial(baseColor: number, opacity?: number): THREE.MeshStandardMaterial;
+/**
+ * Create an error state material (for validation feedback)
+ *
+ * @returns MeshStandardMaterial in error state (red tint)
+ */
+export declare function createErrorMaterial(): THREE.MeshStandardMaterial;

package/dist/scene/shared/utils/Options.d.ts

@@ -0,0 +1,16 @@
+import { ControllerOptions, EngineOptions, MapControlsOptions } from '../types';
+/**
+ * returns default complete mapControlsOptions or an autocompleted partial mapControlOptions
+ * @param options
+ */
+export declare function mapControlsOptions(options?: MapControlsOptions | undefined): MapControlsOptions;
+/**
+ * returns default complete controllerOptions or an autocompleted partial controllerOptions
+ * @param options
+ */
+export declare function controllerOptions(options?: ControllerOptions | undefined): ControllerOptions;
+/**
+ * returns default complete engineOptions or and autoCompleted partial engineOptions
+ * @param options
+ */
+export declare function engineOptions(options?: EngineOptions | undefined): EngineOptions;

package/dist/scene/simulation/CircuitRunnerController.d.ts

@@ -0,0 +1,227 @@
+import { Circuit, BehaviorRegistry } from '../../core/index.ts';
+import { IFactoryRegistry } from '../shared/components/ComponentVisualFactory';
+import { SharedResources, ControllerOptions } from '../shared/types';
+import { AbstractCircuitController } from '../shared/AbstractCircuitController';
+/**
+ * Simulation Circuit Runner Controller Implementation
+ *
+ * Manages Three.js scene for live circuit simulation visualization.
+ * Provides smooth interpolation between simulation ticks for 60fps rendering.
+ * Animates current flow through wires and component state changes.
+ */
+export declare class CircuitRunnerController extends AbstractCircuitController {
+    private _runner;
+    private _behaviorRegistry;
+    private _animationContext;
+    private _autoPlay;
+    private _isPlaying;
+    private _tickIntervalMs;
+    private _simulationLoopId;
+    private _clickHandler;
+    /**
+     * Create a new Simulation Circuit Controller
+     *
+     * @param factoryRegistry - Component visual factory registry
+     * @param behaviorRegistry - Component behavior registry
+     * @param sharedResources - Optional shared resources for facade pattern (CircuitEngine)
+     * @throws {TypeError} If factoryRegistry is null/undefined
+     */
+    constructor(factoryRegistry: IFactoryRegistry, behaviorRegistry: BehaviorRegistry, sharedResources?: SharedResources);
+    /**
+     * Check if simulation is currently playing (auto-advancing ticks)
+     * Returns false if paused or no circuit loaded
+     */
+    get isPlaying(): boolean;
+    /**
+     * Get current tick interval in milliseconds
+     * Default is 500ms (2 ticks per second)
+     */
+    get tickInterval(): number;
+    /**
+     * Set tick interval in milliseconds (50-2000ms)
+     * If simulation is playing, restarts the interval with new value
+     *
+     * @param value - Interval in milliseconds, must be between 50-2000ms
+     * @throws {RangeError} If value is outside valid range
+     */
+    set tickInterval(value: number);
+    /**
+     * Get current simulation speed in ticks per second.
+     * Range: 1-20 TPS
+     */
+    get simulationSpeed(): number;
+    /**
+     * Set simulation speed in ticks per second.
+     * Value is clamped to range 1-20 TPS.
+     * If simulation is playing, restarts the interval with new value.
+     * Emits 'simulationSpeedChanged' event when speed changes.
+     *
+     * @param tps - Ticks per second (1-20)
+     */
+    set simulationSpeed(tps: number);
+    /**
+     * Minimum allowed simulation speed in ticks per second.
+     */
+    get minSimulationSpeed(): number;
+    /**
+     * Maximum allowed simulation speed in ticks per second.
+     */
+    get maxSimulationSpeed(): number;
+    /**
+     * Compute the number of ticks required for a transition given its duration in milliseconds.
+     * Formula: ceil(transitionUserSpanMs × simulationSpeed / 1000), minimum 1.
+     *
+     * @param transitionUserSpanMs - Transition duration in milliseconds
+     * @returns Number of ticks for the transition (minimum 1)
+     */
+    computeTickCount(transitionUserSpanMs: number): number;
+    /**
+     * Get the transition duration from component config for user-driven transitions.
+     * @param config - Component config map
+     * @returns Transition duration in milliseconds (defaults to TRANSITION_USER_SPAN_MS)
+     */
+    private _getTransitionUserSpan;
+    /**
+     * Get current simulation tick number
+     * Returns 0 if no circuit runner is loaded
+     */
+    get currentTick(): number;
+    /**
+     * Specific Initialization logic, performed after AbstractCircuitController initialization
+     * @private
+     *
+     * @param options - Controller options passed to initialize()
+     */
+    protected onInitialize(options?: ControllerOptions): void;
+    protected emitReady(): void;
+    /**
+     * specific disposal prepended at the beginning of dispose process
+     */
+    protected onDispose(): void;
+    onSetActive(active: boolean): void;
+    setCircuit(circuit: Circuit | null): void;
+    /**
+     * specific logic when to render a new set circuit
+     * @protected
+     */
+    protected onSetCircuit(): void;
+    /**
+     * Play automatic simulation playback
+     * Simulation will advance at the configured tick interval until paused
+     *
+     * Requires a circuit runner to be loaded via setCircuitRunner()
+     * Emits 'simulationPlayed' event on play
+     * Emits 'simulationTick' event on each tick
+     */
+    play(): void;
+    /**
+     * Pause automatic simulation playback
+     * Safe to call even if already paused or no circuit loaded
+     *
+     * Emits 'simulationPaused' event
+     */
+    pause(): void;
+    /**
+     * Execute a single simulation tick
+     * Simulation remains paused after step, useful for debugging
+     *
+     * If currently playing, pauses first then steps
+     * Requires a circuit runner to be loaded via setCircuitRunner()
+     * Emits 'simulationStepped' event with tick result
+     */
+    step(): void;
+    /**
+     * Stop the simulation, reset visual to initial state
+     * Simulation remains paused after step, useful for debugging
+     *
+     * If currently playing, pauses first then steps
+     * Requires a circuit runner to be loaded via setCircuitRunner()
+     * Emits 'simulationStopped' event with tick result (0)
+     */
+    stop(): void;
+    /**
+     * Execute one simulation tick and update visuals
+     * @private
+     */
+    private _executeTick;
+    /**
+     * Update component animations for dirty components
+     * @private
+     */
+    private _updateDirtyComponents;
+    /**
+     * Update all active AnimationMixers.
+     * Called per frame from the render loop via CircuitEngine.update(delta).
+     *
+     * @param delta - Time in seconds since last frame
+     */
+    updateAnimations(delta: number): void;
+    /**
+     * Recompute animation timescales when simulation speed changes mid-animation.
+     * Updates ticksPerSecond on userData and adjusts active action timeScales.
+     */
+    private _updateAnimationTimescales;
+    /**
+     * Update wire visual state based on electrical state
+     * @private
+     */
+    private _updateDirtyWires;
+    /**
+     * Update enode visual state based on electrical state
+     * Applies emissive glow to pins and branching points
+     * @private
+     */
+    private _updateDirtyEnodes;
+    /**
+     * rollback wires/enodes/components visuals to edition state (no simulation state)
+     */
+    _removeSimulationStateVisuals(): void;
+    /**
+     * Handle click events for component interaction
+     * @param event
+     * @private
+     */
+    private _handleClick;
+    /**
+     * Handle regular click events : emit user commands to the runner
+     * @param clickedElement
+     * @private
+     */
+    private _handleRegularClick;
+    private _handleCtrlClick;
+    /**
+     * recreate all visuals based on circuit data
+     * Should be called on an already cleared scene
+     *
+     * When using shared resources (CircuitEngine facade), skips visual creation
+     * if visuals already exist in the shared maps (created by edit controller).
+     * @private
+     */
+    private _fullUpdate;
+    /**
+     * Consider all elements as dirty to update all visual state according to simulation state
+     * @private
+     */
+    private _visualUpdateFromSimulationState;
+    private _createComponentObject3D;
+    /**
+     * Index component mesh and its pins meshes for interaction (hover, selection)
+     * @param componentId
+     * @param object3D
+     * @private
+     */
+    private _indexComponentObject3D;
+    /**
+     * Create enode (branching point ONLY) visual object and add to scene
+     * pin enodes are created and attache to their components by createComponentObject3D()
+     *
+     * @param enode
+     * @private
+     */
+    private _createEnodeObject3D;
+    private _createWireObject3D;
+    private _removeComponentObject3D;
+    private _removeEnodeObject3D;
+    private _removeWireObject3D;
+    protected _removeAllVisuals(): void;
+}