r3-v2/dist/r3.js

class R3 {
  static version = '2.0.784';
  static compileDate = '2021 Sep 19 - 21:28:13 pm';
}

class Runtime {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    Object.assign(this, options);

  }

}

Runtime.BASE_CODER = 0x0;
Runtime.BASE_DOM = 0x1;
Runtime.BASE_GUI = 0x2;
Runtime.BASE_GRAPHICS = 0x3;
Runtime.BASE_IMAGE = 0x4;
Runtime.BASE_PHYSICS = 0x5;
Runtime.BASE_SOCKET = 0x6;
Runtime.BASE_STATISTICS = 0x7;
Runtime.CODE_MIRROR = 0x8;
Runtime.DOCUMENT = 0x9;
Runtime.CONTROL_KIT = 0xa;
Runtime.THREE = 0xb;
Runtime.NODE_JS_IMAGE = 0xc;
Runtime.WEB_IMAGE = 0xd;
Runtime.BULLET = 0xe;
Runtime.STATS = 0xf;

class RuntimeCoder extends Runtime {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);
  }

}

/**

  Class R3.Runtime.Coder.CodeMirror
  [Inherited from Runtime]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from RuntimeCoder]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to RuntimeCodeMirror]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class RuntimeCodeMirror extends RuntimeCoder {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);

  }

  /**
   * buildInstance()
   * - Creates a runtime instance object based on the R3.Component representing it. 
   * @param component 
   */
  buildInstance(component) {

  }

}

class RuntimeDOM extends Runtime {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);
  }

}

/**

  Class R3.Runtime.DOM.Document
  [Inherited from Runtime]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from RuntimeDOM]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to RuntimeDocument]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class RuntimeDocument extends RuntimeDOM {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);

  }

  /**
   * buildInstance()
   * - Creates a runtime instance object based on the R3.Component representing it. 
   * @param component 
   */
  buildInstance(component) {

    if (component instanceof R3.Component.DOM.Canvas) {
      let canvas = document.createElement('canvas');
      canvas.setAttribute('width', component.width);
      canvas.setAttribute('height', component.height);
      canvas.setAttribute('style', component.style);
      return canvas;
    }

  }

}

class RuntimeGUI extends Runtime {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);
  }

}

/**

  Class R3.Runtime.GUI.ControlKit
  [Inherited from Runtime]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from RuntimeGUI]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to RuntimeControlKit]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class RuntimeControlKit extends RuntimeGUI {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);

  }

  /**
   * buildInstance()
   * - Creates a runtime instance object based on the R3.Component representing it. 
   * @param component 
   */
  buildInstance(component) {

  }

}

class RuntimeGraphics extends Runtime {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);
  }

}

/**

  Class R3.Runtime.Graphics.Three
  [Inherited from Runtime]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from RuntimeGraphics]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to RuntimeThree]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class RuntimeThree extends RuntimeGraphics {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);

  }

  /**
   * buildInstance()
   * - Creates a runtime instance object based on the R3.Component representing it. 
   * @param component 
   */
  buildInstance(component) {

  }

}

class RuntimeImage extends Runtime {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);
  }

}

/**

  Class R3.Runtime.Image.NodeJSImage
  [Inherited from Runtime]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from RuntimeImage]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to RuntimeNodeJSImage]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class RuntimeNodeJSImage extends RuntimeImage {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);

  }

  /**
   * buildInstance()
   * - Creates a runtime instance object based on the R3.Component representing it. 
   * @param component 
   */
  buildInstance(component) {

  }

}

/**

  Class R3.Runtime.Image.WebImage
  [Inherited from Runtime]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from RuntimeImage]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to RuntimeWebImage]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class RuntimeWebImage extends RuntimeImage {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);

  }

  /**
   * buildInstance()
   * - Creates a runtime instance object based on the R3.Component representing it. 
   * @param component 
   */
  buildInstance(component) {

    if (component instanceof R3.Component.Graphics.Image) {
      let image = document.createElement('img');
      image.setAttribute('src', component.src);
      image.setAttribute('alt', component.alt);
      return image;
    }

  }

}

class RuntimePhysics extends Runtime {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);
  }

}

/**

  Class R3.Runtime.Physics.Bullet
  [Inherited from Runtime]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from RuntimePhysics]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to RuntimeBullet]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class RuntimeBullet extends RuntimePhysics {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);

  }

  /**
   * buildInstance()
   * - Creates a runtime instance object based on the R3.Component representing it. 
   * @param component 
   */
  buildInstance(component) {

  }

}

class RuntimeSocket extends Runtime {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);
  }

}

class RuntimeStatistics extends Runtime {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);
  }

}

/**

  Class R3.Runtime.Statistics.Stats
  [Inherited from Runtime]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from RuntimeStatistics]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to RuntimeStats]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class RuntimeStats extends RuntimeStatistics {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);

  }

  /**
   * buildInstance()
   * - Creates a runtime instance object based on the R3.Component representing it. 
   * @param component 
   */
  buildInstance(component) {

  }

}

class System {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    Object.assign(this, options);

  }

}

System.DOM = 0x0;
System.INPUT = 0x1;
System.LINKING = 0x2;
System.RENDER = 0x3;
System.RUNTIME = 0x4;
System.SOCKET = 0x5;
System.STORAGE = 0x6;
System.MAX_SYSTEM = 0x7;

/**

  Class R3.System.DOM
  [Inherited from System]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to SystemDOM]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class SystemDOM extends System {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);

  }

  /**
   * Start()
   * - Starts the system by registering subscriptions to events 
   * @param options 
   */
  static Start(options) {

    SystemDOM.Subscriptions['DOM_COMPONENT_INITIALIZED'] = Event.Subscribe(
      Event.DOM_COMPONENT_INITIALIZED,
      SystemDOM.OnDomComponentInitialized
    );

    SystemDOM.Started = true;

    console.log('Started system: SystemDOM');

  }

  /**
   * Stop()
   * - Stops the system by removing these subscriptions to events 
   * @param options 
   */
  static Stop(options) {

    SystemDOM.Subscriptions['DOM_COMPONENT_INITIALIZED'].remove();
    delete SystemDOM.Subscriptions['DOM_COMPONENT_INITIALIZED'];

    SystemDOM.Started = false;

    console.log('Stopped system: SystemDOM');

  }

  /**
   * OnDomComponentInitialized()
   * - Listens to events of type Event.DOM_COMPONENT_INITIALIZED and executes this function. 
   * @param object (The event data passed as argument - typically an R3Object) 
   * @return null
   */
  static OnDomComponentInitialized(object) {

  }

}

/**
 * static Started - Indicates whether or not this system is running or not
 */
SystemDOM.Started = false;

/**
 * static Subscriptions - An association object which hold the subscription handles for Events this system is listening
 * to. The system can stop receiving events by calling remove() on a handle.
 */
SystemDOM.Subscriptions = {};

/**

  Class R3.System.Input
  [Inherited from System]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to SystemInput]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class SystemInput extends System {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);

  }

  /**
   * Start()
   * - Starts the system by registering subscriptions to events 
   * @param options 
   */
  static Start(options) {

    SystemInput.Subscriptions['TOUCH_START'] = Event.Subscribe(
      Event.TOUCH_START,
      SystemInput.OnTouchStart
    );

    SystemInput.Subscriptions['TOUCH_END'] = Event.Subscribe(
      Event.TOUCH_END,
      SystemInput.OnTouchEnd
    );

    SystemInput.Subscriptions['TOUCH_MOVE'] = Event.Subscribe(
      Event.TOUCH_MOVE,
      SystemInput.OnTouchMove
    );

    SystemInput.Subscriptions['TOUCH_CANCEL'] = Event.Subscribe(
      Event.TOUCH_CANCEL,
      SystemInput.OnTouchCancel
    );

    SystemInput.Subscriptions['KEYBOARD_DOWN'] = Event.Subscribe(
      Event.KEYBOARD_DOWN,
      SystemInput.OnKeyboardDown
    );

    SystemInput.Subscriptions['KEYBOARD_UP'] = Event.Subscribe(
      Event.KEYBOARD_UP,
      SystemInput.OnKeyboardUp
    );

    SystemInput.Subscriptions['MOUSE_DOWN'] = Event.Subscribe(
      Event.MOUSE_DOWN,
      SystemInput.OnMouseDown
    );

    SystemInput.Subscriptions['MOUSE_UP'] = Event.Subscribe(
      Event.MOUSE_UP,
      SystemInput.OnMouseUp
    );

    SystemInput.Subscriptions['MOUSE_MOVE'] = Event.Subscribe(
      Event.MOUSE_MOVE,
      SystemInput.OnMouseMove
    );

    SystemInput.Subscriptions['MOUSE_WHEEL'] = Event.Subscribe(
      Event.MOUSE_WHEEL,
      SystemInput.OnMouseWheel
    );

    SystemInput.Started = true;

    console.log('Started system: SystemInput');

  }

  /**
   * Stop()
   * - Stops the system by removing these subscriptions to events 
   * @param options 
   */
  static Stop(options) {

    SystemInput.Subscriptions['TOUCH_START'].remove();
    delete SystemInput.Subscriptions['TOUCH_START'];

    SystemInput.Subscriptions['TOUCH_END'].remove();
    delete SystemInput.Subscriptions['TOUCH_END'];

    SystemInput.Subscriptions['TOUCH_MOVE'].remove();
    delete SystemInput.Subscriptions['TOUCH_MOVE'];

    SystemInput.Subscriptions['TOUCH_CANCEL'].remove();
    delete SystemInput.Subscriptions['TOUCH_CANCEL'];

    SystemInput.Subscriptions['KEYBOARD_DOWN'].remove();
    delete SystemInput.Subscriptions['KEYBOARD_DOWN'];

    SystemInput.Subscriptions['KEYBOARD_UP'].remove();
    delete SystemInput.Subscriptions['KEYBOARD_UP'];

    SystemInput.Subscriptions['MOUSE_DOWN'].remove();
    delete SystemInput.Subscriptions['MOUSE_DOWN'];

    SystemInput.Subscriptions['MOUSE_UP'].remove();
    delete SystemInput.Subscriptions['MOUSE_UP'];

    SystemInput.Subscriptions['MOUSE_MOVE'].remove();
    delete SystemInput.Subscriptions['MOUSE_MOVE'];

    SystemInput.Subscriptions['MOUSE_WHEEL'].remove();
    delete SystemInput.Subscriptions['MOUSE_WHEEL'];

    SystemInput.Started = false;

    console.log('Stopped system: SystemInput');

  }

  /**
   * OnTouchStart()
   * - Listens to events of type Event.TOUCH_START and executes this function. 
   * @param object (The event data passed as argument - typically an R3Object) 
   * @return null
   */
  static OnTouchStart(object) {

  }

  /**
   * OnTouchEnd()
   * - Listens to events of type Event.TOUCH_END and executes this function. 
   * @param object (The event data passed as argument - typically an R3Object) 
   * @return null
   */
  static OnTouchEnd(object) {

  }

  /**
   * OnTouchMove()
   * - Listens to events of type Event.TOUCH_MOVE and executes this function. 
   * @param object (The event data passed as argument - typically an R3Object) 
   * @return null
   */
  static OnTouchMove(object) {

  }

  /**
   * OnTouchCancel()
   * - Listens to events of type Event.TOUCH_CANCEL and executes this function. 
   * @param object (The event data passed as argument - typically an R3Object) 
   * @return null
   */
  static OnTouchCancel(object) {

  }

  /**
   * OnKeyboardDown()
   * - Listens to events of type Event.KEYBOARD_DOWN and executes this function. 
   * @param object (The event data passed as argument - typically an R3Object) 
   * @return null
   */
  static OnKeyboardDown(object) {

  }

  /**
   * OnKeyboardUp()
   * - Listens to events of type Event.KEYBOARD_UP and executes this function. 
   * @param object (The event data passed as argument - typically an R3Object) 
   * @return null
   */
  static OnKeyboardUp(object) {

  }

  /**
   * OnMouseDown()
   * - Listens to events of type Event.MOUSE_DOWN and executes this function. 
   * @param object (The event data passed as argument - typically an R3Object) 
   * @return null
   */
  static OnMouseDown(object) {

  }

  /**
   * OnMouseUp()
   * - Listens to events of type Event.MOUSE_UP and executes this function. 
   * @param object (The event data passed as argument - typically an R3Object) 
   * @return null
   */
  static OnMouseUp(object) {

  }

  /**
   * OnMouseMove()
   * - Listens to events of type Event.MOUSE_MOVE and executes this function. 
   * @param object (The event data passed as argument - typically an R3Object) 
   * @return null
   */
  static OnMouseMove(object) {

  }

  /**
   * OnMouseWheel()
   * - Listens to events of type Event.MOUSE_WHEEL and executes this function. 
   * @param object (The event data passed as argument - typically an R3Object) 
   * @return null
   */
  static OnMouseWheel(object) {

  }

}

/**
 * static Started - Indicates whether or not this system is running or not
 */
SystemInput.Started = false;

/**
 * static Subscriptions - An association object which hold the subscription handles for Events this system is listening
 * to. The system can stop receiving events by calling remove() on a handle.
 */
SystemInput.Subscriptions = {};

/**

  Class R3.System.Linking
  [Inherited from System]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to SystemLinking]

  Properties:

    <no properties>

  Static Properties:

    - BlacklistedComponents (Default value [] - A list of component constructors which should not be
      permitted to create instances immediately)

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class SystemLinking extends System {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);

  }

  /**
   * Start()
   * - Starts the system by registering subscriptions to events 
   * @param options 
   */
  static Start(options) {

    SystemLinking.Subscriptions['OBJECT_CREATED'] = Event.Subscribe(
      Event.OBJECT_CREATED,
      SystemLinking.OnObjectCreated
    );

    SystemLinking.Subscriptions['OBJECT_INITIALIZED'] = Event.Subscribe(
      Event.OBJECT_INITIALIZED,
      SystemLinking.OnObjectInitialized
    );

    SystemLinking.Subscriptions['INSTANCE_CREATED'] = Event.Subscribe(
      Event.INSTANCE_CREATED,
      SystemLinking.OnInstanceCreated
    );

    SystemLinking.Subscriptions['CREATE_INSTANCE_BEFORE'] = Event.Subscribe(
      Event.CREATE_INSTANCE_BEFORE,
      SystemLinking.OnCreateInstanceBefore
    );

    SystemLinking.Started = true;

    console.log('Started system: SystemLinking');

  }

  /**
   * Stop()
   * - Stops the system by removing these subscriptions to events 
   * @param options 
   */
  static Stop(options) {

    SystemLinking.Subscriptions['OBJECT_CREATED'].remove();
    delete SystemLinking.Subscriptions['OBJECT_CREATED'];

    SystemLinking.Subscriptions['OBJECT_INITIALIZED'].remove();
    delete SystemLinking.Subscriptions['OBJECT_INITIALIZED'];

    SystemLinking.Subscriptions['INSTANCE_CREATED'].remove();
    delete SystemLinking.Subscriptions['INSTANCE_CREATED'];

    SystemLinking.Subscriptions['CREATE_INSTANCE_BEFORE'].remove();
    delete SystemLinking.Subscriptions['CREATE_INSTANCE_BEFORE'];

    SystemLinking.Started = false;

    console.log('Stopped system: SystemLinking');

  }

  /**
   * OnObjectCreated()
   * - Listens to events of type OBJECT_CREATED and executes this function.  
   * @param object (The event data passed as argument - typically an R3Object) 
   * @return 
   */
  static OnObjectCreated(object) {

    console.log('object created');

  }

  /**
   * OnObjectInitialized()
   * - Listens to events of type OBJECT_INITIALIZED and executes this function.  
   * @param object (The event data passed as argument - typically an R3Object) 
   * @return 
   */
  static OnObjectInitialized(object) {

    console.log('object initialized');

  }

  /**
   * OnInstanceCreated()
   * - Listens to events of type INSTANCE_CREATED and executes this function.  
   * @param object (The event data passed as argument - typically an R3Object) 
   * @return 
   */
  static OnInstanceCreated(object) {

    console.log('instance created');

  }

  /**
   * OnCreateInstanceBefore()
   * - Listens to events of type CREATE_INSTANCE_BEFORE and executes this function.  
   * @param object (The event data passed as argument - typically an R3Object) 
   * @return boolean delayInstance which indicates whether or not instance creation is delayed (handled) by
   *   another system. (i.e. where instance creation order is of importance)
   */
  static OnCreateInstanceBefore(object) {

    for (let i = 0; i < SystemLinking.BlacklistedComponents.length; i++) {
      if (object instanceof SystemLinking.BlacklistedComponents) {
        return true;
      }
    }

    return false;

  }

}

/**
 * static Started - Indicates whether or not this system is running or not
 */
SystemLinking.Started = false;

/**
 * static Subscriptions - An association object which hold the subscription handles for Events this system is listening
 * to. The system can stop receiving events by calling remove() on a handle.
 */
SystemLinking.Subscriptions = {};

/**
 * static BlacklistedComponents - A list of component constructors which should not be permitted to create instances immediately
 */
SystemLinking.BlacklistedComponents = [];

/**

  Class R3.System.Render
  [Inherited from System]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to SystemRender]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class SystemRender extends System {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);

  }

  /**
   * Start()
   * - Starts the system by registering subscriptions to events 
   * @param options 
   */
  static Start(options) {

    SystemRender.Subscriptions['INSTANCE_CREATED'] = Event.Subscribe(
      Event.INSTANCE_CREATED,
      SystemRender.OnInstanceCreated
    );

    SystemRender.Started = true;

    console.log('Started system: SystemRender');

  }

  /**
   * Stop()
   * - Stops the system by removing these subscriptions to events 
   * @param options 
   */
  static Stop(options) {

    SystemRender.Subscriptions['INSTANCE_CREATED'].remove();
    delete SystemRender.Subscriptions['INSTANCE_CREATED'];

    SystemRender.Started = false;

    console.log('Stopped system: SystemRender');

  }

  /**
   * OnInstanceCreated()
   * - Listens to events of type Event.INSTANCE_CREATED and executes this function. 
   * @param object (The event data passed as argument - typically an R3Object) 
   * @return null
   */
  static OnInstanceCreated(object) {

    if (object instanceof R3.Component.DOM) {
      if (object.runtime instanceof R3.Runtime.DOM.Document) {
        document.body.appendChild(object.instance);
      }
    }

    if (object instanceof R3.Component.Graphics.Image) {
      if (object.runtime instanceof R3.Runtime.Image.WebImage) {
        document.body.appendChild(object.instance);
      }
    }
    

  }

}

/**
 * static Started - Indicates whether or not this system is running or not
 */
SystemRender.Started = false;

/**
 * static Subscriptions - An association object which hold the subscription handles for Events this system is listening
 * to. The system can stop receiving events by calling remove() on a handle.
 */
SystemRender.Subscriptions = {};

/**

  Class R3.System.Runtime
  [Inherited from System]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to SystemRuntime]

  Properties:

    <no properties>

  Static Properties:

    - Projects (Default value [])
    - CurrentProject (Default value null)
    - RuntimeCoder (Default value {})
    - RuntimeDOM (Default value {})
    - RuntimeGUI (Default value {})
    - RuntimeGraphics (Default value {})
    - RuntimePhysics (Default value {})
    - RuntimeStatistics (Default value {})

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class SystemRuntime extends System {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);

  }

  /**
   * Start()
   * - Starts the system by registering subscriptions to events 
   * @param options 
   */
  static Start(options) {

    SystemRuntime.Subscriptions['GET_RUNTIME'] = Event.Subscribe(
      Event.GET_RUNTIME,
      SystemRuntime.OnGetRuntime
    );

    SystemRuntime.Subscriptions['PROJECT_INITIALIZED'] = Event.Subscribe(
      Event.PROJECT_INITIALIZED,
      SystemRuntime.OnProjectInitialized
    );

    SystemRuntime.Started = true;

    console.log('Started system: SystemRuntime');

  }

  /**
   * Stop()
   * - Stops the system by removing these subscriptions to events 
   * @param options 
   */
  static Stop(options) {

    SystemRuntime.Subscriptions['GET_RUNTIME'].remove();
    delete SystemRuntime.Subscriptions['GET_RUNTIME'];

    SystemRuntime.Subscriptions['PROJECT_INITIALIZED'].remove();
    delete SystemRuntime.Subscriptions['PROJECT_INITIALIZED'];

    SystemRuntime.Started = false;

    console.log('Stopped system: SystemRuntime');

  }

  /**
   * OnGetRuntime()
   * - Listens to events of type Event.GET_RUNTIME and executes this function. 
   * @param object (The event data passed as argument - typically an R3Object) 
   * @return null
   */
  static OnGetRuntime(object) {

    if (object instanceof R3.Component.DOM) {

      if (SystemRuntime.CurrentProject === null) {
        return new R3.Runtime.DOM.Document();
      } else {
        console.log('TODO: implement a project based DOM runtime');
      }
    }

    if (object instanceof R3.Image) {

      if (SystemRuntime.CurrentProject === null) {
        return new R3.Runtime.Image.WebImage();
      } else {
        console.log('TODO: implement a project based Image runtime');
      }
    }

  }

  /**
   * OnProjectInitialized()
   * - Listens to events of type Event.PROJECT_INITIALIZED and executes this function. 
   * @param object (The event data passed as argument - typically an R3Object) 
   * @return null
   */
  static OnProjectInitialized(object) {

    Utils.PushUnique(SystemRuntime.Projects, object);
    SystemRuntime.CurrentProject = object;

  }

}

/**
 * static Started - Indicates whether or not this system is running or not
 */
SystemRuntime.Started = false;

/**
 * static Subscriptions - An association object which hold the subscription handles for Events this system is listening
 * to. The system can stop receiving events by calling remove() on a handle.
 */
SystemRuntime.Subscriptions = {};

/**
 * static Projects - No comment
 */
SystemRuntime.Projects = [];

/**
 * static CurrentProject - No comment
 */
SystemRuntime.CurrentProject = null;

/**
 * static RuntimeCoder - No comment
 */
SystemRuntime.RuntimeCoder = {};

/**
 * static RuntimeDOM - No comment
 */
SystemRuntime.RuntimeDOM = {};

/**
 * static RuntimeGUI - No comment
 */
SystemRuntime.RuntimeGUI = {};

/**
 * static RuntimeGraphics - No comment
 */
SystemRuntime.RuntimeGraphics = {};

/**
 * static RuntimePhysics - No comment
 */
SystemRuntime.RuntimePhysics = {};

/**
 * static RuntimeStatistics - No comment
 */
SystemRuntime.RuntimeStatistics = {};

/**

  Class R3.System.Socket
  [Inherited from System]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to SystemSocket]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class SystemSocket extends System {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);

  }

  /**
   * Start()
   * - Starts the system by registering subscriptions to events 
   * @param options 
   */
  static Start(options) {

    SystemSocket.Started = true;

    console.log('Started system: SystemSocket');

  }

  /**
   * Stop()
   * - Stops the system by removing these subscriptions to events 
   * @param options 
   */
  static Stop(options) {

    SystemSocket.Started = false;

    console.log('Stopped system: SystemSocket');

  }

}

/**
 * static Started - Indicates whether or not this system is running or not
 */
SystemSocket.Started = false;

/**
 * static Subscriptions - An association object which hold the subscription handles for Events this system is listening
 * to. The system can stop receiving events by calling remove() on a handle.
 */
SystemSocket.Subscriptions = {};

/**

  Class R3.System.Storage
  [Inherited from System]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to SystemStorage]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class SystemStorage extends System {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    super(options);

    Object.assign(this, options);

  }

  /**
   * Start()
   * - Starts the system by registering subscriptions to events 
   * @param options 
   */
  static Start(options) {

    SystemStorage.Subscriptions['IMAGE_COMPONENT_INITIALIZED'] = Event.Subscribe(
      Event.IMAGE_COMPONENT_INITIALIZED,
      SystemStorage.OnImageComponentInitialized
    );

    SystemStorage.Started = true;

    console.log('Started system: SystemStorage');

  }

  /**
   * Stop()
   * - Stops the system by removing these subscriptions to events 
   * @param options 
   */
  static Stop(options) {

    SystemStorage.Subscriptions['IMAGE_COMPONENT_INITIALIZED'].remove();
    delete SystemStorage.Subscriptions['IMAGE_COMPONENT_INITIALIZED'];

    SystemStorage.Started = false;

    console.log('Stopped system: SystemStorage');

  }

  /**
   * OnImageComponentInitialized()
   * - Listens to events of type Event.IMAGE_COMPONENT_INITIALIZED and executes this function. 
   * @param object (The event data passed as argument - typically an R3Object) 
   * @return null
   */
  static OnImageComponentInitialized(object) {

  }

}

/**
 * static Started - Indicates whether or not this system is running or not
 */
SystemStorage.Started = false;

/**
 * static Subscriptions - An association object which hold the subscription handles for Events this system is listening
 * to. The system can stop receiving events by calling remove() on a handle.
 */
SystemStorage.Subscriptions = {};

class Event {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    Object.assign(this, options);

  }

  /**
   * async()
   * - Simply calls 'Async()' passing it the arguments 
   * @param eventId
   * @param data
   * @param clientCallback
   * @param clientErrorCallback 
   */
  async(
    eventId,
    data,
    clientCallback,
    clientErrorCallback
  ) {

		return Event.Async(
			eventId,
			data,
			clientCallback,
			clientErrorCallback
		);

  }

  /**
   * emit()
   * - Simply calls 'Emit()' passing it the arguments 
   * @param eventId
   * @param data
   * @param clientCallback
   * @param clientErrorCallback 
   */
  emit(
    eventId,
    data,
    clientCallback,
    clientErrorCallback
  ) {

		return Event.Emit(
			eventId,
			data,
			clientCallback,
			clientErrorCallback
		);

  }

  /**
   * subscribe()
   * - Simply calls 'Subscribe()' passing it the arguments 
   * @param eventId
   * @param callback 
   */
  subscribe(
    eventId,
    callback
  ) {

		return Event.Subscribe(eventId, callback.bind(this));

  }

  /**
   * Async()
   * - Calls all subscription functions registered to eventId with data, clientCallback and clientErrorCallback as
   *   arguments. If an error occurs during clientCallback it additionally will execute clientErrorCallback with the
   *   error as argument. 
   * @param eventId
   * @param data
   * @param clientCallback
   * @param clientErrorCallback 
   */
  static Async(
    eventId,
    data,
    clientCallback,
    clientErrorCallback
  ) {

		if (Event.Subscriptions.hasOwnProperty(eventId)) {

			let subscriptionIds = Object.keys(Event.Subscriptions[eventId]);

			subscriptionIds.map(
				function(subscriptionId) {
					try {
						Event.Subscriptions[eventId][subscriptionId](data, clientCallback, clientErrorCallback);
					} catch (error) {
						if (clientErrorCallback) {
							clientErrorCallback(error);
						} else {
							console.error(error);
							throw error;
						}
					}
				}
			)
		}

  }

  /**
   * Emit()
   * - Calls all subscription functions registered to eventId with data as arg. Calls clientCallback directly after
   *   the event result is obtained, passing it the result. If an exception occurs during execution, the
   *   clientErrorCallback is called with the error as argument. 
   * @param eventId
   * @param data
   * @param clientCallback
   * @param clientErrorCallback 
   */
  static Emit(
    eventId,
    data,
    clientCallback,
    clientErrorCallback
  ) {

		if (Event.Subscriptions.hasOwnProperty(eventId)) {

			let subscriptionIds = Object.keys(Event.Subscriptions[eventId]);

			subscriptionIds.map(
				function(subscriptionId) {
					try {
						let result = Event.Subscriptions[eventId][subscriptionId](data);

						if (clientCallback) {
							clientCallback(result);
						}
					} catch (error) {
						if (clientErrorCallback) {
							clientErrorCallback(error);
						} else {
							console.error(error);
							throw error;
						}
					}
				}
			)
		}

  }

  /**
   * Subscribe()
   * - Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised  
   * @param eventId
   * @param callback 
   * @returns {Object} - A handle to the subscription which can be removed by calling handle.remove()
   */
  static Subscribe(
    eventId,
    callback
  ) {

		let subscriptionId = Utils.RandomId(10);

		if (Event.Subscriptions.hasOwnProperty(eventId)) {

			if (Event.Subscriptions[eventId][subscriptionId]) {
				throw new Error('A component can only subscribe to a particular event ID once');
			}

			Event.Subscriptions[eventId][subscriptionId] = callback;

		} else {
			Event.Subscriptions[eventId] = {};
			Event.Subscriptions[eventId][subscriptionId] = callback;
		}

		/**
		 * Return a handle to the caller to allow us to unsubscribe to this event
		 */
		return {
			fn: callback,
			remove: function (eventId, subscriptionId) {

				return function () {

					/**
					 * Stop listening for this event from this component
					 */
					delete Event.Subscriptions[eventId][subscriptionId];

					/**
					 * If the length of listeners is 0, stop referencing this event
					 * @type {string[]}
					 */
					let listeners = Object.keys(Event.Subscriptions[eventId]);
					if (listeners.length === 0) {
						delete Event.Subscriptions[eventId];
					}

					return true;
				}

			}(eventId, subscriptionId),
			subscriptionId : subscriptionId
		};

  }

	/**
	 * Some nice Events handling
	 * @type {{}}
	 */
	static Subscriptions = {};

}

Event.BEFORE_RENDER = 0x1;
Event.COMPONENT_CREATED = 0x2;
Event.COMPONENT_INITIALIZED = 0x3;
Event.CREATE_INSTANCE_BEFORE = 0x4;
Event.DISPOSE_INSTANCE = 0x5;
Event.DISPOSE_OBJECT = 0x6;
Event.DOM_COMPONENT_INITIALIZED = 0x7;
Event.ENTITY_CREATED = 0x8;
Event.ENTITY_INITIALIZED = 0x9;
Event.GET_RUNTIME = 0xa;
Event.GET_WINDOW_SIZE = 0xb;
Event.GRAPHICS_COMPONENT_INITIALIZED = 0xc;
Event.IMAGE_COMPONENT_INITIALIZED = 0xd;
Event.IMAGE_INITIALIZED = 0xe;
Event.INPUT_COMPONENT_INITIALIZED = 0xf;
Event.INSTANCE_CREATED = 0x10;
Event.INSTANCE_DISPOSED = 0x11;
Event.KEYBOARD_DOWN = 0x12;
Event.KEYBOARD_UP = 0x13;
Event.MOUSE_DOWN = 0x14;
Event.MOUSE_MOVE = 0x15;
Event.MOUSE_UP = 0x16;
Event.MOUSE_WHEEL = 0x17;
Event.OBJECT_CREATED = 0x18;
Event.OBJECT_INITIALIZED = 0x19;
Event.PAUSE = 0x1a;
Event.PROJECT_INITIALIZED = 0x1b;
Event.RESTART = 0x1c;
Event.START = 0x1d;
Event.TOUCH_CANCEL = 0x1e;
Event.TOUCH_END = 0x1f;
Event.TOUCH_MOVE = 0x20;
Event.TOUCH_START = 0x21;
Event.UPDATE_FROM_INSTANCE_AFTER = 0x22;
Event.UPDATE_FROM_INSTANCE_BEFORE = 0x23;
Event.UPDATE_INSTANCE_AFTER = 0x24;
Event.UPDATE_INSTANCE_BEFORE = 0x25;
Event.UPDATE_INSTANCE_PROPERTY = 0x26;
Event.UPDATE_PROPERTY_FROM_INSTANCE = 0x27;
Event.MAX_EVENTS = 0x28;

Event.GetEventName = function(eventId) {

	switch(eventId) {
		case 0x1 : return 'before_render';
		case 0x2 : return 'component_created';
		case 0x3 : return 'component_initialized';
		case 0x4 : return 'create_instance_before';
		case 0x5 : return 'dispose_instance';
		case 0x6 : return 'dispose_object';
		case 0x7 : return 'dom_component_initialized';
		case 0x8 : return 'entity_created';
		case 0x9 : return 'entity_initialized';
		case 0xa : return 'get_runtime';
		case 0xb : return 'get_window_size';
		case 0xc : return 'graphics_component_initialized';
		case 0xd : return 'image_component_initialized';
		case 0xe : return 'image_initialized';
		case 0xf : return 'input_component_initialized';
		case 0x10 : return 'instance_created';
		case 0x11 : return 'instance_disposed';
		case 0x12 : return 'keyboard_down';
		case 0x13 : return 'keyboard_up';
		case 0x14 : return 'mouse_down';
		case 0x15 : return 'mouse_move';
		case 0x16 : return 'mouse_up';
		case 0x17 : return 'mouse_wheel';
		case 0x18 : return 'object_created';
		case 0x19 : return 'object_initialized';
		case 0x1a : return 'pause';
		case 0x1b : return 'project_initialized';
		case 0x1c : return 'restart';
		case 0x1d : return 'start';
		case 0x1e : return 'touch_cancel';
		case 0x1f : return 'touch_end';
		case 0x20 : return 'touch_move';
		case 0x21 : return 'touch_start';
		case 0x22 : return 'update_from_instance_after';
		case 0x23 : return 'update_from_instance_before';
		case 0x24 : return 'update_instance_after';
		case 0x25 : return 'update_instance_before';
		case 0x26 : return 'update_instance_property';
		case 0x27 : return 'update_property_from_instance';
		default :
			throw new Error('Event type not defined : ' + eventId);
	}

};

/**

  Class R3.Event.Object
  [Inherited from Event]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - async(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Async()' passing it the arguments

    - emit(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Emit()' passing it the arguments

    - subscribe(eventId, callback)
        Simply calls 'Subscribe()' passing it the arguments

  Inherited Static Methods:

    - Async(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data, clientCallback and clientErrorCallback as
        arguments. If an error occurs during clientCallback it additionally will execute clientErrorCallback with the
        error as argument.

    - Emit(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data as arg. Calls clientCallback directly after
        the event result is obtained, passing it the result. If an exception occurs during execution, the
        clientErrorCallback is called with the error as argument.

    - Subscribe(eventId, callback)
        Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised

  [Belonging to R3Object]

  Properties:

    - id (Default value Utils.RandomId(10) - Each Object receives an 10 digit random ID which uniquely
      identifies it everywhere (client and server side))
    - name (Default value 'Object ' + options.id - Each Object has a name)
    - register (Default value true)

  Static Properties:

    <no static properties>

  Methods:

    - initialize()
        Should raises an event(s) which indicates that this object initialized

  Static Methods:

    <no static methods>

 **/

class R3Object extends Event {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    if (typeof options.initialized === 'undefined') {
      options.initialized = false;
    }

    if (typeof options.callDepth === 'undefined') {
      options.callDepth = 0;
    } else {
      options.callDepth++;
    }

    super(options);

    /**
     * id - Each Object receives an 10 digit random ID which uniquely identifies it everywhere (client and
     * server side)
     */
    if (typeof options.id === 'undefined') {
      options.id = Utils.RandomId(10);
    }
    /**
     * name - Each Object has a name
     */
    if (typeof options.name === 'undefined') {
      options.name = 'Object ' + options.id;
    }
    /**
     * register - No comment
     */
    if (typeof options.register === 'undefined') {
      options.register = true;
    }

    Object.assign(this, options);

    if (options.callDepth === 0) {
      this.initialize();
    } else {
      options.callDepth--;
    }

  }

  /**
   * initialize()
   * - Should raises an event(s) which indicates that this object initialized  
   */
  initialize() {

    try {
      super.initialize();
    } catch (err) {

      if (!(err instanceof TypeError)) {
        //Another unexpected error occurred - and we are not inside a base class
        throw err;
      }

      delete this.callDepth;
      this.initialized = true;

      Event.Emit(Event.OBJECT_INITIALIZED, this);

      this.createInstance();
    }

  }

}

/**

  Class R3.Event.Object.Entity
  [Inherited from Event]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - async(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Async()' passing it the arguments

    - emit(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Emit()' passing it the arguments

    - subscribe(eventId, callback)
        Simply calls 'Subscribe()' passing it the arguments

  Inherited Static Methods:

    - Async(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data, clientCallback and clientErrorCallback as
        arguments. If an error occurs during clientCallback it additionally will execute clientErrorCallback with the
        error as argument.

    - Emit(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data as arg. Calls clientCallback directly after
        the event result is obtained, passing it the result. If an exception occurs during execution, the
        clientErrorCallback is called with the error as argument.

    - Subscribe(eventId, callback)
        Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised

  [Inherited from R3Object]

  Inherited Properties:

    - id (Default value Utils.RandomId(10) - Each Object receives an 10 digit random ID which uniquely
      identifies it everywhere (client and server side))
    - name (Default value 'Object ' + options.id - Each Object has a name)
    - register (Default value true)

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - initialize()
        Should raises an event(s) which indicates that this object initialized

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to Entity]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class Entity extends R3Object {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    if (typeof options.callDepth === 'undefined') {
      options.callDepth = 0;
    } else {
      options.callDepth++;
    }

    super(options);

    this.emit(Event.ENTITY_CREATED, this);

    Object.assign(this, options);

    if (options.callDepth === 0) {
      this.initialize();
    } else {
      options.callDepth--;
    }

  }

  /**
   * initialize()
   * - Should raises an event(s) which indicates that this object initialized  
   */
  initialize() {

    try {
      super.initialize();
    } catch (err) {

      if (!(err instanceof TypeError)) {
        //Another unexpected error occurred - and we are not inside a base class
        throw err;
      }

      delete this.callDepth;
      this.initialized = true;

      this.createInstance();
    }

    Event.Emit(Event.OBJECT_INITIALIZED, this);
    Event.Emit(Event.ENTITY_INITIALIZED, this);

  }

}

Entity.SLIDER = 0x0;
Entity.MAX_ENTITY = 0x1;

/**

  Class R3.Event.Object.Entity.Slider
  [Inherited from Event]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - async(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Async()' passing it the arguments

    - emit(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Emit()' passing it the arguments

    - subscribe(eventId, callback)
        Simply calls 'Subscribe()' passing it the arguments

  Inherited Static Methods:

    - Async(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data, clientCallback and clientErrorCallback as
        arguments. If an error occurs during clientCallback it additionally will execute clientErrorCallback with the
        error as argument.

    - Emit(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data as arg. Calls clientCallback directly after
        the event result is obtained, passing it the result. If an exception occurs during execution, the
        clientErrorCallback is called with the error as argument.

    - Subscribe(eventId, callback)
        Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised

  [Inherited from R3Object]

  Inherited Properties:

    - id (Default value Utils.RandomId(10) - Each Object receives an 10 digit random ID which uniquely
      identifies it everywhere (client and server side))
    - name (Default value 'Object ' + options.id - Each Object has a name)
    - register (Default value true)

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - initialize()
        Should raises an event(s) which indicates that this object initialized

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from Entity]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to EntitySlider]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class EntitySlider extends Entity {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    if (typeof options.initialized === 'undefined') {
      options.initialized = false;
    }

    if (typeof options.callDepth === 'undefined') {
      options.callDepth = 0;
    } else {
      options.callDepth++;
    }

    super(options);

    /**
     * parent - The parent R3.Object of this component
     */
    if (typeof options.parent === 'undefined') {
      options.parent = null;
    }
    /**
     * components - A list of components that this entity is composed of
     */
    if (typeof options.components === 'undefined') {
      options.components = [];
    }

    Object.assign(this, options);

    if (options.callDepth === 0) {
      this.initialize();
    } else {
      options.callDepth--;
    }

  }

}

/**

  Class R3.Event.Object.Component
  [Inherited from Event]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - async(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Async()' passing it the arguments

    - emit(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Emit()' passing it the arguments

    - subscribe(eventId, callback)
        Simply calls 'Subscribe()' passing it the arguments

  Inherited Static Methods:

    - Async(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data, clientCallback and clientErrorCallback as
        arguments. If an error occurs during clientCallback it additionally will execute clientErrorCallback with the
        error as argument.

    - Emit(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data as arg. Calls clientCallback directly after
        the event result is obtained, passing it the result. If an exception occurs during execution, the
        clientErrorCallback is called with the error as argument.

    - Subscribe(eventId, callback)
        Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised

  [Inherited from R3Object]

  Inherited Properties:

    - id (Default value Utils.RandomId(10) - Each Object receives an 10 digit random ID which uniquely
      identifies it everywhere (client and server side))
    - name (Default value 'Object ' + options.id - Each Object has a name)
    - register (Default value true)

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - initialize()
        Should raises an event(s) which indicates that this object initialized

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to Component]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class Component extends R3Object {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    if (typeof options.callDepth === 'undefined') {
      options.callDepth = 0;
    } else {
      options.callDepth++;
    }

    super(options);

    this.emit(Event.COMPONENT_CREATED, this);

    /**
     * register - No comment
     */
    if (typeof options.register === 'undefined') {
      options.register = true;
    }

    Object.assign(this, options);

    if (options.callDepth === 0) {
      this.initialize();
    } else {
      options.callDepth--;
    }

  }

  /**
   * initialize()
   * - Should raises an event(s) which indicates that this object initialized  
   */
  initialize() {

    try {
      super.initialize();
    } catch (err) {

      if (!(err instanceof TypeError)) {
        //Another unexpected error occurred - and we are not inside a base class
        throw err;
      }

      delete this.callDepth;
      this.initialized = true;

      Event.Emit(Event.COMPONENT_INITIALIZED, this);

      this.createInstance();
    }

  }

  /**
   * createInstance()
   * - Creates an instance of this object based on the current runtime  
   */
  createInstance() {

    this.emit(
      Event.CREATE_INSTANCE_BEFORE,
      this,
      function(delayInstance) {
        if (delayInstance === true) {
          console.log('Instance creation delayed for ' + this.name);
        } else {
          this.setRuntime();
          this.instance = this.runtime.buildInstance(this);
          this.emit(Event.INSTANCE_CREATED, this);
        }
      }
    );

  }

  /**
   * dispose()
   * - Disposes of this object by disposing the instance first.  
   */
  dispose() {

    this.subscribe(
      Event.INSTANCE_DISPOSED,
      function(object) {
        if (object === this) {
          this.emit(Event.DISPOSE_OBJECT, this);
        }
      }
    );

    this.disposeInstance();

  }

  /**
   * disposeInstance()
   * - Disposes of the runtime instance.  
   */
  disposeInstance() {

    console.log('Disposing instance of ' + this.name);
    this.emit(Event.DISPOSE_INSTANCE, this);

  }

  /**
   * setRuntime()
   * - Sets the runtime property of this component required for constructing an instance of this component.  
   */
  setRuntime() {

    this.emit(
      Event.GET_RUNTIME,
      this,
      function(runtime) {
        this.runtime = runtime;
      }.bind(this)
    )

  }

}

Component.DOM = 0x0;
Component.CANVAS = 0x1;
Component.GRAPHICS = 0x2;
Component.IMAGE = 0x3;
Component.MATERIAL = 0x4;
Component.MESH = 0x5;
Component.TEXTURE = 0x6;
Component.INPUT = 0x7;
Component.TOUCH = 0x8;
Component.MAX_COMPONENT = 0x9;

/**

  Class R3.Event.Object.Component.DOM
  [Inherited from Event]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - async(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Async()' passing it the arguments

    - emit(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Emit()' passing it the arguments

    - subscribe(eventId, callback)
        Simply calls 'Subscribe()' passing it the arguments

  Inherited Static Methods:

    - Async(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data, clientCallback and clientErrorCallback as
        arguments. If an error occurs during clientCallback it additionally will execute clientErrorCallback with the
        error as argument.

    - Emit(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data as arg. Calls clientCallback directly after
        the event result is obtained, passing it the result. If an exception occurs during execution, the
        clientErrorCallback is called with the error as argument.

    - Subscribe(eventId, callback)
        Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised

  [Inherited from R3Object]

  Inherited Properties:

    - id (Default value Utils.RandomId(10) - Each Object receives an 10 digit random ID which uniquely
      identifies it everywhere (client and server side))
    - name (Default value 'Object ' + options.id - Each Object has a name)
    - register (Default value true)

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - initialize()
        Should raises an event(s) which indicates that this object initialized

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from Component]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to ComponentDOM]

  Properties:

    - instance (Default value null - Holds the current instance of this object as determined (built) by
      the runtime object.)

  Static Properties:

    <no static properties>

  Methods:

    - initialize()
        In addition to firing an Event.OBJECT_INITIALIZED and Event.COMPONENT_INITIALIZED, it also fires an
        Event.DOM_COMPONENT_INITIALIZED

  Static Methods:

    <no static methods>

 **/

class ComponentDOM extends Component {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    if (typeof options.initialized === 'undefined') {
      options.initialized = false;
    }

    if (typeof options.callDepth === 'undefined') {
      options.callDepth = 0;
    } else {
      options.callDepth++;
    }

    super(options);

    /**
     * parent - The parent R3.Object of this component
     */
    if (typeof options.parent === 'undefined') {
      options.parent = null;
    }
    /**
     * instance - Holds the current instance of this object as determined (built) by the runtime object.
     */
    if (typeof options.instance === 'undefined') {
      options.instance = null;
    }

    /**
     * instance - Holds the current instance of this object as determined (built) by the runtime object.
     */
    if (typeof options.instance === 'undefined') {
      options.instance = null;
    }

    Object.assign(this, options);

    if (options.callDepth === 0) {
      this.initialize();
    } else {
      options.callDepth--;
    }

  }

  /**
   * updateInstance()
   * - Updates this object by copying the values of the current object into it's instance object. 
   * @param property 
   */
  updateInstance(property) {

    this.emit(Event.UPDATE_INSTANCE_BEFORE, this);

    if (property === 'instance') {
      this.instance.instance = this.instance;
      this.emit(
        Event.UPDATE_INSTANCE_PROPERTY,
        {
          component : this,
          property : 'instance',
          instanceProperty : 'instance'
        }
      );
      if (property !== 'all') {
        return;
      }
    }

    this.emit(Event.UPDATE_INSTANCE_AFTER, this);

  }

  /**
   * updateFromInstance()
   * - Updates this object by copying the values of its instance into the current object. 
   * @param property 
   */
  updateFromInstance(property) {

    this.emit(Event.UPDATE_FROM_INSTANCE_BEFORE, this);

    if (property === 'instance' || property === 'all') {
      this.instance = this.instance.instance;
      this.emit(
        Event.UPDATE_PROPERTY_FROM_INSTANCE,
        {
          component : this,
          property : 'instance',
          instanceProperty : 'instance'
        }
      );
      if (property !== 'all') {
        return;
      }
    }

    this.emit(Event.UPDATE_FROM_INSTANCE_AFTER, this);

  }

  /**
   * initialize()
   * - In addition to firing an Event.OBJECT_INITIALIZED and Event.COMPONENT_INITIALIZED, it also fires an
   *   Event.DOM_COMPONENT_INITIALIZED  
   */
  initialize() {

    try {
      super.initialize();
    } catch (err) {

      if (!(err instanceof TypeError)) {
        //Another unexpected error occurred - and we are not inside a base class
        throw err;
      }

      delete this.callDepth;
      this.initialized = true;

      Event.Emit(Event.DOM_COMPONENT_INITIALIZED, this);

      this.createInstance();
    }

  }

}

/**

  Class R3.Event.Object.Component.DOM.Canvas
  [Inherited from Event]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - async(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Async()' passing it the arguments

    - emit(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Emit()' passing it the arguments

    - subscribe(eventId, callback)
        Simply calls 'Subscribe()' passing it the arguments

  Inherited Static Methods:

    - Async(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data, clientCallback and clientErrorCallback as
        arguments. If an error occurs during clientCallback it additionally will execute clientErrorCallback with the
        error as argument.

    - Emit(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data as arg. Calls clientCallback directly after
        the event result is obtained, passing it the result. If an exception occurs during execution, the
        clientErrorCallback is called with the error as argument.

    - Subscribe(eventId, callback)
        Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised

  [Inherited from R3Object]

  Inherited Properties:

    - id (Default value Utils.RandomId(10) - Each Object receives an 10 digit random ID which uniquely
      identifies it everywhere (client and server side))
    - name (Default value 'Object ' + options.id - Each Object has a name)
    - register (Default value true)

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - initialize()
        Should raises an event(s) which indicates that this object initialized

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from Component]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from ComponentDOM]

  Inherited Properties:

    - instance (Default value null - Holds the current instance of this object as determined (built) by
      the runtime object.)

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - initialize()
        In addition to firing an Event.OBJECT_INITIALIZED and Event.COMPONENT_INITIALIZED, it also fires an
        Event.DOM_COMPONENT_INITIALIZED

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to ComponentCanvas]

  Properties:

    - type (Default value 'canvas')
    - width (Default value 500 - The initial width of the canvas (You can override it with CSS))
    - height (Default value 500 - The initial height of the canvas (You can override it with CSS))
    - style (Default value 'border:1px solid #000000;')

  Static Properties:

    <no static properties>

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class ComponentCanvas extends ComponentDOM {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    if (typeof options.initialized === 'undefined') {
      options.initialized = false;
    }

    if (typeof options.callDepth === 'undefined') {
      options.callDepth = 0;
    } else {
      options.callDepth++;
    }

    super(options);

    /**
     * parent - The parent R3.Object of this component
     */
    if (typeof options.parent === 'undefined') {
      options.parent = null;
    }
    /**
     * instance - Holds the current instance of this object as determined (built) by the runtime object.
     */
    if (typeof options.instance === 'undefined') {
      options.instance = null;
    }

    /**
     * type - No comment
     */
    if (typeof options.type === 'undefined') {
      options.type = 'canvas';
    }
    /**
     * width - The initial width of the canvas (You can override it with CSS)
     */
    if (typeof options.width === 'undefined') {
      options.width = 500;
    }
    /**
     * height - The initial height of the canvas (You can override it with CSS)
     */
    if (typeof options.height === 'undefined') {
      options.height = 500;
    }
    /**
     * style - No comment
     */
    if (typeof options.style === 'undefined') {
      options.style = 'border:1px solid #000000;';
    }

    Object.assign(this, options);

    if (options.callDepth === 0) {
      this.initialize();
    } else {
      options.callDepth--;
    }

  }

  /**
   * updateInstance()
   * - Updates this object by copying the values of the current object into it's instance object. 
   * @param property 
   */
  updateInstance(property) {

    this.emit(Event.UPDATE_INSTANCE_BEFORE, this);

    if (property === 'width') {
      this.instance.width = this.width;
      this.emit(
        Event.UPDATE_INSTANCE_PROPERTY,
        {
          component : this,
          property : 'width',
          instanceProperty : 'width'
        }
      );
      if (property !== 'all') {
        return;
      }
    }
    if (property === 'height') {
      this.instance.height = this.height;
      this.emit(
        Event.UPDATE_INSTANCE_PROPERTY,
        {
          component : this,
          property : 'height',
          instanceProperty : 'height'
        }
      );
      if (property !== 'all') {
        return;
      }
    }
    if (property === 'style') {
      this.instance.style = this.style;
      this.emit(
        Event.UPDATE_INSTANCE_PROPERTY,
        {
          component : this,
          property : 'style',
          instanceProperty : 'style'
        }
      );
      if (property !== 'all') {
        return;
      }
    }

    this.emit(Event.UPDATE_INSTANCE_AFTER, this);

  }

  /**
   * updateFromInstance()
   * - Updates this object by copying the values of its instance into the current object. 
   * @param property 
   */
  updateFromInstance(property) {

    this.emit(Event.UPDATE_FROM_INSTANCE_BEFORE, this);

    if (property === 'width' || property === 'all') {
      this.width = this.instance.width;
      this.emit(
        Event.UPDATE_PROPERTY_FROM_INSTANCE,
        {
          component : this,
          property : 'width',
          instanceProperty : 'width'
        }
      );
      if (property !== 'all') {
        return;
      }
    }
    if (property === 'height' || property === 'all') {
      this.height = this.instance.height;
      this.emit(
        Event.UPDATE_PROPERTY_FROM_INSTANCE,
        {
          component : this,
          property : 'height',
          instanceProperty : 'height'
        }
      );
      if (property !== 'all') {
        return;
      }
    }
    if (property === 'style' || property === 'all') {
      this.style = this.instance.style;
      this.emit(
        Event.UPDATE_PROPERTY_FROM_INSTANCE,
        {
          component : this,
          property : 'style',
          instanceProperty : 'style'
        }
      );
      if (property !== 'all') {
        return;
      }
    }

    this.emit(Event.UPDATE_FROM_INSTANCE_AFTER, this);

  }

}

/**

  Class R3.Event.Object.Component.Graphics
  [Inherited from Event]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - async(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Async()' passing it the arguments

    - emit(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Emit()' passing it the arguments

    - subscribe(eventId, callback)
        Simply calls 'Subscribe()' passing it the arguments

  Inherited Static Methods:

    - Async(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data, clientCallback and clientErrorCallback as
        arguments. If an error occurs during clientCallback it additionally will execute clientErrorCallback with the
        error as argument.

    - Emit(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data as arg. Calls clientCallback directly after
        the event result is obtained, passing it the result. If an exception occurs during execution, the
        clientErrorCallback is called with the error as argument.

    - Subscribe(eventId, callback)
        Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised

  [Inherited from R3Object]

  Inherited Properties:

    - id (Default value Utils.RandomId(10) - Each Object receives an 10 digit random ID which uniquely
      identifies it everywhere (client and server side))
    - name (Default value 'Object ' + options.id - Each Object has a name)
    - register (Default value true)

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - initialize()
        Should raises an event(s) which indicates that this object initialized

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from Component]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to ComponentGraphics]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    - initialize()
        In addition to firing an Event.OBJECT_INITIALIZED and Event.COMPONENT_INITIALIZED, it also fires an
        Event.GRAPHICS_COMPONENT_INITIALIZED

  Static Methods:

    <no static methods>

 **/

class ComponentGraphics extends Component {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    if (typeof options.initialized === 'undefined') {
      options.initialized = false;
    }

    if (typeof options.callDepth === 'undefined') {
      options.callDepth = 0;
    } else {
      options.callDepth++;
    }

    super(options);

    /**
     * parent - The parent R3.Object of this component
     */
    if (typeof options.parent === 'undefined') {
      options.parent = null;
    }
    /**
     * instance - Holds the current instance of this object as determined (built) by the runtime object.
     */
    if (typeof options.instance === 'undefined') {
      options.instance = null;
    }

    Object.assign(this, options);

    if (options.callDepth === 0) {
      this.initialize();
    } else {
      options.callDepth--;
    }

  }

  /**
   * updateInstance()
   * - Updates this object by copying the values of the current object into it's instance object. 
   * @param property 
   */
  updateInstance(property) {

    this.emit(Event.UPDATE_INSTANCE_BEFORE, this);

    this.emit(Event.UPDATE_INSTANCE_AFTER, this);

  }

  /**
   * updateFromInstance()
   * - Updates this object by copying the values of its instance into the current object. 
   * @param property 
   */
  updateFromInstance(property) {

    this.emit(Event.UPDATE_FROM_INSTANCE_BEFORE, this);

    this.emit(Event.UPDATE_FROM_INSTANCE_AFTER, this);

  }

  /**
   * initialize()
   * - In addition to firing an Event.OBJECT_INITIALIZED and Event.COMPONENT_INITIALIZED, it also fires an
   *   Event.GRAPHICS_COMPONENT_INITIALIZED  
   */
  initialize() {

    try {
      super.initialize();
    } catch (err) {

      if (!(err instanceof TypeError)) {
        //Another unexpected error occurred - and we are not inside a base class
        throw err;
      }

      delete this.callDepth;
      this.initialized = true;

      Event.Emit(Event.GRAPHICS_COMPONENT_INITIALIZED, this);

      this.createInstance();
    }

  }

}

/**

  Class R3.Event.Object.Component.Graphics.Image
  [Inherited from Event]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - async(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Async()' passing it the arguments

    - emit(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Emit()' passing it the arguments

    - subscribe(eventId, callback)
        Simply calls 'Subscribe()' passing it the arguments

  Inherited Static Methods:

    - Async(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data, clientCallback and clientErrorCallback as
        arguments. If an error occurs during clientCallback it additionally will execute clientErrorCallback with the
        error as argument.

    - Emit(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data as arg. Calls clientCallback directly after
        the event result is obtained, passing it the result. If an exception occurs during execution, the
        clientErrorCallback is called with the error as argument.

    - Subscribe(eventId, callback)
        Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised

  [Inherited from R3Object]

  Inherited Properties:

    - id (Default value Utils.RandomId(10) - Each Object receives an 10 digit random ID which uniquely
      identifies it everywhere (client and server side))
    - name (Default value 'Object ' + options.id - Each Object has a name)
    - register (Default value true)

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - initialize()
        Should raises an event(s) which indicates that this object initialized

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from Component]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from ComponentGraphics]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - initialize()
        In addition to firing an Event.OBJECT_INITIALIZED and Event.COMPONENT_INITIALIZED, it also fires an
        Event.GRAPHICS_COMPONENT_INITIALIZED

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to ComponentImage]

  Properties:

    - src (Default value
      'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAABhGlDQ1BJQ0MgcHJvZmlsZQAAKJF9kT1Iw0AcxV9TpSotDu0g4pChumhBVMRRq1CECqFWaNXB5NIvaNKQpLg4Cq4FBz8Wqw4uzro6uAqC4AeIm5uToouU+L+k0CLWg+N+vLv3uHsHCPUy06yucUDTbTOViIuZ7KoYeEUvwgghgFGZWcacJCXRcXzdw8fXuxjP6nzuzxFScxYDfCLxLDNMm3iDeHrTNjjvE0dYUVaJz4nHTLog8SPXFY/fOBdcFnhmxEyn5okjxGKhjZU2ZkVTI54ijqqaTvlCxmOV8xZnrVxlzXvyFwZz+soy12kOIYFFLEGCCAVVlFCGjRitOikWUrQf7+AfdP0SuRRylcDIsYAKNMiuH/wPfndr5ScnvKRgHOh+cZyPYSCwCzRqjvN97DiNE8D/DFzpLX+lDsx8kl5radEjoH8buLhuacoecLkDDDwZsim7kp+mkM8D72f0TVkgfAv0rXm9Nfdx+gCkqavkDXBwCIwUKHu9w7t72nv790yzvx9QEXKZwXQv9wAAAAZiS0dEADIANAAxUB4d7wAAAAlwSFlzAAAuIwAALiMBeKU/dgAAAAd0SU1FB+UJEw0JHX/9/lIAAAAZdEVYdENvbW1lbnQAQ3JlYXRlZCB3aXRoIEdJTVBXgQ4XAAAADUlEQVQI12Ng+M+gBgADKAEm2Ka93QAAAABJRU5ErkJggg)
    - alt (Default value '15% opaque 1x1 green pixel' - The alt attribute of this image)
    - fileName (Default value Utils.LowerUnderscore(options.name) - Name of the image under which it is
      stored)
    - extension (Default value '.png' - Extension of the file name including the '.' (ex. '.jpg'))
    - external_path (Default value '/images/' + options.id + '.png' - Path to the image relative to the
      project defined API URL)
    - internal_path (Default value '/tmp/' + options.id + '.png' - Server side path on the server to the
      file, excluding filename)
    - contentType (Default value 'image/png' - Content type of the file (based on the extension, ex.
      'image/jpeg'))
    - size (Default value 565 - Size of the file in bytes)
    - width (Default value 1 - Width of the image in pixels)
    - height (Default value 1 - height of the image in pixels)
    - orientation (Default value 'square' - The orientation of the image, one of 'square', 'landscape',
      'portrait')

  Static Properties:

    <no static properties>

  Methods:

    - initialize()
        Also raises Event.IMAGE_INITIALIZED

  Static Methods:

    <no static methods>

 **/

class ComponentImage extends ComponentGraphics {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    if (typeof options.initialized === 'undefined') {
      options.initialized = false;
    }

    if (typeof options.callDepth === 'undefined') {
      options.callDepth = 0;
    } else {
      options.callDepth++;
    }

    super(options);

    /**
     * parent - The parent R3.Object of this component
     */
    if (typeof options.parent === 'undefined') {
      options.parent = null;
    }
    /**
     * instance - Holds the current instance of this object as determined (built) by the runtime object.
     */
    if (typeof options.instance === 'undefined') {
      options.instance = null;
    }

    /**
     * src - The src attribute of this image, defaults to a 15% opaque 1x1 green pixel
     */
    if (typeof options.src === 'undefined') {
      options.src = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAABhGlDQ1BJQ0MgcHJvZmlsZQAAKJF9kT1Iw0AcxV9TpSotDu0g4pChumhBVMRRq1CECqFWaNXB5NIvaNKQpLg4Cq4FBz8Wqw4uzro6uAqC4AeIm5uToouU+L+k0CLWg+N+vLv3uHsHCPUy06yucUDTbTOViIuZ7KoYeEUvwgghgFGZWcacJCXRcXzdw8fXuxjP6nzuzxFScxYDfCLxLDNMm3iDeHrTNjjvE0dYUVaJz4nHTLog8SPXFY/fOBdcFnhmxEyn5okjxGKhjZU2ZkVTI54ijqqaTvlCxmOV8xZnrVxlzXvyFwZz+soy12kOIYFFLEGCCAVVlFCGjRitOikWUrQf7+AfdP0SuRRylcDIsYAKNMiuH/wPfndr5ScnvKRgHOh+cZyPYSCwCzRqjvN97DiNE8D/DFzpLX+lDsx8kl5radEjoH8buLhuacoecLkDDDwZsim7kp+mkM8D72f0TVkgfAv0rXm9Nfdx+gCkqavkDXBwCIwUKHu9w7t72nv790yzvx9QEXKZwXQv9wAAAAZiS0dEADIANAAxUB4d7wAAAAlwSFlzAAAuIwAALiMBeKU/dgAAAAd0SU1FB+UJEw0JHX/9/lIAAAAZdEVYdENvbW1lbnQAQ3JlYXRlZCB3aXRoIEdJTVBXgQ4XAAAADUlEQVQI12Ng+M+gBgADKAEm2Ka93QAAAABJRU5ErkJggg==';
    }
    /**
     * alt - The alt attribute of this image
     */
    if (typeof options.alt === 'undefined') {
      options.alt = '15% opaque 1x1 green pixel';
    }
    /**
     * fileName - Name of the image under which it is stored
     */
    if (typeof options.fileName === 'undefined') {
      options.fileName = Utils.LowerUnderscore(options.name);
    }
    /**
     * extension - Extension of the file name including the '.' (ex. '.jpg')
     */
    if (typeof options.extension === 'undefined') {
      options.extension = '.png';
    }
    /**
     * external_path - Path to the image relative to the project defined API URL
     */
    if (typeof options.external_path === 'undefined') {
      options.external_path = '/images/' + options.id + '.png';
    }
    /**
     * internal_path - Server side path on the server to the file, excluding filename
     */
    if (typeof options.internal_path === 'undefined') {
      options.internal_path = '/tmp/' + options.id + '.png';
    }
    /**
     * contentType - Content type of the file (based on the extension, ex. 'image/jpeg')
     */
    if (typeof options.contentType === 'undefined') {
      options.contentType = 'image/png';
    }
    /**
     * size - Size of the file in bytes
     */
    if (typeof options.size === 'undefined') {
      options.size = 565;
    }
    /**
     * width - Width of the image in pixels
     */
    if (typeof options.width === 'undefined') {
      options.width = 1;
    }
    /**
     * height - height of the image in pixels
     */
    if (typeof options.height === 'undefined') {
      options.height = 1;
    }
    /**
     * orientation - The orientation of the image, one of 'square', 'landscape', 'portrait'
     */
    if (typeof options.orientation === 'undefined') {
      options.orientation = 'square';
    }

    if (options.extension.match(/(png)$/i)) {
      options.contentType = 'image/png';
    }

    if (options.extension.match(/(jpg|jpeg)$/i)) {
      options.contentType = 'image/jpeg';
    }

    if (options.extension.match(/(gif)$/i)) {
      options.contentType = 'image/gif';
    }

    Object.assign(this, options);

    if (this.width > this.height) {
      this.orientation = 'landscape';
    }

    if (this.width < this.height) {
      this.orientation = 'portrait';
    }

    if (this.width === this.height) {
      this.orientation = 'square';
    }

    if (options.callDepth === 0) {
      this.initialize();
    } else {
      options.callDepth--;
    }

  }

  /**
   * updateInstance()
   * - Updates this object by copying the values of the current object into it's instance object. 
   * @param property 
   */
  updateInstance(property) {

    this.emit(Event.UPDATE_INSTANCE_BEFORE, this);

    if (property === 'src') {
      this.instance.src = this.src;
      this.emit(
        Event.UPDATE_INSTANCE_PROPERTY,
        {
          component : this,
          property : 'src',
          instanceProperty : 'src'
        }
      );
      if (property !== 'all') {
        return;
      }
    }
    if (property === 'alt') {
      this.instance.alt = this.alt;
      this.emit(
        Event.UPDATE_INSTANCE_PROPERTY,
        {
          component : this,
          property : 'alt',
          instanceProperty : 'alt'
        }
      );
      if (property !== 'all') {
        return;
      }
    }
    if (property === 'external_path') {
      this.instance.external_path = this.external_path;
      this.emit(
        Event.UPDATE_INSTANCE_PROPERTY,
        {
          component : this,
          property : 'external_path',
          instanceProperty : 'external_path'
        }
      );
      if (property !== 'all') {
        return;
      }
    }
    if (property === 'internal_path') {
      this.instance.internal_path = this.internal_path;
      this.emit(
        Event.UPDATE_INSTANCE_PROPERTY,
        {
          component : this,
          property : 'internal_path',
          instanceProperty : 'internal_path'
        }
      );
      if (property !== 'all') {
        return;
      }
    }
    if (property === 'size') {
      this.instance.size = this.size;
      this.emit(
        Event.UPDATE_INSTANCE_PROPERTY,
        {
          component : this,
          property : 'size',
          instanceProperty : 'size'
        }
      );
      if (property !== 'all') {
        return;
      }
    }
    if (property === 'width') {
      this.instance.width = this.width;
      this.emit(
        Event.UPDATE_INSTANCE_PROPERTY,
        {
          component : this,
          property : 'width',
          instanceProperty : 'width'
        }
      );
      if (property !== 'all') {
        return;
      }
    }
    if (property === 'height') {
      this.instance.height = this.height;
      this.emit(
        Event.UPDATE_INSTANCE_PROPERTY,
        {
          component : this,
          property : 'height',
          instanceProperty : 'height'
        }
      );
      if (property !== 'all') {
        return;
      }
    }
    if (property === 'orientation') {
      this.instance.orientation = this.orientation;
      this.emit(
        Event.UPDATE_INSTANCE_PROPERTY,
        {
          component : this,
          property : 'orientation',
          instanceProperty : 'orientation'
        }
      );
      if (property !== 'all') {
        return;
      }
    }

    this.emit(Event.UPDATE_INSTANCE_AFTER, this);

  }

  /**
   * updateFromInstance()
   * - Updates this object by copying the values of its instance into the current object. 
   * @param property 
   */
  updateFromInstance(property) {

    this.emit(Event.UPDATE_FROM_INSTANCE_BEFORE, this);

    if (property === 'src' || property === 'all') {
      this.src = this.instance.src;
      this.emit(
        Event.UPDATE_PROPERTY_FROM_INSTANCE,
        {
          component : this,
          property : 'src',
          instanceProperty : 'src'
        }
      );
      if (property !== 'all') {
        return;
      }
    }
    if (property === 'alt' || property === 'all') {
      this.alt = this.instance.alt;
      this.emit(
        Event.UPDATE_PROPERTY_FROM_INSTANCE,
        {
          component : this,
          property : 'alt',
          instanceProperty : 'alt'
        }
      );
      if (property !== 'all') {
        return;
      }
    }
    if (property === 'external_path' || property === 'all') {
      this.external_path = this.instance.external_path;
      this.emit(
        Event.UPDATE_PROPERTY_FROM_INSTANCE,
        {
          component : this,
          property : 'external_path',
          instanceProperty : 'external_path'
        }
      );
      if (property !== 'all') {
        return;
      }
    }
    if (property === 'internal_path' || property === 'all') {
      this.internal_path = this.instance.internal_path;
      this.emit(
        Event.UPDATE_PROPERTY_FROM_INSTANCE,
        {
          component : this,
          property : 'internal_path',
          instanceProperty : 'internal_path'
        }
      );
      if (property !== 'all') {
        return;
      }
    }
    if (property === 'size' || property === 'all') {
      this.size = this.instance.size;
      this.emit(
        Event.UPDATE_PROPERTY_FROM_INSTANCE,
        {
          component : this,
          property : 'size',
          instanceProperty : 'size'
        }
      );
      if (property !== 'all') {
        return;
      }
    }
    if (property === 'width' || property === 'all') {
      this.width = this.instance.width;
      this.emit(
        Event.UPDATE_PROPERTY_FROM_INSTANCE,
        {
          component : this,
          property : 'width',
          instanceProperty : 'width'
        }
      );
      if (property !== 'all') {
        return;
      }
    }
    if (property === 'height' || property === 'all') {
      this.height = this.instance.height;
      this.emit(
        Event.UPDATE_PROPERTY_FROM_INSTANCE,
        {
          component : this,
          property : 'height',
          instanceProperty : 'height'
        }
      );
      if (property !== 'all') {
        return;
      }
    }
    if (property === 'orientation' || property === 'all') {
      this.orientation = this.instance.orientation;
      this.emit(
        Event.UPDATE_PROPERTY_FROM_INSTANCE,
        {
          component : this,
          property : 'orientation',
          instanceProperty : 'orientation'
        }
      );
      if (property !== 'all') {
        return;
      }
    }

    this.emit(Event.UPDATE_FROM_INSTANCE_AFTER, this);

  }

  /**
   * initialize()
   * - Also raises Event.IMAGE_INITIALIZED  
   */
  initialize() {

    try {
      super.initialize();
    } catch (err) {

      if (!(err instanceof TypeError)) {
        //Another unexpected error occurred - and we are not inside a base class
        throw err;
      }

      delete this.callDepth;
      this.initialized = true;

      Event.Emit(Event.IMAGE_COMPONENT_INITIALIZED, this);

      this.createInstance();
    }

  }

}

/**

  Class R3.Event.Object.Component.Graphics.Material
  [Inherited from Event]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - async(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Async()' passing it the arguments

    - emit(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Emit()' passing it the arguments

    - subscribe(eventId, callback)
        Simply calls 'Subscribe()' passing it the arguments

  Inherited Static Methods:

    - Async(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data, clientCallback and clientErrorCallback as
        arguments. If an error occurs during clientCallback it additionally will execute clientErrorCallback with the
        error as argument.

    - Emit(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data as arg. Calls clientCallback directly after
        the event result is obtained, passing it the result. If an exception occurs during execution, the
        clientErrorCallback is called with the error as argument.

    - Subscribe(eventId, callback)
        Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised

  [Inherited from R3Object]

  Inherited Properties:

    - id (Default value Utils.RandomId(10) - Each Object receives an 10 digit random ID which uniquely
      identifies it everywhere (client and server side))
    - name (Default value 'Object ' + options.id - Each Object has a name)
    - register (Default value true)

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - initialize()
        Should raises an event(s) which indicates that this object initialized

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from Component]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from ComponentGraphics]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - initialize()
        In addition to firing an Event.OBJECT_INITIALIZED and Event.COMPONENT_INITIALIZED, it also fires an
        Event.GRAPHICS_COMPONENT_INITIALIZED

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to ComponentMaterial]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class ComponentMaterial extends ComponentGraphics {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    if (typeof options.initialized === 'undefined') {
      options.initialized = false;
    }

    if (typeof options.callDepth === 'undefined') {
      options.callDepth = 0;
    } else {
      options.callDepth++;
    }

    super(options);

    /**
     * parent - The parent R3.Object of this component
     */
    if (typeof options.parent === 'undefined') {
      options.parent = null;
    }
    /**
     * instance - Holds the current instance of this object as determined (built) by the runtime object.
     */
    if (typeof options.instance === 'undefined') {
      options.instance = null;
    }

    Object.assign(this, options);

    if (options.callDepth === 0) {
      this.initialize();
    } else {
      options.callDepth--;
    }

  }

  /**
   * updateInstance()
   * - Updates this object by copying the values of the current object into it's instance object. 
   * @param property 
   */
  updateInstance(property) {

    this.emit(Event.UPDATE_INSTANCE_BEFORE, this);

    this.emit(Event.UPDATE_INSTANCE_AFTER, this);

  }

  /**
   * updateFromInstance()
   * - Updates this object by copying the values of its instance into the current object. 
   * @param property 
   */
  updateFromInstance(property) {

    this.emit(Event.UPDATE_FROM_INSTANCE_BEFORE, this);

    this.emit(Event.UPDATE_FROM_INSTANCE_AFTER, this);

  }

}

/**

  Class R3.Event.Object.Component.Graphics.Mesh
  [Inherited from Event]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - async(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Async()' passing it the arguments

    - emit(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Emit()' passing it the arguments

    - subscribe(eventId, callback)
        Simply calls 'Subscribe()' passing it the arguments

  Inherited Static Methods:

    - Async(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data, clientCallback and clientErrorCallback as
        arguments. If an error occurs during clientCallback it additionally will execute clientErrorCallback with the
        error as argument.

    - Emit(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data as arg. Calls clientCallback directly after
        the event result is obtained, passing it the result. If an exception occurs during execution, the
        clientErrorCallback is called with the error as argument.

    - Subscribe(eventId, callback)
        Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised

  [Inherited from R3Object]

  Inherited Properties:

    - id (Default value Utils.RandomId(10) - Each Object receives an 10 digit random ID which uniquely
      identifies it everywhere (client and server side))
    - name (Default value 'Object ' + options.id - Each Object has a name)
    - register (Default value true)

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - initialize()
        Should raises an event(s) which indicates that this object initialized

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from Component]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from ComponentGraphics]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - initialize()
        In addition to firing an Event.OBJECT_INITIALIZED and Event.COMPONENT_INITIALIZED, it also fires an
        Event.GRAPHICS_COMPONENT_INITIALIZED

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to ComponentMesh]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class ComponentMesh extends ComponentGraphics {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    if (typeof options.initialized === 'undefined') {
      options.initialized = false;
    }

    if (typeof options.callDepth === 'undefined') {
      options.callDepth = 0;
    } else {
      options.callDepth++;
    }

    super(options);

    /**
     * parent - The parent R3.Object of this component
     */
    if (typeof options.parent === 'undefined') {
      options.parent = null;
    }
    /**
     * instance - Holds the current instance of this object as determined (built) by the runtime object.
     */
    if (typeof options.instance === 'undefined') {
      options.instance = null;
    }

    Object.assign(this, options);

    if (options.callDepth === 0) {
      this.initialize();
    } else {
      options.callDepth--;
    }

  }

  /**
   * updateInstance()
   * - Updates this object by copying the values of the current object into it's instance object. 
   * @param property 
   */
  updateInstance(property) {

    this.emit(Event.UPDATE_INSTANCE_BEFORE, this);

    this.emit(Event.UPDATE_INSTANCE_AFTER, this);

  }

  /**
   * updateFromInstance()
   * - Updates this object by copying the values of its instance into the current object. 
   * @param property 
   */
  updateFromInstance(property) {

    this.emit(Event.UPDATE_FROM_INSTANCE_BEFORE, this);

    this.emit(Event.UPDATE_FROM_INSTANCE_AFTER, this);

  }

}

/**

  Class R3.Event.Object.Component.Graphics.Texture
  [Inherited from Event]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - async(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Async()' passing it the arguments

    - emit(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Emit()' passing it the arguments

    - subscribe(eventId, callback)
        Simply calls 'Subscribe()' passing it the arguments

  Inherited Static Methods:

    - Async(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data, clientCallback and clientErrorCallback as
        arguments. If an error occurs during clientCallback it additionally will execute clientErrorCallback with the
        error as argument.

    - Emit(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data as arg. Calls clientCallback directly after
        the event result is obtained, passing it the result. If an exception occurs during execution, the
        clientErrorCallback is called with the error as argument.

    - Subscribe(eventId, callback)
        Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised

  [Inherited from R3Object]

  Inherited Properties:

    - id (Default value Utils.RandomId(10) - Each Object receives an 10 digit random ID which uniquely
      identifies it everywhere (client and server side))
    - name (Default value 'Object ' + options.id - Each Object has a name)
    - register (Default value true)

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - initialize()
        Should raises an event(s) which indicates that this object initialized

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from Component]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from ComponentGraphics]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - initialize()
        In addition to firing an Event.OBJECT_INITIALIZED and Event.COMPONENT_INITIALIZED, it also fires an
        Event.GRAPHICS_COMPONENT_INITIALIZED

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to ComponentTexture]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class ComponentTexture extends ComponentGraphics {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    if (typeof options.initialized === 'undefined') {
      options.initialized = false;
    }

    if (typeof options.callDepth === 'undefined') {
      options.callDepth = 0;
    } else {
      options.callDepth++;
    }

    super(options);

    /**
     * parent - The parent R3.Object of this component
     */
    if (typeof options.parent === 'undefined') {
      options.parent = null;
    }
    /**
     * instance - Holds the current instance of this object as determined (built) by the runtime object.
     */
    if (typeof options.instance === 'undefined') {
      options.instance = null;
    }

    Object.assign(this, options);

    if (options.callDepth === 0) {
      this.initialize();
    } else {
      options.callDepth--;
    }

  }

  /**
   * updateInstance()
   * - Updates this object by copying the values of the current object into it's instance object. 
   * @param property 
   */
  updateInstance(property) {

    this.emit(Event.UPDATE_INSTANCE_BEFORE, this);

    this.emit(Event.UPDATE_INSTANCE_AFTER, this);

  }

  /**
   * updateFromInstance()
   * - Updates this object by copying the values of its instance into the current object. 
   * @param property 
   */
  updateFromInstance(property) {

    this.emit(Event.UPDATE_FROM_INSTANCE_BEFORE, this);

    this.emit(Event.UPDATE_FROM_INSTANCE_AFTER, this);

  }

}

/**

  Class R3.Event.Object.Component.Input
  [Inherited from Event]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - async(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Async()' passing it the arguments

    - emit(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Emit()' passing it the arguments

    - subscribe(eventId, callback)
        Simply calls 'Subscribe()' passing it the arguments

  Inherited Static Methods:

    - Async(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data, clientCallback and clientErrorCallback as
        arguments. If an error occurs during clientCallback it additionally will execute clientErrorCallback with the
        error as argument.

    - Emit(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data as arg. Calls clientCallback directly after
        the event result is obtained, passing it the result. If an exception occurs during execution, the
        clientErrorCallback is called with the error as argument.

    - Subscribe(eventId, callback)
        Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised

  [Inherited from R3Object]

  Inherited Properties:

    - id (Default value Utils.RandomId(10) - Each Object receives an 10 digit random ID which uniquely
      identifies it everywhere (client and server side))
    - name (Default value 'Object ' + options.id - Each Object has a name)
    - register (Default value true)

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - initialize()
        Should raises an event(s) which indicates that this object initialized

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from Component]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to ComponentInput]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    - initialize()
        In addition to firing an Event.OBJECT_INITIALIZED and Event.COMPONENT_INITIALIZED, it also fires an
        Event.INPUT_COMPONENT_INITIALIZED

  Static Methods:

    <no static methods>

 **/

class ComponentInput extends Component {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    if (typeof options.initialized === 'undefined') {
      options.initialized = false;
    }

    if (typeof options.callDepth === 'undefined') {
      options.callDepth = 0;
    } else {
      options.callDepth++;
    }

    super(options);

    /**
     * parent - The parent R3.Object of this component
     */
    if (typeof options.parent === 'undefined') {
      options.parent = null;
    }
    /**
     * instance - Holds the current instance of this object as determined (built) by the runtime object.
     */
    if (typeof options.instance === 'undefined') {
      options.instance = null;
    }

    Object.assign(this, options);

    if (options.callDepth === 0) {
      this.initialize();
    } else {
      options.callDepth--;
    }

  }

  /**
   * updateInstance()
   * - Updates this object by copying the values of the current object into it's instance object. 
   * @param property 
   */
  updateInstance(property) {

    this.emit(Event.UPDATE_INSTANCE_BEFORE, this);

    this.emit(Event.UPDATE_INSTANCE_AFTER, this);

  }

  /**
   * updateFromInstance()
   * - Updates this object by copying the values of its instance into the current object. 
   * @param property 
   */
  updateFromInstance(property) {

    this.emit(Event.UPDATE_FROM_INSTANCE_BEFORE, this);

    this.emit(Event.UPDATE_FROM_INSTANCE_AFTER, this);

  }

  /**
   * initialize()
   * - In addition to firing an Event.OBJECT_INITIALIZED and Event.COMPONENT_INITIALIZED, it also fires an
   *   Event.INPUT_COMPONENT_INITIALIZED  
   */
  initialize() {

    try {
      super.initialize();
    } catch (err) {

      if (!(err instanceof TypeError)) {
        //Another unexpected error occurred - and we are not inside a base class
        throw err;
      }

      delete this.callDepth;
      this.initialized = true;

      Event.Emit(Event.INPUT_COMPONENT_INITIALIZED, this);

      this.createInstance();
    }

  }

}

/**

  Class R3.Event.Object.Component.Input.Touch
  [Inherited from Event]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - async(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Async()' passing it the arguments

    - emit(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Emit()' passing it the arguments

    - subscribe(eventId, callback)
        Simply calls 'Subscribe()' passing it the arguments

  Inherited Static Methods:

    - Async(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data, clientCallback and clientErrorCallback as
        arguments. If an error occurs during clientCallback it additionally will execute clientErrorCallback with the
        error as argument.

    - Emit(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data as arg. Calls clientCallback directly after
        the event result is obtained, passing it the result. If an exception occurs during execution, the
        clientErrorCallback is called with the error as argument.

    - Subscribe(eventId, callback)
        Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised

  [Inherited from R3Object]

  Inherited Properties:

    - id (Default value Utils.RandomId(10) - Each Object receives an 10 digit random ID which uniquely
      identifies it everywhere (client and server side))
    - name (Default value 'Object ' + options.id - Each Object has a name)
    - register (Default value true)

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - initialize()
        Should raises an event(s) which indicates that this object initialized

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from Component]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    <no inherited methods>

  Inherited Static Methods:

    <no inherited static methods>

  [Inherited from ComponentInput]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - initialize()
        In addition to firing an Event.OBJECT_INITIALIZED and Event.COMPONENT_INITIALIZED, it also fires an
        Event.INPUT_COMPONENT_INITIALIZED

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to ComponentTouch]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    <no methods>

  Static Methods:

    <no static methods>

 **/

class ComponentTouch extends ComponentInput {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    if (typeof options.initialized === 'undefined') {
      options.initialized = false;
    }

    if (typeof options.callDepth === 'undefined') {
      options.callDepth = 0;
    } else {
      options.callDepth++;
    }

    super(options);

    /**
     * parent - The parent R3.Object of this component
     */
    if (typeof options.parent === 'undefined') {
      options.parent = null;
    }
    /**
     * instance - Holds the current instance of this object as determined (built) by the runtime object.
     */
    if (typeof options.instance === 'undefined') {
      options.instance = null;
    }

    Object.assign(this, options);

    if (options.callDepth === 0) {
      this.initialize();
    } else {
      options.callDepth--;
    }

  }

  /**
   * updateInstance()
   * - Updates this object by copying the values of the current object into it's instance object. 
   * @param property 
   */
  updateInstance(property) {

    this.emit(Event.UPDATE_INSTANCE_BEFORE, this);

    this.emit(Event.UPDATE_INSTANCE_AFTER, this);

  }

  /**
   * updateFromInstance()
   * - Updates this object by copying the values of its instance into the current object. 
   * @param property 
   */
  updateFromInstance(property) {

    this.emit(Event.UPDATE_FROM_INSTANCE_BEFORE, this);

    this.emit(Event.UPDATE_FROM_INSTANCE_AFTER, this);

  }

}

/**

  Class R3.Event.Object.Project
  [Inherited from Event]

  Inherited Properties:

    <no inherited properties>

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - async(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Async()' passing it the arguments

    - emit(eventId, data, clientCallback, clientErrorCallback)
        Simply calls 'Emit()' passing it the arguments

    - subscribe(eventId, callback)
        Simply calls 'Subscribe()' passing it the arguments

  Inherited Static Methods:

    - Async(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data, clientCallback and clientErrorCallback as
        arguments. If an error occurs during clientCallback it additionally will execute clientErrorCallback with the
        error as argument.

    - Emit(eventId, data, clientCallback, clientErrorCallback)
        Calls all subscription functions registered to eventId with data as arg. Calls clientCallback directly after
        the event result is obtained, passing it the result. If an exception occurs during execution, the
        clientErrorCallback is called with the error as argument.

    - Subscribe(eventId, callback)
        Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised

  [Inherited from R3Object]

  Inherited Properties:

    - id (Default value Utils.RandomId(10) - Each Object receives an 10 digit random ID which uniquely
      identifies it everywhere (client and server side))
    - name (Default value 'Object ' + options.id - Each Object has a name)
    - register (Default value true)

  Inherited Static Properties:

    <no inherited static properties>

  Inherited Methods:

    - initialize()
        Should raises an event(s) which indicates that this object initialized

  Inherited Static Methods:

    <no inherited static methods>

  [Belonging to Project]

  Properties:

    <no properties>

  Static Properties:

    <no static properties>

  Methods:

    - initialize()
        Overrides for R3.Event.R3Object.initialize()

  Static Methods:

    <no static methods>

 **/

class Project extends R3Object {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    if (typeof options.initialized === 'undefined') {
      options.initialized = false;
    }

    if (typeof options.callDepth === 'undefined') {
      options.callDepth = 0;
    } else {
      options.callDepth++;
    }

    super(options);

    Object.assign(this, options);

    if (options.callDepth === 0) {
      this.initialize();
    } else {
      options.callDepth--;
    }

  }

  /**
   * initialize()
   * - Should raises an event(s) which indicates that this object initialized  
   */
  initialize() {

    try {
      super.initialize();
    } catch (err) {

      if (!(err instanceof TypeError)) {
        //Another unexpected error occurred - and we are not inside a base class
        throw err;
      }

      delete this.callDepth;
      this.initialized = true;

      this.createInstance();
    }

    Event.Emit(Event.OBJECT_INITIALIZED, this);
    Event.Emit(Event.PROJECT_INITIALIZED, this);

  }

}

class Utils {

  constructor(options) {

    if (typeof options === 'undefined') {
      options = {};
    }

    Object.assign(this, options);

  }

  static GetFirstParent(object, constructor) {

    if (Utils.UndefinedOrNull(constructor)) {
      throw new Error('You need to specify a constructor');
    }

    if (object.parent === null) {
      return null;
    }

    if (object.parent instanceof constructor) {
      return object.parent;
    } else {
      return Utils.GetFirstParent(object.parent, constructor);
    }

  };

  static SyntaxHighlight(json) {
    if (typeof json != 'string') {
      json = JSON.stringify(json, undefined, 2);
    }
    json = json.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
    return json.replace(/("(\u[a-zA-Z0-9]{4}|\[^u]|[^\"])*"(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?)/g, function (match) {
      let cls = 'number';
      if (/^"/.test(match)) {
        if (/:$/.test(match)) {
          cls = 'key';
        } else {
          cls = 'string';
        }
      } else if (/true|false/.test(match)) {
        cls = 'boolean';
      } else if (/null/.test(match)) {
        cls = 'null';
      }
      return '<span class="' + cls + '">' + match + '</span>';
    });
  };

  static GetParentProject(component) {

    if (Utils.UndefinedOrNull(component.parent)) {
      throw new Error('Parent not found');
    }

    if (component.parent instanceof R3.Project) {
      return component.parent;
    }

    return Utils.GetParentProject(component.parent);
  };

  static GetParents(component, parents) {

    if (Utils.UndefinedOrNull(parents)) {
      parents = [];
    }

    if (Utils.UndefinedOrNull(component.parent)) {
      return parents;
    }

    parents.push(component.parent);

    return Utils.GetParents(component.parent, parents);

  };

  /**
   * @return {boolean}
   */
  static Instance(component) {
    return Utils.Defined(component) && Utils.Defined(component.instance);
  };

  /**
   * Utils.RemoveFromSelect
   * @param select
   * @param id
   * @returns {boolean}
   * @constructor
   */
  static RemoveFromSelect(select, id) {

    let i;

    for (i = 0; i < select.options.length; i++) {
      if (select.options[i].value === id) {
        select.remove(i);
        return true;
      }
    }
    return false;
  };

  /**
   * Utils.GetSelectIndex
   *
   * Get the select index of given id
   *
   * @param select
   * @param id
   * @returns boolean true if successful
   *
   * @constructor
   */
  static SetSelectIndex(select, id) {
    for (let i = 0; i < select.options.length; i++) {
      if (select.options[i].value === id) {
        select.selectedIndex = i;
        return true;
      }
    }
    return false;
  };

  static SortSelect(select) {

    let tmp = [];
    let i;

    for (i = 1; i < select.options.length; i++) {
      tmp[i-1] = [];
      tmp[i-1][0] = select.options[i].text;
      tmp[i-1][1] = select.options[i].value;
    }

    tmp.sort();

    select.options = [select.options[0]];

    for (i = 0; i < tmp.length; i++) {
      select.options[i+1] = new Option(tmp[i][0], tmp[i][1]);
    }

    return;
  };

  /**
   * Gets the parent of object whith property of optional type constructor. If index is specified, get the parent of the
   * object with property[index] - which means the property should be an array
   * @param object
   * @param property
   * @param index
   * @param constructor
   * @returns {*}
   * @constructor
   */
  static GetParent(object, property, index, constructor) {

    if (Utils.UndefinedOrNull(constructor)) {
      constructor = null;
    }

    if (Utils.UndefinedOrNull(index)) {
      index = null;
    }

    if (object.parent) {
      /**
       * Parent defined
       */
      if (object.parent.hasOwnProperty(property)) {

        if (constructor) {

          if (index) {

            if (object.parent[property][index] instanceof constructor) {
              return object.parent[property][index];
            } else {

              if (typeof object.parent.getParent === 'function') {
                return object.parent.getParent(property, index, constructor);
              } else {
                console.warn('getParent not defined on API object : ' + object.parent + ' - you should avoid having these messsages');
                return null;
              }
            }

          } else {
            if (object.parent[property] instanceof constructor) {
              return object.parent[property];
            } else {

              if (typeof object.parent.getParent === 'function') {
                return object.parent.getParent(property, index, constructor);
              } else {
                console.warn('getParent not defined on API object : ' + object.parent + ' - you should avoid having these messsages');
                return null;
              }

            }
          }

        } else {

          if (index) {
            return object.parent[property][index];
          } else {
            return object.parent[property];
          }

        }
      } else {

        /**
         * This parent does not have the property - go a level higher
         */
        if (typeof object.parent.getParent === 'function') {
          return object.parent.getParent(property, index, constructor);
        } else {
          console.warn('getParent not defined on API object : ' + object.parent + ' - you should avoid having these messsages');
          return null;
        }
      }

    } else {
      /**
       * No parent defined
       */
      console.warn('property : ' + property + ' of type ' + constructor + ' was not found in the parent chain');
      return null;
    }

  };

  /**
   * Strips image extension from given path
   * @param imagePath
   * @constructor
   */
  static StripImageExtension(imagePath) {
    return imagePath.replace(/(\.png$|\.gif$|\.jpeg$|\.jpg$)/,'')
  };

  /**
   * Returns true if unloaded
   * @param component
   * @returns {boolean}
   * @constructor
   */
  static Unloaded(component) {
    if (
      Utils.UndefinedOrNull(component) ||
      Utils.UndefinedOrNull(component.instance)
    ) {
      return true;
    }

    return false;
  };

  /**
   *
   * @param component
   * @returns {boolean}
   * @constructor
   */
  static Loaded(component) {
    if (component && component.instance) {
      return true;
    }

    return false;
  };

  static BuildVectorSource(result, name, dimension) {

    if (dimension === 2) {
      result[name] = {};
      result[name].x = false;
      result[name].y = false;
      return;
    }

    if (dimension === 3) {
      result[name] = {};
      result[name].x = false;
      result[name].y = false;
      result[name].y = false;
      return;
    }

    if (dimension === 4) {
      result[name] = {};
      result[name].x = false;
      result[name].y = false;
      result[name].z = false;
      result[name].w = false;
      return;
    }

    console.warn('unknown dimension : ' + dimension);
  };

  /**
   * Returns all 'instances' of the array, or null if an 'instance' is undefined
   * @constructor
   * @param array
   */
  static GetArrayInstances(array) {
    return array.reduce(
      function(result, object) {

        if (result === null) {
          return result;
        }

        if (Utils.UndefinedOrNull(object.instance)) {
          result = null;
        } else {
          result.push(object.instance);
        }

        return result;
      },
      []
    );
  };

  static SortFacesByMaterialIndex(faces) {

    /**
     * Sorts faces according to material index because later we will create
     * groups for each vertice group
     */
    faces.sort(function(a, b) {

      if (a.materialIndex < b.materialIndex) {
        return -1;
      }

      if (a.materialIndex > b.materialIndex) {
        return 1;
      }

      return 0;
    });

    return faces;
  };

  static BuildQuaternionSource(result, name) {
    result[name] = {};
    result[name].axis = {};
    result[name].axis.x = false;
    result[name].axis.y = false;
    result[name].axis.z = false;
    result[name].angle = false;
    result[name].x = false;
    result[name].y = false;
    result[name].z = false;
    result[name].w = false;
  };

  static ObjectPropertiesAsBoolean(object) {
    return Object.keys(object).reduce(
      function(result, propertyId) {

        if (typeof object[propertyId] === 'function') {
          return result;
        }

        result[propertyId] = false;

        // if (object[propertyId] instanceof R3.Vector2) {
        //     Utils.BuildVectorSource(result, propertyId, 2);
        // }
        //
        // if (object[propertyId] instanceof R3.Vector3) {
        //     Utils.BuildVectorSource(result, propertyId, 3);
        // }
        //
        // if (object[propertyId] instanceof R3.Vector4) {
        //     Utils.BuildVectorSource(result, propertyId, 4);
        // }
        //
        // if (object[propertyId] instanceof R3.Quaternion) {
        //     Utils.BuildQuaternionSource(result, propertyId);
        // }

        return result;

      }.bind(this),
      {}
    );
  };

  static GetRuntime() {

    let result = null;

    R3.Event.Emit(
      R3.Event.GET_RUNTIME,
      null,
      function(runtime) {
        result = runtime;
      }
    );

    return result;
  };

  /**
   * Returns the window size or null
   * @returns {*}
   * @constructor
   */
  static GetWindowSize() {

    let size = null;

    R3.Event.Emit(
      R3.Event.GET_WINDOW_SIZE,
      null,
      function(data) {
        size = data;
      }.bind(this)
    );

    return size;

  };

  /**
   * Convenience function to update object width and height members with window size
   * @param object
   * @constructor
   */
  static UpdateWindowSize(object) {
    let size = Utils.GetWindowSize();
    object.width = size.width;
    object.height = size.height;
  };

  /**
   * Returns id of object with the name if it exists in the array, otherwise null
   * @param name
   * @param array
   * @returns {*}
   * @constructor
   */
  static ObjectIdWithNameInArray(name, array) {

    return array.reduce(
      function(result, object) {

        if (result) {
          return result;
        }

        if (name === object.name) {
          return object.id;
        }

        return null;
      },
      null
    );
  };

  static LoadIdsFromArrayToIdObject(array, idToObject) {

  };

  static LoadIdsFromObjectToIdObject(object, idToObject) {

  };

  /**
   * Gets random int exclusive of maximum but inclusive of minimum
   * @param min
   * @param max
   * @returns {*}
   * @constructor
   */
  static GetRandomInt(min, max) {
    min = Math.ceil(min);
    max = Math.floor(max);
    return Math.floor(Math.random() * (max - min)) + min; //The maximum is exclusive and the minimum is inclusive
  };

  /**
   * Gets random int inclusive of minimum and maximum
   * @param min
   * @param max
   * @returns {*}
   * @constructor
   */
  static GetRandomIntInclusive(min, max) {
    min = Math.ceil(min);
    max = Math.floor(max);
    return Math.floor(Math.random() * (max - min + 1)) + min; //The maximum is inclusive and the minimum is inclusive
  };

  static InterpolateArray(data, fitCount) {

    let linearInterpolate = function(before, after, atPoint) {
      return before + (after - before) * atPoint;
    };

    let newData = [];

    let springFactor = Number((data.length - 1) / (fitCount - 1));

    newData[0] = data[0]; // for new allocation

    for ( let i = 1; i < fitCount - 1; i++) {
      let tmp     = i * springFactor;
      let before  = Number(Math.floor(tmp)).toFixed();
      let after   = Number(Math.ceil(tmp)).toFixed();
      let atPoint = tmp - before;
      newData[i]  = linearInterpolate(data[before], data[after], atPoint);
    }

    newData[fitCount - 1] = data[data.length - 1]; // for new allocation

    return newData;
  };

  /**
   * Undefined or null check
   * @param variable
   * @returns {boolean}
   * @constructor
   */
  static UndefinedOrNull(
    variable
  ) {
    return typeof variable === 'undefined' || variable === null;
  };

  /**
   * The variable is not undefined and not null
   * @param variable
   * @returns {boolean}
   * @constructor
   */
  static Defined(
    variable
  ) {
    return typeof variable !== 'undefined' && variable !== null;
  };

  /**
   * Gets function parameters
   * @param fn
   * @constructor
   */
  static GetParameters(fn) {

    let FN_ARGS = /^function\s*[^\(]*\(\s*([^\)]*)\)/m;
    let FN_ARG_SPLIT = /,/;
    let FN_ARG = /^\s*(_?)(.+?)\s*$/;
    let STRIP_COMMENTS = /(\/\/.*$)|(\/\*[\s\S]*?\*\/)|(\s*=[^,\)]*(('(?:\'|[^'\r\n])*')|("(?:\"|[^"\r\n])*"))|(\s*=[^,\)]*))/mg;

    let parameters,
      fnText,
      argDecl;

    if (typeof fn !== 'function') {
      parameters = [];
      fnText = fn.toString().replace(STRIP_COMMENTS, '');
      argDecl = fnText.match(FN_ARGS);
      argDecl[1].split(FN_ARG_SPLIT).forEach(function(arg) {
        arg.replace(FN_ARG, function(all, underscore, name) {
          parameters.push(name);
        });
      });
    } else {
      throw Error("not a function")
    }

    return parameters;
  };

  /**
   * Returns either an ID of the object or Null
   * @param object
   * @returns {null}
   * @constructor
   */
  static IdOrNull(object) {
    if (Utils.UndefinedOrNull(object)) {
      return null;
    } else {
      if (Utils.UndefinedOrNull(object.id)) {
        console.warn('saving an object reference with no ID : ', object);
        return null;
      }
      return object.id;
    }
  };

  /**
   * Limit a property to values between -pi and +pi
   * @param property
   * @param objectProperty
   * @returns {{configurable?: boolean, enumerable?: boolean, value?, writable?: boolean, get?: Function, set?: Function}}
   * @constructor
   */
  static LimitToPI(property, objectProperty) {

    let store = objectProperty;

    return {
      get : function() {
        return store;
      },
      set : function(value) {
        while (value > Math.PI) {
          value -= (Math.PI * 2);
        }

        while (value < -(Math.PI)) {
          value += (Math.PI * 2);
        }

        store = value;
      }
    };
  };

  /**
   * Returns an array of IDs representing the objects
   * @param array
   * @returns []
   * @constructor
   */
  static IdArrayOrEmptyArray(array) {
    if (Utils.UndefinedOrNull(array)) {
      return [];
    } else {

      return array.map(function(item) {

        if (Utils.UndefinedOrNull(item.id)) {
          throw new Error('No ID found while trying to store IDs to array');
        }

        return item.id
      });
    }
  };

  /**
   * Links an object to its parent through idToObject array
   * @param propertyString
   * @param idToObject
   * @param parentObject
   * @param id
   * @constructor
   */
  static Link(propertyString, idToObject, parentObject, id) {

    if (!Utils.UndefinedOrNull(parentObject[propertyString])) {

      if (!idToObject.hasOwnProperty(id)) {
        console.warn('Linking failed for object:' + parentObject.name);
      }

      parentObject[propertyString] = idToObject[id];
    }
  };

  /**
   * Generates a random ID
   * @returns {string}
   * @constructor
   */
  static RandomId(length) {

    if (Utils.UndefinedOrNull(length)) {
      length = 10;
    }

    return Math.random().toString(36).substr(2, length);
  };

  static InvertWindingOrder(triangles) {

    for (let i = 0; i < triangles.length; i++) {
      let v1 = triangles[i].v1;
      triangles[i].v1 = triangles[i].v2;
      triangles[i].v2 = v1;

      let backupUV = triangles[i].triangle.v1uv;
      triangles[i].triangle.v1uv = triangles[i].triangle.v2uv;
      triangles[i].triangle.v2uv = backupUV;
    }

    return triangles;
  };

  /**
   * Inverts a mesh winding order (and its instance)
   * @param mesh R3.D3.Mesh
   * @returns {*}
   * @constructor
   */
  static InvertMeshWindingOrder(mesh) {

    mesh.faces.forEach(
      function(face) {

        let tmpV1 = face.v1;
        face.v1 = face.v2;
        face.v2 = tmpV1;

        let tmpV1uv = face.v1uv;
        face.v1uv = face.v2uv;
        face.v2uv = tmpV1uv;

      }.bind(this)
    );

    //mesh.computeNormals = true;
    //mesh.createInstance();
  };

  /**
   * This function resets a the winding order of a mesh from a reference point V (the average center of the mesh)
   */
  static ResetWindingOrder(faces, vertices) {

    let vertexList = new R3.API.Vector3.Points();

    for (let v = 0; v < vertices.length; v++) {
      vertexList.add(new R3.API.Vector3(
        vertices[v].position.x,
        vertices[v].position.y,
        vertices[v].position.z
      ));
    }

    let V = vertexList.average();

    let triangles = [];

    for (let s = 0; s < faces.length; s += 3) {

      let v0 = faces[s];
      let v1 = faces[s+1];
      let v2 = faces[s+2];

      triangles.push(
        {
          v0 : v0,
          v1 : v1,
          v2 : v2,
          edges : [
            {v0: v0, v1: v1},
            {v0: v1, v1: v2},
            {v0: v2, v1: v0}
          ],
          winding : 0,
          edgeIndex : -1,
          processed : false
        }
      );
    }

    for (let i = 0; i < triangles.length; i++) {
      if (
        R3.API.Vector3.clockwise(
          vertices[triangles[i].v0].position,
          vertices[triangles[i].v1].position,
          vertices[triangles[i].v2].position,
          V
        )
      ) {
        console.log('clockwise');
        let bv1 = triangles[i].v1;
        triangles[i].v1 = triangles[i].v2;
        triangles[i].v2 = bv1;
      } else {
        console.log('not clockwise');
      }
    }

    return triangles;
  };

  /**
   * This function resets the winding order for triangles in faces, given an initial triangle and orientation edge
   * used pseudocode from
   * http://stackoverflow.com/questions/17036970/how-to-correct-winding-of-triangles-to-counter-clockwise-direction-of-a-3d-mesh
   *  We need to use a graph traversal algorithm,
   *  lets assume we have method that returns neighbor of triangle on given edge
   *
   *      neighbor_on_egde( next_tria, edge )
   *
   *  to_process = set of pairs triangle and orientation edge, initial state is one good oriented triangle with any edge on it
   *  processed = set of processed triangles; initial empty
   *
   *  while to_process is not empty:
   *      next_tria, orientation_edge = to_process.pop()
   *      add next_tria in processed
   *      if next_tria is not opposite oriented than orientation_edge:
   *          change next_tria (ABC) orientation  (B<->C)
   *      for each edge (AB) in next_tria:
   *          neighbor_tria = neighbor_on_egde( next_tria, edge )
   *          if neighbor_tria exists and neighbor_tria not in processed:
   *              to_process add (neighbor_tria, edge opposite oriented (BA))
   * @param faces R3.D3.Face[]
   * @param orientationEdge R3.API.Vector2
   * @returns {Array}
   */
  static FixWindingOrder(faces, orientationEdge) {

    /**
     * Checks if a Face belonging to a TriangleEdge has already been processed
     * @param processed TriangleEdge[]
     * @param triangle Face
     * @returns {boolean}
     */
    function inProcessed(processed, triangle) {

      for (let i = 0; i < processed.length; i++) {
        if (processed[i].triangle.equals(triangle)) {
          return true;
        }
      }

      return false;
    }

    /**
     * Returns a neighbouring triangle on a specific edge - preserving the edge orientation
     * @param edge R3.API.Vector2
     * @param faces R3.D3.Face[]
     * @param currentTriangle
     * @returns {*}
     */
    function neighbourOnEdge(edge, faces, currentTriangle) {

      for (let i = 0; i < faces.length; i++) {
        if (
          (faces[i].v0 === edge.x && faces[i].v1 === edge.y) ||
          (faces[i].v1 === edge.x && faces[i].v2 === edge.y) ||
          (faces[i].v2 === edge.x && faces[i].v0 === edge.y) ||
          (faces[i].v0 === edge.y && faces[i].v1 === edge.x) ||
          (faces[i].v1 === edge.y && faces[i].v2 === edge.x) ||
          (faces[i].v2 === edge.y && faces[i].v0 === edge.x)
        ) {

          let triangle = new R3.D3.API.Face(
            null,
            null,
            faces[i].v0index,
            faces[i].v1index,
            faces[i].v2index,
            faces[i].materialIndex,
            faces[i].uvs
          );

          if (triangle.equals(currentTriangle)) {
            continue;
          }

          return new R3.D3.TriangleEdge(
            triangle,
            edge
          );
        }
      }

      return null;
    }

    let toProcess = [
      new R3.D3.TriangleEdge(
        new R3.D3.API.Face(
          null,
          null,
          faces[0].v0index,
          faces[0].v1index,
          faces[0].v2index,
          faces[0].materialIndex,
          faces[0].uvs
        ),
        orientationEdge
      )
    ];

    let processed = [];

    while (toProcess.length > 0) {

      let triangleEdge = toProcess.pop();

      /**
       * If edge is the same orientation (i.e. the edge order is the same as the given triangle edge) it needs to be reversed
       * to have the same winding order)
       */
      if (
        (triangleEdge.triangle.v0index === triangleEdge.edge.x &&
          triangleEdge.triangle.v1index === triangleEdge.edge.y) ||
        (triangleEdge.triangle.v1index === triangleEdge.edge.x &&
          triangleEdge.triangle.v2index === triangleEdge.edge.y) ||
        (triangleEdge.triangle.v2index === triangleEdge.edge.x &&
          triangleEdge.triangle.v0index === triangleEdge.edge.y)
      ) {
        let backupV = triangleEdge.triangle.v1index;
        triangleEdge.triangle.v1index = triangleEdge.triangle.v2index;
        triangleEdge.triangle.v2index = backupV;

        // let backupUV = triangleEdge.triangle.v1uv;
        // triangleEdge.triangle.v1uv = triangleEdge.triangle.v2uv;
        // triangleEdge.triangle.v2uv = backupUV;
        //
        let backupUV = triangleEdge.triangle.uvs[0][1];
        triangleEdge.triangle.uvs[0][1] = triangleEdge.triangle.uvs[0][2];
        triangleEdge.triangle.uvs[0][2] = backupUV;
      }

      processed.push(triangleEdge);

      let edges = [
        new R3.API.Vector2(
          triangleEdge.triangle.v0index,
          triangleEdge.triangle.v1index
        ),
        new R3.API.Vector2(
          triangleEdge.triangle.v1index,
          triangleEdge.triangle.v2index
        ),
        new R3.API.Vector2(
          triangleEdge.triangle.v2index,
          triangleEdge.triangle.v0index
        )
      ];

      for (let j = 0; j < edges.length; j++) {
        let neighbour = neighbourOnEdge(edges[j], faces, triangleEdge.triangle);
        if (neighbour && !inProcessed(processed, neighbour.triangle)) {
          toProcess.push(neighbour);
        }
      }
    }

    /**
     * In processed - we will have some duplicates - only add the unique ones
     * @type {Array}
     */
    let triangles = [];
    for (let i = 0; i < processed.length; i++) {
      let found = false;
      for (let k = 0; k < triangles.length; k++) {
        if (triangles[k].equals(processed[i].triangle)){
          found = true;
          break;
        }
      }
      if (!found) {
        triangles.push(processed[i].triangle);
      }
    }

    return triangles;
  };

  /**
   * This is a work-around function to fix polys which don't triangulate because
   * they could lie on Z-plane (XZ or YZ)) - we translate the poly to the origin, systematically rotate the poly around
   * Z then Y axis
   * @param verticesFlat []
   * @param grain is the amount to systematically rotate the poly by - a finer grain means a more accurate maximum XY
   * @return []
   */
  static FixPolyZPlane(verticesFlat, grain) {

    if ((verticesFlat.length % 3) !== 0 && !(verticesFlat.length > 9)) {
      console.log("The vertices are not in the right length : " + verticesFlat.length);
    }

    let vertices = [];

    let points = new R3.API.Quaternion.Points();

    for (let i = 0; i < verticesFlat.length; i += 3) {
      points.add(new R3.API.Vector3(
        verticesFlat[i],
        verticesFlat[i + 1],
        verticesFlat[i + 2]
      ));
    }

    points.toOrigin();

    points.maximizeXDistance(grain);

    points.maximizeYDistance(grain);

    for (i = 0; i < points.vectors.length; i++) {
      vertices.push(
        [
          points.vectors[i].x,
          points.vectors[i].y
        ]
      );
    }

    return vertices;
  };

  static MovingAverage(period) {
    let nums = [];
    return function(num) {
      nums.push(num);
      if (nums.length > period)
        nums.splice(0,1);  // remove the first element of the array
      let sum = 0;
      for (let i in nums)
        sum += nums[i];
      let n = period;
      if (nums.length < period)
        n = nums.length;
      return(sum/n);
    }
  };

  static Intersect(a, b) {

    let t;

    /**
     * Loop over shortest array
     */
    if (b.length > a.length) {
      t = b;
      b = a;
      a = t;
    }

    return a.filter(
      /**
       * Check if exists
       * @param e
       * @returns {boolean}
       */
      function(e) {
        return (b.indexOf(e) > -1);
      }
    ).filter(
      /**
       * Remove Duplicates
       * @param e
       * @param i
       * @param c
       * @returns {boolean}
       */
      function(e, i, c) {
        return c.indexOf(e) === i;
      }
    );
  };

  static Difference(a, b) {

    let t;

    /**
     * Loop over shortest array
     */
    if (b.length > a.length) {
      t = b;
      b = a;
      a = t;
    }

    return a.filter(
      /**
       * Check if exists
       * @param e
       * @returns {boolean}
       */
      function(e) {
        return (b.indexOf(e) === -1);
      }
    ).filter(
      /**
       * Remove Duplicates
       * @param e
       * @param i
       * @param c
       * @returns {boolean}
       */
      function(e, i, c) {
        return c.indexOf(e) === i;
      }
    );
  };

  /**
   * Push only if not in there already
   * @param array
   * @param object
   * @constructor
   */
  static PushUnique(array, object) {

    if (array.indexOf(object) === -1) {
      array.push(object);
    }
  };

  /**
   * Checks whether or not the object is empty
   * @param obj
   * @returns {boolean}
   * @constructor
   */
  static IsEmpty(obj) {
    return (Object.keys(obj).length === 0 && obj.constructor === Object);
  };

  static IsString(member) {
    return (typeof member === 'string');
  };

  static IsBoolean(member) {
    return (member === true || member === false);
  };

  static IsColor(member) {
    return (member instanceof R3.Color);
  };

  static IsNumber(member) {
    return (typeof member === 'number');
  };

  static IsVector2(member) {
    return (
      member instanceof R3.API.Vector2 ||
      member instanceof R3.Vector2
    );
  };

  static IsVector3(member) {
    return (
      member instanceof R3.API.Vector3 ||
      member instanceof R3.Vector3
    );
  };

  static IsVector4(member) {
    return (
      member instanceof R3.API.Vector4 ||
      member instanceof R3.Vector4 ||
      member instanceof R3.API.Quaternion ||
      member instanceof R3.Quaternion
    );
  };

  static IsObject(member) {
    let type = typeof member;
    return type === 'function' || type === 'object' && !!member;
  };

  /**
   * @return {string}
   */
  static LowerUnderscore(name) {
    let string = name.toLowerCase().replace(/\s+/g, '_');
    string = string.replace(/-/g, '_');
    string = string.replace(/\_+/g, '_');
    return string;
  };

  static UpperCaseWordsSpaces(input) {

    let word = input.replace(/[-_]/g, ' ');

    word = word.replace(/\s+/, ' ');

    let words = word.split(' ');

    return words.reduce(
      function(result, word) {
        result += word[0].toUpperCase() + word.substr(1);
        return result + ' ';
      },
      ''
    ).trim();
  };

  /**
   * @return {string}
   */
  static UpperCaseUnderscore(word) {

    let str = '';

    word.split('').map(
      function(letter){
      if (letter === letter.toUpperCase()) {
        str += '_' + letter;
      } else {
        str += letter.toUpperCase();
      }
    });

    str = str.replace(new RegExp('^_'),'');

    return str;
  };

  /**
   * Returns Left Padded Text - ex. length 5, padchar 0, string abc = '00abc'
   * @param length
   * @param padChar
   * @param string
   * @returns {string}
   * @constructor
   */
  static PaddedText(length, padChar, string) {

    let pad = "";

    for (let x = 0; x < length; x++) {
      pad += padChar;
    }

    return pad.substring(0, pad.length - string.length) + string;
  };

}

System.DOM = SystemDOM;
System.Input = SystemInput;
System.Linking = SystemLinking;
System.Render = SystemRender;
System.Runtime = SystemRuntime;
System.Socket = SystemSocket;
System.Storage = SystemStorage;
Component.DOM = ComponentDOM;
Component.DOM.Canvas = ComponentCanvas;
Component.Graphics = ComponentGraphics;
Component.Graphics.Image = ComponentImage;
Component.Graphics.Material = ComponentMaterial;
Component.Graphics.Mesh = ComponentMesh;
Component.Graphics.Texture = ComponentTexture;
Component.Input = ComponentInput;
Component.Input.Touch = ComponentTouch;
Runtime.Coder = RuntimeCoder;
Runtime.Coder.CodeMirror = RuntimeCodeMirror;
Runtime.DOM = RuntimeDOM;
Runtime.DOM.Document = RuntimeDocument;
Runtime.GUI = RuntimeGUI;
Runtime.GUI.ControlKit = RuntimeControlKit;
Runtime.Graphics = RuntimeGraphics;
Runtime.Graphics.Three = RuntimeThree;
Runtime.Image = RuntimeImage;
Runtime.Image.NodeJSImage = RuntimeNodeJSImage;
Runtime.Image.WebImage = RuntimeWebImage;
Runtime.Physics = RuntimePhysics;
Runtime.Physics.Bullet = RuntimeBullet;
Runtime.Socket = RuntimeSocket;
Runtime.Statistics = RuntimeStatistics;
Runtime.Statistics.Stats = RuntimeStats;
Entity.Slider = EntitySlider;
R3.Runtime = Runtime;
R3.System = System;
R3.Event = Event;
R3.Utils = Utils;
R3.Object = R3Object;
R3.Entity = Entity;
R3.Component = Component;
R3.Project = Project;
R3.Canvas = Component.DOM.Canvas;
R3.Image = Component.Graphics.Image;
R3.Material = Component.Graphics.Material;
R3.Mesh = Component.Graphics.Mesh;
R3.Texture = Component.Graphics.Texture;
R3.Touch = Component.Input.Touch;

console.log('r3.js - version ' + R3.version + ' compiled ' + R3.compileDate);
R3.System.DOM.Start();
R3.System.Input.Start();
R3.System.Linking.Start();
R3.System.Render.Start();
R3.System.Runtime.Start();
R3.System.Socket.Start();
R3.System.Storage.Start();