2985 lines
63 KiB
JavaScript
2985 lines
63 KiB
JavaScript
class R3 {
|
|
static version = '2.0.158';
|
|
static compileDate = '2021 Sep 06 - 12:10:13 pm';
|
|
}
|
|
|
|
/**
|
|
|
|
Started=false
|
|
Subscriptions=[]
|
|
|
|
**/
|
|
|
|
class System {
|
|
|
|
constructor(options) {
|
|
|
|
Event.Emit(Event.OBJECT_CREATED, this);
|
|
|
|
if (typeof options === 'undefined') {
|
|
options = {};
|
|
}
|
|
|
|
if (typeof options.started === 'undefined') {
|
|
options.started = false;
|
|
}
|
|
if (typeof options.subscriptions === 'undefined') {
|
|
options.subscriptions = [];
|
|
}
|
|
|
|
Object.assign(this, options);
|
|
|
|
Event.Emit(Event.OBJECT_INITIALIZED, this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
System.Started = false;
|
|
System.Subscriptions = [];
|
|
|
|
class Event {
|
|
|
|
constructor(options) {
|
|
|
|
Event.Emit(Event.OBJECT_CREATED, this);
|
|
|
|
if (typeof options === 'undefined') {
|
|
options = {};
|
|
}
|
|
|
|
Object.assign(this, options);
|
|
|
|
Event.Emit(Event.OBJECT_INITIALIZED, this);
|
|
|
|
}
|
|
|
|
/**
|
|
* Some nice Events handling
|
|
* @type {{}}
|
|
*/
|
|
static Subscriptions = {};
|
|
|
|
/**
|
|
* async()
|
|
* - Simply calls 'Async()' passing it the arguments
|
|
* @param eventId
|
|
* @param data
|
|
* @param clientCallback
|
|
* @param clientErrorCallback
|
|
*/
|
|
async(
|
|
eventId,
|
|
data,
|
|
clientCallback,
|
|
clientErrorCallback
|
|
) {
|
|
|
|
return Event.Async(
|
|
eventId,
|
|
data,
|
|
clientCallback,
|
|
clientErrorCallback
|
|
);
|
|
|
|
}
|
|
|
|
/**
|
|
* emit()
|
|
* - Simply calls 'Emit()' passing it the arguments
|
|
* @param eventId
|
|
* @param data
|
|
* @param clientCallback
|
|
* @param clientErrorCallback
|
|
*/
|
|
emit(
|
|
eventId,
|
|
data,
|
|
clientCallback,
|
|
clientErrorCallback
|
|
) {
|
|
|
|
return Event.Emit(
|
|
eventId,
|
|
data,
|
|
clientCallback,
|
|
clientErrorCallback
|
|
);
|
|
|
|
}
|
|
|
|
/**
|
|
* subscribe()
|
|
* - Simply calls 'Subscribe()' passing it the arguments
|
|
* @param eventId
|
|
* @param callback
|
|
*/
|
|
subscribe(
|
|
eventId,
|
|
callback
|
|
) {
|
|
|
|
return Event.Subscribe(eventId, callback.bind(this));
|
|
|
|
}
|
|
|
|
/**
|
|
* Async()
|
|
* - Calls all subscription functions registered to eventId with data, clientCallback and clientErrorCallback as
|
|
* arguments. If an error occurs during clientCallback it additionally will execute clientErrorCallback with the
|
|
* error as argument.
|
|
* @param eventId
|
|
* @param data
|
|
* @param clientCallback
|
|
* @param clientErrorCallback
|
|
*/
|
|
static Async(
|
|
eventId,
|
|
data,
|
|
clientCallback,
|
|
clientErrorCallback
|
|
) {
|
|
|
|
if (Event.Subscriptions.hasOwnProperty(eventId)) {
|
|
|
|
let subscriptionIds = Object.keys(Event.Subscriptions[eventId]);
|
|
|
|
subscriptionIds.map(
|
|
function(subscriptionId) {
|
|
try {
|
|
Event.Subscriptions[eventId][subscriptionId](data, clientCallback, clientErrorCallback);
|
|
} catch (error) {
|
|
if (clientErrorCallback) {
|
|
clientErrorCallback(error);
|
|
} else {
|
|
console.error(error);
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
)
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Emit()
|
|
* - Calls all subscription functions registered to eventId with data as arg. Calls clientCallback directly after
|
|
* the event result is obtained, passing it the result. If an exception occurs during execution, the
|
|
* clientErrorCallback is called with the error as argument.
|
|
* @param eventId
|
|
* @param data
|
|
* @param clientCallback
|
|
* @param clientErrorCallback
|
|
*/
|
|
static Emit(
|
|
eventId,
|
|
data,
|
|
clientCallback,
|
|
clientErrorCallback
|
|
) {
|
|
|
|
if (Event.Subscriptions.hasOwnProperty(eventId)) {
|
|
|
|
let subscriptionIds = Object.keys(Event.Subscriptions[eventId]);
|
|
|
|
subscriptionIds.map(
|
|
function(subscriptionId) {
|
|
try {
|
|
let result = Event.Subscriptions[eventId][subscriptionId](data);
|
|
|
|
if (clientCallback) {
|
|
clientCallback(result);
|
|
}
|
|
} catch (error) {
|
|
if (clientErrorCallback) {
|
|
clientErrorCallback(error);
|
|
} else {
|
|
console.error(error);
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
)
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Subscribe()
|
|
* - Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised
|
|
* @param eventId
|
|
* @param callback
|
|
* @returns {Object} - A handle to the subscription which can be removed by calling handle.remove()
|
|
*/
|
|
static Subscribe(
|
|
eventId,
|
|
callback
|
|
) {
|
|
|
|
let subscriptionId = Utils.RandomId(10);
|
|
|
|
if (Event.Subscriptions.hasOwnProperty(eventId)) {
|
|
|
|
if (Event.Subscriptions[eventId][subscriptionId]) {
|
|
throw new Error('A component can only subscribe to a particular event ID once');
|
|
}
|
|
|
|
Event.Subscriptions[eventId][subscriptionId] = callback;
|
|
} else {
|
|
Event.Subscriptions[eventId] = {};
|
|
Event.Subscriptions[eventId][subscriptionId] = callback;
|
|
}
|
|
|
|
/**
|
|
* Return a handle to the caller to allow us to unsubscribe to this event
|
|
*/
|
|
return {
|
|
fn: callback,
|
|
remove: function (eventId, subscriptionId) {
|
|
|
|
return function () {
|
|
|
|
/**
|
|
* Stop listening for this event from this component
|
|
*/
|
|
delete Event.Subscriptions[eventId][subscriptionId];
|
|
|
|
/**
|
|
* If the length of listeners is 0, stop referencing this event
|
|
* @type {string[]}
|
|
*/
|
|
let listeners = Object.keys(Event.Subscriptions[eventId]);
|
|
if (listeners.length === 0) {
|
|
delete Event.Subscriptions[eventId];
|
|
}
|
|
}
|
|
|
|
}(eventId, subscriptionId),
|
|
subscriptionId : subscriptionId
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Event.COMPONENT_CREATED = 0x1;
|
|
Event.CREATE_INSTANCE_BEFORE = 0x2;
|
|
Event.DISPOSE_INSTANCE = 0x3;
|
|
Event.DISPOSE_OBJECT = 0x4;
|
|
Event.GET_RUNTIME = 0x5;
|
|
Event.GET_WINDOW_SIZE = 0x6;
|
|
Event.INSTANCE_CREATED = 0x7;
|
|
Event.INSTANCE_DISPOSED = 0x8;
|
|
Event.KEYBOARD_DOWN = 0x9;
|
|
Event.KEYBOARD_UP = 0xa;
|
|
Event.MOUSE_DOWN = 0xb;
|
|
Event.MOUSE_MOVE = 0xc;
|
|
Event.MOUSE_UP = 0xd;
|
|
Event.MOUSE_WHEEL = 0xe;
|
|
Event.OBJECT_CREATED = 0xf;
|
|
Event.OBJECT_INITIALIZED = 0x10;
|
|
Event.PAUSE = 0x11;
|
|
Event.RESTART = 0x12;
|
|
Event.START = 0x13;
|
|
Event.TOUCH_CANCEL = 0x14;
|
|
Event.TOUCH_END = 0x15;
|
|
Event.TOUCH_MOVE = 0x16;
|
|
Event.TOUCH_START = 0x17;
|
|
Event.MAX_EVENTS = 0x18;
|
|
|
|
Event.GetEventName = function(eventId) {
|
|
|
|
switch(eventId) {
|
|
case 0x1 : return 'component_created';
|
|
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 'keyboard_down';
|
|
case 0xa : return 'keyboard_up';
|
|
case 0xb : return 'mouse_down';
|
|
case 0xc : return 'mouse_move';
|
|
case 0xd : return 'mouse_up';
|
|
case 0xe : return 'mouse_wheel';
|
|
case 0xf : return 'object_created';
|
|
case 0x10 : return 'object_initialized';
|
|
case 0x11 : return 'pause';
|
|
case 0x12 : return 'restart';
|
|
case 0x13 : return 'start';
|
|
case 0x14 : return 'touch_cancel';
|
|
case 0x15 : return 'touch_end';
|
|
case 0x16 : return 'touch_move';
|
|
case 0x17 : return 'touch_start';
|
|
default :
|
|
throw new Error('Event type not defined : ' + eventId);
|
|
}
|
|
|
|
};
|
|
|
|
class Utils {
|
|
|
|
constructor(options) {
|
|
|
|
Event.Emit(Event.OBJECT_CREATED, this);
|
|
|
|
if (typeof options === 'undefined') {
|
|
options = {};
|
|
}
|
|
|
|
Object.assign(this, options);
|
|
|
|
Event.Emit(Event.OBJECT_INITIALIZED, this);
|
|
|
|
}
|
|
|
|
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, '<').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 '<span class="' + cls + '">' + match + '</span>';
|
|
});
|
|
};
|
|
|
|
static GetParentProject(component) {
|
|
|
|
if (Utils.UndefinedOrNull(component.parent)) {
|
|
throw new Error('Parent not found');
|
|
}
|
|
|
|
if (component.parent instanceof R3.Project) {
|
|
return component.parent;
|
|
}
|
|
|
|
return Utils.GetParentProject(component.parent);
|
|
};
|
|
|
|
static GetParents(component, parents) {
|
|
|
|
if (Utils.UndefinedOrNull(parents)) {
|
|
parents = [];
|
|
}
|
|
|
|
if (Utils.UndefinedOrNull(component.parent)) {
|
|
return parents;
|
|
}
|
|
|
|
parents.push(component.parent);
|
|
|
|
return Utils.GetParents(component.parent, parents);
|
|
|
|
};
|
|
|
|
/**
|
|
* @return {boolean}
|
|
*/
|
|
static Instance(component) {
|
|
return Utils.Defined(component) && Utils.Defined(component.instance);
|
|
};
|
|
|
|
/**
|
|
* Utils.RemoveFromSelect
|
|
* @param select
|
|
* @param id
|
|
* @returns {boolean}
|
|
* @constructor
|
|
*/
|
|
static RemoveFromSelect(select, id) {
|
|
|
|
let i;
|
|
|
|
for (i = 0; i < select.options.length; i++) {
|
|
if (select.options[i].value === id) {
|
|
select.remove(i);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
/**
|
|
* Utils.GetSelectIndex
|
|
*
|
|
* Get the select index of given id
|
|
*
|
|
* @param select
|
|
* @param id
|
|
* @returns boolean true if successful
|
|
*
|
|
* @constructor
|
|
*/
|
|
static SetSelectIndex(select, id) {
|
|
for (let i = 0; i < select.options.length; i++) {
|
|
if (select.options[i].value === id) {
|
|
select.selectedIndex = i;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
static SortSelect(select) {
|
|
|
|
let tmp = [];
|
|
let i;
|
|
|
|
for (i = 1; i < select.options.length; i++) {
|
|
tmp[i-1] = [];
|
|
tmp[i-1][0] = select.options[i].text;
|
|
tmp[i-1][1] = select.options[i].value;
|
|
}
|
|
|
|
tmp.sort();
|
|
|
|
select.options = [select.options[0]];
|
|
|
|
for (i = 0; i < tmp.length; i++) {
|
|
select.options[i+1] = new Option(tmp[i][0], tmp[i][1]);
|
|
}
|
|
|
|
return;
|
|
};
|
|
|
|
/**
|
|
* Gets the parent of object whith property of optional type constructor. If index is specified, get the parent of the
|
|
* object with property[index] - which means the property should be an array
|
|
* @param object
|
|
* @param property
|
|
* @param index
|
|
* @param constructor
|
|
* @returns {*}
|
|
* @constructor
|
|
*/
|
|
static GetParent(object, property, index, constructor) {
|
|
|
|
if (Utils.UndefinedOrNull(constructor)) {
|
|
constructor = null;
|
|
}
|
|
|
|
if (Utils.UndefinedOrNull(index)) {
|
|
index = null;
|
|
}
|
|
|
|
if (object.parent) {
|
|
/**
|
|
* Parent defined
|
|
*/
|
|
if (object.parent.hasOwnProperty(property)) {
|
|
|
|
if (constructor) {
|
|
|
|
if (index) {
|
|
|
|
if (object.parent[property][index] instanceof constructor) {
|
|
return object.parent[property][index];
|
|
} else {
|
|
|
|
if (typeof object.parent.getParent === 'function') {
|
|
return object.parent.getParent(property, index, constructor);
|
|
} else {
|
|
console.warn('getParent not defined on API object : ' + object.parent + ' - you should avoid having these messsages');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
if (object.parent[property] instanceof constructor) {
|
|
return object.parent[property];
|
|
} else {
|
|
|
|
if (typeof object.parent.getParent === 'function') {
|
|
return object.parent.getParent(property, index, constructor);
|
|
} else {
|
|
console.warn('getParent not defined on API object : ' + object.parent + ' - you should avoid having these messsages');
|
|
return null;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
if (index) {
|
|
return object.parent[property][index];
|
|
} else {
|
|
return object.parent[property];
|
|
}
|
|
|
|
}
|
|
} else {
|
|
|
|
/**
|
|
* This parent does not have the property - go a level higher
|
|
*/
|
|
if (typeof object.parent.getParent === 'function') {
|
|
return object.parent.getParent(property, index, constructor);
|
|
} else {
|
|
console.warn('getParent not defined on API object : ' + object.parent + ' - you should avoid having these messsages');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
/**
|
|
* No parent defined
|
|
*/
|
|
console.warn('property : ' + property + ' of type ' + constructor + ' was not found in the parent chain');
|
|
return null;
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
* Strips image extension from given path
|
|
* @param imagePath
|
|
* @constructor
|
|
*/
|
|
static StripImageExtension(imagePath) {
|
|
return imagePath.replace(/(\.png$|\.gif$|\.jpeg$|\.jpg$)/,'')
|
|
};
|
|
|
|
/**
|
|
* Returns true if unloaded
|
|
* @param component
|
|
* @returns {boolean}
|
|
* @constructor
|
|
*/
|
|
static Unloaded(component) {
|
|
if (
|
|
Utils.UndefinedOrNull(component) ||
|
|
Utils.UndefinedOrNull(component.instance)
|
|
) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
/**
|
|
*
|
|
* @param component
|
|
* @returns {boolean}
|
|
* @constructor
|
|
*/
|
|
static Loaded(component) {
|
|
if (component && component.instance) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
static BuildVectorSource(result, name, dimension) {
|
|
|
|
if (dimension === 2) {
|
|
result[name] = {};
|
|
result[name].x = false;
|
|
result[name].y = false;
|
|
return;
|
|
}
|
|
|
|
if (dimension === 3) {
|
|
result[name] = {};
|
|
result[name].x = false;
|
|
result[name].y = false;
|
|
result[name].y = false;
|
|
return;
|
|
}
|
|
|
|
if (dimension === 4) {
|
|
result[name] = {};
|
|
result[name].x = false;
|
|
result[name].y = false;
|
|
result[name].z = false;
|
|
result[name].w = false;
|
|
return;
|
|
}
|
|
|
|
console.warn('unknown dimension : ' + dimension);
|
|
};
|
|
|
|
/**
|
|
* Returns all 'instances' of the array, or null if an 'instance' is undefined
|
|
* @constructor
|
|
* @param array
|
|
*/
|
|
static GetArrayInstances(array) {
|
|
return array.reduce(
|
|
function(result, object) {
|
|
|
|
if (result === null) {
|
|
return result;
|
|
}
|
|
|
|
if (Utils.UndefinedOrNull(object.instance)) {
|
|
result = null;
|
|
} else {
|
|
result.push(object.instance);
|
|
}
|
|
|
|
return result;
|
|
},
|
|
[]
|
|
);
|
|
};
|
|
|
|
static SortFacesByMaterialIndex(faces) {
|
|
|
|
/**
|
|
* Sorts faces according to material index because later we will create
|
|
* groups for each vertice group
|
|
*/
|
|
faces.sort(function(a, b) {
|
|
|
|
if (a.materialIndex < b.materialIndex) {
|
|
return -1;
|
|
}
|
|
|
|
if (a.materialIndex > b.materialIndex) {
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
});
|
|
|
|
return faces;
|
|
};
|
|
|
|
static BuildQuaternionSource(result, name) {
|
|
result[name] = {};
|
|
result[name].axis = {};
|
|
result[name].axis.x = false;
|
|
result[name].axis.y = false;
|
|
result[name].axis.z = false;
|
|
result[name].angle = false;
|
|
result[name].x = false;
|
|
result[name].y = false;
|
|
result[name].z = false;
|
|
result[name].w = false;
|
|
};
|
|
|
|
static ObjectPropertiesAsBoolean(object) {
|
|
return Object.keys(object).reduce(
|
|
function(result, propertyId) {
|
|
|
|
if (typeof object[propertyId] === 'function') {
|
|
return result;
|
|
}
|
|
|
|
result[propertyId] = false;
|
|
|
|
// if (object[propertyId] instanceof R3.Vector2) {
|
|
// Utils.BuildVectorSource(result, propertyId, 2);
|
|
// }
|
|
//
|
|
// if (object[propertyId] instanceof R3.Vector3) {
|
|
// Utils.BuildVectorSource(result, propertyId, 3);
|
|
// }
|
|
//
|
|
// if (object[propertyId] instanceof R3.Vector4) {
|
|
// Utils.BuildVectorSource(result, propertyId, 4);
|
|
// }
|
|
//
|
|
// if (object[propertyId] instanceof R3.Quaternion) {
|
|
// Utils.BuildQuaternionSource(result, propertyId);
|
|
// }
|
|
|
|
return result;
|
|
|
|
}.bind(this),
|
|
{}
|
|
);
|
|
};
|
|
|
|
static GetRuntime() {
|
|
|
|
let result = null;
|
|
|
|
R3.Event.Emit(
|
|
R3.Event.GET_RUNTIME,
|
|
null,
|
|
function(runtime) {
|
|
result = runtime;
|
|
}
|
|
);
|
|
|
|
return result;
|
|
};
|
|
|
|
/**
|
|
* Returns the window size or null
|
|
* @returns {*}
|
|
* @constructor
|
|
*/
|
|
static GetWindowSize() {
|
|
|
|
let size = null;
|
|
|
|
R3.Event.Emit(
|
|
R3.Event.GET_WINDOW_SIZE,
|
|
null,
|
|
function(data) {
|
|
size = data;
|
|
}.bind(this)
|
|
);
|
|
|
|
return size;
|
|
|
|
};
|
|
|
|
/**
|
|
* Convenience function to update object width and height members with window size
|
|
* @param object
|
|
* @constructor
|
|
*/
|
|
static UpdateWindowSize(object) {
|
|
let size = Utils.GetWindowSize();
|
|
object.width = size.width;
|
|
object.height = size.height;
|
|
};
|
|
|
|
/**
|
|
* Returns id of object with the name if it exists in the array, otherwise null
|
|
* @param name
|
|
* @param array
|
|
* @returns {*}
|
|
* @constructor
|
|
*/
|
|
static ObjectIdWithNameInArray(name, array) {
|
|
|
|
return array.reduce(
|
|
function(result, object) {
|
|
|
|
if (result) {
|
|
return result;
|
|
}
|
|
|
|
if (name === object.name) {
|
|
return object.id;
|
|
}
|
|
|
|
return null;
|
|
},
|
|
null
|
|
);
|
|
};
|
|
|
|
static LoadIdsFromArrayToIdObject(array, idToObject) {
|
|
|
|
};
|
|
|
|
static LoadIdsFromObjectToIdObject(object, idToObject) {
|
|
|
|
};
|
|
|
|
/**
|
|
* Gets random int exclusive of maximum but inclusive of minimum
|
|
* @param min
|
|
* @param max
|
|
* @returns {*}
|
|
* @constructor
|
|
*/
|
|
static GetRandomInt(min, max) {
|
|
min = Math.ceil(min);
|
|
max = Math.floor(max);
|
|
return Math.floor(Math.random() * (max - min)) + min; //The maximum is exclusive and the minimum is inclusive
|
|
};
|
|
|
|
/**
|
|
* Gets random int inclusive of minimum and maximum
|
|
* @param min
|
|
* @param max
|
|
* @returns {*}
|
|
* @constructor
|
|
*/
|
|
static GetRandomIntInclusive(min, max) {
|
|
min = Math.ceil(min);
|
|
max = Math.floor(max);
|
|
return Math.floor(Math.random() * (max - min + 1)) + min; //The maximum is inclusive and the minimum is inclusive
|
|
};
|
|
|
|
static InterpolateArray(data, fitCount) {
|
|
|
|
let linearInterpolate = function(before, after, atPoint) {
|
|
return before + (after - before) * atPoint;
|
|
};
|
|
|
|
let newData = [];
|
|
|
|
let springFactor = Number((data.length - 1) / (fitCount - 1));
|
|
|
|
newData[0] = data[0]; // for new allocation
|
|
|
|
for ( let i = 1; i < fitCount - 1; i++) {
|
|
let tmp = i * springFactor;
|
|
let before = Number(Math.floor(tmp)).toFixed();
|
|
let after = Number(Math.ceil(tmp)).toFixed();
|
|
let atPoint = tmp - before;
|
|
newData[i] = linearInterpolate(data[before], data[after], atPoint);
|
|
}
|
|
|
|
newData[fitCount - 1] = data[data.length - 1]; // for new allocation
|
|
|
|
return newData;
|
|
};
|
|
|
|
/**
|
|
* Undefined or null check
|
|
* @param variable
|
|
* @returns {boolean}
|
|
* @constructor
|
|
*/
|
|
static UndefinedOrNull(
|
|
variable
|
|
) {
|
|
return typeof variable === 'undefined' || variable === null;
|
|
};
|
|
|
|
/**
|
|
* The variable is not undefined and not null
|
|
* @param variable
|
|
* @returns {boolean}
|
|
* @constructor
|
|
*/
|
|
static Defined(
|
|
variable
|
|
) {
|
|
return typeof variable !== 'undefined' && variable !== null;
|
|
};
|
|
|
|
/**
|
|
* Gets function parameters
|
|
* @param fn
|
|
* @constructor
|
|
*/
|
|
static GetParameters(fn) {
|
|
|
|
let FN_ARGS = /^function\s*[^\(]*\(\s*([^\)]*)\)/m;
|
|
let FN_ARG_SPLIT = /,/;
|
|
let FN_ARG = /^\s*(_?)(.+?)\s*$/;
|
|
let STRIP_COMMENTS = /(\/\/.*$)|(\/\*[\s\S]*?\*\/)|(\s*=[^,\)]*(('(?:\'|[^'\r\n])*')|("(?:\"|[^"\r\n])*"))|(\s*=[^,\)]*))/mg;
|
|
|
|
let parameters,
|
|
fnText,
|
|
argDecl;
|
|
|
|
if (typeof fn !== 'function') {
|
|
parameters = [];
|
|
fnText = fn.toString().replace(STRIP_COMMENTS, '');
|
|
argDecl = fnText.match(FN_ARGS);
|
|
argDecl[1].split(FN_ARG_SPLIT).forEach(function(arg) {
|
|
arg.replace(FN_ARG, function(all, underscore, name) {
|
|
parameters.push(name);
|
|
});
|
|
});
|
|
} else {
|
|
throw Error("not a function")
|
|
}
|
|
|
|
return parameters;
|
|
};
|
|
|
|
/**
|
|
* Returns either an ID of the object or Null
|
|
* @param object
|
|
* @returns {null}
|
|
* @constructor
|
|
*/
|
|
static IdOrNull(object) {
|
|
if (Utils.UndefinedOrNull(object)) {
|
|
return null;
|
|
} else {
|
|
if (Utils.UndefinedOrNull(object.id)) {
|
|
console.warn('saving an object reference with no ID : ', object);
|
|
return null;
|
|
}
|
|
return object.id;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Limit a property to values between -pi and +pi
|
|
* @param property
|
|
* @param objectProperty
|
|
* @returns {{configurable?: boolean, enumerable?: boolean, value?, writable?: boolean, get?: Function, set?: Function}}
|
|
* @constructor
|
|
*/
|
|
static LimitToPI(property, objectProperty) {
|
|
|
|
let store = objectProperty;
|
|
|
|
return {
|
|
get : function() {
|
|
return store;
|
|
},
|
|
set : function(value) {
|
|
while (value > Math.PI) {
|
|
value -= (Math.PI * 2);
|
|
}
|
|
|
|
while (value < -(Math.PI)) {
|
|
value += (Math.PI * 2);
|
|
}
|
|
|
|
store = value;
|
|
}
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Returns an array of IDs representing the objects
|
|
* @param array
|
|
* @returns []
|
|
* @constructor
|
|
*/
|
|
static IdArrayOrEmptyArray(array) {
|
|
if (Utils.UndefinedOrNull(array)) {
|
|
return [];
|
|
} else {
|
|
|
|
return array.map(function(item) {
|
|
|
|
if (Utils.UndefinedOrNull(item.id)) {
|
|
throw new Error('No ID found while trying to store IDs to array');
|
|
}
|
|
|
|
return item.id
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Links an object to its parent through idToObject array
|
|
* @param propertyString
|
|
* @param idToObject
|
|
* @param parentObject
|
|
* @param id
|
|
* @constructor
|
|
*/
|
|
static Link(propertyString, idToObject, parentObject, id) {
|
|
|
|
if (!Utils.UndefinedOrNull(parentObject[propertyString])) {
|
|
|
|
if (!idToObject.hasOwnProperty(id)) {
|
|
console.warn('Linking failed for object:' + parentObject.name);
|
|
}
|
|
|
|
parentObject[propertyString] = idToObject[id];
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Generates a random ID
|
|
* @returns {string}
|
|
* @constructor
|
|
*/
|
|
static RandomId(length) {
|
|
|
|
if (Utils.UndefinedOrNull(length)) {
|
|
length = 10;
|
|
}
|
|
|
|
return Math.random().toString(36).substr(2, length);
|
|
};
|
|
|
|
static InvertWindingOrder(triangles) {
|
|
|
|
for (let i = 0; i < triangles.length; i++) {
|
|
let v1 = triangles[i].v1;
|
|
triangles[i].v1 = triangles[i].v2;
|
|
triangles[i].v2 = v1;
|
|
|
|
let backupUV = triangles[i].triangle.v1uv;
|
|
triangles[i].triangle.v1uv = triangles[i].triangle.v2uv;
|
|
triangles[i].triangle.v2uv = backupUV;
|
|
}
|
|
|
|
return triangles;
|
|
};
|
|
|
|
/**
|
|
* Inverts a mesh winding order (and its instance)
|
|
* @param mesh R3.D3.Mesh
|
|
* @returns {*}
|
|
* @constructor
|
|
*/
|
|
static InvertMeshWindingOrder(mesh) {
|
|
|
|
mesh.faces.forEach(
|
|
function(face) {
|
|
|
|
let tmpV1 = face.v1;
|
|
face.v1 = face.v2;
|
|
face.v2 = tmpV1;
|
|
|
|
let tmpV1uv = face.v1uv;
|
|
face.v1uv = face.v2uv;
|
|
face.v2uv = tmpV1uv;
|
|
|
|
}.bind(this)
|
|
);
|
|
|
|
//mesh.computeNormals = true;
|
|
//mesh.createInstance();
|
|
};
|
|
|
|
/**
|
|
* This function resets a the winding order of a mesh from a reference point V (the average center of the mesh)
|
|
*/
|
|
static ResetWindingOrder(faces, vertices) {
|
|
|
|
let vertexList = new R3.API.Vector3.Points();
|
|
|
|
for (let v = 0; v < vertices.length; v++) {
|
|
vertexList.add(new R3.API.Vector3(
|
|
vertices[v].position.x,
|
|
vertices[v].position.y,
|
|
vertices[v].position.z
|
|
));
|
|
}
|
|
|
|
let V = vertexList.average();
|
|
|
|
let triangles = [];
|
|
|
|
for (let s = 0; s < faces.length; s += 3) {
|
|
|
|
let v0 = faces[s];
|
|
let v1 = faces[s+1];
|
|
let v2 = faces[s+2];
|
|
|
|
triangles.push(
|
|
{
|
|
v0 : v0,
|
|
v1 : v1,
|
|
v2 : v2,
|
|
edges : [
|
|
{v0: v0, v1: v1},
|
|
{v0: v1, v1: v2},
|
|
{v0: v2, v1: v0}
|
|
],
|
|
winding : 0,
|
|
edgeIndex : -1,
|
|
processed : false
|
|
}
|
|
);
|
|
}
|
|
|
|
for (let i = 0; i < triangles.length; i++) {
|
|
if (
|
|
R3.API.Vector3.clockwise(
|
|
vertices[triangles[i].v0].position,
|
|
vertices[triangles[i].v1].position,
|
|
vertices[triangles[i].v2].position,
|
|
V
|
|
)
|
|
) {
|
|
console.log('clockwise');
|
|
let bv1 = triangles[i].v1;
|
|
triangles[i].v1 = triangles[i].v2;
|
|
triangles[i].v2 = bv1;
|
|
} else {
|
|
console.log('not clockwise');
|
|
}
|
|
}
|
|
|
|
return triangles;
|
|
};
|
|
|
|
/**
|
|
* This function resets the winding order for triangles in faces, given an initial triangle and orientation edge
|
|
* used pseudocode from
|
|
* http://stackoverflow.com/questions/17036970/how-to-correct-winding-of-triangles-to-counter-clockwise-direction-of-a-3d-mesh
|
|
* We need to use a graph traversal algorithm,
|
|
* lets assume we have method that returns neighbor of triangle on given edge
|
|
*
|
|
* neighbor_on_egde( next_tria, edge )
|
|
*
|
|
* to_process = set of pairs triangle and orientation edge, initial state is one good oriented triangle with any edge on it
|
|
* processed = set of processed triangles; initial empty
|
|
*
|
|
* while to_process is not empty:
|
|
* next_tria, orientation_edge = to_process.pop()
|
|
* add next_tria in processed
|
|
* if next_tria is not opposite oriented than orientation_edge:
|
|
* change next_tria (ABC) orientation (B<->C)
|
|
* for each edge (AB) in next_tria:
|
|
* neighbor_tria = neighbor_on_egde( next_tria, edge )
|
|
* if neighbor_tria exists and neighbor_tria not in processed:
|
|
* to_process add (neighbor_tria, edge opposite oriented (BA))
|
|
* @param faces R3.D3.Face[]
|
|
* @param orientationEdge R3.API.Vector2
|
|
* @returns {Array}
|
|
*/
|
|
static FixWindingOrder(faces, orientationEdge) {
|
|
|
|
/**
|
|
* Checks if a Face belonging to a TriangleEdge has already been processed
|
|
* @param processed TriangleEdge[]
|
|
* @param triangle Face
|
|
* @returns {boolean}
|
|
*/
|
|
function inProcessed(processed, triangle) {
|
|
|
|
for (let i = 0; i < processed.length; i++) {
|
|
if (processed[i].triangle.equals(triangle)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns a neighbouring triangle on a specific edge - preserving the edge orientation
|
|
* @param edge R3.API.Vector2
|
|
* @param faces R3.D3.Face[]
|
|
* @param currentTriangle
|
|
* @returns {*}
|
|
*/
|
|
function neighbourOnEdge(edge, faces, currentTriangle) {
|
|
|
|
for (let i = 0; i < faces.length; i++) {
|
|
if (
|
|
(faces[i].v0 === edge.x && faces[i].v1 === edge.y) ||
|
|
(faces[i].v1 === edge.x && faces[i].v2 === edge.y) ||
|
|
(faces[i].v2 === edge.x && faces[i].v0 === edge.y) ||
|
|
(faces[i].v0 === edge.y && faces[i].v1 === edge.x) ||
|
|
(faces[i].v1 === edge.y && faces[i].v2 === edge.x) ||
|
|
(faces[i].v2 === edge.y && faces[i].v0 === edge.x)
|
|
) {
|
|
|
|
let triangle = new R3.D3.API.Face(
|
|
null,
|
|
null,
|
|
faces[i].v0index,
|
|
faces[i].v1index,
|
|
faces[i].v2index,
|
|
faces[i].materialIndex,
|
|
faces[i].uvs
|
|
);
|
|
|
|
if (triangle.equals(currentTriangle)) {
|
|
continue;
|
|
}
|
|
|
|
return new R3.D3.TriangleEdge(
|
|
triangle,
|
|
edge
|
|
);
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
let toProcess = [
|
|
new R3.D3.TriangleEdge(
|
|
new R3.D3.API.Face(
|
|
null,
|
|
null,
|
|
faces[0].v0index,
|
|
faces[0].v1index,
|
|
faces[0].v2index,
|
|
faces[0].materialIndex,
|
|
faces[0].uvs
|
|
),
|
|
orientationEdge
|
|
)
|
|
];
|
|
|
|
let processed = [];
|
|
|
|
while (toProcess.length > 0) {
|
|
|
|
let triangleEdge = toProcess.pop();
|
|
|
|
/**
|
|
* If edge is the same orientation (i.e. the edge order is the same as the given triangle edge) it needs to be reversed
|
|
* to have the same winding order)
|
|
*/
|
|
if (
|
|
(triangleEdge.triangle.v0index === triangleEdge.edge.x &&
|
|
triangleEdge.triangle.v1index === triangleEdge.edge.y) ||
|
|
(triangleEdge.triangle.v1index === triangleEdge.edge.x &&
|
|
triangleEdge.triangle.v2index === triangleEdge.edge.y) ||
|
|
(triangleEdge.triangle.v2index === triangleEdge.edge.x &&
|
|
triangleEdge.triangle.v0index === triangleEdge.edge.y)
|
|
) {
|
|
let backupV = triangleEdge.triangle.v1index;
|
|
triangleEdge.triangle.v1index = triangleEdge.triangle.v2index;
|
|
triangleEdge.triangle.v2index = backupV;
|
|
|
|
// let backupUV = triangleEdge.triangle.v1uv;
|
|
// triangleEdge.triangle.v1uv = triangleEdge.triangle.v2uv;
|
|
// triangleEdge.triangle.v2uv = backupUV;
|
|
//
|
|
let backupUV = triangleEdge.triangle.uvs[0][1];
|
|
triangleEdge.triangle.uvs[0][1] = triangleEdge.triangle.uvs[0][2];
|
|
triangleEdge.triangle.uvs[0][2] = backupUV;
|
|
}
|
|
|
|
processed.push(triangleEdge);
|
|
|
|
let edges = [
|
|
new R3.API.Vector2(
|
|
triangleEdge.triangle.v0index,
|
|
triangleEdge.triangle.v1index
|
|
),
|
|
new R3.API.Vector2(
|
|
triangleEdge.triangle.v1index,
|
|
triangleEdge.triangle.v2index
|
|
),
|
|
new R3.API.Vector2(
|
|
triangleEdge.triangle.v2index,
|
|
triangleEdge.triangle.v0index
|
|
)
|
|
];
|
|
|
|
for (let j = 0; j < edges.length; j++) {
|
|
let neighbour = neighbourOnEdge(edges[j], faces, triangleEdge.triangle);
|
|
if (neighbour && !inProcessed(processed, neighbour.triangle)) {
|
|
toProcess.push(neighbour);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* In processed - we will have some duplicates - only add the unique ones
|
|
* @type {Array}
|
|
*/
|
|
let triangles = [];
|
|
for (let i = 0; i < processed.length; i++) {
|
|
let found = false;
|
|
for (let k = 0; k < triangles.length; k++) {
|
|
if (triangles[k].equals(processed[i].triangle)){
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!found) {
|
|
triangles.push(processed[i].triangle);
|
|
}
|
|
}
|
|
|
|
return triangles;
|
|
};
|
|
|
|
/**
|
|
* This is a work-around function to fix polys which don't triangulate because
|
|
* they could lie on Z-plane (XZ or YZ)) - we translate the poly to the origin, systematically rotate the poly around
|
|
* Z then Y axis
|
|
* @param verticesFlat []
|
|
* @param grain is the amount to systematically rotate the poly by - a finer grain means a more accurate maximum XY
|
|
* @return []
|
|
*/
|
|
static FixPolyZPlane(verticesFlat, grain) {
|
|
|
|
if ((verticesFlat.length % 3) !== 0 && !(verticesFlat.length > 9)) {
|
|
console.log("The vertices are not in the right length : " + verticesFlat.length);
|
|
}
|
|
|
|
let vertices = [];
|
|
|
|
let points = new R3.API.Quaternion.Points();
|
|
|
|
for (let i = 0; i < verticesFlat.length; i += 3) {
|
|
points.add(new R3.API.Vector3(
|
|
verticesFlat[i],
|
|
verticesFlat[i + 1],
|
|
verticesFlat[i + 2]
|
|
));
|
|
}
|
|
|
|
points.toOrigin();
|
|
|
|
points.maximizeXDistance(grain);
|
|
|
|
points.maximizeYDistance(grain);
|
|
|
|
for (i = 0; i < points.vectors.length; i++) {
|
|
vertices.push(
|
|
[
|
|
points.vectors[i].x,
|
|
points.vectors[i].y
|
|
]
|
|
);
|
|
}
|
|
|
|
return vertices;
|
|
};
|
|
|
|
static MovingAverage(period) {
|
|
let nums = [];
|
|
return function(num) {
|
|
nums.push(num);
|
|
if (nums.length > period)
|
|
nums.splice(0,1); // remove the first element of the array
|
|
let sum = 0;
|
|
for (let i in nums)
|
|
sum += nums[i];
|
|
let n = period;
|
|
if (nums.length < period)
|
|
n = nums.length;
|
|
return(sum/n);
|
|
}
|
|
};
|
|
|
|
static Intersect(a, b) {
|
|
|
|
let t;
|
|
|
|
/**
|
|
* Loop over shortest array
|
|
*/
|
|
if (b.length > a.length) {
|
|
t = b;
|
|
b = a;
|
|
a = t;
|
|
}
|
|
|
|
return a.filter(
|
|
/**
|
|
* Check if exists
|
|
* @param e
|
|
* @returns {boolean}
|
|
*/
|
|
function(e) {
|
|
return (b.indexOf(e) > -1);
|
|
}
|
|
).filter(
|
|
/**
|
|
* Remove Duplicates
|
|
* @param e
|
|
* @param i
|
|
* @param c
|
|
* @returns {boolean}
|
|
*/
|
|
function(e, i, c) {
|
|
return c.indexOf(e) === i;
|
|
}
|
|
);
|
|
};
|
|
|
|
static Difference(a, b) {
|
|
|
|
let t;
|
|
|
|
/**
|
|
* Loop over shortest array
|
|
*/
|
|
if (b.length > a.length) {
|
|
t = b;
|
|
b = a;
|
|
a = t;
|
|
}
|
|
|
|
return a.filter(
|
|
/**
|
|
* Check if exists
|
|
* @param e
|
|
* @returns {boolean}
|
|
*/
|
|
function(e) {
|
|
return (b.indexOf(e) === -1);
|
|
}
|
|
).filter(
|
|
/**
|
|
* Remove Duplicates
|
|
* @param e
|
|
* @param i
|
|
* @param c
|
|
* @returns {boolean}
|
|
*/
|
|
function(e, i, c) {
|
|
return c.indexOf(e) === i;
|
|
}
|
|
);
|
|
};
|
|
|
|
/**
|
|
* Push only if not in there already
|
|
* @param array
|
|
* @param object
|
|
* @constructor
|
|
*/
|
|
static PushUnique(array, object) {
|
|
|
|
if (array.indexOf(object) === -1) {
|
|
array.push(object);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Checks whether or not the object is empty
|
|
* @param obj
|
|
* @returns {boolean}
|
|
* @constructor
|
|
*/
|
|
static IsEmpty(obj) {
|
|
return (Object.keys(obj).length === 0 && obj.constructor === Object);
|
|
};
|
|
|
|
static IsString(member) {
|
|
return (typeof member === 'string');
|
|
};
|
|
|
|
static IsBoolean(member) {
|
|
return (member === true || member === false);
|
|
};
|
|
|
|
static IsColor(member) {
|
|
return (member instanceof R3.Color);
|
|
};
|
|
|
|
static IsNumber(member) {
|
|
return (typeof member === 'number');
|
|
};
|
|
|
|
static IsVector2(member) {
|
|
return (
|
|
member instanceof R3.API.Vector2 ||
|
|
member instanceof R3.Vector2
|
|
);
|
|
};
|
|
|
|
static IsVector3(member) {
|
|
return (
|
|
member instanceof R3.API.Vector3 ||
|
|
member instanceof R3.Vector3
|
|
);
|
|
};
|
|
|
|
static IsVector4(member) {
|
|
return (
|
|
member instanceof R3.API.Vector4 ||
|
|
member instanceof R3.Vector4 ||
|
|
member instanceof R3.API.Quaternion ||
|
|
member instanceof R3.Quaternion
|
|
);
|
|
};
|
|
|
|
static IsObject(member) {
|
|
let type = typeof member;
|
|
return type === 'function' || type === 'object' && !!member;
|
|
};
|
|
|
|
/**
|
|
* @return {string}
|
|
*/
|
|
static LowerUnderscore(name) {
|
|
let string = name.toLowerCase().replace(/\s+/g, '_');
|
|
string = string.replace(/-/g, '_');
|
|
string = string.replace(/\_+/g, '_');
|
|
return string;
|
|
};
|
|
|
|
static UpperCaseWordsSpaces(input) {
|
|
|
|
let word = input.replace(/[-_]/g, ' ');
|
|
|
|
word = word.replace(/\s+/, ' ');
|
|
|
|
let words = word.split(' ');
|
|
|
|
return words.reduce(
|
|
function(result, word) {
|
|
result += word[0].toUpperCase() + word.substr(1);
|
|
return result + ' ';
|
|
},
|
|
''
|
|
).trim();
|
|
};
|
|
|
|
/**
|
|
* @return {string}
|
|
*/
|
|
static UpperCaseUnderscore(word) {
|
|
|
|
let str = '';
|
|
|
|
word.split('').map(
|
|
function(letter){
|
|
if (letter === letter.toUpperCase()) {
|
|
str += '_' + letter;
|
|
} else {
|
|
str += letter.toUpperCase();
|
|
}
|
|
});
|
|
|
|
str = str.replace(new RegExp('^_'),'');
|
|
|
|
return str;
|
|
};
|
|
|
|
/**
|
|
* Returns Left Padded Text - ex. length 5, padchar 0, string abc = '00abc'
|
|
* @param length
|
|
* @param padChar
|
|
* @param string
|
|
* @returns {string}
|
|
* @constructor
|
|
*/
|
|
static PaddedText(length, padChar, string) {
|
|
|
|
let pad = "";
|
|
|
|
for (let x = 0; x < length; x++) {
|
|
pad += padChar;
|
|
}
|
|
|
|
return pad.substring(0, pad.length - string.length) + string;
|
|
};
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
Class R3.System.Input
|
|
[Inherited from System]
|
|
|
|
Inherited Properties:
|
|
|
|
- started (Default value false)
|
|
- subscriptions (Default value [])
|
|
|
|
Inherited Static Properties:
|
|
|
|
- Started (Default value false)
|
|
- Subscriptions (Default value [])
|
|
|
|
Inherited Methods:
|
|
|
|
<no inherited methods>
|
|
|
|
Inherited Static Methods:
|
|
|
|
<no inherited static methods>
|
|
|
|
[Belonging to SystemInput]
|
|
|
|
Properties:
|
|
|
|
<no properties>
|
|
|
|
Static Properties:
|
|
|
|
<no static properties>
|
|
|
|
Methods:
|
|
|
|
- start()
|
|
Starts a transient system by registering subscriptions to Events
|
|
|
|
- stop()
|
|
Stops a transient system to by removing subscriptions to Events
|
|
|
|
Static Methods:
|
|
|
|
- Start()
|
|
Starts the system by registering subscriptions to events
|
|
|
|
- Stop()
|
|
Stops the system by removing these subscriptions to events
|
|
|
|
**/
|
|
|
|
class SystemInput extends System {
|
|
|
|
constructor(options) {
|
|
|
|
if (typeof options === 'undefined') {
|
|
options = {};
|
|
}
|
|
|
|
super(options);
|
|
|
|
this.emit(Event.OBJECT_CREATED, this);
|
|
|
|
Object.assign(this, options);
|
|
|
|
this.emit(Event.OBJECT_INITIALIZED, this);
|
|
|
|
}
|
|
|
|
/**
|
|
* start()
|
|
* - Starts a transient system by registering subscriptions to Events
|
|
*/
|
|
start() {
|
|
|
|
console.log('Test for custom start before');
|
|
|
|
this.started = true;
|
|
|
|
console.log('Started transient system: SystemInput');
|
|
|
|
}
|
|
|
|
/**
|
|
* stop()
|
|
* - Stops a transient system to by removing subscriptions to Events
|
|
*/
|
|
stop() {
|
|
|
|
this.started = false;
|
|
|
|
console.log('Stopped transient system: SystemInput');
|
|
|
|
}
|
|
|
|
/**
|
|
* Start()
|
|
* - Starts the system by registering subscriptions to events
|
|
*/
|
|
static Start() {
|
|
|
|
SystemInput.Subscriptions.push(
|
|
new Event.Subscribe(
|
|
Event.TOUCH_START,
|
|
SystemInput.OnTouchStart
|
|
)
|
|
);
|
|
SystemInput.Subscriptions.push(
|
|
new Event.Subscribe(
|
|
Event.TOUCH_END,
|
|
SystemInput.OnTouchEnd
|
|
)
|
|
);
|
|
SystemInput.Subscriptions.push(
|
|
new Event.Subscribe(
|
|
Event.TOUCH_MOVE,
|
|
SystemInput.OnTouchMove
|
|
)
|
|
);
|
|
SystemInput.Subscriptions.push(
|
|
new Event.Subscribe(
|
|
Event.TOUCH_CANCEL,
|
|
SystemInput.OnTouchCancel
|
|
)
|
|
);
|
|
SystemInput.Subscriptions.push(
|
|
new Event.Subscribe(
|
|
Event.KEYBOARD_DOWN,
|
|
SystemInput.OnKeyboardDown
|
|
)
|
|
);
|
|
SystemInput.Subscriptions.push(
|
|
new Event.Subscribe(
|
|
Event.KEYBOARD_UP,
|
|
SystemInput.OnKeyboardUp
|
|
)
|
|
);
|
|
SystemInput.Subscriptions.push(
|
|
new Event.Subscribe(
|
|
Event.MOUSE_DOWN,
|
|
SystemInput.OnMouseDown
|
|
)
|
|
);
|
|
SystemInput.Subscriptions.push(
|
|
new Event.Subscribe(
|
|
Event.MOUSE_UP,
|
|
SystemInput.OnMouseUp
|
|
)
|
|
);
|
|
SystemInput.Subscriptions.push(
|
|
new Event.Subscribe(
|
|
Event.MOUSE_MOVE,
|
|
SystemInput.OnMouseMove
|
|
)
|
|
);
|
|
SystemInput.Subscriptions.push(
|
|
new Event.Subscribe(
|
|
Event.MOUSE_WHEEL,
|
|
SystemInput.OnMouseWheel
|
|
)
|
|
);
|
|
|
|
SystemInput.Started = true;
|
|
|
|
console.log('Started system: SystemInput');
|
|
|
|
}
|
|
|
|
/**
|
|
* Stop()
|
|
* - Stops the system by removing these subscriptions to events
|
|
*/
|
|
static Stop() {
|
|
|
|
SystemInput.Subscriptions = SystemInput.Subscriptions.reduce(
|
|
(result, subscription) => {
|
|
if (subscription.remove() !== true) {
|
|
result.push(subscription);
|
|
}
|
|
return result;
|
|
},
|
|
[]
|
|
);
|
|
|
|
SystemInput.Subscriptions = SystemInput.Subscriptions.reduce(
|
|
(result, subscription) => {
|
|
if (subscription.remove() !== true) {
|
|
result.push(subscription);
|
|
}
|
|
return result;
|
|
},
|
|
[]
|
|
);
|
|
|
|
SystemInput.Subscriptions = SystemInput.Subscriptions.reduce(
|
|
(result, subscription) => {
|
|
if (subscription.remove() !== true) {
|
|
result.push(subscription);
|
|
}
|
|
return result;
|
|
},
|
|
[]
|
|
);
|
|
|
|
SystemInput.Subscriptions = SystemInput.Subscriptions.reduce(
|
|
(result, subscription) => {
|
|
if (subscription.remove() !== true) {
|
|
result.push(subscription);
|
|
}
|
|
return result;
|
|
},
|
|
[]
|
|
);
|
|
|
|
SystemInput.Subscriptions = SystemInput.Subscriptions.reduce(
|
|
(result, subscription) => {
|
|
if (subscription.remove() !== true) {
|
|
result.push(subscription);
|
|
}
|
|
return result;
|
|
},
|
|
[]
|
|
);
|
|
|
|
SystemInput.Subscriptions = SystemInput.Subscriptions.reduce(
|
|
(result, subscription) => {
|
|
if (subscription.remove() !== true) {
|
|
result.push(subscription);
|
|
}
|
|
return result;
|
|
},
|
|
[]
|
|
);
|
|
|
|
SystemInput.Subscriptions = SystemInput.Subscriptions.reduce(
|
|
(result, subscription) => {
|
|
if (subscription.remove() !== true) {
|
|
result.push(subscription);
|
|
}
|
|
return result;
|
|
},
|
|
[]
|
|
);
|
|
|
|
SystemInput.Subscriptions = SystemInput.Subscriptions.reduce(
|
|
(result, subscription) => {
|
|
if (subscription.remove() !== true) {
|
|
result.push(subscription);
|
|
}
|
|
return result;
|
|
},
|
|
[]
|
|
);
|
|
|
|
SystemInput.Subscriptions = SystemInput.Subscriptions.reduce(
|
|
(result, subscription) => {
|
|
if (subscription.remove() !== true) {
|
|
result.push(subscription);
|
|
}
|
|
return result;
|
|
},
|
|
[]
|
|
);
|
|
|
|
SystemInput.Subscriptions = SystemInput.Subscriptions.reduce(
|
|
(result, subscription) => {
|
|
if (subscription.remove() !== true) {
|
|
result.push(subscription);
|
|
}
|
|
return result;
|
|
},
|
|
[]
|
|
);
|
|
|
|
SystemInput.Started = false;
|
|
|
|
console.log('Stopped system: SystemInput');
|
|
|
|
}
|
|
|
|
/**
|
|
* OnTouchStart()
|
|
* - Listens to events of type Event.TOUCH_START and executes this function.
|
|
* @param data (The event data passed as argument - typically an R3Object)
|
|
* @return null
|
|
*/
|
|
static OnTouchStart(data) {
|
|
|
|
}
|
|
|
|
/**
|
|
* OnTouchEnd()
|
|
* - Listens to events of type Event.TOUCH_END and executes this function.
|
|
* @param data (The event data passed as argument - typically an R3Object)
|
|
* @return null
|
|
*/
|
|
static OnTouchEnd(data) {
|
|
|
|
}
|
|
|
|
/**
|
|
* OnTouchMove()
|
|
* - Listens to events of type Event.TOUCH_MOVE and executes this function.
|
|
* @param data (The event data passed as argument - typically an R3Object)
|
|
* @return null
|
|
*/
|
|
static OnTouchMove(data) {
|
|
|
|
}
|
|
|
|
/**
|
|
* OnTouchCancel()
|
|
* - Listens to events of type Event.TOUCH_CANCEL and executes this function.
|
|
* @param data (The event data passed as argument - typically an R3Object)
|
|
* @return null
|
|
*/
|
|
static OnTouchCancel(data) {
|
|
|
|
}
|
|
|
|
/**
|
|
* OnKeyboardDown()
|
|
* - Listens to events of type Event.KEYBOARD_DOWN and executes this function.
|
|
* @param data (The event data passed as argument - typically an R3Object)
|
|
* @return null
|
|
*/
|
|
static OnKeyboardDown(data) {
|
|
|
|
}
|
|
|
|
/**
|
|
* OnKeyboardUp()
|
|
* - Listens to events of type Event.KEYBOARD_UP and executes this function.
|
|
* @param data (The event data passed as argument - typically an R3Object)
|
|
* @return null
|
|
*/
|
|
static OnKeyboardUp(data) {
|
|
|
|
}
|
|
|
|
/**
|
|
* OnMouseDown()
|
|
* - Listens to events of type Event.MOUSE_DOWN and executes this function.
|
|
* @param data (The event data passed as argument - typically an R3Object)
|
|
* @return null
|
|
*/
|
|
static OnMouseDown(data) {
|
|
|
|
}
|
|
|
|
/**
|
|
* OnMouseUp()
|
|
* - Listens to events of type Event.MOUSE_UP and executes this function.
|
|
* @param data (The event data passed as argument - typically an R3Object)
|
|
* @return null
|
|
*/
|
|
static OnMouseUp(data) {
|
|
|
|
}
|
|
|
|
/**
|
|
* OnMouseMove()
|
|
* - Listens to events of type Event.MOUSE_MOVE and executes this function.
|
|
* @param data (The event data passed as argument - typically an R3Object)
|
|
* @return null
|
|
*/
|
|
static OnMouseMove(data) {
|
|
|
|
}
|
|
|
|
/**
|
|
* OnMouseWheel()
|
|
* - Listens to events of type Event.MOUSE_WHEEL and executes this function.
|
|
* @param data (The event data passed as argument - typically an R3Object)
|
|
* @return null
|
|
*/
|
|
static OnMouseWheel(data) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
Class R3.System.Linking
|
|
[Inherited from System]
|
|
|
|
Inherited Properties:
|
|
|
|
- started (Default value false)
|
|
- subscriptions (Default value [])
|
|
|
|
Inherited Static Properties:
|
|
|
|
- Started (Default value false)
|
|
- Subscriptions (Default value [])
|
|
|
|
Inherited Methods:
|
|
|
|
<no inherited methods>
|
|
|
|
Inherited Static Methods:
|
|
|
|
<no inherited static methods>
|
|
|
|
[Belonging to SystemLinking]
|
|
|
|
Properties:
|
|
|
|
<no properties>
|
|
|
|
Static Properties:
|
|
|
|
<no static properties>
|
|
|
|
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
|
|
|
|
**/
|
|
|
|
class SystemLinking extends System {
|
|
|
|
constructor(options) {
|
|
|
|
if (typeof options === 'undefined') {
|
|
options = {};
|
|
}
|
|
|
|
super(options);
|
|
|
|
this.emit(Event.OBJECT_CREATED, this);
|
|
|
|
Object.assign(this, options);
|
|
|
|
this.emit(Event.OBJECT_INITIALIZED, this);
|
|
|
|
}
|
|
|
|
/**
|
|
* start()
|
|
* - Just calls System.Start(options)
|
|
* @param options
|
|
*/
|
|
start(options) {
|
|
|
|
this.started = true;
|
|
|
|
console.log('Started transient system: SystemLinking');
|
|
|
|
}
|
|
|
|
/**
|
|
* stop()
|
|
* - Just calls System.Stop(options)
|
|
* @param options
|
|
*/
|
|
stop(options) {
|
|
|
|
this.started = false;
|
|
|
|
console.log('Stopped transient system: SystemLinking');
|
|
|
|
}
|
|
|
|
/**
|
|
* Start()
|
|
* - Starts the system by registering subscriptions to events
|
|
* @param options
|
|
*/
|
|
static Start(options) {
|
|
|
|
SystemLinking.Subscriptions.push(
|
|
new Event.Subscribe(
|
|
Event.OBJECT_CREATED,
|
|
SystemLinking.OnObjectCreated
|
|
)
|
|
);
|
|
SystemLinking.Subscriptions.push(
|
|
new Event.Subscribe(
|
|
Event.INSTANCE_CREATED,
|
|
SystemLinking.OnInstanceCreated
|
|
)
|
|
);
|
|
|
|
SystemLinking.Started = true;
|
|
|
|
console.log('Started system: SystemLinking');
|
|
|
|
}
|
|
|
|
/**
|
|
* Stop()
|
|
* - Stops the system by removing these subscriptions to events
|
|
* @param options
|
|
*/
|
|
static Stop(options) {
|
|
|
|
SystemLinking.Subscriptions = SystemLinking.Subscriptions.reduce(
|
|
(result, subscription) => {
|
|
if (subscription.remove() !== true) {
|
|
result.push(subscription);
|
|
}
|
|
return result;
|
|
},
|
|
[]
|
|
);
|
|
|
|
SystemLinking.Subscriptions = SystemLinking.Subscriptions.reduce(
|
|
(result, subscription) => {
|
|
if (subscription.remove() !== true) {
|
|
result.push(subscription);
|
|
}
|
|
return result;
|
|
},
|
|
[]
|
|
);
|
|
|
|
SystemLinking.Started = false;
|
|
|
|
console.log('Stopped system: SystemLinking');
|
|
|
|
}
|
|
|
|
/**
|
|
* OnObjectCreated()
|
|
* - Listens to events of type Event.OBJECT_CREATED and executes this function.
|
|
* @param data (The event data passed as argument - typically an R3Object)
|
|
* @return null
|
|
*/
|
|
static OnObjectCreated(data) {
|
|
|
|
}
|
|
|
|
/**
|
|
* OnInstanceCreated()
|
|
* - Listens to events of type Event.INSTANCE_CREATED and executes this function.
|
|
* @param data (The event data passed as argument - typically an R3Object)
|
|
* @return null
|
|
*/
|
|
static OnInstanceCreated(data) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
Class R3.System.Socket
|
|
[Inherited from System]
|
|
|
|
Inherited Properties:
|
|
|
|
- started (Default value false)
|
|
- subscriptions (Default value [])
|
|
|
|
Inherited Static Properties:
|
|
|
|
- Started (Default value false)
|
|
- Subscriptions (Default value [])
|
|
|
|
Inherited Methods:
|
|
|
|
<no inherited methods>
|
|
|
|
Inherited Static Methods:
|
|
|
|
<no inherited static methods>
|
|
|
|
[Belonging to SystemSocket]
|
|
|
|
Properties:
|
|
|
|
<no properties>
|
|
|
|
Static Properties:
|
|
|
|
<no static properties>
|
|
|
|
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
|
|
|
|
**/
|
|
|
|
class SystemSocket extends System {
|
|
|
|
constructor(options) {
|
|
|
|
if (typeof options === 'undefined') {
|
|
options = {};
|
|
}
|
|
|
|
super(options);
|
|
|
|
this.emit(Event.OBJECT_CREATED, this);
|
|
|
|
Object.assign(this, options);
|
|
|
|
this.emit(Event.OBJECT_INITIALIZED, this);
|
|
|
|
}
|
|
|
|
/**
|
|
* start()
|
|
* - Just calls System.Start(options)
|
|
* @param options
|
|
*/
|
|
start(options) {
|
|
|
|
this.started = true;
|
|
|
|
console.log('Started transient system: SystemSocket');
|
|
|
|
}
|
|
|
|
/**
|
|
* stop()
|
|
* - Just calls System.Stop(options)
|
|
* @param options
|
|
*/
|
|
stop(options) {
|
|
|
|
this.started = false;
|
|
|
|
console.log('Stopped transient system: SystemSocket');
|
|
|
|
console.log('system socket stop test');
|
|
|
|
}
|
|
|
|
/**
|
|
* Start()
|
|
* - Starts the system by registering subscriptions to events
|
|
* @param options
|
|
*/
|
|
static Start(options) {
|
|
|
|
SystemSocket.Started = true;
|
|
|
|
console.log('Started system: SystemSocket');
|
|
|
|
console.log('CUSTOM Start Test Stuff');
|
|
|
|
}
|
|
|
|
/**
|
|
* Stop()
|
|
* - Stops the system by removing these subscriptions to events
|
|
* @param options
|
|
*/
|
|
static Stop(options) {
|
|
|
|
SystemSocket.Started = false;
|
|
|
|
console.log('Stopped system: SystemSocket');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
Class R3.System.Test
|
|
[Inherited from System]
|
|
|
|
Inherited Properties:
|
|
|
|
- started (Default value false)
|
|
- subscriptions (Default value [])
|
|
|
|
Inherited Static Properties:
|
|
|
|
- Started (Default value false)
|
|
- Subscriptions (Default value [])
|
|
|
|
Inherited Methods:
|
|
|
|
<no inherited methods>
|
|
|
|
Inherited Static Methods:
|
|
|
|
<no inherited static methods>
|
|
|
|
[Belonging to SystemTest]
|
|
|
|
Properties:
|
|
|
|
<no properties>
|
|
|
|
Static Properties:
|
|
|
|
<no static properties>
|
|
|
|
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
|
|
|
|
**/
|
|
|
|
class SystemTest extends System {
|
|
|
|
constructor(options) {
|
|
|
|
if (typeof options === 'undefined') {
|
|
options = {};
|
|
}
|
|
|
|
super(options);
|
|
|
|
this.emit(Event.OBJECT_CREATED, this);
|
|
|
|
Object.assign(this, options);
|
|
|
|
this.emit(Event.OBJECT_INITIALIZED, this);
|
|
|
|
}
|
|
|
|
/**
|
|
* start()
|
|
* - Just calls System.Start(options)
|
|
* @param options
|
|
*/
|
|
start(options) {
|
|
|
|
this.started = true;
|
|
|
|
console.log('Started transient system: SystemTest');
|
|
|
|
}
|
|
|
|
/**
|
|
* stop()
|
|
* - Just calls System.Stop(options)
|
|
* @param options
|
|
*/
|
|
stop(options) {
|
|
|
|
this.started = false;
|
|
|
|
console.log('Stopped transient system: SystemTest');
|
|
|
|
}
|
|
|
|
/**
|
|
* Start()
|
|
* - Starts the system by registering subscriptions to events
|
|
* @param options
|
|
*/
|
|
static Start(options) {
|
|
|
|
SystemTest.Started = true;
|
|
|
|
console.log('Started system: SystemTest');
|
|
|
|
}
|
|
|
|
/**
|
|
* Stop()
|
|
* - Stops the system by removing these subscriptions to events
|
|
* @param options
|
|
*/
|
|
static Stop(options) {
|
|
|
|
SystemTest.Started = false;
|
|
|
|
console.log('Stopped system: SystemTest');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
Class R3.Event.Object
|
|
[Inherited from Event]
|
|
|
|
Inherited Properties:
|
|
|
|
<no inherited properties>
|
|
|
|
Inherited Static Properties:
|
|
|
|
<no inherited static properties>
|
|
|
|
Inherited Methods:
|
|
|
|
- async(eventId, data, clientCallback, clientErrorCallback)
|
|
Simply calls 'Async()' passing it the arguments
|
|
|
|
- emit(eventId, data, clientCallback, clientErrorCallback)
|
|
Simply calls 'Emit()' passing it the arguments
|
|
|
|
- subscribe(eventId, callback)
|
|
Simply calls 'Subscribe()' passing it the arguments
|
|
|
|
Inherited Static Methods:
|
|
|
|
- Async(eventId, data, clientCallback, clientErrorCallback)
|
|
Calls all subscription functions registered to eventId with data, clientCallback and clientErrorCallback as
|
|
arguments. If an error occurs during clientCallback it additionally will execute clientErrorCallback with the
|
|
error as argument.
|
|
|
|
- Emit(eventId, data, clientCallback, clientErrorCallback)
|
|
Calls all subscription functions registered to eventId with data as arg. Calls clientCallback directly after
|
|
the event result is obtained, passing it the result. If an exception occurs during execution, the
|
|
clientErrorCallback is called with the error as argument.
|
|
|
|
- Subscribe(eventId, callback)
|
|
Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised
|
|
|
|
[Belonging to R3Object]
|
|
|
|
Properties:
|
|
|
|
- register (Default value true)
|
|
|
|
Static Properties:
|
|
|
|
<no static properties>
|
|
|
|
Methods:
|
|
|
|
<no methods>
|
|
|
|
Static Methods:
|
|
|
|
<no static methods>
|
|
|
|
Of the form x=<value>
|
|
|
|
Of the form x=<instance.property>
|
|
|
|
**/
|
|
|
|
class R3Object extends Event {
|
|
|
|
constructor(options) {
|
|
|
|
if (typeof options === 'undefined') {
|
|
options = {};
|
|
}
|
|
|
|
super(options);
|
|
|
|
this.emit(Event.OBJECT_CREATED, this);
|
|
|
|
if (typeof options.register === 'undefined') {
|
|
options.register = true;
|
|
}
|
|
|
|
Object.assign(this, options);
|
|
|
|
this.emit(Event.OBJECT_INITIALIZED, this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
Class R3.Event.Runtime
|
|
[Inherited from Event]
|
|
|
|
Inherited Properties:
|
|
|
|
<no inherited properties>
|
|
|
|
Inherited Static Properties:
|
|
|
|
<no inherited static properties>
|
|
|
|
Inherited Methods:
|
|
|
|
- async(eventId, data, clientCallback, clientErrorCallback)
|
|
Simply calls 'Async()' passing it the arguments
|
|
|
|
- emit(eventId, data, clientCallback, clientErrorCallback)
|
|
Simply calls 'Emit()' passing it the arguments
|
|
|
|
- subscribe(eventId, callback)
|
|
Simply calls 'Subscribe()' passing it the arguments
|
|
|
|
Inherited Static Methods:
|
|
|
|
- Async(eventId, data, clientCallback, clientErrorCallback)
|
|
Calls all subscription functions registered to eventId with data, clientCallback and clientErrorCallback as
|
|
arguments. If an error occurs during clientCallback it additionally will execute clientErrorCallback with the
|
|
error as argument.
|
|
|
|
- Emit(eventId, data, clientCallback, clientErrorCallback)
|
|
Calls all subscription functions registered to eventId with data as arg. Calls clientCallback directly after
|
|
the event result is obtained, passing it the result. If an exception occurs during execution, the
|
|
clientErrorCallback is called with the error as argument.
|
|
|
|
- Subscribe(eventId, callback)
|
|
Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised
|
|
|
|
[Belonging to Runtime]
|
|
|
|
Properties:
|
|
|
|
<no properties>
|
|
|
|
Static Properties:
|
|
|
|
<no static properties>
|
|
|
|
Methods:
|
|
|
|
<no methods>
|
|
|
|
Static Methods:
|
|
|
|
<no static methods>
|
|
|
|
Of the form x=<value>
|
|
|
|
Of the form x=<instance.property>
|
|
|
|
**/
|
|
|
|
class Runtime extends Event {
|
|
|
|
constructor(options) {
|
|
|
|
if (typeof options === 'undefined') {
|
|
options = {};
|
|
}
|
|
|
|
super(options);
|
|
|
|
this.emit(Event.OBJECT_CREATED, this);
|
|
|
|
Object.assign(this, options);
|
|
|
|
this.emit(Event.OBJECT_INITIALIZED, this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Runtime.DEFAULT = 0x1;
|
|
Runtime.GRAPHICS = 0x2;
|
|
|
|
/**
|
|
|
|
Class R3.Event.Object.Component
|
|
[Inherited from Event]
|
|
|
|
Inherited Properties:
|
|
|
|
<no inherited properties>
|
|
|
|
Inherited Static Properties:
|
|
|
|
<no inherited static properties>
|
|
|
|
Inherited Methods:
|
|
|
|
- async(eventId, data, clientCallback, clientErrorCallback)
|
|
Simply calls 'Async()' passing it the arguments
|
|
|
|
- emit(eventId, data, clientCallback, clientErrorCallback)
|
|
Simply calls 'Emit()' passing it the arguments
|
|
|
|
- subscribe(eventId, callback)
|
|
Simply calls 'Subscribe()' passing it the arguments
|
|
|
|
Inherited Static Methods:
|
|
|
|
- Async(eventId, data, clientCallback, clientErrorCallback)
|
|
Calls all subscription functions registered to eventId with data, clientCallback and clientErrorCallback as
|
|
arguments. If an error occurs during clientCallback it additionally will execute clientErrorCallback with the
|
|
error as argument.
|
|
|
|
- Emit(eventId, data, clientCallback, clientErrorCallback)
|
|
Calls all subscription functions registered to eventId with data as arg. Calls clientCallback directly after
|
|
the event result is obtained, passing it the result. If an exception occurs during execution, the
|
|
clientErrorCallback is called with the error as argument.
|
|
|
|
- Subscribe(eventId, callback)
|
|
Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised
|
|
|
|
[Inherited from R3Object]
|
|
|
|
Inherited Properties:
|
|
|
|
- register (Default value true)
|
|
|
|
Inherited Static Properties:
|
|
|
|
<no inherited static properties>
|
|
|
|
Inherited Methods:
|
|
|
|
<no inherited methods>
|
|
|
|
Inherited Static Methods:
|
|
|
|
<no inherited static methods>
|
|
|
|
[Belonging to Component]
|
|
|
|
Properties:
|
|
|
|
- runtime (Default value R3.Runtime.DEFAULT)
|
|
|
|
Static Properties:
|
|
|
|
<no static properties>
|
|
|
|
Methods:
|
|
|
|
- createInstance()
|
|
No comment
|
|
|
|
- dispose()
|
|
No comment
|
|
|
|
- disposeInstance()
|
|
No comment
|
|
|
|
- getRuntime()
|
|
No comment
|
|
|
|
Static Methods:
|
|
|
|
<no static methods>
|
|
|
|
Of the form x=<value>
|
|
|
|
Of the form x=<instance.property>
|
|
|
|
**/
|
|
|
|
class Component extends R3Object {
|
|
|
|
constructor(options) {
|
|
|
|
if (typeof options === 'undefined') {
|
|
options = {};
|
|
}
|
|
|
|
super(options);
|
|
|
|
this.emit(Event.OBJECT_CREATED, this);
|
|
|
|
if (typeof options.runtime === 'undefined') {
|
|
options.runtime = R3.Runtime.DEFAULT;
|
|
}
|
|
|
|
Object.assign(this, options);
|
|
|
|
this.emit(Event.OBJECT_INITIALIZED, this);
|
|
|
|
this.emit(Event.COMPONENT_CREATED, this);
|
|
}
|
|
|
|
/**
|
|
* createInstance()
|
|
* - No comment
|
|
*/
|
|
createInstance() {
|
|
|
|
this.emit(Event.CREATE_INSTANCE_BEFORE, this);
|
|
|
|
this.getRuntime().createInstance(
|
|
this,
|
|
{
|
|
'runtime': this.runtime
|
|
}
|
|
)
|
|
this.emit(Event.INSTANCE_CREATED, this);
|
|
|
|
}
|
|
|
|
/**
|
|
* dispose()
|
|
* - No comment
|
|
*/
|
|
dispose() {
|
|
|
|
this.subscribe(
|
|
Event.INSTANCE_DISPOSED,
|
|
function(object) {
|
|
if (object === this) {
|
|
this.emit(Event.DISPOSE_OBJECT, this);
|
|
}
|
|
}
|
|
);
|
|
|
|
this.disposeInstance();
|
|
|
|
}
|
|
|
|
/**
|
|
* disposeInstance()
|
|
* - No comment
|
|
*/
|
|
disposeInstance() {
|
|
|
|
console.log('Disposing instance of ' + this.name);
|
|
this.emit(Event.DISPOSE_INSTANCE, this);
|
|
|
|
}
|
|
|
|
/**
|
|
* getRuntime()
|
|
* - No comment
|
|
*/
|
|
getRuntime() {
|
|
|
|
if (this.runtime === R3.Runtime.DEFAULT) {
|
|
//TODO: implement runtime base
|
|
return null;
|
|
}
|
|
|
|
//TODO: implement runtime classes
|
|
return null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
Class R3.Event.Object.Project
|
|
[Inherited from Event]
|
|
|
|
Inherited Properties:
|
|
|
|
<no inherited properties>
|
|
|
|
Inherited Static Properties:
|
|
|
|
<no inherited static properties>
|
|
|
|
Inherited Methods:
|
|
|
|
- async(eventId, data, clientCallback, clientErrorCallback)
|
|
Simply calls 'Async()' passing it the arguments
|
|
|
|
- emit(eventId, data, clientCallback, clientErrorCallback)
|
|
Simply calls 'Emit()' passing it the arguments
|
|
|
|
- subscribe(eventId, callback)
|
|
Simply calls 'Subscribe()' passing it the arguments
|
|
|
|
Inherited Static Methods:
|
|
|
|
- Async(eventId, data, clientCallback, clientErrorCallback)
|
|
Calls all subscription functions registered to eventId with data, clientCallback and clientErrorCallback as
|
|
arguments. If an error occurs during clientCallback it additionally will execute clientErrorCallback with the
|
|
error as argument.
|
|
|
|
- Emit(eventId, data, clientCallback, clientErrorCallback)
|
|
Calls all subscription functions registered to eventId with data as arg. Calls clientCallback directly after
|
|
the event result is obtained, passing it the result. If an exception occurs during execution, the
|
|
clientErrorCallback is called with the error as argument.
|
|
|
|
- Subscribe(eventId, callback)
|
|
Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised
|
|
|
|
[Inherited from R3Object]
|
|
|
|
Inherited Properties:
|
|
|
|
- register (Default value true)
|
|
|
|
Inherited Static Properties:
|
|
|
|
<no inherited static properties>
|
|
|
|
Inherited Methods:
|
|
|
|
<no inherited methods>
|
|
|
|
Inherited Static Methods:
|
|
|
|
<no inherited static methods>
|
|
|
|
[Belonging to Project]
|
|
|
|
Properties:
|
|
|
|
<no properties>
|
|
|
|
Static Properties:
|
|
|
|
<no static properties>
|
|
|
|
Methods:
|
|
|
|
<no methods>
|
|
|
|
Static Methods:
|
|
|
|
<no static methods>
|
|
|
|
Of the form x=<value>
|
|
|
|
Of the form x=<instance.property>
|
|
|
|
**/
|
|
|
|
class Project extends R3Object {
|
|
|
|
constructor(options) {
|
|
|
|
if (typeof options === 'undefined') {
|
|
options = {};
|
|
}
|
|
|
|
super(options);
|
|
|
|
this.emit(Event.OBJECT_CREATED, this);
|
|
|
|
Object.assign(this, options);
|
|
|
|
this.emit(Event.OBJECT_INITIALIZED, this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
Class R3.Event.Object.Component.Image
|
|
[Inherited from Event]
|
|
|
|
Inherited Properties:
|
|
|
|
<no inherited properties>
|
|
|
|
Inherited Static Properties:
|
|
|
|
<no inherited static properties>
|
|
|
|
Inherited Methods:
|
|
|
|
- async(eventId, data, clientCallback, clientErrorCallback)
|
|
Simply calls 'Async()' passing it the arguments
|
|
|
|
- emit(eventId, data, clientCallback, clientErrorCallback)
|
|
Simply calls 'Emit()' passing it the arguments
|
|
|
|
- subscribe(eventId, callback)
|
|
Simply calls 'Subscribe()' passing it the arguments
|
|
|
|
Inherited Static Methods:
|
|
|
|
- Async(eventId, data, clientCallback, clientErrorCallback)
|
|
Calls all subscription functions registered to eventId with data, clientCallback and clientErrorCallback as
|
|
arguments. If an error occurs during clientCallback it additionally will execute clientErrorCallback with the
|
|
error as argument.
|
|
|
|
- Emit(eventId, data, clientCallback, clientErrorCallback)
|
|
Calls all subscription functions registered to eventId with data as arg. Calls clientCallback directly after
|
|
the event result is obtained, passing it the result. If an exception occurs during execution, the
|
|
clientErrorCallback is called with the error as argument.
|
|
|
|
- Subscribe(eventId, callback)
|
|
Subscribes to 'eventName', ex. Event.BEFORE_RENDER and executes 'callback()' when eventName is raised
|
|
|
|
[Inherited from R3Object]
|
|
|
|
Inherited Properties:
|
|
|
|
- register (Default value true)
|
|
|
|
Inherited Static Properties:
|
|
|
|
<no inherited static properties>
|
|
|
|
Inherited Methods:
|
|
|
|
<no inherited methods>
|
|
|
|
Inherited Static Methods:
|
|
|
|
<no inherited static methods>
|
|
|
|
[Inherited from Component]
|
|
|
|
Inherited Properties:
|
|
|
|
- runtime (Default value R3.Runtime.DEFAULT)
|
|
|
|
Inherited Static Properties:
|
|
|
|
<no inherited static properties>
|
|
|
|
Inherited Methods:
|
|
|
|
- createInstance()
|
|
No comment
|
|
|
|
- dispose()
|
|
No comment
|
|
|
|
- disposeInstance()
|
|
No comment
|
|
|
|
- getRuntime()
|
|
No comment
|
|
|
|
Inherited Static Methods:
|
|
|
|
<no inherited static methods>
|
|
|
|
[Belonging to Image]
|
|
|
|
Properties:
|
|
|
|
<no properties>
|
|
|
|
Static Properties:
|
|
|
|
<no static properties>
|
|
|
|
Methods:
|
|
|
|
<no methods>
|
|
|
|
Static Methods:
|
|
|
|
<no static methods>
|
|
|
|
Of the form x=<value>
|
|
|
|
Of the form x=<instance.property>
|
|
|
|
**/
|
|
|
|
class Image extends Component {
|
|
|
|
constructor(options) {
|
|
|
|
if (typeof options === 'undefined') {
|
|
options = {};
|
|
}
|
|
|
|
super(options);
|
|
|
|
this.emit(Event.OBJECT_CREATED, this);
|
|
|
|
Object.assign(this, options);
|
|
|
|
this.emit(Event.OBJECT_INITIALIZED, this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
R3.Object = R3Object;
|
|
R3.Component = Component;
|
|
R3.System = System;
|
|
R3.Event = Event;
|
|
R3.Utils = Utils;
|
|
R3.System.Input = SystemInput;
|
|
R3.System.Linking = SystemLinking;
|
|
R3.System.Socket = SystemSocket;
|
|
R3.System.Test = SystemTest;
|
|
R3.Event.Object = R3Object;
|
|
R3.Event.Runtime = Runtime;
|
|
R3.Event.Object.Component = Component;
|
|
R3.Event.Object.Project = Project;
|
|
R3.Event.Object.Component.Image = Image;
|
|
R3.Runtime = Runtime;
|
|
|
|
console.log('r3.js - version ' + R3.version + ' compiled ' + R3.compileDate);
|
|
|
|
R3.System.Input.Start();
|
|
R3.System.Linking.Start();
|
|
R3.System.Socket.Start();
|
|
R3.System.Test.Start();
|
|
|