@planara/core 2.8.0 → 3.1.0

package/dist/interfaces/api/mesh-api.d.ts

@@ -1,38 +1,119 @@
 import * as THREE from 'three';
 /**
- * Интерфейс для управления фигурами внутри рендерера.
- * Предоставляет базовый CRUD-набор операций для добавления, удаления и получения фигур из сцены.
+ * API для управления мешами (фигурами) в сцене.
+ *
+ * @remarks
+ * Предоставляет базовые CRUD-операции для работы с мешами:
+ * - добавление одного или нескольких мешей
+ * - удаление одного или нескольких мешей
+ * - получение списка всех мешей
+ *
+ * Используется модулями и менеджерами, которым нужно управлять
+ * 3D-объектами на сцене (например, `SceneModule`).
+ *
+ * @see {@link SceneModule} - реализация этого интерфейса
+ * @see {@link Renderer} - рендерер, предоставляющий доступ к сцене
+ *
  * @internal
+ * @interface
  */
 export interface IMeshApi {
     /**
-     * Добавляет фигуру в сцену.
+     * Добавляет один меш на сцену.
      *
-     * @param mesh - Фигура, которую необходимо добавить.
+     * @param mesh - меш для добавления
+     *
+     * @remarks
+     * Меш становится видимым на сцене после вызова этого метода.
+     * Если меш уже добавлен, он не будет продублирован.
+     *
+     * @example
+     * ```typescript
+     * const geometry = new THREE.BoxGeometry(1, 1, 1);
+     * const material = new THREE.MeshStandardMaterial({ color: 0xff0000 });
+     * const mesh = new THREE.Mesh(geometry, material);
+     * meshApi.addMesh(mesh);
+     * ```
+     *
+     * @internal
+     * @method
      */
     addMesh(mesh: THREE.Mesh): void;
     /**
-     * Добавляет несколько фигур в сцену за один вызов.
+     * Добавляет несколько мешей на сцену за один вызов.
+     *
+     * @param meshes - массив мешей для добавления
      *
-     * @param meshes - Массив фигур для добавления.
+     * @remarks
+     * Полезно для массового добавления объектов, например,
+     * при загрузке сцены из файла.
+     *
+     * @example
+     * ```typescript
+     * const meshes = [mesh1, mesh2, mesh3];
+     * meshApi.addMeshes(meshes);
+     * ```
+     *
+     * @internal
+     * @method
      */
     addMeshes(meshes: THREE.Mesh[]): void;
     /**
-     * Удаляет фигуру из сцены.
+     * Удаляет один меш со сцены.
+     *
+     * @param mesh - меш для удаления
+     *
+     * @remarks
+     * Меш перестаёт отображаться, но его геометрия и материал
+     * остаются в памяти. Для полного освобождения памяти нужно
+     * вызвать `dispose()` у геометрии и материала.
      *
-     * @param mesh - Фигура, которую необходимо удалить.
+     * @example
+     * ```typescript
+     * meshApi.removeMesh(mesh);
+     * mesh.geometry.dispose();
+     * mesh.material.dispose();
+     * ```
+     *
+     * @internal
+     * @method
      */
     removeMesh(mesh: THREE.Mesh): void;
     /**
-     * Удаляет несколько фигур из сцены за один вызов.
+     * Удаляет несколько мешей со сцены за один вызов.
+     *
+     * @param meshes - массив мешей для удаления
+     *
+     * @remarks
+     * Полезно для массового удаления объектов, например,
+     * при очистке сцены.
+     *
+     * @example
+     * ```typescript
+     * const meshes = meshApi.getMeshes();
+     * meshApi.removeMeshes(meshes);
+     * ```
      *
-     * @param meshes - Массив фигур для удаления.
+     * @internal
+     * @method
      */
     removeMeshes(meshes: THREE.Mesh[]): void;
     /**
-     * Возвращает список всех фигур, находящихся в сцене.
+     * Возвращает список всех мешей, находящихся на сцене.
+     *
+     * @returns массив мешей
+     *
+     * @remarks
+     * Возвращает только меши, добавленные через `addMesh` или `addMeshes`.
+     * Вспомогательные объекты (сетка, оси, свет) не включаются в список.
+     *
+     * @example
+     * ```typescript
+     * const allMeshes = meshApi.getMeshes();
+     * ```
      *
-     * @returns Массив текущих фигур.
+     * @internal
+     * @method
      */
     getMeshes(): THREE.Mesh[];
 }

package/dist/interfaces/api/mesh-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mesh-api.d.ts","sourceRoot":"","sources":["../../../src/interfaces/api/mesh-api.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC;IAEhC;;;;OAIG;IACH,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC;IAEtC;;;;OAIG;IACH,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC;IAEnC;;;;OAIG;IACH,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC;IAEzC;;;;OAIG;IACH,SAAS,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;CAC3B"}
+{"version":3,"file":"mesh-api.d.ts","sourceRoot":"","sources":["../../../src/interfaces/api/mesh-api.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,QAAQ;IACvB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC;IAEhC;;;;;;;;;;;;;;;;;OAiBG;IACH,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC;IAEtC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC;IAEnC;;;;;;;;;;;;;;;;;OAiBG;IACH,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC;IAEzC;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;CAC3B"}

package/dist/interfaces/api/raycast-api.d.ts

@@ -6,9 +6,11 @@ import { SelectMode } from '@planara/types';
  * определяет, какие объекты участвуют в пиккинге и какие пороги
  * используются:
  * Настройка режима может меняться на лету, перед любым вызовом `raycaster.intersectObjects`.
+ *
  * @internal
+ * @interface
  */
-export interface IRaycastAPI {
+export interface IRaycastApi {
     /**
      * Устанавливает режим работы Raycaster и связанные с ним таргеты/пороговые параметры.
      *
@@ -17,6 +19,9 @@ export interface IRaycastAPI {
      * - `Edge`
      * - `Vertex`
      * @param mode Текущий режим выбора (`Mesh | Face | Edge | Vertex`).
+     *
+     * @internal
+     * @method
      */
     setRaycastMode(mode: SelectMode): void;
 }

package/dist/interfaces/api/raycast-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"raycast-api.d.ts","sourceRoot":"","sources":["../../../src/interfaces/api/raycast-api.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;;;;OAQG;IACH,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;CACxC"}
+{"version":3,"file":"raycast-api.d.ts","sourceRoot":"","sources":["../../../src/interfaces/api/raycast-api.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;;OAWG;IACH,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;CACxC"}

package/dist/interfaces/api/renderer/index.d.ts

@@ -0,0 +1,6 @@
+export * from './renderable';
+export * from './renderer-access';
+export * from './renderer-camera-access';
+export * from './renderer-dom-access';
+export * from './renderer-scene-access';
+//# sourceMappingURL=index.d.ts.map

package/dist/interfaces/api/renderer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/api/renderer/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC"}

package/dist/interfaces/api/renderer/renderable.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Интерфейс для объектов, которые могут быть отрисованы.
+ *
+ * @remarks
+ * Предназначен для модулей, которым требуется кастомный рендеринг
+ * поверх основной сцены (например, `GizmoModule`).
+ *
+ * **Отличие от `IUpdatableModule`:**
+ * - `render()` вызывается **после** основного рендера сцены
+ * - `render()` предназначен для отрисовки дополнительных элементов
+ *   (осей координат, отладочной информации, оверлеев)
+ *
+ * **Жизненный цикл:**
+ * 1. `init()` (из `IRuntimeModule`) — создание ресурсов
+ * 2. `render()` — отрисовка (вызывается каждый кадр)
+ * 3. `dispose()` (из `IRuntimeModule`) — освобождение ресурсов
+ *
+ * @public
+ * @interface
+ */
+export interface IRenderable {
+    /**
+     * Выполняет кастомный рендеринг объекта.
+     *
+     * @remarks
+     * Вызывается каждый кадр **после** основного рендера сцены.
+     *
+     * **Важно:** метод не должен выполнять тяжёлые операции,
+     * чтобы не снижать производительность.
+     *
+     * @example
+     * ```typescript
+     * public render(): void {
+     *   const canvas = this._domApi.getCanvas();
+     *   this._gizmo?.render(canvas.width, canvas.height);
+     *   this._drawFPS();
+     * }
+     * ```
+     *
+     * @public
+     * @method
+     */
+    render(): void;
+}
+//# sourceMappingURL=renderable.d.ts.map

package/dist/interfaces/api/renderer/renderable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderable.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/api/renderer/renderable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,IAAI,IAAI,CAAC;CAChB"}

package/dist/interfaces/api/renderer/renderer-access.d.ts

@@ -0,0 +1,34 @@
+import * as THREE from 'three';
+/**
+ * Низкоуровневый доступ к WebGLRenderer.
+ *
+ * @remarks
+ * Этот интерфейс **реализуется самим рендерером** (`Renderer`).
+ * Предоставляет прямой доступ к WebGLRenderer Three.js.
+ *
+ * Используется **только внутренними API-слоями** (например, `RendererApi`),
+ * но не модулями напрямую.
+ *
+ * @see {@link Renderer} - класс, реализующий этот интерфейс
+ *
+ * @public
+ * @interface
+ */
+export interface IRendererAccess {
+    /**
+     * Возвращает WebGLRenderer.
+     *
+     * @returns THREE.WebGLRenderer - рендерер Three.js
+     *
+     * @example
+     * ```typescript
+     * // Использование в RendererApi
+     * const renderer = this._rendererAccess.getRenderer();
+     * ```
+     *
+     * @public
+     * @method
+     */
+    getRenderer(): THREE.WebGLRenderer;
+}
+//# sourceMappingURL=renderer-access.d.ts.map

package/dist/interfaces/api/renderer/renderer-access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer-access.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/api/renderer/renderer-access.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;;;;;;;;OAaG;IACH,WAAW,IAAI,KAAK,CAAC,aAAa,CAAC;CACpC"}

package/dist/interfaces/api/renderer/renderer-camera-access.d.ts

@@ -0,0 +1,37 @@
+import * as THREE from 'three';
+/**
+ * Предоставляет низкоуровневый доступ к камере рендерера.
+ *
+ * Этот интерфейс используется внутренними модулями (например, `CameraApi`) для
+ * получения прямого доступа к камере `Three.js`. Он не содержит логики управления
+ * камерой — только доступ к объекту.
+ *
+ * @remarks
+ * В отличие от `ICameraApi`, который предоставляет высокоуровневые операции
+ * (включение слоёв, настройка параметров), этот интерфейс нужен только для
+ * чтения камеры.
+ *
+ * @see {@link Renderer} - класс, который реализует этот интерфейс
+ *
+ * @public
+ * @interface
+ */
+export interface IRendererCameraAccess {
+    /**
+     * Возвращает камеру рендерера.
+     *
+     * @returns Камера Three.js.
+     *
+     * @example
+     * ```typescript
+     * const camera = cameraAccess.getCamera();
+     * camera.position.set(5, 5, 5);
+     * camera.lookAt(0, 0, 0);
+     * ```
+     *
+     * @public
+     * @method
+     */
+    getCamera(): THREE.Camera;
+}
+//# sourceMappingURL=renderer-camera-access.d.ts.map

package/dist/interfaces/api/renderer/renderer-camera-access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer-camera-access.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/api/renderer/renderer-camera-access.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;;;;;;OAcG;IACH,SAAS,IAAI,KAAK,CAAC,MAAM,CAAC;CAC3B"}

package/dist/interfaces/api/renderer/renderer-dom-access.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Низкоуровневый доступ к DOM-элементам рендерера.
+ *
+ * @remarks
+ * Этот интерфейс предоставляет доступ к canvas и DOM-элементу рендерера.
+ * Используется внутренними API-слоями (например, `DomApi`)
+ * для получения доступа к DOM без необходимости знать конкретную реализацию рендерера.
+ *
+ * @see {@link Renderer} - класс, реализующий этот интерфейс
+ *
+ * @public
+ * @interface
+ */
+export interface IRendererDomAccess {
+    /**
+     * Возвращает canvas-элемент редактора.
+     *
+     * @remarks
+     * Canvas используется для рендеринга 3D-сцены.
+     *
+     * @returns HTMLCanvasElement - canvas элемент
+     *
+     * @example
+     * ```typescript
+     * const canvas = domAccess.getCanvas();
+     * ```
+     *
+     * @public
+     */
+    getCanvas(): HTMLCanvasElement;
+    /**
+     * Возвращает DOM-элемент рендерера.
+     *
+     * @remarks
+     * Обычно это тот же canvas, но в некоторых случаях может быть
+     * другим элементом (например, div-обёрткой). Используется для
+     * подписки на события ввода (mousemove, click, dblclick и т.д.).
+     *
+     * @returns HTMLElement - DOM-элемент для подписки на события
+     *
+     * @example
+     * ```typescript
+     * const domElement = domAccess.getDomElement();
+     * ```
+     *
+     * @public
+     * @method
+     */
+    getDomElement(): HTMLElement;
+}
+//# sourceMappingURL=renderer-dom-access.d.ts.map

package/dist/interfaces/api/renderer/renderer-dom-access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer-dom-access.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/api/renderer/renderer-dom-access.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;;;;;;;;;;OAcG;IACH,SAAS,IAAI,iBAAiB,CAAC;IAE/B;;;;;;;;;;;;;;;;;OAiBG;IACH,aAAa,IAAI,WAAW,CAAC;CAC9B"}

package/dist/interfaces/api/renderer/renderer-scene-access.d.ts

@@ -0,0 +1,45 @@
+import * as THREE from 'three';
+/**
+ * Низкоуровневый доступ к сцене рендерера.
+ *
+ * @remarks
+ * Этот интерфейс предоставляет доступ к сцене Three.js.
+ * Используется внутренними API-слоями (например, `SceneApi`)
+ * для получения доступа к сцене без необходимости знать конкретную
+ * реализацию рендерера.
+ *
+ * @see {@link Renderer} - класс, реализующий этот интерфейс
+ *
+ * @public
+ * @interface
+ */
+export interface IRendererSceneAccess {
+    /**
+     * Возвращает сцену рендерера.
+     *
+     * @returns THREE.Scene - сцена Three.js
+     *
+     * @remarks
+     * Сцена содержит все объекты, которые рендерятся на экране.
+     * Через неё можно добавлять, удалять и модифицировать объекты.
+     *
+     * @example
+     * ```typescript
+     * const scene = sceneAccess.getScene();
+     *
+     * // Добавление объекта
+     * scene.add(myMesh);
+     *
+     * // Поиск объекта по имени
+     * const obj = scene.getObjectByName('myObject');
+     *
+     * // Удаление объекта
+     * scene.remove(obj);
+     * ```
+     *
+     * @public
+     * @method
+     */
+    getScene(): THREE.Scene;
+}
+//# sourceMappingURL=renderer-scene-access.d.ts.map

package/dist/interfaces/api/renderer/renderer-scene-access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer-scene-access.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/api/renderer/renderer-scene-access.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,QAAQ,IAAI,KAAK,CAAC,KAAK,CAAC;CACzB"}

package/dist/interfaces/api/renderer-api.d.ts

@@ -0,0 +1,35 @@
+import * as THREE from 'three';
+/**
+ * API для доступа к WebGLRenderer.
+ *
+ * @remarks
+ * Этот интерфейс **реализуется прослойкой** (`RendererApi`), а не самим рендерером.
+ * Предоставляет тот же функционал, но через верхнеуровневый API.
+ *
+ * Используется **модулями** (например, `GizmoModule`), которым нужен доступ
+ * к WebGLRenderer, но которые не должны знать о конкретной реализации рендерера.
+ *
+ * @see {@link RendererApi} - реализация этого интерфейса
+ * @see {@link IRendererAccess} - нижнеуровневый доступ (реализуется рендерером)
+ *
+ * @internal
+ * @interface
+ */
+export interface IRendererApi {
+    /**
+     * Возвращает WebGLRenderer.
+     *
+     * @returns THREE.WebGLRenderer - рендерер Three.js
+     *
+     * @example
+     * ```typescript
+     * const renderer = rendererApi.getRenderer();
+     * renderer.setSize(width, height);
+     * ```
+     *
+     * @internal
+     * @method
+     */
+    getRenderer(): THREE.WebGLRenderer;
+}
+//# sourceMappingURL=renderer-api.d.ts.map

package/dist/interfaces/api/renderer-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer-api.d.ts","sourceRoot":"","sources":["../../../src/interfaces/api/renderer-api.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;;;;;;;;;OAaG;IACH,WAAW,IAAI,KAAK,CAAC,aAAa,CAAC;CACpC"}

package/dist/interfaces/api/scene-api.d.ts

@@ -1,50 +1,90 @@
 import * as THREE from 'three';
 /**
- * Мини-API для взаимодействия со сценой и слоями камеры.
+ * Высокоуровневое API для управления сценой.
  *
  * @remarks
- * Абстрагирует прямой доступ к `THREE.Scene`/`THREE.Camera`, позволяя
- * хендлерам добавлять/удалять объекты и управлять видимостью слоёв.
- * Рекомендуется использовать совместно с константами слоёв
- * (например, `MESH_LAYER`, `LINE_LAYER`, `OVERLAY_LAYER`).
+ * Предоставляет базовые операции для работы со сценой Three.js:
+ * - получение сцены
+ * - добавление объектов на сцену
+ * - удаление объектов со сцены
  *
- * @example
- * // Добавить оверлей на слой подсветок и убедиться, что камера его видит:
- * sceneApi.add(overlayLine, OVERLAY_LAYER);
- * sceneApi.enableCameraLayer(OVERLAY_LAYER);
+ * Используется модулями и хендлерами, которым нужно управлять
+ * объектами на сцене (например, добавление мешей, света, вспомогательных элементов).
+ *
+ * @see {@link SceneApi} - реализация этого интерфейса
+ * @see {@link IRendererSceneAccess} - низкоуровневый доступ к сцене (internal)
+ *
+ * @internal
+ * @interface
  */
 export interface ISceneApi {
     /**
-     * Добавляет объект в сцену.
+     * Возвращает сцену рендерера.
      *
-     * @param obj - Объект для добавления (`THREE.Object3D`).
-     * @param layer - (Опц.) Слой, который следует выставить объекту перед добавлением.
+     * @returns THREE.Scene - сцена Three.js
+     *
+     * @example
+     * ```typescript
+     * const scene = sceneApi.getScene();
+     * ```
+     *
+     * @internal
+     * @method
+     */
+    getScene(): THREE.Scene;
+    /**
+     * Добавляет объект на сцену.
+     *
+     * @param object - объект Three.js для добавления (Mesh, Light, Group и т.д.)
      *
      * @remarks
-     * Если `layer` указан, реализация должна вызвать `obj.layers.set(layer)` или
-     * эквивалентную логику, прежде чем поместить объект в сцену.
+     * Объект будет виден на сцене после вызова этого метода.
+     * Если объект уже добавлен, он не будет продублирован.
+     *
+     * @example
+     * ```typescript
+     * const mesh = new THREE.Mesh(geometry, material);
+     * sceneApi.addToScene(mesh);
+     * ```
+     *
+     * @internal
+     * @method
      */
-    addObject(obj: THREE.Object3D, layer?: number): void;
+    addToScene(object: THREE.Object3D): void;
     /**
-     * Удаляет объект из сцены.
+     * Удаляет объект со сцены.
      *
-     * @param obj - Объект для удаления.
+     * @param object - объект Three.js для удаления
      *
      * @remarks
-     * Реализация может дополнительно освобождать ресурсы (материалы, геометрию)
-     * по соглашению, но это не обязательно для интерфейса.
+     * Объект перестаёт отображаться на сцене.
+     *
+     * @example
+     * ```typescript
+     * sceneApi.removeFromScene(mesh);
+     * ```
+     *
+     * @internal
+     * @method
      */
-    removeObject(obj: THREE.Object3D): void;
+    removeFromScene(object: THREE.Object3D): void;
     /**
-     * Включает указанный слой для активной камеры,
-     * чтобы объекты на этом слое были видимы.
+     * Добавляет объект в сцену и (опционально) выставляет ему слой.
+     *
+     * @param object - Объект, который нужно добавить в сцену.
+     * @param layer - (Опц.) Номер слоя, который следует установить объекту перед добавлением.
      *
-     * @param layer - Номер слоя, который требуется включить.
+     * @remarks
+     * Если рендерер уже диспоузнут (scene отсутствует), метод тихо завершится.
+     * Слой задаётся через `obj.layers.set(layer)`, после чего объект добавляется в `this.scene`.
      *
      * @example
-     * // Показать оверлеи подсветки:
-     * sceneApi.enableCameraLayer(OVERLAY_LAYER);
+     * // Добавить оверлей на слой подсветок:
+     * add(overlayLine, OVERLAY_LAYER);
+     *
+     * @internal
+     * @method
      */
-    enableCameraLayer(layer: number): void;
+    addObject(object: THREE.Object3D, layer?: number): void;
 }
 //# sourceMappingURL=scene-api.d.ts.map

package/dist/interfaces/api/scene-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene-api.d.ts","sourceRoot":"","sources":["../../../src/interfaces/api/scene-api.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,SAAS;IACxB;;;;;;;;;OASG;IACH,SAAS,CAAC,GAAG,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAErD;;;;;;;;OAQG;IACH,YAAY,CAAC,GAAG,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC;IAExC;;;;;;;;;OASG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACxC"}
+{"version":3,"file":"scene-api.d.ts","sourceRoot":"","sources":["../../../src/interfaces/api/scene-api.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,SAAS;IACxB;;;;;;;;;;;;OAYG;IACH,QAAQ,IAAI,KAAK,CAAC,KAAK,CAAC;IAExB;;;;;;;;;;;;;;;;;OAiBG;IACH,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC;IAEzC;;;;;;;;;;;;;;;OAeG;IACH,eAAe,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC;IAE9C;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACzD"}