@hellpig/anarchy-engine 22.0.3 → 22.0.5

package/dist/Light/Wrappers/HemisphereLightWrapper.d.ts

@@ -1,2 +1,2 @@
-import { TAbstractLightWrapper, THemisphereLight, THemisphereLightParams, TLightServiceDependencies } from '../Models';
+import { TAbstractLightWrapper, THemisphereLight, THemisphereLightParams, TLightServiceDependencies } from '@hellpig/anarchy-engine/Light/Models';
 export declare function HemisphereLightWrapper(params: THemisphereLightParams, dependencies: TLightServiceDependencies): TAbstractLightWrapper<THemisphereLight>;

package/dist/Light/Wrappers/LightWrapperHelper.d.ts

@@ -1,3 +1,3 @@
-import { TAnyLight, TLightParams } from '../Models';
-import { TWriteable } from '../../../../anarchy-shared/src/Utils';
+import { TAnyLight, TLightParams } from '@hellpig/anarchy-engine/Light/Models';
+import { TWriteable } from '@hellpig/anarchy-shared/Utils';
 export declare function applyShadowParams<T extends TAnyLight, P extends TLightParams>(params: P, entity: TWriteable<T>): void;

package/dist/Light/Wrappers/PointLightWrapper.d.ts

@@ -1,2 +1,2 @@
-import { TAbstractLightWrapper, TLightServiceDependencies, TPointLight, TPointLightParams } from '../Models';
+import { TAbstractLightWrapper, TLightServiceDependencies, TPointLight, TPointLightParams } from '@hellpig/anarchy-engine/Light/Models';
 export declare function PointLightWrapper(params: TPointLightParams, dependencies: TLightServiceDependencies): TAbstractLightWrapper<TPointLight>;

package/dist/Light/Wrappers/RectAreaLightWrapper.d.ts

@@ -1,2 +1,2 @@
-import { TAbstractLightWrapper, TLightServiceDependencies, TRectAreaLight, TRectAreaLightParams } from '../Models';
+import { TAbstractLightWrapper, TLightServiceDependencies, TRectAreaLight, TRectAreaLightParams } from '@hellpig/anarchy-engine/Light/Models';
 export declare function RectAreaLightWrapper(params: TRectAreaLightParams, dependencies: TLightServiceDependencies): TAbstractLightWrapper<TRectAreaLight>;

package/dist/Light/Wrappers/SpotLightWrapper.d.ts

@@ -1,2 +1,2 @@
-import { TAbstractLightWrapper, TLightServiceDependencies, TSpotLight, TSpotLightParams } from '../Models';
+import { TAbstractLightWrapper, TLightServiceDependencies, TSpotLight, TSpotLightParams } from '@hellpig/anarchy-engine/Light/Models';
 export declare function SpotLightWrapper(params: TSpotLightParams, dependencies: TLightServiceDependencies): TAbstractLightWrapper<TSpotLight>;

package/dist/LoadingManager/Factories/LoadingManagerFactory.d.ts

@@ -1,2 +1,2 @@
-import { TLoadingManagerFactory } from '../Models';
+import { TLoadingManagerFactory } from '@hellpig/anarchy-engine/LoadingManager/Models';
 export declare function LoadingManagerFactory(): TLoadingManagerFactory;

package/dist/LoadingManager/Models/TLoadingEvent.d.ts

@@ -1,4 +1,4 @@
-import { LoadingEventType } from '../Constants';
+import { LoadingEventType } from '@hellpig/anarchy-engine/LoadingManager/Constants';
 export type TLoadingEvent = Readonly<{
     type: LoadingEventType;
     url?: string;

package/dist/LoadingManager/Models/TLoadingManagerFactory.d.ts

@@ -1,4 +1,4 @@
-import { TReactiveFactory } from '../../Abstract';
+import { TReactiveFactory } from '@hellpig/anarchy-engine/Abstract';
 import { TLoadingManagerParams } from './TLoadingManagerParams';
 import { TLoadingManagerWrapper } from './TLoadingManagerWrapper';
 export type TLoadingManagerFactory = TReactiveFactory<TLoadingManagerWrapper, TLoadingManagerParams>;

package/dist/LoadingManager/Models/TLoadingManagerParams.d.ts

@@ -1,4 +1,4 @@
-import { TWithName, TWithTags } from '../../Mixins';
+import { TWithName, TWithTags } from '@hellpig/anarchy-engine/Mixins';
 export type TLoadingManagerParams = Readonly<{
     onLoad?: () => void;
     onProgress?: (url: string, loaded: number, total: number) => void;

package/dist/LoadingManager/Models/TLoadingManagerRegistry.d.ts

@@ -1,3 +1,3 @@
-import { TAbstractEntityRegistry } from '../../Abstract/Models';
+import { TAbstractEntityRegistry } from '@hellpig/anarchy-engine/Abstract/Models';
 import { TLoadingManagerWrapper } from './TLoadingManagerWrapper';
 export type TLoadingManagerRegistry = TAbstractEntityRegistry<TLoadingManagerWrapper>;

package/dist/LoadingManager/Models/TLoadingManagerService.d.ts

@@ -1,5 +1,5 @@
-import { TAbstractService } from '../../Abstract';
-import { TWithCreateService, TWithFactoryService, TWithRegistryService } from '../../Mixins';
+import { TAbstractService } from '@hellpig/anarchy-engine/Abstract';
+import { TWithCreateService, TWithFactoryService, TWithRegistryService } from '@hellpig/anarchy-engine/Mixins';
 import { TLoadingManagerFactory } from './TLoadingManagerFactory';
 import { TLoadingManagerParams } from './TLoadingManagerParams';
 import { TLoadingManagerRegistry } from './TLoadingManagerRegistry';

package/dist/LoadingManager/Models/TLoadingManagerWrapper.d.ts

@@ -1,6 +1,6 @@
-import { TAbstractWrapper } from '../../Abstract';
-import { TLoadingEvent } from '..';
-import { TDestroyable } from '../../Mixins';
+import { TAbstractWrapper } from '@hellpig/anarchy-engine/Abstract';
+import { TLoadingEvent } from '@hellpig/anarchy-engine/LoadingManager';
+import { TDestroyable } from '@hellpig/anarchy-engine/Mixins';
 import { BehaviorSubject } from 'rxjs';
 import { LoadingManager } from 'three';
 export type TLoadingManagerWrapper = TAbstractWrapper<LoadingManager> & Readonly<{

package/dist/LoadingManager/Registries/LoadingManagerRegistry.d.ts

@@ -1,2 +1,2 @@
-import { TLoadingManagerRegistry } from '../Models';
+import { TLoadingManagerRegistry } from '@hellpig/anarchy-engine/LoadingManager/Models';
 export declare function LoadingManagerRegistry(): TLoadingManagerRegistry;

package/dist/LoadingManager/Services/LoadingManagerService.d.ts

@@ -1,2 +1,2 @@
-import { TLoadingManagerFactory, TLoadingManagerRegistry, TLoadingManagerService } from '../Models';
+import { TLoadingManagerFactory, TLoadingManagerRegistry, TLoadingManagerService } from '@hellpig/anarchy-engine/LoadingManager/Models';
 export declare function LoadingManagerService(factory: TLoadingManagerFactory, registry: TLoadingManagerRegistry): TLoadingManagerService;

package/dist/LoadingManager/Wrappers/LoadingManagerWrapper.d.ts

@@ -1,2 +1,2 @@
-import { TLoadingManagerParams, TLoadingManagerWrapper } from '../Models';
+import { TLoadingManagerParams, TLoadingManagerWrapper } from '@hellpig/anarchy-engine/LoadingManager/Models';
 export declare function LoadingManagerWrapper(params: TLoadingManagerParams): TLoadingManagerWrapper;

package/dist/Loop/Constants/LoopsDefaultSettings.d.ts

@@ -1,4 +1,4 @@
-import { TLoopsSettings, TLoopsSettingsModes, TLoopsSettingsSteps } from '../Models';
+import { TLoopsSettings, TLoopsSettingsModes, TLoopsSettingsSteps } from '@hellpig/anarchy-engine/Loop/Models';
 export declare const LOOPS_DEFAULT_STEPS: TLoopsSettingsSteps;
 export declare const LOOPS_MODES: TLoopsSettingsModes;
 export declare const LOOPS_DEFAULT_SETTINGS: TLoopsSettings;

package/dist/Loop/Entities/DeltaCalculator.d.ts

@@ -1,2 +1,2 @@
-import { TDeltaCalculator } from '../Models';
+import { TDeltaCalculator } from '@hellpig/anarchy-engine/Loop/Models';
 export declare function DeltaCalculator(useClock?: boolean): TDeltaCalculator;

package/dist/Loop/Entities/Loop.d.ts

@@ -1,2 +1,2 @@
-import { TLoop, TLoopParams } from '../Models';
+import { TLoop, TLoopParams } from '@hellpig/anarchy-engine/Loop/Models';
 export declare function Loop({ name, type, trigger, maxPriority, isParallelMode }: TLoopParams): TLoop | never;

package/dist/Loop/Factories/LoopFactory.d.ts

@@ -1,2 +1,2 @@
-import { TLoopFactory } from '../Models';
+import { TLoopFactory } from '@hellpig/anarchy-engine/Loop/Models';
 export declare function LoopFactory(): TLoopFactory;

package/dist/Loop/Models/TDelta.d.ts

@@ -1,2 +1,2 @@
-import { TMilliseconds } from '../../Math/Types';
+import { TMilliseconds } from '@hellpig/anarchy-engine/Math/Types';
 export type TDelta = TMilliseconds;

package/dist/Loop/Models/TDeltaCalculator.d.ts

@@ -1,4 +1,4 @@
-import { TMilliseconds } from '../../Math';
+import { TMilliseconds } from '@hellpig/anarchy-engine/Math';
 import { Clock } from 'three';
 export type TDeltaCalculator = Readonly<{
     isPaused: boolean;

package/dist/Loop/Models/TLoop.d.ts

@@ -1,6 +1,6 @@
-import { TAbstractLoop } from '../../Abstract';
-import { LoopTrigger, LoopType, LoopUpdatePriority } from '../Constants';
-import { TDestroyable, TRegistrable, TWithName } from '../../Mixins';
+import { TAbstractLoop } from '@hellpig/anarchy-engine/Abstract';
+import { LoopTrigger, LoopType, LoopUpdatePriority } from '@hellpig/anarchy-engine/Loop/Constants';
+import { TDestroyable, TRegistrable, TWithName } from '@hellpig/anarchy-engine/Mixins';
 import { BehaviorSubject } from 'rxjs';
 import { TDelta } from './TDelta';
 import { TLoopTriggerFn } from './TLoopTriggerFn';

package/dist/Loop/Models/TLoopFactory.d.ts

@@ -1,4 +1,4 @@
-import { TReactiveFactory } from '../../Abstract';
+import { TReactiveFactory } from '@hellpig/anarchy-engine/Abstract';
 import { TLoop } from './TLoop';
 import { TLoopParams } from './TLoopParams';
 export type TLoopFactory = TReactiveFactory<TLoop, TLoopParams>;

package/dist/Loop/Models/TLoopParams.d.ts

@@ -1,4 +1,4 @@
-import { LoopType } from '../Constants';
+import { LoopType } from '@hellpig/anarchy-engine/Loop/Constants';
 import { TLoopTriggerFn } from './TLoopTriggerFn';
 export type TLoopParams = Readonly<{
     name: string;

package/dist/Loop/Models/TLoopRegistry.d.ts

@@ -1,3 +1,3 @@
-import { TAbstractEntityRegistry } from '../../Abstract';
+import { TAbstractEntityRegistry } from '@hellpig/anarchy-engine/Abstract';
 import { TLoop } from './TLoop';
 export type TLoopRegistry = TAbstractEntityRegistry<TLoop>;

package/dist/Loop/Models/TLoopService.d.ts

@@ -1,17 +1,17 @@
-import { TAbstractService } from '../../Abstract';
-import { TAudioLoop } from '../../Audio';
-import { TCollisionsLoop } from '../../Collisions';
-import { TControlsLoop } from '../../Controls';
-import { TIntersectionsLoop } from '../../Intersections';
-import { TKinematicLoop } from '../../Kinematic';
-import { LoopType } from '../Constants';
-import { TWithCreateService, TWithFactoryService, TWithRegistryService } from '../../Mixins';
-import { TMouseLoop } from '../../Mouse';
-import { TPhysicsLoop } from '../../Physics';
-import { TRenderLoop } from '../../Space';
-import { TSpatialLoop } from '../../Spatial';
-import { TTextLoop } from '../../Text';
-import { TTransformLoop } from '../../TransformDrive';
+import { TAbstractService } from '@hellpig/anarchy-engine/Abstract';
+import { TAudioLoop } from '@hellpig/anarchy-engine/Audio';
+import { TCollisionsLoop } from '@hellpig/anarchy-engine/Collisions';
+import { TControlsLoop } from '@hellpig/anarchy-engine/Controls';
+import { TIntersectionsLoop } from '@hellpig/anarchy-engine/Intersections';
+import { TKinematicLoop } from '@hellpig/anarchy-engine/Kinematic';
+import { LoopType } from '@hellpig/anarchy-engine/Loop/Constants';
+import { TWithCreateService, TWithFactoryService, TWithRegistryService } from '@hellpig/anarchy-engine/Mixins';
+import { TMouseLoop } from '@hellpig/anarchy-engine/Mouse';
+import { TPhysicsLoop } from '@hellpig/anarchy-engine/Physics';
+import { TRenderLoop } from '@hellpig/anarchy-engine/Space';
+import { TSpatialLoop } from '@hellpig/anarchy-engine/Spatial';
+import { TTextLoop } from '@hellpig/anarchy-engine/Text';
+import { TTransformLoop } from '@hellpig/anarchy-engine/TransformDrive';
 import { TLoop } from './TLoop';
 import { TLoopFactory } from './TLoopFactory';
 import { TLoopParams } from './TLoopParams';

package/dist/Loop/Models/TLoopWorkerRequestData.d.ts

@@ -1,4 +1,4 @@
-import { LoopWorkerActions } from '../Constants';
+import { LoopWorkerActions } from '@hellpig/anarchy-engine/Loop/Constants';
 export type TLoopWorkerStopRequestData = Readonly<{
     action: LoopWorkerActions;
 }>;

package/dist/Loop/Models/TLoopWorkerResponseData.d.ts

@@ -1,4 +1,4 @@
-import { TMilliseconds } from '../../Math';
+import { TMilliseconds } from '@hellpig/anarchy-engine/Math';
 export type TLoopWorkerResponseData = Readonly<{
     delta: TMilliseconds;
     loopId: string;

package/dist/Loop/Registries/LoopRegistry.d.ts

@@ -1,2 +1,2 @@
-import { TLoopRegistry } from '../Models';
+import { TLoopRegistry } from '@hellpig/anarchy-engine/Loop/Models';
 export declare function LoopRegistry(): TLoopRegistry;

package/dist/Loop/Services/LoopService.d.ts

@@ -1,2 +1,2 @@
-import { TLoopFactory, TLoopRegistry, TLoopService } from '../Models';
+import { TLoopFactory, TLoopRegistry, TLoopService } from '@hellpig/anarchy-engine/Loop/Models';
 export declare function LoopService(factory: TLoopFactory, registry: TLoopRegistry): TLoopService;

package/dist/Loop/Utils/LoopDebugUtils.d.ts

@@ -1,2 +1,2 @@
-import { TLoop } from '../Models';
+import { TLoop } from '@hellpig/anarchy-engine/Loop/Models';
 export declare function testTickRate(loop: TLoop, durationMs?: number): void;

package/dist/Loop/Utils/LoopUtils.d.ts

@@ -1,2 +1,2 @@
-import { LoopType } from '../Constants';
+import { LoopType } from '@hellpig/anarchy-engine/Loop/Constants';
 export declare const getMainLoopNameByType: (type: LoopType) => string;

package/dist/Material/Adapters/ConfigToParams.d.ts

@@ -1,2 +1,2 @@
-import { TMaterialConfig, TMaterialConfigToParamsDependencies, TMaterialParams } from '../Models';
+import { TMaterialConfig, TMaterialConfigToParamsDependencies, TMaterialParams } from '@hellpig/anarchy-engine/Material/Models';
 export declare function materialConfigToParams(config: TMaterialConfig, { textureService }: TMaterialConfigToParamsDependencies): TMaterialParams;

package/dist/Material/Adapters/EntityToConfig.d.ts

@@ -1,2 +1,2 @@
-import { TAnyMaterialWrapper, TMaterialConfig, TMaterialEntityToConfigDependencies } from '../Models';
+import { TAnyMaterialWrapper, TMaterialConfig, TMaterialEntityToConfigDependencies } from '@hellpig/anarchy-engine/Material/Models';
 export declare function materialEntityToConfig(entity: TAnyMaterialWrapper, { textureResourceRegistry }: TMaterialEntityToConfigDependencies): TMaterialConfig;

package/dist/Material/Constants/Material/MaterialMap.d.ts

@@ -1,3 +1,3 @@
-import { TTypeOfMaterials } from '../../Models';
+import { TTypeOfMaterials } from '@hellpig/anarchy-engine/Material/Models';
 import { MaterialType } from './MaterialType';
 export declare const MaterialMap: Readonly<Record<MaterialType, TTypeOfMaterials>>;

package/dist/Material/Factories/MaterialFactory.d.ts

@@ -1,2 +1,2 @@
-import { TMaterialFactory } from '../Models';
+import { TMaterialFactory } from '@hellpig/anarchy-engine/Material/Models';
 export declare function MaterialFactory(): TMaterialFactory;

package/dist/Material/Mixins/WithMaterial.d.ts

@@ -1,5 +1,5 @@
-import { TWithMaterial } from '../Models';
-import { TRawModel3d } from '../../Models3d';
-import { TWriteable } from '../../../../anarchy-shared/src/Utils';
-import { Points } from 'three/src/objects/Points';
+import { TWithMaterial } from '@hellpig/anarchy-engine/Material/Models';
+import { TRawModel3d } from '@hellpig/anarchy-engine/Models3d';
+import { TWriteable } from '@hellpig/anarchy-shared/Utils';
+import { Points } from 'three';
 export declare function withMaterial<T extends TWriteable<TRawModel3d | Points>>(entity: T): TWithMaterial;

package/dist/Material/Mixins/WithMaterial.js.map

@@ -1 +1 @@
-{"version":3,"file":"WithMaterial.js","sources":["../../../src/Material/Mixins/WithMaterial.ts"],"sourcesContent":["import type { TWithMaterial } from '@hellpig/anarchy-engine/Material/Models';\nimport type { TRawModel3d } from '@hellpig/anarchy-engine/Models3d';\nimport type { TWriteable } from '@hellpig/anarchy-shared/Utils';\nimport { isDefined } from '@hellpig/anarchy-shared/Utils';\nimport type { Group, Material, Mesh, Object3D } from 'three';\nimport type { Points } from 'three/src/objects/Points';\n\nexport function withMaterial<T extends TWriteable<TRawModel3d | Points>>(entity: T): TWithMaterial {\n  function useMaterial(material: Material): Material {\n    if ((entity as Group).isGroup) {\n      entity.traverse((object) => hasMaterial(object) && applyMaterial(object, material));\n    } else if (hasMaterial(entity)) applyMaterial(entity, material);\n    return material;\n  }\n\n  return {\n    useMaterial\n  };\n}\n\nconst hasMaterial = (entity: Mesh | Group | Points | Object3D): boolean => isDefined((entity as Mesh).material);\n// eslint-disable-next-line functional/immutable-data\nconst applyMaterial = (entity: Mesh | Group | Points | Object3D, material: Material): void => void ((entity as Mesh).material = material);\n"],"names":["withMaterial","entity","useMaterial","material","isGroup","traverse","object","hasMaterial","applyMaterial","isDefined"],"mappings":"6EAOO,SAASA,aAAyDC,QAQvE,MAAO,CACLC,YARF,SAAqBC,UAInB,OAHKF,OAAiBG,QACpBH,OAAOI,SAAUC,QAAWC,YAAYD,SAAWE,cAAcF,OAAQH,WAChEI,YAAYN,SAASO,cAAcP,OAAQE,UAC/CA,QACT,EAKF,CAEA,MAAMI,YAAeN,QAAsDQ,UAAWR,OAAgBE,UAEhGK,cAAgB,CAACP,OAA0CE,YAAoCF,OAAgBE,SAAWA"}
+{"version":3,"file":"WithMaterial.js","sources":["../../../src/Material/Mixins/WithMaterial.ts"],"sourcesContent":["import type { TWithMaterial } from '@hellpig/anarchy-engine/Material/Models';\nimport type { TRawModel3d } from '@hellpig/anarchy-engine/Models3d';\nimport type { TWriteable } from '@hellpig/anarchy-shared/Utils';\nimport { isDefined } from '@hellpig/anarchy-shared/Utils';\nimport type { Group, Material, Mesh, Object3D, Points } from 'three';\n\nexport function withMaterial<T extends TWriteable<TRawModel3d | Points>>(entity: T): TWithMaterial {\n  function useMaterial(material: Material): Material {\n    if ((entity as Group).isGroup) {\n      entity.traverse((object) => hasMaterial(object) && applyMaterial(object, material));\n    } else if (hasMaterial(entity)) applyMaterial(entity, material);\n    return material;\n  }\n\n  return {\n    useMaterial\n  };\n}\n\nconst hasMaterial = (entity: Mesh | Group | Points | Object3D): boolean => isDefined((entity as Mesh).material);\n// eslint-disable-next-line functional/immutable-data\nconst applyMaterial = (entity: Mesh | Group | Points | Object3D, material: Material): void => void ((entity as Mesh).material = material);\n"],"names":["withMaterial","entity","useMaterial","material","isGroup","traverse","object","hasMaterial","applyMaterial","isDefined"],"mappings":"6EAMO,SAASA,aAAyDC,QAQvE,MAAO,CACLC,YARF,SAAqBC,UAInB,OAHKF,OAAiBG,QACpBH,OAAOI,SAAUC,QAAWC,YAAYD,SAAWE,cAAcF,OAAQH,WAChEI,YAAYN,SAASO,cAAcP,OAAQE,UAC/CA,QACT,EAKF,CAEA,MAAMI,YAAeN,QAAsDQ,UAAWR,OAAgBE,UAEhGK,cAAgB,CAACP,OAA0CE,YAAoCF,OAAgBE,SAAWA"}

package/dist/Material/Models/TAnyMaterialWrapper.d.ts

@@ -1,4 +1,4 @@
-import { TWrapper } from '../../Abstract';
+import { TWrapper } from '@hellpig/anarchy-engine/Abstract';
 import { LineBasicMaterial, LineDashedMaterial, MeshBasicMaterial, MeshDepthMaterial, MeshDistanceMaterial, MeshLambertMaterial, MeshMatcapMaterial, MeshNormalMaterial, MeshPhongMaterial, MeshPhysicalMaterial, MeshStandardMaterial, MeshToonMaterial, PointsMaterial, RawShaderMaterial, ShaderMaterial, ShadowMaterial, SpriteMaterial } from 'three';
 import { TMaterialConfig } from './TMaterialConfig';
 import { TMaterialEntityToConfigDependencies } from './TMaterialEntityToConfigDependencies';

package/dist/Material/Models/TMaterialConfigOptions.d.ts

@@ -1,5 +1,5 @@
-import { BlendEquationName, BlendingDstFactorName, BlendingName, BlendingSrcFactorName, CombineName, DepthPackingStrategiesName, NormalMapTypesName, SideName, StencilFailName, StencilFuncName, StencilOpName } from '../Constants';
-import { TEulerLike } from '../../ThreeLib';
+import { BlendEquationName, BlendingDstFactorName, BlendingName, BlendingSrcFactorName, CombineName, DepthPackingStrategiesName, NormalMapTypesName, SideName, StencilFailName, StencilFuncName, StencilOpName } from '@hellpig/anarchy-engine/Material/Constants';
+import { TEulerLike } from '@hellpig/anarchy-engine/ThreeLib';
 import { Vector2Like } from 'three';
 import { TBasicMaterialParamsOptions, TDepthMaterialParamsOptions, TDistanceMaterialParamsOptions, TLambertMaterialParamsOptions, TLineBasicMaterialParamsOptions, TLineDashedMaterialParamsOptions, TMatcapMaterialParamsOptions, TNormalMaterialParamsOptions, TPhongMaterialParamsOptions, TPhysicalMaterialParamsOptions, TPointsMaterialParamsOptions, TShaderMaterialParamsOptions, TShadowMaterialParamsOptions, TSpriteMaterialParamsOptions, TStandardMaterialParamsOptions, TToonMaterialParamsOptions } from './TMaterialParamsOptions';
 type TOmitParamsOnlyFields<T> = Omit<T, 'blendDst' | 'blendEquation' | 'blendSrc' | 'blending' | 'clearcoatNormalScale' | 'clippingPlanes' | 'combine' | 'depthPacking' | 'envMapRotation' | 'matcap' | 'normalMapType' | 'normalScale' | 'side' | 'stencilFail' | 'stencilFunc' | 'stencilZFail' | 'stencilZPass' | 'uniformsGroups' | 'alphaMap' | 'anisotropyMap' | 'aoMap' | 'bumpMap' | 'clearcoatMap' | 'clearcoatNormalMap' | 'clearcoatRoughnessMap' | 'displacementMap' | 'emissiveMap' | 'envMap' | 'gradientMap' | 'iridescenceMap' | 'iridescenceThicknessMap' | 'lightMap' | 'map' | 'metalnessMap' | 'normalMap' | 'roughnessMap' | 'sheenColorMap' | 'sheenRoughnessMap' | 'specularColorMap' | 'specularIntensityMap' | 'specularMap' | 'thicknessMap' | 'transmissionMap'>;

package/dist/Material/Models/TMaterialConfigToParamsDependencies.d.ts

@@ -1,4 +1,4 @@
-import { TTextureService } from '../../Texture';
+import { TTextureService } from '@hellpig/anarchy-engine/Texture';
 export type TMaterialConfigToParamsDependencies = Readonly<{
     textureService: TTextureService;
 }>;

package/dist/Material/Models/TMaterialEntityToConfigDependencies.d.ts

@@ -1,4 +1,4 @@
-import { TTextureAsyncRegistry } from '../../Texture';
+import { TTextureAsyncRegistry } from '@hellpig/anarchy-engine/Texture';
 export type TMaterialEntityToConfigDependencies = Readonly<{
     textureResourceRegistry: TTextureAsyncRegistry;
 }>;

package/dist/Material/Models/TMaterialFactory.d.ts

@@ -1,4 +1,4 @@
-import { TParamsFromConfigWithDependencies, TReactiveFactory } from '../../Abstract';
+import { TParamsFromConfigWithDependencies, TReactiveFactory } from '@hellpig/anarchy-engine/Abstract';
 import { TAnyMaterialWrapper } from './TAnyMaterialWrapper';
 import { TMaterialConfig } from './TMaterialConfig';
 import { TMaterialConfigToParamsDependencies } from './TMaterialConfigToParamsDependencies';

package/dist/Material/Models/TMaterialParams.d.ts

@@ -1,4 +1,4 @@
-import { TWithName, TWithTags } from '../../Mixins';
+import { TWithName, TWithTags } from '@hellpig/anarchy-engine/Mixins';
 import { TMaterialParamsOptions } from './TMaterialParamsOptions';
 import { TMaterialParamsTextures } from './TMaterialParamsTextures';
 import { TWithMaterialType } from './TWithMaterialType';

package/dist/Material/Models/TMaterialParamsOptions.d.ts

@@ -1,7 +1,4 @@
-import { LineBasicMaterialParameters, LineDashedMaterialParameters, MeshBasicMaterialParameters, MeshDepthMaterialParameters, MeshDistanceMaterialParameters, MeshLambertMaterialParameters, MeshMatcapMaterialParameters, MeshNormalMaterialParameters, MeshPhysicalMaterialParameters, MeshStandardMaterialParameters, MeshToonMaterialParameters, ShaderMaterialParameters, ShadowMaterialParameters, SpriteMaterialParameters } from 'three';
-import { MaterialParameters } from 'three/src/materials/Material';
-import { MeshPhongMaterialParameters } from 'three/src/materials/MeshPhongMaterial';
-import { PointsMaterialParameters } from 'three/src/materials/PointsMaterial';
+import { LineBasicMaterialParameters, LineDashedMaterialParameters, MaterialParameters, MeshBasicMaterialParameters, MeshDepthMaterialParameters, MeshDistanceMaterialParameters, MeshLambertMaterialParameters, MeshMatcapMaterialParameters, MeshNormalMaterialParameters, MeshPhongMaterialParameters, MeshPhysicalMaterialParameters, MeshStandardMaterialParameters, MeshToonMaterialParameters, PointsMaterialParameters, ShaderMaterialParameters, ShadowMaterialParameters, SpriteMaterialParameters } from 'three';
 export type TOmitNonMaterialOptionsFields<T extends MaterialParameters> = Omit<T, 'allowOverride' | 'defines' | 'id' | 'isMaterial' | 'name' | 'type' | 'userData' | 'uuid' | 'version'>;
 export type TBasicMaterialParamsOptions = TOmitNonMaterialOptionsFields<MeshBasicMaterialParameters>;
 export type TDepthMaterialParamsOptions = TOmitNonMaterialOptionsFields<MeshDepthMaterialParameters>;

package/dist/Material/Models/TMaterialParamsTextures.d.ts

@@ -1,4 +1,4 @@
-import { TTexture } from '../../Texture';
+import { TTexture } from '@hellpig/anarchy-engine/Texture';
 import { TBasicMaterialTextureKeys, TDepthMaterialTextureKeys, TDistanceMaterialTextureKeys, TLambertMaterialTextureKeys, TMatcapMaterialTextureKeys, TNormalMaterialTextureKeys, TPhongMaterialTextureKeys, TPhysicalMaterialTextureKeys, TPointsMaterialTextureKeys, TStandardMaterialTextureKeys, TToonMaterialTextureKeys } from './TMaterialTextureKeys';
 export type TBasicMaterialParamsTextures = Readonly<{
     [key in TBasicMaterialTextureKeys]?: TTexture;

package/dist/Material/Models/TMaterialRegistry.d.ts

@@ -1,3 +1,3 @@
-import { TAbstractEntityRegistry } from '../../Abstract';
+import { TAbstractEntityRegistry } from '@hellpig/anarchy-engine/Abstract';
 import { TAnyMaterialWrapper } from './TAnyMaterialWrapper';
 export type TMaterialRegistry = TAbstractEntityRegistry<TAnyMaterialWrapper>;

package/dist/Material/Models/TMaterialService.d.ts

@@ -1,5 +1,5 @@
-import { TSerializableEntitiesService } from '../../Abstract';
-import { TWithCreateFromConfigService, TWithCreateService, TWithFactoryService, TWithRegistryService } from '../../Mixins';
+import { TSerializableEntitiesService } from '@hellpig/anarchy-engine/Abstract';
+import { TWithCreateFromConfigService, TWithCreateService, TWithFactoryService, TWithRegistryService } from '@hellpig/anarchy-engine/Mixins';
 import { TAnyMaterialWrapper } from './TAnyMaterialWrapper';
 import { TMaterialConfig } from './TMaterialConfig';
 import { TMaterialFactory } from './TMaterialFactory';

package/dist/Material/Models/TMaterialServiceDependencies.d.ts

@@ -1,4 +1,4 @@
-import { TTextureService } from '../../Texture';
+import { TTextureService } from '@hellpig/anarchy-engine/Texture';
 export type TMaterialServiceDependencies = Readonly<{
     textureService: TTextureService;
 }>;

package/dist/Material/Models/TWithMaterialType.d.ts

@@ -1,4 +1,4 @@
-import { MaterialType } from '../Constants';
+import { MaterialType } from '@hellpig/anarchy-engine/Material/Constants';
 export type TWithMaterialType = Readonly<{
     type: MaterialType;
 }>;

package/dist/Material/Registries/MaterialRegistry.d.ts

@@ -1,2 +1,2 @@
-import { TMaterialRegistry } from '../Models';
+import { TMaterialRegistry } from '@hellpig/anarchy-engine/Material/Models';
 export declare function MaterialRegistry(): TMaterialRegistry;

package/dist/Material/Services/MaterialService.d.ts

@@ -1,2 +1,2 @@
-import { TMaterialFactory, TMaterialRegistry, TMaterialService, TMaterialServiceDependencies } from '../Models';
+import { TMaterialFactory, TMaterialRegistry, TMaterialService, TMaterialServiceDependencies } from '@hellpig/anarchy-engine/Material/Models';
 export declare function MaterialService(factory: TMaterialFactory, registry: TMaterialRegistry, dependencies: TMaterialServiceDependencies): TMaterialService;

package/dist/Material/Utils/MaterialUtils.d.ts

@@ -1,5 +1,5 @@
-import { TMaterialParams, TMaterials } from '../Models';
-import { TEulerLike, TEulerString } from '../../ThreeLib';
+import { TMaterialParams, TMaterials } from '@hellpig/anarchy-engine/Material/Models';
+import { TEulerLike, TEulerString } from '@hellpig/anarchy-engine/ThreeLib';
 import { LineDashedMaterial, Material, MeshBasicMaterial, MeshDepthMaterial, MeshLambertMaterial, MeshMatcapMaterial, MeshPhongMaterial, MeshPhysicalMaterial, MeshStandardMaterial, PointsMaterial, SpriteMaterial, Vector2Like, Vector3Like } from 'three';
 export declare function isPointsMaterial<T extends Material | ReadonlyArray<Material>>(material: PointsMaterial | T): material is PointsMaterial;
 export declare function isPhysicalMaterial<T extends Material | ReadonlyArray<Material>>(material: MeshPhysicalMaterial | T): material is MeshPhysicalMaterial;

package/dist/Material/Wrappers/MaterialWrapper.d.ts

@@ -1,2 +1,2 @@
-import { TAnyMaterialWrapper, TMaterialParams } from '../Models';
+import { TAnyMaterialWrapper, TMaterialParams } from '@hellpig/anarchy-engine/Material/Models';
 export declare function MaterialWrapper(params: TMaterialParams): TAnyMaterialWrapper;

package/dist/Math/Utils/AnglesUtils.d.ts

@@ -1,6 +1,6 @@
-import { ForwardAxis } from '../../Kinematic/Constants';
-import { TDegrees, TMetersPerSecond, TRadians, TRadiansPerSecond } from '../Types';
-import { TEulerLike } from '../../ThreeLib';
+import { ForwardAxis } from '@hellpig/anarchy-engine/Kinematic/Constants';
+import { TDegrees, TMetersPerSecond, TRadians, TRadiansPerSecond } from '@hellpig/anarchy-engine/Math/Types';
+import { TEulerLike } from '@hellpig/anarchy-engine/ThreeLib';
 import { EulerOrder, QuaternionLike, Vector3Like, Euler, Quaternion, Vector3 } from 'three';
 export declare function getHorizontalAzimuth(x: number, z: number, point: Vector3Like, forwardAxis: ForwardAxis): TRadians;
 export declare function getElevation(x: number, y: number, z: number, point: Vector3Like): TRadians;

package/dist/Math/Utils/AnglesUtils.js

@@ -1,2 +1,2 @@
-import{isQuaternionLike,isEulerLike}from"../../Utils/CheckUtils.js";import{Vector3,Euler,Quaternion}from"three";import{euclideanModulo,degToRad,radToDeg}from"three/src/math/MathUtils";import{ForwardAxis}from"../../Kinematic/Constants/ForwardAxis.js";import{radiansPerSecond,metersPerSecond}from"../../Distance/Utils/DistanceUtils.js";function getHorizontalAzimuth(x,z,point,forwardAxis){let azimuthRad=Math.atan2(point.z-z,point.x-x);return forwardAxis.toLocaleLowerCase()==="Z".toLocaleLowerCase()&&(azimuthRad=-azimuthRad+Math.PI/2),azimuthRad=euclideanModulo(azimuthRad,2*Math.PI),azimuthRad}function getElevation(x,y,z,point){const dy=point.y-y,horizontalDistance=Math.sqrt((point.x-x)**2+(point.z-z)**2);return Math.atan2(dy,horizontalDistance)}function getAzimuthElevationFromQuaternion(q){const{x:x,y:y,z:z,w:w}=q;return{azimuth:Math.atan2(2*(w*z+x*y),1-2*(y*y+z*z)),elevation:Math.asin(2*(w*y-z*x))}}function getAzimuthElevationFromVector(v,forwardAxis){let azimuth;azimuth=forwardAxis===ForwardAxis.Z?Math.atan2(v.x,v.z):Math.atan2(v.z,v.x);const elevation=Math.atan2(v.y,Math.sqrt(v.x*v.x+v.z*v.z));return{azimuth:euclideanModulo(azimuth,2*Math.PI),elevation:elevation}}const getAzimuthFromDirection=direction=>{let azimuth=Math.atan2(direction.z,direction.x);return azimuth<0&&(azimuth+=2*Math.PI),azimuth},getAzimuthFromQuaternionDirection=quaternion=>{const{x:x,y:y,z:z,w:w}=quaternion;let azimuth=Math.atan2(2*(w*y+z*x),1-2*(x*x+y*y));return azimuth<0&&(azimuth+=2*Math.PI),azimuth},getElevationFromDirection=direction=>Math.atan2(direction.y,Math.sqrt(direction.x**2+direction.z**2)),getElevationFromQuaternionDirection=quaternion=>{const{x:x,y:y,z:z,w:w}=quaternion;return Math.asin(2*(w*x-y*z))},getDirectionFromLinearVelocity=linearVelocity=>linearVelocity.clone().normalize(),getSpeedFromLinearVelocity=linearVelocity=>metersPerSecond(linearVelocity.length()),getLinearVelocityByDeg=(speed,azimuth,elevation)=>{const azimuthRad=degToRad(azimuth),elevationRad=degToRad(elevation);return new Vector3(speed*Math.cos(elevationRad)*Math.cos(azimuthRad),speed*Math.sin(elevationRad),speed*Math.cos(elevationRad)*Math.sin(azimuthRad))},getLinearVelocity=(speed,azimuth,elevation)=>new Vector3(speed*Math.cos(elevation)*Math.cos(azimuth),speed*Math.sin(elevation),speed*Math.cos(elevation)*Math.sin(azimuth)),getSpeedFromAngularVelocity=angularVelocity=>radiansPerSecond(angularVelocity.length()),getDirectionFromAngularVelocity=angularVelocity=>angularVelocity.clone().normalize();function get3DAzimuth(center,point){const dx=point.x-center.x,dy=point.y-center.y,dz=point.z-center.z;let azimuth=Math.atan2(dz,dx);azimuth<0&&(azimuth+=2*Math.PI);const horizontalDistance=Math.sqrt(dx*dx+dz*dz);return{azimuth:azimuth,elevation:Math.atan2(dy,horizontalDistance)}}function degreesToEuler(degrees){const radians={x:degToRad(degrees.x),y:degToRad(degrees.y),z:degToRad(degrees.z)};return new Vector3(radians.x,radians.y,radians.z)}function degreesToQuaternion(degrees){const radians={x:degToRad(degrees.x),y:degToRad(degrees.y),z:degToRad(degrees.z)},euler=new Euler(radians.x,radians.y,radians.z);return(new Quaternion).setFromEuler(euler)}function quaternionToDegrees(quaternion){const q=new Quaternion(quaternion.x,quaternion.y,quaternion.z,quaternion.w),euler=(new Euler).setFromQuaternion(q,"XYZ");return new Vector3(radToDeg(euler.x),radToDeg(euler.y),radToDeg(euler.z))}function applyRotationOffsetWithReorder(target,source,offset,order="XYZ"){source.reorder(order),target.set(source.x+offset.x,source.y+offset.y,source.z+offset.z,order),target.set(euclideanModulo(target.x+Math.PI,2*Math.PI)-Math.PI,euclideanModulo(target.y+Math.PI,2*Math.PI)-Math.PI,euclideanModulo(target.z+Math.PI,2*Math.PI)-Math.PI)}function toQuaternion(quaternionOrEuler){if(isQuaternionLike(quaternionOrEuler))return new Quaternion(quaternionOrEuler.x,quaternionOrEuler.y,quaternionOrEuler.z,quaternionOrEuler.w);if(isEulerLike(quaternionOrEuler))return(new Quaternion).setFromEuler(new Euler(quaternionOrEuler.x,quaternionOrEuler.y,quaternionOrEuler.z));throw new Error("Entity must be Quaternion or Euler, but it is something else")}export{applyRotationOffsetWithReorder,degreesToEuler,degreesToQuaternion,get3DAzimuth,getAzimuthElevationFromQuaternion,getAzimuthElevationFromVector,getAzimuthFromDirection,getAzimuthFromQuaternionDirection,getDirectionFromAngularVelocity,getDirectionFromLinearVelocity,getElevation,getElevationFromDirection,getElevationFromQuaternionDirection,getHorizontalAzimuth,getLinearVelocity,getLinearVelocityByDeg,getSpeedFromAngularVelocity,getSpeedFromLinearVelocity,quaternionToDegrees,toQuaternion};
+import{isQuaternionLike,isEulerLike}from"../../Utils/CheckUtils.js";import{Vector3,Euler,Quaternion,MathUtils}from"three";import{ForwardAxis}from"../../Kinematic/Constants/ForwardAxis.js";import{radiansPerSecond,metersPerSecond}from"../../Distance/Utils/DistanceUtils.js";const{degToRad:degToRad,euclideanModulo:euclideanModulo,radToDeg:radToDeg}=MathUtils;function getHorizontalAzimuth(x,z,point,forwardAxis){let azimuthRad=Math.atan2(point.z-z,point.x-x);return forwardAxis.toLocaleLowerCase()==="Z".toLocaleLowerCase()&&(azimuthRad=-azimuthRad+Math.PI/2),azimuthRad=euclideanModulo(azimuthRad,2*Math.PI),azimuthRad}function getElevation(x,y,z,point){const dy=point.y-y,horizontalDistance=Math.sqrt((point.x-x)**2+(point.z-z)**2);return Math.atan2(dy,horizontalDistance)}function getAzimuthElevationFromQuaternion(q){const{x:x,y:y,z:z,w:w}=q;return{azimuth:Math.atan2(2*(w*z+x*y),1-2*(y*y+z*z)),elevation:Math.asin(2*(w*y-z*x))}}function getAzimuthElevationFromVector(v,forwardAxis){let azimuth;azimuth=forwardAxis===ForwardAxis.Z?Math.atan2(v.x,v.z):Math.atan2(v.z,v.x);const elevation=Math.atan2(v.y,Math.sqrt(v.x*v.x+v.z*v.z));return{azimuth:euclideanModulo(azimuth,2*Math.PI),elevation:elevation}}const getAzimuthFromDirection=direction=>{let azimuth=Math.atan2(direction.z,direction.x);return azimuth<0&&(azimuth+=2*Math.PI),azimuth},getAzimuthFromQuaternionDirection=quaternion=>{const{x:x,y:y,z:z,w:w}=quaternion;let azimuth=Math.atan2(2*(w*y+z*x),1-2*(x*x+y*y));return azimuth<0&&(azimuth+=2*Math.PI),azimuth},getElevationFromDirection=direction=>Math.atan2(direction.y,Math.sqrt(direction.x**2+direction.z**2)),getElevationFromQuaternionDirection=quaternion=>{const{x:x,y:y,z:z,w:w}=quaternion;return Math.asin(2*(w*x-y*z))},getDirectionFromLinearVelocity=linearVelocity=>linearVelocity.clone().normalize(),getSpeedFromLinearVelocity=linearVelocity=>metersPerSecond(linearVelocity.length()),getLinearVelocityByDeg=(speed,azimuth,elevation)=>{const azimuthRad=degToRad(azimuth),elevationRad=degToRad(elevation);return new Vector3(speed*Math.cos(elevationRad)*Math.cos(azimuthRad),speed*Math.sin(elevationRad),speed*Math.cos(elevationRad)*Math.sin(azimuthRad))},getLinearVelocity=(speed,azimuth,elevation)=>new Vector3(speed*Math.cos(elevation)*Math.cos(azimuth),speed*Math.sin(elevation),speed*Math.cos(elevation)*Math.sin(azimuth)),getSpeedFromAngularVelocity=angularVelocity=>radiansPerSecond(angularVelocity.length()),getDirectionFromAngularVelocity=angularVelocity=>angularVelocity.clone().normalize();function get3DAzimuth(center,point){const dx=point.x-center.x,dy=point.y-center.y,dz=point.z-center.z;let azimuth=Math.atan2(dz,dx);azimuth<0&&(azimuth+=2*Math.PI);const horizontalDistance=Math.sqrt(dx*dx+dz*dz);return{azimuth:azimuth,elevation:Math.atan2(dy,horizontalDistance)}}function degreesToEuler(degrees){const radians={x:degToRad(degrees.x),y:degToRad(degrees.y),z:degToRad(degrees.z)};return new Vector3(radians.x,radians.y,radians.z)}function degreesToQuaternion(degrees){const radians={x:degToRad(degrees.x),y:degToRad(degrees.y),z:degToRad(degrees.z)},euler=new Euler(radians.x,radians.y,radians.z);return(new Quaternion).setFromEuler(euler)}function quaternionToDegrees(quaternion){const q=new Quaternion(quaternion.x,quaternion.y,quaternion.z,quaternion.w),euler=(new Euler).setFromQuaternion(q,"XYZ");return new Vector3(radToDeg(euler.x),radToDeg(euler.y),radToDeg(euler.z))}function applyRotationOffsetWithReorder(target,source,offset,order="XYZ"){source.reorder(order),target.set(source.x+offset.x,source.y+offset.y,source.z+offset.z,order),target.set(euclideanModulo(target.x+Math.PI,2*Math.PI)-Math.PI,euclideanModulo(target.y+Math.PI,2*Math.PI)-Math.PI,euclideanModulo(target.z+Math.PI,2*Math.PI)-Math.PI)}function toQuaternion(quaternionOrEuler){if(isQuaternionLike(quaternionOrEuler))return new Quaternion(quaternionOrEuler.x,quaternionOrEuler.y,quaternionOrEuler.z,quaternionOrEuler.w);if(isEulerLike(quaternionOrEuler))return(new Quaternion).setFromEuler(new Euler(quaternionOrEuler.x,quaternionOrEuler.y,quaternionOrEuler.z));throw new Error("Entity must be Quaternion or Euler, but it is something else")}export{applyRotationOffsetWithReorder,degreesToEuler,degreesToQuaternion,get3DAzimuth,getAzimuthElevationFromQuaternion,getAzimuthElevationFromVector,getAzimuthFromDirection,getAzimuthFromQuaternionDirection,getDirectionFromAngularVelocity,getDirectionFromLinearVelocity,getElevation,getElevationFromDirection,getElevationFromQuaternionDirection,getHorizontalAzimuth,getLinearVelocity,getLinearVelocityByDeg,getSpeedFromAngularVelocity,getSpeedFromLinearVelocity,quaternionToDegrees,toQuaternion};
 //# sourceMappingURL=AnglesUtils.js.map

package/dist/Math/Utils/AnglesUtils.js.map

@@ -1 +1 @@
-{"version":3,"file":"AnglesUtils.js","sources":["../../../src/Math/Utils/AnglesUtils.ts"],"sourcesContent":["import { metersPerSecond, radiansPerSecond } from '@hellpig/anarchy-engine/Distance';\nimport { ForwardAxis } from '@hellpig/anarchy-engine/Kinematic/Constants';\nimport type { TDegrees, TMetersPerSecond, TRadians, TRadiansPerSecond } from '@hellpig/anarchy-engine/Math/Types';\nimport type { TEulerLike } from '@hellpig/anarchy-engine/ThreeLib';\nimport { isEulerLike, isQuaternionLike } from '@hellpig/anarchy-engine/Utils/CheckUtils';\nimport type { EulerOrder, QuaternionLike, Vector3Like } from 'three';\nimport { Euler, Quaternion, Vector3 } from 'three';\nimport { degToRad, euclideanModulo, radToDeg } from 'three/src/math/MathUtils';\n\nexport function getHorizontalAzimuth(x: number, z: number, point: Vector3Like, forwardAxis: ForwardAxis): TRadians {\n  const dx: number = point.x - x;\n  const dz: number = point.z - z;\n\n  let azimuthRad: number = Math.atan2(dz, dx);\n  if (forwardAxis.toLocaleLowerCase() === 'Z'.toLocaleLowerCase()) azimuthRad = -azimuthRad + Math.PI / 2;\n  azimuthRad = euclideanModulo(azimuthRad, Math.PI * 2);\n\n  return azimuthRad as TRadians;\n}\n\n// TODO add unit tests\nexport function getElevation(x: number, y: number, z: number, point: Vector3Like): TRadians {\n  const dx: number = point.x - x;\n  const dy: number = point.y - y;\n  const dz: number = point.z - z;\n\n  const horizontalDistance: number = Math.sqrt(dx ** 2 + dz ** 2);\n\n  return Math.atan2(dy, horizontalDistance) as TRadians;\n}\n\n// TODO add unit tests\nexport function getAzimuthElevationFromQuaternion(q: Quaternion): { azimuth: TRadians; elevation: TRadians } {\n  const { x, y, z, w } = q;\n\n  const azimuth: TRadians = Math.atan2(2 * (w * z + x * y), 1 - 2 * (y * y + z * z)) as TRadians;\n  const elevation: TRadians = Math.asin(2 * (w * y - z * x)) as TRadians;\n\n  return { azimuth, elevation };\n}\n\nexport function getAzimuthElevationFromVector(v: Vector3Like, forwardAxis: ForwardAxis): { azimuth: TRadians; elevation: TRadians } {\n  let azimuth: TRadians;\n\n  if (forwardAxis === ForwardAxis.Z) {\n    azimuth = Math.atan2(v.x, v.z) as TRadians;\n  } else {\n    azimuth = Math.atan2(v.z, v.x) as TRadians;\n  }\n\n  const elevation: TRadians = Math.atan2(v.y, Math.sqrt(v.x * v.x + v.z * v.z)) as TRadians;\n\n  return { azimuth: euclideanModulo(azimuth, Math.PI * 2) as TRadians, elevation };\n}\n\n// TODO add unit tests\nexport const getAzimuthFromDirection = (direction: Vector3Like): TRadians => {\n  let azimuth: TRadians = Math.atan2(direction.z, direction.x) as TRadians;\n  if (azimuth < 0) (azimuth as number) += 2 * Math.PI;\n  return azimuth;\n};\n\n// TODO add unit tests\nexport const getAzimuthFromQuaternionDirection = (quaternion: QuaternionLike): TRadians => {\n  const { x, y, z, w } = quaternion;\n\n  // Calculate azimuth using the quaternion components\n  const sinY: number = 2 * (w * y + z * x);\n  const cosY: number = 1 - 2 * (x * x + y * y);\n\n  let azimuth: TRadians = Math.atan2(sinY, cosY) as TRadians;\n\n  // Normalize azimuth to range [0, 2π]\n  if (azimuth < 0) (azimuth as number) += 2 * Math.PI;\n\n  return azimuth;\n};\n\n// TODO add unit tests\nexport const getElevationFromDirection = (direction: Vector3Like): TRadians => Math.atan2(direction.y, Math.sqrt(direction.x ** 2 + direction.z ** 2)) as TRadians;\n// TODO add unit tests\nexport const getElevationFromQuaternionDirection = (quaternion: QuaternionLike): TRadians => {\n  const { x, y, z, w } = quaternion;\n  return Math.asin(2 * (w * x - y * z)) as TRadians;\n};\n\n// TODO add unit tests\nexport const getDirectionFromLinearVelocity = (linearVelocity: Vector3): Vector3 => linearVelocity.clone().normalize();\n// TODO add unit tests\nexport const getSpeedFromLinearVelocity = (linearVelocity: Vector3): TMetersPerSecond => metersPerSecond(linearVelocity.length());\n// TODO add unit tests\nexport const getLinearVelocityByDeg = (speed: TMetersPerSecond, azimuth: TDegrees, elevation: TDegrees): Vector3 => {\n  const azimuthRad: TRadians = degToRad(azimuth) as TRadians;\n  const elevationRad: TRadians = degToRad(elevation) as TRadians;\n  return new Vector3(speed * Math.cos(elevationRad) * Math.cos(azimuthRad), speed * Math.sin(elevationRad), speed * Math.cos(elevationRad) * Math.sin(azimuthRad));\n};\n\n// TODO add unit tests\nexport const getLinearVelocity = (speed: TMetersPerSecond, azimuth: TRadians, elevation: TRadians): Vector3 =>\n  new Vector3(speed * Math.cos(elevation) * Math.cos(azimuth), speed * Math.sin(elevation), speed * Math.cos(elevation) * Math.sin(azimuth));\n\n// TODO add unit tests\nexport const getSpeedFromAngularVelocity = (angularVelocity: Quaternion): TRadiansPerSecond => radiansPerSecond(angularVelocity.length());\n\n// TODO add unit tests\nexport const getDirectionFromAngularVelocity = (angularVelocity: Quaternion): Quaternion => angularVelocity.clone().normalize();\n\n// TODO add unit tests\nexport function get3DAzimuth(center: Vector3Like, point: Vector3Like): { azimuth: TRadians; elevation: TRadians } {\n  const dx: number = point.x - center.x;\n  const dy: number = point.y - center.y;\n  const dz: number = point.z - center.z;\n\n  let azimuth: number = Math.atan2(dz, dx);\n\n  // Ensure azimuth is in range [0, 2π]\n  if (azimuth < 0) azimuth += 2 * Math.PI;\n\n  const horizontalDistance: number = Math.sqrt(dx * dx + dz * dz);\n  const elevation: number = Math.atan2(dy, horizontalDistance);\n\n  return {\n    azimuth: azimuth as TRadians,\n    elevation: elevation as TRadians\n  };\n}\n\n// TODO add unit tests\nexport function degreesToEuler(degrees: Vector3Like): Vector3 {\n  const radians = {\n    x: degToRad(degrees.x),\n    y: degToRad(degrees.y),\n    z: degToRad(degrees.z)\n  };\n\n  return new Vector3(radians.x, radians.y, radians.z);\n}\n\n// TODO add unit tests\nexport function degreesToQuaternion(degrees: Vector3Like): Quaternion {\n  const radians = {\n    x: degToRad(degrees.x),\n    y: degToRad(degrees.y),\n    z: degToRad(degrees.z)\n  };\n\n  const euler: Euler = new Euler(radians.x, radians.y, radians.z);\n  return new Quaternion().setFromEuler(euler);\n}\n\n// TODO add unit tests\nexport function quaternionToDegrees(quaternion: QuaternionLike): Vector3 {\n  const q: Quaternion = new Quaternion(quaternion.x, quaternion.y, quaternion.z, quaternion.w);\n  const euler: Euler = new Euler().setFromQuaternion(q, 'XYZ');\n\n  return new Vector3(radToDeg(euler.x), radToDeg(euler.y), radToDeg(euler.z));\n}\n\nexport function applyRotationOffsetWithReorder(target: Euler, source: Euler, offset: Euler, order: EulerOrder = 'XYZ'): void {\n  source.reorder(order);\n\n  target.set(source.x + offset.x, source.y + offset.y, source.z + offset.z, order);\n\n  target.set(euclideanModulo(target.x + Math.PI, Math.PI * 2) - Math.PI, euclideanModulo(target.y + Math.PI, Math.PI * 2) - Math.PI, euclideanModulo(target.z + Math.PI, Math.PI * 2) - Math.PI);\n}\n\nexport function toQuaternion(quaternionOrEuler: QuaternionLike | TEulerLike): Quaternion | never {\n  if (isQuaternionLike(quaternionOrEuler)) return new Quaternion(quaternionOrEuler.x, quaternionOrEuler.y, quaternionOrEuler.z, quaternionOrEuler.w);\n  if (isEulerLike(quaternionOrEuler)) return new Quaternion().setFromEuler(new Euler(quaternionOrEuler.x, quaternionOrEuler.y, quaternionOrEuler.z));\n  throw new Error('Entity must be Quaternion or Euler, but it is something else');\n}\n"],"names":["getHorizontalAzimuth","x","z","point","forwardAxis","azimuthRad","Math","atan2","toLocaleLowerCase","PI","euclideanModulo","getElevation","y","dy","horizontalDistance","sqrt","getAzimuthElevationFromQuaternion","q","w","azimuth","elevation","asin","getAzimuthElevationFromVector","v","ForwardAxis","Z","getAzimuthFromDirection","direction","getAzimuthFromQuaternionDirection","quaternion","getElevationFromDirection","getElevationFromQuaternionDirection","getDirectionFromLinearVelocity","linearVelocity","clone","normalize","getSpeedFromLinearVelocity","metersPerSecond","length","getLinearVelocityByDeg","speed","degToRad","elevationRad","Vector3","cos","sin","getLinearVelocity","getSpeedFromAngularVelocity","angularVelocity","radiansPerSecond","getDirectionFromAngularVelocity","get3DAzimuth","center","dx","dz","degreesToEuler","degrees","radians","degreesToQuaternion","euler","Euler","Quaternion","setFromEuler","quaternionToDegrees","setFromQuaternion","radToDeg","applyRotationOffsetWithReorder","target","source","offset","order","reorder","set","toQuaternion","quaternionOrEuler","isQuaternionLike","isEulerLike","Error"],"mappings":"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"}
+{"version":3,"file":"AnglesUtils.js","sources":["../../../src/Math/Utils/AnglesUtils.ts"],"sourcesContent":["import { metersPerSecond, radiansPerSecond } from '@hellpig/anarchy-engine/Distance';\nimport { ForwardAxis } from '@hellpig/anarchy-engine/Kinematic/Constants';\nimport type { TDegrees, TMetersPerSecond, TRadians, TRadiansPerSecond } from '@hellpig/anarchy-engine/Math/Types';\nimport type { TEulerLike } from '@hellpig/anarchy-engine/ThreeLib';\nimport { isEulerLike, isQuaternionLike } from '@hellpig/anarchy-engine/Utils/CheckUtils';\nimport type { EulerOrder, QuaternionLike, Vector3Like } from 'three';\nimport { Euler, MathUtils, Quaternion, Vector3 } from 'three';\n\nconst { degToRad, euclideanModulo, radToDeg } = MathUtils;\n\nexport function getHorizontalAzimuth(x: number, z: number, point: Vector3Like, forwardAxis: ForwardAxis): TRadians {\n  const dx: number = point.x - x;\n  const dz: number = point.z - z;\n\n  let azimuthRad: number = Math.atan2(dz, dx);\n  if (forwardAxis.toLocaleLowerCase() === 'Z'.toLocaleLowerCase()) azimuthRad = -azimuthRad + Math.PI / 2;\n  azimuthRad = euclideanModulo(azimuthRad, Math.PI * 2);\n\n  return azimuthRad as TRadians;\n}\n\n// TODO add unit tests\nexport function getElevation(x: number, y: number, z: number, point: Vector3Like): TRadians {\n  const dx: number = point.x - x;\n  const dy: number = point.y - y;\n  const dz: number = point.z - z;\n\n  const horizontalDistance: number = Math.sqrt(dx ** 2 + dz ** 2);\n\n  return Math.atan2(dy, horizontalDistance) as TRadians;\n}\n\n// TODO add unit tests\nexport function getAzimuthElevationFromQuaternion(q: Quaternion): { azimuth: TRadians; elevation: TRadians } {\n  const { x, y, z, w } = q;\n\n  const azimuth: TRadians = Math.atan2(2 * (w * z + x * y), 1 - 2 * (y * y + z * z)) as TRadians;\n  const elevation: TRadians = Math.asin(2 * (w * y - z * x)) as TRadians;\n\n  return { azimuth, elevation };\n}\n\nexport function getAzimuthElevationFromVector(v: Vector3Like, forwardAxis: ForwardAxis): { azimuth: TRadians; elevation: TRadians } {\n  let azimuth: TRadians;\n\n  if (forwardAxis === ForwardAxis.Z) {\n    azimuth = Math.atan2(v.x, v.z) as TRadians;\n  } else {\n    azimuth = Math.atan2(v.z, v.x) as TRadians;\n  }\n\n  const elevation: TRadians = Math.atan2(v.y, Math.sqrt(v.x * v.x + v.z * v.z)) as TRadians;\n\n  return { azimuth: euclideanModulo(azimuth, Math.PI * 2) as TRadians, elevation };\n}\n\n// TODO add unit tests\nexport const getAzimuthFromDirection = (direction: Vector3Like): TRadians => {\n  let azimuth: TRadians = Math.atan2(direction.z, direction.x) as TRadians;\n  if (azimuth < 0) (azimuth as number) += 2 * Math.PI;\n  return azimuth;\n};\n\n// TODO add unit tests\nexport const getAzimuthFromQuaternionDirection = (quaternion: QuaternionLike): TRadians => {\n  const { x, y, z, w } = quaternion;\n\n  // Calculate azimuth using the quaternion components\n  const sinY: number = 2 * (w * y + z * x);\n  const cosY: number = 1 - 2 * (x * x + y * y);\n\n  let azimuth: TRadians = Math.atan2(sinY, cosY) as TRadians;\n\n  // Normalize azimuth to range [0, 2π]\n  if (azimuth < 0) (azimuth as number) += 2 * Math.PI;\n\n  return azimuth;\n};\n\n// TODO add unit tests\nexport const getElevationFromDirection = (direction: Vector3Like): TRadians => Math.atan2(direction.y, Math.sqrt(direction.x ** 2 + direction.z ** 2)) as TRadians;\n// TODO add unit tests\nexport const getElevationFromQuaternionDirection = (quaternion: QuaternionLike): TRadians => {\n  const { x, y, z, w } = quaternion;\n  return Math.asin(2 * (w * x - y * z)) as TRadians;\n};\n\n// TODO add unit tests\nexport const getDirectionFromLinearVelocity = (linearVelocity: Vector3): Vector3 => linearVelocity.clone().normalize();\n// TODO add unit tests\nexport const getSpeedFromLinearVelocity = (linearVelocity: Vector3): TMetersPerSecond => metersPerSecond(linearVelocity.length());\n// TODO add unit tests\nexport const getLinearVelocityByDeg = (speed: TMetersPerSecond, azimuth: TDegrees, elevation: TDegrees): Vector3 => {\n  const azimuthRad: TRadians = degToRad(azimuth) as TRadians;\n  const elevationRad: TRadians = degToRad(elevation) as TRadians;\n  return new Vector3(speed * Math.cos(elevationRad) * Math.cos(azimuthRad), speed * Math.sin(elevationRad), speed * Math.cos(elevationRad) * Math.sin(azimuthRad));\n};\n\n// TODO add unit tests\nexport const getLinearVelocity = (speed: TMetersPerSecond, azimuth: TRadians, elevation: TRadians): Vector3 =>\n  new Vector3(speed * Math.cos(elevation) * Math.cos(azimuth), speed * Math.sin(elevation), speed * Math.cos(elevation) * Math.sin(azimuth));\n\n// TODO add unit tests\nexport const getSpeedFromAngularVelocity = (angularVelocity: Quaternion): TRadiansPerSecond => radiansPerSecond(angularVelocity.length());\n\n// TODO add unit tests\nexport const getDirectionFromAngularVelocity = (angularVelocity: Quaternion): Quaternion => angularVelocity.clone().normalize();\n\n// TODO add unit tests\nexport function get3DAzimuth(center: Vector3Like, point: Vector3Like): { azimuth: TRadians; elevation: TRadians } {\n  const dx: number = point.x - center.x;\n  const dy: number = point.y - center.y;\n  const dz: number = point.z - center.z;\n\n  let azimuth: number = Math.atan2(dz, dx);\n\n  // Ensure azimuth is in range [0, 2π]\n  if (azimuth < 0) azimuth += 2 * Math.PI;\n\n  const horizontalDistance: number = Math.sqrt(dx * dx + dz * dz);\n  const elevation: number = Math.atan2(dy, horizontalDistance);\n\n  return {\n    azimuth: azimuth as TRadians,\n    elevation: elevation as TRadians\n  };\n}\n\n// TODO add unit tests\nexport function degreesToEuler(degrees: Vector3Like): Vector3 {\n  const radians = {\n    x: degToRad(degrees.x),\n    y: degToRad(degrees.y),\n    z: degToRad(degrees.z)\n  };\n\n  return new Vector3(radians.x, radians.y, radians.z);\n}\n\n// TODO add unit tests\nexport function degreesToQuaternion(degrees: Vector3Like): Quaternion {\n  const radians = {\n    x: degToRad(degrees.x),\n    y: degToRad(degrees.y),\n    z: degToRad(degrees.z)\n  };\n\n  const euler: Euler = new Euler(radians.x, radians.y, radians.z);\n  return new Quaternion().setFromEuler(euler);\n}\n\n// TODO add unit tests\nexport function quaternionToDegrees(quaternion: QuaternionLike): Vector3 {\n  const q: Quaternion = new Quaternion(quaternion.x, quaternion.y, quaternion.z, quaternion.w);\n  const euler: Euler = new Euler().setFromQuaternion(q, 'XYZ');\n\n  return new Vector3(radToDeg(euler.x), radToDeg(euler.y), radToDeg(euler.z));\n}\n\nexport function applyRotationOffsetWithReorder(target: Euler, source: Euler, offset: Euler, order: EulerOrder = 'XYZ'): void {\n  source.reorder(order);\n\n  target.set(source.x + offset.x, source.y + offset.y, source.z + offset.z, order);\n\n  target.set(euclideanModulo(target.x + Math.PI, Math.PI * 2) - Math.PI, euclideanModulo(target.y + Math.PI, Math.PI * 2) - Math.PI, euclideanModulo(target.z + Math.PI, Math.PI * 2) - Math.PI);\n}\n\nexport function toQuaternion(quaternionOrEuler: QuaternionLike | TEulerLike): Quaternion | never {\n  if (isQuaternionLike(quaternionOrEuler)) return new Quaternion(quaternionOrEuler.x, quaternionOrEuler.y, quaternionOrEuler.z, quaternionOrEuler.w);\n  if (isEulerLike(quaternionOrEuler)) return new Quaternion().setFromEuler(new Euler(quaternionOrEuler.x, quaternionOrEuler.y, quaternionOrEuler.z));\n  throw new Error('Entity must be Quaternion or Euler, but it is something else');\n}\n"],"names":["degToRad","euclideanModulo","radToDeg","MathUtils","getHorizontalAzimuth","x","z","point","forwardAxis","azimuthRad","Math","atan2","toLocaleLowerCase","PI","getElevation","y","dy","horizontalDistance","sqrt","getAzimuthElevationFromQuaternion","q","w","azimuth","elevation","asin","getAzimuthElevationFromVector","v","ForwardAxis","Z","getAzimuthFromDirection","direction","getAzimuthFromQuaternionDirection","quaternion","getElevationFromDirection","getElevationFromQuaternionDirection","getDirectionFromLinearVelocity","linearVelocity","clone","normalize","getSpeedFromLinearVelocity","metersPerSecond","length","getLinearVelocityByDeg","speed","elevationRad","Vector3","cos","sin","getLinearVelocity","getSpeedFromAngularVelocity","angularVelocity","radiansPerSecond","getDirectionFromAngularVelocity","get3DAzimuth","center","dx","dz","degreesToEuler","degrees","radians","degreesToQuaternion","euler","Euler","Quaternion","setFromEuler","quaternionToDegrees","setFromQuaternion","applyRotationOffsetWithReorder","target","source","offset","order","reorder","set","toQuaternion","quaternionOrEuler","isQuaternionLike","isEulerLike","Error"],"mappings":"gRAQA,MAAMA,SAAEA,SAAAC,gBAAUA,gBAAAC,SAAiBA,UAAaC,UAEzC,SAASC,qBAAqBC,EAAWC,EAAWC,MAAoBC,aAI7E,IAAIC,WAAqBC,KAAKC,MAFXJ,MAAMD,EAAIA,EADVC,MAAMF,EAAIA,GAO7B,OAHIG,YAAYI,sBAAwB,IAAIA,sBAAqBH,YAAcA,WAAaC,KAAKG,GAAK,GACtGJ,WAAaR,gBAAgBQ,WAAsB,EAAVC,KAAKG,IAEvCJ,UACT,CAGO,SAASK,aAAaT,EAAWU,EAAWT,EAAWC,OAC5D,MACMS,GAAaT,MAAMQ,EAAIA,EAGvBE,mBAA6BP,KAAKQ,MAJrBX,MAAMF,EAAIA,IAIsB,GAFhCE,MAAMD,EAAIA,IAEgC,GAE7D,OAAOI,KAAKC,MAAMK,GAAIC,mBACxB,CAGO,SAASE,kCAAkCC,GAChD,MAAMf,EAAEA,EAAAU,EAAGA,EAAAT,EAAGA,EAAAe,EAAGA,GAAMD,EAKvB,MAAO,CAAEE,QAHiBZ,KAAKC,MAAM,GAAKU,EAAIf,EAAID,EAAIU,GAAI,EAAI,GAAKA,EAAIA,EAAIT,EAAIA,IAG7DiB,UAFUb,KAAKc,KAAK,GAAKH,EAAIN,EAAIT,EAAID,IAGzD,CAEO,SAASoB,8BAA8BC,EAAgBlB,aAC5D,IAAIc,QAGFA,QADEd,cAAgBmB,YAAYC,EACpBlB,KAAKC,MAAMe,EAAErB,EAAGqB,EAAEpB,GAElBI,KAAKC,MAAMe,EAAEpB,EAAGoB,EAAErB,GAG9B,MAAMkB,UAAsBb,KAAKC,MAAMe,EAAEX,EAAGL,KAAKQ,KAAKQ,EAAErB,EAAIqB,EAAErB,EAAIqB,EAAEpB,EAAIoB,EAAEpB,IAE1E,MAAO,CAAEgB,QAASrB,gBAAgBqB,QAAmB,EAAVZ,KAAKG,IAAqBU,oBACvE,CAGO,MAAMM,wBAA2BC,YACtC,IAAIR,QAAoBZ,KAAKC,MAAMmB,UAAUxB,EAAGwB,UAAUzB,GAE1D,OADIiB,QAAU,IAAIA,SAAsB,EAAIZ,KAAKG,IAC1CS,SAIIS,kCAAqCC,aAChD,MAAM3B,EAAEA,EAAAU,EAAGA,EAAAT,EAAGA,EAAAe,EAAGA,GAAMW,WAMvB,IAAIV,QAAoBZ,KAAKC,MAHR,GAAKU,EAAIN,EAAIT,EAAID,GACjB,EAAI,GAAKA,EAAIA,EAAIU,EAAIA,IAO1C,OAFIO,QAAU,IAAIA,SAAsB,EAAIZ,KAAKG,IAE1CS,SAIIW,0BAA6BH,WAAqCpB,KAAKC,MAAMmB,UAAUf,EAAGL,KAAKQ,KAAKY,UAAUzB,GAAK,EAAIyB,UAAUxB,GAAK,IAEtI4B,oCAAuCF,aAClD,MAAM3B,EAAEA,EAAAU,EAAGA,EAAAT,EAAGA,EAAAe,EAAGA,GAAMW,WACvB,OAAOtB,KAAKc,KAAK,GAAKH,EAAIhB,EAAIU,EAAIT,KAIvB6B,+BAAkCC,gBAAqCA,eAAeC,QAAQC,YAE9FC,2BAA8BH,gBAA8CI,gBAAgBJ,eAAeK,UAE3GC,uBAAyB,CAACC,MAAyBrB,QAAmBC,aACjF,MAAMd,WAAuBT,SAASsB,SAChCsB,aAAyB5C,SAASuB,WACxC,OAAO,IAAIsB,QAAQF,MAAQjC,KAAKoC,IAAIF,cAAgBlC,KAAKoC,IAAIrC,YAAakC,MAAQjC,KAAKqC,IAAIH,cAAeD,MAAQjC,KAAKoC,IAAIF,cAAgBlC,KAAKqC,IAAItC,cAIzIuC,kBAAoB,CAACL,MAAyBrB,QAAmBC,YAC5E,IAAIsB,QAAQF,MAAQjC,KAAKoC,IAAIvB,WAAab,KAAKoC,IAAIxB,SAAUqB,MAAQjC,KAAKqC,IAAIxB,WAAYoB,MAAQjC,KAAKoC,IAAIvB,WAAab,KAAKqC,IAAIzB,UAGtH2B,4BAA+BC,iBAAmDC,iBAAiBD,gBAAgBT,UAGnHW,gCAAmCF,iBAA4CA,gBAAgBb,QAAQC,YAG7G,SAASe,aAAaC,OAAqB/C,OAChD,MAAMgD,GAAahD,MAAMF,EAAIiD,OAAOjD,EAC9BW,GAAaT,MAAMQ,EAAIuC,OAAOvC,EAC9ByC,GAAajD,MAAMD,EAAIgD,OAAOhD,EAEpC,IAAIgB,QAAkBZ,KAAKC,MAAM6C,GAAID,IAGjCjC,QAAU,IAAGA,SAAW,EAAIZ,KAAKG,IAErC,MAAMI,mBAA6BP,KAAKQ,KAAKqC,GAAKA,GAAKC,GAAKA,IAG5D,MAAO,CACLlC,gBACAC,UAJwBb,KAAKC,MAAMK,GAAIC,oBAM3C,CAGO,SAASwC,eAAeC,SAC7B,MAAMC,QAAU,CACdtD,EAAGL,SAAS0D,QAAQrD,GACpBU,EAAGf,SAAS0D,QAAQ3C,GACpBT,EAAGN,SAAS0D,QAAQpD,IAGtB,OAAO,IAAIuC,QAAQc,QAAQtD,EAAGsD,QAAQ5C,EAAG4C,QAAQrD,EACnD,CAGO,SAASsD,oBAAoBF,SAClC,MAAMC,QAAU,CACdtD,EAAGL,SAAS0D,QAAQrD,GACpBU,EAAGf,SAAS0D,QAAQ3C,GACpBT,EAAGN,SAAS0D,QAAQpD,IAGhBuD,MAAe,IAAIC,MAAMH,QAAQtD,EAAGsD,QAAQ5C,EAAG4C,QAAQrD,GAC7D,OAAO,IAAIyD,YAAaC,aAAaH,MACvC,CAGO,SAASI,oBAAoBjC,YAClC,MAAMZ,EAAgB,IAAI2C,WAAW/B,WAAW3B,EAAG2B,WAAWjB,EAAGiB,WAAW1B,EAAG0B,WAAWX,GACpFwC,OAAe,IAAIC,OAAQI,kBAAkB9C,EAAG,OAEtD,OAAO,IAAIyB,QAAQ3C,SAAS2D,MAAMxD,GAAIH,SAAS2D,MAAM9C,GAAIb,SAAS2D,MAAMvD,GAC1E,CAEO,SAAS6D,+BAA+BC,OAAeC,OAAeC,OAAeC,MAAoB,OAC9GF,OAAOG,QAAQD,OAEfH,OAAOK,IAAIJ,OAAOhE,EAAIiE,OAAOjE,EAAGgE,OAAOtD,EAAIuD,OAAOvD,EAAGsD,OAAO/D,EAAIgE,OAAOhE,EAAGiE,OAE1EH,OAAOK,IAAIxE,gBAAgBmE,OAAO/D,EAAIK,KAAKG,GAAc,EAAVH,KAAKG,IAAUH,KAAKG,GAAIZ,gBAAgBmE,OAAOrD,EAAIL,KAAKG,GAAc,EAAVH,KAAKG,IAAUH,KAAKG,GAAIZ,gBAAgBmE,OAAO9D,EAAII,KAAKG,GAAc,EAAVH,KAAKG,IAAUH,KAAKG,GAC7L,CAEO,SAAS6D,aAAaC,mBAC3B,GAAIC,iBAAiBD,mBAAoB,OAAO,IAAIZ,WAAWY,kBAAkBtE,EAAGsE,kBAAkB5D,EAAG4D,kBAAkBrE,EAAGqE,kBAAkBtD,GAChJ,GAAIwD,YAAYF,mBAAoB,OAAO,IAAIZ,YAAaC,aAAa,IAAIF,MAAMa,kBAAkBtE,EAAGsE,kBAAkB5D,EAAG4D,kBAAkBrE,IAC/I,MAAM,IAAIwE,MAAM,+DAClB"}

package/dist/Math/Utils/DistanceUtils.d.ts

@@ -1,2 +1,2 @@
-import { TReadonlyVector3 } from '../../ThreeLib';
+import { TReadonlyVector3 } from '@hellpig/anarchy-engine/ThreeLib';
 export declare function getDistance(pointA: TReadonlyVector3, pointB: TReadonlyVector3): number;

package/dist/Measurements/Constants/Distance.d.ts

@@ -1,2 +1,2 @@
-import { TMeters } from '../../Math/Types';
+import { TMeters } from '@hellpig/anarchy-engine/Math/Types';
 export declare const METER: TMeters;

package/dist/Measurements/Constants/Time.d.ts

@@ -1,4 +1,4 @@
-import { TMilliseconds } from '../../Math/Types';
+import { TMilliseconds } from '@hellpig/anarchy-engine/Math/Types';
 export declare const MILLISECOND: TMilliseconds;
 export declare const SECOND: TMilliseconds;
 export declare const MINUTE: TMilliseconds;

package/dist/Measurements/Utils/MeasurementsUtils.d.ts

@@ -1,5 +1,5 @@
 import { Vector } from '@dimforge/rapier3d/math';
-import { TDegrees, TMeters, TMilliseconds, TRadians, TSeconds } from '../../Math/Types';
+import { TDegrees, TMeters, TMilliseconds, TRadians, TSeconds } from '@hellpig/anarchy-engine/Math/Types';
 import { Vector3 } from 'three';
 export declare const meters: (meters: number) => TMeters;
 export declare const centimetersToMeters: (cm: number) => TMeters;

package/dist/Mixins/GameObjects/Mixins/Movable/WithMoveBy2dMixin.d.ts

@@ -1,2 +1,2 @@
-import { TMovableXY, TWithPosition2dProperty } from '../../Models';
+import { TMovableXY, TWithPosition2dProperty } from '@hellpig/anarchy-engine/Mixins/GameObjects/Models';
 export declare function withMoveBy2dMixin(entity: TWithPosition2dProperty): TMovableXY;

package/dist/Mixins/GameObjects/Mixins/Movable/WithMoveBy3dMixin.d.ts

@@ -1,2 +1,2 @@
-import { TMovableXYZ, TWithPosition3dProperty } from '../../Models';
+import { TMovableXYZ, TWithPosition3dProperty } from '@hellpig/anarchy-engine/Mixins/GameObjects/Models';
 export declare function withMoveBy3dMixin(entity: TWithPosition3dProperty): TMovableXYZ;

package/dist/Mixins/GameObjects/Mixins/Movable/WithMoveBy4dMixin.d.ts

@@ -1,2 +1,2 @@
-import { TMovableXYZW, TWithPosition4dProperty } from '../../Models';
+import { TMovableXYZW, TWithPosition4dProperty } from '@hellpig/anarchy-engine/Mixins/GameObjects/Models';
 export declare function withMoveBy4dMixin(entity: TWithPosition4dProperty): TMovableXYZW;

package/dist/Mixins/GameObjects/Mixins/Movable/WithMoveByWMixin.d.ts

@@ -1,2 +1,2 @@
-import { TMovableW, TWithPosition4dProperty } from '../../Models';
+import { TMovableW, TWithPosition4dProperty } from '@hellpig/anarchy-engine/Mixins/GameObjects/Models';
 export declare function withMoveByWMixin(entity: TWithPosition4dProperty): TMovableW;

package/dist/Mixins/GameObjects/Mixins/Movable/WithMoveByXMixin.d.ts

@@ -1,2 +1,2 @@
-import { TMovableX, TWithPositionProperty } from '../../Models';
+import { TMovableX, TWithPositionProperty } from '@hellpig/anarchy-engine/Mixins/GameObjects/Models';
 export declare function withMoveByXMixin(entity: TWithPositionProperty): TMovableX;

package/dist/Mixins/GameObjects/Mixins/Movable/WithMoveByYMixin.d.ts

@@ -1,2 +1,2 @@
-import { TMovableY, TWithPositionProperty } from '../../Models';
+import { TMovableY, TWithPositionProperty } from '@hellpig/anarchy-engine/Mixins/GameObjects/Models';
 export declare function withMoveByYMixin(entity: TWithPositionProperty): TMovableY;