From 3835bbe9fae5f3374bde66fe0c50c8dde22fd8f9 Mon Sep 17 00:00:00 2001 From: "Theunis J. Botha" Date: Sun, 4 Jul 2021 20:32:41 +0200 Subject: [PATCH] generate indexes + r3-r3.js --- dist/r3.js | 3479 ++++++++++++++++++++++++++------ package.json | 3 +- src/r3/index.js | 19 +- src/r3/r3-component/index.js | 3 + src/r3/r3-r3.js | 13 +- src/r3/r3-system/index.js | 3 + src/templates/index.template | 3 + src/templates/r3-base.template | 7 +- src/templates/token.db | 2 + update_templates.php | 51 + version | 1 + 11 files changed, 2938 insertions(+), 646 deletions(-) create mode 100644 version diff --git a/dist/r3.js b/dist/r3.js index c34c9e6..d1c3333 100644 --- a/dist/r3.js +++ b/dist/r3.js @@ -1,290 +1,439 @@ -/******/ (function(modules) { // webpackBootstrap -/******/ // The module cache -/******/ var installedModules = {}; -/******/ -/******/ // The require function -/******/ function __webpack_require__(moduleId) { -/******/ -/******/ // Check if module is in cache -/******/ if(installedModules[moduleId]) { -/******/ return installedModules[moduleId].exports; -/******/ } -/******/ // Create a new module (and put it into the cache) -/******/ var module = installedModules[moduleId] = { -/******/ i: moduleId, -/******/ l: false, -/******/ exports: {} -/******/ }; -/******/ -/******/ // Execute the module function -/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); -/******/ -/******/ // Flag the module as loaded -/******/ module.l = true; -/******/ -/******/ // Return the exports of the module -/******/ return module.exports; -/******/ } -/******/ -/******/ -/******/ // expose the modules object (__webpack_modules__) -/******/ __webpack_require__.m = modules; -/******/ -/******/ // expose the module cache -/******/ __webpack_require__.c = installedModules; -/******/ -/******/ // define getter function for harmony exports -/******/ __webpack_require__.d = function(exports, name, getter) { -/******/ if(!__webpack_require__.o(exports, name)) { -/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); -/******/ } -/******/ }; -/******/ -/******/ // define __esModule on exports -/******/ __webpack_require__.r = function(exports) { -/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { -/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); -/******/ } -/******/ Object.defineProperty(exports, '__esModule', { value: true }); -/******/ }; -/******/ -/******/ // create a fake namespace object -/******/ // mode & 1: value is a module id, require it -/******/ // mode & 2: merge all properties of value into the ns -/******/ // mode & 4: return value when already ns object -/******/ // mode & 8|1: behave like require -/******/ __webpack_require__.t = function(value, mode) { -/******/ if(mode & 1) value = __webpack_require__(value); -/******/ if(mode & 8) return value; -/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; -/******/ var ns = Object.create(null); -/******/ __webpack_require__.r(ns); -/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); -/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); -/******/ return ns; -/******/ }; -/******/ -/******/ // getDefaultExport function for compatibility with non-harmony modules -/******/ __webpack_require__.n = function(module) { -/******/ var getter = module && module.__esModule ? -/******/ function getDefault() { return module['default']; } : -/******/ function getModuleExports() { return module; }; -/******/ __webpack_require__.d(getter, 'a', getter); -/******/ return getter; -/******/ }; -/******/ -/******/ // Object.prototype.hasOwnProperty.call -/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; -/******/ -/******/ // __webpack_public_path__ -/******/ __webpack_require__.p = ""; -/******/ -/******/ -/******/ // Load entry module and return exports -/******/ return __webpack_require__(__webpack_require__.s = "./src/r3/index.js"); -/******/ }) -/************************************************************************/ -/******/ ({ +const Event = require('.././r3-event'); +const Utils = require('.././r3-utils'); -/***/ "./src/r3/index.js": -/*!*************************!*\ - !*** ./src/r3/index.js ***! - \*************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -var R3 = __webpack_require__(/*! ./r3.js */ "./src/r3/r3.js"); - -R3.System.Linking.start(); -R3.System.Socket.start(); -module.exports = R3; - -/***/ }), - -/***/ "./src/r3/r3-event.js": -/*!****************************!*\ - !*** ./src/r3/r3-event.js ***! - \****************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } - -var Utils = __webpack_require__(!(function webpackMissingModule() { var e = new Error("Cannot find module 'r3-utils'"); e.code = 'MODULE_NOT_FOUND'; throw e; }())); /** - OPTIONS_START - OPTIONS_END + CUSTOM_OPTIONS_START + started=false + CUSTOM_OPTIONS_END + + CUSTOM_METHODS_START + start(options) - Just calls System.Start(options) + stop(options) - Just calls System.Stop(options) + CUSTOM_METHODS_END + + CUSTOM_STATIC_METHODS_START + Start(options) - Starts the system by registering subscriptions to events + Stop(options) - Stops the system by removing these subscriptions to events + CUSTOM_STATIC_METHODS_END **/ +class System { -var Event = /*#__PURE__*/function () { - //CONSTRUCTOR_TEMPLATE_START - function Event(options) { - _classCallCheck(this, Event); + //GENERATE_CONSTRUCTOR_START + constructor(options) { - Event.Emit(Event.OBJECT_CREATED, this); //OPTIONS_INIT_START + Event.Emit(Event.OBJECT_CREATED, this); + //GENERATE_OPTIONS_INIT_START if (typeof options === 'undefined') { options = {}; - } //OPTIONS_INIT_END + } + if (Utils.UndefinedOrNull(options.started)) { + options.started = false; + } + //GENERATE_OPTIONS_INIT_END + //CUSTOM_OPTIONS_INIT_START //CUSTOM_OPTIONS_INIT_END + Object.assign(this, options); - Object.assign(this, options); //CUSTOM_BEFORE_INIT_START + //CUSTOM_BEFORE_INIT_START //CUSTOM_BEFORE_INIT_END Event.Emit(Event.OBJECT_INITIALIZED, this); - } //CONSTRUCTOR_TEMPLATE_END + + //CUSTOM_AFTER_INIT_START + //CUSTOM_AFTER_INIT_END + } + //GENERATE_CONSTRUCTOR_END + //CUSTOM_IMPLEMENTATION_START + //CUSTOM_IMPLEMENTATION_END + + //GENERATE_METHODS_START /** - * Some nice Events handling - * @type {{}} + * start() + * - Just calls System.Start(options) + * @param options */ + start(options) { + //GENERATE_START_METHOD_START + //GENERATE_START_METHOD_END + + //CUSTOM_START_METHOD_START + System.Start(options); - _createClass(Event, [{ - key: "subscribe", - value: /** - * Subscribe to some events - * @param eventName - * @param callback - */ - function subscribe(eventName, callback) { - return Event.Subscribe(eventName, callback.bind(this)); - } - }, { - key: "emit", - value: function emit(eventName, data, clientCallback, clientErrorCallback) { - return Event.Emit(eventName, data, clientCallback, clientErrorCallback); - } - /** - * Execute the functions which subscribe to this event, but don't process the client callback - the subscription function - * should execute the client callback - * @param eventId - * @param data - * @param clientCallback - * @param clientErrorCallback - * @returns {number} - * @constructor + * Now do something else */ - }], [{ - key: "Subscribe", - value: function Subscribe(eventName, fn) { - /** - * Todo - maybe eventually store a boolean which indicates if the function has been executed - */ - var subscriptionId = Utils.RandomId(10); + console.log('something else'); + //CUSTOM_START_METHOD_END - if (Event.Subscriptions.hasOwnProperty(eventName)) { - if (Event.Subscriptions[eventName][subscriptionId]) { - throw new Error('A component can only subscribe to a particular event ID once'); - } + } - Event.Subscriptions[eventName][subscriptionId] = fn; - } else { - Event.Subscriptions[eventName] = {}; - Event.Subscriptions[eventName][subscriptionId] = fn; - } - /** - * Return a handle to the caller to allow us to unsubscribe to this event - */ + /** + * stop() + * - Just calls System.Stop(options) + * @param options + */ + stop(options) { + //GENERATE_STOP_METHOD_START + //GENERATE_STOP_METHOD_END - return { - fn: fn, - 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[]} - */ + //CUSTOM_STOP_METHOD_START + System.Stop(options); + //CUSTOM_STOP_METHOD_END - var listeners = Object.keys(Event.Subscriptions[eventId]); + } + //GENERATE_METHODS_END - if (listeners.length === 0) { - delete Event.Subscriptions[eventId]; - } - }; - }(eventName, subscriptionId), - subscriptionId: subscriptionId - }; - } - }, { - key: "Emit", - value: - /** - * Static Synchronous Event - Calls clientCallback directly after the event result is obtained - * @param eventId - * @param data - * @param clientCallback is executed ideally when the event completed - * @param clientErrorCallback - * @returns {number} of callbacks executed - * @constructor - */ - function Emit(eventId, data, clientCallback, clientErrorCallback) { - if (Event.Subscriptions.hasOwnProperty(eventId)) { - var subscriptionIds = Object.keys(Event.Subscriptions[eventId]); - subscriptionIds.map(function (subscriptionId) { - try { - var result = Event.Subscriptions[eventId][subscriptionId](data); + //GENERATE_STATIC_METHODS_START - if (clientCallback) { - clientCallback(result); - } - } catch (error) { - if (clientErrorCallback) { - clientErrorCallback(error); - } else { - console.error(error); - throw error; - } - } - }); - } - } - }, { - key: "Async", - value: function Async(eventId, data, clientCallback, clientErrorCallback) { - if (Event.Subscriptions.hasOwnProperty(eventId)) { - var 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; - } - } - }); - } - } - }]); + /** + * Start() + * - Starts the system by registering subscriptions to events + * @param options + */ + static Start(options) { - return Event; -}(); + //GENERATE_STATIC_START_METHOD_START + //GENERATE_STATIC_START_METHOD_END -_defineProperty(Event, "Subscriptions", {}); + //CUSTOM_STATIC_START_METHOD_START + console.log('Starting system X'); + //CUSTOM_STATIC_START_METHOD_END + + } + + /** + * Stop() + * - Stops the system by removing these subscriptions to events + * @param options + */ + static Stop(options) { + + //GENERATE_STATIC_STOP_METHOD_START + //GENERATE_STATIC_STOP_METHOD_END + + //CUSTOM_STATIC_STOP_METHOD_START + console.log('Stopping system X'); + //CUSTOM_STATIC_STOP_METHOD_END + + } + //GENERATE_STATIC_METHODS_END + +} //CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_START +//CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_END + +module.exports = System;const Utils = require('./r3-utils'); + +/** + + GENERATE_INHERITED_START + + GENERATE_INHERITED_END + + CUSTOM_OPTIONS_START + CUSTOM_OPTIONS_END + + CUSTOM_METHODS_START + 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 + CUSTOM_METHODS_END + + CUSTOM_STATIC_METHODS_START + 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 @return {Object} - A handle to the subscription which can be removed by calling handle.remove() + CUSTOM_STATIC_METHODS_END + + **/ + +class Event { + + //GENERATE_CONSTRUCTOR_START + constructor(options) { + + Event.Emit(Event.OBJECT_CREATED, this); + + //GENERATE_OPTIONS_INIT_START + //GENERATE_OPTIONS_INIT_END + + //CUSTOM_OPTIONS_INIT_START + //CUSTOM_OPTIONS_INIT_END + + Object.assign(this, options); + + //CUSTOM_BEFORE_INIT_START + //CUSTOM_BEFORE_INIT_END + + Event.Emit(Event.OBJECT_INITIALIZED, this); + + //CUSTOM_AFTER_INIT_START + //CUSTOM_AFTER_INIT_END + } + //GENERATE_CONSTRUCTOR_END + + //CUSTOM_IMPLEMENTATION_START + + /** + * Some nice Events handling + * @type {{}} + */ + static Subscriptions = {}; + + //CUSTOM_IMPLEMENTATION_END + + //GENERATE_METHODS_START + + /** + * async() + * - Simply calls 'Async()' passing it the arguments + * @param eventId + * @param data + * @param clientCallback + * @param clientErrorCallback + */ + async( + eventId, + data, + clientCallback, + clientErrorCallback + ) { + + //GENERATE_ASYNC_METHOD_START + //GENERATE_ASYNC_METHOD_END + + //CUSTOM_ASYNC_METHOD_START + return Event.Async( + eventId, + data, + clientCallback, + clientErrorCallback + ); + //CUSTOM_ASYNC_METHOD_END + + } + + /** + * emit() + * - Simply calls 'Emit()' passing it the arguments + * @param eventId + * @param data + * @param clientCallback + * @param clientErrorCallback + */ + emit( + eventId, + data, + clientCallback, + clientErrorCallback + ) { + + //GENERATE_EMIT_METHOD_START + //GENERATE_EMIT_METHOD_END + + //CUSTOM_EMIT_METHOD_START + return Event.Emit( + eventId, + data, + clientCallback, + clientErrorCallback + ); + //CUSTOM_EMIT_METHOD_END + + } + + /** + * subscribe() + * - Simply calls 'Subscribe()' passing it the arguments + * @param eventId + * @param callback + */ + subscribe( + eventId, + callback + ) { + + //GENERATE_SUBSCRIBE_METHOD_START + //GENERATE_SUBSCRIBE_METHOD_END + + //CUSTOM_SUBSCRIBE_METHOD_START + return Event.Subscribe(eventId, callback.bind(this)); + //CUSTOM_SUBSCRIBE_METHOD_END + + } + //GENERATE_METHODS_END + + //GENERATE_STATIC_METHODS_START + + /** + * 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 + ) { + + //GENERATE_STATIC_ASYNC_METHOD_START + //GENERATE_STATIC_ASYNC_METHOD_END + + //CUSTOM_STATIC_ASYNC_METHOD_START + 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; + } + } + } + ) + } + //CUSTOM_STATIC_ASYNC_METHOD_END + + } + + /** + * 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 + ) { + + //GENERATE_STATIC_EMIT_METHOD_START + //GENERATE_STATIC_EMIT_METHOD_END + + //CUSTOM_STATIC_EMIT_METHOD_START + 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; + } + } + } + ) + } + //CUSTOM_STATIC_EMIT_METHOD_END + + } + + /** + * Subscribe() + * - Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised + * @param eventId + * @param callback \n * @returns {Object} - A handle to the subscription which can be removed by calling handle.remove() + */ + static Subscribe( + eventId, + callback + ) { + + //GENERATE_STATIC_SUBSCRIBE_METHOD_START + //GENERATE_STATIC_SUBSCRIBE_METHOD_END + + //CUSTOM_STATIC_SUBSCRIBE_METHOD_START + 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]; + } + } + + }(eventId, subscriptionId), + subscriptionId : subscriptionId + }; + //CUSTOM_STATIC_SUBSCRIBE_METHOD_END + + } + //GENERATE_STATIC_METHODS_END + +} + +//CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_START + //EVENT_GENERATED_START Event.COMPONENT_INITIALIZED = 0x1; Event.CREATE_INSTANCE_BEFORE = 0x2; @@ -305,491 +454,2561 @@ Event.UPDATE_INSTANCE_AFTER = 0x10; Event.UPDATE_INSTANCE_BEFORE = 0x11; Event.MAX_EVENTS = 0x12; -Event.GetEventName = function (eventId) { - switch (eventId) { - case 0x1: - return 'component_initialized'; +Event.GetEventName = function(eventId) { - case 0x2: - return 'create_instance_before'; + switch(eventId) { + case 0x1 : return 'component_initialized'; + case 0x2 : return 'create_instance_before'; + case 0x3 : return 'dispose_instance'; + case 0x4 : return 'dispose_object'; + case 0x5 : return 'get_runtime'; + case 0x6 : return 'get_window_size'; + case 0x7 : return 'instance_created'; + case 0x8 : return 'instance_disposed'; + case 0x9 : return 'object_created'; + case 0xa : return 'object_initialized'; + case 0xb : return 'pause'; + case 0xc : return 'restart'; + case 0xd : return 'start'; + case 0xe : return 'update_from_instance_after'; + case 0xf : return 'update_from_instance_before'; + case 0x10 : return 'update_instance_after'; + case 0x11 : return 'update_instance_before'; + default : + throw new Error('Event type not defined : ' + eventId); + } - case 0x3: - return 'dispose_instance'; +}; +//EVENT_GENERATED_END - case 0x4: - return 'dispose_object'; - - case 0x5: - return 'get_runtime'; - - case 0x6: - return 'get_window_size'; - - case 0x7: - return 'instance_created'; - - case 0x8: - return 'instance_disposed'; - - case 0x9: - return 'object_created'; - - case 0xa: - return 'object_initialized'; - - case 0xb: - return 'pause'; - - case 0xc: - return 'restart'; - - case 0xd: - return 'start'; - - case 0xe: - return 'update_from_instance_after'; - - case 0xf: - return 'update_from_instance_before'; - - case 0x10: - return 'update_instance_after'; - - case 0x11: - return 'update_instance_before'; - - default: - throw new Error('Event type not defined : ' + eventId); - } -}; //EVENT_GENERATED_END //CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_END +module.exports = Event;const Event = require('./r3-event'); -module.exports = Event; - -/***/ }), - -/***/ "./src/r3/r3-r3-object.js": -/*!********************************!*\ - !*** ./src/r3/r3-r3-object.js ***! - \********************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } - -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - -function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } - -function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - -function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - -function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } - -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - -var Utils = __webpack_require__(!(function webpackMissingModule() { var e = new Error("Cannot find module 'r3-utils'"); e.code = 'MODULE_NOT_FOUND'; throw e; }())); - -var Event = __webpack_require__(!(function webpackMissingModule() { var e = new Error("Cannot find module 'r3-event.js'"); e.code = 'MODULE_NOT_FOUND'; throw e; }())); /** - OPTIONS_START - id=Utils.RandomId(10) - name=this.constructor.name + '(' + options.id + ')' - register=true - OPTIONS_END + GENERATE_INHERITED_START - INSTANCE_OPTIONS_MAPPING_START - INSTANCE_OPTIONS_MAPPING_END + GENERATE_INHERITED_END - LINKED_OBJECTS_START - LINKED_OBJECTS_END + CUSTOM_OPTIONS_START + CUSTOM_OPTIONS_END - EXCLUDED_FROM_INSTANCE_OPTIONS_START - id - name - register - EXCLUDED_FROM_INSTANCE_OPTIONS_END + CUSTOM_METHODS_START + CUSTOM_METHODS_END + + CUSTOM_STATIC_METHODS_START + CUSTOM_STATIC_METHODS_END **/ +class Utils { -var R3Object = /*#__PURE__*/function (_Event) { - _inherits(R3Object, _Event); + //GENERATE_CONSTRUCTOR_START + constructor(options) { - var _super = _createSuper(R3Object); + Event.Emit(Event.OBJECT_CREATED, this); - //CONSTRUCTOR_EXTENDS_TEMPLATE_START - function R3Object(options) { - var _this; + //GENERATE_OPTIONS_INIT_START + //GENERATE_OPTIONS_INIT_END - _classCallCheck(this, R3Object); + //CUSTOM_OPTIONS_INIT_START + //CUSTOM_OPTIONS_INIT_END + + Object.assign(this, options); + + //CUSTOM_BEFORE_INIT_START + //CUSTOM_BEFORE_INIT_END + + Event.Emit(Event.OBJECT_INITIALIZED, this); + + //CUSTOM_AFTER_INIT_START + //CUSTOM_AFTER_INIT_END + } + //GENERATE_CONSTRUCTOR_END + + //CUSTOM_IMPLEMENTATION_START + 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, '&').replace(//g, '>'); + 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 '' + match + ''; + }); + }; + + 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; + }; + //CUSTOM_IMPLEMENTATION_END + + //GENERATE_METHODS_START + //GENERATE_METHODS_END + + //GENERATE_STATIC_METHODS_START + //GENERATE_STATIC_METHODS_END + +} + +//CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_START +//CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_END + +module.exports = Utils;const Event = require('.././r3-event'); +const Utils = require('.././r3-utils'); +const System = require('./r3-system.js'); + +/** + + GENERATE_INHERITED_START + + [Inherited from System] + + Properties: + + - started (Default value false) + + Methods: + + - start(options) + Just calls System.Start(options) + + - stop(options) + Just calls System.Stop(options) + + Static Methods: + + - Start(options) + Starts the system by registering subscriptions to events + + - Stop(options) + Stops the system by removing these subscriptions to events + + [Belonging to SystemLinking] + + Properties: + + + + Methods: + + + + Static Methods: + + + + GENERATE_INHERITED_END + + CUSTOM_OPTIONS_START + CUSTOM_OPTIONS_END + + CUSTOM_EVENT_LISTENERS_START + CUSTOM_EVENT_LISTENERS_END + + **/ + +class SystemLinking extends System { + + //GENERATE_CONSTRUCTOR_EXTENDS_START + constructor(options) { if (Utils.UndefinedOrNull(options)) { options = {}; } - _this = _super.call(this, options); + super(options); - _this.emit(Event.OBJECT_CREATED, _assertThisInitialized(_this)); //OPTIONS_INIT_START + this.emit(Event.OBJECT_CREATED, this); + //GENERATE_OPTIONS_INIT_START + //GENERATE_OPTIONS_INIT_END - if (typeof options === 'undefined') { - options = {}; - } - - if (Utils.UndefinedOrNull(options.id)) { - options.id = Utils.RandomId(10); - } - - if (Utils.UndefinedOrNull(options.name)) { - options.name = _this.constructor.name + '(' + options.id + ')'; - } - - if (Utils.UndefinedOrNull(options.register)) { - options.register = true; - } //OPTIONS_INIT_END //CUSTOM_OPTIONS_INIT_START //CUSTOM_OPTIONS_INIT_END + Object.assign(this, options); - Object.assign(_assertThisInitialized(_this), options); //CUSTOM_BEFORE_INIT_START + //CUSTOM_BEFORE_INIT_START //CUSTOM_BEFORE_INIT_END - _this.emit(Event.OBJECT_INITIALIZED, _assertThisInitialized(_this)); + this.emit(Event.OBJECT_INITIALIZED, this); - return _this; - } //CONSTRUCTOR_EXTENDS_TEMPLATE_END - //CREATE_INSTANCE_TEMPLATE_START + //CUSTOM_AFTER_INIT_START + //CUSTOM_AFTER_INIT_END + } + //GENERATE_CONSTRUCTOR_EXTENDS_END + //GENERATE_EVENT_LISTENERS_START + //GENERATE_EVENT_LISTENERS_END - _createClass(R3Object, [{ - key: "createInstance", - value: function createInstance() { - //CREATE_INSTANCE_BEFORE_START - this.emit(Event.CREATE_INSTANCE_BEFORE, this); //CREATE_INSTANCE_BEFORE_END - //CUSTOM_CREATE_INSTANCE_START - //CUSTOM_CREATE_INSTANCE_END - //CREATE_INSTANCE_AFTER_START + //CUSTOM_IMPLEMENTATION_START + //CUSTOM_IMPLEMENTATION_END - this[this.runtime].createInstance(this, {//CREATE_INSTANCE_OPTIONS_START - //CREATE_INSTANCE_OPTIONS_END - }); - this.emit(Event.INSTANCE_CREATED, this); //CREATE_INSTANCE_AFTER_END - } //CREATE_INSTANCE_TEMPLATE_END - //UPDATE_INSTANCE_TEMPLATE_START +} - }, { - key: "updateInstance", - value: function updateInstance(property) { - //UPDATE_INSTANCE_BEFORE_START - this.emit(Event.UPDATE_INSTANCE_BEFORE, this); //UPDATE_INSTANCE_BEFORE_END - //UPDATE_INSTANCE_OPTIONS_START - //UPDATE_INSTANCE_OPTIONS_END - //CUSTOM_UPDATE_INSTANCE_START - //CUSTOM_UPDATE_INSTANCE_END - //UPDATE_INSTANCE_AFTER_START +//CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_START +//CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_END - this.emit(Event.UPDATE_INSTANCE_AFTER, this); //UPDATE_INSTANCE_AFTER_END - } //UPDATE_INSTANCE_TEMPLATE_END - //UPDATE_FROM_INSTANCE_TEMPLATE_START +module.exports = SystemLinking;const Event = require('.././r3-event'); +const Utils = require('.././r3-utils'); +const System = require('./r3-system.js'); - }, { - key: "updateFromInstance", - value: function updateFromInstance(property) { - //UPDATE_FROM_INSTANCE_BEFORE_START - this.emit(Event.UPDATE_FROM_INSTANCE_BEFORE, this); //UPDATE_FROM_INSTANCE_BEFORE_END - //UPDATE_FROM_INSTANCE_OPTIONS_START - //UPDATE_FROM_INSTANCE_OPTIONS_END - //CUSTOM_UPDATE_FROM_INSTANCE_START - //CUSTOM_UPDATE_FROM_INSTANCE_END - //UPDATE_FROM_INSTANCE_AFTER_START +/** - this.emit(Event.UPDATE_FROM_INSTANCE_AFTER, this); //UPDATE_FROM_INSTANCE_AFTER_END - } //UPDATE_FROM_INSTANCE_TEMPLATE_END - //DISPOSE_TEMPLATE_START + GENERATE_INHERITED_START - }, { - key: "dispose", - value: function dispose() { - //DISPOSE_BEFORE_START - this.subscribe(Event.INSTANCE_DISPOSED, function (object) { + [Inherited from System] + + Properties: + + - started (Default value false) + + Methods: + + - start(options) + Just calls System.Start(options) + + - stop(options) + Just calls System.Stop(options) + + Static Methods: + + - Start(options) + Starts the system by registering subscriptions to events + + - Stop(options) + Stops the system by removing these subscriptions to events + + [Belonging to SystemSocket] + + Properties: + + + + Methods: + + + + Static Methods: + + + + GENERATE_INHERITED_END + + CUSTOM_OPTIONS_START + CUSTOM_OPTIONS_END + + CUSTOM_EVENT_LISTENERS_START + CUSTOM_EVENT_LISTENERS_END + + **/ + +class SystemSocket extends System { + + //GENERATE_CONSTRUCTOR_EXTENDS_START + constructor(options) { + + if (Utils.UndefinedOrNull(options)) { + options = {}; + } + + super(options); + + this.emit(Event.OBJECT_CREATED, this); + + //GENERATE_OPTIONS_INIT_START + //GENERATE_OPTIONS_INIT_END + + //CUSTOM_OPTIONS_INIT_START + //CUSTOM_OPTIONS_INIT_END + + Object.assign(this, options); + + //CUSTOM_BEFORE_INIT_START + //CUSTOM_BEFORE_INIT_END + + this.emit(Event.OBJECT_INITIALIZED, this); + + //CUSTOM_AFTER_INIT_START + //CUSTOM_AFTER_INIT_END + } + //GENERATE_CONSTRUCTOR_EXTENDS_END + + //GENERATE_EVENT_LISTENERS_START + //GENERATE_EVENT_LISTENERS_END + + //CUSTOM_IMPLEMENTATION_START + //CUSTOM_IMPLEMENTATION_END + +} + +//CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_START +//CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_END + +module.exports = SystemSocket;const Event = require('.././r3-event'); +const Utils = require('.././r3-utils'); +const System = require('./r3-system.js'); + +/** + + GENERATE_INHERITED_START + + [Inherited from System] + + Properties: + + - started (Default value false) + + Methods: + + - start(options) + Just calls System.Start(options) + + - stop(options) + Just calls System.Stop(options) + + Static Methods: + + - Start(options) + Starts the system by registering subscriptions to events + + - Stop(options) + Stops the system by removing these subscriptions to events + + [Belonging to SystemTest] + + Properties: + + + + Methods: + + + + Static Methods: + + + + GENERATE_INHERITED_END + + CUSTOM_OPTIONS_START + CUSTOM_OPTIONS_END + + CUSTOM_EVENT_LISTENERS_START + CUSTOM_EVENT_LISTENERS_END + + **/ + +class SystemTest extends System { + + //GENERATE_CONSTRUCTOR_EXTENDS_START + constructor(options) { + + if (Utils.UndefinedOrNull(options)) { + options = {}; + } + + super(options); + + this.emit(Event.OBJECT_CREATED, this); + + //GENERATE_OPTIONS_INIT_START + //GENERATE_OPTIONS_INIT_END + + //CUSTOM_OPTIONS_INIT_START + //CUSTOM_OPTIONS_INIT_END + + Object.assign(this, options); + + //CUSTOM_BEFORE_INIT_START + //CUSTOM_BEFORE_INIT_END + + this.emit(Event.OBJECT_INITIALIZED, this); + + //CUSTOM_AFTER_INIT_START + //CUSTOM_AFTER_INIT_END + } + //GENERATE_CONSTRUCTOR_EXTENDS_END + + //GENERATE_EVENT_LISTENERS_START + //GENERATE_EVENT_LISTENERS_END + + //CUSTOM_IMPLEMENTATION_START + //CUSTOM_IMPLEMENTATION_END + +} + +//CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_START +//CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_END + +module.exports = SystemTest;const Utils = require('./r3-utils'); +const Event = require('./r3-event.js'); + +/** + + GENERATE_INHERITED_START + + [Inherited from Event] + + Properties: + + + + 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 + + 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: + + - register (Default value true) + + Methods: + + + + Static Methods: + + + + GENERATE_INHERITED_END + + Of the form x= + CUSTOM_OPTIONS_START + register=true + CUSTOM_OPTIONS_END + + Of the form x= + CUSTOM_INSTANCE_OPTIONS_MAPPING_START + CUSTOM_INSTANCE_OPTIONS_MAPPING_END + + CUSTOM_LINKED_OBJECTS_START + CUSTOM_LINKED_OBJECTS_END + + CUSTOM_EXCLUDED_FROM_INSTANCE_OPTIONS_START + CUSTOM_EXCLUDED_FROM_INSTANCE_OPTIONS_END + + CUSTOM_METHODS_START + CUSTOM_METHODS_END + + CUSTOM_STATIC_METHODS_START + CUSTOM_STATIC_METHODS_END + + **/ + +class R3Object extends Event { + + //GENERATE_CONSTRUCTOR_EXTENDS_START + constructor(options) { + + if (Utils.UndefinedOrNull(options)) { + options = {}; + } + + super(options); + + this.emit(Event.OBJECT_CREATED, this); + + //GENERATE_OPTIONS_INIT_START + if (typeof options === 'undefined') { + options = {}; + } + if (Utils.UndefinedOrNull(options.register)) { + options.register = true; + } + //GENERATE_OPTIONS_INIT_END + + //CUSTOM_OPTIONS_INIT_START + //CUSTOM_OPTIONS_INIT_END + + Object.assign(this, options); + + //CUSTOM_BEFORE_INIT_START + //CUSTOM_BEFORE_INIT_END + + this.emit(Event.OBJECT_INITIALIZED, this); + + //CUSTOM_AFTER_INIT_START + //CUSTOM_AFTER_INIT_END + } + //GENERATE_CONSTRUCTOR_EXTENDS_END + + //GENERATE_METHODS_START + //GENERATE_METHODS_END + + //GENERATE_STATIC_METHODS_START + //GENERATE_STATIC_METHODS_END + + //CUSTOM_IMPLEMENTATION_START + //CUSTOM_IMPLEMENTATION_END +} + +//CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_START +//CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_END + +module.exports = R3Object;const Event = require('.././r3-event'); +const Utils = require('.././r3-utils'); +const R3Object = require('.././r3-r3-object.js'); + +/** + + GENERATE_INHERITED_START + + [Inherited from Event] + + Properties: + + + + 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 + + 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] + + Properties: + + - register (Default value true) + + Methods: + + + + Static Methods: + + + + [Belonging to Component] + + Properties: + + - x (Default value 0) + - y (Default value 0) + - z (Default value 0) + + Methods: + + - createInstance() + Creates an instance of this object based on the runtime. + + - updateInstance(property) + Updates the instance property, ex. 'x', or specify 'all' to update all properties based on the current object + property(ies) + + - updateFromInstance(property) + Updates the object property, ex. 'x', or specify 'all' to update all properties of this object based on the + value of the instance property(ies) + + - dispose() + Sends out a notification that this object wants to be deleted. It will first send out a message to delete it's + instance, because an object instance should not exist without an object parent (except maybe for particles) + + - disposeInstance() + This will signal all systems that an instance wants to be deleted. Once it has been deleted, another event + will be triggered to notify listeners of the deletion of this instance. This can give 'dispose()' a chance to + dispose the object parent this instance. + + - toApiObject() + Transforms the current object into JSON ready to be stored to the back-end. + + Static Methods: + + + + GENERATE_INHERITED_END + + Of the form x= + CUSTOM_OPTIONS_START + x=0 + y=0 + z=0 + CUSTOM_OPTIONS_END + + Of the form x= + CUSTOM_INSTANCE_OPTIONS_MAPPING_START + CUSTOM_INSTANCE_OPTIONS_MAPPING_END + + CUSTOM_LINKED_OBJECTS_START + CUSTOM_LINKED_OBJECTS_END + + CUSTOM_EXCLUDED_FROM_INSTANCE_OPTIONS_START + CUSTOM_EXCLUDED_FROM_INSTANCE_OPTIONS_END + + CUSTOM_METHODS_START + createInstance() - Creates an instance of this object based on the runtime. + updateInstance(property) - Updates the instance property, ex. 'x', or specify 'all' to update all properties based on the current object property(ies) + updateFromInstance(property) - Updates the object property, ex. 'x', or specify 'all' to update all properties of this object based on the value of the instance property(ies) + dispose() - Sends out a notification that this object wants to be deleted. It will first send out a message to delete it's instance, because an object instance should not exist without an object parent (except maybe for particles) + disposeInstance() - This will signal all systems that an instance wants to be deleted. Once it has been deleted, another event will be triggered to notify listeners of the deletion of this instance. This can give 'dispose()' a chance to dispose the object parent this instance. + toApiObject() - Transforms the current object into JSON ready to be stored to the back-end. @returns JSON + CUSTOM_METHODS_END + + CUSTOM_STATIC_METHODS_START + CUSTOM_STATIC_METHODS_END + + **/ + +class Component extends R3Object { + + //GENERATE_CONSTRUCTOR_EXTENDS_START + constructor(options) { + + if (Utils.UndefinedOrNull(options)) { + options = {}; + } + + super(options); + + this.emit(Event.OBJECT_CREATED, this); + + //GENERATE_OPTIONS_INIT_START + if (typeof options === 'undefined') { + options = {}; + } + if (Utils.UndefinedOrNull(options.x)) { + options.x = 0; + } + if (Utils.UndefinedOrNull(options.y)) { + options.y = 0; + } + if (Utils.UndefinedOrNull(options.z)) { + options.z = 0; + } + //GENERATE_OPTIONS_INIT_END + + //CUSTOM_OPTIONS_INIT_START + //CUSTOM_OPTIONS_INIT_END + + Object.assign(this, options); + + //CUSTOM_BEFORE_INIT_START + //CUSTOM_BEFORE_INIT_END + + this.emit(Event.OBJECT_INITIALIZED, this); + + //CUSTOM_AFTER_INIT_START + //CUSTOM_AFTER_INIT_END + } + //GENERATE_CONSTRUCTOR_EXTENDS_END + + //GENERATE_METHODS_START + + /** + * createInstance() + * - Creates an instance of this object based on the runtime. + */ + createInstance() { + + //GENERATE_CREATE_INSTANCE_METHOD_START + this.emit(Event.CREATE_INSTANCE_BEFORE, this); + + this[this.runtime].createInstance( + this, + { + //GENERATE_CREATE_INSTANCE_OPTIONS_START + 'x': this.x, + 'y': this.y, + 'z': this.z + //GENERATE_CREATE_INSTANCE_OPTIONS_END + } + ) + this.emit(Event.INSTANCE_CREATED, this); + //GENERATE_CREATE_INSTANCE_METHOD_END + + //CUSTOM_CREATE_INSTANCE_METHOD_START + //CUSTOM_CREATE_INSTANCE_METHOD_END + + } + + /** + * updateInstance() + * - Updates the instance property, ex. 'x', or specify 'all' to update all properties based on the current object + * property(ies) + * @param property + */ + updateInstance(property) { + + //GENERATE_UPDATE_INSTANCE_METHOD_START + this.emit(Event.UPDATE_INSTANCE_BEFORE, this); + + //GENERATE_UPDATE_INSTANCE_OPTIONS_START + if (property === 'x') { + this.instance.x = this.x; + if (property !== 'all') { + this.emit(Event.UPDATE_INSTANCE_AFTER, this); + return; + } + } + if (property === 'y') { + this.instance.y = this.y; + if (property !== 'all') { + this.emit(Event.UPDATE_INSTANCE_AFTER, this); + return; + } + } + if (property === 'z') { + this.instance.z = this.z; + if (property !== 'all') { + this.emit(Event.UPDATE_INSTANCE_AFTER, this); + return; + } + } + //GENERATE_UPDATE_INSTANCE_OPTIONS_END + + this.emit(Event.UPDATE_INSTANCE_AFTER, this); + //GENERATE_UPDATE_INSTANCE_METHOD_END + + //CUSTOM_UPDATE_INSTANCE_METHOD_START + //CUSTOM_UPDATE_INSTANCE_METHOD_END + + } + + /** + * updateFromInstance() + * - Updates the object property, ex. 'x', or specify 'all' to update all properties of this object based on the + * value of the instance property(ies) + * @param property + */ + updateFromInstance(property) { + + //GENERATE_UPDATE_FROM_INSTANCE_METHOD_START + this.emit(Event.UPDATE_FROM_INSTANCE_BEFORE, this); + + //GENERATE_UPDATE_FROM_INSTANCE_OPTIONS_START + if (property === 'x' || property === 'all') { + this.x = this.instance.x; + if (property !== 'all') { + this.emit(Event.UPDATE_FROM_INSTANCE_AFTER, this); + return; + } + } + if (property === 'y' || property === 'all') { + this.y = this.instance.y; + if (property !== 'all') { + this.emit(Event.UPDATE_FROM_INSTANCE_AFTER, this); + return; + } + } + if (property === 'z' || property === 'all') { + this.z = this.instance.z; + if (property !== 'all') { + this.emit(Event.UPDATE_FROM_INSTANCE_AFTER, this); + return; + } + } + //GENERATE_UPDATE_FROM_INSTANCE_OPTIONS_END + + this.emit(Event.UPDATE_FROM_INSTANCE_AFTER, this); + + //GENERATE_UPDATE_FROM_INSTANCE_METHOD_END + + //CUSTOM_UPDATE_FROM_INSTANCE_METHOD_START + //CUSTOM_UPDATE_FROM_INSTANCE_METHOD_END + + } + + /** + * dispose() + * - Sends out a notification that this object wants to be deleted. It will first send out a message to delete it's + * instance, because an object instance should not exist without an object parent (except maybe for particles) + */ + dispose() { + + //GENERATE_DISPOSE_METHOD_START + this.subscribe( + Event.INSTANCE_DISPOSED, + function(object) { if (object === this) { this.emit(Event.DISPOSE_OBJECT, this); } - }); //DISPOSE_BEFORE_END - //CUSTOM_DISPOSE_START - //CUSTOM_DISPOSE_END - //DISPOSE_AFTER_START + } + ); - this.disposeInstance(); //DISPOSE_AFTER_END - } //DISPOSE_TEMPLATE_END - //DISPOSE_INSTANCE_TEMPLATE_START + this.disposeInstance(); + //GENERATE_DISPOSE_METHOD_END - }, { - key: "disposeInstance", - value: function disposeInstance() { - //DISPOSE_INSTANCE_BEFORE_START - console.log('Disposing instance of ' + this.name); //DISPOSE_INSTANCE_BEFORE_END - //CUSTOM_DISPOSE_INSTANCE_START - //CUSTOM_DISPOSE_INSTANCE_END - //DISPOSE_INSTANCE_AFTER_START + //CUSTOM_DISPOSE_METHOD_START + //CUSTOM_DISPOSE_METHOD_END - this.emit(Event.DISPOSE_INSTANCE, this); //DISPOSE_INSTANCE_AFTER_END - } //DISPOSE_INSTANCE_TEMPLATE_END - //CUSTOM_IMPLEMENTATION_START - //CUSTOM_IMPLEMENTATION_END + } - }]); + /** + * disposeInstance() + * - This will signal all systems that an instance wants to be deleted. Once it has been deleted, another event + * will be triggered to notify listeners of the deletion of this instance. This can give 'dispose()' a chance to + * dispose the object parent this instance. + */ + disposeInstance() { - return R3Object; -}(Event); //CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_START + //GENERATE_DISPOSE_INSTANCE_METHOD_START + console.log('Disposing instance of ' + this.name); + this.emit(Event.DISPOSE_INSTANCE, this); + //GENERATE_DISPOSE_INSTANCE_METHOD_END + + //CUSTOM_DISPOSE_INSTANCE_METHOD_START + //CUSTOM_DISPOSE_INSTANCE_METHOD_END + + } + + /** + * toApiObject() + * - Transforms the current object into JSON ready to be stored to the back-end. \n * @returns JSON + */ + toApiObject() { + + //GENERATE_TO_API_OBJECT_METHOD_START + //GENERATE_TO_API_OBJECT_METHOD_END + + //CUSTOM_TO_API_OBJECT_METHOD_START + //CUSTOM_TO_API_OBJECT_METHOD_END + + } + //GENERATE_METHODS_END + + //GENERATE_STATIC_METHODS_START + //GENERATE_STATIC_METHODS_END + + //CUSTOM_IMPLEMENTATION_START + //CUSTOM_IMPLEMENTATION_END +} + +//CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_START //CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_END +module.exports = Component;const Event = require('./r3-event'); +const Utils = require('./r3-utils'); +const R3Object = require('./r3-r3-object.js'); -module.exports = R3Object; +/** -/***/ }), + GENERATE_INHERITED_START -/***/ "./src/r3/r3-system/index.js": -/*!***********************************!*\ - !*** ./src/r3/r3-system/index.js ***! - \***********************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { + [Inherited from Event] -var System = __webpack_require__(/*! ./r3-system.js */ "./src/r3/r3-system/r3-system.js"); + Properties: -var SystemLinking = __webpack_require__(/*! ./r3-system-linking.js */ "./src/r3/r3-system/r3-system-linking.js"); + -var SystemSocket = __webpack_require__(/*! ./r3-system-socket.js */ "./src/r3/r3-system/r3-system-socket.js"); + Methods: -module.exports = { - System: System, - SystemLinking: SystemLinking, - SystemSocket: SystemSocket -}; + - async(eventId, data, clientCallback, clientErrorCallback) + Simply calls 'Async()' passing it the arguments -/***/ }), + - emit(eventId, data, clientCallback, clientErrorCallback) + Simply calls 'Emit()' passing it the arguments -/***/ "./src/r3/r3-system/r3-system-linking.js": -/*!***********************************************!*\ - !*** ./src/r3/r3-system/r3-system-linking.js ***! - \***********************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { + - subscribe(eventId, callback) + Simply calls 'Subscribe()' passing it the arguments -function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + Static Methods: -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + - 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. -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + - 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. -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + - Subscribe(eventId, callback) + Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised -function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); } + [Inherited from R3Object] -function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; } + Properties: -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + - register (Default value true) -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + Methods: -function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + -function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + Static Methods: -function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + -function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + [Belonging to Project] -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + Properties: -var System = __webpack_require__(/*! ./r3-system */ "./src/r3/r3-system/r3-system.js"); + -var R3Object = __webpack_require__(/*! ../r3-r3-object */ "./src/r3/r3-r3-object.js"); + Methods: -var Event = __webpack_require__(/*! ../r3-event */ "./src/r3/r3-event.js"); + -var LinkingSystem = /*#__PURE__*/function (_System) { - _inherits(LinkingSystem, _System); + Static Methods: - var _super = _createSuper(LinkingSystem); + - function LinkingSystem() { - _classCallCheck(this, LinkingSystem); + GENERATE_INHERITED_END + + Of the form x= + CUSTOM_OPTIONS_START + CUSTOM_OPTIONS_END + + Of the form x= + CUSTOM_INSTANCE_OPTIONS_MAPPING_START + CUSTOM_INSTANCE_OPTIONS_MAPPING_END + + CUSTOM_LINKED_OBJECTS_START + CUSTOM_LINKED_OBJECTS_END + + CUSTOM_EXCLUDED_FROM_INSTANCE_OPTIONS_START + CUSTOM_EXCLUDED_FROM_INSTANCE_OPTIONS_END + + CUSTOM_METHODS_START + CUSTOM_METHODS_END + + CUSTOM_STATIC_METHODS_START + CUSTOM_STATIC_METHODS_END + + **/ + +class Project extends R3Object { + + //GENERATE_CONSTRUCTOR_EXTENDS_START + constructor(options) { + + if (Utils.UndefinedOrNull(options)) { + options = {}; + } + + super(options); + + this.emit(Event.OBJECT_CREATED, this); + + //GENERATE_OPTIONS_INIT_START + //GENERATE_OPTIONS_INIT_END + + //CUSTOM_OPTIONS_INIT_START + //CUSTOM_OPTIONS_INIT_END + + Object.assign(this, options); + + //CUSTOM_BEFORE_INIT_START + //CUSTOM_BEFORE_INIT_END + + this.emit(Event.OBJECT_INITIALIZED, this); + + //CUSTOM_AFTER_INIT_START + //CUSTOM_AFTER_INIT_END + } + //GENERATE_CONSTRUCTOR_EXTENDS_END + + //GENERATE_METHODS_START + //GENERATE_METHODS_END + + //GENERATE_STATIC_METHODS_START + //GENERATE_STATIC_METHODS_END + + //CUSTOM_IMPLEMENTATION_START + //CUSTOM_IMPLEMENTATION_END +} + +//CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_START +Project.CAMERA_INDEX_EDIT = 0x0; +Project.CAMERA_INDEX_RUN = 0x1; + +Project.APPLICATION_MODE_EDIT = Project.CAMERA_INDEX_EDIT; +Project.APPLICATION_MODE_RUN = Project.CAMERA_INDEX_RUN; + +Project.RENDERER_INDEX_MAIN = 0x0; + +Project.RENDER_TARGET_INDEX_NONE = -0x1; +//CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_END + +module.exports = Project;const Event = require('.././r3-event'); +const Utils = require('.././r3-utils'); +const Component = require('.././r3-component.js'); + +/** + + GENERATE_INHERITED_START + + [Inherited from Event] + + Properties: + + + + 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 + + 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] + + Properties: + + - register (Default value true) + + Methods: + + + + Static Methods: + + + + [Inherited from Component] + + Properties: + + - x (Default value 0) + - y (Default value 0) + - z (Default value 0) + + Methods: + + - createInstance() + Creates an instance of this object based on the runtime. + + - updateInstance(property) + Updates the instance property, ex. 'x', or specify 'all' to update all properties based on the current object + property(ies) + + - updateFromInstance(property) + Updates the object property, ex. 'x', or specify 'all' to update all properties of this object based on the + value of the instance property(ies) + + - dispose() + Sends out a notification that this object wants to be deleted. It will first send out a message to delete it's + instance, because an object instance should not exist without an object parent (except maybe for particles) + + - disposeInstance() + This will signal all systems that an instance wants to be deleted. Once it has been deleted, another event + will be triggered to notify listeners of the deletion of this instance. This can give 'dispose()' a chance to + dispose the object parent this instance. + + - toApiObject() + Transforms the current object into JSON ready to be stored to the back-end. + + Static Methods: + + + + [Belonging to Image] + + Properties: + + + + Methods: + + - createInstance() + Creates an instance of this object based on the runtime. + + - updateInstance(property) + Updates the instance property, ex. 'x', or specify 'all' to update all properties based on the current object + property(ies) + + - updateFromInstance(property) + Updates the object property, ex. 'x', or specify 'all' to update all properties of this object based on the + value of the instance property(ies) + + - dispose() + Sends out a notification that this object wants to be deleted. It will first send out a message to delete it's + instance, because an object instance should not exist without an object parent (except maybe for particles) + + - disposeInstance() + This will signal all systems that an instance wants to be deleted. Once it has been deleted, another event + will be triggered to notify listeners of the deletion of this instance. This can give 'dispose()' a chance to + dispose the object parent this instance. + + - toApiObject() + Transforms the current object into JSON ready to be stored to the back-end. + + Static Methods: + + + + GENERATE_INHERITED_END + + Of the form x= + CUSTOM_OPTIONS_START + CUSTOM_OPTIONS_END + + Of the form x= + CUSTOM_INSTANCE_OPTIONS_MAPPING_START + CUSTOM_INSTANCE_OPTIONS_MAPPING_END + + CUSTOM_LINKED_OBJECTS_START + CUSTOM_LINKED_OBJECTS_END + + CUSTOM_EXCLUDED_FROM_INSTANCE_OPTIONS_START + CUSTOM_EXCLUDED_FROM_INSTANCE_OPTIONS_END + + CUSTOM_METHODS_START + createInstance() - Creates an instance of this object based on the runtime. + updateInstance(property) - Updates the instance property, ex. 'x', or specify 'all' to update all properties based on the current object property(ies) + updateFromInstance(property) - Updates the object property, ex. 'x', or specify 'all' to update all properties of this object based on the value of the instance property(ies) + dispose() - Sends out a notification that this object wants to be deleted. It will first send out a message to delete it's instance, because an object instance should not exist without an object parent (except maybe for particles) + disposeInstance() - This will signal all systems that an instance wants to be deleted. Once it has been deleted, another event will be triggered to notify listeners of the deletion of this instance. This can give 'dispose()' a chance to dispose the object parent this instance. + toApiObject() - Transforms the current object into JSON ready to be stored to the back-end. @returns JSON + CUSTOM_METHODS_END + + CUSTOM_STATIC_METHODS_START + CUSTOM_STATIC_METHODS_END + + **/ + +class Image extends Component { + + //GENERATE_CONSTRUCTOR_EXTENDS_START + constructor(options) { + + if (Utils.UndefinedOrNull(options)) { + options = {}; + } + + super(options); + + this.emit(Event.OBJECT_CREATED, this); + + //GENERATE_OPTIONS_INIT_START + //GENERATE_OPTIONS_INIT_END + + //CUSTOM_OPTIONS_INIT_START + //CUSTOM_OPTIONS_INIT_END + + Object.assign(this, options); + + //CUSTOM_BEFORE_INIT_START + //CUSTOM_BEFORE_INIT_END + + this.emit(Event.OBJECT_INITIALIZED, this); + + //CUSTOM_AFTER_INIT_START + //CUSTOM_AFTER_INIT_END + } + //GENERATE_CONSTRUCTOR_EXTENDS_END + + //GENERATE_METHODS_START + + /** + * createInstance() + * - Creates an instance of this object based on the runtime. + */ + createInstance() { + + //GENERATE_CREATE_INSTANCE_METHOD_START + this.emit(Event.CREATE_INSTANCE_BEFORE, this); + + this[this.runtime].createInstance( + this, + { + //GENERATE_CREATE_INSTANCE_OPTIONS_START + //GENERATE_CREATE_INSTANCE_OPTIONS_END + } + ) + this.emit(Event.INSTANCE_CREATED, this); + //GENERATE_CREATE_INSTANCE_METHOD_END + + //CUSTOM_CREATE_INSTANCE_METHOD_START + //CUSTOM_CREATE_INSTANCE_METHOD_END - return _super.apply(this, arguments); } - _createClass(LinkingSystem, null, [{ - key: "start", - value: function start() { - _get(_getPrototypeOf(LinkingSystem), "start", this).call(this); + /** + * updateInstance() + * - Updates the instance property, ex. 'x', or specify 'all' to update all properties based on the current object + * property(ies) + * @param property + */ + updateInstance(property) { - console.log('starting linking system'); - Event.Subscribe(Event.OBJECT_CREATED, function () { - console.log('linking system discovered an object'); - }); - var object = new R3Object(); - return true; - } - }]); + //GENERATE_UPDATE_INSTANCE_METHOD_START + this.emit(Event.UPDATE_INSTANCE_BEFORE, this); - return LinkingSystem; -}(System); + //GENERATE_UPDATE_INSTANCE_OPTIONS_START + //GENERATE_UPDATE_INSTANCE_OPTIONS_END -module.exports = LinkingSystem; + this.emit(Event.UPDATE_INSTANCE_AFTER, this); + //GENERATE_UPDATE_INSTANCE_METHOD_END -/***/ }), + //CUSTOM_UPDATE_INSTANCE_METHOD_START + //CUSTOM_UPDATE_INSTANCE_METHOD_END -/***/ "./src/r3/r3-system/r3-system-socket.js": -/*!**********************************************!*\ - !*** ./src/r3/r3-system/r3-system-socket.js ***! - \**********************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } - -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); } - -function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; } - -function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } - -function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } - -function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } - -function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } - -function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } - -function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } - -function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } - -var System = __webpack_require__(/*! ./r3-system.js */ "./src/r3/r3-system/r3-system.js"); - -var SocketSystem = /*#__PURE__*/function (_System) { - _inherits(SocketSystem, _System); - - var _super = _createSuper(SocketSystem); - - function SocketSystem() { - _classCallCheck(this, SocketSystem); - - return _super.apply(this, arguments); } - _createClass(SocketSystem, null, [{ - key: "start", - value: function start() { - _get(_getPrototypeOf(SocketSystem), "start", this).call(this); + /** + * updateFromInstance() + * - Updates the object property, ex. 'x', or specify 'all' to update all properties of this object based on the + * value of the instance property(ies) + * @param property + */ + updateFromInstance(property) { - console.log('starting socket system'); - return true; - } - }]); + //GENERATE_UPDATE_FROM_INSTANCE_METHOD_START + this.emit(Event.UPDATE_FROM_INSTANCE_BEFORE, this); - return SocketSystem; -}(System); + //GENERATE_UPDATE_FROM_INSTANCE_OPTIONS_START + //GENERATE_UPDATE_FROM_INSTANCE_OPTIONS_END -module.exports = SocketSystem; + this.emit(Event.UPDATE_FROM_INSTANCE_AFTER, this); -/***/ }), + //GENERATE_UPDATE_FROM_INSTANCE_METHOD_END -/***/ "./src/r3/r3-system/r3-system.js": -/*!***************************************!*\ - !*** ./src/r3/r3-system/r3-system.js ***! - \***************************************/ -/*! no static exports found */ -/***/ (function(module, exports) { + //CUSTOM_UPDATE_FROM_INSTANCE_METHOD_START + //CUSTOM_UPDATE_FROM_INSTANCE_METHOD_END -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -var System = /*#__PURE__*/function () { - function System() { - _classCallCheck(this, System); } - _createClass(System, null, [{ - key: "start", - value: function start() { - console.log('starting a system'); - } - }]); + /** + * dispose() + * - Sends out a notification that this object wants to be deleted. It will first send out a message to delete it's + * instance, because an object instance should not exist without an object parent (except maybe for particles) + */ + dispose() { - return System; -}(); + //GENERATE_DISPOSE_METHOD_START + this.subscribe( + Event.INSTANCE_DISPOSED, + function(object) { + if (object === this) { + this.emit(Event.DISPOSE_OBJECT, this); + } + } + ); -module.exports = System; + this.disposeInstance(); + //GENERATE_DISPOSE_METHOD_END -/***/ }), + //CUSTOM_DISPOSE_METHOD_START + //CUSTOM_DISPOSE_METHOD_END -/***/ "./src/r3/r3.js": -/*!**********************!*\ - !*** ./src/r3/r3.js ***! - \**********************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } - -function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } - -var _require = __webpack_require__(/*! ./r3-system */ "./src/r3/r3-system/index.js"), - System = _require.System, - SystemLinking = _require.SystemLinking, - SystemSocket = _require.SystemSocket; - -var R3Object = __webpack_require__(/*! ./r3-r3-object */ "./src/r3/r3-r3-object.js"); - -var R3 = /*#__PURE__*/function () { - function R3() { - _classCallCheck(this, R3); } - _createClass(R3, null, [{ - key: "version", - value: function version() { - return 'Sun Jun 20 2021 18:45:42 GMT+0000 (Coordinated Universal Time)'; - } - }]); + /** + * disposeInstance() + * - This will signal all systems that an instance wants to be deleted. Once it has been deleted, another event + * will be triggered to notify listeners of the deletion of this instance. This can give 'dispose()' a chance to + * dispose the object parent this instance. + */ + disposeInstance() { - return R3; -}(); + //GENERATE_DISPOSE_INSTANCE_METHOD_START + console.log('Disposing instance of ' + this.name); + this.emit(Event.DISPOSE_INSTANCE, this); + //GENERATE_DISPOSE_INSTANCE_METHOD_END -R3.R3Object = R3Object; -R3.System = System; -R3.System.Linking = SystemLinking; -R3.System.Socket = SystemSocket; -module.exports = R3; + //CUSTOM_DISPOSE_INSTANCE_METHOD_START + //CUSTOM_DISPOSE_INSTANCE_METHOD_END -/***/ }) + } -/******/ }); -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./src/r3/index.js","webpack:///./src/r3/r3-event.js","webpack:///./src/r3/r3-r3-object.js","webpack:///./src/r3/r3-system/index.js","webpack:///./src/r3/r3-system/r3-system-linking.js","webpack:///./src/r3/r3-system/r3-system-socket.js","webpack:///./src/r3/r3-system/r3-system.js","webpack:///./src/r3/r3.js"],"names":["R3","require","System","Linking","start","Socket","module","exports","Utils","Event","options","Emit","OBJECT_CREATED","Object","assign","OBJECT_INITIALIZED","eventName","callback","Subscribe","bind","data","clientCallback","clientErrorCallback","fn","subscriptionId","RandomId","Subscriptions","hasOwnProperty","Error","remove","eventId","listeners","keys","length","subscriptionIds","map","result","error","console","COMPONENT_INITIALIZED","CREATE_INSTANCE_BEFORE","DISPOSE_INSTANCE","DISPOSE_OBJECT","GET_RUNTIME","GET_WINDOW_SIZE","INSTANCE_CREATED","INSTANCE_DISPOSED","PAUSE","RESTART","START","UPDATE_FROM_INSTANCE_AFTER","UPDATE_FROM_INSTANCE_BEFORE","UPDATE_INSTANCE_AFTER","UPDATE_INSTANCE_BEFORE","MAX_EVENTS","GetEventName","R3Object","UndefinedOrNull","emit","id","name","constructor","register","runtime","createInstance","property","subscribe","object","disposeInstance","log","SystemLinking","SystemSocket","LinkingSystem","SocketSystem"],"mappings":"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","file":"r3.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = \"./src/r3/index.js\");\n","const R3 = require('./r3.js');\n\nR3.System.Linking.start();\nR3.System.Socket.start();\n\nmodule.exports = R3;\n","const Utils = require('r3-utils');\n\n/**\n\n OPTIONS_START\n OPTIONS_END\n\n **/\n\nclass Event {\n\n  //CONSTRUCTOR_TEMPLATE_START\n  constructor(options) {\n\n    Event.Emit(Event.OBJECT_CREATED, this);\n\n    //OPTIONS_INIT_START\n    if (typeof options === 'undefined') {\n        options = {};\n    }\n\t\t//OPTIONS_INIT_END\n\n    //CUSTOM_OPTIONS_INIT_START\n    //CUSTOM_OPTIONS_INIT_END\n\n    Object.assign(this, options);\n\n    //CUSTOM_BEFORE_INIT_START\n    //CUSTOM_BEFORE_INIT_END\n\n    Event.Emit(Event.OBJECT_INITIALIZED, this);\n  }\n\t//CONSTRUCTOR_TEMPLATE_END\n\n  //CUSTOM_IMPLEMENTATION_START\n\n\t/**\n\t * Some nice Events handling\n\t * @type {{}}\n\t */\n\tstatic Subscriptions = {};\n\n\tstatic Subscribe(\n\t\teventName,\n\t\tfn\n\t) {\n\t\t/**\n\t\t * Todo - maybe eventually store a boolean which indicates if the function has been executed\n\t\t */\n\t\tlet subscriptionId = Utils.RandomId(10);\n\n\t\tif (Event.Subscriptions.hasOwnProperty(eventName)) {\n\n\t\t\tif (Event.Subscriptions[eventName][subscriptionId]) {\n\t\t\t\tthrow new Error('A component can only subscribe to a particular event ID once');\n\t\t\t}\n\n\t\t\tEvent.Subscriptions[eventName][subscriptionId] = fn;\n\t\t} else {\n\t\t\tEvent.Subscriptions[eventName] = {};\n\t\t\tEvent.Subscriptions[eventName][subscriptionId] = fn;\n\t\t}\n\n\t\t/**\n\t\t * Return a handle to the caller to allow us to unsubscribe to this event\n\t\t */\n\t\treturn {\n\t\t\tfn: fn,\n\t\t\tremove: function (eventId, subscriptionId) {\n\n\t\t\t\treturn function () {\n\n\t\t\t\t\t/**\n\t\t\t\t\t * Stop listening for this event from this component\n\t\t\t\t\t */\n\t\t\t\t\tdelete Event.Subscriptions[eventId][subscriptionId];\n\n\t\t\t\t\t/**\n\t\t\t\t\t * If the length of listeners is 0, stop referencing this event\n\t\t\t\t\t * @type {string[]}\n\t\t\t\t\t */\n\t\t\t\t\tlet listeners = Object.keys(Event.Subscriptions[eventId]);\n\t\t\t\t\tif (listeners.length === 0) {\n\t\t\t\t\t\tdelete Event.Subscriptions[eventId];\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t}(eventName, subscriptionId),\n\t\t\tsubscriptionId : subscriptionId\n\t\t};\n\t};\n\n\t/**\n\t * Subscribe to some events\n\t * @param eventName\n\t * @param callback\n\t */\n\tsubscribe(\n\t\teventName,\n\t\tcallback\n\t) {\n\t\treturn Event.Subscribe(eventName, callback.bind(this));\n\t};\n\n\t/**\n\t * Static Synchronous Event - Calls clientCallback directly after the event result is obtained\n\t * @param eventId\n\t * @param data\n\t * @param clientCallback is executed ideally when the event completed\n\t * @param clientErrorCallback\n\t * @returns {number} of callbacks executed\n\t * @constructor\n\t */\n\tstatic Emit(\n\t\teventId,\n\t\tdata,\n\t\tclientCallback,\n\t\tclientErrorCallback\n\t) {\n\t\tif (Event.Subscriptions.hasOwnProperty(eventId)) {\n\n\t\t\tlet subscriptionIds = Object.keys(Event.Subscriptions[eventId]);\n\n\t\t\tsubscriptionIds.map(\n\t\t\t\tfunction(subscriptionId) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tlet result = Event.Subscriptions[eventId][subscriptionId](data);\n\n\t\t\t\t\t\tif (clientCallback) {\n\t\t\t\t\t\t\tclientCallback(result);\n\t\t\t\t\t\t}\n\t\t\t\t\t} catch (error) {\n\t\t\t\t\t\tif (clientErrorCallback) {\n\t\t\t\t\t\t\tclientErrorCallback(error);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tconsole.error(error);\n\t\t\t\t\t\t\tthrow error;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t)\n\t\t}\n\t}\n\n\temit(\n\t\teventName,\n\t\tdata,\n\t\tclientCallback,\n\t\tclientErrorCallback\n\t) {\n\t\treturn Event.Emit(\n\t\t\teventName,\n\t\t\tdata,\n\t\t\tclientCallback,\n\t\t\tclientErrorCallback\n\t\t);\n\t}\n\n\t/**\n\t * Execute the functions which subscribe to this event, but don't process the client callback - the subscription function\n\t * should execute the client callback\n\t * @param eventId\n\t * @param data\n\t * @param clientCallback\n\t * @param clientErrorCallback\n\t * @returns {number}\n\t * @constructor\n\t */\n\tstatic Async(\n\t\teventId,\n\t\tdata,\n\t\tclientCallback,\n\t\tclientErrorCallback\n\t) {\n\t\tif (Event.Subscriptions.hasOwnProperty(eventId)) {\n\n\t\t\tlet subscriptionIds = Object.keys(Event.Subscriptions[eventId]);\n\n\t\t\tsubscriptionIds.map(\n\t\t\t\tfunction(subscriptionId) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tEvent.Subscriptions[eventId][subscriptionId](data, clientCallback, clientErrorCallback);\n\t\t\t\t\t} catch (error) {\n\t\t\t\t\t\tif (clientErrorCallback) {\n\t\t\t\t\t\t\tclientErrorCallback(error);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tconsole.error(error);\n\t\t\t\t\t\t\tthrow error;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t)\n\t\t}\n\t};\n  //CUSTOM_IMPLEMENTATION_END\n\n}\n\n//CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_START\n\n//EVENT_GENERATED_START\nEvent.COMPONENT_INITIALIZED = 0x1;\nEvent.CREATE_INSTANCE_BEFORE = 0x2;\nEvent.DISPOSE_INSTANCE = 0x3;\nEvent.DISPOSE_OBJECT = 0x4;\nEvent.GET_RUNTIME = 0x5;\nEvent.GET_WINDOW_SIZE = 0x6;\nEvent.INSTANCE_CREATED = 0x7;\nEvent.INSTANCE_DISPOSED = 0x8;\nEvent.OBJECT_CREATED = 0x9;\nEvent.OBJECT_INITIALIZED = 0xa;\nEvent.PAUSE = 0xb;\nEvent.RESTART = 0xc;\nEvent.START = 0xd;\nEvent.UPDATE_FROM_INSTANCE_AFTER = 0xe;\nEvent.UPDATE_FROM_INSTANCE_BEFORE = 0xf;\nEvent.UPDATE_INSTANCE_AFTER = 0x10;\nEvent.UPDATE_INSTANCE_BEFORE = 0x11;\nEvent.MAX_EVENTS = 0x12;\n\nEvent.GetEventName = function(eventId) {\n\n\tswitch(eventId) {\n\t\tcase 0x1 : return 'component_initialized';\n\t\tcase 0x2 : return 'create_instance_before';\n\t\tcase 0x3 : return 'dispose_instance';\n\t\tcase 0x4 : return 'dispose_object';\n\t\tcase 0x5 : return 'get_runtime';\n\t\tcase 0x6 : return 'get_window_size';\n\t\tcase 0x7 : return 'instance_created';\n\t\tcase 0x8 : return 'instance_disposed';\n\t\tcase 0x9 : return 'object_created';\n\t\tcase 0xa : return 'object_initialized';\n\t\tcase 0xb : return 'pause';\n\t\tcase 0xc : return 'restart';\n\t\tcase 0xd : return 'start';\n\t\tcase 0xe : return 'update_from_instance_after';\n\t\tcase 0xf : return 'update_from_instance_before';\n\t\tcase 0x10 : return 'update_instance_after';\n\t\tcase 0x11 : return 'update_instance_before';\n\t\tdefault :\n\t\t\tthrow new Error('Event type not defined : ' + eventId);\n\t}\n\n};\n//EVENT_GENERATED_END\n\n//CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_END\n\nmodule.exports = Event;","const Utils = require('r3-utils');\nconst Event = require('r3-event.js');\n\n/**\n\n OPTIONS_START\n id=Utils.RandomId(10)\n name=this.constructor.name + '(' + options.id + ')'\n register=true\n OPTIONS_END\n\n INSTANCE_OPTIONS_MAPPING_START\n INSTANCE_OPTIONS_MAPPING_END\n\n LINKED_OBJECTS_START\n LINKED_OBJECTS_END\n\n EXCLUDED_FROM_INSTANCE_OPTIONS_START\n id\n name\n register\n EXCLUDED_FROM_INSTANCE_OPTIONS_END\n\n **/\n\nclass R3Object extends Event {\n\n  //CONSTRUCTOR_EXTENDS_TEMPLATE_START\n  constructor(options) {\n\n    if (Utils.UndefinedOrNull(options)) {\n      options = {};\n    }\n\n    super(options);\n\n    this.emit(Event.OBJECT_CREATED, this);\n\n    //OPTIONS_INIT_START\n    if (typeof options === 'undefined') {\n        options = {};\n    }\n    if (Utils.UndefinedOrNull(options.id)) {\n      options.id = Utils.RandomId(10);\n    }\n    if (Utils.UndefinedOrNull(options.name)) {\n      options.name = this.constructor.name + '(' + options.id + ')';\n    }\n    if (Utils.UndefinedOrNull(options.register)) {\n      options.register = true;\n    }\n\t\t//OPTIONS_INIT_END\n\n    //CUSTOM_OPTIONS_INIT_START\n    //CUSTOM_OPTIONS_INIT_END\n\n    Object.assign(this, options);\n\n    //CUSTOM_BEFORE_INIT_START\n    //CUSTOM_BEFORE_INIT_END\n\n    this.emit(Event.OBJECT_INITIALIZED, this);\n  }\n\t//CONSTRUCTOR_EXTENDS_TEMPLATE_END\n\n  //CREATE_INSTANCE_TEMPLATE_START\n  createInstance() {\n\n    //CREATE_INSTANCE_BEFORE_START\n    this.emit(Event.CREATE_INSTANCE_BEFORE, this);\n\t\t//CREATE_INSTANCE_BEFORE_END\n\n    //CUSTOM_CREATE_INSTANCE_START\n    //CUSTOM_CREATE_INSTANCE_END\n\n    //CREATE_INSTANCE_AFTER_START\n    this[this.runtime].createInstance(\n      this,\n      {\n        //CREATE_INSTANCE_OPTIONS_START\n        //CREATE_INSTANCE_OPTIONS_END\n      }\n    )\n\n    this.emit(Event.INSTANCE_CREATED, this);\n\t\t//CREATE_INSTANCE_AFTER_END\n\n  }\n\t//CREATE_INSTANCE_TEMPLATE_END\n\n  //UPDATE_INSTANCE_TEMPLATE_START\n  updateInstance(property) {\n\n    //UPDATE_INSTANCE_BEFORE_START\n    this.emit(Event.UPDATE_INSTANCE_BEFORE, this);\n\t\t//UPDATE_INSTANCE_BEFORE_END\n\n    //UPDATE_INSTANCE_OPTIONS_START\n\t\t//UPDATE_INSTANCE_OPTIONS_END\n\n    //CUSTOM_UPDATE_INSTANCE_START\n    //CUSTOM_UPDATE_INSTANCE_END\n\n    //UPDATE_INSTANCE_AFTER_START\n    this.emit(Event.UPDATE_INSTANCE_AFTER, this);\n\t\t//UPDATE_INSTANCE_AFTER_END\n\n  }\n\t//UPDATE_INSTANCE_TEMPLATE_END\n\n  //UPDATE_FROM_INSTANCE_TEMPLATE_START\n  updateFromInstance(property) {\n\n    //UPDATE_FROM_INSTANCE_BEFORE_START\n    this.emit(Event.UPDATE_FROM_INSTANCE_BEFORE, this);\n\t\t//UPDATE_FROM_INSTANCE_BEFORE_END\n\n    //UPDATE_FROM_INSTANCE_OPTIONS_START\n\t\t//UPDATE_FROM_INSTANCE_OPTIONS_END\n\n    //CUSTOM_UPDATE_FROM_INSTANCE_START\n    //CUSTOM_UPDATE_FROM_INSTANCE_END\n\n    //UPDATE_FROM_INSTANCE_AFTER_START\n    this.emit(Event.UPDATE_FROM_INSTANCE_AFTER, this);\n\t\t//UPDATE_FROM_INSTANCE_AFTER_END\n\n  }\n\t//UPDATE_FROM_INSTANCE_TEMPLATE_END\n\n  //DISPOSE_TEMPLATE_START\n  dispose() {\n\n    //DISPOSE_BEFORE_START\n    this.subscribe(\n      Event.INSTANCE_DISPOSED,\n      function(object) {\n        if (object === this) {\n          this.emit(Event.DISPOSE_OBJECT, this);\n        }\n      }\n    );\n\t\t//DISPOSE_BEFORE_END\n\n    //CUSTOM_DISPOSE_START\n    //CUSTOM_DISPOSE_END\n\n    //DISPOSE_AFTER_START\n    this.disposeInstance();\n\t\t//DISPOSE_AFTER_END\n\n  }\n\t//DISPOSE_TEMPLATE_END\n\n  //DISPOSE_INSTANCE_TEMPLATE_START\n  disposeInstance() {\n\n    //DISPOSE_INSTANCE_BEFORE_START\n    console.log('Disposing instance of ' + this.name);\n\t\t//DISPOSE_INSTANCE_BEFORE_END\n\n    //CUSTOM_DISPOSE_INSTANCE_START\n    //CUSTOM_DISPOSE_INSTANCE_END\n\n    //DISPOSE_INSTANCE_AFTER_START\n    this.emit(Event.DISPOSE_INSTANCE, this);\n\t\t//DISPOSE_INSTANCE_AFTER_END\n\n  }\n\t//DISPOSE_INSTANCE_TEMPLATE_END\n\n  //CUSTOM_IMPLEMENTATION_START\n  //CUSTOM_IMPLEMENTATION_END\n\n}\n\n//CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_START\n//CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_END\n\nmodule.exports = R3Object;","const System = require('./r3-system.js');\nconst SystemLinking = require('./r3-system-linking.js');\nconst SystemSocket = require('./r3-system-socket.js');\n\nmodule.exports = {\n  System,\n  SystemLinking,\n  SystemSocket\n}","const System = require('./r3-system');\nconst R3Object = require('../r3-r3-object');\nconst Event = require('../r3-event');\n\nclass LinkingSystem extends System {\n\n\tstatic start() {\n\n\t\tsuper.start();\n\t\t\n\t\tconsole.log('starting linking system');\n\n\t\tEvent.Subscribe(\n\t\t\tEvent.OBJECT_CREATED,\n\t\t\t() => {\n\t\t\t\tconsole.log('linking system discovered an object');\n\t\t\t}\n\t\t);\n\n\t\tlet object = new R3Object();\n\n\t\treturn true;\n\n\t}\t\n\n}\n\nmodule.exports = LinkingSystem;\n","const System = require('./r3-system.js');\n\nclass SocketSystem extends System {\n\n\tstatic start() {\n\n\t\tsuper.start();\n\t\t\n\t\tconsole.log('starting socket system');\n\n\t\treturn true;\n\n\t}\n\n}\n\nmodule.exports = SocketSystem;","class System {\n\n\tstatic start() {\n\t\tconsole.log('starting a system');\t\n\t}\n\n}\n\nmodule.exports = System;\n","const {System, SystemLinking, SystemSocket} = require('./r3-system');\nconst R3Object = require('./r3-r3-object');\n\nclass R3 {\n\n\tconstructor() {\n\t}\n\n\tstatic version() {\n\t\treturn '__DATE__';\n\t}\n\n}\n\nR3.R3Object \t\t= R3Object;\nR3.System \t\t\t= System;\nR3.System.Linking\t= SystemLinking;\nR3.System.Socket\t= SystemSocket;\n\nmodule.exports = R3;\n"],"sourceRoot":""} \ No newline at end of file + /** + * toApiObject() + * - Transforms the current object into JSON ready to be stored to the back-end. \n * @returns JSON + */ + toApiObject() { + + //GENERATE_TO_API_OBJECT_METHOD_START + //GENERATE_TO_API_OBJECT_METHOD_END + + //CUSTOM_TO_API_OBJECT_METHOD_START + //CUSTOM_TO_API_OBJECT_METHOD_END + + } + //GENERATE_METHODS_END + + //GENERATE_STATIC_METHODS_START + //GENERATE_STATIC_METHODS_END + + //CUSTOM_IMPLEMENTATION_START + //CUSTOM_IMPLEMENTATION_END +} + +//CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_START +//CUSTOM_OUT_OF_CLASS_IMPLEMENTATION_END + +module.exports = Image; \ No newline at end of file diff --git a/package.json b/package.json index 6754f9b..090c714 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "r3", - "version": "2.0.0", + "version" : "2.0.18", "description": "", "private": true, "dependencies": { @@ -19,6 +19,7 @@ "map-stream": "0.0.7", "mocha": "^9.0.0", "webpack": "^5.39.1", + "webpack-cli": "*", "webpack-stream": "^6.1.2" }, "scripts": { diff --git a/src/r3/index.js b/src/r3/index.js index 59ee134..1579027 100644 --- a/src/r3/index.js +++ b/src/r3/index.js @@ -1,15 +1,18 @@ //GENERATE_IMPORTS_START -const R3 = require('./r3-r3.js'); -const System = require('./r3-system/r3-system.js'); -const Event = require('./r3-event.js'); -const Utils = require('./r3-utils.js'); +const R3 = require('r3-r3.js'); //GENERATE_IMPORTS_END +//GENERATE_INDEX_BODY_START +R3.System.Linking.Start() +R3.System.Socket.Start() +R3.System.Test.Start() + +console.log('r3.js - version ' + R3.version + ' compiled ' + R3.compileDate); + +//GENERATE_INDEX_BODY_END + module.exports = { //GENERATE_EXPORTS_START - R3, - System, - Event, - Utils + R3 //GENERATE_EXPORTS_END } \ No newline at end of file diff --git a/src/r3/r3-component/index.js b/src/r3/r3-component/index.js index 3157a7f..2a45b0a 100644 --- a/src/r3/r3-component/index.js +++ b/src/r3/r3-component/index.js @@ -3,6 +3,9 @@ const Component = require('./r3-component.js'); const Image = require('./r3-image.js'); //GENERATE_IMPORTS_END +//GENERATE_INDEX_BODY_START +//GENERATE_INDEX_BODY_END + module.exports = { //GENERATE_EXPORTS_START Component, diff --git a/src/r3/r3-r3.js b/src/r3/r3-r3.js index 969c88d..65ebfc9 100644 --- a/src/r3/r3-r3.js +++ b/src/r3/r3-r3.js @@ -1,6 +1,6 @@ class R3 { - static version = '__VERSION__'; - static compileDate = '__DATE__'; + static version = '2.0.18'; + static compileDate = '2021 Jul 04 - 16:34:09 pm'; } //GENERATE_IMPORTS_START @@ -29,10 +29,13 @@ R3.Event.Object.Project = Project; R3.Event.Object.Component.Image = Image; //GENERATE_DEFINES_END +//GENERATE_CONVENIENT_DEFINES_START +R3.Object = R3Object; +R3.Component = Component; +//GENERATE_CONVENIENT_DEFINES_END + //CUSTOM_CONVENIENT_DEFINES_START -R3.Object = R3.Event.Object; -R3.Project = R3.Event.Object.Project; -R3.Component = R3.Event.Object.Component; +R3.Project = Project; //CUSTOM_CONVENIENT_DEFINES_END module.exports = R3; diff --git a/src/r3/r3-system/index.js b/src/r3/r3-system/index.js index f2eb235..f573ba9 100644 --- a/src/r3/r3-system/index.js +++ b/src/r3/r3-system/index.js @@ -5,6 +5,9 @@ const SystemSocket = require('./r3-system-socket.js'); const SystemTest = require('./r3-system-test.js'); //GENERATE_IMPORTS_END +//GENERATE_INDEX_BODY_START +//GENERATE_INDEX_BODY_END + module.exports = { //GENERATE_EXPORTS_START System, diff --git a/src/templates/index.template b/src/templates/index.template index 231c6ae..9b6f590 100644 --- a/src/templates/index.template +++ b/src/templates/index.template @@ -1,6 +1,9 @@ //GENERATE_IMPORTS_START //GENERATE_IMPORTS_END +//GENERATE_INDEX_BODY_START +//GENERATE_INDEX_BODY_END + module.exports = { //GENERATE_EXPORTS_START //GENERATE_EXPORTS_END diff --git a/src/templates/r3-base.template b/src/templates/r3-base.template index d326f88..ad0d373 100644 --- a/src/templates/r3-base.template +++ b/src/templates/r3-base.template @@ -1,6 +1,6 @@ class R3 { - static version = '__VERSION__'; - static compileDate = '__DATE__'; + static version = 'VERSION'; + static compileDate = 'DATE'; } //GENERATE_IMPORTS_START @@ -9,6 +9,9 @@ class R3 { //GENERATE_DEFINES_START //GENERATE_DEFINES_END +//GENERATE_CONVENIENT_DEFINES_START +//GENERATE_CONVENIENT_DEFINES_END + //CUSTOM_CONVENIENT_DEFINES_START //CUSTOM_CONVENIENT_DEFINES_END diff --git a/src/templates/token.db b/src/templates/token.db index 6c767ae..7bd3ea4 100644 --- a/src/templates/token.db +++ b/src/templates/token.db @@ -1,6 +1,7 @@ GENERATE_ASYNC_METHOD GENERATE_CONSTRUCTOR GENERATE_CONSTRUCTOR_EXTENDS +GENERATE_CONVENIENT_DEFINES GENERATE_CREATE_INSTANCE_METHOD GENERATE_CREATE_INSTANCE_OPTIONS GENERATE_DEFINES @@ -10,6 +11,7 @@ GENERATE_EMIT_METHOD GENERATE_EVENT_LISTENERS GENERATE_EXPORTS GENERATE_IMPORTS +GENERATE_INDEX_BODY GENERATE_INHERITED GENERATE_METHOD_NAME_UPPERCASE_METHOD GENERATE_METHODS diff --git a/update_templates.php b/update_templates.php index f0321a0..3c406c7 100755 --- a/update_templates.php +++ b/update_templates.php @@ -952,6 +952,11 @@ function generateR3($nodes) $file = str_replace('src/r3', '.', $node->file); array_push($imports, "const " . $node->name . ' = require(\'' . $file . "');"); array_push($defines, $node->nameSpace . $node->nameSpaceClassName . ' = ' . $node->name); + + if (sizeof($node->children) > 0 && substr_count($node->nameSpace, ".") > 1) { + $convenientDefine = "R3." . $node->nameSpaceClassName . ' = ' . $node->name; + array_push($convenientDefines, $convenientDefine); + } } @@ -963,13 +968,59 @@ function generateR3($nodes) $template = file_get_contents('src/templates/r3-base.template'); + $version = file_get_contents('version'); + + $template = str_replace('DATE', date("Y M d - H:i:s a"), $template); + $template = str_replace('VERSION', $version, $template); + file_put_contents($r3File, $template); + $packageJson = file_get_contents('package.json'); + $packageJson = preg_replace('/(.*version.*: ").*(".*)/', '${1}' . $version . '${2}', $packageJson); + file_put_contents('package.json', $packageJson); + updateSection($r3File, 'GENERATE_IMPORTS', implode("\n", $imports)); updateSection($r3File, 'GENERATE_DEFINES', implode(";\n", $defines) . ";"); + updateSection($r3File, 'GENERATE_CONVENIENT_DEFINES', implode(";\n", $convenientDefines) . ";"); + if (in_array('CUSTOM_CONVENIENT_DEFINES', array_keys($tokens))) { updateSection($r3File, 'CUSTOM_CONVENIENT_DEFINES', $tokens['CUSTOM_CONVENIENT_DEFINES']); } + + $indexFile = 'src/r3/index.js'; + + $template = file_get_contents('src/templates/index.template'); + file_put_contents($indexFile, $template); + + $imports = ['const R3 = require(\'r3-r3.js\');']; + $exports = ' R3'; + $indexBody = []; + + foreach ($nodes as $node) { + /** + * Node $node + */ + if (preg_match('/\bSystem\w+\b/', $node->name)){ + array_push($indexBody, $node->nameSpace . $node->nameSpaceClassName . ".Start()"); + } + } + + array_push($indexBody, "\nconsole.log('r3.js - version ' + R3.version + ' compiled ' + R3.compileDate);\n\n"); + + updateSection($indexFile, 'GENERATE_IMPORTS', implode("\n", $imports)); + updateSection($indexFile, 'GENERATE_INDEX_BODY', implode("\n", $indexBody)); + updateSection($indexFile, 'GENERATE_EXPORTS', $exports); + + $r3js = fopen('dist/r3.js', "w"); + + ftruncate($r3js, 0); + + foreach ($nodes as $node) { + $contents = file_get_contents($node->file); + fwrite($r3js, $contents); + } + + fclose($r3js); } if ($argv[2] == 'build-graph') { diff --git a/version b/version new file mode 100644 index 0000000..e164972 --- /dev/null +++ b/version @@ -0,0 +1 @@ +2.0.18 \ No newline at end of file