import {Vector2} from "./math/Vector2.js";
import {Matrix} from "./math/Matrix.js";
import {UUID} from "./math/UUID.js";
/**
* Base object class, implements all the object positioning and scaling features.
*
* Stores all the base properties shared between all objects as the position, transformation properties, children etc.
*
* Object2D object can be used as a group to the other objects drawn.
*
* @class
*/
function Object2D()
{
/**
* UUID of the object.
*
* @type {string}
*/
this.uuid = UUID.generate();
/**
* List of children objects attached to the object.
*
* @type {Object2D[]}
*/
this.children = [];
/**
* Parent object, the object position is affected by its parent position.
*
* @type {Object2D}
*/
this.parent = null;
/**
* Depth level in the object tree, objects with higher depth are drawn on top.
*
* The layer value is considered first.
*
* @type {number}
*/
this.level = 0;
/**
* Position of the object.
*
* The world position of the object is affected by its parent transform.
*
* @type {Vector2}
*/
this.position = new Vector2(0, 0);
/**
* Origin of the object used as point of rotation.
*
* @type {Vector2}
*/
this.origin = new Vector2(0, 0);
/**
* Scale of the object.
*
* The world scale of the object is affected by the parent transform.
*
* @type {Vector2}
*/
this.scale = new Vector2(1, 1);
/**
* Rotation of the object relative to its center.
*
* The world rotation of the object is affected by the parent transform.
*
* @type {number}
*/
this.rotation = 0.0;
/**
* Indicates if the object is visible.
*
* @type {boolean}
*/
this.visible = true;
/**
* Layer of this object, objects are sorted by layer value.
*
* Lower layer value is draw first, higher layer value is drawn on top.
*
* @type {number}
*/
this.layer = 0;
/**
* Local transformation matrix applied to the object.
*
* @type {Matrix}
*/
this.matrix = new Matrix();
/**
* Global transformation matrix multiplied by the parent matrix.
*
* Used to transform the object before projecting into screen coordinates.
*
* @type {Matrix}
*/
this.globalMatrix = new Matrix();
/**
* Inverse of the global (world) transform matrix.
*
* Used to convert pointer input points (viewport space) into object coordinates.
*
* @type {Matrix}
*/
this.inverseGlobalMatrix = new Matrix();
/**
* Mask objects being applied to this object. Used to mask/subtract portions of this object when rendering.
*
* Multiple masks can be used simultaneously. Same mask might be reused for multiple objects.
*
* @type {Mask[]}
*/
this.masks = [];
/**
* Indicates if the transform matrix should be automatically updated every frame.
*
* Set this false for better performance. But if you do so dont forget to set matrixNeedsUpdate every time that a transform attribute is changed.
*
* @type {boolean}
*/
this.matrixAutoUpdate = true;
/**
* Indicates if the matrix needs to be updated, should be set true after changes to the object position, scale or rotation.
*
* The matrix is updated before rendering the object, after the matrix is updated this attribute is automatically reset to false.
*
* @type {boolean}
*/
this.matrixNeedsUpdate = true;
/**
* Draggable controls if its possible to drag the object around. Set this true to enable dragging events on this object.
*
* The onPointerDrag callback is used to update the state of the object while being dragged, by default it just updates the object position.
*
* @type {boolean}
*/
this.draggable = false;
/**
* Indicates if this object uses pointer events.
*
* Can be set false to skip the pointer interaction events, better performance if pointer events are not required.
*
* @type {boolean}
*/
this.pointerEvents = true;
/**
* Flag to indicate whether this object ignores the viewport transformation.
*
* @type {boolean}
*/
this.ignoreViewport = false;
/**
* Flag to indicate if the context of canvas should be saved before render.
*
* @type {boolean}
*/
this.saveContextState = true;
/**
* Flag to indicate if the context of canvas should be restored after render.
*
* @type {boolean}
*/
this.restoreContextState = true;
/**
* Flag indicating if the pointer is inside of the element.
*
* Used to control object event.
*
* @type {boolean}
*/
this.pointerInside = false;
/**
* Flag to indicate if the object is currently being dragged.
*
* @type {boolean}
*/
this.beingDragged = false;
/**
* Indicates if the object should be serialized or not as a child of another object.
*
* Used to prevent duplicate serialization data on custom objects. Should be set false for objects added on constructor.
*
* @type {boolean}
*/
this.serializable = true;
}
Object2D.prototype.constructor = Object2D;
/**
* Type of the object, used for data serialization and/or checking the object type.
*
* The name used should match the object constructor name. But it is not required.
*
* If this type is from an external library you can add the library name to the object type name to prevent collisions.
*
* @type {string}
*/
Object2D.prototype.type = "Object2D";
/**
* List of available object types known by the application. Stores the object constructor by object type.
*
* Newly created types should be introduced in this map for data serialization support.
*
* New object types should be added using the Object2D.register() method.
*
* @static
* @type {Map<string, Function>}
*/
Object2D.types = new Map([[Object2D.prototype.type, Object2D]]);
/**
* Register a object type into the application. Associates the type string to the object constructor.
*
* Should be called for every new object class implemented if you want to be able to serialize and parse data.
*
* @static
* @param {Function} constructor Object constructor.
* @param {string} type Object type name.
*/
Object2D.register = function(constructor, type)
{
Object2D.types.set(type, constructor);
};
/**
* Check if a point in world coordinates intersects this object or its children and get a list of the objects intersected.
*
* @param {Vector2} point Point in world coordinates.
* @param {Object2D[]} list List of objects intersected passed to children objects recursively.
* @return {Object2D[]} List of object intersected by this point.
*/
Object2D.prototype.getWorldPointIntersections = function(point, list)
{
if(list === undefined)
{
list = [];
}
// Calculate the pointer position in the object coordinates
var localPoint = this.inverseGlobalMatrix.transformPoint(point);
if(this.isInside(localPoint))
{
list.push(this);
}
// Iterate trough the children
for(var i = 0; i < this.children.length; i++)
{
this.children[i].getWorldPointIntersections(point, list);
}
return list;
};
/**
* Check if a point in world coordinates intersects this object or some of its children.
*
* @param {Vector2} point Point in world coordinates.
* @param {boolean} recursive If set to true it will also check intersections with the object children.
* @return {boolean} Returns true if the point in inside of the object.
*/
Object2D.prototype.isWorldPointInside = function(point, recursive)
{
// Calculate the pointer position in the object coordinates
var localPoint = this.inverseGlobalMatrix.transformPoint(point);
if(this.isInside(localPoint))
{
return true;
}
// Iterate trough the children
if(recursive)
{
for(var i = 0; i < this.children.length; i++)
{
if(this.children[i].isWorldPointInside(point, true))
{
return true;
}
}
}
return false;
};
/**
* Destroy the object, removes it from the parent object.
*/
Object2D.prototype.destroy = function()
{
if(this.parent !== null)
{
this.parent.remove(this);
}
};
/**
* Traverse the object tree and run a function for all objects.
*
* @param {Function} callback Callback function that receives the object as parameter.
*/
Object2D.prototype.traverse = function(callback)
{
callback(this);
for(var i = 0; i < this.children.length; i++)
{
this.children[i].traverse(callback);
}
};
/**
* Get a object from its children list by its UUID.
*
* @param {string} uuid UUID of the object to get.
* @return {Object2D} The object that has the UUID specified, null if the object was not found.
*/
Object2D.prototype.getChildByUUID = function(uuid)
{
var object = null;
this.traverse(function(child)
{
if(child.uuid === uuid)
{
object = child;
}
});
return object;
};
/**
* Attach a children to this object.
*
* The object is set as children of this object and the transformations applied to this object are traversed to its children.
*
* @param {Object2D} object Object to attach to this object.
*/
Object2D.prototype.add = function(object)
{
object.parent = this;
object.level = this.level + 1;
object.traverse(function(child)
{
if(child.onAdd !== null)
{
child.onAdd(this);
}
});
this.children.push(object);
};
/**
* Remove object from the children list.
*
* Resets the parent of the object to null and resets its level.
*
* @param {Object2D} children Object to be removed.
*/
Object2D.prototype.remove = function(children)
{
var index = this.children.indexOf(children);
if(index !== -1)
{
var object = this.children[index];
object.parent = null;
object.level = 0;
object.traverse(function(child)
{
if(child.onRemove !== null)
{
child.onRemove(this);
}
});
this.children.splice(index, 1)
}
};
/**
* Check if a point is inside of the object. Used by the renderer check for pointer collision (required for the object to properly process pointer events).
*
* Point should be in local object coordinates.
*
* To check if a point in world coordinates intersects the object the inverseGlobalMatrix should be applied to that point before calling this method.
*
* @param {Vector2} point Point in local object coordinates.
* @return {boolean} True if the point is inside of the object.
*/
Object2D.prototype.isInside = function(point)
{
return false;
};
/**
* Update the transformation matrix of the object.
*
* @param {CanvasRenderingContext2D} context Canvas 2d drawing context.
*/
Object2D.prototype.updateMatrix = function(context)
{
if(this.matrixAutoUpdate || this.matrixNeedsUpdate)
{
this.matrix.compose(this.position.x, this.position.y, this.scale.x, this.scale.y, this.origin.x, this.origin.y, this.rotation);
this.globalMatrix.copy(this.matrix);
if(this.parent !== null)
{
this.globalMatrix.premultiply(this.parent.globalMatrix);
}
this.inverseGlobalMatrix = this.globalMatrix.getInverse()
this.matrixNeedsUpdate = false;
}
};
/**
* Apply the transform to the rendering context, it is assumed that the viewport transform is pre-applied to the context.
*
* This is called before style() and draw(). It can also be used for some pre-rendering logic.
*
* @param {CanvasRenderingContext2D} context Canvas 2d drawing context.
* @param {Viewport} viewport Viewport applied to the canvas.
* @param {Element} canvas DOM canvas element where the content is being drawn.
* @param {Renderer} renderer Renderer object being used to draw the object into the canvas.
*/
Object2D.prototype.transform = function(context, viewport, canvas, renderer)
{
this.globalMatrix.tranformContext(context);
};
/**
* Style is called right before draw() it should not draw any content into the canvas, all context styling should be applied here (colors, fonts, etc).
*
* The draw() and style() methods can be useful for objects that share the same styling attributes but are drawing differently.
*
* Should be implemented by underlying classes.
*
* @param {CanvasRenderingContext2D} context Canvas 2d drawing context.
* @param {Viewport} viewport Viewport used to view the canvas content.
* @param {Element} canvas DOM canvas element where the content is being drawn.
*/
Object2D.prototype.style = null; // function(context, viewport, canvas){};
/**
* Draw the object into the canvas, this is called transform() and style(), should be where the content is actually drawn into the canvas.
*
* Should be implemented by underlying classes.
*
* @param {CanvasRenderingContext2D} context Canvas 2d drawing context.
* @param {Viewport} viewport Viewport used to view the canvas content.
* @param {Element} canvas DOM canvas element where the content is being drawn.
*/
Object2D.prototype.draw = null; // function(context, viewport, canvas){};
/**
* Callback method while the object is being dragged across the screen.
*
* By default is adds the delta value to the object position (making it follow the mouse movement).
*
* Delta is the movement of the pointer already translated into local object coordinates.
*
* To detect when the object drag stops the onPointerDragEnd() method can be used.
*
* @param {Pointer} pointer Pointer object that receives the user input.
* @param {Viewport} viewport Viewport where the object is drawn.
* @param {Vector2} delta Pointer movement diff in world space since the last frame.
* @param {Vector2} positionWorld Position of the dragging pointer in world coordinates.
*/
Object2D.prototype.onPointerDrag = function(pointer, viewport, delta, positionWorld)
{
this.position.add(delta);
};
/**
* Callback method called when the pointer drag start after the button was pressed
*
* @param {Pointer} pointer Pointer object that receives the user input.
* @param {Viewport} viewport Viewport where the object is drawn.
*/
Object2D.prototype.onPointerDragStart = null;
/**
* Callback method called when the pointer drag ends after the button has been released.
*
* @param {Pointer} pointer Pointer object that receives the user input.
* @param {Viewport} viewport Viewport where the object is drawn.
*/
Object2D.prototype.onPointerDragEnd = null;
/**
* Method called when the object its added to a parent.
*
* @param {Object2D} parent Parent object were it was added.
*/
Object2D.prototype.onAdd = null;
/**
* Method called when the object gets removed from its parent
*
* @param {Object2D} parent Parent object from were the object is being removed.
*/
Object2D.prototype.onRemove = null;
/**
* Callback method called every time before the object is draw into the canvas.
*
* Should be used to run object logic, any preparation code, move the object, etc.
*
* This method is called for every object before rendering.
*/
Object2D.prototype.onUpdate = null;
/**
* Callback method called when the pointer enters the object.
*
* It is not called while the pointer is inside of the object, just on the first time that the pointer enters the object for that use onPointerOver()
*
* @param {Pointer} pointer Pointer object that receives the user input.
* @param {Viewport} viewport Viewport where the object is drawn.
*/
Object2D.prototype.onPointerEnter = null;
/**
* Method called when the was inside of the object and leaves the object.
*
* @param {Pointer} pointer Pointer object that receives the user input.
* @param {Viewport} viewport Viewport where the object is drawn.
*/
Object2D.prototype.onPointerLeave = null;
/**
* Method while the pointer is over (inside) of the object.
*
* @param {Pointer} pointer Pointer object that receives the user input.
* @param {Viewport} viewport Viewport where the object is drawn.
*/
Object2D.prototype.onPointerOver = null;
/**
* Method called while the pointer button is pressed.
*
* @param {Pointer} pointer Pointer object that receives the user input.
* @param {Viewport} viewport Viewport where the object is drawn.
*/
Object2D.prototype.onButtonPressed = null;
/**
* Method called while the pointer button is double clicked.
*
* @param {Pointer} pointer Pointer object that receives the user input.
* @param {Viewport} viewport Viewport where the object is drawn.
*/
Object2D.prototype.onDoubleClick = null;
/**
* Callback method called when the pointer button is pressed down (single time).
*
* @param {Pointer} pointer Pointer object that receives the user input.
* @param {Viewport} viewport Viewport where the object is drawn.
*/
Object2D.prototype.onButtonDown = null;
/**
* Method called when the pointer button is released (single time).
*
* @param {Pointer} pointer Pointer object that receives the user input.
* @param {Viewport} viewport Viewport where the object is drawn.
*/
Object2D.prototype.onButtonUp = null;
/**
* Serialize the object data into a JSON object. That can be written into a file, sent using HTTP request etc.
*
* All required attributes to recreate the object in its current state should be stored. Relations between children should be stored by their UUID only.
*
* Data has to be parsed back into a usable object.
*
* @param {boolean} recursive If set false the children list is not serialized, otherwise all children are serialized.
* @return {Object} Serialized object data.
*/
Object2D.prototype.serialize = function(recursive)
{
var data = {
uuid: this.uuid,
type: this.type,
position: this.position.toArray(),
origin: this.origin.toArray(),
scale: this.scale.toArray(),
rotation: this.rotation,
visible: this.visible,
layer: this.layer,
matrix: this.matrix.m,
globalMatrix: this.globalMatrix.m,
inverseGlobalMatrix: this.inverseGlobalMatrix.m,
matrixAutoUpdate: this.matrixAutoUpdate,
draggable: this.draggable,
pointerEvents: this.pointerEvents,
ignoreViewport: this.ignoreViewport,
saveContextState: this.saveContextState,
restoreContextState: this.restoreContextState,
children: [],
masks: []
};
if(recursive !== false)
{
for(var i = 0; i < this.children.length; i++)
{
if(this.children[i].serializable)
{
data.children.push(this.children[i].serialize());
}
}
}
for(var i = 0; i < this.masks.length; i++)
{
data.masks.push(this.masks[i].uuid);
}
return data;
};
/**
* Parse serialized object data and fill the object attributes.
*
* Implementations of this method should only load the attributes added to the structure, the based method already loads common attributes.
*
* Dont forget to register object types using the Object2D.register() method.
*
* @param {Object} data Object data loaded from JSON.
* @param {Object2D} root Root object being loaded can be used to get references to other objects.
*/
Object2D.prototype.parse = function(data, root)
{
this.uuid = data.uuid;
this.position.fromArray(data.position);
this.origin.fromArray(data.origin);
this.scale.fromArray(data.scale);
this.rotation = data.rotation;
this.visible = data.visible;
this.layer = data.layer;
this.matrix = new Matrix(data.matrix);
this.globalMatrix = new Matrix(data.globalMatrix);
this.inverseGlobalMatrix = new Matrix(data.inverseGlobalMatrix);
this.matrixAutoUpdate = data.matrixAutoUpdate;
this.draggable = data.draggable;
this.pointerEvents = data.pointerEvents;
this.ignoreViewport = data.ignoreViewport;
this.saveContextState = data.saveContextState;
this.restoreContextState = data.restoreContextState;
for(var i = 0; i < this.masks.length; i++)
{
data.masks.push(root.getChildByUUID(data.masks[i]));
}
};
/**
* Create objects from serialized object data into the proper data structures.
*
* All objects should implement serialization methods to serialize and load data properly.
*
* First all objects instances are created to ensure that object trying to get references to other object can have the data accessible, only then the parse method is called.
*
* @static
* @param {Object} data Object data loaded from JSON.
* @return {Object2D} Parsed object data.
*/
Object2D.parse = function(data)
{
// List of objects created stored as pairs of object, data to be later parsed.
var objects = [];
// Parse all objects from the data object recursively and create the correct instances.
function createObjectInstances(data)
{
if(!Object2D.types.has(data.type))
{
throw new Error("Object type " + data.type + " unknown. Cannot parse data.");
}
var Constructor = Object2D.types.get(data.type);
var object = new Constructor();
object.uuid = data.uuid;
objects.push({object: object, data: data});
for(var i = 0; i < data.children.length; i++)
{
object.add(createObjectInstances(data.children[i]));
}
return object;
}
var root = createObjectInstances(data);
// Parse objects data
for(var i = 0; i < objects.length; i++)
{
objects[i].object.parse(objects[i].data, root);
}
return root;
};
export {Object2D};