ohzi-core 5.13.2 → 5.14.2

package/src/view_components/ViewComponentManager.js

@@ -0,0 +1,58 @@
+import ViewManager from './ViewManager';
+
+class ViewComponentManager
+{
+  constructor()
+  {
+    this.components = [];
+    this.enabled_components = new Set();
+  }
+
+  update()
+  {
+    for (let component of this.enabled_components)
+    {
+      component.update(ViewManager.transition_handler.current_state_data);
+    }
+  }
+
+  register_component(component)
+  {
+    this.components.push(component);
+  }
+
+  enable_component(component)
+  {
+    // const component_to_enable = this.get_component_by_name(component_name);
+
+    this.enabled_components.add(component);
+  }
+
+  disable_component(component)
+  {
+    // const component_to_disable = this.get_component_by_name(component_name);
+
+    this.enabled_components.delete(component);
+  }
+
+  get_component_by_name(component_name)
+  {
+    console.warn('DEPRECATED. Use ViewComponentManager.get instead');
+    this.get(component_name);
+  }
+
+  get(component_name)
+  {
+    for (let i = 0; i < this.components.length; i++)
+    {
+      if (this.components[i].name === component_name)
+      {
+        return this.components[i];
+      }
+    }
+    console.error('[ViewComponentManager.get] no component found for: ', component_name);
+    return undefined;
+  }
+}
+
+export default new ViewComponentManager();

package/src/view_components/ViewContext.js

@@ -0,0 +1,14 @@
+class ViewContext
+{
+  constructor()
+  {
+    this.app = undefined;
+  }
+
+  set_app(app)
+  {
+    this.app = app;
+  }
+}
+
+export default new ViewContext();

package/src/view_components/ViewManager.js

@@ -0,0 +1,119 @@
+import TransitionTable from './transition/TransitionTable';
+import ViewStateTransitionHandler from './transition/ViewStateTransitionHandler';
+
+class ViewManager
+{
+  constructor()
+  {
+    this.views = [];
+
+    this.transition_table = new TransitionTable();
+    this.transition_handler = new ViewStateTransitionHandler(this.transition_table);
+  }
+
+  update()
+  {
+    this.transition_handler.update();
+  }
+
+  go_to_view(view_name, change_url = true, skip = false)
+  {
+    let v = this.get(view_name);
+    this.transition_handler.go_to_state(v, skip);
+
+    if (change_url)
+    {
+      this.__change_browser_url(v.url);
+    }
+  }
+
+  register_view(view)
+  {
+    this.views.push(view);
+  }
+
+  has_view(view_name)
+  {
+    for (let i = 0; i < this.views.length; i++)
+    {
+      if (this.views[i].name === view_name)
+      {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  add_transitions(transitions)
+  {
+    this.transition_table.add_transitions(transitions);
+  }
+
+  set_transitions(transitions)
+  {
+    this.transition_table.set_transitions(transitions);
+  }
+
+  set_view(view_name)
+  {
+    let view = this.get(view_name);
+
+    this.transition_handler.set_state(view);
+  }
+
+  get_current_view()
+  {
+    return this.transition_handler.current_state;
+  }
+
+  get_view_by_name(view_name)
+  {
+    console.warn('DEPRECATED. Use ViewManager.get instead');
+    this.get(view_name);
+  }
+
+  get(view_name)
+  {
+    for (let i = 0; i < this.views.length; i++)
+    {
+      if (this.views[i].name === view_name)
+      {
+        return this.views[i];
+      }
+    }
+    console.error('[ViewManager.get] no view found for: ', view_name);
+    return undefined;
+  }
+
+  get_view_by_url(url)
+  {
+    console.warn('DEPRECATED. Use ViewManager.get_by_url instead');
+    this.get_by_url(url);
+  }
+
+  get_by_url(url)
+  {
+    for (let i = 0; i < this.views.length; i++)
+    {
+      if (this.views[i].url === url)
+      {
+        return this.views[i];
+      }
+    }
+    console.error('[ViewManager.get_by_url] no view found for: ', url);
+    return undefined;
+  }
+
+  set_initial_state_data(initial_state_data)
+  {
+    this.transition_table.set_initial_state_data(initial_state_data);
+    this.transition_handler.set_initial_state_data(initial_state_data);
+  }
+
+  __change_browser_url(url)
+  {
+    window.history.pushState('', '', url);
+  }
+}
+
+export default new ViewManager();

package/src/view_components/ViewState.js

@@ -0,0 +1,54 @@
+export default class ViewState
+{
+  constructor(name)
+  {
+    this.name = name;
+  }
+
+  start()
+  {
+  }
+
+  show()
+  {
+  }
+
+  hide()
+  {
+  }
+
+  before_enter()
+  {
+  }
+
+  on_enter()
+  {
+  }
+
+  update()
+  {
+  }
+
+  update_enter_transition(global_view_data, transition_progress, action_sequencer)
+  {
+    // Backward compatibility. It will be removed in future releases.
+    this.update_transition(global_view_data, transition_progress, action_sequencer);
+  }
+
+  update_exit_transition(global_view_data, transition_progress, action_sequencer)
+  {
+  }
+
+  // Deprecated
+  update_transition(global_view_data, transition_progress, action_sequencer)
+  {
+  }
+
+  before_exit()
+  {
+  }
+
+  on_exit()
+  {
+  }
+}

package/src/view_components/transition/ActionSequencerBuilder.js

@@ -0,0 +1,91 @@
+import ActionSequencer from '../../action_sequencer/ActionSequencer';
+import NumberInterpolator from '../../action_sequencer/NumberInterpolator';
+import ActionEvent from '../../action_sequencer/ActionEvent';
+import DrawIOAnimationSheet from './DrawIOAnimationSheet';
+
+export default class ActionSequencerBuilder
+{
+  constructor(initial_state_data)
+  {
+    this.initial_state_data = initial_state_data;
+  }
+
+  from_animation_sheet(animation_data, current_context, initial_context)
+  {
+    initial_context = initial_context || this.initial_state_data;
+    let tracks = animation_data.animation_tracks;
+    let triggers = animation_data.triggers;
+
+    let initial_tracks = this.state_to_tracks(this.initial_state_data);
+
+    for (let i = 0; i < initial_tracks.length; i++)
+    {
+      if (tracks.find(element => element.attribute_name === initial_tracks[i].attribute_name) === undefined)
+      {
+        tracks.push(initial_tracks[i]);
+      }
+    }
+
+    let sequencer = new ActionSequencer(current_context);
+
+    for (let i = 0; i < tracks.length; i++)
+    {
+      let t = tracks[i];
+      let interpolator = new NumberInterpolator(t.attribute_name, current_context[t.attribute_name], t.to_value, t.easing_function);
+      sequencer.add_action_interpolator(t.from_time, t.to_time, interpolator, true);
+    }
+
+    for (let i = 0; i < triggers.length; i++)
+    {
+      let t = triggers[i];
+      let action_event = new ActionEvent(t.name, t.method);
+      sequencer.add_action_event(t.at_time, action_event);
+    }
+
+    return sequencer;
+  }
+
+  state_to_tracks(state)
+  {
+    let tracks = [];
+
+    let keys = Object.keys(state);
+
+    for (let i = 0; i < keys.length; i++)
+    {
+      tracks.push({
+        attribute_name: keys[i],
+        from_time: 0,
+        to_time: 1,
+        to_value: state[keys[i]],
+        easing_function: 'ease_in_out_cubic'
+      });
+    }
+
+    return tracks;
+  }
+
+  from_draw_io(xml, context)
+  {
+    let transition_data = (new DrawIOAnimationSheet()).parse(xml);
+    let tracks = transition_data.animation_tracks;
+    let triggers = transition_data.triggers;
+    let sequencer = new ActionSequencer(context);
+
+    for (let i = 0; i < tracks.length; i++)
+    {
+      let t = tracks[i];
+      let interpolator = new NumberInterpolator(t.attribute_name, context[t.attribute_name], t.to_value, t.easing_function);
+      sequencer.add_action_interpolator(t.from_time, t.to_time, interpolator, true);
+    }
+
+    for (let i = 0; i < triggers.length; i++)
+    {
+      let t = triggers[i];
+      let action_event = new ActionEvent(t.name, t.method);
+      sequencer.add_action_event(t.at_time, action_event);
+    }
+
+    return sequencer;
+  }
+}

package/src/view_components/transition/DrawIOAnimationSheet.js

@@ -0,0 +1,90 @@
+export default class DrawIOAnimationSheet
+{
+  constructor()
+  {
+
+  }
+
+  parse(xml_document)
+  {
+    let doc = new DOMParser().parseFromString(xml_document, 'text/xml');
+
+    let animation_nodes = doc.querySelectorAll('mxGeometry');
+
+    let animation_tracks = [];
+    let triggers = [];
+
+    for (let i = 0; i < animation_nodes.length; i++)
+    {
+      let node = animation_nodes[i];
+      let parent_node = node.parentElement;
+      let data = parent_node.getAttribute('value');
+
+      let x_pos = this.get_node_x_position(node);
+
+      let from = x_pos / 100;
+      let duration = parseFloat(node.getAttribute('width')) / 100;
+
+      // is trigger
+      if (parent_node.getAttribute('style').includes('rhombus;'))
+      {
+        let split_data = data.split('.');
+        let trigger_name = split_data[0];
+        let trigger_method = split_data[1];
+
+        triggers.push({
+          name: trigger_name,
+          method: trigger_method,
+          at_time: from + duration * 0.5
+        });
+      }
+
+      let valid_element = parent_node.getAttribute('style').includes('rounded=0;') &&
+                           !parent_node.getAttribute('style').includes('text;');
+
+      if (valid_element && data !== '' && !data.includes(' '))
+      {
+        let split_data = data.split('=');
+
+        let attribute_name = split_data[0];
+
+        let value_data = split_data[1].split('--');
+        let to_value = parseFloat(value_data[0]);
+        let easing_function = value_data[1];
+
+        if (split_data.length !== 2)
+        {
+          console.error('DrawIO data is malformed:', data);
+        }
+
+        if (value_data.length !== 2)
+        {
+          console.error('DrawIO data is malformed:', data);
+        }
+
+        animation_tracks.push({
+          attribute_name: attribute_name,
+          from_time: from,
+          to_time: from + duration,
+          to_value: to_value,
+          easing_function: easing_function
+        });
+      }
+    }
+
+    animation_tracks.sort((a, b) =>
+    {
+      return a.from_time - b.from_time;
+    });
+    return {
+      animation_tracks: animation_tracks,
+      triggers: triggers
+    };
+  }
+
+  get_node_x_position(node)
+  {
+    let x_pos = node.getAttribute('x');
+    return x_pos === null ? 0 : parseFloat(x_pos);
+  }
+}

package/src/view_components/transition/TransitionTable.js

@@ -0,0 +1,44 @@
+import ActionSequencerBuilder from './ActionSequencerBuilder';
+
+export default class TransitionTable
+{
+  constructor()
+  {
+    this.transitions = [];
+    this.initial_state_data = {};
+  }
+
+  get(to_state, current_context)
+  {
+    for (let i = 0; i < this.transitions.length; i++)
+    {
+      if (this.transitions[i].to === to_state)
+      {
+        let action_sequencer = new ActionSequencerBuilder(this.initial_state_data).from_animation_sheet(this.transitions[i].data, current_context);
+
+        return action_sequencer;
+      }
+    }
+
+    console.error('TransitionTable.get no data found for: ', to_state);
+    return undefined;
+  }
+
+  add_transitions(transitions)
+  {
+    for (let i = 0; i < transitions.length; i++)
+    {
+      this.transitions.push(transitions[i]);
+    }
+  }
+
+  set_transitions(transitions)
+  {
+    this.transitions = transitions;
+  }
+
+  set_initial_state_data(initial_state_data)
+  {
+    this.initial_state_data = initial_state_data;
+  }
+}

package/src/view_components/transition/ViewStateTransitionHandler.js

@@ -0,0 +1,81 @@
+import Time from '../../Time';
+import ViewState from '../ViewState';
+
+export default class ViewStateTransitionHandler
+{
+  constructor(transition_table)
+  {
+    this.last_state = new ViewState();
+    this.current_state = new ViewState();
+
+    this.initial_state_data = {};
+    this.current_state_data = {};
+
+    this.transition_table = transition_table;
+
+    this.transitioning = false;
+  }
+
+  go_to_state(state, skip = false)
+  {
+    this.last_state = this.current_state;
+    this.current_state = state;
+
+    this.last_state.before_exit();
+    this.current_state.show();
+    this.current_state.before_enter();
+
+    this.action_sequencer = this.transition_table.get(this.current_state.name, this.current_state_data);
+    this.action_sequencer.play();
+
+    this.transitioning = true;
+
+    if (skip)
+    {
+      this.action_sequencer.skip();
+      this.update();
+    }
+  }
+
+  update()
+  {
+    if (this.transitioning)
+    {
+      this.action_sequencer.update(Time.delta_time);
+      this.last_state.update_exit_transition(this.current_state_data, this.action_sequencer.get_progress(), this.action_sequencer);
+      this.current_state.update_enter_transition(this.current_state_data, this.action_sequencer.get_progress(), this.action_sequencer);
+
+      if (this.action_sequencer.is_finished())
+      {
+        this.transitioning = false;
+
+        this.action_sequencer.update(Time.delta_time);
+        this.last_state.update_exit_transition(this.current_state_data, this.action_sequencer.get_progress(), this.action_sequencer);
+        this.current_state.update_enter_transition(this.current_state_data, this.action_sequencer.get_progress(), this.action_sequencer);
+
+        if (this.last_state.name !== this.current_state.name)
+        {
+          this.last_state.hide();
+        }
+
+        this.last_state.on_exit();
+        this.current_state.on_enter();
+      }
+    }
+    else
+    {
+      this.current_state.update();
+    }
+  }
+
+  set_state(state)
+  {
+    this.current_state = state;
+  }
+
+  set_initial_state_data(initial_state_data)
+  {
+    Object.assign(this.initial_state_data, initial_state_data);
+    Object.assign(this.current_state_data, initial_state_data);
+  }
+}

package/types/BaseApplication.d.ts

@@ -0,0 +1,8 @@
+export class BaseApplication {
+    on_post_start(): void;
+    on_enter(): void;
+    on_exit(): void;
+    update(): void;
+    on_post_render(): void;
+    on_pre_render(): void;
+}

package/types/CameraManager.d.ts

@@ -0,0 +1,8 @@
+import { Camera } from "three";
+
+export class CameraManager {
+    static init(): void;
+    static _current: Camera;
+    static set current(arg: Camera);
+    static get current(): Camera;
+}

package/types/Capabilities.d.ts

@@ -0,0 +1,6 @@
+export class Capabilities {
+    static init(): void;
+    static max_anisotropy: number;
+    static vertex_texture_sampler_available: boolean;
+    static fp_textures_available: boolean;
+}

package/types/Configuration.d.ts

@@ -0,0 +1,6 @@
+ export class Configuration {
+    static init(parameters?: {}): void;
+    static dpr: number;
+    static app: {};
+    static from_json(json: any): void;
+}

package/types/Debug.d.ts

@@ -0,0 +1,37 @@
+import { PerspectiveCamera } from "ohzi-core";
+import { AxisHelper } from "ohzi-core/types/components/AxisHelper";
+import { Arrow } from "ohzi-core/types/primitives/Arrow";
+import { Cube } from "ohzi-core/types/primitives/Cube";
+import { Sphere } from "ohzi-core/types/primitives/Sphere";
+
+export class Debug {
+    static init(): void;
+    static Vector3_one: any;
+    static Vector3_zero: any;
+    static canvas_renderer: any;
+    static display_texture_meshes: any[];
+    static ctx: any;
+    static scene: any;
+    static camera: PerspectiveCamera;
+    static draw_arrow(origin: any, dir: any, color?: number): Arrow
+    ;
+    static draw_axis(): AxisHelper;
+    static set_debug_RT(RT: any): void;
+    static rt_debug: any;
+    static draw_rectangle(position_2d: any, width: any, height: any, color: any): void;
+    static clear(): void;
+    static draw_line_2D(from: any, to: any, color: any): void;
+    static draw_line(points: any, color?: number): any;
+    static draw_cube(pos: any, size: any, color: any): Cube;
+    static draw_oriented_cube(from: any, to: any, height?: number, color?: string, depth?: number): Cube;
+    static draw_plane(width: any, height: any, color: any): any;
+    static draw_empty_cube(pos: any, size: any, color: any): any;
+    static draw_sphere(pos: any, size: any, color: any): Sphere;
+    static draw_point_array(input_points: any, open?: boolean, color?: number): any;
+    static draw_sphere_helper(sphere: any, color: any): any;
+    static draw_math_sphere(sphere: any): void;
+    static draw_bounding_box(bb: any): void;
+    static draw_curve(curve: any, options: any): void;
+    static draw_texture(tex: any, w: any, h: any): any;
+    static render(graphics: any): void;
+}

package/types/EventManager.d.ts

@@ -0,0 +1,42 @@
+export class EventManager {
+    static init(): void;
+    static queue: {};
+    static zoom_changed_evt: string;
+    static store_clickd_evt: string;
+    static point_selected_evt: string;
+    static config_changed: string;
+    static path_substep_completed: string;
+    static path_completed: string;
+    static go_to_store_requested_evt: string;
+    static resource_loaded_evt: string;
+    static service_clicked_evt: string;
+    static unit_pos_updated_evt: string;
+    static floor_changed_evt: string;
+    static on_enter_floor_navigation: string;
+    static on_exit_floor_navigation: string;
+    static on_enter_floor_selection: string;
+    static on_exit_floor_selection: string;
+    static on_enter_outside_navigation: string;
+    static on_exit_outside_navigation: string;
+    static step_selected_evt: string;
+    static fire(event: any, payload: any): void;
+    static on(event: any, callback: any): void;
+    static fire_zoom_changed(zoom: any): void;
+    static fire_store_selected(store_id: any): void;
+    static fire_point_selected(hit_data: any): void;
+    static fire_config_changed(): void;
+    static fire_path_substep_completed(step_number: any): void;
+    static fire_path_completed(): void;
+    static fire_step_selected(step_index: any): void;
+    static fire_go_to_store_requested(store_id: any): void;
+    static fire_resource_loaded(resource: any): void;
+    static fire_service_clicked(service: any): void;
+    static fire_unit_position_updated(unit_data: any): void;
+    static fire_floor_switched(floor_id: any): void;
+    static fire_on_enter_floor_navigation(state: any): void;
+    static fire_on_exit_floor_navigation(state: any): void;
+    static fire_on_enter_floor_selection(state: any): void;
+    static fire_on_exit_floor_selection(state: any): void;
+    static fire_on_enter_outside_navigation(state: any): void;
+    static fire_on_exit_outside_navigation(state: any): void;
+}