Options
All
  • Public
  • Public/Protected
  • All
Menu

Class WWTEngineVuexModule

The store module class for the WWT Vuex implementation.

See WWTAwareComponent for an organized overview of the state variables, getters, actions, and mutations exposed by this module.

Hierarchy

  • VuexModule
    • WWTEngineVuexModule

Implements

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

  • Parameters

    • module: Module<ThisType<any>, any>

    Returns WWTEngineVuexModule

Properties

Optional actions

actions: ActionTree<ThisType<any>, any>

activeLayers

activeLayers: string[] = []

The GUIDs of all rendered layers, in their draw order.

availableImagesets

availableImagesets: ImagesetInfo[] = []

Info about the imagesets that are available in the engine to be used as backgrounds

backgroundImageset

backgroundImageset: null | Imageset = null

The current imageset acting as the background imagery, if defined.

clockDiscontinuities

clockDiscontinuities: number = 0

The number of times that the WWT engine clock has been changed in a discontinuous manner.

The point of this property is that one can watch() it and get alerted to when this happens.

clockRate

clockRate: number = 1.0

The rate at which the WWT engine clock progresses, compared to real time.

context

context: ActionContext<ThisType<any>, any>

currentTime

currentTime: Date = ...

The current WWT clock time of the view, as a UTC Date.

decRad

decRad: number = 0.0

The current declination of the view, in radians.

TODO: define this properly for planetary lat/lng views!

foregroundImageset

foregroundImageset: null | Imageset = null

The current imageset acting as the foreground imagery, if defined.

foregroundOpacity

foregroundOpacity: number = 100

The opacity with which the foreground imageset is rendered; valid values are between 0 and 100 (inclusive).

Optional getters

getters: GetterTree<ThisType<any>, any>

imagesetLayers

imagesetLayers: {} = {}

Settings for all registered imageset layers.

Type declaration

isTourPlayerActive

isTourPlayerActive: boolean = false

Whether the tour playback mode is active.

Specifically, this is true if the WWTControl has a uiController item that is a TourPlayer item. See also isTourPlaying.

isTourPlaying

isTourPlaying: boolean = false

Whether a tour is actively playing righ now.

It might be the case that a tour player is active, but the tour is paused.

Optional modules

modules: ModuleTree<any>

Optional mutations

mutations: MutationTree<ThisType<any>>

Optional namespaced

namespaced: boolean

raRad

raRad: number = 0.0

The current right ascension of the view, in radians.

TODO: define this properly for planetary lat/lng views!

renderType

renderType: ImageSetType = ...

The current mode of the renderer

rollRad

rollRad: number = 0

The current roll of the view camera, in radians

showWebGl2Warning

showWebGl2Warning: boolean = false

spreadSheetLayers

spreadSheetLayers: {} = {}

Settings for all registered WWT spreadsheet layers.

Type declaration

  • [guidtext: string]: SpreadSheetLayerState

Optional state

state: ThisType<any> | (() => ThisType<any>)

timeAtStartup

timeAtStartup: number = ...

tourCompletions

tourCompletions: number = 0

The number of times that a tour has played through to the end.

The point of this property is that one can watch() it and get alerted to tour completion.

tourRunTime

tourRunTime: null | number = null

The total run-time of the current tour, if there is one, measured in seconds.

tourStopStartTimes

tourStopStartTimes: number[] = []

The start times of the stops in the tour, measured in seconds.

It is possible for tour stops to be linked in a non-linear order, such that actual playback won't proceed linearly in the way that this API would imply.

tourTimecode

tourTimecode: number = 0.0

How far we have progressed into the current tour, in seconds.

This number does not necessarily progress monotonically due to the way that WWT measures tour playback progress. We associate a start time with each "stop" in the tour, and can measure progress through a stop, but stops do not necessarily transition from one to another in linear fashion.

That being said, this number should range between 0 and the runtime of the current tour. If no tour is loaded, it will be zero.

zoomDeg

zoomDeg: number = 0.0

The current zoom level of the view, in degrees.

The zoom level is the angular height of the viewport, times size.

TODO: define this properly for 3D modes!

Static Optional actions

actions: ActionTree<any, any>

Static Optional getters

getters: GetterTree<any, any>

Static Optional modules

modules: ModuleTree<any>

Static Optional mutations

mutations: MutationTree<any>

Static Optional namespaced

namespaced: boolean

Static Optional state

state: any

Accessors

activeImagesetLayerStates

findRADecForScreenPoint

  • get findRADecForScreenPoint(): (pt: { x: number; y: number }) => { dec: number; ra: number }
  • Returns (pt: { x: number; y: number }) => { dec: number; ra: number }

      • (pt: { x: number; y: number }): { dec: number; ra: number }
      • Parameters

        • pt: { x: number; y: number }
          • x: number
          • y: number

        Returns { dec: number; ra: number }

        • dec: number
        • ra: number

findScreenPointForRADec

  • get findScreenPointForRADec(): (pt: { dec: number; ra: number }) => { x: number; y: number }
  • Returns (pt: { dec: number; ra: number }) => { x: number; y: number }

      • (pt: { dec: number; ra: number }): { x: number; y: number }
      • Parameters

        • pt: { dec: number; ra: number }
          • dec: number
          • ra: number

        Returns { x: number; y: number }

        • x: number
        • y: number

imagesetForLayer

  • get imagesetForLayer(): (guidtext: string) => null | Imageset
  • Returns (guidtext: string) => null | Imageset

      • (guidtext: string): null | Imageset
      • Parameters

        • guidtext: string

        Returns null | Imageset

imagesetStateForLayer

layerForHipsCatalog

  • get layerForHipsCatalog(): (name: string) => null | SpreadSheetLayer
  • Returns (name: string) => null | SpreadSheetLayer

      • (name: string): null | SpreadSheetLayer
      • Parameters

        • name: string

        Returns null | SpreadSheetLayer

lookupImageset

  • get lookupImageset(): (imagesetName: string) => null | Imageset
  • Returns (imagesetName: string) => null | Imageset

      • (imagesetName: string): null | Imageset
      • Parameters

        • imagesetName: string

        Returns null | Imageset

spreadSheetLayer

  • get spreadSheetLayer(): (catalog: CatalogLayerInfo) => null | SpreadSheetLayer

spreadSheetLayerById

  • get spreadSheetLayerById(): (id: string) => null | SpreadSheetLayer
  • Returns (id: string) => null | SpreadSheetLayer

      • (id: string): null | SpreadSheetLayer
      • Parameters

        • id: string

        Returns null | SpreadSheetLayer

spreadsheetState

  • get spreadsheetState(): (catalog: CatalogLayerInfo) => null | SpreadSheetLayerSettingsInterfaceRO

spreadsheetStateById

  • get spreadsheetStateById(): (id: string) => null | SpreadSheetLayerSettingsInterfaceRO
  • Returns (id: string) => null | SpreadSheetLayerSettingsInterfaceRO

      • (id: string): null | SpreadSheetLayerSettingsInterfaceRO
      • Parameters

        • id: string

        Returns null | SpreadSheetLayerSettingsInterfaceRO

spreadsheetStateForHipsCatalog

  • get spreadsheetStateForHipsCatalog(): (name: string) => null | SpreadSheetLayerSettingsInterfaceRO
  • Returns (name: string) => null | SpreadSheetLayerSettingsInterfaceRO

      • (name: string): null | SpreadSheetLayerSettingsInterfaceRO
      • Parameters

        • name: string

        Returns null | SpreadSheetLayerSettingsInterfaceRO

Methods

addAnnotation

  • addAnnotation(ann: Annotation): void

addCatalogHipsByName

  • addCatalogHipsByName(options: AddCatalogHipsByNameOptions): Promise<Imageset>

addImageSetLayer

  • addImageSetLayer(options: AddImageSetLayerOptions): Promise<ImageSetLayer>

applyFitsLayerSettings

  • applyFitsLayerSettings(options: ApplyFitsLayerSettingsOptions): void

applySetting

  • applySetting(setting: EngineSetting): void

applyTableLayerSettings

  • applyTableLayerSettings(options: ApplyTableLayerSettingsOptions): void

clearAnnotations

  • clearAnnotations(): void

createTableLayer

deleteLayer

  • deleteLayer(id: string | Guid): void

getCatalogHipsDataInView

  • getCatalogHipsDataInView(options: GetCatalogHipsDataInViewOptions): Promise<InViewReturnMessage>

gotoRADecZoom

gotoTarget

  • gotoTarget(options: GotoTargetOptions): Promise<void>

internalIncrementTourCompletions

  • internalIncrementTourCompletions(): void

internalLinkToInstance

  • internalLinkToInstance(wwt: WWTInstance): void

internalUnlinkFromInstance

  • internalUnlinkFromInstance(): void

internalUpdate

  • internalUpdate(): void

loadFitsLayer

  • loadFitsLayer(options: LoadFitsLayerOptions): Promise<ImageSetLayer>

loadImageCollection

loadTour

  • loadTour(__namedParameters: LoadTourParams): Promise<{ tourRunTime: null | number; tourStopStartTimes: number[] }>

move

  • move(args: { x: number; y: number }): void

removeAnnotation

  • removeAnnotation(ann: Annotation): void

removeCatalogHipsByName

  • removeCatalogHipsByName(name: string): void

seekToTourTimecode

  • seekToTourTimecode(value: number): void

setBackgroundImageByName

  • setBackgroundImageByName(imagesetName: string): void

setClockRate

  • setClockRate(rate: number): void

setClockSync

  • setClockSync(isSynced: boolean): void

setFitsLayerColormap

  • setFitsLayerColormap(options: SetFitsLayerColormapOptions): void

setForegroundImageByName

  • setForegroundImageByName(imagesetName: string): void

setForegroundOpacity

  • setForegroundOpacity(opacity: number): void

setImageSetLayerOrder

  • setImageSetLayerOrder(options: SetLayerOrderOptions): void

setTime

  • setTime(time: Date): void

setTourPlayerLeaveSettingsWhenStopped

  • setTourPlayerLeaveSettingsWhenStopped(value: boolean): void

setTrackedObject

  • setTrackedObject(obj: SolarSystemObjects): void

setupForImageset

startTour

  • startTour(): void

stretchFitsLayer

  • stretchFitsLayer(options: StretchFitsLayerOptions): void

tilt

  • tilt(args: { x: number; y: number }): void

toggleTourPlayPauseState

  • toggleTourPlayPauseState(): void

updateAvailableImagesets

  • updateAvailableImagesets(): void

updateTableLayer

  • updateTableLayer(options: UpdateTableLayerOptions): void

viewAsTourXml

  • viewAsTourXml(name: string): Promise<null | string>

waitForReady

  • waitForReady(): Promise<void>

zoom

  • zoom(factor: number): void

Generated using TypeDoc