ohzi-core 10.6.7 → 11.0.0

package/src/resource_loader/AsyncTextureLoader.js

@@ -9,6 +9,8 @@ class AsyncTextureLoader extends AbstractLoader
   {
     super(resource_id, url, size);
 
+    this.original_url = '';
+
     this.colorSpaceConversion = colorSpaceConversion;
     this.premultiplyAlpha = premultiplyAlpha;
     this.flipY = flipY;
@@ -51,7 +53,7 @@ class AsyncTextureLoader extends AbstractLoader
 
       image.onerror = () =>
       {
-        console.error('Error loading texture. Maybe the resource is not an image?', this.url, this.original_url);
+        console.error('The source image could not be decoded.', this.original_url);
       };
     }
     else
@@ -93,9 +95,9 @@ class AsyncTextureLoader extends AbstractLoader
 
         this.__update_downloaded_bytes(1, 1);
         this.__loading_ended();
-      }).catch(function(e)
+      }).catch((e) =>
       {
-        console.error(e);
+        console.error(e, this.original_url);
       });
     }
     else

package/src/resource_loader/BasisLoader.js

@@ -1,7 +1,5 @@
 import { AbstractLoader } from './AbstractLoader';
 
-// import { sRGBEncoding } from 'three';
-
 class BasisLoader extends AbstractLoader
 {
   constructor(resource_id, url, loader, size)
@@ -17,8 +15,6 @@ class BasisLoader extends AbstractLoader
     {
       this.loader.load(this.url, (basis) =>
       {
-      // basis.encoding = sRGBEncoding;
-
         resource_container.set_resource(this.resource_id, this.url, basis);
 
         this.__update_downloaded_bytes(1, 1);

package/src/view_components/ApplicationView.js

@@ -1,5 +1,3 @@
-import { ResourceContainer } from '../ResourceContainer';
-import { HTMLUtilities } from '../utilities/HTMLUtilities';
 import { ViewManager } from './ViewManager';
 import { ViewState } from './ViewState';
 
@@ -12,22 +10,7 @@ class ApplicationView extends ViewState
     this.container = container;
     this.url = url;
 
-    let transition_data = ResourceContainer.get(`${name}_data`);
-
-    transition_data = transition_data || {
-      animation_tracks: [],
-      triggers: []
-    };
-
-    const transitions = [
-      {
-        to: name,
-        data: transition_data
-      }
-    ];
-
     ViewManager.register_view(this);
-    ViewManager.add_transitions(transitions);
   }
 
   show()
@@ -58,19 +41,9 @@ class ApplicationView extends ViewState
     this.container.classList.remove('before_exit');
   }
 
-  load_html_images()
-  {
-    HTMLUtilities.load_images(this.container);
-  }
-
-  load_html_videos()
-  {
-    HTMLUtilities.load_videos(this.container);
-  }
-
-  set_opacity(current_state_data)
+  set_opacity(opacity)
   {
-    this.container.style.opacity = current_state_data[`${this.name}_opacity`];
+    this.container.style.opacity = opacity;
   }
 }
 

package/src/view_components/ApplicationViewController.js

@@ -0,0 +1,95 @@
+import { TransitionManager } from './TransitionManager';
+import { VCManager } from './VCManager';
+import { ViewState } from './ViewState';
+import { WorkerToMain } from './WorkerToMain';
+
+class ApplicationViewController extends ViewState
+{
+  constructor({ name, url, transition_data })
+  {
+    super(name);
+
+    this.url = url;
+
+    transition_data = transition_data || {
+      animation_tracks: [],
+      triggers: []
+    };
+
+    const transitions = [
+      {
+        to: name,
+        data: transition_data
+      }
+    ];
+
+    this.current_opacity = 0;
+
+    VCManager.register_view_controller(this);
+    TransitionManager.add_transitions(transitions);
+  }
+
+  show()
+  {
+    WorkerToMain.push(`${this.name}_view.show`);
+  }
+
+  before_enter()
+  {
+    WorkerToMain.push(`${this.name}_view.before_enter`);
+  }
+
+  on_enter()
+  {
+    WorkerToMain.push(`${this.name}_view.on_enter`);
+  }
+
+  before_exit()
+  {
+    WorkerToMain.push(`${this.name}_view.before_exit`);
+  }
+
+  on_exit()
+  {
+    WorkerToMain.push(`${this.name}_view.on_exit`);
+  }
+
+  hide()
+  {
+    WorkerToMain.push(`${this.name}_view.hide`);
+  }
+
+  update()
+  {
+    WorkerToMain.push(`${this.name}_view.update`);
+  }
+
+  fixed_update()
+  {
+    // TODO: Evaluate if a fixed update is necessary on the main thread
+  }
+
+  update_enter_transition(global_view_data, transition_progress, action_sequencer)
+  {
+    WorkerToMain.push(`${this.name}_view.update_enter_transition`, [global_view_data, transition_progress]);
+  }
+
+  update_exit_transition(global_view_data, transition_progress, action_sequencer)
+  {
+    WorkerToMain.push(`${this.name}_view.update_exit_transition`, [global_view_data, transition_progress]);
+  }
+
+  set_opacity(current_state_data)
+  {
+    const opacity = current_state_data[`${this.name}_opacity`];
+
+    if (this.current_opacity > opacity || this.current_opacity < opacity)
+    {
+      this.current_opacity = opacity;
+
+      WorkerToMain.push(`${this.name}_view.set_opacity`, [opacity]);
+    }
+  }
+}
+
+export { ApplicationViewController };

package/src/view_components/TransitionManager.js

@@ -0,0 +1,60 @@
+import { TransitionTable } from './transition/TransitionTable';
+import { ViewStateTransitionHandler } from './transition/ViewStateTransitionHandler';
+
+class TransitionManager
+{
+  constructor()
+  {
+    this.transition_table = new TransitionTable();
+    this.transition_handler = new ViewStateTransitionHandler(this.transition_table);
+  }
+
+  get action_sequencer()
+  {
+    return this.transition_handler.action_sequencer;
+  }
+
+  get current_state_data()
+  {
+    return this.transition_handler.current_state_data;
+  }
+
+  before_update()
+  {
+    this.transition_handler.before_update();
+  }
+
+  update()
+  {
+    this.transition_handler.update();
+  }
+
+  fixed_update()
+  {
+    this.transition_handler.fixed_update();
+  }
+
+  add_transitions(transitions)
+  {
+    this.transition_table.add_transitions(transitions);
+  }
+
+  set_transitions(transitions)
+  {
+    this.transition_table.set_transitions(transitions);
+  }
+
+  set_default_state_data(default_state_data)
+  {
+    this.transition_table.set_default_state_data(default_state_data);
+    this.transition_handler.set_default_state_data(default_state_data);
+  }
+
+  set_transitions_velocity(transitions_velocity)
+  {
+    this.transition_table.set_transitions_velocity(transitions_velocity);
+  }
+}
+
+const transition_manager = new TransitionManager();
+export { transition_manager as TransitionManager };

package/src/view_components/VCManager.js

@@ -0,0 +1,9 @@
+import { ViewControllerManager } from './ViewControllerManager';
+
+// Formerly ViewControllerManager
+class VCManager extends ViewControllerManager
+{
+}
+
+const v_c_manager = new VCManager();
+export { v_c_manager as VCManager };

package/src/view_components/ViewComponent.js

@@ -1,4 +1,3 @@
-import { HTMLUtilities } from '../utilities/HTMLUtilities';
 import { ViewComponentManager } from './ViewComponentManager';
 
 class ViewComponent
@@ -7,7 +6,8 @@ class ViewComponent
   {
     this.name = name;
     this.container = container;
-    this.hidden = true;
+
+    // this.hidden = true;
 
     ViewComponentManager.register_component(this);
   }
@@ -19,9 +19,10 @@ class ViewComponent
   on_enter()
   {
     this.container.classList.remove('hidden');
-    ViewComponentManager.enable_component(this);
 
-    this.hidden = false;
+    // this.hidden = false;
+
+    ViewComponentManager.enable_component(this);
   }
 
   update()
@@ -31,43 +32,15 @@ class ViewComponent
   on_exit()
   {
     this.container.classList.add('hidden');
-    ViewComponentManager.disable_component(this);
-
-    this.hidden = true;
-  }
 
-  set_opacity(current_state_data)
-  {
-    this.container.style.opacity = current_state_data[`${this.name}_opacity`];
-    this.toggle_hidden();
-  }
+    // this.hidden = true;
 
-  toggle_hidden()
-  {
-    if (this.container.style.opacity > 0.001)
-    {
-      if (this.hidden)
-      {
-        this.on_enter();
-      }
-    }
-    else
-    {
-      if (!this.hidden)
-      {
-        this.on_exit();
-      }
-    }
-  }
-
-  load_html_images()
-  {
-    HTMLUtilities.load_images(this.container);
+    ViewComponentManager.disable_component(this);
   }
 
-  load_html_videos()
+  set_opacity(opacity)
   {
-    HTMLUtilities.load_videos(this.container);
+    this.container.style.opacity = opacity;
   }
 }
 

package/src/view_components/ViewComponentController.js

@@ -0,0 +1,73 @@
+import { ViewComponentControllerManager } from './ViewComponentControllerManager';
+import { WorkerToMain } from './WorkerToMain';
+
+class ViewComponentController
+{
+  constructor({ name })
+  {
+    this.name = name;
+
+    this.current_opacity = 0;
+    this.hidden = true;
+
+    ViewComponentControllerManager.register_component_controller(this);
+  }
+
+  start()
+  {
+  }
+
+  on_enter()
+  {
+    ViewComponentControllerManager.enable_component_controller(this);
+    WorkerToMain.push(`${this.name}_component.on_enter`);
+
+    this.hidden = false;
+  }
+
+  update()
+  {
+    WorkerToMain.push(`${this.name}_component.update`);
+  }
+
+  on_exit()
+  {
+    ViewComponentControllerManager.disable_component_controller(this);
+    WorkerToMain.push(`${this.name}_component.on_exit`);
+
+    this.hidden = true;
+  }
+
+  set_opacity(current_state_data)
+  {
+    const opacity = current_state_data[`${this.name}_opacity`];
+
+    if (this.current_opacity > opacity || this.current_opacity < opacity)
+    {
+      this.current_opacity = opacity;
+
+      WorkerToMain.push(`${this.name}_component.set_opacity`, [opacity]);
+      this.toggle_hidden();
+    }
+  }
+
+  toggle_hidden()
+  {
+    if (this.current_opacity > 0.0001)
+    {
+      if (this.hidden)
+      {
+        this.on_enter();
+      }
+    }
+    else
+    {
+      if (!this.hidden)
+      {
+        this.on_exit();
+      }
+    }
+  }
+}
+
+export { ViewComponentController };

package/src/view_components/ViewComponentControllerManager.js

@@ -0,0 +1,59 @@
+import { TransitionManager } from './TransitionManager';
+
+class ViewComponentControllerManager
+{
+  constructor()
+  {
+    this.component_controllers = [];
+    this.enabled_component_controllers = new Set();
+  }
+
+  update()
+  {
+    this.__set_component_controllers_opacities();
+
+    for (const component_controller of this.enabled_component_controllers)
+    {
+      component_controller.update(TransitionManager.current_state_data);
+    }
+  }
+
+  register_component_controller(component_controller)
+  {
+    this.component_controllers.push(component_controller);
+  }
+
+  enable_component_controller(component_controller)
+  {
+    this.enabled_component_controllers.add(component_controller);
+  }
+
+  disable_component_controller(component_controller)
+  {
+    this.enabled_component_controllers.delete(component_controller);
+  }
+
+  get(component_name)
+  {
+    for (let i = 0; i < this.component_controllers.length; i++)
+    {
+      if (this.component_controllers[i].name === component_name)
+      {
+        return this.component_controllers[i];
+      }
+    }
+    console.error('[ViewComponentControllerManager.get] no component_controller found for: ', component_name);
+    return undefined;
+  }
+
+  __set_component_controllers_opacities()
+  {
+    for (let i = 0; i < this.component_controllers.length; i++)
+    {
+      this.component_controllers[i].set_opacity(TransitionManager.current_state_data);
+    }
+  }
+}
+
+const view_component_contorller_manager = new ViewComponentControllerManager();
+export { view_component_contorller_manager as ViewComponentControllerManager };

package/src/view_components/ViewComponentManager.js

@@ -1,4 +1,4 @@
-import { ViewManager } from './ViewManager';
+import { TransitionManager } from './TransitionManager';
 
 class ViewComponentManager
 {
@@ -14,7 +14,7 @@ class ViewComponentManager
 
     for (const component of this.enabled_components)
     {
-      component.update(ViewManager.transition_handler.current_state_data);
+      component.update(TransitionManager.current_state_data);
     }
   }
 
@@ -25,24 +25,14 @@ class ViewComponentManager
 
   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++)
@@ -60,7 +50,7 @@ class ViewComponentManager
   {
     for (let i = 0; i < this.components.length; i++)
     {
-      this.components[i].set_opacity(ViewManager.transition_handler.current_state_data);
+      this.components[i].set_opacity(TransitionManager.current_state_data);
     }
   }
 }

package/src/view_components/ViewControllerManager.js

@@ -0,0 +1,91 @@
+import { TransitionManager } from './TransitionManager';
+
+class ViewControllerManager
+{
+  constructor()
+  {
+    this.view_controllers = [];
+  }
+
+  go_to_view_controller(view_controller_name, skip = false)
+  {
+    const v = this.get(view_controller_name);
+    TransitionManager.transition_handler.go_to_state(v, skip);
+  }
+
+  update()
+  {
+    this.__set_view_controllers_opacities();
+  }
+
+  register_view_controller(view_controller)
+  {
+    this.view_controllers.push(view_controller);
+  }
+
+  set_view_controller(view_controller_name)
+  {
+    const view_controller = this.get(view_controller_name);
+
+    TransitionManager.transition_handler.set_state(view_controller);
+  }
+
+  get_current_view_controller()
+  {
+    return TransitionManager.transition_handler.current_state;
+  }
+
+  get(view_controller_name)
+  {
+    for (let i = 0; i < this.view_controllers.length; i++)
+    {
+      if (this.view_controllers[i].name === view_controller_name)
+      {
+        return this.view_controllers[i];
+      }
+    }
+    console.error('[ViewControllerManager.get] no view controller found for: ', view_controller_name);
+    return undefined;
+  }
+
+  // get_by_url(url)
+  // {
+  //   for (let i = 0; i < this.view_controllers.length; i++)
+  //   {
+  //     if (this.view_controllers[i].url === url)
+  //     {
+  //       return this.view_controllers[i];
+  //     }
+  //   }
+  //   console.error('[ViewControllerManager.get_by_url] no view controller found for: ', url);
+  //   return undefined;
+  // }
+
+  __set_view_controllers_opacities()
+  {
+    for (let i = 0; i < this.view_controllers.length; i++)
+    {
+      this.view_controllers[i].set_opacity(TransitionManager.transition_handler.current_state_data);
+    }
+  }
+
+  __capitalize(string)
+  {
+    let aux_string = string.toUpperCase().replace('/', '');
+    aux_string = this.__snake_to_whitespace(aux_string);
+
+    return aux_string;
+  }
+
+  __snake_to_whitespace(string)
+  {
+    return string.replace(
+      /([-_][A-Z])/g,
+      (group) => group
+        .replace('-', ' ')
+        .replace('_', ' ')
+    );
+  }
+}
+
+export { ViewControllerManager };