/*! * EaselJS * Visit http://createjs.com/ for documentation, updates and examples. * * Copyright (c) 2010 gskinner.com, inc. * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ //############################################################################## // extend.js //############################################################################## this.createjs = this.createjs||{}; /** * @class Utility Methods */ /** * Sets up the prototype chain and constructor property for a new class. * * This should be called right after creating the class constructor. * * function MySubClass() {} * createjs.extend(MySubClass, MySuperClass); * MySubClass.prototype.doSomething = function() { } * * var foo = new MySubClass(); * console.log(foo instanceof MySuperClass); // true * console.log(foo.prototype.constructor === MySubClass); // true * * @method extend * @param {Function} subclass The subclass. * @param {Function} superclass The superclass to extend. * @return {Function} Returns the subclass's new prototype. */ createjs.extend = function(subclass, superclass) { "use strict"; function o() { this.constructor = subclass; } o.prototype = superclass.prototype; return (subclass.prototype = new o()); }; //############################################################################## // promote.js //############################################################################## this.createjs = this.createjs||{}; /** * @class Utility Methods */ /** * Promotes any methods on the super class that were overridden, by creating an alias in the format `prefix_methodName`. * It is recommended to use the super class's name as the prefix. * An alias to the super class's constructor is always added in the format `prefix_constructor`. * This allows the subclass to call super class methods without using `function.call`, providing better performance. * * For example, if `MySubClass` extends `MySuperClass`, and both define a `draw` method, then calling `promote(MySubClass, "MySuperClass")` * would add a `MySuperClass_constructor` method to MySubClass and promote the `draw` method on `MySuperClass` to the * prototype of `MySubClass` as `MySuperClass_draw`. * * This should be called after the class's prototype is fully defined. * * function ClassA(name) { * this.name = name; * } * ClassA.prototype.greet = function() { * return "Hello "+this.name; * } * * function ClassB(name, punctuation) { * this.ClassA_constructor(name); * this.punctuation = punctuation; * } * createjs.extend(ClassB, ClassA); * ClassB.prototype.greet = function() { * return this.ClassA_greet()+this.punctuation; * } * createjs.promote(ClassB, "ClassA"); * * var foo = new ClassB("World", "!?!"); * console.log(foo.greet()); // Hello World!?! * * @method promote * @param {Function} subclass The class to promote super class methods on. * @param {String} prefix The prefix to add to the promoted method names. Usually the name of the superclass. * @return {Function} Returns the subclass. */ createjs.promote = function(subclass, prefix) { "use strict"; var subP = subclass.prototype, supP = (Object.getPrototypeOf&&Object.getPrototypeOf(subP))||subP.__proto__; if (supP) { subP[(prefix+="_") + "constructor"] = supP.constructor; // constructor is not always innumerable for (var n in supP) { if (subP.hasOwnProperty(n) && (typeof supP[n] == "function")) { subP[prefix + n] = supP[n]; } } } return subclass; }; //############################################################################## // indexOf.js //############################################################################## this.createjs = this.createjs||{}; /** * @class Utility Methods */ /** * Finds the first occurrence of a specified value searchElement in the passed in array, and returns the index of * that value. Returns -1 if value is not found. * * var i = createjs.indexOf(myArray, myElementToFind); * * @method indexOf * @param {Array} array Array to search for searchElement * @param searchElement Element to find in array. * @return {Number} The first index of searchElement in array. */ createjs.indexOf = function (array, searchElement){ "use strict"; for (var i = 0,l=array.length; i < l; i++) { if (searchElement === array[i]) { return i; } } return -1; }; //############################################################################## // UID.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * Global utility for generating sequential unique ID numbers. The UID class uses a static interface (ex. UID.get()) * and should not be instantiated. * @class UID * @static **/ function UID() { throw "UID cannot be instantiated"; } // private static properties: /** * @property _nextID * @type Number * @protected **/ UID._nextID = 0; // public static methods: /** * Returns the next unique id. * @method get * @return {Number} The next unique id * @static **/ UID.get = function() { return UID._nextID++; }; createjs.UID = UID; }()); //############################################################################## // deprecate.js //############################################################################## this.createjs = this.createjs||{}; /** * @class Utility Methods */ /** * Wraps deprecated methods so they still be used, but throw warnings to developers. * * obj.deprecatedMethod = createjs.deprecate("Old Method Name", obj._fallbackMethod); * * The recommended approach for deprecated properties is: * * try { * Obj ect.defineProperties(object, { * readyOnlyProp: { get: createjs.deprecate("readOnlyProp", function() { return this.alternateProp; }) }, * readWriteProp: { * get: createjs.deprecate("readOnlyProp", function() { return this.alternateProp; }), * set: createjs.deprecate("readOnlyProp", function(val) { this.alternateProp = val; }) * }); * } catch (e) {} * * @method deprecate * @param {Function} [fallbackMethod=null] A method to call when the deprecated method is used. See the example for how * @param {String} [name=null] The name of the method or property to display in the console warning. * to deprecate properties. * @return {Function} If a fallbackMethod is supplied, returns a closure that will call the fallback method after * logging the warning in the console. */ createjs.deprecate = function(fallbackMethod, name) { "use strict"; return function() { var msg = "Deprecated property or method '"+name+"'. See docs for info."; console && (console.warn ? console.warn(msg) : console.log(msg)); return fallbackMethod && fallbackMethod.apply(this, arguments); } }; //############################################################################## // Event.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * Contains properties and methods shared by all events for use with * {{#crossLink "EventDispatcher"}}{{/crossLink}}. * * Note that Event objects are often reused, so you should never * rely on an event object's state outside of the call stack it was received in. * @class Event * @param {String} type The event type. * @param {Boolean} [bubbles=false] Indicates whether the event will bubble through the display list. * @param {Boolean} [cancelable=false] Indicates whether the default behaviour of this event can be cancelled. * @constructor **/ function Event(type, bubbles, cancelable) { // public properties: /** * The type of event. * @property type * @type String **/ this.type = type; /** * The object that generated an event. * @property target * @type Object * @default null * @readonly */ this.target = null; /** * The current target that a bubbling event is being dispatched from. For non-bubbling events, this will * always be the same as target. For example, if childObj.parent = parentObj, and a bubbling event * is generated from childObj, then a listener on parentObj would receive the event with * target=childObj (the original target) and currentTarget=parentObj (where the listener was added). * @property currentTarget * @type Object * @default null * @readonly */ this.currentTarget = null; /** * For bubbling events, this indicates the current event phase:
    *
  1. capture phase: starting from the top parent to the target
  2. *
  3. at target phase: currently being dispatched from the target
  4. *
  5. bubbling phase: from the target to the top parent
  6. *
* @property eventPhase * @type Number * @default 0 * @readonly */ this.eventPhase = 0; /** * Indicates whether the event will bubble through the display list. * @property bubbles * @type Boolean * @default false * @readonly */ this.bubbles = !!bubbles; /** * Indicates whether the default behaviour of this event can be cancelled via * {{#crossLink "Event/preventDefault"}}{{/crossLink}}. This is set via the Event constructor. * @property cancelable * @type Boolean * @default false * @readonly */ this.cancelable = !!cancelable; /** * The epoch time at which this event was created. * @property timeStamp * @type Number * @default 0 * @readonly */ this.timeStamp = (new Date()).getTime(); /** * Indicates if {{#crossLink "Event/preventDefault"}}{{/crossLink}} has been called * on this event. * @property defaultPrevented * @type Boolean * @default false * @readonly */ this.defaultPrevented = false; /** * Indicates if {{#crossLink "Event/stopPropagation"}}{{/crossLink}} or * {{#crossLink "Event/stopImmediatePropagation"}}{{/crossLink}} has been called on this event. * @property propagationStopped * @type Boolean * @default false * @readonly */ this.propagationStopped = false; /** * Indicates if {{#crossLink "Event/stopImmediatePropagation"}}{{/crossLink}} has been called * on this event. * @property immediatePropagationStopped * @type Boolean * @default false * @readonly */ this.immediatePropagationStopped = false; /** * Indicates if {{#crossLink "Event/remove"}}{{/crossLink}} has been called on this event. * @property removed * @type Boolean * @default false * @readonly */ this.removed = false; } var p = Event.prototype; // public methods: /** * Sets {{#crossLink "Event/defaultPrevented:property"}}{{/crossLink}} to true if the event is cancelable. * Mirrors the DOM level 2 event standard. In general, cancelable events that have `preventDefault()` called will * cancel the default behaviour associated with the event. * @method preventDefault **/ p.preventDefault = function() { this.defaultPrevented = this.cancelable&&true; }; /** * Sets {{#crossLink "Event/propagationStopped:property"}}{{/crossLink}} to true. * Mirrors the DOM event standard. * @method stopPropagation **/ p.stopPropagation = function() { this.propagationStopped = true; }; /** * Sets {{#crossLink "Event/propagationStopped:property"}}{{/crossLink}} and * {{#crossLink "Event/immediatePropagationStopped:property"}}{{/crossLink}} to true. * Mirrors the DOM event standard. * @method stopImmediatePropagation **/ p.stopImmediatePropagation = function() { this.immediatePropagationStopped = this.propagationStopped = true; }; /** * Causes the active listener to be removed via removeEventListener(); * * myBtn.addEventListener("click", function(evt) { * // do stuff... * evt.remove(); // removes this listener. * }); * * @method remove **/ p.remove = function() { this.removed = true; }; /** * Returns a clone of the Event instance. * @method clone * @return {Event} a clone of the Event instance. **/ p.clone = function() { return new Event(this.type, this.bubbles, this.cancelable); }; /** * Provides a chainable shortcut method for setting a number of properties on the instance. * * @method set * @param {Object} props A generic object containing properties to copy to the instance. * @return {Event} Returns the instance the method is called on (useful for chaining calls.) * @chainable */ p.set = function(props) { for (var n in props) { this[n] = props[n]; } return this; }; /** * Returns a string representation of this object. * @method toString * @return {String} a string representation of the instance. **/ p.toString = function() { return "[Event (type="+this.type+")]"; }; createjs.Event = Event; }()); //############################################################################## // EventDispatcher.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * EventDispatcher provides methods for managing queues of event listeners and dispatching events. * * You can either extend EventDispatcher or mix its methods into an existing prototype or instance by using the * EventDispatcher {{#crossLink "EventDispatcher/initialize"}}{{/crossLink}} method. * * Together with the CreateJS Event class, EventDispatcher provides an extended event model that is based on the * DOM Level 2 event model, including addEventListener, removeEventListener, and dispatchEvent. It supports * bubbling / capture, preventDefault, stopPropagation, stopImmediatePropagation, and handleEvent. * * EventDispatcher also exposes a {{#crossLink "EventDispatcher/on"}}{{/crossLink}} method, which makes it easier * to create scoped listeners, listeners that only run once, and listeners with associated arbitrary data. The * {{#crossLink "EventDispatcher/off"}}{{/crossLink}} method is merely an alias to * {{#crossLink "EventDispatcher/removeEventListener"}}{{/crossLink}}. * * Another addition to the DOM Level 2 model is the {{#crossLink "EventDispatcher/removeAllEventListeners"}}{{/crossLink}} * method, which can be used to listeners for all events, or listeners for a specific event. The Event object also * includes a {{#crossLink "Event/remove"}}{{/crossLink}} method which removes the active listener. * *

Example

* Add EventDispatcher capabilities to the "MyClass" class. * * EventDispatcher.initialize(MyClass.prototype); * * Add an event (see {{#crossLink "EventDispatcher/addEventListener"}}{{/crossLink}}). * * instance.addEventListener("eventName", handlerMethod); * function handlerMethod(event) { * console.log(event.target + " Was Clicked"); * } * * Maintaining proper scope
* Scope (ie. "this") can be be a challenge with events. Using the {{#crossLink "EventDispatcher/on"}}{{/crossLink}} * method to subscribe to events simplifies this. * * instance.addEventListener("click", function(event) { * console.log(instance == this); // false, scope is ambiguous. * }); * * instance.on("click", function(event) { * console.log(instance == this); // true, "on" uses dispatcher scope by default. * }); * * If you want to use addEventListener instead, you may want to use function.bind() or a similar proxy to manage * scope. * * Browser support * The event model in CreateJS can be used separately from the suite in any project, however the inheritance model * requires modern browsers (IE9+). * * * @class EventDispatcher * @constructor **/ function EventDispatcher() { // private properties: /** * @protected * @property _listeners * @type Object **/ this._listeners = null; /** * @protected * @property _captureListeners * @type Object **/ this._captureListeners = null; } var p = EventDispatcher.prototype; // static public methods: /** * Static initializer to mix EventDispatcher methods into a target object or prototype. * * EventDispatcher.initialize(MyClass.prototype); // add to the prototype of the class * EventDispatcher.initialize(myObject); // add to a specific instance * * @method initialize * @static * @param {Object} target The target object to inject EventDispatcher methods into. This can be an instance or a * prototype. **/ EventDispatcher.initialize = function(target) { target.addEventListener = p.addEventListener; target.on = p.on; target.removeEventListener = target.off = p.removeEventListener; target.removeAllEventListeners = p.removeAllEventListeners; target.hasEventListener = p.hasEventListener; target.dispatchEvent = p.dispatchEvent; target._dispatchEvent = p._dispatchEvent; target.willTrigger = p.willTrigger; }; // public methods: /** * Adds the specified event listener. Note that adding multiple listeners to the same function will result in * multiple callbacks getting fired. * *

Example

* * displayObject.addEventListener("click", handleClick); * function handleClick(event) { * // Click happened. * } * * @method addEventListener * @param {String} type The string type of the event. * @param {Function | Object} listener An object with a handleEvent method, or a function that will be called when * the event is dispatched. * @param {Boolean} [useCapture] For events that bubble, indicates whether to listen for the event in the capture or bubbling/target phase. * @return {Function | Object} Returns the listener for chaining or assignment. **/ p.addEventListener = function(type, listener, useCapture) { var listeners; if (useCapture) { listeners = this._captureListeners = this._captureListeners||{}; } else { listeners = this._listeners = this._listeners||{}; } var arr = listeners[type]; if (arr) { this.removeEventListener(type, listener, useCapture); } arr = listeners[type]; // remove may have deleted the array if (!arr) { listeners[type] = [listener]; } else { arr.push(listener); } return listener; }; /** * A shortcut method for using addEventListener that makes it easier to specify an execution scope, have a listener * only run once, associate arbitrary data with the listener, and remove the listener. * * This method works by creating an anonymous wrapper function and subscribing it with addEventListener. * The wrapper function is returned for use with `removeEventListener` (or `off`). * * IMPORTANT: To remove a listener added with `on`, you must pass in the returned wrapper function as the listener, or use * {{#crossLink "Event/remove"}}{{/crossLink}}. Likewise, each time you call `on` a NEW wrapper function is subscribed, so multiple calls * to `on` with the same params will create multiple listeners. * *

Example

* * var listener = myBtn.on("click", handleClick, null, false, {count:3}); * function handleClick(evt, data) { * data.count -= 1; * console.log(this == myBtn); // true - scope defaults to the dispatcher * if (data.count == 0) { * alert("clicked 3 times!"); * myBtn.off("click", listener); * // alternately: evt.remove(); * } * } * * @method on * @param {String} type The string type of the event. * @param {Function | Object} listener An object with a handleEvent method, or a function that will be called when * the event is dispatched. * @param {Object} [scope] The scope to execute the listener in. Defaults to the dispatcher/currentTarget for function listeners, and to the listener itself for object listeners (ie. using handleEvent). * @param {Boolean} [once=false] If true, the listener will remove itself after the first time it is triggered. * @param {*} [data] Arbitrary data that will be included as the second parameter when the listener is called. * @param {Boolean} [useCapture=false] For events that bubble, indicates whether to listen for the event in the capture or bubbling/target phase. * @return {Function} Returns the anonymous function that was created and assigned as the listener. This is needed to remove the listener later using .removeEventListener. **/ p.on = function(type, listener, scope, once, data, useCapture) { if (listener.handleEvent) { scope = scope||listener; listener = listener.handleEvent; } scope = scope||this; return this.addEventListener(type, function(evt) { listener.call(scope, evt, data); once&&evt.remove(); }, useCapture); }; /** * Removes the specified event listener. * * Important Note: that you must pass the exact function reference used when the event was added. If a proxy * function, or function closure is used as the callback, the proxy/closure reference must be used - a new proxy or * closure will not work. * *

Example

* * displayObject.removeEventListener("click", handleClick); * * @method removeEventListener * @param {String} type The string type of the event. * @param {Function | Object} listener The listener function or object. * @param {Boolean} [useCapture] For events that bubble, indicates whether to listen for the event in the capture or bubbling/target phase. **/ p.removeEventListener = function(type, listener, useCapture) { var listeners = useCapture ? this._captureListeners : this._listeners; if (!listeners) { return; } var arr = listeners[type]; if (!arr) { return; } for (var i=0,l=arr.length; iIMPORTANT: To remove a listener added with `on`, you must pass in the returned wrapper function as the listener. See * {{#crossLink "EventDispatcher/on"}}{{/crossLink}} for an example. * * @method off * @param {String} type The string type of the event. * @param {Function | Object} listener The listener function or object. * @param {Boolean} [useCapture] For events that bubble, indicates whether to listen for the event in the capture or bubbling/target phase. **/ p.off = p.removeEventListener; /** * Removes all listeners for the specified type, or all listeners of all types. * *

Example

* * // Remove all listeners * displayObject.removeAllEventListeners(); * * // Remove all click listeners * displayObject.removeAllEventListeners("click"); * * @method removeAllEventListeners * @param {String} [type] The string type of the event. If omitted, all listeners for all types will be removed. **/ p.removeAllEventListeners = function(type) { if (!type) { this._listeners = this._captureListeners = null; } else { if (this._listeners) { delete(this._listeners[type]); } if (this._captureListeners) { delete(this._captureListeners[type]); } } }; /** * Dispatches the specified event to all listeners. * *

Example

* * // Use a string event * this.dispatchEvent("complete"); * * // Use an Event instance * var event = new createjs.Event("progress"); * this.dispatchEvent(event); * * @method dispatchEvent * @param {Object | String | Event} eventObj An object with a "type" property, or a string type. * While a generic object will work, it is recommended to use a CreateJS Event instance. If a string is used, * dispatchEvent will construct an Event instance if necessary with the specified type. This latter approach can * be used to avoid event object instantiation for non-bubbling events that may not have any listeners. * @param {Boolean} [bubbles] Specifies the `bubbles` value when a string was passed to eventObj. * @param {Boolean} [cancelable] Specifies the `cancelable` value when a string was passed to eventObj. * @return {Boolean} Returns false if `preventDefault()` was called on a cancelable event, true otherwise. **/ p.dispatchEvent = function(eventObj, bubbles, cancelable) { if (typeof eventObj == "string") { // skip everything if there's no listeners and it doesn't bubble: var listeners = this._listeners; if (!bubbles && (!listeners || !listeners[eventObj])) { return true; } eventObj = new createjs.Event(eventObj, bubbles, cancelable); } else if (eventObj.target && eventObj.clone) { // redispatching an active event object, so clone it: eventObj = eventObj.clone(); } // TODO: it would be nice to eliminate this. Maybe in favour of evtObj instanceof Event? Or !!evtObj.createEvent try { eventObj.target = this; } catch (e) {} // try/catch allows redispatching of native events if (!eventObj.bubbles || !this.parent) { this._dispatchEvent(eventObj, 2); } else { var top=this, list=[top]; while (top.parent) { list.push(top = top.parent); } var i, l=list.length; // capture & atTarget for (i=l-1; i>=0 && !eventObj.propagationStopped; i--) { list[i]._dispatchEvent(eventObj, 1+(i==0)); } // bubbling for (i=1; iExample * * createjs.Ticker.addEventListener("tick", handleTick); * function handleTick(event) { * // Actions carried out each tick (aka frame) * if (!event.paused) { * // Actions carried out when the Ticker is not paused. * } * } * * @class Ticker * @uses EventDispatcher * @static **/ function Ticker() { throw "Ticker cannot be instantiated."; } // constants: /** * In this mode, Ticker uses the requestAnimationFrame API, but attempts to synch the ticks to target framerate. It * uses a simple heuristic that compares the time of the RAF return to the target time for the current frame and * dispatches the tick when the time is within a certain threshold. * * This mode has a higher variance for time between frames than {{#crossLink "Ticker/TIMEOUT:property"}}{{/crossLink}}, * but does not require that content be time based as with {{#crossLink "Ticker/RAF:property"}}{{/crossLink}} while * gaining the benefits of that API (screen synch, background throttling). * * Variance is usually lowest for framerates that are a divisor of the RAF frequency. This is usually 60, so * framerates of 10, 12, 15, 20, and 30 work well. * * Falls back to {{#crossLink "Ticker/TIMEOUT:property"}}{{/crossLink}} if the requestAnimationFrame API is not * supported. * @property RAF_SYNCHED * @static * @type {String} * @default "synched" * @readonly **/ Ticker.RAF_SYNCHED = "synched"; /** * In this mode, Ticker passes through the requestAnimationFrame heartbeat, ignoring the target framerate completely. * Because requestAnimationFrame frequency is not deterministic, any content using this mode should be time based. * You can leverage {{#crossLink "Ticker/getTime"}}{{/crossLink}} and the {{#crossLink "Ticker/tick:event"}}{{/crossLink}} * event object's "delta" properties to make this easier. * * Falls back on {{#crossLink "Ticker/TIMEOUT:property"}}{{/crossLink}} if the requestAnimationFrame API is not * supported. * @property RAF * @static * @type {String} * @default "raf" * @readonly **/ Ticker.RAF = "raf"; /** * In this mode, Ticker uses the setTimeout API. This provides predictable, adaptive frame timing, but does not * provide the benefits of requestAnimationFrame (screen synch, background throttling). * @property TIMEOUT * @static * @type {String} * @default "timeout" * @readonly **/ Ticker.TIMEOUT = "timeout"; // static events: /** * Dispatched each tick. The event will be dispatched to each listener even when the Ticker has been paused using * {{#crossLink "Ticker/paused:property"}}{{/crossLink}}. * *

Example

* * createjs.Ticker.addEventListener("tick", handleTick); * function handleTick(event) { * console.log("Paused:", event.paused, event.delta); * } * * @event tick * @param {Object} target The object that dispatched the event. * @param {String} type The event type. * @param {Boolean} paused Indicates whether the ticker is currently paused. * @param {Number} delta The time elapsed in ms since the last tick. * @param {Number} time The total time in ms since Ticker was initialized. * @param {Number} runTime The total time in ms that Ticker was not paused since it was initialized. For example, * you could determine the amount of time that the Ticker has been paused since initialization with `time-runTime`. * @since 0.6.0 */ // public static properties: /** * Specifies the timing api (setTimeout or requestAnimationFrame) and mode to use. See * {{#crossLink "Ticker/TIMEOUT:property"}}{{/crossLink}}, {{#crossLink "Ticker/RAF:property"}}{{/crossLink}}, and * {{#crossLink "Ticker/RAF_SYNCHED:property"}}{{/crossLink}} for mode details. * @property timingMode * @static * @type {String} * @default Ticker.TIMEOUT **/ Ticker.timingMode = null; /** * Specifies a maximum value for the delta property in the tick event object. This is useful when building time * based animations and systems to prevent issues caused by large time gaps caused by background tabs, system sleep, * alert dialogs, or other blocking routines. Double the expected frame duration is often an effective value * (ex. maxDelta=50 when running at 40fps). * * This does not impact any other values (ex. time, runTime, etc), so you may experience issues if you enable maxDelta * when using both delta and other values. * * If 0, there is no maximum. * @property maxDelta * @static * @type {number} * @default 0 */ Ticker.maxDelta = 0; /** * When the ticker is paused, all listeners will still receive a tick event, but the paused property * of the event will be `true`. Also, while paused the `runTime` will not increase. See {{#crossLink "Ticker/tick:event"}}{{/crossLink}}, * {{#crossLink "Ticker/getTime"}}{{/crossLink}}, and {{#crossLink "Ticker/getEventTime"}}{{/crossLink}} for more * info. * *

Example

* * createjs.Ticker.addEventListener("tick", handleTick); * createjs.Ticker.paused = true; * function handleTick(event) { * console.log(event.paused, * createjs.Ticker.getTime(false), * createjs.Ticker.getTime(true)); * } * * @property paused * @static * @type {Boolean} * @default false **/ Ticker.paused = false; // mix-ins: // EventDispatcher methods: Ticker.removeEventListener = null; Ticker.removeAllEventListeners = null; Ticker.dispatchEvent = null; Ticker.hasEventListener = null; Ticker._listeners = null; createjs.EventDispatcher.initialize(Ticker); // inject EventDispatcher methods. Ticker._addEventListener = Ticker.addEventListener; Ticker.addEventListener = function() { !Ticker._inited&&Ticker.init(); return Ticker._addEventListener.apply(Ticker, arguments); }; // private static properties: /** * @property _inited * @static * @type {Boolean} * @private **/ Ticker._inited = false; /** * @property _startTime * @static * @type {Number} * @private **/ Ticker._startTime = 0; /** * @property _pausedTime * @static * @type {Number} * @private **/ Ticker._pausedTime=0; /** * The number of ticks that have passed * @property _ticks * @static * @type {Number} * @private **/ Ticker._ticks = 0; /** * The number of ticks that have passed while Ticker has been paused * @property _pausedTicks * @static * @type {Number} * @private **/ Ticker._pausedTicks = 0; /** * @property _interval * @static * @type {Number} * @private **/ Ticker._interval = 50; /** * @property _lastTime * @static * @type {Number} * @private **/ Ticker._lastTime = 0; /** * @property _times * @static * @type {Array} * @private **/ Ticker._times = null; /** * @property _tickTimes * @static * @type {Array} * @private **/ Ticker._tickTimes = null; /** * Stores the timeout or requestAnimationFrame id. * @property _timerId * @static * @type {Number} * @private **/ Ticker._timerId = null; /** * True if currently using requestAnimationFrame, false if using setTimeout. This may be different than timingMode * if that property changed and a tick hasn't fired. * @property _raf * @static * @type {Boolean} * @private **/ Ticker._raf = true; // static getter / setters: /** * Use the {{#crossLink "Ticker/interval:property"}}{{/crossLink}} property instead. * @method _setInterval * @private * @static * @param {Number} interval **/ Ticker._setInterval = function(interval) { Ticker._interval = interval; if (!Ticker._inited) { return; } Ticker._setupTick(); }; /** * Use the {{#crossLink "Ticker/interval:property"}}{{/crossLink}} property instead. * @method setInterval * @deprecated */ // Ticker.setInterval is @deprecated. Remove for 1.1+ Ticker.setInterval = createjs.deprecate(Ticker._setInterval, "Ticker.setInterval"); /** * Use the {{#crossLink "Ticker/interval:property"}}{{/crossLink}} property instead. * @method _getInterval * @private * @static * @return {Number} **/ Ticker._getInterval = function() { return Ticker._interval; }; /** * Use the {{#crossLink "Ticker/interval:property"}}{{/crossLink}} property instead. * @method getInterval * @deprecated */ // Ticker.getInterval is @deprecated. Remove for 1.1+ Ticker.getInterval = createjs.deprecate(Ticker._getInterval, "Ticker.getInterval"); /** * Use the {{#crossLink "Ticker/framerate:property"}}{{/crossLink}} property instead. * @method _setFPS * @private * @static * @param {Number} value **/ Ticker._setFPS = function(value) { Ticker._setInterval(1000/value); }; /** * Use the {{#crossLink "Ticker/framerate:property"}}{{/crossLink}} property instead. * @method setFPS * @deprecated */ // Ticker.setFPS is @deprecated. Remove for 1.1+ Ticker.setFPS = createjs.deprecate(Ticker._setFPS, "Ticker.setFPS"); /** * Use the {{#crossLink "Ticker/framerate:property"}}{{/crossLink}} property instead. * @method _getFPS * @static * @private * @return {Number} **/ Ticker._getFPS = function() { return 1000/Ticker._interval; }; /** * Use the {{#crossLink "Ticker/framerate:property"}}{{/crossLink}} property instead. * @method getFPS * @deprecated */ // Ticker.getFPS is @deprecated. Remove for 1.1+ Ticker.getFPS = createjs.deprecate(Ticker._getFPS, "Ticker.getFPS"); /** * Indicates the target time (in milliseconds) between ticks. Default is 50 (20 FPS). * Note that actual time between ticks may be more than specified depending on CPU load. * This property is ignored if the ticker is using the `RAF` timing mode. * @property interval * @static * @type {Number} **/ /** * Indicates the target frame rate in frames per second (FPS). Effectively just a shortcut to `interval`, where * `framerate == 1000/interval`. * @property framerate * @static * @type {Number} **/ try { Object.defineProperties(Ticker, { interval: { get: Ticker._getInterval, set: Ticker._setInterval }, framerate: { get: Ticker._getFPS, set: Ticker._setFPS } }); } catch (e) { console.log(e); } // public static methods: /** * Starts the tick. This is called automatically when the first listener is added. * @method init * @static **/ Ticker.init = function() { if (Ticker._inited) { return; } Ticker._inited = true; Ticker._times = []; Ticker._tickTimes = []; Ticker._startTime = Ticker._getTime(); Ticker._times.push(Ticker._lastTime = 0); Ticker.interval = Ticker._interval; }; /** * Stops the Ticker and removes all listeners. Use init() to restart the Ticker. * @method reset * @static **/ Ticker.reset = function() { if (Ticker._raf) { var f = window.cancelAnimationFrame || window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || window.oCancelAnimationFrame || window.msCancelAnimationFrame; f&&f(Ticker._timerId); } else { clearTimeout(Ticker._timerId); } Ticker.removeAllEventListeners("tick"); Ticker._timerId = Ticker._times = Ticker._tickTimes = null; Ticker._startTime = Ticker._lastTime = Ticker._ticks = Ticker._pausedTime = 0; Ticker._inited = false; }; /** * Returns the average time spent within a tick. This can vary significantly from the value provided by getMeasuredFPS * because it only measures the time spent within the tick execution stack. * * Example 1: With a target FPS of 20, getMeasuredFPS() returns 20fps, which indicates an average of 50ms between * the end of one tick and the end of the next. However, getMeasuredTickTime() returns 15ms. This indicates that * there may be up to 35ms of "idle" time between the end of one tick and the start of the next. * * Example 2: With a target FPS of 30, {{#crossLink "Ticker/framerate:property"}}{{/crossLink}} returns 10fps, which * indicates an average of 100ms between the end of one tick and the end of the next. However, {{#crossLink "Ticker/getMeasuredTickTime"}}{{/crossLink}} * returns 20ms. This would indicate that something other than the tick is using ~80ms (another script, DOM * rendering, etc). * @method getMeasuredTickTime * @static * @param {Number} [ticks] The number of previous ticks over which to measure the average time spent in a tick. * Defaults to the number of ticks per second. To get only the last tick's time, pass in 1. * @return {Number} The average time spent in a tick in milliseconds. **/ Ticker.getMeasuredTickTime = function(ticks) { var ttl=0, times=Ticker._tickTimes; if (!times || times.length < 1) { return -1; } // by default, calculate average for the past ~1 second: ticks = Math.min(times.length, ticks||(Ticker._getFPS()|0)); for (var i=0; i= (Ticker._interval-1)*0.97) { Ticker._tick(); } }; /** * @method _handleRAF * @static * @private **/ Ticker._handleRAF = function() { Ticker._timerId = null; Ticker._setupTick(); Ticker._tick(); }; /** * @method _handleTimeout * @static * @private **/ Ticker._handleTimeout = function() { Ticker._timerId = null; Ticker._setupTick(); Ticker._tick(); }; /** * @method _setupTick * @static * @private **/ Ticker._setupTick = function() { if (Ticker._timerId != null) { return; } // avoid duplicates var mode = Ticker.timingMode; if (mode == Ticker.RAF_SYNCHED || mode == Ticker.RAF) { var f = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame; if (f) { Ticker._timerId = f(mode == Ticker.RAF ? Ticker._handleRAF : Ticker._handleSynch); Ticker._raf = true; return; } } Ticker._raf = false; Ticker._timerId = setTimeout(Ticker._handleTimeout, Ticker._interval); }; /** * @method _tick * @static * @private **/ Ticker._tick = function() { var paused = Ticker.paused; var time = Ticker._getTime(); var elapsedTime = time-Ticker._lastTime; Ticker._lastTime = time; Ticker._ticks++; if (paused) { Ticker._pausedTicks++; Ticker._pausedTime += elapsedTime; } if (Ticker.hasEventListener("tick")) { var event = new createjs.Event("tick"); var maxDelta = Ticker.maxDelta; event.delta = (maxDelta && elapsedTime > maxDelta) ? maxDelta : elapsedTime; event.paused = paused; event.time = time; event.runTime = time-Ticker._pausedTime; Ticker.dispatchEvent(event); } Ticker._tickTimes.unshift(Ticker._getTime()-time); while (Ticker._tickTimes.length > 100) { Ticker._tickTimes.pop(); } Ticker._times.unshift(time); while (Ticker._times.length > 100) { Ticker._times.pop(); } }; /** * @method _getTime * @static * @private **/ var w=window, now=w.performance.now || w.performance.mozNow || w.performance.msNow || w.performance.oNow || w.performance.webkitNow; Ticker._getTime = function() { return ((now&&now.call(w.performance))||(new Date().getTime())) - Ticker._startTime; }; createjs.Ticker = Ticker; }()); //############################################################################## // VideoBuffer.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * When an HTML video seeks, including when looping, there is an indeterminate period before a new frame is available. * This can result in the video blinking or flashing when it is drawn to a canvas. The VideoBuffer class resolves * this issue by drawing each frame to an off-screen canvas and preserving the prior frame during a seek. * * var myBuffer = new createjs.VideoBuffer(myVideo); * var myBitmap = new Bitmap(myBuffer); * * @class VideoBuffer * @param {HTMLVideoElement} video The HTML video element to buffer. * @constructor **/ function VideoBuffer(video) { // private properties: /** * Used by Bitmap to determine when the video buffer is ready to be drawn. Not intended for general use. * @property readyState * @protected * @type {Number} * @default 0 **/ this.readyState = video.readyState; /** * @property _video * @protected * @type {HTMLVideoElement} * @default 0 **/ this._video = video; /** * @property _canvas * @protected * @type {HTMLCanvasElement} * @default 0 **/ this._canvas = null; /** * @property _lastTime * @protected * @type {Number} * @default -1 **/ this._lastTime = -1; if (this.readyState < 2) { video.addEventListener("canplaythrough", this._videoReady.bind(this)); } //once:true isn't supported everywhere, but its a non-critical optimization here. } var p = VideoBuffer.prototype; // public methods: /** * Gets an HTML canvas element showing the current video frame, or the previous frame if in a seek / loop. * Primarily for use by {{#crossLink "Bitmap"}}{{/crossLink}}. * @method getImage **/ p.getImage = function() { if (this.readyState < 2) { return; } var canvas=this._canvas, video = this._video; if (!canvas) { canvas = this._canvas = createjs.createCanvas?createjs.createCanvas():document.createElement("canvas"); canvas.width = video.videoWidth; canvas.height = video.videoHeight; } if (video.readyState >= 2 && video.currentTime !== this._lastTime) { var ctx = canvas.getContext("2d"); ctx.clearRect(0,0,canvas.width,canvas.height); ctx.drawImage(video,0,0,canvas.width,canvas.height); this._lastTime = video.currentTime; } return canvas; }; // private methods: /** * @method _videoReady * @protected **/ p._videoReady = function() { this.readyState = 2; }; createjs.VideoBuffer = VideoBuffer; }()); //############################################################################## // MouseEvent.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * Passed as the parameter to all mouse/pointer/touch related events. For a listing of mouse events and their properties, * see the {{#crossLink "DisplayObject"}}{{/crossLink}} and {{#crossLink "Stage"}}{{/crossLink}} event listings. * @class MouseEvent * @param {String} type The event type. * @param {Boolean} bubbles Indicates whether the event will bubble through the display list. * @param {Boolean} cancelable Indicates whether the default behaviour of this event can be cancelled. * @param {Number} stageX The normalized x position relative to the stage. * @param {Number} stageY The normalized y position relative to the stage. * @param {MouseEvent} nativeEvent The native DOM event related to this mouse event. * @param {Number} pointerID The unique id for the pointer. * @param {Boolean} primary Indicates whether this is the primary pointer in a multitouch environment. * @param {Number} rawX The raw x position relative to the stage. * @param {Number} rawY The raw y position relative to the stage. * @param {DisplayObject} relatedTarget The secondary target for the event. * @extends Event * @constructor **/ function MouseEvent(type, bubbles, cancelable, stageX, stageY, nativeEvent, pointerID, primary, rawX, rawY, relatedTarget) { this.Event_constructor(type, bubbles, cancelable); // public properties: /** * The normalized x position on the stage. This will always be within the range 0 to stage width. * @property stageX * @type Number */ this.stageX = stageX; /** * The normalized y position on the stage. This will always be within the range 0 to stage height. * @property stageY * @type Number **/ this.stageY = stageY; /** * The raw x position relative to the stage. Normally this will be the same as the stageX value, unless * stage.mouseMoveOutside is true and the pointer is outside of the stage bounds. * @property rawX * @type Number */ this.rawX = (rawX==null)?stageX:rawX; /** * The raw y position relative to the stage. Normally this will be the same as the stageY value, unless * stage.mouseMoveOutside is true and the pointer is outside of the stage bounds. * @property rawY * @type Number */ this.rawY = (rawY==null)?stageY:rawY; /** * The native MouseEvent generated by the browser. The properties and API for this * event may differ between browsers. This property will be null if the * EaselJS property was not directly generated from a native MouseEvent. * @property nativeEvent * @type HtmlMouseEvent * @default null **/ this.nativeEvent = nativeEvent; /** * The unique id for the pointer (touch point or cursor). This will be either -1 for the mouse, or the system * supplied id value. * @property pointerID * @type {Number} */ this.pointerID = pointerID; /** * Indicates whether this is the primary pointer in a multitouch environment. This will always be true for the mouse. * For touch pointers, the first pointer in the current stack will be considered the primary pointer. * @property primary * @type {Boolean} */ this.primary = !!primary; /** * The secondary target for the event, if applicable. This is used for {{#crossLink "DisplayObject/mouseout:event"}}{{/crossLink}}/ * {{#crossLink "DisplayObject/rollout:event"}}{{/crossLink}} * events to indicate the object that the mouse entered from, {{#crossLink "DisplayObject/rollover:event"}}{{/crossLink}}/ * {{#crossLink "DisplayObject/rollover:event"}}{{/crossLink}} for the object the mouse exited, * and {{#crossLink "Stage/stagemousedown:event"}}{{/crossLink}}/{{#crossLink "Stage/stagemouseup:event"}}{{/crossLink}} * events for the object that was the under the cursor, if any. * * Only valid interaction targets will be returned (ie. objects with mouse listeners or a cursor set). * @property relatedTarget * @type {DisplayObject} */ this.relatedTarget = relatedTarget; } var p = createjs.extend(MouseEvent, createjs.Event); // TODO: deprecated // p.initialize = function() {}; // searchable for devs wondering where it is. REMOVED. See docs for details. // getter / setters: /** * Returns the x position of the mouse in the local coordinate system of the current target (ie. the dispatcher). * @property localX * @type {Number} * @readonly */ p._get_localX = function() { return this.currentTarget.globalToLocal(this.rawX, this.rawY).x; }; /** * Returns the y position of the mouse in the local coordinate system of the current target (ie. the dispatcher). * @property localY * @type {Number} * @readonly */ p._get_localY = function() { return this.currentTarget.globalToLocal(this.rawX, this.rawY).y; }; /** * Indicates whether the event was generated by a touch input (versus a mouse input). * @property isTouch * @type {Boolean} * @readonly */ p._get_isTouch = function() { return this.pointerID !== -1; }; try { Object.defineProperties(p, { localX: { get: p._get_localX }, localY: { get: p._get_localY }, isTouch: { get: p._get_isTouch } }); } catch (e) {} // TODO: use Log // public methods: /** * Returns a clone of the MouseEvent instance. * @method clone * @return {MouseEvent} a clone of the MouseEvent instance. **/ p.clone = function() { return new MouseEvent(this.type, this.bubbles, this.cancelable, this.stageX, this.stageY, this.nativeEvent, this.pointerID, this.primary, this.rawX, this.rawY); }; /** * Returns a string representation of this object. * @method toString * @return {String} a string representation of the instance. **/ p.toString = function() { return "[MouseEvent (type="+this.type+" stageX="+this.stageX+" stageY="+this.stageY+")]"; }; createjs.MouseEvent = createjs.promote(MouseEvent, "Event"); }()); //############################################################################## // Matrix2D.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * Represents an affine transformation matrix, and provides tools for constructing and concatenating matrices. * * This matrix can be visualized as: * * [ a c tx * b d ty * 0 0 1 ] * * Note the locations of b and c. * * @class Matrix2D * @param {Number} [a=1] Specifies the a property for the new matrix. * @param {Number} [b=0] Specifies the b property for the new matrix. * @param {Number} [c=0] Specifies the c property for the new matrix. * @param {Number} [d=1] Specifies the d property for the new matrix. * @param {Number} [tx=0] Specifies the tx property for the new matrix. * @param {Number} [ty=0] Specifies the ty property for the new matrix. * @constructor **/ function Matrix2D(a, b, c, d, tx, ty) { this.setValues(a,b,c,d,tx,ty); // public properties: // assigned in the setValues method. /** * Position (0, 0) in a 3x3 affine transformation matrix. * @property a * @type Number **/ /** * Position (0, 1) in a 3x3 affine transformation matrix. * @property b * @type Number **/ /** * Position (1, 0) in a 3x3 affine transformation matrix. * @property c * @type Number **/ /** * Position (1, 1) in a 3x3 affine transformation matrix. * @property d * @type Number **/ /** * Position (2, 0) in a 3x3 affine transformation matrix. * @property tx * @type Number **/ /** * Position (2, 1) in a 3x3 affine transformation matrix. * @property ty * @type Number **/ } var p = Matrix2D.prototype; // constants: /** * Multiplier for converting degrees to radians. Used internally by Matrix2D. * @property DEG_TO_RAD * @static * @final * @type Number * @readonly **/ Matrix2D.DEG_TO_RAD = Math.PI/180; // static public properties: /** * An identity matrix, representing a null transformation. * @property identity * @static * @type Matrix2D * @readonly **/ Matrix2D.identity = null; // set at bottom of class definition. // public methods: /** * Sets the specified values on this instance. * @method setValues * @param {Number} [a=1] Specifies the a property for the new matrix. * @param {Number} [b=0] Specifies the b property for the new matrix. * @param {Number} [c=0] Specifies the c property for the new matrix. * @param {Number} [d=1] Specifies the d property for the new matrix. * @param {Number} [tx=0] Specifies the tx property for the new matrix. * @param {Number} [ty=0] Specifies the ty property for the new matrix. * @return {Matrix2D} This instance. Useful for chaining method calls. */ p.setValues = function(a, b, c, d, tx, ty) { // don't forget to update docs in the constructor if these change: this.a = (a == null) ? 1 : a; this.b = b || 0; this.c = c || 0; this.d = (d == null) ? 1 : d; this.tx = tx || 0; this.ty = ty || 0; return this; }; /** * Appends the specified matrix properties to this matrix. All parameters are required. * This is the equivalent of multiplying `(this matrix) * (specified matrix)`. * @method append * @param {Number} a * @param {Number} b * @param {Number} c * @param {Number} d * @param {Number} tx * @param {Number} ty * @return {Matrix2D} This matrix. Useful for chaining method calls. **/ p.append = function(a, b, c, d, tx, ty) { var a1 = this.a; var b1 = this.b; var c1 = this.c; var d1 = this.d; if (a != 1 || b != 0 || c != 0 || d != 1) { this.a = a1*a+c1*b; this.b = b1*a+d1*b; this.c = a1*c+c1*d; this.d = b1*c+d1*d; } this.tx = a1*tx+c1*ty+this.tx; this.ty = b1*tx+d1*ty+this.ty; return this; }; /** * Prepends the specified matrix properties to this matrix. * This is the equivalent of multiplying `(specified matrix) * (this matrix)`. * All parameters are required. * @method prepend * @param {Number} a * @param {Number} b * @param {Number} c * @param {Number} d * @param {Number} tx * @param {Number} ty * @return {Matrix2D} This matrix. Useful for chaining method calls. **/ p.prepend = function(a, b, c, d, tx, ty) { var a1 = this.a; var c1 = this.c; var tx1 = this.tx; this.a = a*a1+c*this.b; this.b = b*a1+d*this.b; this.c = a*c1+c*this.d; this.d = b*c1+d*this.d; this.tx = a*tx1+c*this.ty+tx; this.ty = b*tx1+d*this.ty+ty; return this; }; /** * Appends the specified matrix to this matrix. * This is the equivalent of multiplying `(this matrix) * (specified matrix)`. * @method appendMatrix * @param {Matrix2D} matrix * @return {Matrix2D} This matrix. Useful for chaining method calls. **/ p.appendMatrix = function(matrix) { return this.append(matrix.a, matrix.b, matrix.c, matrix.d, matrix.tx, matrix.ty); }; /** * Prepends the specified matrix to this matrix. * This is the equivalent of multiplying `(specified matrix) * (this matrix)`. * For example, you could calculate the combined transformation for a child object using: * * var o = myDisplayObject; * var mtx = o.getMatrix(); * while (o = o.parent) { * // prepend each parent's transformation in turn: * o.prependMatrix(o.getMatrix()); * } * @method prependMatrix * @param {Matrix2D} matrix * @return {Matrix2D} This matrix. Useful for chaining method calls. **/ p.prependMatrix = function(matrix) { return this.prepend(matrix.a, matrix.b, matrix.c, matrix.d, matrix.tx, matrix.ty); }; /** * Generates matrix properties from the specified display object transform properties, and appends them to this matrix. * For example, you can use this to generate a matrix representing the transformations of a display object: * * var mtx = new createjs.Matrix2D(); * mtx.appendTransform(o.x, o.y, o.scaleX, o.scaleY, o.rotation); * @method appendTransform * @param {Number} x * @param {Number} y * @param {Number} scaleX * @param {Number} scaleY * @param {Number} rotation * @param {Number} skewX * @param {Number} skewY * @param {Number} regX Optional. * @param {Number} regY Optional. * @return {Matrix2D} This matrix. Useful for chaining method calls. **/ p.appendTransform = function(x, y, scaleX, scaleY, rotation, skewX, skewY, regX, regY) { if (rotation%360) { var r = rotation*Matrix2D.DEG_TO_RAD; var cos = Math.cos(r); var sin = Math.sin(r); } else { cos = 1; sin = 0; } if (skewX || skewY) { // TODO: can this be combined into a single append operation? skewX *= Matrix2D.DEG_TO_RAD; skewY *= Matrix2D.DEG_TO_RAD; this.append(Math.cos(skewY), Math.sin(skewY), -Math.sin(skewX), Math.cos(skewX), x, y); this.append(cos*scaleX, sin*scaleX, -sin*scaleY, cos*scaleY, 0, 0); } else { this.append(cos*scaleX, sin*scaleX, -sin*scaleY, cos*scaleY, x, y); } if (regX || regY) { // append the registration offset: this.tx -= regX*this.a+regY*this.c; this.ty -= regX*this.b+regY*this.d; } return this; }; /** * Generates matrix properties from the specified display object transform properties, and prepends them to this matrix. * For example, you could calculate the combined transformation for a child object using: * * var o = myDisplayObject; * var mtx = new createjs.Matrix2D(); * do { * // prepend each parent's transformation in turn: * mtx.prependTransform(o.x, o.y, o.scaleX, o.scaleY, o.rotation, o.skewX, o.skewY, o.regX, o.regY); * } while (o = o.parent); * * Note that the above example would not account for {{#crossLink "DisplayObject/transformMatrix:property"}}{{/crossLink}} * values. See {{#crossLink "Matrix2D/prependMatrix"}}{{/crossLink}} for an example that does. * @method prependTransform * @param {Number} x * @param {Number} y * @param {Number} scaleX * @param {Number} scaleY * @param {Number} rotation * @param {Number} skewX * @param {Number} skewY * @param {Number} regX Optional. * @param {Number} regY Optional. * @return {Matrix2D} This matrix. Useful for chaining method calls. **/ p.prependTransform = function(x, y, scaleX, scaleY, rotation, skewX, skewY, regX, regY) { if (rotation%360) { var r = rotation*Matrix2D.DEG_TO_RAD; var cos = Math.cos(r); var sin = Math.sin(r); } else { cos = 1; sin = 0; } if (regX || regY) { // prepend the registration offset: this.tx -= regX; this.ty -= regY; } if (skewX || skewY) { // TODO: can this be combined into a single prepend operation? skewX *= Matrix2D.DEG_TO_RAD; skewY *= Matrix2D.DEG_TO_RAD; this.prepend(cos*scaleX, sin*scaleX, -sin*scaleY, cos*scaleY, 0, 0); this.prepend(Math.cos(skewY), Math.sin(skewY), -Math.sin(skewX), Math.cos(skewX), x, y); } else { this.prepend(cos*scaleX, sin*scaleX, -sin*scaleY, cos*scaleY, x, y); } return this; }; /** * Applies a clockwise rotation transformation to the matrix. * @method rotate * @param {Number} angle The angle to rotate by, in degrees. To use a value in radians, multiply it by `Math.PI/180`. * @return {Matrix2D} This matrix. Useful for chaining method calls. **/ p.rotate = function(angle) { angle = angle*Matrix2D.DEG_TO_RAD; var cos = Math.cos(angle); var sin = Math.sin(angle); var a1 = this.a; var b1 = this.b; this.a = a1*cos+this.c*sin; this.b = b1*cos+this.d*sin; this.c = -a1*sin+this.c*cos; this.d = -b1*sin+this.d*cos; return this; }; /** * Applies a skew transformation to the matrix. * @method skew * @param {Number} skewX The amount to skew horizontally in degrees. To use a value in radians, multiply it by `Math.PI/180`. * @param {Number} skewY The amount to skew vertically in degrees. * @return {Matrix2D} This matrix. Useful for chaining method calls. */ p.skew = function(skewX, skewY) { skewX = skewX*Matrix2D.DEG_TO_RAD; skewY = skewY*Matrix2D.DEG_TO_RAD; this.append(Math.cos(skewY), Math.sin(skewY), -Math.sin(skewX), Math.cos(skewX), 0, 0); return this; }; /** * Applies a scale transformation to the matrix. * @method scale * @param {Number} x The amount to scale horizontally. E.G. a value of 2 will double the size in the X direction, and 0.5 will halve it. * @param {Number} y The amount to scale vertically. * @return {Matrix2D} This matrix. Useful for chaining method calls. **/ p.scale = function(x, y) { this.a *= x; this.b *= x; this.c *= y; this.d *= y; //this.tx *= x; //this.ty *= y; return this; }; /** * Translates the matrix on the x and y axes. * @method translate * @param {Number} x * @param {Number} y * @return {Matrix2D} This matrix. Useful for chaining method calls. **/ p.translate = function(x, y) { this.tx += this.a*x + this.c*y; this.ty += this.b*x + this.d*y; return this; }; /** * Sets the properties of the matrix to those of an identity matrix (one that applies a null transformation). * @method identity * @return {Matrix2D} This matrix. Useful for chaining method calls. **/ p.identity = function() { this.a = this.d = 1; this.b = this.c = this.tx = this.ty = 0; return this; }; /** * Inverts the matrix, causing it to perform the opposite transformation. * @method invert * @return {Matrix2D} This matrix. Useful for chaining method calls. **/ p.invert = function() { var a1 = this.a; var b1 = this.b; var c1 = this.c; var d1 = this.d; var tx1 = this.tx; var n = a1*d1-b1*c1; this.a = d1/n; this.b = -b1/n; this.c = -c1/n; this.d = a1/n; this.tx = (c1*this.ty-d1*tx1)/n; this.ty = -(a1*this.ty-b1*tx1)/n; return this; }; /** * Returns true if the matrix is an identity matrix. * @method isIdentity * @return {Boolean} **/ p.isIdentity = function() { return this.tx === 0 && this.ty === 0 && this.a === 1 && this.b === 0 && this.c === 0 && this.d === 1; }; /** * Returns true if this matrix is equal to the specified matrix (all property values are equal). * @method equals * @param {Matrix2D} matrix The matrix to compare. * @return {Boolean} **/ p.equals = function(matrix) { return this.tx === matrix.tx && this.ty === matrix.ty && this.a === matrix.a && this.b === matrix.b && this.c === matrix.c && this.d === matrix.d; }; /** * Transforms a point according to this matrix. * @method transformPoint * @param {Number} x The x component of the point to transform. * @param {Number} y The y component of the point to transform. * @param {Point | Object} [pt] An object to copy the result into. If omitted a generic object with x/y properties will be returned. * @return {Point} This matrix. Useful for chaining method calls. **/ p.transformPoint = function(x, y, pt) { pt = pt||{}; pt.x = x*this.a+y*this.c+this.tx; pt.y = x*this.b+y*this.d+this.ty; return pt; }; /** * Decomposes the matrix into transform properties (x, y, scaleX, scaleY, and rotation). Note that these values * may not match the transform properties you used to generate the matrix, though they will produce the same visual * results. * @method decompose * @param {Object} target The object to apply the transform properties to. If null, then a new object will be returned. * @return {Object} The target, or a new generic object with the transform properties applied. */ p.decompose = function(target) { // TODO: it would be nice to be able to solve for whether the matrix can be decomposed into only scale/rotation even when scale is negative if (target == null) { target = {}; } target.x = this.tx; target.y = this.ty; target.scaleX = Math.sqrt(this.a * this.a + this.b * this.b); target.scaleY = Math.sqrt(this.c * this.c + this.d * this.d); var skewX = Math.atan2(-this.c, this.d); var skewY = Math.atan2(this.b, this.a); var delta = Math.abs(1-skewX/skewY); if (delta < 0.00001) { // effectively identical, can use rotation: target.rotation = skewY/Matrix2D.DEG_TO_RAD; if (this.a < 0 && this.d >= 0) { target.rotation += (target.rotation <= 0) ? 180 : -180; } target.skewX = target.skewY = 0; } else { target.skewX = skewX/Matrix2D.DEG_TO_RAD; target.skewY = skewY/Matrix2D.DEG_TO_RAD; } return target; }; /** * Copies all properties from the specified matrix to this matrix. * @method copy * @param {Matrix2D} matrix The matrix to copy properties from. * @return {Matrix2D} This matrix. Useful for chaining method calls. */ p.copy = function(matrix) { return this.setValues(matrix.a, matrix.b, matrix.c, matrix.d, matrix.tx, matrix.ty); }; /** * Returns a clone of the Matrix2D instance. * @method clone * @return {Matrix2D} a clone of the Matrix2D instance. **/ p.clone = function() { return new Matrix2D(this.a, this.b, this.c, this.d, this.tx, this.ty); }; /** * Returns a string representation of this object. * @method toString * @return {String} a string representation of the instance. **/ p.toString = function() { return "[Matrix2D (a="+this.a+" b="+this.b+" c="+this.c+" d="+this.d+" tx="+this.tx+" ty="+this.ty+")]"; }; // this has to be populated after the class is defined: Matrix2D.identity = new Matrix2D(); createjs.Matrix2D = Matrix2D; }()); //############################################################################## // DisplayProps.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; /** * Used for calculating and encapsulating display related properties. * @class DisplayProps * @param {Number} [visible=true] Visible value. * @param {Number} [alpha=1] Alpha value. * @param {Number} [shadow=null] A Shadow instance or null. * @param {Number} [compositeOperation=null] A compositeOperation value or null. * @param {Number} [matrix] A transformation matrix. Defaults to a new identity matrix. * @constructor **/ function DisplayProps(visible, alpha, shadow, compositeOperation, matrix) { this.setValues(visible, alpha, shadow, compositeOperation, matrix); // public properties: // assigned in the setValues method. /** * Property representing the alpha that will be applied to a display object. * @property alpha * @type Number **/ /** * Property representing the shadow that will be applied to a display object. * @property shadow * @type Shadow **/ /** * Property representing the compositeOperation that will be applied to a display object. * You can find a list of valid composite operations at: * https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API/Tutorial/Compositing * @property compositeOperation * @type String **/ /** * Property representing the value for visible that will be applied to a display object. * @property visible * @type Boolean **/ /** * The transformation matrix that will be applied to a display object. * @property matrix * @type Matrix2D **/ } var p = DisplayProps.prototype; // initialization: /** * Reinitializes the instance with the specified values. * @method setValues * @param {Number} [visible=true] Visible value. * @param {Number} [alpha=1] Alpha value. * @param {Number} [shadow=null] A Shadow instance or null. * @param {Number} [compositeOperation=null] A compositeOperation value or null. * @param {Number} [matrix] A transformation matrix. Defaults to an identity matrix. * @return {DisplayProps} This instance. Useful for chaining method calls. * @chainable */ p.setValues = function (visible, alpha, shadow, compositeOperation, matrix) { this.visible = visible == null ? true : !!visible; this.alpha = alpha == null ? 1 : alpha; this.shadow = shadow; this.compositeOperation = compositeOperation; this.matrix = matrix || (this.matrix&&this.matrix.identity()) || new createjs.Matrix2D(); return this; }; // public methods: /** * Appends the specified display properties. This is generally used to apply a child's properties its parent's. * @method append * @param {Boolean} visible desired visible value * @param {Number} alpha desired alpha value * @param {Shadow} shadow desired shadow value * @param {String} compositeOperation desired composite operation value * @param {Matrix2D} [matrix] a Matrix2D instance * @return {DisplayProps} This instance. Useful for chaining method calls. * @chainable */ p.append = function(visible, alpha, shadow, compositeOperation, matrix) { this.alpha *= alpha; this.shadow = shadow || this.shadow; this.compositeOperation = compositeOperation || this.compositeOperation; this.visible = this.visible && visible; matrix&&this.matrix.appendMatrix(matrix); return this; }; /** * Prepends the specified display properties. This is generally used to apply a parent's properties to a child's. * For example, to get the combined display properties that would be applied to a child, you could use: * * var o = myDisplayObject; * var props = new createjs.DisplayProps(); * do { * // prepend each parent's props in turn: * props.prepend(o.visible, o.alpha, o.shadow, o.compositeOperation, o.getMatrix()); * } while (o = o.parent); * * @method prepend * @param {Boolean} visible desired visible value * @param {Number} alpha desired alpha value * @param {Shadow} shadow desired shadow value * @param {String} compositeOperation desired composite operation value * @param {Matrix2D} [matrix] a Matrix2D instance * @return {DisplayProps} This instance. Useful for chaining method calls. * @chainable */ p.prepend = function(visible, alpha, shadow, compositeOperation, matrix) { this.alpha *= alpha; this.shadow = this.shadow || shadow; this.compositeOperation = this.compositeOperation || compositeOperation; this.visible = this.visible && visible; matrix&&this.matrix.prependMatrix(matrix); return this; }; /** * Resets this instance and its matrix to default values. * @method identity * @return {DisplayProps} This instance. Useful for chaining method calls. * @chainable */ p.identity = function() { this.visible = true; this.alpha = 1; this.shadow = this.compositeOperation = null; this.matrix.identity(); return this; }; /** * Returns a clone of the DisplayProps instance. Clones the associated matrix. * @method clone * @return {DisplayProps} a clone of the DisplayProps instance. **/ p.clone = function() { return new DisplayProps(this.alpha, this.shadow, this.compositeOperation, this.visible, this.matrix.clone()); }; // private methods: createjs.DisplayProps = DisplayProps; })(); //############################################################################## // Point.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * Represents a point on a 2 dimensional x / y coordinate system. * *

Example

* * var point = new createjs.Point(0, 100); * * @class Point * @param {Number} [x=0] X position. * @param {Number} [y=0] Y position. * @constructor **/ function Point(x, y) { this.setValues(x, y); // public properties: // assigned in the setValues method. /** * X position. * @property x * @type Number * @default 0 **/ /** * Y position. * @property y * @type Number * @default 0 **/ } var p = Point.prototype; // public methods: /** * Sets the specified values on this instance. * @method setValues * @param {Number} [x=0] X position. * @param {Number} [y=0] Y position. * @return {Point} This instance. Useful for chaining method calls. * @chainable */ p.setValues = function(x, y) { this.x = x||0; this.y = y||0; return this; }; /** * Offsets the Point object by the specified amount. *
    *
  • The value of `dx` is added to the original value of `x` to create the new `x` value
  • *
  • The value of `dy` is added to the original value of `y` to create the new `y` value
  • *
* @method offset * @param {Number} dx The amount by which to offset the horizontal coordinate, `x`. * @param {Number} dy The amount by which to offset the vertical coordinate, `y`. * @return {Point} This instance. Useful for chaining method calls. * @chainable */ p.offset = function(dx, dy) { this.x += dx; this.y += dy; return this; }; /** * Converts a pair of polar coordinates to a Cartesian point coordinate. * @method polar * @param {Number} len The length coordinate of the polar pair. * @param {Number} angle The angle, in radians, of the polar pair. * @param {Point | Object} [pt] An object to copy the result into. If omitted a new {{#crossLink "Point"}}{{/crossLink}} * will be returned. * @return {Point} The new, interpolated point. * @static */ Point.polar = function(len, angle, pt) { pt = pt||new Point(); pt.x = len * Math.cos(angle); pt.y = len * Math.sin(angle); return pt; }; /** * Determine a point between two specified points. * * The parameter `f` determines where the new interpolated point is located relative to the two end points specified * by parameters `pt1` and `pt2`: *
    *
  • The closer the value of the parameter `f` is to 1.0, the closer the interpolated point is to the first * point (parameter `pt1`).
  • *
  • The closer the value of the parameter `f` is to 0, the closer the interpolated point is to the second * point (parameter `pt2`).
  • *
* @method interpolate * @param {Point | Object} pt1 The first point as a Point or generic object. * @param {Point | Object} pt2 The second point as a Point or generic object. * @param {Number} f The level of interpolation between the two points. Indicates where the new point will be, along * the line between `pt1` and `pt2`. If `f=1`, `pt1` is returned; if `f=0`, `pt2` is returned. * @param {Point | Object} [pt] An object to copy the result into. If omitted, a new {{#crossLink "Point"}}{{/crossLink}} * will be returned. * @return {Point} A new interpolated Point, or the `pt` passed in the 4th parameter with the interpolated values. * @static */ Point.interpolate = function(pt1, pt2, f, pt) { pt = pt || new Point(); pt.x = pt2.x + f * (pt1.x - pt2.x); pt.y = pt2.y + f * (pt1.y - pt2.y); return pt; }; /** * Copies all properties from the specified point to this point. * @method copy * @param {Point} point The point to copy properties from. * @return {Point} This point. Useful for chaining method calls. * @chainable */ p.copy = function(point) { this.x = point.x; this.y = point.y; return this; }; /** * Returns a clone of the Point instance. * @method clone * @return {Point} a clone of the Point instance. **/ p.clone = function() { return new Point(this.x, this.y); }; /** * Returns a string representation of this object. * @method toString * @return {String} a string representation of the instance. **/ p.toString = function() { return "[Point (x="+this.x+" y="+this.y+")]"; }; createjs.Point = Point; }()); //############################################################################## // Rectangle.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * Represents a rectangle as defined by the points (x, y) and (x+width, y+height). * *

Example

* * var rect = new createjs.Rectangle(0, 0, 100, 100); * * @class Rectangle * @param {Number} [x=0] X position. * @param {Number} [y=0] Y position. * @param {Number} [width=0] The width of the Rectangle. * @param {Number} [height=0] The height of the Rectangle. * @constructor **/ function Rectangle(x, y, width, height) { this.setValues(x, y, width, height); // public properties: // assigned in the setValues method. /** * X position. * @property x * @type Number **/ /** * Y position. * @property y * @type Number **/ /** * Width. * @property width * @type Number **/ /** * Height. * @property height * @type Number **/ } var p = Rectangle.prototype; // public methods: /** * Sets the specified values on this instance. * @method setValues * @param {Number} [x=0] X position. * @param {Number} [y=0] Y position. * @param {Number} [width=0] The width of the Rectangle. * @param {Number} [height=0] The height of the Rectangle. * @return {Rectangle} This instance. Useful for chaining method calls. * @chainable */ p.setValues = function(x, y, width, height) { // don't forget to update docs in the constructor if these change: this.x = x||0; this.y = y||0; this.width = width||0; this.height = height||0; return this; }; /** * Extends the rectangle's bounds to include the described point or rectangle. * @method extend * @param {Number} x X position of the point or rectangle. * @param {Number} y Y position of the point or rectangle. * @param {Number} [width=0] The width of the rectangle. * @param {Number} [height=0] The height of the rectangle. * @return {Rectangle} This instance. Useful for chaining method calls. * @chainable */ p.extend = function(x, y, width, height) { width = width||0; height = height||0; if (x+width > this.x+this.width) { this.width = x+width-this.x; } if (y+height > this.y+this.height) { this.height = y+height-this.y; } if (x < this.x) { this.width += this.x-x; this.x = x; } if (y < this.y) { this.height += this.y-y; this.y = y; } return this; }; /** * Adds the specified padding to the rectangle's bounds. * @method pad * @param {Number} top * @param {Number} left * @param {Number} bottom * @param {Number} right * @return {Rectangle} This instance. Useful for chaining method calls. * @chainable */ p.pad = function(top, left, bottom, right) { this.x -= left; this.y -= top; this.width += left+right; this.height += top+bottom; return this; }; /** * Copies all properties from the specified rectangle to this rectangle. * @method copy * @param {Rectangle} rectangle The rectangle to copy properties from. * @return {Rectangle} This rectangle. Useful for chaining method calls. * @chainable */ p.copy = function(rectangle) { return this.setValues(rectangle.x, rectangle.y, rectangle.width, rectangle.height); }; /** * Returns true if this rectangle fully encloses the described point or rectangle. * @method contains * @param {Number} x X position of the point or rectangle. * @param {Number} y Y position of the point or rectangle. * @param {Number} [width=0] The width of the rectangle. * @param {Number} [height=0] The height of the rectangle. * @return {Boolean} True if the described point or rectangle is contained within this rectangle. */ p.contains = function(x, y, width, height) { width = width||0; height = height||0; return (x >= this.x && x+width <= this.x+this.width && y >= this.y && y+height <= this.y+this.height); }; /** * Returns a new rectangle which contains this rectangle and the specified rectangle. * @method union * @param {Rectangle} rect The rectangle to calculate a union with. * @return {Rectangle} A new rectangle describing the union. */ p.union = function(rect) { return this.clone().extend(rect.x, rect.y, rect.width, rect.height); }; /** * Returns a new rectangle which describes the intersection (overlap) of this rectangle and the specified rectangle, * or null if they do not intersect. * @method intersection * @param {Rectangle} rect The rectangle to calculate an intersection with. * @return {Rectangle} A new rectangle describing the intersection or null. */ p.intersection = function(rect) { var x1 = rect.x, y1 = rect.y, x2 = x1+rect.width, y2 = y1+rect.height; if (this.x > x1) { x1 = this.x; } if (this.y > y1) { y1 = this.y; } if (this.x + this.width < x2) { x2 = this.x + this.width; } if (this.y + this.height < y2) { y2 = this.y + this.height; } return (x2 <= x1 || y2 <= y1) ? null : new Rectangle(x1, y1, x2-x1, y2-y1); }; /** * Returns true if the specified rectangle intersects (has any overlap) with this rectangle. * @method intersects * @param {Rectangle} rect The rectangle to compare. * @return {Boolean} True if the rectangles intersect. */ p.intersects = function(rect) { return (rect.x <= this.x+this.width && this.x <= rect.x+rect.width && rect.y <= this.y+this.height && this.y <= rect.y + rect.height); }; /** * Returns true if the width or height are equal or less than 0. * @method isEmpty * @return {Boolean} True if the rectangle is empty. */ p.isEmpty = function() { return this.width <= 0 || this.height <= 0; }; /** * Returns a clone of the Rectangle instance. * @method clone * @return {Rectangle} a clone of the Rectangle instance. **/ p.clone = function() { return new Rectangle(this.x, this.y, this.width, this.height); }; /** * Returns a string representation of this object. * @method toString * @return {String} a string representation of the instance. **/ p.toString = function() { return "[Rectangle (x="+this.x+" y="+this.y+" width="+this.width+" height="+this.height+")]"; }; createjs.Rectangle = Rectangle; }()); //############################################################################## // ButtonHelper.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * The ButtonHelper is a helper class to create interactive buttons from {{#crossLink "MovieClip"}}{{/crossLink}} or * {{#crossLink "Sprite"}}{{/crossLink}} instances. This class will intercept mouse events from an object, and * automatically call {{#crossLink "Sprite/gotoAndStop"}}{{/crossLink}} or {{#crossLink "Sprite/gotoAndPlay"}}{{/crossLink}}, * to the respective animation labels, add a pointer cursor, and allows the user to define a hit state frame. * * The ButtonHelper instance does not need to be added to the stage, but a reference should be maintained to prevent * garbage collection. * * Note that over states will not work unless you call {{#crossLink "Stage/enableMouseOver"}}{{/crossLink}}. * *

Example

* * var helper = new createjs.ButtonHelper(myInstance, "out", "over", "down", false, myInstance, "hit"); * myInstance.addEventListener("click", handleClick); * function handleClick(event) { * // Click Happened. * } * * @class ButtonHelper * @param {Sprite|MovieClip} target The instance to manage. * @param {String} [outLabel="out"] The label or animation to go to when the user rolls out of the button. * @param {String} [overLabel="over"] The label or animation to go to when the user rolls over the button. * @param {String} [downLabel="down"] The label or animation to go to when the user presses the button. * @param {Boolean} [play=false] If the helper should call "gotoAndPlay" or "gotoAndStop" on the button when changing * states. * @param {DisplayObject} [hitArea] An optional item to use as the hit state for the button. If this is not defined, * then the button's visible states will be used instead. Note that the same instance as the "target" argument can be * used for the hitState. * @param {String} [hitLabel] The label or animation on the hitArea instance that defines the hitArea bounds. If this is * null, then the default state of the hitArea will be used. * * @constructor */ function ButtonHelper(target, outLabel, overLabel, downLabel, play, hitArea, hitLabel) { if (!target.addEventListener) { return; } // public properties: /** * The target for this button helper. * @property target * @type MovieClip | Sprite * @readonly **/ this.target = target; /** * The label name or frame number to display when the user mouses out of the target. Defaults to "over". * @property overLabel * @type String | Number **/ this.overLabel = overLabel == null ? "over" : overLabel; /** * The label name or frame number to display when the user mouses over the target. Defaults to "out". * @property outLabel * @type String | Number **/ this.outLabel = outLabel == null ? "out" : outLabel; /** * The label name or frame number to display when the user presses on the target. Defaults to "down". * @property downLabel * @type String | Number **/ this.downLabel = downLabel == null ? "down" : downLabel; /** * If true, then ButtonHelper will call gotoAndPlay, if false, it will use gotoAndStop. Default is false. * @property play * @default false * @type Boolean **/ this.play = play; // private properties /** * @property _isPressed * @type Boolean * @protected **/ this._isPressed = false; /** * @property _isOver * @type Boolean * @protected **/ this._isOver = false; /** * @property _enabled * @type Boolean * @protected **/ this._enabled = false; // setup: target.mouseChildren = false; // prevents issues when children are removed from the display list when state changes. this.enabled = true; this.handleEvent({}); if (hitArea) { if (hitLabel) { hitArea.actionsEnabled = false; hitArea.gotoAndStop&&hitArea.gotoAndStop(hitLabel); } target.hitArea = hitArea; } } var p = ButtonHelper.prototype; // getter / setters: /** * Use the {{#crossLink "ButtonHelper/enabled:property"}}{{/crossLink}} property instead. * @method setEnabled * @param {Boolean} value The enabled property to set the instance to. * @[rptected * @protected **/ p._setEnabled = function(value) { if (value == this._enabled) { return; } var o = this.target; this._enabled = value; if (value) { o.cursor = "pointer"; o.addEventListener("rollover", this); o.addEventListener("rollout", this); o.addEventListener("mousedown", this); o.addEventListener("pressup", this); if (o._reset) { o.__reset = o._reset; o._reset = this._reset;} } else { o.cursor = null; o.removeEventListener("rollover", this); o.removeEventListener("rollout", this); o.removeEventListener("mousedown", this); o.removeEventListener("pressup", this); if (o.__reset) { o._reset = o.__reset; delete(o.__reset); } } }; /** * Use the {{#crossLink "ButtonHelper/enabled:property"}}{{/crossLink}} property instead. * @method setEnabled * @deprecated */ // ButtonHelper.setEnabled is @deprecated. Remove for 1.1+ p.setEnabled = createjs.deprecate(p._setEnabled, "ButtonHelper.setEnabled"); /** * Use the {{#crossLink "ButtonHelper/enabled:property"}}{{/crossLink}} property instead. * @method getEnabled * @protected * @return {Boolean} **/ p._getEnabled = function() { return this._enabled; }; /** * Use the {{#crossLink "ButtonHelper/enabled:property"}}{{/crossLink}} property instead. * @method getEnabled * @deprecated */ // ButtonHelper.getEnabled is @deprecated. Remove for 1.1+ p.getEnabled = createjs.deprecate(p._getEnabled, "ButtonHelper.getEnabled"); /** * Enables or disables the button functionality on the target. * @property enabled * @type {Boolean} **/ try { Object.defineProperties(p, { enabled: { get: p._getEnabled, set: p._setEnabled } }); } catch (e) {} // TODO: use Log // public methods: /** * Returns a string representation of this object. * @method toString * @return {String} a string representation of the instance. **/ p.toString = function() { return "[ButtonHelper]"; }; // private methods: /** * @method handleEvent * @param {Object} evt The mouse event to handle. * @protected **/ p.handleEvent = function(evt) { var label, t = this.target, type = evt.type; if (type == "mousedown") { this._isPressed = true; label = this.downLabel; } else if (type == "pressup") { this._isPressed = false; label = this._isOver ? this.overLabel : this.outLabel; } else if (type == "rollover") { this._isOver = true; label = this._isPressed ? this.downLabel : this.overLabel; } else { // rollout and default this._isOver = false; label = this._isPressed ? this.overLabel : this.outLabel; } if (this.play) { t.gotoAndPlay&&t.gotoAndPlay(label); } else { t.gotoAndStop&&t.gotoAndStop(label); } }; /** * Injected into target. Preserves the paused state through a reset. * @method _reset * @protected **/ p._reset = function() { // TODO: explore better ways to handle this issue. This is hacky & disrupts object signatures. var p = this.paused; this.__reset(); this.paused = p; }; createjs.ButtonHelper = ButtonHelper; }()); //############################################################################## // Shadow.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * This class encapsulates the properties required to define a shadow to apply to a {{#crossLink "DisplayObject"}}{{/crossLink}} * via its shadow property. * *

Example

* * myImage.shadow = new createjs.Shadow("#000000", 5, 5, 10); * * @class Shadow * @constructor * @param {String} color The color of the shadow. This can be any valid CSS color value. * @param {Number} offsetX The x offset of the shadow in pixels. * @param {Number} offsetY The y offset of the shadow in pixels. * @param {Number} blur The size of the blurring effect. **/ function Shadow(color, offsetX, offsetY, blur) { // public properties: /** * The color of the shadow. This can be any valid CSS color value. * @property color * @type String * @default null */ this.color = color||"black"; /** The x offset of the shadow. * @property offsetX * @type Number * @default 0 */ this.offsetX = offsetX||0; /** The y offset of the shadow. * @property offsetY * @type Number * @default 0 */ this.offsetY = offsetY||0; /** The blur of the shadow. * @property blur * @type Number * @default 0 */ this.blur = blur||0; } var p = Shadow.prototype; // static public properties: /** * An identity shadow object (all properties are set to 0). * @property identity * @type Shadow * @static * @final * @readonly **/ Shadow.identity = new Shadow("transparent", 0, 0, 0); // public methods: /** * Returns a string representation of this object. * @method toString * @return {String} a string representation of the instance. **/ p.toString = function() { return "[Shadow]"; }; /** * Returns a clone of this Shadow instance. * @method clone * @return {Shadow} A clone of the current Shadow instance. **/ p.clone = function() { return new Shadow(this.color, this.offsetX, this.offsetY, this.blur); }; createjs.Shadow = Shadow; }()); //############################################################################## // SpriteSheet.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * Encapsulates the properties and methods associated with a sprite sheet. A sprite sheet is a series of images (usually * animation frames) combined into a larger image (or images). For example, an animation consisting of eight 100x100 * images could be combined into a single 400x200 sprite sheet (4 frames across by 2 high). * * The data passed to the SpriteSheet constructor defines: *
    *
  1. The source image or images to use.
  2. *
  3. The positions of individual image frames.
  4. *
  5. Sequences of frames that form named animations. Optional.
  6. *
  7. The target playback framerate. Optional.
  8. *
*

SpriteSheet Format

* SpriteSheets are an object with two required properties (`images` and `frames`), and two optional properties * (`framerate` and `animations`). This makes them easy to define in javascript code, or in JSON. * *

images

* An array of source images. Images can be either an HTMlimage * instance, or a uri to an image. The former is recommended to control preloading. * * images: [image1, "path/to/image2.png"], * *

frames

* Defines the individual frames. There are two supported formats for frame data: * When all of the frames are the same size (in a grid), use an object with `width`, `height`, `regX`, `regY`, * and `count` properties. * *
    *
  • `width` & `height` are required and specify the dimensions of the frames
  • *
  • `regX` & `regY` indicate the registration point or "origin" of the frames
  • *
  • `spacing` indicate the spacing between frames
  • *
  • `margin` specify the margin around the image(s)
  • *
  • `count` allows you to specify the total number of frames in the spritesheet; if omitted, this will * be calculated based on the dimensions of the source images and the frames. Frames will be assigned * indexes based on their position in the source images (left to right, top to bottom).
  • *
* * frames: {width:64, height:64, count:20, regX: 32, regY:64, spacing:0, margin:0} * * If the frames are of different sizes, use an array of frame definitions. Each definition is itself an array * with 4 required and 3 optional entries, in the order: * *
    *
  • The first four, `x`, `y`, `width`, and `height` are required and define the frame rectangle.
  • *
  • The fifth, `imageIndex`, specifies the index of the source image (defaults to 0)
  • *
  • The last two, `regX` and `regY` specify the registration point of the frame
  • *
* * frames: [ * // x, y, width, height, imageIndex*, regX*, regY* * [64, 0, 96, 64], * [0, 0, 64, 64, 1, 32, 32] * // etc. * ] * *

animations

* Optional. An object defining sequences of frames to play as named animations. Each property corresponds to an * animation of the same name. Each animation must specify the frames to play, and may * also include a relative playback `speed` (ex. 2 would playback at double speed, 0.5 at half), and * the name of the `next` animation to sequence to after it completes. * * There are three formats supported for defining the frames in an animation, which can be mixed and matched as appropriate: *
    *
  1. for a single frame animation, you can simply specify the frame index * * animations: { * sit: 7 * } * *
  2. *
  3. * for an animation of consecutive frames, you can use an array with two required, and two optional entries * in the order: `start`, `end`, `next`, and `speed`. This will play the frames from start to end inclusive. * * animations: { * // start, end, next*, speed* * run: [0, 8], * jump: [9, 12, "run", 2] * } * *
  4. *
  5. * for non-consecutive frames, you can use an object with a `frames` property defining an array of frame * indexes to play in order. The object can also specify `next` and `speed` properties. * * animations: { * walk: { * frames: [1,2,3,3,2,1] * }, * shoot: { * frames: [1,4,5,6], * next: "walk", * speed: 0.5 * } * } * *
  6. *
* Note: the `speed` property was added in EaselJS 0.7.0. Earlier versions had a `frequency` * property instead, which was the inverse of `speed`. For example, a value of "4" would be 1/4 normal speed in * earlier versions, but is 4x normal speed in EaselJS 0.7.0+. * *

framerate

* Optional. Indicates the default framerate to play this spritesheet at in frames per second. See * {{#crossLink "SpriteSheet/framerate:property"}}{{/crossLink}} for more information. * * framerate: 20 * * Note that the Sprite framerate will only work if the stage update method is provided with the {{#crossLink "Ticker/tick:event"}}{{/crossLink}} * event generated by the {{#crossLink "Ticker"}}{{/crossLink}}. * * createjs.Ticker.on("tick", handleTick); * function handleTick(event) { * stage.update(event); * } * *

Example

* To define a simple sprite sheet, with a single image "sprites.jpg" arranged in a regular 50x50 grid with three * animations: "stand" showing the first frame, "run" looping frame 1-5 inclusive, and "jump" playing frame 6-8 and * sequencing back to run. * * var data = { * images: ["sprites.jpg"], * frames: {width:50, height:50}, * animations: { * stand:0, * run:[1,5], * jump:[6,8,"run"] * } * }; * var spriteSheet = new createjs.SpriteSheet(data); * var animation = new createjs.Sprite(spriteSheet, "run"); * *

Generating SpriteSheet Images

* Spritesheets can be created manually by combining images in PhotoShop, and specifying the frame size or * coordinates manually, however there are a number of tools that facilitate this. *
    *
  • Exporting SpriteSheets or HTML5 content from Adobe Flash/Animate supports the EaselJS SpriteSheet format.
  • *
  • The popular Texture Packer has * EaselJS support. *
  • SWF animations in Adobe Flash/Animate can be exported to SpriteSheets using Zoë
  • *
* *

Cross Origin Issues

* Warning: Images loaded cross-origin will throw cross-origin security errors when interacted with * using: *
    *
  • a mouse
  • *
  • methods such as {{#crossLink "Container/getObjectUnderPoint"}}{{/crossLink}}
  • *
  • Filters (see {{#crossLink "Filter"}}{{/crossLink}})
  • *
  • caching (see {{#crossLink "DisplayObject/cache"}}{{/crossLink}})
  • *
* You can get around this by setting `crossOrigin` property on your images before passing them to EaselJS, or * setting the `crossOrigin` property on PreloadJS' LoadQueue or LoadItems. * * var img = new Image(); * img.crossOrigin="Anonymous"; * img.src = "http://server-with-CORS-support.com/path/to/image.jpg"; * * If you pass string paths to SpriteSheets, they will not work cross-origin. The server that stores the image must * support cross-origin requests, or this will not work. For more information, check out * CORS overview on MDN. * * @class SpriteSheet * @constructor * @param {Object} data An object describing the SpriteSheet data. * @extends EventDispatcher **/ function SpriteSheet(data) { this.EventDispatcher_constructor(); // public properties: /** * Indicates whether all images are finished loading. * @property complete * @type Boolean * @readonly **/ this.complete = true; /** * Specifies the framerate to use by default for Sprite instances using the SpriteSheet. See the Sprite class * {{#crossLink "Sprite/framerate:property"}}{{/crossLink}} for more information. * @property framerate * @type Number **/ this.framerate = 0; // private properties: /** * @property _animations * @protected * @type Array **/ this._animations = null; /** * @property _frames * @protected * @type Array **/ this._frames = null; /** * @property _images * @protected * @type Array **/ this._images = null; /** * @property _data * @protected * @type Object **/ this._data = null; /** * @property _loadCount * @protected * @type Number **/ this._loadCount = 0; // only used for simple frame defs: /** * @property _frameHeight * @protected * @type Number **/ this._frameHeight = 0; /** * @property _frameWidth * @protected * @type Number **/ this._frameWidth = 0; /** * @property _numFrames * @protected * @type Number **/ this._numFrames = 0; /** * @property _regX * @protected * @type Number **/ this._regX = 0; /** * @property _regY * @protected * @type Number **/ this._regY = 0; /** * @property _spacing * @protected * @type Number **/ this._spacing = 0; /** * @property _margin * @protected * @type Number **/ this._margin = 0; // setup: this._parseData(data); } var p = createjs.extend(SpriteSheet, createjs.EventDispatcher); // TODO: deprecated // p.initialize = function() {}; // searchable for devs wondering where it is. REMOVED. See docs for details. // events: /** * Dispatched when all images are loaded. Note that this only fires if the images * were not fully loaded when the sprite sheet was initialized. You should check the complete property * to prior to adding a listener. Ex. * * var sheet = new createjs.SpriteSheet(data); * if (!sheet.complete) { * // not preloaded, listen for the complete event: * sheet.addEventListener("complete", handler); * } * * @event complete * @param {Object} target The object that dispatched the event. * @param {String} type The event type. * @since 0.6.0 */ /** * Dispatched when getFrame is called with a valid frame index. This is primarily intended for use by {{#crossLink "SpriteSheetBuilder"}}{{/crossLink}} * when doing on-demand rendering. * @event getframe * @param {Number} index The frame index. * @param {Object} frame The frame object that getFrame will return. */ /** * Dispatched when an image encounters an error. A SpriteSheet will dispatch an error event for each image that * encounters an error, and will still dispatch a {{#crossLink "SpriteSheet/complete:event"}}{{/crossLink}} * event once all images are finished processing, even if an error is encountered. * @event error * @param {String} src The source of the image that failed to load. * @since 0.8.2 */ // getter / setters: /** * Use the {{#crossLink "SpriteSheet/animations:property"}}{{/crossLink}} property instead. * @method _getAnimations * @protected * @return {Array} **/ p._getAnimations = function() { return this._animations.slice(); }; /** * Use the {{#crossLink "SpriteSheet/animations:property"}}{{/crossLink}} property instead. * @method getAnimations * @deprecated */ // SpriteSheet.getAnimations is @deprecated. Remove for 1.1+ p.getAnimations = createjs.deprecate(p._getAnimations, "SpriteSheet.getAnimations"); /** * Returns an array of all available animation names available on this sprite sheet as strings. * @property animations * @type {Array} * @readonly **/ try { Object.defineProperties(p, { animations: { get: p._getAnimations } }); } catch (e) {} // public methods: /** * Returns the total number of frames in the specified animation, or in the whole sprite * sheet if the animation param is omitted. Returns 0 if the spritesheet relies on calculated frame counts, and * the images have not been fully loaded. * @method getNumFrames * @param {String} animation The name of the animation to get a frame count for. * @return {Number} The number of frames in the animation, or in the entire sprite sheet if the animation param is omitted. */ p.getNumFrames = function(animation) { if (animation == null) { return this._frames ? this._frames.length : this._numFrames || 0; } else { var data = this._data[animation]; if (data == null) { return 0; } else { return data.frames.length; } } }; /** * Returns an object defining the specified animation. The returned object contains:
    *
  • frames: an array of the frame ids in the animation
  • *
  • speed: the playback speed for this animation
  • *
  • name: the name of the animation
  • *
  • next: the default animation to play next. If the animation loops, the name and next property will be the * same.
  • *
* @method getAnimation * @param {String} name The name of the animation to get. * @return {Object} a generic object with frames, speed, name, and next properties. **/ p.getAnimation = function(name) { return this._data[name]; }; /** * Returns an object specifying the image and source rect of the specified frame. The returned object has:
    *
  • an image property holding a reference to the image object in which the frame is found
  • *
  • a rect property containing a Rectangle instance which defines the boundaries for the frame within that * image.
  • *
  • A regX and regY property corresponding to the regX/Y values for the frame. *
* @method getFrame * @param {Number} frameIndex The index of the frame. * @return {Object} a generic object with image and rect properties. Returns null if the frame does not exist. **/ p.getFrame = function(frameIndex) { var frame; if (this._frames && (frame=this._frames[frameIndex])) { return frame; } return null; }; /** * Returns a {{#crossLink "Rectangle"}}{{/crossLink}} instance defining the bounds of the specified frame relative * to the origin. For example, a 90 x 70 frame with a regX of 50 and a regY of 40 would return: * * [x=-50, y=-40, width=90, height=70] * * @method getFrameBounds * @param {Number} frameIndex The index of the frame. * @param {Rectangle} [rectangle] A Rectangle instance to copy the values into. By default a new instance is created. * @return {Rectangle} A Rectangle instance. Returns null if the frame does not exist, or the image is not fully loaded. **/ p.getFrameBounds = function(frameIndex, rectangle) { var frame = this.getFrame(frameIndex); return frame ? (rectangle||new createjs.Rectangle()).setValues(-frame.regX, -frame.regY, frame.rect.width, frame.rect.height) : null; }; /** * Returns a string representation of this object. * @method toString * @return {String} a string representation of the instance. **/ p.toString = function() { return "[SpriteSheet]"; }; /** * SpriteSheet cannot be cloned. A SpriteSheet can be shared by multiple Sprite instances without cloning it. * @method clone **/ p.clone = function() { throw("SpriteSheet cannot be cloned.") }; // private methods: /** * @method _parseData * @param {Object} data An object describing the SpriteSheet data. * @protected **/ p._parseData = function(data) { var i,l,o,a; if (data == null) { return; } this.framerate = data.framerate||0; // parse images: if (data.images && (l=data.images.length) > 0) { a = this._images = []; for (i=0; i= maxFrames) { break imgLoop; } frameCount++; this._frames.push({ image: img, rect: new createjs.Rectangle(x, y, frameWidth, frameHeight), regX: this._regX, regY: this._regY }); x += frameWidth+spacing; } y += frameHeight+spacing; } } this._numFrames = frameCount; }; createjs.SpriteSheet = createjs.promote(SpriteSheet, "EventDispatcher"); }()); //############################################################################## // Graphics.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * The Graphics class exposes an easy to use API for generating vector drawing instructions and drawing them to a * specified context. Note that you can use Graphics without any dependency on the EaselJS framework by calling {{#crossLink "Graphics/draw"}}{{/crossLink}} * directly, or it can be used with the {{#crossLink "Shape"}}{{/crossLink}} object to draw vector graphics within the * context of an EaselJS display list. * * There are two approaches to working with Graphics object: calling methods on a Graphics instance (the "Graphics API"), or * instantiating Graphics command objects and adding them to the graphics queue via {{#crossLink "Graphics/append"}}{{/crossLink}}. * The former abstracts the latter, simplifying beginning and ending paths, fills, and strokes. * * var g = new createjs.Graphics(); * g.setStrokeStyle(1); * g.beginStroke("#000000"); * g.beginFill("red"); * g.drawCircle(0,0,30); * * All drawing methods in Graphics return the Graphics instance, so they can be chained together. For example, * the following line of code would generate the instructions to draw a rectangle with a red stroke and blue fill: * * myGraphics.beginStroke("red").beginFill("blue").drawRect(20, 20, 100, 50); * * Each graphics API call generates a command object (see below). The last command to be created can be accessed via * {{#crossLink "Graphics/command:property"}}{{/crossLink}}: * * var fillCommand = myGraphics.beginFill("red").command; * // ... later, update the fill style/color: * fillCommand.style = "blue"; * // or change it to a bitmap fill: * fillCommand.bitmap(myImage); * * For more direct control of rendering, you can instantiate and append command objects to the graphics queue directly. In this case, you * need to manage path creation manually, and ensure that fill/stroke is applied to a defined path: * * // start a new path. Graphics.beginCmd is a reusable BeginPath instance: * myGraphics.append(createjs.Graphics.beginCmd); * // we need to define the path before applying the fill: * var circle = new createjs.Graphics.Circle(0,0,30); * myGraphics.append(circle); * // fill the path we just defined: * var fill = new createjs.Graphics.Fill("red"); * myGraphics.append(fill); * * These approaches can be used together, for example to insert a custom command: * * myGraphics.beginFill("red"); * var customCommand = new CustomSpiralCommand(etc); * myGraphics.append(customCommand); * myGraphics.beginFill("blue"); * myGraphics.drawCircle(0, 0, 30); * * See {{#crossLink "Graphics/append"}}{{/crossLink}} for more info on creating custom commands. * *

Tiny API

* The Graphics class also includes a "tiny API", which is one or two-letter methods that are shortcuts for all of the * Graphics methods. These methods are great for creating compact instructions, and is used by the Toolkit for CreateJS * to generate readable code. All tiny methods are marked as protected, so you can view them by enabling protected * descriptions in the docs. * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
TinyMethodTinyMethod
mt{{#crossLink "Graphics/moveTo"}}{{/crossLink}} lt {{#crossLink "Graphics/lineTo"}}{{/crossLink}}
a/at{{#crossLink "Graphics/arc"}}{{/crossLink}} / {{#crossLink "Graphics/arcTo"}}{{/crossLink}} bt{{#crossLink "Graphics/bezierCurveTo"}}{{/crossLink}}
qt{{#crossLink "Graphics/quadraticCurveTo"}}{{/crossLink}} (also curveTo)r{{#crossLink "Graphics/rect"}}{{/crossLink}}
cp{{#crossLink "Graphics/closePath"}}{{/crossLink}} c{{#crossLink "Graphics/clear"}}{{/crossLink}}
f{{#crossLink "Graphics/beginFill"}}{{/crossLink}} lf{{#crossLink "Graphics/beginLinearGradientFill"}}{{/crossLink}}
rf{{#crossLink "Graphics/beginRadialGradientFill"}}{{/crossLink}} bf{{#crossLink "Graphics/beginBitmapFill"}}{{/crossLink}}
ef{{#crossLink "Graphics/endFill"}}{{/crossLink}} ss / sd{{#crossLink "Graphics/setStrokeStyle"}}{{/crossLink}} / {{#crossLink "Graphics/setStrokeDash"}}{{/crossLink}}
s{{#crossLink "Graphics/beginStroke"}}{{/crossLink}} ls{{#crossLink "Graphics/beginLinearGradientStroke"}}{{/crossLink}}
rs{{#crossLink "Graphics/beginRadialGradientStroke"}}{{/crossLink}} bs{{#crossLink "Graphics/beginBitmapStroke"}}{{/crossLink}}
es{{#crossLink "Graphics/endStroke"}}{{/crossLink}} dr{{#crossLink "Graphics/drawRect"}}{{/crossLink}}
rr{{#crossLink "Graphics/drawRoundRect"}}{{/crossLink}} rc{{#crossLink "Graphics/drawRoundRectComplex"}}{{/crossLink}}
dc{{#crossLink "Graphics/drawCircle"}}{{/crossLink}} de{{#crossLink "Graphics/drawEllipse"}}{{/crossLink}}
dp{{#crossLink "Graphics/drawPolyStar"}}{{/crossLink}} p{{#crossLink "Graphics/decodePath"}}{{/crossLink}}
* * Here is the above example, using the tiny API instead. * * myGraphics.s("red").f("blue").r(20, 20, 100, 50); * * @class Graphics * @constructor **/ function Graphics() { // public properties /** * Holds a reference to the last command that was created or appended. For example, you could retain a reference * to a Fill command in order to dynamically update the color later by using: * * var myFill = myGraphics.beginFill("red").command; * // update color later: * myFill.style = "yellow"; * * @property command * @type Object **/ this.command = null; // private properties /** * @property _stroke * @protected * @type {Stroke} **/ this._stroke = null; /** * @property _strokeStyle * @protected * @type {StrokeStyle} **/ this._strokeStyle = null; /** * @property _oldStrokeStyle * @protected * @type {StrokeStyle} **/ this._oldStrokeStyle = null; /** * @property _strokeDash * @protected * @type {StrokeDash} **/ this._strokeDash = null; /** * @property _oldStrokeDash * @protected * @type {StrokeDash} **/ this._oldStrokeDash = null; /** * @property _strokeIgnoreScale * @protected * @type Boolean **/ this._strokeIgnoreScale = false; /** * @property _fill * @protected * @type {Fill} **/ this._fill = null; /** * @property _instructions * @protected * @type {Array} **/ this._instructions = []; /** * Indicates the last instruction index that was committed. * @property _commitIndex * @protected * @type {Number} **/ this._commitIndex = 0; /** * Uncommitted instructions. * @property _activeInstructions * @protected * @type {Array} **/ this._activeInstructions = []; /** * This indicates that there have been changes to the activeInstruction list since the last updateInstructions call. * @property _dirty * @protected * @type {Boolean} * @default false **/ this._dirty = false; /** * Index to draw from if a store operation has happened. * @property _storeIndex * @protected * @type {Number} * @default 0 **/ this._storeIndex = 0; // setup: this.clear(); } var p = Graphics.prototype; var G = Graphics; // shortcut // static public methods: /** * Returns a CSS compatible color string based on the specified RGB numeric color values in the format * "rgba(255,255,255,1.0)", or if alpha is null then in the format "rgb(255,255,255)". For example, * * createjs.Graphics.getRGB(50, 100, 150, 0.5); * // Returns "rgba(50,100,150,0.5)" * * It also supports passing a single hex color value as the first param, and an optional alpha value as the second * param. For example, * * createjs.Graphics.getRGB(0xFF00FF, 0.2); * // Returns "rgba(255,0,255,0.2)" * * @method getRGB * @static * @param {Number} r The red component for the color, between 0 and 0xFF (255). * @param {Number} g The green component for the color, between 0 and 0xFF (255). * @param {Number} b The blue component for the color, between 0 and 0xFF (255). * @param {Number} [alpha] The alpha component for the color where 0 is fully transparent and 1 is fully opaque. * @return {String} A CSS compatible color string based on the specified RGB numeric color values in the format * "rgba(255,255,255,1.0)", or if alpha is null then in the format "rgb(255,255,255)". **/ Graphics.getRGB = function(r, g, b, alpha) { if (r != null && b == null) { alpha = g; b = r&0xFF; g = r>>8&0xFF; r = r>>16&0xFF; } if (alpha == null) { return "rgb("+r+","+g+","+b+")"; } else { return "rgba("+r+","+g+","+b+","+alpha+")"; } }; /** * Returns a CSS compatible color string based on the specified HSL numeric color values in the format "hsla(360,100,100,1.0)", * or if alpha is null then in the format "hsl(360,100,100)". * * createjs.Graphics.getHSL(150, 100, 70); * // Returns "hsl(150,100,70)" * * @method getHSL * @static * @param {Number} hue The hue component for the color, between 0 and 360. * @param {Number} saturation The saturation component for the color, between 0 and 100. * @param {Number} lightness The lightness component for the color, between 0 and 100. * @param {Number} [alpha] The alpha component for the color where 0 is fully transparent and 1 is fully opaque. * @return {String} A CSS compatible color string based on the specified HSL numeric color values in the format * "hsla(360,100,100,1.0)", or if alpha is null then in the format "hsl(360,100,100)". **/ Graphics.getHSL = function(hue, saturation, lightness, alpha) { if (alpha == null) { return "hsl("+(hue%360)+","+saturation+"%,"+lightness+"%)"; } else { return "hsla("+(hue%360)+","+saturation+"%,"+lightness+"%,"+alpha+")"; } }; // static properties: /** * A reusable instance of {{#crossLink "Graphics.BeginPath"}}{{/crossLink}} to avoid * unnecessary instantiation. * @property beginCmd * @type {Graphics.BeginPath} * @static **/ // defined at the bottom of this file. /** * Map of Base64 characters to values. Used by {{#crossLink "Graphics/decodePath"}}{{/crossLink}}. * @property BASE_64 * @static * @final * @readonly * @type {Object} **/ Graphics.BASE_64 = {"A":0,"B":1,"C":2,"D":3,"E":4,"F":5,"G":6,"H":7,"I":8,"J":9,"K":10,"L":11,"M":12,"N":13,"O":14,"P":15,"Q":16,"R":17,"S":18,"T":19,"U":20,"V":21,"W":22,"X":23,"Y":24,"Z":25,"a":26,"b":27,"c":28,"d":29,"e":30,"f":31,"g":32,"h":33,"i":34,"j":35,"k":36,"l":37,"m":38,"n":39,"o":40,"p":41,"q":42,"r":43,"s":44,"t":45,"u":46,"v":47,"w":48,"x":49,"y":50,"z":51,"0":52,"1":53,"2":54,"3":55,"4":56,"5":57,"6":58,"7":59,"8":60,"9":61,"+":62,"/":63}; /** * Maps numeric values for the caps parameter of {{#crossLink "Graphics/setStrokeStyle"}}{{/crossLink}} to * corresponding string values. This is primarily for use with the tiny API. The mappings are as follows: 0 to * "butt", 1 to "round", and 2 to "square". * For example, to set the line caps to "square": * * myGraphics.ss(16, 2); * * @property STROKE_CAPS_MAP * @static * @final * @readonly * @type {Array} **/ Graphics.STROKE_CAPS_MAP = ["butt", "round", "square"]; /** * Maps numeric values for the joints parameter of {{#crossLink "Graphics/setStrokeStyle"}}{{/crossLink}} to * corresponding string values. This is primarily for use with the tiny API. The mappings are as follows: 0 to * "miter", 1 to "round", and 2 to "bevel". * For example, to set the line joints to "bevel": * * myGraphics.ss(16, 0, 2); * * @property STROKE_JOINTS_MAP * @static * @final * @readonly * @type {Array} **/ Graphics.STROKE_JOINTS_MAP = ["miter", "round", "bevel"]; /** * @property _ctx * @static * @protected * @type {CanvasRenderingContext2D} **/ var canvas = (createjs.createCanvas?createjs.createCanvas():document.createElement("canvas")); if (canvas.getContext) { Graphics._ctx = canvas.getContext("2d"); canvas.width = canvas.height = 1; } // getter / setters: /** * Use the {{#crossLink "Graphics/instructions:property"}}{{/crossLink}} property instead. * @method _getInstructions * @protected * @return {Array} The instructions array, useful for chaining **/ p._getInstructions = function() { this._updateInstructions(); return this._instructions; }; /** * Use the {{#crossLink "Graphics/instructions:property"}}{{/crossLink}} property instead. * @method getInstructions * @deprecated */ // Graphics.getInstructions is @deprecated. Remove for 1.1+ p.getInstructions = createjs.deprecate(p._getInstructions, "Graphics.getInstructions"); /** * Returns the graphics instructions array. Each entry is a graphics command object (ex. Graphics.Fill, Graphics.Rect) * Modifying the returned array directly is not recommended, and is likely to result in unexpected behaviour. * * This property is mainly intended for introspection of the instructions (ex. for graphics export). * @property instructions * @type {Array} * @readonly **/ try { Object.defineProperties(p, { instructions: { get: p._getInstructions } }); } catch (e) {} // public methods: /** * Returns true if this Graphics instance has no drawing commands. * @method isEmpty * @return {Boolean} Returns true if this Graphics instance has no drawing commands. **/ p.isEmpty = function() { return !(this._instructions.length || this._activeInstructions.length); }; /** * Draws the display object into the specified context ignoring its visible, alpha, shadow, and transform. * Returns true if the draw was handled (useful for overriding functionality). * * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method draw * @param {CanvasRenderingContext2D} ctx The canvas 2D context object to draw into. * @param {Object} data Optional data that is passed to graphics command exec methods. When called from a Shape instance, the shape passes itself as the data parameter. This can be used by custom graphic commands to insert contextual data. **/ p.draw = function(ctx, data) { this._updateInstructions(); var instr = this._instructions; for (var i=this._storeIndex, l=instr.length; iDisplayObject.mask to draw the clipping path, for example. * * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method drawAsPath * @param {CanvasRenderingContext2D} ctx The canvas 2D context object to draw into. **/ p.drawAsPath = function(ctx) { this._updateInstructions(); var instr, instrs = this._instructions; for (var i=this._storeIndex, l=instrs.length; i * whatwg spec. * @method lineTo * @param {Number} x The x coordinate the drawing point should draw to. * @param {Number} y The y coordinate the drawing point should draw to. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.lineTo = function(x, y) { return this.append(new G.LineTo(x,y)); }; /** * Draws an arc with the specified control points and radius. For detailed information, read the * * whatwg spec. A tiny API method "at" also exists. * @method arcTo * @param {Number} x1 * @param {Number} y1 * @param {Number} x2 * @param {Number} y2 * @param {Number} radius * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.arcTo = function(x1, y1, x2, y2, radius) { return this.append(new G.ArcTo(x1, y1, x2, y2, radius)); }; /** * Draws an arc defined by the radius, startAngle and endAngle arguments, centered at the position (x, y). For * example, to draw a full circle with a radius of 20 centered at (100, 100): * * arc(100, 100, 20, 0, Math.PI*2); * * For detailed information, read the * whatwg spec. * A tiny API method "a" also exists. * @method arc * @param {Number} x * @param {Number} y * @param {Number} radius * @param {Number} startAngle Measured in radians. * @param {Number} endAngle Measured in radians. * @param {Boolean} anticlockwise * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.arc = function(x, y, radius, startAngle, endAngle, anticlockwise) { return this.append(new G.Arc(x, y, radius, startAngle, endAngle, anticlockwise)); }; /** * Draws a quadratic curve from the current drawing point to (x, y) using the control point (cpx, cpy). For detailed * information, read the * whatwg spec. A tiny API method "qt" also exists. * @method quadraticCurveTo * @param {Number} cpx * @param {Number} cpy * @param {Number} x * @param {Number} y * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.quadraticCurveTo = function(cpx, cpy, x, y) { return this.append(new G.QuadraticCurveTo(cpx, cpy, x, y)); }; /** * Draws a bezier curve from the current drawing point to (x, y) using the control points (cp1x, cp1y) and (cp2x, * cp2y). For detailed information, read the * * whatwg spec. A tiny API method "bt" also exists. * @method bezierCurveTo * @param {Number} cp1x * @param {Number} cp1y * @param {Number} cp2x * @param {Number} cp2y * @param {Number} x * @param {Number} y * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.bezierCurveTo = function(cp1x, cp1y, cp2x, cp2y, x, y) { return this.append(new G.BezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y)); }; /** * Draws a rectangle at (x, y) with the specified width and height using the current fill and/or stroke. * For detailed information, read the * * whatwg spec. A tiny API method "r" also exists. * @method rect * @param {Number} x * @param {Number} y * @param {Number} w Width of the rectangle * @param {Number} h Height of the rectangle * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.rect = function(x, y, w, h) { return this.append(new G.Rect(x, y, w, h)); }; /** * Closes the current path, effectively drawing a line from the current drawing point to the first drawing point specified * since the fill or stroke was last set. A tiny API method "cp" also exists. * @method closePath * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.closePath = function() { return this._activeInstructions.length ? this.append(new G.ClosePath()) : this; }; // public methods that roughly map to Adobe Flash/Animate graphics APIs: /** * Clears all drawing instructions, effectively resetting this Graphics instance. Any line and fill styles will need * to be redefined to draw shapes following a clear call. A tiny API method "c" also exists. * @method clear * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.clear = function() { this._instructions.length = this._activeInstructions.length = this._commitIndex = 0; this._strokeStyle = this._oldStrokeStyle = this._stroke = this._fill = this._strokeDash = this._oldStrokeDash = null; this._dirty = this._strokeIgnoreScale = false; return this; }; /** * Begins a fill with the specified color. This ends the current sub-path. A tiny API method "f" also exists. * @method beginFill * @param {String} color A CSS compatible color value (ex. "red", "#FF0000", or "rgba(255,0,0,0.5)"). Setting to * null will result in no fill. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.beginFill = function(color) { return this._setFill(color ? new G.Fill(color) : null); }; /** * Begins a linear gradient fill defined by the line (x0, y0) to (x1, y1). This ends the current sub-path. For * example, the following code defines a black to white vertical gradient ranging from 20px to 120px, and draws a * square to display it: * * myGraphics.beginLinearGradientFill(["#000","#FFF"], [0, 1], 0, 20, 0, 120).drawRect(20, 20, 120, 120); * * A tiny API method "lf" also exists. * @method beginLinearGradientFill * @param {Array} colors An array of CSS compatible color values. For example, ["#F00","#00F"] would define a gradient * drawing from red to blue. * @param {Array} ratios An array of gradient positions which correspond to the colors. For example, [0.1, 0.9] would draw * the first color to 10% then interpolating to the second color at 90%. * @param {Number} x0 The position of the first point defining the line that defines the gradient direction and size. * @param {Number} y0 The position of the first point defining the line that defines the gradient direction and size. * @param {Number} x1 The position of the second point defining the line that defines the gradient direction and size. * @param {Number} y1 The position of the second point defining the line that defines the gradient direction and size. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.beginLinearGradientFill = function(colors, ratios, x0, y0, x1, y1) { return this._setFill(new G.Fill().linearGradient(colors, ratios, x0, y0, x1, y1)); }; /** * Begins a radial gradient fill. This ends the current sub-path. For example, the following code defines a red to * blue radial gradient centered at (100, 100), with a radius of 50, and draws a circle to display it: * * myGraphics.beginRadialGradientFill(["#F00","#00F"], [0, 1], 100, 100, 0, 100, 100, 50).drawCircle(100, 100, 50); * * A tiny API method "rf" also exists. * @method beginRadialGradientFill * @param {Array} colors An array of CSS compatible color values. For example, ["#F00","#00F"] would define * a gradient drawing from red to blue. * @param {Array} ratios An array of gradient positions which correspond to the colors. For example, [0.1, * 0.9] would draw the first color to 10% then interpolating to the second color at 90%. * @param {Number} x0 Center position of the inner circle that defines the gradient. * @param {Number} y0 Center position of the inner circle that defines the gradient. * @param {Number} r0 Radius of the inner circle that defines the gradient. * @param {Number} x1 Center position of the outer circle that defines the gradient. * @param {Number} y1 Center position of the outer circle that defines the gradient. * @param {Number} r1 Radius of the outer circle that defines the gradient. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.beginRadialGradientFill = function(colors, ratios, x0, y0, r0, x1, y1, r1) { return this._setFill(new G.Fill().radialGradient(colors, ratios, x0, y0, r0, x1, y1, r1)); }; /** * Begins a pattern fill using the specified image. This ends the current sub-path. A tiny API method "bf" also * exists. * @method beginBitmapFill * @param {HTMLImageElement | HTMLCanvasElement | HTMLVideoElement} image The Image, Canvas, or Video object to use * as the pattern. Must be loaded prior to creating a bitmap fill, or the fill will be empty. * @param {String} repetition Optional. Indicates whether to repeat the image in the fill area. One of "repeat", * "repeat-x", "repeat-y", or "no-repeat". Defaults to "repeat". Note that Firefox does not support "repeat-x" or * "repeat-y" (latest tests were in FF 20.0), and will default to "repeat". * @param {Matrix2D} matrix Optional. Specifies a transformation matrix for the bitmap fill. This transformation * will be applied relative to the parent transform. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.beginBitmapFill = function(image, repetition, matrix) { return this._setFill(new G.Fill(null,matrix).bitmap(image, repetition)); }; /** * Ends the current sub-path, and begins a new one with no fill. Functionally identical to beginFill(null). * A tiny API method "ef" also exists. * @method endFill * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.endFill = function() { return this.beginFill(); }; /** * Sets the stroke style. Like all drawing methods, this can be chained, so you can define * the stroke style and color in a single line of code like so: * * myGraphics.setStrokeStyle(8,"round").beginStroke("#F00"); * * A tiny API method "ss" also exists. * @method setStrokeStyle * @param {Number} thickness The width of the stroke. * @param {String | Number} [caps=0] Indicates the type of caps to use at the end of lines. One of butt, * round, or square. Defaults to "butt". Also accepts the values 0 (butt), 1 (round), and 2 (square) for use with * the tiny API. * @param {String | Number} [joints=0] Specifies the type of joints that should be used where two lines meet. * One of bevel, round, or miter. Defaults to "miter". Also accepts the values 0 (miter), 1 (round), and 2 (bevel) * for use with the tiny API. * @param {Number} [miterLimit=10] If joints is set to "miter", then you can specify a miter limit ratio which * controls at what point a mitered joint will be clipped. * @param {Boolean} [ignoreScale=false] If true, the stroke will be drawn at the specified thickness regardless * of active transformations. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.setStrokeStyle = function(thickness, caps, joints, miterLimit, ignoreScale) { this._updateInstructions(true); this._strokeStyle = this.command = new G.StrokeStyle(thickness, caps, joints, miterLimit, ignoreScale); // ignoreScale lives on Stroke, not StrokeStyle, so we do a little trickery: if (this._stroke) { this._stroke.ignoreScale = ignoreScale; } this._strokeIgnoreScale = ignoreScale; return this; }; /** * Sets or clears the stroke dash pattern. * * myGraphics.setStrokeDash([20, 10], 0); * * A tiny API method `sd` also exists. * @method setStrokeDash * @param {Array} [segments] An array specifying the dash pattern, alternating between line and gap. * For example, `[20,10]` would create a pattern of 20 pixel lines with 10 pixel gaps between them. * Passing null or an empty array will clear the existing stroke dash. * @param {Number} [offset=0] The offset of the dash pattern. For example, you could increment this value to create a "marching ants" effect. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.setStrokeDash = function(segments, offset) { this._updateInstructions(true); this._strokeDash = this.command = new G.StrokeDash(segments, offset); return this; }; /** * Begins a stroke with the specified color. This ends the current sub-path. A tiny API method "s" also exists. * @method beginStroke * @param {String} color A CSS compatible color value (ex. "#FF0000", "red", or "rgba(255,0,0,0.5)"). Setting to * null will result in no stroke. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.beginStroke = function(color) { return this._setStroke(color ? new G.Stroke(color) : null); }; /** * Begins a linear gradient stroke defined by the line (x0, y0) to (x1, y1). This ends the current sub-path. For * example, the following code defines a black to white vertical gradient ranging from 20px to 120px, and draws a * square to display it: * * myGraphics.setStrokeStyle(10). * beginLinearGradientStroke(["#000","#FFF"], [0, 1], 0, 20, 0, 120).drawRect(20, 20, 120, 120); * * A tiny API method "ls" also exists. * @method beginLinearGradientStroke * @param {Array} colors An array of CSS compatible color values. For example, ["#F00","#00F"] would define * a gradient drawing from red to blue. * @param {Array} ratios An array of gradient positions which correspond to the colors. For example, [0.1, * 0.9] would draw the first color to 10% then interpolating to the second color at 90%. * @param {Number} x0 The position of the first point defining the line that defines the gradient direction and size. * @param {Number} y0 The position of the first point defining the line that defines the gradient direction and size. * @param {Number} x1 The position of the second point defining the line that defines the gradient direction and size. * @param {Number} y1 The position of the second point defining the line that defines the gradient direction and size. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.beginLinearGradientStroke = function(colors, ratios, x0, y0, x1, y1) { return this._setStroke(new G.Stroke().linearGradient(colors, ratios, x0, y0, x1, y1)); }; /** * Begins a radial gradient stroke. This ends the current sub-path. For example, the following code defines a red to * blue radial gradient centered at (100, 100), with a radius of 50, and draws a rectangle to display it: * * myGraphics.setStrokeStyle(10) * .beginRadialGradientStroke(["#F00","#00F"], [0, 1], 100, 100, 0, 100, 100, 50) * .drawRect(50, 90, 150, 110); * * A tiny API method "rs" also exists. * @method beginRadialGradientStroke * @param {Array} colors An array of CSS compatible color values. For example, ["#F00","#00F"] would define * a gradient drawing from red to blue. * @param {Array} ratios An array of gradient positions which correspond to the colors. For example, [0.1, * 0.9] would draw the first color to 10% then interpolating to the second color at 90%, then draw the second color * to 100%. * @param {Number} x0 Center position of the inner circle that defines the gradient. * @param {Number} y0 Center position of the inner circle that defines the gradient. * @param {Number} r0 Radius of the inner circle that defines the gradient. * @param {Number} x1 Center position of the outer circle that defines the gradient. * @param {Number} y1 Center position of the outer circle that defines the gradient. * @param {Number} r1 Radius of the outer circle that defines the gradient. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.beginRadialGradientStroke = function(colors, ratios, x0, y0, r0, x1, y1, r1) { return this._setStroke(new G.Stroke().radialGradient(colors, ratios, x0, y0, r0, x1, y1, r1)); }; /** * Begins a pattern fill using the specified image. This ends the current sub-path. Note that unlike bitmap fills, * strokes do not currently support a matrix parameter due to limitations in the canvas API. A tiny API method "bs" * also exists. * @method beginBitmapStroke * @param {HTMLImageElement | HTMLCanvasElement | HTMLVideoElement} image The Image, Canvas, or Video object to use * as the pattern. Must be loaded prior to creating a bitmap fill, or the fill will be empty. * @param {String} [repetition=repeat] Optional. Indicates whether to repeat the image in the fill area. One of * "repeat", "repeat-x", "repeat-y", or "no-repeat". Defaults to "repeat". * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.beginBitmapStroke = function(image, repetition) { // NOTE: matrix is not supported for stroke because transforms on strokes also affect the drawn stroke width. return this._setStroke(new G.Stroke().bitmap(image, repetition)); }; /** * Ends the current sub-path, and begins a new one with no stroke. Functionally identical to beginStroke(null). * A tiny API method "es" also exists. * @method endStroke * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.endStroke = function() { return this.beginStroke(); }; /** * Maps the familiar ActionScript curveTo() method to the functionally similar {{#crossLink "Graphics/quadraticCurveTo"}}{{/crossLink}} * method. * @method curveTo * @param {Number} cpx * @param {Number} cpy * @param {Number} x * @param {Number} y * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.curveTo = p.quadraticCurveTo; /** * * Maps the familiar ActionScript drawRect() method to the functionally similar {{#crossLink "Graphics/rect"}}{{/crossLink}} * method. * @method drawRect * @param {Number} x * @param {Number} y * @param {Number} w Width of the rectangle * @param {Number} h Height of the rectangle * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.drawRect = p.rect; /** * Draws a rounded rectangle with all corners with the specified radius. * @method drawRoundRect * @param {Number} x * @param {Number} y * @param {Number} w * @param {Number} h * @param {Number} radius Corner radius. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.drawRoundRect = function(x, y, w, h, radius) { return this.drawRoundRectComplex(x, y, w, h, radius, radius, radius, radius); }; /** * Draws a rounded rectangle with different corner radii. Supports positive and negative corner radii. A tiny API * method "rc" also exists. * @method drawRoundRectComplex * @param {Number} x The horizontal coordinate to draw the round rect. * @param {Number} y The vertical coordinate to draw the round rect. * @param {Number} w The width of the round rect. * @param {Number} h The height of the round rect. * @param {Number} radiusTL Top left corner radius. * @param {Number} radiusTR Top right corner radius. * @param {Number} radiusBR Bottom right corner radius. * @param {Number} radiusBL Bottom left corner radius. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.drawRoundRectComplex = function(x, y, w, h, radiusTL, radiusTR, radiusBR, radiusBL) { return this.append(new G.RoundRect(x, y, w, h, radiusTL, radiusTR, radiusBR, radiusBL)); }; /** * Draws a circle with the specified radius at (x, y). * * var g = new createjs.Graphics(); * g.setStrokeStyle(1); * g.beginStroke(createjs.Graphics.getRGB(0,0,0)); * g.beginFill(createjs.Graphics.getRGB(255,0,0)); * g.drawCircle(0,0,3); * * var s = new createjs.Shape(g); * s.x = 100; * s.y = 100; * * stage.addChild(s); * stage.update(); * * A tiny API method "dc" also exists. * @method drawCircle * @param {Number} x x coordinate center point of circle. * @param {Number} y y coordinate center point of circle. * @param {Number} radius Radius of circle. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.drawCircle = function(x, y, radius) { return this.append(new G.Circle(x, y, radius)); }; /** * Draws an ellipse (oval) with a specified width (w) and height (h). Similar to {{#crossLink "Graphics/drawCircle"}}{{/crossLink}}, * except the width and height can be different. A tiny API method "de" also exists. * @method drawEllipse * @param {Number} x The left coordinate point of the ellipse. Note that this is different from {{#crossLink "Graphics/drawCircle"}}{{/crossLink}} * which draws from center. * @param {Number} y The top coordinate point of the ellipse. Note that this is different from {{#crossLink "Graphics/drawCircle"}}{{/crossLink}} * which draws from the center. * @param {Number} w The height (horizontal diameter) of the ellipse. The horizontal radius will be half of this * number. * @param {Number} h The width (vertical diameter) of the ellipse. The vertical radius will be half of this number. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.drawEllipse = function(x, y, w, h) { return this.append(new G.Ellipse(x, y, w, h)); }; /** * Draws a star if pointSize is greater than 0, or a regular polygon if pointSize is 0 with the specified number of * points. For example, the following code will draw a familiar 5 pointed star shape centered at 100, 100 and with a * radius of 50: * * myGraphics.beginFill("#FF0").drawPolyStar(100, 100, 50, 5, 0.6, -90); * // Note: -90 makes the first point vertical * * A tiny API method "dp" also exists. * * @method drawPolyStar * @param {Number} x Position of the center of the shape. * @param {Number} y Position of the center of the shape. * @param {Number} radius The outer radius of the shape. * @param {Number} sides The number of points on the star or sides on the polygon. * @param {Number} pointSize The depth or "pointy-ness" of the star points. A pointSize of 0 will draw a regular * polygon (no points), a pointSize of 1 will draw nothing because the points are infinitely pointy. * @param {Number} angle The angle of the first point / corner. For example a value of 0 will draw the first point * directly to the right of the center. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.drawPolyStar = function(x, y, radius, sides, pointSize, angle) { return this.append(new G.PolyStar(x, y, radius, sides, pointSize, angle)); }; /** * Appends a graphics command object to the graphics queue. Command objects expose an "exec" method * that accepts two parameters: the Context2D to operate on, and an arbitrary data object passed into * {{#crossLink "Graphics/draw"}}{{/crossLink}}. The latter will usually be the Shape instance that called draw. * * This method is used internally by Graphics methods, such as drawCircle, but can also be used directly to insert * built-in or custom graphics commands. For example: * * // attach data to our shape, so we can access it during the draw: * myShape.color = "red"; * * // append a Circle command object: * myShape.graphics.append(new createjs.Graphics.Circle(50, 50, 30)); * * // append a custom command object with an exec method that sets the fill style * // based on the shape's data, and then fills the circle. * myShape.graphics.append({exec:function(ctx, shape) { * ctx.fillStyle = shape.color; * ctx.fill(); * }}); * * @method append * @param {Object} command A graphics command object exposing an "exec" method. * @param {boolean} clean The clean param is primarily for internal use. A value of true indicates that a command does not generate a path that should be stroked or filled. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.append = function(command, clean) { this._activeInstructions.push(command); this.command = command; if (!clean) { this._dirty = true; } return this; }; /** * Decodes a compact encoded path string into a series of draw instructions. * This format is not intended to be human readable, and is meant for use by authoring tools. * The format uses a base64 character set, with each character representing 6 bits, to define a series of draw * commands. * * Each command is comprised of a single "header" character followed by a variable number of alternating x and y * position values. Reading the header bits from left to right (most to least significant): bits 1 to 3 specify the * type of operation (0-moveTo, 1-lineTo, 2-quadraticCurveTo, 3-bezierCurveTo, 4-closePath, 5-7 unused). Bit 4 * indicates whether position values use 12 bits (2 characters) or 18 bits (3 characters), with a one indicating the * latter. Bits 5 and 6 are currently unused. * * Following the header is a series of 0 (closePath), 2 (moveTo, lineTo), 4 (quadraticCurveTo), or 6 (bezierCurveTo) * parameters. These parameters are alternating x/y positions represented by 2 or 3 characters (as indicated by the * 4th bit in the command char). These characters consist of a 1 bit sign (1 is negative, 0 is positive), followed * by an 11 (2 char) or 17 (3 char) bit integer value. All position values are in tenths of a pixel. Except in the * case of move operations which are absolute, this value is a delta from the previous x or y position (as * appropriate). * * For example, the string "A3cAAMAu4AAA" represents a line starting at -150,0 and ending at 150,0. *
A - bits 000000. First 3 bits (000) indicate a moveTo operation. 4th bit (0) indicates 2 chars per * parameter. *
n0 - 110111011100. Absolute x position of -150.0px. First bit indicates a negative value, remaining bits * indicate 1500 tenths of a pixel. *
AA - 000000000000. Absolute y position of 0. *
I - 001100. First 3 bits (001) indicate a lineTo operation. 4th bit (1) indicates 3 chars per parameter. *
Au4 - 000000101110111000. An x delta of 300.0px, which is added to the previous x value of -150.0px to * provide an absolute position of +150.0px. *
AAA - 000000000000000000. A y delta value of 0. * * A tiny API method "p" also exists. * @method decodePath * @param {String} str The path string to decode. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.decodePath = function(str) { var instructions = [this.moveTo, this.lineTo, this.quadraticCurveTo, this.bezierCurveTo, this.closePath]; var paramCount = [2, 2, 4, 6, 0]; var i=0, l=str.length; var params = []; var x=0, y=0; var base64 = Graphics.BASE_64; while (i>3; // highest order bits 1-3 code for operation. var f = instructions[fi]; // check that we have a valid instruction & that the unused bits are empty: if (!f || (n&3)) { throw("bad path data (@"+i+"): "+c); } var pl = paramCount[fi]; if (!fi) { x=y=0; } // move operations reset the position. params.length = 0; i++; var charCount = (n>>2&1)+2; // 4th header bit indicates number size for this operation. for (var p=0; p>5) ? -1 : 1; num = ((num&31)<<6)|(base64[str.charAt(i+1)]); if (charCount == 3) { num = (num<<6)|(base64[str.charAt(i+2)]); } num = sign*num/10; if (p%2) { x = (num += x); } else { y = (num += y); } params[p] = num; i += charCount; } f.apply(this,params); } return this; }; /** * Stores all graphics commands so they won't be executed in future draws. Calling store() a second time adds to * the existing store. This also affects `drawAsPath()`. * * This is useful in cases where you are creating vector graphics in an iterative manner (ex. generative art), so * that only new graphics need to be drawn (which can provide huge performance benefits), but you wish to retain all * of the vector instructions for later use (ex. scaling, modifying, or exporting). * * Note that calling store() will force the active path (if any) to be ended in a manner similar to changing * the fill or stroke. * * For example, consider a application where the user draws lines with the mouse. As each line segment (or collection of * segments) are added to a Shape, it can be rasterized using {{#crossLink "DisplayObject/updateCache"}}{{/crossLink}}, * and then stored, so that it can be redrawn at a different scale when the application is resized, or exported to SVG. * * // set up cache: * myShape.cache(0,0,500,500,scale); * * // when the user drags, draw a new line: * myShape.graphics.moveTo(oldX,oldY).lineTo(newX,newY); * // then draw it into the existing cache: * myShape.updateCache("source-over"); * // store the new line, so it isn't redrawn next time: * myShape.store(); * * // then, when the window resizes, we can re-render at a different scale: * // first, unstore all our lines: * myShape.unstore(); * // then cache using the new scale: * myShape.cache(0,0,500,500,newScale); * // finally, store the existing commands again: * myShape.store(); * * @method store * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.store = function() { this._updateInstructions(true); this._storeIndex = this._instructions.length; return this; }; /** * Unstores any graphics commands that were previously stored using {{#crossLink "Graphics/store"}}{{/crossLink}} * so that they will be executed in subsequent draw calls. * * @method unstore * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable **/ p.unstore = function() { this._storeIndex = 0; return this; }; /** * Returns a clone of this Graphics instance. Note that the individual command objects are not cloned. * @method clone * @return {Graphics} A clone of the current Graphics instance. **/ p.clone = function() { var o = new Graphics(); o.command = this.command; o._stroke = this._stroke; o._strokeStyle = this._strokeStyle; o._strokeDash = this._strokeDash; o._strokeIgnoreScale = this._strokeIgnoreScale; o._fill = this._fill; o._instructions = this._instructions.slice(); o._commitIndex = this._commitIndex; o._activeInstructions = this._activeInstructions.slice(); o._dirty = this._dirty; o._storeIndex = this._storeIndex; return o; }; /** * Returns a string representation of this object. * @method toString * @return {String} a string representation of the instance. **/ p.toString = function() { return "[Graphics]"; }; // tiny API: /** * Shortcut to moveTo. * @method mt * @param {Number} x The x coordinate the drawing point should move to. * @param {Number} y The y coordinate the drawing point should move to. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls). * @chainable * @protected **/ p.mt = p.moveTo; /** * Shortcut to lineTo. * @method lt * @param {Number} x The x coordinate the drawing point should draw to. * @param {Number} y The y coordinate the drawing point should draw to. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.lt = p.lineTo; /** * Shortcut to arcTo. * @method at * @param {Number} x1 * @param {Number} y1 * @param {Number} x2 * @param {Number} y2 * @param {Number} radius * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.at = p.arcTo; /** * Shortcut to bezierCurveTo. * @method bt * @param {Number} cp1x * @param {Number} cp1y * @param {Number} cp2x * @param {Number} cp2y * @param {Number} x * @param {Number} y * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.bt = p.bezierCurveTo; /** * Shortcut to quadraticCurveTo / curveTo. * @method qt * @param {Number} cpx * @param {Number} cpy * @param {Number} x * @param {Number} y * @protected * @chainable **/ p.qt = p.quadraticCurveTo; /** * Shortcut to arc. * @method a * @param {Number} x * @param {Number} y * @param {Number} radius * @param {Number} startAngle Measured in radians. * @param {Number} endAngle Measured in radians. * @param {Boolean} anticlockwise * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @protected * @chainable **/ p.a = p.arc; /** * Shortcut to rect. * @method r * @param {Number} x * @param {Number} y * @param {Number} w Width of the rectangle * @param {Number} h Height of the rectangle * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.r = p.rect; /** * Shortcut to closePath. * @method cp * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.cp = p.closePath; /** * Shortcut to clear. * @method c * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.c = p.clear; /** * Shortcut to beginFill. * @method f * @param {String} color A CSS compatible color value (ex. "red", "#FF0000", or "rgba(255,0,0,0.5)"). Setting to * null will result in no fill. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.f = p.beginFill; /** * Shortcut to beginLinearGradientFill. * @method lf * @param {Array} colors An array of CSS compatible color values. For example, ["#F00","#00F"] would define a gradient * drawing from red to blue. * @param {Array} ratios An array of gradient positions which correspond to the colors. For example, [0.1, 0.9] would draw * the first color to 10% then interpolating to the second color at 90%. * @param {Number} x0 The position of the first point defining the line that defines the gradient direction and size. * @param {Number} y0 The position of the first point defining the line that defines the gradient direction and size. * @param {Number} x1 The position of the second point defining the line that defines the gradient direction and size. * @param {Number} y1 The position of the second point defining the line that defines the gradient direction and size. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.lf = p.beginLinearGradientFill; /** * Shortcut to beginRadialGradientFill. * @method rf * @param {Array} colors An array of CSS compatible color values. For example, ["#F00","#00F"] would define * a gradient drawing from red to blue. * @param {Array} ratios An array of gradient positions which correspond to the colors. For example, [0.1, * 0.9] would draw the first color to 10% then interpolating to the second color at 90%. * @param {Number} x0 Center position of the inner circle that defines the gradient. * @param {Number} y0 Center position of the inner circle that defines the gradient. * @param {Number} r0 Radius of the inner circle that defines the gradient. * @param {Number} x1 Center position of the outer circle that defines the gradient. * @param {Number} y1 Center position of the outer circle that defines the gradient. * @param {Number} r1 Radius of the outer circle that defines the gradient. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.rf = p.beginRadialGradientFill; /** * Shortcut to beginBitmapFill. * @method bf * @param {HTMLImageElement | HTMLCanvasElement | HTMLVideoElement} image The Image, Canvas, or Video object to use * as the pattern. * @param {String} repetition Optional. Indicates whether to repeat the image in the fill area. One of "repeat", * "repeat-x", "repeat-y", or "no-repeat". Defaults to "repeat". Note that Firefox does not support "repeat-x" or * "repeat-y" (latest tests were in FF 20.0), and will default to "repeat". * @param {Matrix2D} matrix Optional. Specifies a transformation matrix for the bitmap fill. This transformation * will be applied relative to the parent transform. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.bf = p.beginBitmapFill; /** * Shortcut to endFill. * @method ef * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.ef = p.endFill; /** * Shortcut to setStrokeStyle. * @method ss * @param {Number} thickness The width of the stroke. * @param {String | Number} [caps=0] Indicates the type of caps to use at the end of lines. One of butt, * round, or square. Defaults to "butt". Also accepts the values 0 (butt), 1 (round), and 2 (square) for use with * the tiny API. * @param {String | Number} [joints=0] Specifies the type of joints that should be used where two lines meet. * One of bevel, round, or miter. Defaults to "miter". Also accepts the values 0 (miter), 1 (round), and 2 (bevel) * for use with the tiny API. * @param {Number} [miterLimit=10] If joints is set to "miter", then you can specify a miter limit ratio which * controls at what point a mitered joint will be clipped. * @param {Boolean} [ignoreScale=false] If true, the stroke will be drawn at the specified thickness regardless * of active transformations. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.ss = p.setStrokeStyle; /** * Shortcut to setStrokeDash. * @method sd * @param {Array} [segments] An array specifying the dash pattern, alternating between line and gap. * For example, [20,10] would create a pattern of 20 pixel lines with 10 pixel gaps between them. * Passing null or an empty array will clear any existing dash. * @param {Number} [offset=0] The offset of the dash pattern. For example, you could increment this value to create a "marching ants" effect. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.sd = p.setStrokeDash; /** * Shortcut to beginStroke. * @method s * @param {String} color A CSS compatible color value (ex. "#FF0000", "red", or "rgba(255,0,0,0.5)"). Setting to * null will result in no stroke. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.s = p.beginStroke; /** * Shortcut to beginLinearGradientStroke. * @method ls * @param {Array} colors An array of CSS compatible color values. For example, ["#F00","#00F"] would define * a gradient drawing from red to blue. * @param {Array} ratios An array of gradient positions which correspond to the colors. For example, [0.1, * 0.9] would draw the first color to 10% then interpolating to the second color at 90%. * @param {Number} x0 The position of the first point defining the line that defines the gradient direction and size. * @param {Number} y0 The position of the first point defining the line that defines the gradient direction and size. * @param {Number} x1 The position of the second point defining the line that defines the gradient direction and size. * @param {Number} y1 The position of the second point defining the line that defines the gradient direction and size. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.ls = p.beginLinearGradientStroke; /** * Shortcut to beginRadialGradientStroke. * @method rs * @param {Array} colors An array of CSS compatible color values. For example, ["#F00","#00F"] would define * a gradient drawing from red to blue. * @param {Array} ratios An array of gradient positions which correspond to the colors. For example, [0.1, * 0.9] would draw the first color to 10% then interpolating to the second color at 90%, then draw the second color * to 100%. * @param {Number} x0 Center position of the inner circle that defines the gradient. * @param {Number} y0 Center position of the inner circle that defines the gradient. * @param {Number} r0 Radius of the inner circle that defines the gradient. * @param {Number} x1 Center position of the outer circle that defines the gradient. * @param {Number} y1 Center position of the outer circle that defines the gradient. * @param {Number} r1 Radius of the outer circle that defines the gradient. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.rs = p.beginRadialGradientStroke; /** * Shortcut to beginBitmapStroke. * @method bs * @param {HTMLImageElement | HTMLCanvasElement | HTMLVideoElement} image The Image, Canvas, or Video object to use * as the pattern. * @param {String} [repetition=repeat] Optional. Indicates whether to repeat the image in the fill area. One of * "repeat", "repeat-x", "repeat-y", or "no-repeat". Defaults to "repeat". * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.bs = p.beginBitmapStroke; /** * Shortcut to endStroke. * @method es * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.es = p.endStroke; /** * Shortcut to drawRect. * @method dr * @param {Number} x * @param {Number} y * @param {Number} w Width of the rectangle * @param {Number} h Height of the rectangle * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.dr = p.drawRect; /** * Shortcut to drawRoundRect. * @method rr * @param {Number} x * @param {Number} y * @param {Number} w * @param {Number} h * @param {Number} radius Corner radius. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.rr = p.drawRoundRect; /** * Shortcut to drawRoundRectComplex. * @method rc * @param {Number} x The horizontal coordinate to draw the round rect. * @param {Number} y The vertical coordinate to draw the round rect. * @param {Number} w The width of the round rect. * @param {Number} h The height of the round rect. * @param {Number} radiusTL Top left corner radius. * @param {Number} radiusTR Top right corner radius. * @param {Number} radiusBR Bottom right corner radius. * @param {Number} radiusBL Bottom left corner radius. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.rc = p.drawRoundRectComplex; /** * Shortcut to drawCircle. * @method dc * @param {Number} x x coordinate center point of circle. * @param {Number} y y coordinate center point of circle. * @param {Number} radius Radius of circle. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.dc = p.drawCircle; /** * Shortcut to drawEllipse. * @method de * @param {Number} x The left coordinate point of the ellipse. Note that this is different from {{#crossLink "Graphics/drawCircle"}}{{/crossLink}} * which draws from center. * @param {Number} y The top coordinate point of the ellipse. Note that this is different from {{#crossLink "Graphics/drawCircle"}}{{/crossLink}} * which draws from the center. * @param {Number} w The height (horizontal diameter) of the ellipse. The horizontal radius will be half of this * number. * @param {Number} h The width (vertical diameter) of the ellipse. The vertical radius will be half of this number. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.de = p.drawEllipse; /** * Shortcut to drawPolyStar. * @method dp * @param {Number} x Position of the center of the shape. * @param {Number} y Position of the center of the shape. * @param {Number} radius The outer radius of the shape. * @param {Number} sides The number of points on the star or sides on the polygon. * @param {Number} pointSize The depth or "pointy-ness" of the star points. A pointSize of 0 will draw a regular * polygon (no points), a pointSize of 1 will draw nothing because the points are infinitely pointy. * @param {Number} angle The angle of the first point / corner. For example a value of 0 will draw the first point * directly to the right of the center. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.dp = p.drawPolyStar; /** * Shortcut to decodePath. * @method p * @param {String} str The path string to decode. * @return {Graphics} The Graphics instance the method is called on (useful for chaining calls.) * @chainable * @protected **/ p.p = p.decodePath; // private methods: /** * @method _updateInstructions * @param commit * @protected **/ p._updateInstructions = function(commit) { var instr = this._instructions, active = this._activeInstructions, commitIndex = this._commitIndex; if (this._dirty && active.length) { instr.length = commitIndex; // remove old, uncommitted commands instr.push(Graphics.beginCmd); var l = active.length, ll = instr.length; instr.length = ll+l; for (var i=0; i= 2) { var o = this.style = Graphics._ctx.createPattern(image, repetition || ""); o.props = {image: image, repetition: repetition, type: "bitmap"}; } return this; }; p.path = false; /** * Graphics command object. See {{#crossLink "Graphics/beginStroke"}}{{/crossLink}} and {{#crossLink "Graphics/append"}}{{/crossLink}} for more information. * @class Stroke * @constructor * @param {Object} style A valid Context2D fillStyle. * @param {Boolean} ignoreScale **/ /** * A valid Context2D strokeStyle. * @property style * @type Object */ /** * @property ignoreScale * @type Boolean */ /** * Execute the Graphics command in the provided Canvas context. * @method exec * @param {CanvasRenderingContext2D} ctx The canvas rendering context */ p = (G.Stroke = function(style, ignoreScale) { this.style = style; this.ignoreScale = ignoreScale; }).prototype; p.exec = function(ctx) { if (!this.style) { return; } ctx.strokeStyle = this.style; if (this.ignoreScale) { ctx.save(); ctx.setTransform(1,0,0,1,0,0); } ctx.stroke(); if (this.ignoreScale) { ctx.restore(); } }; /** * Creates a linear gradient style and assigns it to {{#crossLink "Stroke/style:property"}}{{/crossLink}}. * See {{#crossLink "Graphics/beginLinearGradientStroke"}}{{/crossLink}} for more information. * @method linearGradient * @param {Array} colors * @param {Array} ratios * @param {Number} x0 * @param {Number} y0 * @param {Number} x1 * @param {Number} y1 * @return {Fill} Returns this Stroke object for chaining or assignment. */ p.linearGradient = G.Fill.prototype.linearGradient; /** * Creates a radial gradient style and assigns it to {{#crossLink "Stroke/style:property"}}{{/crossLink}}. * See {{#crossLink "Graphics/beginRadialGradientStroke"}}{{/crossLink}} for more information. * @method radialGradient * @param {Array} colors * @param {Array} ratios * @param {Number} x0 * @param {Number} y0 * @param {Number} r0 * @param {Number} x1 * @param {Number} y1 * @param {Number} r1 * @return {Fill} Returns this Stroke object for chaining or assignment. */ p.radialGradient = G.Fill.prototype.radialGradient; /** * Creates a bitmap fill style and assigns it to {{#crossLink "Stroke/style:property"}}{{/crossLink}}. * See {{#crossLink "Graphics/beginBitmapStroke"}}{{/crossLink}} for more information. * @method bitmap * @param {HTMLImageElement} image * @param {String} [repetition] One of: repeat, repeat-x, repeat-y, or no-repeat. * @return {Fill} Returns this Stroke object for chaining or assignment. */ p.bitmap = G.Fill.prototype.bitmap; p.path = false; /** * Graphics command object. See {{#crossLink "Graphics/setStrokeStyle"}}{{/crossLink}} and {{#crossLink "Graphics/append"}}{{/crossLink}} for more information. * @class StrokeStyle * @constructor * @param {Number} width * @param {String} [caps=butt] * @param {String} [joints=miter] * @param {Number} [miterLimit=10] * @param {Boolean} [ignoreScale=false] **/ /** * @property width * @type Number */ /** * One of: butt, round, square * @property caps * @type String */ /** * One of: round, bevel, miter * @property joints * @type String */ /** * @property miterLimit * @type Number */ /** * Execute the Graphics command in the provided Canvas context. * @method exec * @param {CanvasRenderingContext2D} ctx The canvas rendering context */ p = (G.StrokeStyle = function(width, caps, joints, miterLimit, ignoreScale) { this.width = width; this.caps = caps; this.joints = joints; this.miterLimit = miterLimit; this.ignoreScale = ignoreScale; }).prototype; p.exec = function(ctx) { ctx.lineWidth = (this.width == null ? "1" : this.width); ctx.lineCap = (this.caps == null ? "butt" : (isNaN(this.caps) ? this.caps : Graphics.STROKE_CAPS_MAP[this.caps])); ctx.lineJoin = (this.joints == null ? "miter" : (isNaN(this.joints) ? this.joints : Graphics.STROKE_JOINTS_MAP[this.joints])); ctx.miterLimit = (this.miterLimit == null ? "10" : this.miterLimit); ctx.ignoreScale = (this.ignoreScale == null ? false : this.ignoreScale); }; p.path = false; /** * Graphics command object. See {{#crossLink "Graphics/setStrokeDash"}}{{/crossLink}} and {{#crossLink "Graphics/append"}}{{/crossLink}} for more information. * @class StrokeDash * @constructor * @param {Array} [segments] * @param {Number} [offset=0] **/ /** * @property segments * @type Array */ /** * @property offset * @type Number */ /** * Execute the Graphics command in the provided Canvas context. * @method exec * @param {CanvasRenderingContext2D} ctx The canvas rendering context */ (G.StrokeDash = function(segments, offset) { this.segments = segments; this.offset = offset||0; }).prototype.exec = function(ctx) { if (ctx.setLineDash) { // feature detection. ctx.setLineDash(this.segments|| G.StrokeDash.EMPTY_SEGMENTS); // instead of [] to reduce churn. ctx.lineDashOffset = this.offset||0; } }; /** * The default value for segments (ie. no dash). * @property EMPTY_SEGMENTS * @static * @final * @readonly * @protected * @type {Array} **/ G.StrokeDash.EMPTY_SEGMENTS = []; /** * Graphics command object. See {{#crossLink "Graphics/drawRoundRectComplex"}}{{/crossLink}} and {{#crossLink "Graphics/append"}}{{/crossLink}} for more information. * @class RoundRect * @constructor * @param {Number} x * @param {Number} y * @param {Number} w * @param {Number} h * @param {Number} radiusTL * @param {Number} radiusTR * @param {Number} radiusBR * @param {Number} radiusBL **/ /** * @property x * @type Number */ /** * @property y * @type Number */ /** * @property w * @type Number */ /** * @property h * @type Number */ /** * @property radiusTL * @type Number */ /** * @property radiusTR * @type Number */ /** * @property radiusBR * @type Number */ /** * @property radiusBL * @type Number */ /** * Execute the Graphics command in the provided Canvas context. * @method exec * @param {CanvasRenderingContext2D} ctx The canvas rendering context */ (G.RoundRect = function(x, y, w, h, radiusTL, radiusTR, radiusBR, radiusBL) { this.x = x; this.y = y; this.w = w; this.h = h; this.radiusTL = radiusTL; this.radiusTR = radiusTR; this.radiusBR = radiusBR; this.radiusBL = radiusBL; }).prototype.exec = function(ctx) { var max = (this.w max) { rTL = max; } if (rTR < 0) { rTR *= (mTR=-1); } if (rTR > max) { rTR = max; } if (rBR < 0) { rBR *= (mBR=-1); } if (rBR > max) { rBR = max; } if (rBL < 0) { rBL *= (mBL=-1); } if (rBL > max) { rBL = max; } ctx.moveTo(x+w-rTR, y); ctx.arcTo(x+w+rTR*mTR, y-rTR*mTR, x+w, y+rTR, rTR); ctx.lineTo(x+w, y+h-rBR); ctx.arcTo(x+w+rBR*mBR, y+h+rBR*mBR, x+w-rBR, y+h, rBR); ctx.lineTo(x+rBL, y+h); ctx.arcTo(x-rBL*mBL, y+h+rBL*mBL, x, y+h-rBL, rBL); ctx.lineTo(x, y+rTL); ctx.arcTo(x-rTL*mTL, y-rTL*mTL, x+rTL, y, rTL); ctx.closePath(); }; /** * Graphics command object. See {{#crossLink "Graphics/drawCircle"}}{{/crossLink}} and {{#crossLink "Graphics/append"}}{{/crossLink}} for more information. * @class Circle * @constructor * @param {Number} x * @param {Number} y * @param {Number} radius **/ /** * @property x * @type Number */ /** * @property y * @type Number */ /** * @property radius * @type Number */ /** * Execute the Graphics command in the provided Canvas context. * @method exec * @param {CanvasRenderingContext2D} ctx The canvas rendering context */ (G.Circle = function(x, y, radius) { this.x = x; this.y = y; this.radius = radius; }).prototype.exec = function(ctx) { ctx.arc(this.x, this.y, this.radius, 0, Math.PI*2); }; /** * Graphics command object. See {{#crossLink "Graphics/drawEllipse"}}{{/crossLink}} and {{#crossLink "Graphics/append"}}{{/crossLink}} for more information. * @class Ellipse * @constructor * @param {Number} x * @param {Number} y * @param {Number} w * @param {Number} h **/ /** * @property x * @type Number */ /** * @property y * @type Number */ /** * @property w * @type Number */ /** * @property h * @type Number */ /** * Execute the Graphics command in the provided Canvas context. * @method exec * @param {CanvasRenderingContext2D} ctx The canvas rendering context */ (G.Ellipse = function(x, y, w, h) { this.x = x; this.y = y; this.w = w; this.h = h; }).prototype.exec = function(ctx) { var x = this.x, y = this.y; var w = this.w, h = this.h; var k = 0.5522848; var ox = (w / 2) * k; var oy = (h / 2) * k; var xe = x + w; var ye = y + h; var xm = x + w / 2; var ym = y + h / 2; ctx.moveTo(x, ym); ctx.bezierCurveTo(x, ym-oy, xm-ox, y, xm, y); ctx.bezierCurveTo(xm+ox, y, xe, ym-oy, xe, ym); ctx.bezierCurveTo(xe, ym+oy, xm+ox, ye, xm, ye); ctx.bezierCurveTo(xm-ox, ye, x, ym+oy, x, ym); }; /** * Graphics command object. See {{#crossLink "Graphics/drawPolyStar"}}{{/crossLink}} and {{#crossLink "Graphics/append"}}{{/crossLink}} for more information. * @class PolyStar * @constructor * @param {Number} x * @param {Number} y * @param {Number} radius * @param {Number} sides * @param {Number} pointSize * @param {Number} angle **/ /** * @property x * @type Number */ /** * @property y * @type Number */ /** * @property radius * @type Number */ /** * @property sides * @type Number */ /** * @property pointSize * @type Number */ /** * @property angle * @type Number */ /** * Execute the Graphics command in the provided Canvas context. * @method exec * @param {CanvasRenderingContext2D} ctx The canvas rendering context */ (G.PolyStar = function(x, y, radius, sides, pointSize, angle) { this.x = x; this.y = y; this.radius = radius; this.sides = sides; this.pointSize = pointSize; this.angle = angle; }).prototype.exec = function(ctx) { var x = this.x, y = this.y; var radius = this.radius; var angle = (this.angle||0)/180*Math.PI; var sides = this.sides; var ps = 1-(this.pointSize||0); var a = Math.PI/sides; ctx.moveTo(x+Math.cos(angle)*radius, y+Math.sin(angle)*radius); for (var i=0; iNote: In EaselJS 0.7.0, the mouseEnabled property will not work properly with nested Containers. Please * check out the latest NEXT version in GitHub for an updated version with this issue resolved. The fix will be * provided in the next release of EaselJS. * @property mouseEnabled * @type {Boolean} * @default true **/ this.mouseEnabled = true; /** * If false, the tick will not run on this display object (or its children). This can provide some performance benefits. * In addition to preventing the "tick" event from being dispatched, it will also prevent tick related updates * on some display objects (ex. Sprite & MovieClip frame advancing, and DOMElement display properties). * @property tickEnabled * @type Boolean * @default true **/ this.tickEnabled = true; /** * An optional name for this display object. Included in {{#crossLink "DisplayObject/toString"}}{{/crossLink}} . Useful for * debugging. * @property name * @type {String} * @default null **/ this.name = null; /** * A reference to the {{#crossLink "Container"}}{{/crossLink}} or {{#crossLink "Stage"}}{{/crossLink}} object that * contains this display object, or null if it has not been added * to one. * @property parent * @final * @type {Container} * @default null * @readonly **/ this.parent = null; /** * The left offset for this display object's registration point. For example, to make a 100x100px Bitmap rotate * around its center, you would set regX and {{#crossLink "DisplayObject/regY:property"}}{{/crossLink}} to 50. * Cached object's registration points should be set based on pre-cache conditions, not cached size. * @property regX * @type {Number} * @default 0 **/ this.regX = 0; /** * The y offset for this display object's registration point. For example, to make a 100x100px Bitmap rotate around * its center, you would set {{#crossLink "DisplayObject/regX:property"}}{{/crossLink}} and regY to 50. * Cached object's registration points should be set based on pre-cache conditions, not cached size. * @property regY * @type {Number} * @default 0 **/ this.regY = 0; /** * The rotation in degrees for this display object. * @property rotation * @type {Number} * @default 0 **/ this.rotation = 0; /** * The factor to stretch this display object horizontally. For example, setting scaleX to 2 will stretch the display * object to twice its nominal width. To horizontally flip an object, set the scale to a negative number. * @property scaleX * @type {Number} * @default 1 **/ this.scaleX = 1; /** * The factor to stretch this display object vertically. For example, setting scaleY to 0.5 will stretch the display * object to half its nominal height. To vertically flip an object, set the scale to a negative number. * @property scaleY * @type {Number} * @default 1 **/ this.scaleY = 1; /** * The factor to skew this display object horizontally. * @property skewX * @type {Number} * @default 0 **/ this.skewX = 0; /** * The factor to skew this display object vertically. * @property skewY * @type {Number} * @default 0 **/ this.skewY = 0; /** * A shadow object that defines the shadow to render on this display object. Set to `null` to remove a shadow. If * null, this property is inherited from the parent container. * @property shadow * @type {Shadow} * @default null **/ this.shadow = null; /** * Indicates whether this display object should be rendered to the canvas and included when running the Stage * {{#crossLink "Container/getObjectsUnderPoint"}}{{/crossLink}} method. * @property visible * @type {Boolean} * @default true **/ this.visible = true; /** * The x (horizontal) position of the display object, relative to its parent. * @property x * @type {Number} * @default 0 **/ this.x = 0; /** The y (vertical) position of the display object, relative to its parent. * @property y * @type {Number} * @default 0 **/ this.y = 0; /** * If set, defines the transformation for this display object, overriding all other transformation properties * (x, y, rotation, scale, skew). * @property transformMatrix * @type {Matrix2D} * @default null **/ this.transformMatrix = null; /** * The composite operation indicates how the pixels of this display object will be composited with the elements * behind it. If `null`, this property is inherited from the parent container. For more information, read the * * whatwg spec on compositing. For a list of supported compositeOperation value, visit * the W3C draft on Compositing and Blending. * @property compositeOperation * @type {String} * @default null **/ this.compositeOperation = null; /** * Indicates whether the display object should be drawn to a whole pixel when * {{#crossLink "Stage/snapToPixelEnabled:property"}}{{/crossLink}} is true. To enable/disable snapping on whole * categories of display objects, set this value on the prototype (Ex. Text.prototype.snapToPixel = true). * @property snapToPixel * @type {Boolean} * @default true **/ this.snapToPixel = true; /** * An array of Filter objects to apply to this display object. Filters are only applied / updated when {{#crossLink "cache"}}{{/crossLink}} * or {{#crossLink "updateCache"}}{{/crossLink}} is called on the display object, and only apply to the area that is * cached. * @property filters * @type {Array} * @default null **/ this.filters = null; /** * A Shape instance that defines a vector mask (clipping path) for this display object. The shape's transformation * will be applied relative to the display object's parent coordinates (as if it were a child of the parent). * @property mask * @type {Shape} * @default null */ this.mask = null; /** * A display object that will be tested when checking mouse interactions or testing {{#crossLink "Container/getObjectsUnderPoint"}}{{/crossLink}}. * The hit area will have its transformation applied relative to this display object's coordinate space (as though * the hit test object were a child of this display object and relative to its regX/Y). The hitArea will be tested * using only its own `alpha` value regardless of the alpha value on the target display object, or the target's * ancestors (parents). * * If set on a {{#crossLink "Container"}}{{/crossLink}}, children of the Container will not receive mouse events. * This is similar to setting {{#crossLink "mouseChildren"}}{{/crossLink}} to false. * * Note that hitArea is NOT currently used by the `hitTest()` method, nor is it supported for {{#crossLink "Stage"}}{{/crossLink}}. * @property hitArea * @type {DisplayObject} * @default null */ this.hitArea = null; /** * A CSS cursor (ex. "pointer", "help", "text", etc) that will be displayed when the user hovers over this display * object. You must enable mouseover events using the {{#crossLink "Stage/enableMouseOver"}}{{/crossLink}} method to * use this property. Setting a non-null cursor on a Container will override the cursor set on its descendants. * @property cursor * @type {String} * @default null */ this.cursor = null; // private properties: /** * Moved to {{#crossLink "BitmapCache"}}{{/crossLink}} * @property _cacheScale * @protected * @type {Number} * @default 1 * @deprecated **/ /** * Moved to {{#crossLink "BitmapCache"}}{{/crossLink}} * @property _cacheDataURLID * @protected * @type {Number} * @default 0 * @deprecated */ /** * Moved to {{#crossLink "BitmapCache"}}{{/crossLink}} * @property _cacheDataURL * @protected * @type {String} * @default null * @deprecated */ /** * @property _props * @protected * @type {DisplayObject} * @default null **/ this._props = new createjs.DisplayProps(); /** * @property _rectangle * @protected * @type {Rectangle} * @default null **/ this._rectangle = new createjs.Rectangle(); /** * @property _bounds * @protected * @type {Rectangle} * @default null **/ this._bounds = null; /** * Where StageGL should look for required display properties, matters only for leaf display objects. Containers * or cached objects won't use this property, it's for native display of terminal elements. * @property _webGLRenderStyle * @protected * @type {number} * @default 0 */ this._webGLRenderStyle = DisplayObject._StageGL_NONE; /** * Storage for the calculated position of an object in StageGL. If not using StageGL, you can null it to save memory. * @property _glMtx * @protected * @type {Matrix2D} * @default null */ this._glMtx = new createjs.Matrix2D(); } var p = createjs.extend(DisplayObject, createjs.EventDispatcher); // static properties: /** * Listing of mouse event names. Used in _hasMouseEventListener. * @property _MOUSE_EVENTS * @protected * @static * @type {Array} **/ DisplayObject._MOUSE_EVENTS = ["click","dblclick","mousedown","mouseout","mouseover","pressmove","pressup","rollout","rollover"]; /** * Suppresses errors generated when using features like hitTest, mouse events, and {{#crossLink "getObjectsUnderPoint"}}{{/crossLink}} * with cross domain content. * @property suppressCrossDomainErrors * @static * @type {Boolean} * @default false **/ DisplayObject.suppressCrossDomainErrors = false; /** * @property _snapToPixelEnabled * @protected * @static * @type {Boolean} * @default false **/ DisplayObject._snapToPixelEnabled = false; // stage.snapToPixelEnabled is temporarily copied here during a draw to provide global access. /** * Enum like property for determining StageGL render lookup, i.e. where to expect properties. * @property _StageGL_NONE * @protected * @static * @type {number} */ DisplayObject._StageGL_NONE = 0; /** * Enum like property for determining StageGL render lookup, i.e. where to expect properties. * @property _StageGL_SPRITE * @protected * @static * @type {number} */ DisplayObject._StageGL_SPRITE = 1; /** * Enum like property for determining StageGL render lookup, i.e. where to expect properties. * @property _StageGL_BITMAP * @protected * @static * @type {number} */ DisplayObject._StageGL_BITMAP = 2; /** * @property _hitTestCanvas * @type {HTMLCanvasElement | Object} * @static * @protected **/ /** * @property _hitTestContext * @type {CanvasRenderingContext2D} * @static * @protected **/ var canvas = createjs.createCanvas?createjs.createCanvas():document.createElement("canvas"); // prevent errors on load in browsers without canvas. if (canvas.getContext) { DisplayObject._hitTestCanvas = canvas; DisplayObject._hitTestContext = canvas.getContext("2d"); canvas.width = canvas.height = 1; } // events: /** * Dispatched when the user presses their left mouse button over the display object. See the * {{#crossLink "MouseEvent"}}{{/crossLink}} class for a listing of event properties. * @event mousedown * @since 0.6.0 */ /** * Dispatched when the user presses their left mouse button and then releases it while over the display object. * See the {{#crossLink "MouseEvent"}}{{/crossLink}} class for a listing of event properties. * @event click * @since 0.6.0 */ /** * Dispatched when the user double clicks their left mouse button over this display object. * See the {{#crossLink "MouseEvent"}}{{/crossLink}} class for a listing of event properties. * @event dblclick * @since 0.6.0 */ /** * Dispatched when the user's mouse enters this display object. This event must be enabled using * {{#crossLink "Stage/enableMouseOver"}}{{/crossLink}}. See also {{#crossLink "DisplayObject/rollover:event"}}{{/crossLink}}. * See the {{#crossLink "MouseEvent"}}{{/crossLink}} class for a listing of event properties. * @event mouseover * @since 0.6.0 */ /** * Dispatched when the user's mouse leaves this display object. This event must be enabled using * {{#crossLink "Stage/enableMouseOver"}}{{/crossLink}}. See also {{#crossLink "DisplayObject/rollout:event"}}{{/crossLink}}. * See the {{#crossLink "MouseEvent"}}{{/crossLink}} class for a listing of event properties. * @event mouseout * @since 0.6.0 */ /** * This event is similar to {{#crossLink "DisplayObject/mouseover:event"}}{{/crossLink}}, with the following * differences: it does not bubble, and it considers {{#crossLink "Container"}}{{/crossLink}} instances as an * aggregate of their content. * * For example, myContainer contains two overlapping children: shapeA and shapeB. The user moves their mouse over * shapeA and then directly on to shapeB. With a listener for {{#crossLink "mouseover:event"}}{{/crossLink}} on * myContainer, two events would be received, each targeting a child element: *
    *
  1. when the mouse enters shapeA (target=shapeA)
  2. *
  3. when the mouse enters shapeB (target=shapeB)
  4. *
* However, with a listener for "rollover" instead, only a single event is received when the mouse first enters * the aggregate myContainer content (target=myContainer). * * This event must be enabled using {{#crossLink "Stage/enableMouseOver"}}{{/crossLink}}. * See the {{#crossLink "MouseEvent"}}{{/crossLink}} class for a listing of event properties. * @event rollover * @since 0.7.0 */ /** * This event is similar to {{#crossLink "DisplayObject/mouseout:event"}}{{/crossLink}}, with the following * differences: it does not bubble, and it considers {{#crossLink "Container"}}{{/crossLink}} instances as an * aggregate of their content. * * For example, myContainer contains two overlapping children: shapeA and shapeB. The user moves their mouse over * shapeA, then directly on to shapeB, then off both. With a listener for {{#crossLink "mouseout:event"}}{{/crossLink}} * on myContainer, two events would be received, each targeting a child element: *
    *
  1. when the mouse leaves shapeA (target=shapeA)
  2. *
  3. when the mouse leaves shapeB (target=shapeB)
  4. *
* However, with a listener for "rollout" instead, only a single event is received when the mouse leaves * the aggregate myContainer content (target=myContainer). * * This event must be enabled using {{#crossLink "Stage/enableMouseOver"}}{{/crossLink}}. * See the {{#crossLink "MouseEvent"}}{{/crossLink}} class for a listing of event properties. * @event rollout * @since 0.7.0 */ /** * After a {{#crossLink "DisplayObject/mousedown:event"}}{{/crossLink}} occurs on a display object, a pressmove * event will be generated on that object whenever the mouse moves until the mouse press is released. This can be * useful for dragging and similar operations. * * **Please note** that if the initial mouse target from a `mousedown` event is removed from the stage after being pressed * (e.g. during a `pressmove` event), a `pressmove` event is still generated. However since it is no longer in the * display list, the event can not bubble. This means that previous ancestors (parent containers) will not receive * the event, and therefore can not re-dispatch it. If you intend to listen for `{{#crossLink "DisplayObject/pressup:event"}}{{/crossLink}}` * or `pressmove` on a dynamic object (such as a {{#crossLink "MovieClip"}}{{/crossLink}} or {{#crossLink "Container"}}{{/crossLink}}), * then ensure you set {{#crossLink "Container/mouseChildren:property"}}{{/crossLink}} to `false`. * @event pressmove * @since 0.7.0 */ /** * After a {{#crossLink "DisplayObject/mousedown:event"}}{{/crossLink}} occurs on a display object, a pressup event * will be generated on that object when that mouse press is released. This can be useful for dragging and similar * operations. * * **Please note** that if the initial mouse target from a `mousedown` event is removed from the stage after being pressed * (e.g. during a `pressmove` event), a `pressup` event is still generated. However since it is no longer in the * display list, the event can not bubble. This means that previous ancestors (parent containers) will not receive * the event, and therefore can not re-dispatch it. If you intend to listen for `{{#crossLink "DisplayObject/pressmove:event"}}{{/crossLink}}` * or `pressup` on a dynamic object (such as a {{#crossLink "MovieClip"}}{{/crossLink}} or {{#crossLink "Container"}}{{/crossLink}}), * then ensure you set {{#crossLink "Container/mouseChildren:property"}}{{/crossLink}} to `false`. * @event pressup * @since 0.7.0 */ /** * Dispatched when the display object is added to a parent container. * @event added */ /** * Dispatched when the display object is removed from its parent container. * @event removed */ /** * Dispatched on each display object on a stage whenever the stage updates. This occurs immediately before the * rendering (draw) pass. When {{#crossLink "Stage/update"}}{{/crossLink}} is called, first all display objects on * the stage dispatch the tick event, then all of the display objects are drawn to stage. Children will have their * {{#crossLink "tick:event"}}{{/crossLink}} event dispatched in order of their depth prior to the event being * dispatched on their parent. * @event tick * @param {Object} target The object that dispatched the event. * @param {String} type The event type. * @param {Array} params An array containing any arguments that were passed to the Stage.update() method. For * example if you called stage.update("hello"), then the params would be ["hello"]. * @since 0.6.0 */ // getter / setters: /** * Use the {{#crossLink "DisplayObject/stage:property"}}{{/crossLink}} property instead. * @method _getStage * @protected * @return {Stage} **/ p._getStage = function() { // uses dynamic access to avoid circular dependencies; var o = this, _Stage = createjs["Stage"]; while (o.parent) { o = o.parent; } if (o instanceof _Stage) { return o; } return null; }; /** * Use the {{#crossLink "DisplayObject/stage:property"}}{{/crossLink}} property instead. * @method getStage * @deprecated */ // DisplayObject.getStage is @deprecated. Remove for 1.1+ p.getStage = createjs.deprecate(p._getStage, "DisplayObject.getStage"); /** * Returns the Stage instance that this display object will be rendered on, or null if it has not been added to one. * @property stage * @type {Stage} * @readonly **/ /** * Returns an ID number that uniquely identifies the current cache for this display object. This can be used to * determine if the cache has changed since a previous check. * Moved to {{#crossLink "BitmapCache"}}{{/crossLink}} * @property cacheID * @deprecated * @type {Number} * @default 0 */ /** * Set both the {{#crossLink "DisplayObject/scaleX:property"}}{{/crossLink}} and the {{#crossLink "DisplayObject/scaleY:property"}}{{/crossLink}} * property to the same value. Note that when you get the value, if the `scaleX` and `scaleY` are different values, * it will return only the `scaleX`. * @property scale * @type {Number} * @default 1 */ try { Object.defineProperties(p, { stage: { get: p._getStage }, cacheID: { get: function(){ return this.bitmapCache && this.bitmapCache.cacheID }, set: function(a){ this.bitmapCache && (this.bitmapCache.cacheID = a) } }, scale: { get: function() { return this.scaleX; }, set: function(scale) { this.scaleX = this.scaleY = scale; } } }); } catch (e) {} // public methods: /** * Returns true or false indicating whether the display object would be visible if drawn to a canvas. * This does not account for whether it would be visible within the boundaries of the stage. * * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method isVisible * @return {Boolean} Boolean indicating whether the display object would be visible if drawn to a canvas **/ p.isVisible = function() { return !!(this.visible && this.alpha > 0 && this.scaleX != 0 && this.scaleY != 0); }; /** * Draws the display object into the specified context ignoring its visible, alpha, shadow, and transform. * Returns `true` if the draw was handled (useful for overriding functionality). * * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method draw * @param {CanvasRenderingContext2D} ctx The canvas 2D context object to draw into. * @param {Boolean} [ignoreCache=false] Indicates whether the draw operation should ignore any current cache. For example, * used for drawing the cache (to prevent it from simply drawing an existing cache back into itself). * @return {Boolean} **/ p.draw = function(ctx, ignoreCache) { var cache = this.bitmapCache; if (cache && !ignoreCache) { return cache.draw(ctx); } return false; }; /** * Applies this display object's transformation, alpha, globalCompositeOperation, clipping path (mask), and shadow * to the specified context. This is typically called prior to {{#crossLink "DisplayObject/draw"}}{{/crossLink}}. * @method updateContext * @param {CanvasRenderingContext2D} ctx The canvas 2D to update. **/ p.updateContext = function(ctx) { var o=this, mask=o.mask, mtx= o._props.matrix; if (mask && mask.graphics && !mask.graphics.isEmpty()) { mask.getMatrix(mtx); ctx.transform(mtx.a, mtx.b, mtx.c, mtx.d, mtx.tx, mtx.ty); mask.graphics.drawAsPath(ctx); ctx.clip(); mtx.invert(); ctx.transform(mtx.a, mtx.b, mtx.c, mtx.d, mtx.tx, mtx.ty); } this.getMatrix(mtx); var tx = mtx.tx, ty = mtx.ty; if (DisplayObject._snapToPixelEnabled && o.snapToPixel) { tx = tx + (tx < 0 ? -0.5 : 0.5) | 0; ty = ty + (ty < 0 ? -0.5 : 0.5) | 0; } ctx.transform(mtx.a, mtx.b, mtx.c, mtx.d, tx, ty); ctx.globalAlpha *= o.alpha; if (o.compositeOperation) { ctx.globalCompositeOperation = o.compositeOperation; } if (o.shadow) { this._applyShadow(ctx, o.shadow); } }; /** * Draws the display object into a new element, which is then used for subsequent draws. Intended for complex content * that does not change frequently (ex. a Container with many children that do not move, or a complex vector Shape), * this can provide for much faster rendering because the content does not need to be re-rendered each tick. The * cached display object can be moved, rotated, faded, etc freely, however if its content changes, you must manually * update the cache by calling `updateCache()` again. You must specify the cached area via the x, y, w, and h * parameters. This defines the rectangle that will be rendered and cached using this display object's coordinates. * *

Example

* For example if you defined a Shape that drew a circle at 0, 0 with a radius of 25: * * var shape = new createjs.Shape(); * shape.graphics.beginFill("#ff0000").drawCircle(0, 0, 25); * shape.cache(-25, -25, 50, 50); * * Note that filters need to be defined before the cache is applied or you will have to call updateCache after * application. Check out the {{#crossLink "Filter"}}{{/crossLink}} class for more information. Some filters * (ex. BlurFilter) may not work as expected in conjunction with the scale param. * * Usually, the resulting cacheCanvas will have the dimensions width * scale, height * scale, however some filters (ex. BlurFilter) * will add padding to the canvas dimensions. * * In previous versions caching was handled on DisplayObject but has since been moved to {{#crossLink "BitmapCache"}}{{/crossLink}}. * This allows for easier interaction and alternate cache methods like WebGL with {{#crossLink "StageGL"}}{{/crossLink}}. * For more information on the options object, see the BitmapCache {{#crossLink "BitmapCache/define"}}{{/crossLink}}. * * @method cache * @param {Number} x The x coordinate origin for the cache region. * @param {Number} y The y coordinate origin for the cache region. * @param {Number} width The width of the cache region. * @param {Number} height The height of the cache region. * @param {Number} [scale=1] The scale at which the cache will be created. For example, if you cache a vector shape using * myShape.cache(0,0,100,100,2) then the resulting cacheCanvas will be 200x200 px. This lets you scale and rotate * cached elements with greater fidelity. Default is 1. * @param {Object} [options=undefined] Specify additional parameters for the cache logic **/ p.cache = function(x, y, width, height, scale, options) { if (!this.bitmapCache){ this.bitmapCache = new createjs.BitmapCache(); } else { this.bitmapCache._autoGenerated = false; } this.bitmapCache.define(this, x, y, width, height, scale, options); }; /** * Redraws the display object to its cache. Calling updateCache without an active cache will throw an error. * If compositeOperation is null the current cache will be cleared prior to drawing. Otherwise the display object * will be drawn over the existing cache using the specified compositeOperation. * *

Example

* Clear the current graphics of a cached shape, draw some new instructions, and then update the cache. The new line * will be drawn on top of the old one. * * // Not shown: Creating the shape, and caching it. * shapeInstance.clear(); * shapeInstance.setStrokeStyle(3).beginStroke("#ff0000").moveTo(100, 100).lineTo(200,200); * shapeInstance.updateCache(); * * In previous versions caching was handled on DisplayObject but has since been moved to {{#crossLink "BitmapCache"}}{{/crossLink}}. * This allows for easier interaction and alternate cache methods like WebGL and {{#crossLink "StageGL"}}{{/crossLink}}. * * @method updateCache * @param {String} compositeOperation The compositeOperation to use, or null to clear the cache and redraw it. * * whatwg spec on compositing. **/ p.updateCache = function(compositeOperation) { if (!this.bitmapCache) { throw "cache() must be called before updateCache()"; } this.bitmapCache.update(compositeOperation); }; /** * Clears the current cache. See {{#crossLink "DisplayObject/cache"}}{{/crossLink}} for more information. * @method uncache **/ p.uncache = function() { if (this.bitmapCache) { this.bitmapCache.release(); this.bitmapCache = undefined; } }; /** * Returns a data URL for the cache, or null if this display object is not cached. * Only generated if the cache has changed, otherwise returns last result. * @method getCacheDataURL * @return {String} The image data url for the cache. **/ p.getCacheDataURL = function() { return this.bitmapCache?this.bitmapCache.getCacheDataURL():null; }; /** * Transforms the specified x and y position from the coordinate space of the display object * to the global (stage) coordinate space. For example, this could be used to position an HTML label * over a specific point on a nested display object. Returns a Point instance with x and y properties * correlating to the transformed coordinates on the stage. * *

Example

* * displayObject.x = 300; * displayObject.y = 200; * stage.addChild(displayObject); * var point = displayObject.localToGlobal(100, 100); * // Results in x=400, y=300 * * @method localToGlobal * @param {Number} x The x position in the source display object to transform. * @param {Number} y The y position in the source display object to transform. * @param {Point | Object} [pt] An object to copy the result into. If omitted a new Point object with x/y properties will be returned. * @return {Point} A Point instance with x and y properties correlating to the transformed coordinates * on the stage. **/ p.localToGlobal = function(x, y, pt) { return this.getConcatenatedMatrix(this._props.matrix).transformPoint(x,y, pt||new createjs.Point()); }; /** * Transforms the specified x and y position from the global (stage) coordinate space to the * coordinate space of the display object. For example, this could be used to determine * the current mouse position within the display object. Returns a Point instance with x and y properties * correlating to the transformed position in the display object's coordinate space. * *

Example

* * displayObject.x = 300; * displayObject.y = 200; * stage.addChild(displayObject); * var point = displayObject.globalToLocal(100, 100); * // Results in x=-200, y=-100 * * @method globalToLocal * @param {Number} x The x position on the stage to transform. * @param {Number} y The y position on the stage to transform. * @param {Point | Object} [pt] An object to copy the result into. If omitted a new Point object with x/y properties will be returned. * @return {Point} A Point instance with x and y properties correlating to the transformed position in the * display object's coordinate space. **/ p.globalToLocal = function(x, y, pt) { return this.getConcatenatedMatrix(this._props.matrix).invert().transformPoint(x,y, pt||new createjs.Point()); }; /** * Transforms the specified x and y position from the coordinate space of this display object to the coordinate * space of the target display object. Returns a Point instance with x and y properties correlating to the * transformed position in the target's coordinate space. Effectively the same as using the following code with * {{#crossLink "DisplayObject/localToGlobal"}}{{/crossLink}} and {{#crossLink "DisplayObject/globalToLocal"}}{{/crossLink}}. * * var pt = this.localToGlobal(x, y); * pt = target.globalToLocal(pt.x, pt.y); * * @method localToLocal * @param {Number} x The x position in the source display object to transform. * @param {Number} y The y position on the source display object to transform. * @param {DisplayObject} target The target display object to which the coordinates will be transformed. * @param {Point | Object} [pt] An object to copy the result into. If omitted a new Point object with x/y properties will be returned. * @return {Point} Returns a Point instance with x and y properties correlating to the transformed position * in the target's coordinate space. **/ p.localToLocal = function(x, y, target, pt) { pt = this.localToGlobal(x, y, pt); return target.globalToLocal(pt.x, pt.y, pt); }; /** * Shortcut method to quickly set the transform properties on the display object. All parameters are optional. * Omitted parameters will have the default value set. * *

Example

* * displayObject.setTransform(100, 100, 2, 2); * * @method setTransform * @param {Number} [x=0] The horizontal translation (x position) in pixels * @param {Number} [y=0] The vertical translation (y position) in pixels * @param {Number} [scaleX=1] The horizontal scale, as a percentage of 1 * @param {Number} [scaleY=1] the vertical scale, as a percentage of 1 * @param {Number} [rotation=0] The rotation, in degrees * @param {Number} [skewX=0] The horizontal skew factor * @param {Number} [skewY=0] The vertical skew factor * @param {Number} [regX=0] The horizontal registration point in pixels * @param {Number} [regY=0] The vertical registration point in pixels * @return {DisplayObject} Returns this instance. Useful for chaining commands. * @chainable */ p.setTransform = function(x, y, scaleX, scaleY, rotation, skewX, skewY, regX, regY) { this.x = x || 0; this.y = y || 0; this.scaleX = scaleX == null ? 1 : scaleX; this.scaleY = scaleY == null ? 1 : scaleY; this.rotation = rotation || 0; this.skewX = skewX || 0; this.skewY = skewY || 0; this.regX = regX || 0; this.regY = regY || 0; return this; }; /** * Returns a matrix based on this object's current transform. * @method getMatrix * @param {Matrix2D} matrix Optional. A Matrix2D object to populate with the calculated values. If null, a new * Matrix object is returned. * @return {Matrix2D} A matrix representing this display object's transform. **/ p.getMatrix = function(matrix) { var o = this, mtx = matrix || new createjs.Matrix2D(); return o.transformMatrix ? mtx.copy(o.transformMatrix) : (mtx.identity() && mtx.appendTransform(o.x, o.y, o.scaleX, o.scaleY, o.rotation, o.skewX, o.skewY, o.regX, o.regY)); }; /** * Generates a Matrix2D object representing the combined transform of the display object and all of its * parent Containers up to the highest level ancestor (usually the {{#crossLink "Stage"}}{{/crossLink}}). This can * be used to transform positions between coordinate spaces, such as with {{#crossLink "DisplayObject/localToGlobal"}}{{/crossLink}} * and {{#crossLink "DisplayObject/globalToLocal"}}{{/crossLink}}. * @method getConcatenatedMatrix * @param {Matrix2D} [matrix] A {{#crossLink "Matrix2D"}}{{/crossLink}} object to populate with the calculated values. * If null, a new Matrix2D object is returned. * @return {Matrix2D} The combined matrix. **/ p.getConcatenatedMatrix = function(matrix) { var o = this, mtx = this.getMatrix(matrix); while (o = o.parent) { mtx.prependMatrix(o.getMatrix(o._props.matrix)); } return mtx; }; /** * Generates a DisplayProps object representing the combined display properties of the object and all of its * parent Containers up to the highest level ancestor (usually the {{#crossLink "Stage"}}{{/crossLink}}). * @method getConcatenatedDisplayProps * @param {DisplayProps} [props] A {{#crossLink "DisplayProps"}}{{/crossLink}} object to populate with the calculated values. * If null, a new DisplayProps object is returned. * @return {DisplayProps} The combined display properties. **/ p.getConcatenatedDisplayProps = function(props) { props = props ? props.identity() : new createjs.DisplayProps(); var o = this, mtx = o.getMatrix(props.matrix); do { props.prepend(o.visible, o.alpha, o.shadow, o.compositeOperation); // we do this to avoid problems with the matrix being used for both operations when o._props.matrix is passed in as the props param. // this could be simplified (ie. just done as part of the prepend above) if we switched to using a pool. if (o != this) { mtx.prependMatrix(o.getMatrix(o._props.matrix)); } } while (o = o.parent); return props; }; /** * Tests whether the display object intersects the specified point in local coordinates (ie. draws a pixel with alpha > 0 at * the specified position). This ignores the alpha, shadow, hitArea, mask, and compositeOperation of the display object. * *

Example

* * stage.addEventListener("stagemousedown", handleMouseDown); * function handleMouseDown(event) { * var hit = myShape.hitTest(event.stageX, event.stageY); * } * * Please note that shape-to-shape collision is not currently supported by EaselJS. * @method hitTest * @param {Number} x The x position to check in the display object's local coordinates. * @param {Number} y The y position to check in the display object's local coordinates. * @return {Boolean} A Boolean indicating whether a visible portion of the DisplayObject intersect the specified * local Point. */ p.hitTest = function(x, y) { var ctx = DisplayObject._hitTestContext; ctx.setTransform(1, 0, 0, 1, -x, -y); this.draw(ctx); var hit = this._testHit(ctx); ctx.setTransform(1, 0, 0, 1, 0, 0); ctx.clearRect(0, 0, 2, 2); return hit; }; /** * Provides a chainable shortcut method for setting a number of properties on the instance. * *

Example

* * var myGraphics = new createjs.Graphics().beginFill("#ff0000").drawCircle(0, 0, 25); * var shape = stage.addChild(new Shape()).set({graphics:myGraphics, x:100, y:100, alpha:0.5}); * * @method set * @param {Object} props A generic object containing properties to copy to the DisplayObject instance. * @return {DisplayObject} Returns the instance the method is called on (useful for chaining calls.) * @chainable */ p.set = function(props) { for (var n in props) { this[n] = props[n]; } return this; }; /** * Returns a rectangle representing this object's bounds in its local coordinate system (ie. with no transformation). * Objects that have been cached will return the bounds of the cache. * * Not all display objects can calculate their own bounds (ex. Shape). For these objects, you can use * {{#crossLink "DisplayObject/setBounds"}}{{/crossLink}} so that they are included when calculating Container * bounds. * * * * * * * * * *
All * All display objects support setting bounds manually using setBounds(). Likewise, display objects that * have been cached using cache() will return the bounds of their cache. Manual and cache bounds will override * the automatic calculations listed below. *
Bitmap * Returns the width and height of the {{#crossLink "Bitmap/sourceRect"}}{{/crossLink}} (if specified) or image, * extending from (x=0,y=0). *
Sprite * Returns the bounds of the current frame. May have non-zero x/y if a frame registration point was specified * in the spritesheet data. See also {{#crossLink "SpriteSheet/getFrameBounds"}}{{/crossLink}} *
Container * Returns the aggregate (combined) bounds of all children that return a non-null value from `getBounds()`. *
Shape * Does not currently support automatic bounds calculations. Use `setBounds()` to manually define bounds. *
Text * Returns approximate bounds. Horizontal values (x/width) are quite accurate, but vertical values (y/height) * are not, especially when using {{#crossLink "Text/textBaseline:property"}}{{/crossLink}} values other than "top". *
BitmapText * Returns approximate bounds. Values will be more accurate if spritesheet frame registration points are close * to (x=0,y=0). *
* * Bounds can be expensive to calculate for some objects (ex. text, or containers with many children), and * are recalculated each time you call getBounds(). You can prevent recalculation on static objects by setting the * bounds explicitly: * * var bounds = obj.getBounds(); * obj.setBounds(bounds.x, bounds.y, bounds.width, bounds.height); * // getBounds will now use the set values, instead of recalculating * * To reduce memory impact, the returned Rectangle instance may be reused internally; clone the instance or copy its * values if you need to retain it. * * var myBounds = obj.getBounds().clone(); * // OR: * myRect.copy(obj.getBounds()); * * @method getBounds * @return {Rectangle} A Rectangle instance representing the bounds, or null if bounds are not available for this * object. **/ p.getBounds = function() { if (this._bounds) { return this._rectangle.copy(this._bounds); } var cache = this.bitmapCache; if (cache && this.cacheCanvas) { return cache.getBounds(); } return null; }; /** * Returns a rectangle representing this object's bounds in its parent's coordinate system (ie. with transformations applied). * Objects that have been cached will return the transformed bounds of the cache. * * Not all display objects can calculate their own bounds (ex. Shape). For these objects, you can use * {{#crossLink "DisplayObject/setBounds"}}{{/crossLink}} so that they are included when calculating Container * bounds. * * To reduce memory impact, the returned Rectangle instance may be reused internally; clone the instance or copy its * values if you need to retain it. * * Container instances calculate aggregate bounds for all children that return bounds via getBounds. * @method getTransformedBounds * @return {Rectangle} A Rectangle instance representing the bounds, or null if bounds are not available for this object. **/ p.getTransformedBounds = function() { return this._getBounds(); }; /** * Allows you to manually specify the bounds of an object that either cannot calculate their own bounds (ex. Shape & * Text) for future reference, or so the object can be included in Container bounds. Manually set bounds will always * override calculated bounds. * * The bounds should be specified in the object's local (untransformed) coordinates. For example, a Shape instance * with a 25px radius circle centered at 0,0 would have bounds of (-25, -25, 50, 50). * @method setBounds * @param {Number} x The x origin of the bounds. Pass null to remove the manual bounds. * @param {Number} y The y origin of the bounds. * @param {Number} width The width of the bounds. * @param {Number} height The height of the bounds. **/ p.setBounds = function(x, y, width, height) { if (x == null) { this._bounds = x; return; } this._bounds = (this._bounds || new createjs.Rectangle()).setValues(x, y, width, height); }; /** * Returns a clone of this DisplayObject. Some properties that are specific to this instance's current context are * reverted to their defaults (for example .parent). Caches are not maintained across clones, and some elements * are copied by reference (masks, individual filter instances, hit area) * @method clone * @return {DisplayObject} A clone of the current DisplayObject instance. **/ p.clone = function() { return this._cloneProps(new DisplayObject()); }; /** * Returns a string representation of this object. * @method toString * @return {String} a string representation of the instance. **/ p.toString = function() { return "[DisplayObject (name="+ this.name +")]"; }; // private methods: /** * Called before the object gets drawn and is a chance to ensure the display state of the object is correct. * Mostly used by {{#crossLink "MovieClip"}}{{/crossLink}} and {{#crossLink "BitmapText"}}{{/crossLink}} to * correct their internal state and children prior to being drawn. * * Is manually called via draw in a {{#crossLink "Stage"}}{{/crossLink}} but is automatically called when * present in a {{#crossLink "StageGL"}}{{/crossLink}} instance. * * @method _updateState * @protected * @default null */ p._updateState = null; // separated so it can be used more easily in subclasses: /** * @method _cloneProps * @param {DisplayObject} o The DisplayObject instance which will have properties from the current DisplayObject * instance copied into. * @return {DisplayObject} o * @protected **/ p._cloneProps = function(o) { o.alpha = this.alpha; o.mouseEnabled = this.mouseEnabled; o.tickEnabled = this.tickEnabled; o.name = this.name; o.regX = this.regX; o.regY = this.regY; o.rotation = this.rotation; o.scaleX = this.scaleX; o.scaleY = this.scaleY; o.shadow = this.shadow; o.skewX = this.skewX; o.skewY = this.skewY; o.visible = this.visible; o.x = this.x; o.y = this.y; o.compositeOperation = this.compositeOperation; o.snapToPixel = this.snapToPixel; o.filters = this.filters==null?null:this.filters.slice(0); o.mask = this.mask; o.hitArea = this.hitArea; o.cursor = this.cursor; o._bounds = this._bounds; o._webGLRenderStyle = this._webGLRenderStyle; return o; }; /** * @method _applyShadow * @protected * @param {CanvasRenderingContext2D} ctx * @param {Shadow} shadow **/ p._applyShadow = function(ctx, shadow) { shadow = shadow || Shadow.identity; ctx.shadowColor = shadow.color; ctx.shadowOffsetX = shadow.offsetX; ctx.shadowOffsetY = shadow.offsetY; ctx.shadowBlur = shadow.blur; }; /** * @method _tick * @param {Object} evtObj An event object that will be dispatched to all tick listeners. This object is reused between dispatchers to reduce construction & GC costs. * @protected **/ p._tick = function(evtObj) { // because tick can be really performance sensitive, check for listeners before calling dispatchEvent. var ls = this._listeners; if (ls && ls["tick"]) { // reset & reuse the event object to avoid construction / GC costs: evtObj.target = null; evtObj.propagationStopped = evtObj.immediatePropagationStopped = false; this.dispatchEvent(evtObj); } }; /** * @method _testHit * @protected * @param {CanvasRenderingContext2D} ctx * @return {Boolean} **/ p._testHit = function(ctx) { try { var hit = ctx.getImageData(0, 0, 1, 1).data[3] > 1; } catch (e) { if (!DisplayObject.suppressCrossDomainErrors) { throw "An error has occurred. This is most likely due to security restrictions on reading canvas pixel data with local or cross-domain images."; } } return hit; }; /** * @method _getBounds * @param {Matrix2D} matrix * @param {Boolean} ignoreTransform If true, does not apply this object's transform. * @return {Rectangle} * @protected **/ p._getBounds = function(matrix, ignoreTransform){ return this._transformBounds(this.getBounds(), matrix, ignoreTransform); }; /** * @method _transformBounds * @param {Rectangle} bounds * @param {Matrix2D} matrix * @param {Boolean} ignoreTransform * @return {Rectangle} * @protected **/ p._transformBounds = function(bounds, matrix, ignoreTransform) { if (!bounds) { return bounds; } var x = bounds.x, y = bounds.y, width = bounds.width, height = bounds.height, mtx = this._props.matrix; mtx = ignoreTransform ? mtx.identity() : this.getMatrix(mtx); if (x || y) { mtx.appendTransform(0,0,1,1,0,0,0,-x,-y); } // TODO: simplify this. if (matrix) { mtx.prependMatrix(matrix); } var x_a = width*mtx.a, x_b = width*mtx.b; var y_c = height*mtx.c, y_d = height*mtx.d; var tx = mtx.tx, ty = mtx.ty; var minX = tx, maxX = tx, minY = ty, maxY = ty; if ((x = x_a + tx) < minX) { minX = x; } else if (x > maxX) { maxX = x; } if ((x = x_a + y_c + tx) < minX) { minX = x; } else if (x > maxX) { maxX = x; } if ((x = y_c + tx) < minX) { minX = x; } else if (x > maxX) { maxX = x; } if ((y = x_b + ty) < minY) { minY = y; } else if (y > maxY) { maxY = y; } if ((y = x_b + y_d + ty) < minY) { minY = y; } else if (y > maxY) { maxY = y; } if ((y = y_d + ty) < minY) { minY = y; } else if (y > maxY) { maxY = y; } return bounds.setValues(minX, minY, maxX-minX, maxY-minY); }; /** * Indicates whether the display object has any mouse event listeners or a cursor. * @method _isMouseOpaque * @return {Boolean} * @protected **/ p._hasMouseEventListener = function() { var evts = DisplayObject._MOUSE_EVENTS; for (var i= 0, l=evts.length; iExample * * var container = new createjs.Container(); * container.addChild(bitmapInstance, shapeInstance); * container.x = 100; * * @class Container * @extends DisplayObject * @constructor **/ function Container() { this.DisplayObject_constructor(); // public properties: /** * The array of children in the display list. You should usually use the child management methods such as * {{#crossLink "Container/addChild"}}{{/crossLink}}, {{#crossLink "Container/removeChild"}}{{/crossLink}}, * {{#crossLink "Container/swapChildren"}}{{/crossLink}}, etc, rather than accessing this directly, but it is * included for advanced uses. * @property children * @type Array * @default null **/ this.children = []; /** * Indicates whether the children of this container are independently enabled for mouse/pointer interaction. * If false, the children will be aggregated under the container - for example, a click on a child shape would * trigger a click event on the container. * @property mouseChildren * @type Boolean * @default true **/ this.mouseChildren = true; /** * If false, the tick will not be propagated to children of this Container. This can provide some performance benefits. * In addition to preventing the "tick" event from being dispatched, it will also prevent tick related updates * on some display objects (ex. Sprite & MovieClip frame advancing, DOMElement visibility handling). * @property tickChildren * @type Boolean * @default true **/ this.tickChildren = true; } var p = createjs.extend(Container, createjs.DisplayObject); // getter / setters: /** * Use the {{#crossLink "Container/numChildren:property"}}{{/crossLink}} property instead. * @method _getNumChildren * @protected * @return {Number} **/ p._getNumChildren = function() { return this.children.length; }; /** * Use the {{#crossLink "Container/numChildren:property"}}{{/crossLink}} property instead. * @method getNumChildren * @deprecated */ // Container.getNumChildren is @deprecated. Remove for 1.1+ p.getNumChildren = createjs.deprecate(p._getNumChildren, "Container.getNumChildren"); /** * Returns the number of children in the container. * @property numChildren * @type {Number} * @readonly **/ try { Object.defineProperties(p, { numChildren: { get: p._getNumChildren } }); } catch (e) {} // public methods: /** * Constructor alias for backwards compatibility. This method will be removed in future versions. * Subclasses should be updated to use {{#crossLink "Utility Methods/extends"}}{{/crossLink}}. * @method initialize * @deprecated in favour of `createjs.promote()` **/ p.initialize = Container; // TODO: deprecated. /** * Returns true or false indicating whether the display object would be visible if drawn to a canvas. * This does not account for whether it would be visible within the boundaries of the stage. * * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method isVisible * @return {Boolean} Boolean indicating whether the display object would be visible if drawn to a canvas **/ p.isVisible = function() { var hasContent = this.cacheCanvas || this.children.length; return !!(this.visible && this.alpha > 0 && this.scaleX != 0 && this.scaleY != 0 && hasContent); }; /** * Draws the display object into the specified context ignoring its visible, alpha, shadow, and transform. * Returns true if the draw was handled (useful for overriding functionality). * * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method draw * @param {CanvasRenderingContext2D} ctx The canvas 2D context object to draw into. * @param {Boolean} [ignoreCache=false] Indicates whether the draw operation should ignore any current cache. * For example, used for drawing the cache (to prevent it from simply drawing an existing cache back * into itself). **/ p.draw = function(ctx, ignoreCache) { if (this.DisplayObject_draw(ctx, ignoreCache)) { return true; } // this ensures we don't have issues with display list changes that occur during a draw: var list = this.children.slice(); for (var i=0,l=list.length; iExample * * container.addChild(bitmapInstance); * * You can also add multiple children at once: * * container.addChild(bitmapInstance, shapeInstance, textInstance); * * @method addChild * @param {DisplayObject} child The display object to add. * @return {DisplayObject} The child that was added, or the last child if multiple children were added. **/ p.addChild = function(child) { if (child == null) { return child; } var l = arguments.length; if (l > 1) { for (var i=0; iExample * * addChildAt(child1, index); * * You can also add multiple children, such as: * * addChildAt(child1, child2, ..., index); * * The index must be between 0 and numChildren. For example, to add myShape under otherShape in the display list, * you could use: * * container.addChildAt(myShape, container.getChildIndex(otherShape)); * * This would also bump otherShape's index up by one. Fails silently if the index is out of range. * * @method addChildAt * @param {DisplayObject} child The display object to add. * @param {Number} index The index to add the child at. * @return {DisplayObject} Returns the last child that was added, or the last child if multiple children were added. **/ p.addChildAt = function(child, index) { var l = arguments.length; var indx = arguments[l-1]; // can't use the same name as the index param or it replaces arguments[1] if (indx < 0 || indx > this.children.length) { return arguments[l-2]; } if (l > 2) { for (var i=0; iExample * * container.removeChild(child); * * You can also remove multiple children: * * removeChild(child1, child2, ...); * * Returns true if the child (or children) was removed, or false if it was not in the display list. * @method removeChild * @param {DisplayObject} child The child to remove. * @return {Boolean} true if the child (or children) was removed, or false if it was not in the display list. **/ p.removeChild = function(child) { var l = arguments.length; if (l > 1) { var good = true; for (var i=0; iExample * * container.removeChildAt(2); * * You can also remove multiple children: * * container.removeChild(2, 7, ...) * * Returns true if the child (or children) was removed, or false if any index was out of range. * @method removeChildAt * @param {Number} index The index of the child to remove. * @return {Boolean} true if the child (or children) was removed, or false if any index was out of range. **/ p.removeChildAt = function(index) { var l = arguments.length; if (l > 1) { var a = []; for (var i=0; iExample * * container.removeAllChildren(); * * @method removeAllChildren **/ p.removeAllChildren = function() { var kids = this.children; while (kids.length) { this._removeChildAt(0); } }; /** * Returns the child at the specified index. * *

Example

* * container.getChildAt(2); * * @method getChildAt * @param {Number} index The index of the child to return. * @return {DisplayObject} The child at the specified index. Returns null if there is no child at the index. **/ p.getChildAt = function(index) { return this.children[index]; }; /** * Returns the child with the specified name. * @method getChildByName * @param {String} name The name of the child to return. * @return {DisplayObject} The child with the specified name. **/ p.getChildByName = function(name) { var kids = this.children; for (var i=0,l=kids.length;iExample: Display children with a higher y in front. * * var sortFunction = function(obj1, obj2, options) { * if (obj1.y > obj2.y) { return 1; } * if (obj1.y < obj2.y) { return -1; } * return 0; * } * container.sortChildren(sortFunction); * * @method sortChildren * @param {Function} sortFunction the function to use to sort the child list. See JavaScript's `Array.sort` * documentation for details. **/ p.sortChildren = function(sortFunction) { this.children.sort(sortFunction); }; /** * Returns the index of the specified child in the display list, or -1 if it is not in the display list. * *

Example

* * var index = container.getChildIndex(child); * * @method getChildIndex * @param {DisplayObject} child The child to return the index of. * @return {Number} The index of the specified child. -1 if the child is not found. **/ p.getChildIndex = function(child) { return createjs.indexOf(this.children, child); }; /** * Swaps the children at the specified indexes. Fails silently if either index is out of range. * @method swapChildrenAt * @param {Number} index1 * @param {Number} index2 **/ p.swapChildrenAt = function(index1, index2) { var kids = this.children; var o1 = kids[index1]; var o2 = kids[index2]; if (!o1 || !o2) { return; } kids[index1] = o2; kids[index2] = o1; }; /** * Swaps the specified children's depth in the display list. Fails silently if either child is not a child of this * Container. * @method swapChildren * @param {DisplayObject} child1 * @param {DisplayObject} child2 **/ p.swapChildren = function(child1, child2) { var kids = this.children; var index1,index2; for (var i=0,l=kids.length;i= l) { return; } for (var i=0;i 0 at the * specified position). This ignores the alpha, shadow and compositeOperation of the display object, and all * transform properties including regX/Y. * @method hitTest * @param {Number} x The x position to check in the display object's local coordinates. * @param {Number} y The y position to check in the display object's local coordinates. * @return {Boolean} A Boolean indicating whether there is a visible section of a DisplayObject that overlaps the specified * coordinates. **/ p.hitTest = function(x, y) { // TODO: optimize to use the fast cache check where possible. return (this.getObjectUnderPoint(x, y) != null); }; /** * Returns an array of all display objects under the specified coordinates that are in this container's display * list. This routine ignores any display objects with {{#crossLink "DisplayObject/mouseEnabled:property"}}{{/crossLink}} * set to `false`. The array will be sorted in order of visual depth, with the top-most display object at index 0. * This uses shape based hit detection, and can be an expensive operation to run, so it is best to use it carefully. * For example, if testing for objects under the mouse, test on tick (instead of on {{#crossLink "Stage/stagemousemove:event"}}{{/crossLink}}), * and only if the mouse's position has changed. * *
    *
  • By default (mode=0) this method evaluates all display objects.
  • *
  • By setting the `mode` parameter to `1`, the {{#crossLink "DisplayObject/mouseEnabled:property"}}{{/crossLink}} * and {{#crossLink "mouseChildren:property"}}{{/crossLink}} properties will be respected.
  • *
  • Setting the `mode` to `2` additionally excludes display objects that do not have active mouse event * listeners or a {{#crossLink "DisplayObject:cursor:property"}}{{/crossLink}} property. That is, only objects * that would normally intercept mouse interaction will be included. This can significantly improve performance * in some cases by reducing the number of display objects that need to be tested.
  • *
* * This method accounts for both {{#crossLink "DisplayObject/hitArea:property"}}{{/crossLink}} and {{#crossLink "DisplayObject/mask:property"}}{{/crossLink}}. * @method getObjectsUnderPoint * @param {Number} x The x position in the container to test. * @param {Number} y The y position in the container to test. * @param {Number} [mode=0] The mode to use to determine which display objects to include. 0-all, 1-respect mouseEnabled/mouseChildren, 2-only mouse opaque objects. * @return {Array} An Array of DisplayObjects under the specified coordinates. **/ p.getObjectsUnderPoint = function(x, y, mode) { var arr = []; var pt = this.localToGlobal(x, y); this._getObjectsUnderPoint(pt.x, pt.y, arr, mode>0, mode==1); return arr; }; /** * Similar to {{#crossLink "Container/getObjectsUnderPoint"}}{{/crossLink}}, but returns only the top-most display * object. This runs significantly faster than `getObjectsUnderPoint()`, but is still potentially an expensive * operation. See {{#crossLink "Container/getObjectsUnderPoint"}}{{/crossLink}} for more information. * @method getObjectUnderPoint * @param {Number} x The x position in the container to test. * @param {Number} y The y position in the container to test. * @param {Number} mode The mode to use to determine which display objects to include. 0-all, 1-respect mouseEnabled/mouseChildren, 2-only mouse opaque objects. * @return {DisplayObject} The top-most display object under the specified coordinates. **/ p.getObjectUnderPoint = function(x, y, mode) { var pt = this.localToGlobal(x, y); return this._getObjectsUnderPoint(pt.x, pt.y, null, mode>0, mode==1); }; // Docced in superclass p.getBounds = function() { return this._getBounds(null, true); }; // Docced in superclass p.getTransformedBounds = function() { return this._getBounds(); }; /** * Returns a clone of this Container. Some properties that are specific to this instance's current context are * reverted to their defaults (for example .parent). * @method clone * @param {Boolean} [recursive=false] If true, all of the descendants of this container will be cloned recursively. If false, the * properties of the container will be cloned, but the new instance will not have any children. * @return {Container} A clone of the current Container instance. **/ p.clone = function(recursive) { var o = this._cloneProps(new Container()); if (recursive) { this._cloneChildren(o); } return o; }; /** * Returns a string representation of this object. * @method toString * @return {String} a string representation of the instance. **/ p.toString = function() { return "[Container (name="+ this.name +")]"; }; // private methods: /** * @method _tick * @param {Object} evtObj An event object that will be dispatched to all tick listeners. This object is reused between dispatchers to reduce construction & GC costs. * @protected **/ p._tick = function(evtObj) { if (this.tickChildren) { for (var i=this.children.length-1; i>=0; i--) { var child = this.children[i]; if (child.tickEnabled && child._tick) { child._tick(evtObj); } } } this.DisplayObject__tick(evtObj); }; /** * Recursively clones all children of this container, and adds them to the target container. * @method cloneChildren * @protected * @param {Container} o The target container. **/ p._cloneChildren = function(o) { if (o.children.length) { o.removeAllChildren(); } var arr = o.children; for (var i=0, l=this.children.length; i this.children.length-1) { return false; } var child = this.children[index]; if (child) { child.parent = null; } this.children.splice(index, 1); if (!silent) { child.dispatchEvent("removed"); } return true; }; /** * @method _getObjectsUnderPoint * @param {Number} x * @param {Number} y * @param {Array} arr * @param {Boolean} mouse If true, it will respect mouse interaction properties like mouseEnabled, mouseChildren, and active listeners. * @param {Boolean} activeListener If true, there is an active mouse event listener on a parent object. * @param {Number} currentDepth Indicates the current depth of the search. * @return {DisplayObject} * @protected **/ p._getObjectsUnderPoint = function(x, y, arr, mouse, activeListener, currentDepth) { currentDepth = currentDepth || 0; if (!currentDepth && !this._testMask(this, x, y)) { return null; } var mtx, ctx = createjs.DisplayObject._hitTestContext; activeListener = activeListener || (mouse&&this._hasMouseEventListener()); // draw children one at a time, and check if we get a hit: var children = this.children, l = children.length; for (var i=l-1; i>=0; i--) { var child = children[i]; var hitArea = child.hitArea; if (!child.visible || (!hitArea && !child.isVisible()) || (mouse && !child.mouseEnabled)) { continue; } if (!hitArea && !this._testMask(child, x, y)) { continue; } // if a child container has a hitArea then we only need to check its hitAre2a, so we can treat it as a normal DO: if (!hitArea && child instanceof Container) { var result = child._getObjectsUnderPoint(x, y, arr, mouse, activeListener, currentDepth+1); if (!arr && result) { return (mouse && !this.mouseChildren) ? this : result; } } else { if (mouse && !activeListener && !child._hasMouseEventListener()) { continue; } // TODO: can we pass displayProps forward, to avoid having to calculate this backwards every time? It's kind of a mixed bag. When we're only hunting for DOs with event listeners, it may not make sense. var props = child.getConcatenatedDisplayProps(child._props); mtx = props.matrix; if (hitArea) { mtx.appendMatrix(hitArea.getMatrix(hitArea._props.matrix)); props.alpha = hitArea.alpha; } ctx.globalAlpha = props.alpha; ctx.setTransform(mtx.a, mtx.b, mtx.c, mtx.d, mtx.tx-x, mtx.ty-y); (hitArea||child).draw(ctx); if (!this._testHit(ctx)) { continue; } ctx.setTransform(1, 0, 0, 1, 0, 0); ctx.clearRect(0, 0, 2, 2); if (arr) { arr.push(child); } else { return (mouse && !this.mouseChildren) ? this : child; } } } return null; }; /** * @method _testMask * @param {DisplayObject} target * @param {Number} x * @param {Number} y * @return {Boolean} Indicates whether the x/y is within the masked region. * @protected **/ p._testMask = function(target, x, y) { var mask = target.mask; if (!mask || !mask.graphics || mask.graphics.isEmpty()) { return true; } var mtx = this._props.matrix, parent = target.parent; mtx = parent ? parent.getConcatenatedMatrix(mtx) : mtx.identity(); mtx = mask.getMatrix(mask._props.matrix).prependMatrix(mtx); var ctx = createjs.DisplayObject._hitTestContext; ctx.setTransform(mtx.a, mtx.b, mtx.c, mtx.d, mtx.tx-x, mtx.ty-y); // draw the mask as a solid fill: mask.graphics.drawAsPath(ctx); ctx.fillStyle = "#000"; ctx.fill(); if (!this._testHit(ctx)) { return false; } ctx.setTransform(1, 0, 0, 1, 0, 0); ctx.clearRect(0, 0, 2, 2); return true; }; /** * @method _getBounds * @param {Matrix2D} matrix * @param {Boolean} ignoreTransform If true, does not apply this object's transform. * @return {Rectangle} * @protected **/ p._getBounds = function(matrix, ignoreTransform) { var bounds = this.DisplayObject_getBounds(); if (bounds) { return this._transformBounds(bounds, matrix, ignoreTransform); } var mtx = this._props.matrix; mtx = ignoreTransform ? mtx.identity() : this.getMatrix(mtx); if (matrix) { mtx.prependMatrix(matrix); } var l = this.children.length, rect=null; for (var i=0; iExample * This example creates a stage, adds a child to it, then uses {{#crossLink "Ticker"}}{{/crossLink}} to update the child * and redraw the stage using {{#crossLink "Stage/update"}}{{/crossLink}}. * * var stage = new createjs.Stage("canvasElementId"); * var image = new createjs.Bitmap("imagePath.png"); * stage.addChild(image); * createjs.Ticker.addEventListener("tick", handleTick); * function handleTick(event) { * image.x += 10; * stage.update(); * } * * @class Stage * @extends Container * @constructor * @param {HTMLCanvasElement | String | Object} canvas A canvas object that the Stage will render to, or the string id * of a canvas object in the current document. **/ function Stage(canvas) { this.Container_constructor(); // public properties: /** * Indicates whether the stage should automatically clear the canvas before each render. You can set this to false * to manually control clearing (for generative art, or when pointing multiple stages at the same canvas for * example). * *

Example

* * var stage = new createjs.Stage("canvasId"); * stage.autoClear = false; * * @property autoClear * @type Boolean * @default true **/ this.autoClear = true; /** * The canvas the stage will render to. Multiple stages can share a single canvas, but you must disable autoClear for all but the * first stage that will be ticked (or they will clear each other's render). * * When changing the canvas property you must disable the events on the old canvas, and enable events on the * new canvas or mouse events will not work as expected. For example: * * myStage.enableDOMEvents(false); * myStage.canvas = anotherCanvas; * myStage.enableDOMEvents(true); * * @property canvas * @type HTMLCanvasElement | Object **/ this.canvas = (typeof canvas == "string") ? document.getElementById(canvas) : canvas; /** * The current mouse X position on the canvas. If the mouse leaves the canvas, this will indicate the most recent * position over the canvas, and mouseInBounds will be set to false. * @property mouseX * @type Number * @readonly **/ this.mouseX = 0; /** * The current mouse Y position on the canvas. If the mouse leaves the canvas, this will indicate the most recent * position over the canvas, and mouseInBounds will be set to false. * @property mouseY * @type Number * @readonly **/ this.mouseY = 0; /** * Specifies the area of the stage to affect when calling update. This can be use to selectively * re-draw specific regions of the canvas. If null, the whole canvas area is drawn. * @property drawRect * @type {Rectangle} */ this.drawRect = null; /** * Indicates whether display objects should be rendered on whole pixels. You can set the * {{#crossLink "DisplayObject/snapToPixel"}}{{/crossLink}} property of * display objects to false to enable/disable this behaviour on a per instance basis. * @property snapToPixelEnabled * @type Boolean * @default false **/ this.snapToPixelEnabled = false; /** * Indicates whether the mouse is currently within the bounds of the canvas. * @property mouseInBounds * @type Boolean * @default false **/ this.mouseInBounds = false; /** * If true, tick callbacks will be called on all display objects on the stage prior to rendering to the canvas. * @property tickOnUpdate * @type Boolean * @default true **/ this.tickOnUpdate = true; /** * If true, mouse move events will continue to be called when the mouse leaves the target canvas. See * {{#crossLink "Stage/mouseInBounds:property"}}{{/crossLink}}, and {{#crossLink "MouseEvent"}}{{/crossLink}} * x/y/rawX/rawY. * @property mouseMoveOutside * @type Boolean * @default false **/ this.mouseMoveOutside = false; /** * Prevents selection of other elements in the html page if the user clicks and drags, or double clicks on the canvas. * This works by calling `preventDefault()` on any mousedown events (or touch equivalent) originating on the canvas. * @property preventSelection * @type Boolean * @default true **/ this.preventSelection = true; /** * The hitArea property is not supported for Stage. * @property hitArea * @type {DisplayObject} * @default null */ // private properties: /** * Holds objects with data for each active pointer id. Each object has the following properties: * x, y, event, target, overTarget, overX, overY, inBounds, posEvtObj (native event that last updated position) * @property _pointerData * @type {Object} * @private */ this._pointerData = {}; /** * Number of active pointers. * @property _pointerCount * @type {Object} * @private */ this._pointerCount = 0; /** * The ID of the primary pointer. * @property _primaryPointerID * @type {Object} * @private */ this._primaryPointerID = null; /** * @property _mouseOverIntervalID * @protected * @type Number **/ this._mouseOverIntervalID = null; /** * @property _nextStage * @protected * @type Stage **/ this._nextStage = null; /** * @property _prevStage * @protected * @type Stage **/ this._prevStage = null; // initialize: this.enableDOMEvents(true); } var p = createjs.extend(Stage, createjs.Container); // events: /** * Dispatched when the user moves the mouse over the canvas. * See the {{#crossLink "MouseEvent"}}{{/crossLink}} class for a listing of event properties. * @event stagemousemove * @since 0.6.0 */ /** * Dispatched when the user presses their left mouse button on the canvas. See the {{#crossLink "MouseEvent"}}{{/crossLink}} * class for a listing of event properties. * @event stagemousedown * @since 0.6.0 */ /** * Dispatched when the user the user presses somewhere on the stage, then releases the mouse button anywhere that the page can detect it (this varies slightly between browsers). * You can use {{#crossLink "Stage/mouseInBounds:property"}}{{/crossLink}} to check whether the mouse is currently within the stage bounds. * See the {{#crossLink "MouseEvent"}}{{/crossLink}} class for a listing of event properties. * @event stagemouseup * @since 0.6.0 */ /** * Dispatched when the mouse moves from within the canvas area (mouseInBounds == true) to outside it (mouseInBounds == false). * This is currently only dispatched for mouse input (not touch). See the {{#crossLink "MouseEvent"}}{{/crossLink}} * class for a listing of event properties. * @event mouseleave * @since 0.7.0 */ /** * Dispatched when the mouse moves into the canvas area (mouseInBounds == false) from outside it (mouseInBounds == true). * This is currently only dispatched for mouse input (not touch). See the {{#crossLink "MouseEvent"}}{{/crossLink}} * class for a listing of event properties. * @event mouseenter * @since 0.7.0 */ /** * Dispatched each update immediately before the tick event is propagated through the display list. * You can call preventDefault on the event object to cancel propagating the tick event. * @event tickstart * @since 0.7.0 */ /** * Dispatched each update immediately after the tick event is propagated through the display list. Does not fire if * tickOnUpdate is false. Precedes the "drawstart" event. * @event tickend * @since 0.7.0 */ /** * Dispatched each update immediately before the canvas is cleared and the display list is drawn to it. * You can call preventDefault on the event object to cancel the draw. * @event drawstart * @since 0.7.0 */ /** * Dispatched each update immediately after the display list is drawn to the canvas and the canvas context is restored. * @event drawend * @since 0.7.0 */ // getter / setters: /** * Specifies a target stage that will have mouse / touch interactions relayed to it after this stage handles them. * This can be useful in cases where you have multiple layered canvases and want user interactions * events to pass through. For example, this would relay mouse events from topStage to bottomStage: * * topStage.nextStage = bottomStage; * * To disable relaying, set nextStage to null. * * MouseOver, MouseOut, RollOver, and RollOut interactions are also passed through using the mouse over settings * of the top-most stage, but are only processed if the target stage has mouse over interactions enabled. * Considerations when using roll over in relay targets:
    *
  1. The top-most (first) stage must have mouse over interactions enabled (via enableMouseOver)
  2. *
  3. All stages that wish to participate in mouse over interaction must enable them via enableMouseOver
  4. *
  5. All relay targets will share the frequency value of the top-most stage
  6. *
* To illustrate, in this example the targetStage would process mouse over interactions at 10hz (despite passing * 30 as it's desired frequency): * topStage.nextStage = targetStage; * topStage.enableMouseOver(10); * targetStage.enableMouseOver(30); * * If the target stage's canvas is completely covered by this stage's canvas, you may also want to disable its * DOM events using: * * targetStage.enableDOMEvents(false); * * @property nextStage * @type {Stage} **/ p._get_nextStage = function() { return this._nextStage; }; p._set_nextStage = function(value) { if (this._nextStage) { this._nextStage._prevStage = null; } if (value) { value._prevStage = this; } this._nextStage = value; }; try { Object.defineProperties(p, { nextStage: { get: p._get_nextStage, set: p._set_nextStage } }); } catch (e) {} // TODO: use Log // public methods: /** * Each time the update method is called, the stage will call {{#crossLink "Stage/tick"}}{{/crossLink}} * unless {{#crossLink "Stage/tickOnUpdate:property"}}{{/crossLink}} is set to false, * and then render the display list to the canvas. * * @method update * @param {Object} [props] Props object to pass to `tick()`. Should usually be a {{#crossLink "Ticker"}}{{/crossLink}} event object, or similar object with a delta property. **/ p.update = function(props) { if (!this.canvas) { return; } if (this.tickOnUpdate) { this.tick(props); } if (this.dispatchEvent("drawstart", false, true) === false) { return; } createjs.DisplayObject._snapToPixelEnabled = this.snapToPixelEnabled; var r = this.drawRect, ctx = this.canvas.getContext("2d"); ctx.setTransform(1, 0, 0, 1, 0, 0); if (this.autoClear) { if (r) { ctx.clearRect(r.x, r.y, r.width, r.height); } else { ctx.clearRect(0, 0, this.canvas.width+1, this.canvas.height+1); } } ctx.save(); if (this.drawRect) { ctx.beginPath(); ctx.rect(r.x, r.y, r.width, r.height); ctx.clip(); } this.updateContext(ctx); this.draw(ctx, false); ctx.restore(); this.dispatchEvent("drawend"); }; /** * Draws the stage into the specified context ignoring its visible, alpha, shadow, and transform. * Returns true if the draw was handled (useful for overriding functionality). * * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method draw * @param {CanvasRenderingContext2D} ctx The canvas 2D context object to draw into. * @param {Boolean} [ignoreCache=false] Indicates whether the draw operation should ignore any current cache. * For example, used for drawing the cache (to prevent it from simply drawing an existing cache back * into itself). **/ p.draw = function(ctx, ignoreCache) { var result = this.Container_draw(ctx, ignoreCache); this.canvas._invalid = true; return result; }; /** * Propagates a tick event through the display list. This is automatically called by {{#crossLink "Stage/update"}}{{/crossLink}} * unless {{#crossLink "Stage/tickOnUpdate:property"}}{{/crossLink}} is set to false. * * If a props object is passed to `tick()`, then all of its properties will be copied to the event object that is * propagated to listeners. * * Some time-based features in EaselJS (for example {{#crossLink "Sprite/framerate"}}{{/crossLink}} require that * a {{#crossLink "Ticker/tick:event"}}{{/crossLink}} event object (or equivalent object with a delta property) be * passed as the `props` parameter to `tick()`. For example: * * Ticker.on("tick", handleTick); * function handleTick(evtObj) { * // clone the event object from Ticker, and add some custom data to it: * var evt = evtObj.clone().set({greeting:"hello", name:"world"}); * * // pass it to stage.update(): * myStage.update(evt); // subsequently calls tick() with the same param * } * * // ... * myDisplayObject.on("tick", handleDisplayObjectTick); * function handleDisplayObjectTick(evt) { * console.log(evt.delta); // the delta property from the Ticker tick event object * console.log(evt.greeting, evt.name); // custom data: "hello world" * } * * @method tick * @param {Object} [props] An object with properties that should be copied to the event object. Should usually be a Ticker event object, or similar object with a delta property. **/ p.tick = function(props) { if (!this.tickEnabled || this.dispatchEvent("tickstart", false, true) === false) { return; } var evtObj = new createjs.Event("tick"); if (props) { for (var n in props) { if (props.hasOwnProperty(n)) { evtObj[n] = props[n]; } } } this._tick(evtObj); this.dispatchEvent("tickend"); }; /** * Default event handler that calls the Stage {{#crossLink "Stage/update"}}{{/crossLink}} method when a {{#crossLink "DisplayObject/tick:event"}}{{/crossLink}} * event is received. This allows you to register a Stage instance as a event listener on {{#crossLink "Ticker"}}{{/crossLink}} * directly, using: * * Ticker.addEventListener("tick", myStage); * * Note that if you subscribe to ticks using this pattern, then the tick event object will be passed through to * display object tick handlers, instead of delta and paused parameters. * @property handleEvent * @type Function **/ p.handleEvent = function(evt) { if (evt.type == "tick") { this.update(evt); } }; /** * Clears the target canvas. Useful if {{#crossLink "Stage/autoClear:property"}}{{/crossLink}} is set to `false`. * @method clear **/ p.clear = function() { if (!this.canvas) { return; } var ctx = this.canvas.getContext("2d"); ctx.setTransform(1, 0, 0, 1, 0, 0); ctx.clearRect(0, 0, this.canvas.width+1, this.canvas.height+1); }; /** * Returns a data url that contains a Base64-encoded image of the contents of the stage. The returned data url can * be specified as the src value of an image element. * @method toDataURL * @param {String} [backgroundColor] The background color to be used for the generated image. Any valid CSS color * value is allowed. The default value is a transparent background. * @param {String} [mimeType="image/png"] The MIME type of the image format to be create. The default is "image/png". If an unknown MIME type * is passed in, or if the browser does not support the specified MIME type, the default value will be used. * @return {String} a Base64 encoded image. **/ p.toDataURL = function(backgroundColor, mimeType) { var data, ctx = this.canvas.getContext('2d'), w = this.canvas.width, h = this.canvas.height; if (backgroundColor) { data = ctx.getImageData(0, 0, w, h); var compositeOperation = ctx.globalCompositeOperation; ctx.globalCompositeOperation = "destination-over"; ctx.fillStyle = backgroundColor; ctx.fillRect(0, 0, w, h); } var dataURL = this.canvas.toDataURL(mimeType||"image/png"); if(backgroundColor) { ctx.putImageData(data, 0, 0); ctx.globalCompositeOperation = compositeOperation; } return dataURL; }; /** * Enables or disables (by passing a frequency of 0) mouse over ({{#crossLink "DisplayObject/mouseover:event"}}{{/crossLink}} * and {{#crossLink "DisplayObject/mouseout:event"}}{{/crossLink}}) and roll over events ({{#crossLink "DisplayObject/rollover:event"}}{{/crossLink}} * and {{#crossLink "DisplayObject/rollout:event"}}{{/crossLink}}) for this stage's display list. These events can * be expensive to generate, so they are disabled by default. The frequency of the events can be controlled * independently of mouse move events via the optional `frequency` parameter. * *

Example

* * var stage = new createjs.Stage("canvasId"); * stage.enableMouseOver(10); // 10 updates per second * * @method enableMouseOver * @param {Number} [frequency=20] Optional param specifying the maximum number of times per second to broadcast * mouse over/out events. Set to 0 to disable mouse over events completely. Maximum is 50. A lower frequency is less * responsive, but uses less CPU. **/ p.enableMouseOver = function(frequency) { if (this._mouseOverIntervalID) { clearInterval(this._mouseOverIntervalID); this._mouseOverIntervalID = null; if (frequency == 0) { this._testMouseOver(true); } } if (frequency == null) { frequency = 20; } else if (frequency <= 0) { return; } var o = this; this._mouseOverIntervalID = setInterval(function(){ o._testMouseOver(); }, 1000/Math.min(50,frequency)); }; /** * Enables or disables the event listeners that stage adds to DOM elements (window, document and canvas). It is good * practice to disable events when disposing of a Stage instance, otherwise the stage will continue to receive * events from the page. * * When changing the canvas property you must disable the events on the old canvas, and enable events on the * new canvas or mouse events will not work as expected. For example: * * myStage.enableDOMEvents(false); * myStage.canvas = anotherCanvas; * myStage.enableDOMEvents(true); * * @method enableDOMEvents * @param {Boolean} [enable=true] Indicates whether to enable or disable the events. Default is true. **/ p.enableDOMEvents = function(enable) { if (enable == null) { enable = true; } var n, o, ls = this._eventListeners; if (!enable && ls) { for (n in ls) { o = ls[n]; o.t.removeEventListener(n, o.f, false); } this._eventListeners = null; } else if (enable && !ls && this.canvas) { var t = window.addEventListener ? window : document; var _this = this; ls = this._eventListeners = {}; ls["mouseup"] = {t:t, f:function(e) { _this._handleMouseUp(e)} }; ls["mousemove"] = {t:t, f:function(e) { _this._handleMouseMove(e)} }; ls["dblclick"] = {t:this.canvas, f:function(e) { _this._handleDoubleClick(e)} }; ls["mousedown"] = {t:this.canvas, f:function(e) { _this._handleMouseDown(e)} }; for (n in ls) { o = ls[n]; o.t.addEventListener(n, o.f, false); } } }; /** * Stage instances cannot be cloned. * @method clone **/ p.clone = function() { throw("Stage cannot be cloned."); }; /** * Returns a string representation of this object. * @method toString * @return {String} a string representation of the instance. **/ p.toString = function() { return "[Stage (name="+ this.name +")]"; }; // private methods: /** * @method _getElementRect * @protected * @param {HTMLElement} e **/ p._getElementRect = function(e) { var bounds; try { bounds = e.getBoundingClientRect(); } // this can fail on disconnected DOM elements in IE9 catch (err) { bounds = {top: e.offsetTop, left: e.offsetLeft, width:e.offsetWidth, height:e.offsetHeight}; } var offX = (window.pageXOffset || document.scrollLeft || 0) - (document.clientLeft || document.body.clientLeft || 0); var offY = (window.pageYOffset || document.scrollTop || 0) - (document.clientTop || document.body.clientTop || 0); var styles = window.getComputedStyle ? getComputedStyle(e,null) : e.currentStyle; // IE <9 compatibility. var padL = parseInt(styles.paddingLeft)+parseInt(styles.borderLeftWidth); var padT = parseInt(styles.paddingTop)+parseInt(styles.borderTopWidth); var padR = parseInt(styles.paddingRight)+parseInt(styles.borderRightWidth); var padB = parseInt(styles.paddingBottom)+parseInt(styles.borderBottomWidth); // note: in some browsers bounds properties are read only. return { left: bounds.left+offX+padL, right: bounds.right+offX-padR, top: bounds.top+offY+padT, bottom: bounds.bottom+offY-padB } }; /** * @method _getPointerData * @protected * @param {Number} id **/ p._getPointerData = function(id) { var data = this._pointerData[id]; if (!data) { data = this._pointerData[id] = {x:0,y:0}; } return data; }; /** * @method _handleMouseMove * @protected * @param {MouseEvent} e **/ p._handleMouseMove = function(e) { if(!e){ e = window.event; } this._handlePointerMove(-1, e, e.pageX, e.pageY); }; /** * @method _handlePointerMove * @protected * @param {Number} id * @param {Event} e * @param {Number} pageX * @param {Number} pageY * @param {Stage} owner Indicates that the event has already been captured & handled by the indicated stage. **/ p._handlePointerMove = function(id, e, pageX, pageY, owner) { if (this._prevStage && owner === undefined) { return; } // redundant listener. if (!this.canvas) { return; } var nextStage=this._nextStage, o=this._getPointerData(id); var inBounds = o.inBounds; this._updatePointerPosition(id, e, pageX, pageY); if (inBounds || o.inBounds || this.mouseMoveOutside) { if (id === -1 && o.inBounds == !inBounds) { this._dispatchMouseEvent(this, (inBounds ? "mouseleave" : "mouseenter"), false, id, o, e); } this._dispatchMouseEvent(this, "stagemousemove", false, id, o, e); this._dispatchMouseEvent(o.target, "pressmove", true, id, o, e); } nextStage&&nextStage._handlePointerMove(id, e, pageX, pageY, null); }; /** * @method _updatePointerPosition * @protected * @param {Number} id * @param {Event} e * @param {Number} pageX * @param {Number} pageY **/ p._updatePointerPosition = function(id, e, pageX, pageY) { var rect = this._getElementRect(this.canvas); pageX -= rect.left; pageY -= rect.top; var w = this.canvas.width; var h = this.canvas.height; pageX /= (rect.right-rect.left)/w; pageY /= (rect.bottom-rect.top)/h; var o = this._getPointerData(id); if (o.inBounds = (pageX >= 0 && pageY >= 0 && pageX <= w-1 && pageY <= h-1)) { o.x = pageX; o.y = pageY; } else if (this.mouseMoveOutside) { o.x = pageX < 0 ? 0 : (pageX > w-1 ? w-1 : pageX); o.y = pageY < 0 ? 0 : (pageY > h-1 ? h-1 : pageY); } o.posEvtObj = e; o.rawX = pageX; o.rawY = pageY; if (id === this._primaryPointerID || id === -1) { this.mouseX = o.x; this.mouseY = o.y; this.mouseInBounds = o.inBounds; } }; /** * @method _handleMouseUp * @protected * @param {MouseEvent} e **/ p._handleMouseUp = function(e) { this._handlePointerUp(-1, e, false); }; /** * @method _handlePointerUp * @protected * @param {Number} id * @param {Event} e * @param {Boolean} clear * @param {Stage} owner Indicates that the event has already been captured & handled by the indicated stage. **/ p._handlePointerUp = function(id, e, clear, owner) { var nextStage = this._nextStage, o = this._getPointerData(id); if (this._prevStage && owner === undefined) { return; } // redundant listener. var target=null, oTarget = o.target; if (!owner && (oTarget || nextStage)) { target = this._getObjectsUnderPoint(o.x, o.y, null, true); } if (o.down) { this._dispatchMouseEvent(this, "stagemouseup", false, id, o, e, target); o.down = false; } if (target == oTarget) { this._dispatchMouseEvent(oTarget, "click", true, id, o, e); } this._dispatchMouseEvent(oTarget, "pressup", true, id, o, e); if (clear) { if (id==this._primaryPointerID) { this._primaryPointerID = null; } delete(this._pointerData[id]); } else { o.target = null; } nextStage&&nextStage._handlePointerUp(id, e, clear, owner || target && this); }; /** * @method _handleMouseDown * @protected * @param {MouseEvent} e **/ p._handleMouseDown = function(e) { this._handlePointerDown(-1, e, e.pageX, e.pageY); }; /** * @method _handlePointerDown * @protected * @param {Number} id * @param {Event} e * @param {Number} pageX * @param {Number} pageY * @param {Stage} owner Indicates that the event has already been captured & handled by the indicated stage. **/ p._handlePointerDown = function(id, e, pageX, pageY, owner) { if (this.preventSelection) { e.preventDefault(); } if (this._primaryPointerID == null || id === -1) { this._primaryPointerID = id; } // mouse always takes over. if (pageY != null) { this._updatePointerPosition(id, e, pageX, pageY); } var target = null, nextStage = this._nextStage, o = this._getPointerData(id); if (!owner) { target = o.target = this._getObjectsUnderPoint(o.x, o.y, null, true); } if (o.inBounds) { this._dispatchMouseEvent(this, "stagemousedown", false, id, o, e, target); o.down = true; } this._dispatchMouseEvent(target, "mousedown", true, id, o, e); nextStage&&nextStage._handlePointerDown(id, e, pageX, pageY, owner || target && this); }; /** * @method _testMouseOver * @param {Boolean} clear If true, clears the mouseover / rollover (ie. no target) * @param {Stage} owner Indicates that the event has already been captured & handled by the indicated stage. * @param {Stage} eventTarget The stage that the cursor is actively over. * @protected **/ p._testMouseOver = function(clear, owner, eventTarget) { if (this._prevStage && owner === undefined) { return; } // redundant listener. var nextStage = this._nextStage; if (!this._mouseOverIntervalID) { // not enabled for mouseover, but should still relay the event. nextStage&&nextStage._testMouseOver(clear, owner, eventTarget); return; } var o = this._getPointerData(-1); // only update if the mouse position has changed. This provides a lot of optimization, but has some trade-offs. if (!o || (!clear && this.mouseX == this._mouseOverX && this.mouseY == this._mouseOverY && this.mouseInBounds)) { return; } var e = o.posEvtObj; var isEventTarget = eventTarget || e&&(e.target == this.canvas); var target=null, common = -1, cursor="", t, i, l; if (!owner && (clear || this.mouseInBounds && isEventTarget)) { target = this._getObjectsUnderPoint(this.mouseX, this.mouseY, null, true); this._mouseOverX = this.mouseX; this._mouseOverY = this.mouseY; } var oldList = this._mouseOverTarget||[]; var oldTarget = oldList[oldList.length-1]; var list = this._mouseOverTarget = []; // generate ancestor list and check for cursor: t = target; while (t) { list.unshift(t); if (!cursor) { cursor = t.cursor; } t = t.parent; } this.canvas.style.cursor = cursor; if (!owner && eventTarget) { eventTarget.canvas.style.cursor = cursor; } // find common ancestor: for (i=0,l=list.length; icommon; i--) { this._dispatchMouseEvent(oldList[i], "rollout", false, -1, o, e, target); } for (i=list.length-1; i>common; i--) { this._dispatchMouseEvent(list[i], "rollover", false, -1, o, e, oldTarget); } if (oldTarget != target) { this._dispatchMouseEvent(target, "mouseover", true, -1, o, e, oldTarget); } nextStage&&nextStage._testMouseOver(clear, owner || target && this, eventTarget || isEventTarget && this); }; /** * @method _handleDoubleClick * @protected * @param {MouseEvent} e * @param {Stage} owner Indicates that the event has already been captured & handled by the indicated stage. **/ p._handleDoubleClick = function(e, owner) { var target=null, nextStage=this._nextStage, o=this._getPointerData(-1); if (!owner) { target = this._getObjectsUnderPoint(o.x, o.y, null, true); this._dispatchMouseEvent(target, "dblclick", true, -1, o, e); } nextStage&&nextStage._handleDoubleClick(e, owner || target && this); }; /** * @method _dispatchMouseEvent * @protected * @param {DisplayObject} target * @param {String} type * @param {Boolean} bubbles * @param {Number} pointerId * @param {Object} o * @param {MouseEvent} [nativeEvent] * @param {DisplayObject} [relatedTarget] **/ p._dispatchMouseEvent = function(target, type, bubbles, pointerId, o, nativeEvent, relatedTarget) { // TODO: might be worth either reusing MouseEvent instances, or adding a willTrigger method to avoid GC. if (!target || (!bubbles && !target.hasEventListener(type))) { return; } /* // TODO: account for stage transformations? this._mtx = this.getConcatenatedMatrix(this._mtx).invert(); var pt = this._mtx.transformPoint(o.x, o.y); var evt = new createjs.MouseEvent(type, bubbles, false, pt.x, pt.y, nativeEvent, pointerId, pointerId==this._primaryPointerID || pointerId==-1, o.rawX, o.rawY); */ var evt = new createjs.MouseEvent(type, bubbles, false, o.x, o.y, nativeEvent, pointerId, pointerId === this._primaryPointerID || pointerId === -1, o.rawX, o.rawY, relatedTarget); target.dispatchEvent(evt); }; createjs.Stage = createjs.promote(Stage, "Container"); }()); //############################################################################## // StageGL.js //############################################################################## this.createjs = this.createjs||{}; /* * README IF EDITING: * * - Terminology for developers: * Vertex: a point that help defines a shape, 3 per triangle. Usually has an x,y,z but can have more/less info. * Vertex Property: a piece of information attached to the vertex like a vector3 containing x,y,z * Index/Indices: used in groups of 3 to define a triangle, points to vertices by their index in an array (some render * modes do not use these) * Card: a group of 2 triangles used to display a rectangular image * UV: common names for the [0-1] texture co-ordinates on an image * Batch: a single call to the renderer, best done as little as possible. Multiple cards are batched for this reason * Program/Shader: For every vertex we run the Vertex shader. The results are used per pixel by the Fragment shader. When * combined and paired these are a "shader program" * Texture: WebGL representation of image data and associated extra information, separate from a DOM Image * Slot: A space on the GPU into which textures can be loaded for use in a batch, i.e. using "ActiveTexture" switches texture slot. * Render___: actual WebGL draw call * Buffer: WebGL array data * Cover: A card that covers the entire viewport * Dst: The existing drawing surface in the shader * Src: The new data being provided in the shader * * - Notes: * WebGL treats 0,0 as the bottom left, as such there's a lot of co-ordinate space flipping to make regular canvas * numbers make sense to users and WebGL simultaneously. This extends to textures stored in memory too. If writing * code that deals with x/y, be aware your y may be flipped. * Older versions had distinct internal paths for filters and regular draws, these have been merged. * Draws are slowly assembled out of found content. Overflowing things like shaders, object/texture count will cause * an early draw before continuing. Lookout for the things that force a draw. Marked with <------------------------ */ (function () { "use strict"; /** * A StageGL instance is the root level {{#crossLink "Container"}}{{/crossLink}} for a WebGL-optimized display list, * which can be used in place of the usual {{#crossLink "Stage"}}{{/crossLink}}. This class should behave identically * to a {{#crossLink "Stage"}}{{/crossLink}} except for WebGL-specific functionality. * * Each time the {{#crossLink "Stage/tick"}}{{/crossLink}} method is called, the display list is rendered to the * target <canvas/> instance, ignoring non-WebGL-compatible display objects. On devices and browsers that don't * support WebGL, content will automatically be rendered to canvas 2D context instead. * *

Limitations

* - {{#crossLink "Shape"}}{{/crossLink}}, {{#crossLink "Shadow"}}{{/crossLink}}, and {{#crossLink "Text"}}{{/crossLink}} * are not rendered when added to the display list. * - To display something StageGL cannot render, {{#crossLink "displayObject/cache"}}{{/crossLink}} the object. * Caches can be rendered regardless of source. * - Images are wrapped as a webGL "Texture". Each graphics card has a limit to its concurrent Textures, too many * Textures will noticeably slow performance. * - Each cache counts as an individual Texture. As such {{#crossLink "SpriteSheet"}}{{/crossLink}} and * {{#crossLink "SpriteSheetBuilder"}}{{/crossLink}} are recommended practices to help keep texture counts low. * - To use any image node (DOM Image/Canvas Element) between multiple StageGL instances it must be a * {{#crossLink "Bitmap/clone"}}{{/crossLink}}, otherwise the GPU texture loading and tracking will get confused. * - to avoid an up/down scaled render you must call {{#crossLink "StageGL/updateViewport"}}{{/crossLink}} if you * resize your canvas after making a StageGL instance, this will properly size the WebGL context stored in memory. * - Best performance in demanding scenarios will come from manual management of texture memory, but it is handled * automatically by default. See {{#crossLink "StageGL/releaseTexture"}}{{/crossLink}} for details. * - Disable `directDraw` to get access to cacheless filters and composite oeprations! * *

Example

* This example creates a StageGL instance, adds a child to it, then uses the EaselJS {{#crossLink "Ticker"}}{{/crossLink}} * to update the child and redraw the stage. * * var stage = new createjs.StageGL("canvasElementId"); * * var image = new createjs.Bitmap("imagePath.png"); * stage.addChild(image); * * createjs.Ticker.on("tick", handleTick); * * function handleTick(event) { * image.x += 10; * stage.update(); * } * * @class StageGL * @extends Stage * @constructor * @param {HTMLCanvasElement | String | Object} canvas A canvas object that StageGL will render to, or the string id * of a canvas object in the current DOM. * @param {Object} options All the option parameters in a reference object, some are not supported by some browsers. * @param {Boolean} [options.preserveBuffer=false] If `true`, the canvas is NOT auto-cleared by WebGL (the spec * discourages setting this to `true`). This is useful if you want persistent draw effects and has also fixed device * specific bugs due to mis-timed clear commands. * @param {Boolean} [options.antialias=false] Specifies whether or not the browser's WebGL implementation should try * to perform anti-aliasing. This will also enable linear pixel sampling on power-of-two textures (smoother images). * @param {Boolean} [options.transparent=false] If `true`, the canvas is transparent. This is very * expensive, and should be used with caution. * @param {Boolean} [options.directDraw=true] If `true`, this will bypass intermediary render-textures when possible * resulting in reduced memory and increased performance, this disables some features. Cache-less filters and some * {{#crossLink "DisplayObject/compositeOperation:property"}}{{/crossLink}} values rely on this being false. * @param (Boolean} [options.premultiply] @deprecated Upgraded colour & transparency handling have fixed the issue * this flag was trying to solve rendering it unnecessary. * @param {int} [options.autoPurge=1200] How often the system should automatically dump unused textures. Calls * `purgeTextures(autoPurge)` every `autoPurge/2` draws. See {{#crossLink "StageGL/purgeTextures"}}{{/crossLink}} * for more information on texture purging. * @param {String|int} [options.clearColor=undefined] Automatically calls {{#crossLink "StageGL/setClearColor"}}{{/crossLink}} * after init is complete, can be overridden and changed manually later. */ function StageGL(canvas, options) { this.Stage_constructor(canvas); var transparent, antialias, preserveBuffer, autoPurge, directDraw; if (options !== undefined) { if (typeof options !== "object"){ throw("Invalid options object"); } transparent = options.transparent; antialias = options.antialias; preserveBuffer = options.preserveBuffer; autoPurge = options.autoPurge; directDraw = options.directDraw; } // public properties: /** * Console log potential issues and problems. This is designed to have minimal performance impact, so * if extensive debugging information is required, this may be inadequate. See {{#crossLink "WebGLInspector"}}{{/crossLink}} * @property vocalDebug * @type {Boolean} * @default false */ this.vocalDebug = false; /** * Specifies whether this instance is slaved to a {{#crossLink "BitmapCache"}}{{/crossLink}} or draws independantly. * Necessary to control texture outputs and behaviours when caching. StageGL cache outputs will only render * properly for the StageGL that made them. See the {{#crossLink "cache"}}{{/crossLink}} function documentation * for more information. Enabled by default when BitmapCache's `useGL` is true. * NOTE: This property is mainly for internal use, though it may be useful for advanced uses. * @property isCacheControlled * @type {Boolean} * @default false */ this.isCacheControlled = false; // private properties: /** * Specifies whether or not the canvas is auto-cleared by WebGL. The WebGL spec discourages `true`. * If true, the canvas is NOT auto-cleared by WebGL. Used when the canvas context is created and requires * context re-creation to update. * @property _preserveBuffer * @protected * @type {Boolean} * @default false */ this._preserveBuffer = preserveBuffer||false; /** * Specifies whether or not the browser's WebGL implementation should try to perform anti-aliasing. * @property _antialias * @protected * @type {Boolean} * @default false */ this._antialias = antialias||false; /** * Specifies whether or not the browser's WebGL implementation should be transparent. * @property _transparent * @protected * @type {Boolean} * @default false */ this._transparent = transparent||false; /** * Internal value of {{#crossLink "StageGL/autoPurge"}}{{/crossLink}} * @property _autoPurge * @protected * @type {int} * @default null */ this._autoPurge = undefined; this.autoPurge = autoPurge; //getter/setter handles setting the real value and validating and documentation /** * See directDraw * @property _directDraw * @protected * @type {Boolean} * @default false */ this._directDraw = directDraw === undefined ? true : (!!directDraw); /** * The width in px of the drawing surface saved in memory. * @property _viewportWidth * @protected * @type {Number} * @default 0 */ this._viewportWidth = 0; /** * The height in px of the drawing surface saved in memory. * @property _viewportHeight * @protected * @type {Number} * @default 0 */ this._viewportHeight = 0; /** * A 2D projection matrix used to convert WebGL's viewspace into canvas co-ordinates. Regular canvas display * uses Top-Left values of [0,0] where WebGL uses a Center [0,0] Top-Right [1,1] (euclidean) system. * @property _projectionMatrix * @protected * @type {Float32Array} * @default null */ this._projectionMatrix = null; /** * The current WebGL canvas context. Often shorthanded to just "gl" in many parts of the code. * @property _webGLContext * @protected * @type {WebGLRenderingContext} * @default null */ this._webGLContext = null; /** * Reduce API logic by allowing stage to behave as a renderTexture target, should always be null as null is canvas. * @type {null} * @protected */ this._frameBuffer = null; /** * The color to use when the WebGL canvas has been cleared. May appear as a background color. Defaults to grey. * @property _clearColor * @protected * @type {Object} * @default {r: 0.50, g: 0.50, b: 0.50, a: 0.00} */ this._clearColor = {r: 0.50, g: 0.50, b: 0.50, a: 0.00}; /** * The maximum number of cards (aka a single sprite) that can be drawn in one draw call. Use getter/setters to * modify otherwise internal buffers may be incorrect sizes. * @property _maxBatchVertexCount * @protected * @type {Number} * @default StageGL.DEFAULT_MAX_BATCH_SIZE * StageGL.INDICIES_PER_CARD */ this._maxBatchVertexCount = StageGL.DEFAULT_MAX_BATCH_SIZE * StageGL.INDICIES_PER_CARD; /** * The shader program used to draw the current batch. * @property _activeShader * @protected * @type {WebGLProgram} * @default null */ this._activeShader = null; /** * The non cover, per object shader used for most rendering actions. * @type {WebGLProgram} * @protected */ this._mainShader = null; /** * The vertex position data for the current draw call. * @property _vertices * @protected * @type {Float32Array} * @default null */ this._vertices = null; /** * The WebGL buffer attached to {{#crossLink "StageGL/_vertices:property"}}{{/crossLink}}. * @property _vertexPositionBuffer * @protected * @type {WebGLBuffer} * @default null */ this._vertexPositionBuffer = null; /** * The vertex UV data for the current draw call. * @property _uvs * @protected * @type {Float32Array} * @default null */ this._uvs = null; /** * The WebGL buffer attached to {{#crossLink "StageGL/_uvs:property"}}{{/crossLink}}. * @property _uvPositionBuffer * @protected * @type {WebGLBuffer} * @default null */ this._uvPositionBuffer = null; /** * The vertex indices data for the current draw call. * @property _indices * @protected * @type {Float32Array} * @default null */ this._indices = null; /** * The WebGL buffer attached to {{#crossLink "StageGL/_indices:property"}}{{/crossLink}}. * @property _textureIndexBuffer * @protected * @type {WebGLBuffer} * @default null */ this._textureIndexBuffer = null; /** * The vertices data for the current draw call. * @property _alphas * @protected * @type {Float32Array} * @default null */ this._alphas = null; /** * The WebGL buffer attached to {{#crossLink "StageGL/_alphas:property"}}{{/crossLink}}. * @property _alphaBuffer * @protected * @type {WebGLBuffer} * @default null */ this._alphaBuffer = null; /** * One of the major render buffers used in composite blending drawing. Do not expect this to always be the same object. * "What you're drawing to", object occasionally swaps with concat. * @property _bufferTextureOutput * @protected * @type {WebGLTexture} */ this._bufferTextureOutput = null; /** * One of the major render buffers used in composite blending drawing. Do not expect this to always be the same object. * "What you've draw before now", object occasionally swaps with output. * @property _bufferTextureConcat * @protected * @type {WebGLTexture} */ this._bufferTextureConcat = null; /** * One of the major render buffers used in composite blending drawing. * "Temporary mixing surface" * @property _bufferTextureTemp * @protected * @type {WebGLTexture} */ this._bufferTextureTemp = null; /** * The current render buffer being targeted, usually targets internal buffers, but may be set to cache's buffer during a cache render. * @property _batchTextureOutput * @protected * @type {WebGLTexture | StageGL} */ this._batchTextureOutput = this; /** * The current render buffer being targeted, usually targets internal buffers, but may be set to cache's buffer during a cache render. * @property _batchTextureConcat * @protected * @type {WebGLTexture} */ this._batchTextureConcat = null; /** * The current render buffer being targeted, usually targets internal buffers, but may be set to cache's buffer during a cache render. * @property _batchTextureTemp * @protected * @type {WebGLTexture} */ this._batchTextureTemp = null; /** * Internal library of the shaders that have been compiled and created along with their parameters. Should contain * compiled `gl.ShaderProgram` and settings for `gl.blendFunc` and `gl.blendEquation`. Populated as requested. * * See {{#crossLink "StageGL/_updateRenderMode:method"}}{{/crossLink}} for exact details. * @type {Object} * @private */ this._builtShaders = {}; /** * An index based lookup of every WebGL Texture currently in use. * @property _drawTexture * @protected * @type {Array} */ this._textureDictionary = []; /** * A string based lookup hash of which index a texture is stored at in the dictionary. The lookup string is * often the src url. * @property _textureIDs * @protected * @type {Object} */ this._textureIDs = {}; /** * An array of all the textures currently loaded into the GPU. The index in the array matches the GPU index. * @property _batchTextures * @protected * @type {Array} */ this._batchTextures = []; /** * An array of all the simple filler textures used to prevent issues with missing textures in a batch. * @property _baseTextures * @protected * @type {Array} */ this._baseTextures = []; /** * Texture slots for a draw * @property _gpuTextureCount * @protected * @type {uint} */ this._gpuTextureCount = 8; /** * Texture slots on the hardware * @property _gpuTextureMax * @protected * @type {uint} */ this._gpuTextureMax = 8; /** * Texture slots in a batch for User textures * @property _batchTextureCount * @protected * @type {uint} */ this._batchTextureCount = 0; /** * The location at which the last texture was inserted into a GPU slot */ this._lastTextureInsert = -1; /** * The current string name of the render mode being employed per Context2D spec. * Must start invalid to trigger default shader into being built during init. * https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation * @type {string} * @private */ this._renderMode = ""; /** * Flag indicating that the content being batched in `appendToBatch` must be drawn now and not follow batch logic. * Used for effects that are compounding in nature and cannot be applied in a single pass. * Should be enabled with extreme care due to massive performance implications. * @type {boolean} * @private */ this._immediateRender = false; /** * Vertices drawn into the batch so far. * @type {number} * @private */ this._batchVertexCount = 0; /** * The current batch being drawn, A batch consists of a call to `drawElements` on the GPU. Many of these calls * can occur per draw. * @property _batchId * @protected * @type {Number} * @default 0 */ this._batchID = 0; /** * The current draw being performed, may contain multiple batches. Comparing to {{#crossLink "StageGL/_batchID:property"}}{{/crossLink}} * can reveal batching efficiency. * @property _drawID * @protected * @type {Number} * @default 0 */ this._drawID = 0; /** * Used to prevent textures in certain GPU slots from being replaced by an insert. * @property _slotBlackList * @protected * @type {Array} */ this._slotBlacklist = []; /** * Used to ensure every canvas used as a texture source has a unique ID. * @property _lastTrackedCanvas * @protected * @type {Number} * @default 0 */ this._lastTrackedCanvas = -1; /** * Used to counter-position the object being cached so it aligns with the cache surface. Additionally ensures * that all rendering starts with a top level container. * @property _cacheContainer * @protected * @type {Container} * @default An instance of an EaselJS Container. */ this._cacheContainer = new createjs.Container(); // and begin this._initializeWebGL(); // these settings require everything to be ready if (options !== undefined) { options.clearColor !== undefined && this.setClearColor(options.clearColor); options.premultiply !== undefined && (createjs.deprecate(null, "options.premultiply")()); } } var p = createjs.extend(StageGL, createjs.Stage); // static methods: /** * Calculate the UV co-ordinate based info for sprite frames. Instead of pixel count it uses a 0-1 space. Also includes * the ability to get info back for a specific frame, or only calculate that one frame. * * //generate UV rects for all entries * StageGL.buildUVRects( spriteSheetA ); * //generate all, fetch the first * var firstFrame = StageGL.buildUVRects( spriteSheetB, 0 ); * //generate the rect for just a single frame for performance's sake * var newFrame = StageGL.buildUVRects( dynamicSpriteSheet, newFrameIndex, true ); * * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method buildUVRects * @param {SpriteSheet} spritesheet The spritesheet to find the frames on * @param {int} [target=-1] The index of the frame to return * @param {Boolean} [onlyTarget=false] Whether "target" is the only frame that gets calculated * @static * @return {Object} the target frame if supplied and present or a generic frame {t, l, b, r} */ StageGL.buildUVRects = function (spritesheet, target, onlyTarget) { if (!spritesheet || !spritesheet._frames) { return null; } if (target === undefined) { target = -1; } if (onlyTarget === undefined) { onlyTarget = false; } var start = (target !== -1 && onlyTarget)?(target):(0); var end = (target !== -1 && onlyTarget)?(target+1):(spritesheet._frames.length); for (var i=start; i 7 ? Number("0x"+color.slice(7, 9))/255 : 1; } else if (color.indexOf("rgba(") === 0) { var output = color.slice(5, -1).split(","); r = Number(output[0])/255; g = Number(output[1])/255; b = Number(output[2])/255; a = Number(output[3]); } } else { // >>> is an unsigned shift which is what we want as 0x80000000 and up are negative values r = ((color & 0xFF000000) >>> 24)/255; g = ((color & 0x00FF0000) >>> 16)/255; b = ((color & 0x0000FF00) >>> 8)/255; a = (color & 0x000000FF)/255; } return { r: Math.min(Math.max(0, r), 1), g: Math.min(Math.max(0, g), 1), b: Math.min(Math.max(0, b), 1), a: Math.min(Math.max(0, a), 1) } }; // static properties: /** * The number of properties defined per vertex (x, y, textureU, textureV, textureIndex, alpha) * @property VERTEX_PROPERTY_COUNT * @protected * @static * @final * @type {Number} * @default 6 * @readonly */ StageGL.VERTEX_PROPERTY_COUNT = 6; /** * The number of triangle indices it takes to form a Card. 3 per triangle, 2 triangles. * @property INDICIES_PER_CARD * @protected * @static * @final * @type {Number} * @default 6 * @readonly */ StageGL.INDICIES_PER_CARD = 6; /** * The default value for the maximum number of cards we want to process in a batch. See * {{#crossLink "StageGL/WEBGL_MAX_INDEX_NUM:property"}}{{/crossLink}} for a hard limit. * @property DEFAULT_MAX_BATCH_SIZE * @static * @final * @type {Number} * @default 10000 * @readonly */ StageGL.DEFAULT_MAX_BATCH_SIZE = 10920; /** * The maximum size WebGL allows for element index numbers. Uses a 16 bit unsigned integer. It takes 6 indices to * make a unique card. * @property WEBGL_MAX_INDEX_NUM * @static * @final * @type {Number} * @default 65536 * @readonly */ StageGL.WEBGL_MAX_INDEX_NUM = Math.pow(2, 16); /** * Default UV rect for dealing with full coverage from an image source. * @property UV_RECT * @protected * @static * @final * @type {Object} * @default {t:0, l:0, b:1, r:1} * @readonly */ StageGL.UV_RECT = {t:1, l:0, b:0, r:1}; try { /** * Vertex positions for a card that covers the entire render. Used with render targets primarily. * @property COVER_VERT * @static * @final * @type {Float32Array} * @readonly */ StageGL.COVER_VERT = new Float32Array([ -1, 1, //TL 1, 1, //TR -1, -1, //BL 1, 1, //TR 1, -1, //BR -1, -1 //BL ]); /** * UV for {{#crossLink "StageGL/COVER_VERT:property"}}{{/crossLink}}. * @property COVER_UV * @static * @final * @type {Float32Array} * @readonly */ StageGL.COVER_UV = new Float32Array([ 0, 1, //TL 1, 1, //TR 0, 0, //BL 1, 1, //TR 1, 0, //BR 0, 0 //BL ]); } catch(e) { /* Breaking in older browsers, but those browsers wont run StageGL so no recovery or warning needed */ } /** * Portion of the shader that contains the "varying" properties required in both vertex and fragment shaders. The * regular shader is designed to render all expected objects. Shader code may contain templates that are replaced * pre-compile. * @property REGULAR_VARYING_HEADER * @protected * @static * @final * @type {String} * @readonly */ StageGL.REGULAR_VARYING_HEADER = ( "precision highp float;" + "varying vec2 vTextureCoord;" + "varying lowp float indexPicker;" + "varying lowp float alphaValue;" ); /** * Actual full header for the vertex shader. Includes the varying header. The regular shader is designed to render * all expected objects. Shader code may contain templates that are replaced pre-compile. * @property REGULAR_VERTEX_HEADER * @protected * @static * @final * @type {String} * @readonly */ StageGL.REGULAR_VERTEX_HEADER = ( StageGL.REGULAR_VARYING_HEADER + "attribute vec2 vertexPosition;" + "attribute vec2 uvPosition;" + "attribute lowp float textureIndex;" + "attribute lowp float objectAlpha;" + "uniform mat4 pMatrix;" ); /** * Actual full header for the fragment shader. Includes the varying header. The regular shader is designed to render * all expected objects. Shader code may contain templates that are replaced pre-compile. * @property REGULAR_FRAGMENT_HEADER * @protected * @static * @final * @type {String} * @readonly */ StageGL.REGULAR_FRAGMENT_HEADER = ( StageGL.REGULAR_VARYING_HEADER + "uniform sampler2D uSampler[{{count}}];" ); /** * Body of the vertex shader. The regular shader is designed to render all expected objects. Shader code may contain * templates that are replaced pre-compile. * @property REGULAR_VERTEX_BODY * @protected * @static * @final * @type {String} * @readonly */ StageGL.REGULAR_VERTEX_BODY = ( "void main(void) {" + "gl_Position = pMatrix * vec4(vertexPosition.x, vertexPosition.y, 0.0, 1.0);" + "alphaValue = objectAlpha;" + "indexPicker = textureIndex;" + "vTextureCoord = uvPosition;" + "}" ); /** * Body of the fragment shader. The regular shader is designed to render all expected objects. Shader code may * contain templates that are replaced pre-compile. * @property REGULAR_FRAGMENT_BODY * @protected * @static * @final * @type {String} * @readonly */ StageGL.REGULAR_FRAGMENT_BODY = ( "void main(void) {" + "vec4 color = vec4(1.0, 0.0, 0.0, 1.0);" + "if (indexPicker <= 0.5) {" + "color = texture2D(uSampler[0], vTextureCoord);" + "{{alternates}}" + "}" + "gl_FragColor = vec4(color.rgb * alphaValue, color.a * alphaValue);" + "}" ); /** * Portion of the shader that contains the "varying" properties required in both vertex and fragment shaders. The * cover shader is designed to be a simple vertex/uv only texture render that covers the render surface. Shader * code may contain templates that are replaced pre-compile. * @property COVER_VARYING_HEADER * @protected * @static * @final * @type {String} * @readonly */ StageGL.COVER_VARYING_HEADER = ( "precision highp float;" + //this is usually essential for filter math "varying vec2 vTextureCoord;" ); /** * Actual full header for the vertex shader. Includes the varying header. The cover shader is designed to be a * simple vertex/uv only texture render that covers the render surface. Shader code may contain templates that are * replaced pre-compile. * @property COVER_VERTEX_HEADER * @protected * @static * @final * @type {String} * @readonly */ StageGL.COVER_VERTEX_HEADER = ( StageGL.COVER_VARYING_HEADER + "attribute vec2 vertexPosition;" + "attribute vec2 uvPosition;" ); /** * Actual full header for the fragment shader. Includes the varying header. The cover shader is designed to be a * simple vertex/uv only texture render that covers the render surface. Shader code may contain templates that are * replaced pre-compile. * @property COVER_FRAGMENT_HEADER * @protected * @static * @final * @type {String} * @readonly */ StageGL.COVER_FRAGMENT_HEADER = ( StageGL.COVER_VARYING_HEADER + "uniform sampler2D uSampler;" ); /** * Body of the vertex shader. The cover shader is designed to be a simple vertex/uv only texture render that covers * the render surface. Shader code may contain templates that are replaced pre-compile. * @property COVER_VERTEX_BODY * @protected * @static * @final * @type {String} * @readonly */ StageGL.COVER_VERTEX_BODY = ( "void main(void) {" + "gl_Position = vec4(vertexPosition.x, vertexPosition.y, 0.0, 1.0);" + "vTextureCoord = uvPosition;" + "}" ); /** * Body of the fragment shader. The cover shader is designed to be a simple vertex/uv only texture render that * covers the render surface. Shader code may contain templates that are replaced pre-compile. * @property COVER_FRAGMENT_BODY * @protected * @static * @final * @type {String} * @readonly */ StageGL.COVER_FRAGMENT_BODY = ( "void main(void) {" + "gl_FragColor = texture2D(uSampler, vTextureCoord);" + "}" ); /** * The starting template of a cover fragment shader with simple blending equations * @property BLEND_FRAGMENT_SIMPLE * @protected * @static * @final * @type {String} * @readonly */ StageGL.BLEND_FRAGMENT_SIMPLE = ( "uniform sampler2D uMixSampler;"+ "void main(void) {" + "vec4 src = texture2D(uMixSampler, vTextureCoord);" + "vec4 dst = texture2D(uSampler, vTextureCoord);" // note this is an open bracket on main! ); /** * The starting template of a cover fragment shader which has complex blending equations * @property BLEND_FRAGMENT_COMPLEX * @protected * @static * @final * @type {String} * @readonly */ StageGL.BLEND_FRAGMENT_COMPLEX = ( StageGL.BLEND_FRAGMENT_SIMPLE + "vec3 srcClr = min(src.rgb/src.a, 1.0);" + "vec3 dstClr = min(dst.rgb/dst.a, 1.0);" + "float totalAlpha = min(1.0 - (1.0-dst.a) * (1.0-src.a), 1.0);" + "float srcFactor = min(max(src.a - dst.a, 0.0) / totalAlpha, 1.0);" + "float dstFactor = min(max(dst.a - src.a, 0.0) / totalAlpha, 1.0);" + "float mixFactor = max(max(1.0 - srcFactor, 0.0) - dstFactor, 0.0);" + "gl_FragColor = vec4(" + "(" + "srcFactor * srcClr +" + "dstFactor * dstClr +" + "mixFactor * vec3(" // this should be closed with the cap! ); /** * The closing portion of a template for a cover fragment shader which has complex blending equations * @property BLEND_FRAGMENT_COMPLEX_CAP * @protected * @static * @final * @type {String} * @readonly */ StageGL.BLEND_FRAGMENT_COMPLEX_CAP = ( ")" + ") * totalAlpha, totalAlpha" + ");" + "}" ); /** * A shader utility function, used to calculate the "overlay" blend of two elements * @property BLEND_FRAGMENT_OVERLAY_UTIL * @protected * @static * @final * @type {String} * @readonly */ StageGL.BLEND_FRAGMENT_OVERLAY_UTIL = ( "float overlay(float a, float b) {" + "if(a < 0.5) { return 2.0 * a * b; }" + "return 1.0 - 2.0 * (1.0-a) * (1.0-b);" + "}" ); /** * A collection of shader utility functions, used to calculate HSL math. Taken from W3C spec * https://www.w3.org/TR/compositing-1/#blendingnonseparable * @property BLEND_FRAGMENT_HSL_UTIL * @protected * @static * @final * @type {String} * @readonly */ StageGL.BLEND_FRAGMENT_HSL_UTIL = ( "float getLum(vec3 c) { return 0.299*c.r + 0.589*c.g + 0.109*c.b; }" + "float getSat(vec3 c) { return max(max(c.r, c.g), c.b) - min(min(c.r, c.g), c.b); }" + "vec3 clipHSL(vec3 c) {" + "float lum = getLum(c);" + "float n = min(min(c.r, c.g), c.b);" + "float x = max(max(c.r, c.g), c.b);" + "if(n < 0.0){ c = lum + (((c - lum) * lum) / (lum - n)); }" + "if(x > 1.0){ c = lum + (((c - lum) * (1.0 - lum)) / (x - lum)); }" + "return clamp(c, 0.0, 1.0);" + "}" + "vec3 setLum(vec3 c, float lum) {" + "return clipHSL(c + (lum - getLum(c)));" + "}" + "vec3 setSat(vec3 c, float val) {" + "vec3 result = vec3(0.0);" + "float minVal = min(min(c.r, c.g), c.b);" + "float maxVal = max(max(c.r, c.g), c.b);" + "vec3 minMask = vec3(c.r == minVal, c.g == minVal, c.b == minVal);" + "vec3 maxMask = vec3(c.r == maxVal, c.g == maxVal, c.b == maxVal);" + "vec3 midMask = 1.0 - min(minMask+maxMask, 1.0);" + "float midVal = (c*midMask).r + (c*midMask).g + (c*midMask).b;" + "if(maxVal > minVal) {" + "result = midMask * min( ((midVal - minVal) * val) / (maxVal - minVal), 1.0);" + "result += maxMask * val;" + "}" + "return result;" + "}" ); /** * The hash of supported blend modes and their properties * @property BLEND_SOURCES * @static * @final * @type {Object} * @readonly */ StageGL.BLEND_SOURCES = { "source-over": { // empty object verifies it as a blend mode, but default values handle actual settings //eqRGB: "FUNC_ADD", eqA: "FUNC_ADD" //srcRGB: "ONE", srcA: "ONE" //dstRGB: "ONE_MINUS_SRC_ALPHA", dstA: "ONE_MINUS_SRC_ALPHA" }, "source-in": { shader: (StageGL.BLEND_FRAGMENT_SIMPLE + "gl_FragColor = vec4(src.rgb * dst.a, src.a * dst.a);" + "}") }, "source-in_cheap": { srcRGB: "DST_ALPHA", srcA: "ZERO", dstRGB: "ZERO", dstA: "SRC_ALPHA" }, "source-out": { shader: (StageGL.BLEND_FRAGMENT_SIMPLE + "gl_FragColor = vec4(src.rgb * (1.0 - dst.a), src.a - dst.a);" + "}") }, "source-out_cheap": { eqA: "FUNC_SUBTRACT", srcRGB: "ONE_MINUS_DST_ALPHA", srcA: "ONE", dstRGB: "ZERO", dstA: "SRC_ALPHA" }, "source-atop": { srcRGB: "DST_ALPHA", srcA: "ZERO", dstRGB: "ONE_MINUS_SRC_ALPHA", dstA: "ONE" }, "destination-over": { srcRGB: "ONE_MINUS_DST_ALPHA", srcA: "ONE_MINUS_DST_ALPHA", dstRGB: "ONE", dstA: "ONE" }, "destination-in": { shader: (StageGL.BLEND_FRAGMENT_SIMPLE + "gl_FragColor = vec4(dst.rgb * src.a, src.a * dst.a);" + "}") }, "destination-in_cheap": { srcRGB: "ZERO", srcA: "DST_ALPHA", dstRGB: "SRC_ALPHA", dstA: "ZERO" }, "destination-out": { eqA: "FUNC_REVERSE_SUBTRACT", srcRGB: "ZERO", srcA: "DST_ALPHA", dstRGB: "ONE_MINUS_SRC_ALPHA", dstA: "ONE" }, "destination-atop": { shader: (StageGL.BLEND_FRAGMENT_SIMPLE + "gl_FragColor = vec4(dst.rgb * src.a + src.rgb * (1.0 - dst.a), src.a);" + "}") }, "destination-atop_cheap": { srcRGB: "ONE_MINUS_DST_ALPHA", srcA: "ONE", dstRGB: "SRC_ALPHA", dstA: "ZERO" }, "copy": { shader: (StageGL.BLEND_FRAGMENT_SIMPLE + "gl_FragColor = vec4(src.rgb, src.a);" + "}") }, "copy_cheap": { dstRGB: "ZERO", dstA: "ZERO" }, "xor": { shader: (StageGL.BLEND_FRAGMENT_SIMPLE + "float omSRC = (1.0 - src.a);" + "float omDST = (1.0 - dst.a);" + "gl_FragColor = vec4(src.rgb * omDST + dst.rgb * omSRC, src.a * omDST + dst.a * omSRC);" + "}") }, "multiply": { // this has to be complex to handle retention of both dst and src in non mixed scenarios shader: (StageGL.BLEND_FRAGMENT_COMPLEX + "srcClr * dstClr" + StageGL.BLEND_FRAGMENT_COMPLEX_CAP) }, "multiply_cheap": { // NEW, handles retention of src data incorrectly when no dst data present srcRGB: "ONE_MINUS_DST_ALPHA", srcA: "ONE", dstRGB: "SRC_COLOR", dstA: "ONE" }, "screen": { srcRGB: "ONE", srcA: "ONE", dstRGB: "ONE_MINUS_SRC_COLOR", dstA: "ONE_MINUS_SRC_ALPHA" }, "lighter": { dstRGB: "ONE", dstA:"ONE" }, "lighten": { //WebGL 2.0 can optimize this shader: (StageGL.BLEND_FRAGMENT_COMPLEX + "max(srcClr, dstClr)" + StageGL.BLEND_FRAGMENT_COMPLEX_CAP) }, "darken": { //WebGL 2.0 can optimize this shader: (StageGL.BLEND_FRAGMENT_COMPLEX + "min(srcClr, dstClr)" + StageGL.BLEND_FRAGMENT_COMPLEX_CAP) }, "overlay": { shader: (StageGL.BLEND_FRAGMENT_OVERLAY_UTIL + StageGL.BLEND_FRAGMENT_COMPLEX + "overlay(dstClr.r,srcClr.r), overlay(dstClr.g,srcClr.g), overlay(dstClr.b,srcClr.b)" + StageGL.BLEND_FRAGMENT_COMPLEX_CAP) }, "hard-light": { shader: (StageGL.BLEND_FRAGMENT_OVERLAY_UTIL + StageGL.BLEND_FRAGMENT_COMPLEX + "overlay(srcClr.r,dstClr.r), overlay(srcClr.g,dstClr.g), overlay(srcClr.b,dstClr.b)" + StageGL.BLEND_FRAGMENT_COMPLEX_CAP) }, "soft-light": { shader: ( "float softcurve(float a) {" + "if(a > 0.25) { return sqrt(a); }" + "return ((16.0 * a - 12.0) * a + 4.0) * a;" + "}" + "float softmix(float a, float b) {" + "if(b <= 0.5) { return a - (1.0 - 2.0*b) * a * (1.0 - a); }" + "return a + (2.0 * b - 1.0) * (softcurve(a) - a);" + "}" + StageGL.BLEND_FRAGMENT_COMPLEX + "softmix(dstClr.r,srcClr.r), softmix(dstClr.g,srcClr.g), softmix(dstClr.b,srcClr.b)" + StageGL.BLEND_FRAGMENT_COMPLEX_CAP) }, "color-dodge": { shader: (StageGL.BLEND_FRAGMENT_COMPLEX + "clamp(dstClr / (1.0 - srcClr), 0.0, 1.0)" + StageGL.BLEND_FRAGMENT_COMPLEX_CAP) }, "color-burn": { shader: (StageGL.BLEND_FRAGMENT_COMPLEX + "1.0 - clamp((1.0 - smoothstep(0.0035, 0.9955, dstClr)) / smoothstep(0.0035, 0.9955, srcClr), 0.0, 1.0)" + StageGL.BLEND_FRAGMENT_COMPLEX_CAP) }, "difference": { // do this to match visible results in browsers shader: (StageGL.BLEND_FRAGMENT_COMPLEX + "abs(src.rgb - dstClr)" + StageGL.BLEND_FRAGMENT_COMPLEX_CAP) }, "exclusion": { // do this to match visible results in browsers shader: (StageGL.BLEND_FRAGMENT_COMPLEX + "dstClr + src.rgb - 2.0 * src.rgb * dstClr" + StageGL.BLEND_FRAGMENT_COMPLEX_CAP) }, "hue": { shader: (StageGL.BLEND_FRAGMENT_HSL_UTIL + StageGL.BLEND_FRAGMENT_COMPLEX + "setLum(setSat(srcClr, getSat(dstClr)), getLum(dstClr))" + StageGL.BLEND_FRAGMENT_COMPLEX_CAP) }, "saturation": { shader: (StageGL.BLEND_FRAGMENT_HSL_UTIL + StageGL.BLEND_FRAGMENT_COMPLEX + "setLum(setSat(dstClr, getSat(srcClr)), getLum(dstClr))" + StageGL.BLEND_FRAGMENT_COMPLEX_CAP) }, "color": { shader: (StageGL.BLEND_FRAGMENT_HSL_UTIL + StageGL.BLEND_FRAGMENT_COMPLEX + "setLum(srcClr, getLum(dstClr))" + StageGL.BLEND_FRAGMENT_COMPLEX_CAP) }, "luminosity": { shader: (StageGL.BLEND_FRAGMENT_HSL_UTIL + StageGL.BLEND_FRAGMENT_COMPLEX + "setLum(dstClr, getLum(srcClr))" + StageGL.BLEND_FRAGMENT_COMPLEX_CAP) } }; // events: /** * Dispatched each update immediately before the canvas is cleared and the display list is drawn to it. You can call * {{#crossLink "Event/preventDefault"}}{{/crossLink}} on the event to cancel the draw. * @event drawstart */ /** * Dispatched each update immediately after the display list is drawn to the canvas and the canvas context is restored. * @event drawend */ // getter / setters: p._get_isWebGL = function () { return !!this._webGLContext; }; p._set_autoPurge = function (value) { value = isNaN(value)?1200:value; if (value !== -1) { value = value<10?10:value; } this._autoPurge = value; }; p._get_autoPurge = function () { return Number(this._autoPurge); }; try { Object.defineProperties(p, { /** * Indicates whether WebGL is being used for rendering. For example, this would be `false` if WebGL is not * supported in the browser. * @property isWebGL * @type {Boolean} * @readonly */ isWebGL: { get: p._get_isWebGL }, /** * Specifies whether or not StageGL is automatically purging unused textures. Higher numbers purge less * often. Values below 10 are upgraded to 10, and -1 disables this feature. If you are not dynamically adding * and removing new images this can be se9000t to -1, and should be for performance reasons. If you only add images, * or add and remove the same images for the entire application, it is safe to turn off this feature. Alternately, * manually manage removing textures yourself with {{#crossLink "StageGL/releaseTexture"}}{{/crossLink}} * @property autoPurge * @type {int} * @default 1000 */ autoPurge: { get: p._get_autoPurge, set: p._set_autoPurge } }); } catch (e) {} // TODO: use Log // constructor methods: /** * Create and properly initialize the WebGL instance. * @method _initializeWebGL * @protected * @return {WebGLRenderingContext} */ p._initializeWebGL = function () { if (this.canvas) { if (!this._webGLContext || this._webGLContext.canvas !== this.canvas) { // A context hasn't been defined yet, // OR the defined context belongs to a different canvas, so reinitialize. // defaults and options var options = { depth: false, // nothing has depth stencil: false, // while there's uses for this, we're not using any yet premultipliedAlpha: this._transparent, // this is complicated, trust it alpha: this._transparent, antialias: this._antialias, preserveDrawingBuffer: this._preserveBuffer }; var gl = this._webGLContext = this._fetchWebGLContext(this.canvas, options); if (!gl) { return null; } gl.disable(gl.DEPTH_TEST); gl.depthMask(false); gl.enable(gl.BLEND); gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true); gl.clearColor(0.0, 0.0, 0.0, 0); gl.blendEquationSeparate(gl.FUNC_ADD, gl.FUNC_ADD); gl.blendFuncSeparate(gl.ONE, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA); this._createBuffers(); this._initMaterials(); this._updateRenderMode("source-over"); this.updateViewport(this.canvas.width, this.canvas.height); if (!this._directDraw) { this._bufferTextureOutput = this.getRenderBufferTexture(this._viewportWidth, this._viewportHeight); } this.canvas._invalid = true; } } else { this._webGLContext = null; } return this._webGLContext; }; // public methods: // Docced in superclass p.update = function (props) { if (!this.canvas) { return; } if (this.tickOnUpdate) { this.tick(props); } this.dispatchEvent("drawstart"); if (this._webGLContext) { this.draw(this._webGLContext, false); } else { // Use 2D. if (this.autoClear) { this.clear(); } var ctx = this.canvas.getContext("2d"); ctx.save(); this.updateContext(ctx); this.draw(ctx, false); ctx.restore(); } this.dispatchEvent("drawend"); }; // Docced in superclass p.clear = function () { if (!this.canvas) { return; } var gl = this._webGLContext; if (!StageGL.isWebGLActive(gl)) { // Use 2D. this.Stage_clear(); return; } gl.bindFramebuffer(gl.FRAMEBUFFER, null); this._clearFrameBuffer(this._transparent ? this._clearColor.a : 1); }; /** * Draws the stage into the supplied context if possible. Many WebGL properties only exist on their context. As such * you cannot share contexts among many StageGLs and each context requires a unique StageGL instance. Contexts that * don't match the context managed by this StageGL will be treated as a 2D context. * * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method draw * @param {CanvasRenderingContext2D | WebGLRenderingContext} context The context object to draw into. * @param {Boolean} [ignoreCache=false] Indicates whether the draw operation should ignore any current cache. For * example, used for drawing the cache (to prevent it from simply drawing an existing cache back into itself). * @return {Boolean} If the draw was handled by this function */ p.draw = function (context, ignoreCache) { var gl = this._webGLContext; // 2D context fallback if (!(context === this._webGLContext && StageGL.isWebGLActive(gl))) { return this.Stage_draw(context, ignoreCache); } var storeBatchOutput = this._batchTextureOutput; var storeBatchConcat = this._batchTextureConcat; var storeBatchTemp = this._batchTextureTemp; // Use WebGL this._batchVertexCount = 0; this._drawID++; if (this._directDraw) { this._batchTextureOutput = this; if (this.autoClear) { this.clear(); } } else { this._batchTextureOutput = this._bufferTextureOutput; this._batchTextureConcat = this._bufferTextureConcat; this._batchTextureTemp = this._bufferTextureTemp; } this._updateRenderMode("source-over"); this._drawContent(this, ignoreCache); if (!this._directDraw) { if (this.autoClear) { this.clear(); } this.batchReason = "finalOutput"; this._drawCover(null, this._batchTextureOutput); } // batches may generate or swap around textures. To be sure we capture them, store them back into buffer this._bufferTextureOutput = this._batchTextureOutput; this._bufferTextureConcat = this._batchTextureConcat; this._bufferTextureTemp = this._batchTextureTemp; this._batchTextureOutput = storeBatchOutput; this._batchTextureConcat = storeBatchConcat; this._batchTextureTemp = storeBatchTemp; if (this._autoPurge !== -1 && !(this._drawID%((this._autoPurge/2)|0))) { this.purgeTextures(this._autoPurge); } return true; }; /** * Draws the target into the correct context, be it a canvas or Render Texture using WebGL. * * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method cacheDraw * @param {DisplayObject} target The object we're drawing into cache. * For example, used for drawing the cache (to prevent it from simply drawing an existing cache back into itself). * @param {BitmapCache} manager The BitmapCache instance looking after the cache * @return {Boolean} If the draw was handled by this function */ p.cacheDraw = function (target, manager) { // 2D context fallback if (!StageGL.isWebGLActive(this._webGLContext)) { return false; } for (var i = 0; i < this._gpuTextureCount; i++) { if(this._batchTextures[i]._frameBuffer) { this._batchTextures[i] = this._baseTextures[i]; } } var storeBatchOutput = this._batchTextureOutput; var storeBatchConcat = this._batchTextureConcat; var storeBatchTemp = this._batchTextureTemp; var filterCount = manager._filterCount, filtersLeft = filterCount; var backupWidth = this._viewportWidth, backupHeight = this._viewportHeight; this._updateDrawingSurface(manager._drawWidth, manager._drawHeight); this._batchTextureOutput = (manager._filterCount%2) ? manager._bufferTextureConcat : manager._bufferTextureOutput; this._batchTextureConcat = (manager._filterCount%2) ? manager._bufferTextureOutput : manager._bufferTextureConcat; this._batchTextureTemp = manager._bufferTextureTemp; var container = this._cacheContainer; container.children = [target]; container.transformMatrix = this._alignTargetToCache(target, manager); this._updateRenderMode("source-over"); this._drawContent(container, true); // re-align buffers with fake filter passes to solve certain error cases if (this.isCacheControlled) { // post filter pass to place content into output buffer //TODO: add in directDraw support for cache controlled StageGLs filterCount++; filtersLeft++; } else if (manager._cacheCanvas !== ((manager._filterCount%2) ? this._batchTextureConcat : this._batchTextureOutput)) { // pre filter pass to align output, may of become misaligned due to composite operations filtersLeft++; } while (filtersLeft) { //warning: pay attention to where filtersLeft is modified, this is a micro-optimization var filter = manager._getGLFilter(filterCount - (filtersLeft--)); var swap = this._batchTextureConcat; this._batchTextureConcat = this._batchTextureOutput; this._batchTextureOutput = (this.isCacheControlled && filtersLeft === 0) ? this : swap; this.batchReason = "filterPass"; this._drawCover(this._batchTextureOutput._frameBuffer, this._batchTextureConcat, filter); } manager._bufferTextureOutput = this._batchTextureOutput; manager._bufferTextureConcat = this._batchTextureConcat; manager._bufferTextureTemp = this._batchTextureTemp; this._batchTextureOutput = storeBatchOutput; this._batchTextureConcat = storeBatchConcat; this._batchTextureTemp = storeBatchTemp; this._updateDrawingSurface(backupWidth, backupHeight); return true; }; /** * For every image encountered StageGL registers and tracks it automatically. This tracking can cause memory leaks * if not purged. StageGL, by default, automatically purges them. This does have a cost and may unfortunately find * false positives. This function is for manual management of this memory instead of the automatic system controlled * by the {{#crossLink "StageGL/autoPurge:property"}}{{/crossLink}} property. * * This function will recursively remove all textures found on the object, its children, cache, etc. It will uncache * objects and remove any texture it finds REGARDLESS of whether it is currently in use elsewhere. It is up to the * developer to ensure that a texture in use is not removed. * * Textures in use, or to be used again shortly, should not be removed. This is simply for performance reasons. * Removing a texture in use will cause the texture to end up being re-uploaded slowing rendering. * @method releaseTexture * @param {DisplayObject | WebGLTexture | Image | Canvas} item An object that used the texture to be discarded. * @param {Boolean} [safe=false] Should the release attempt to be "safe" and only delete this usage. */ p.releaseTexture = function (item, safe) { var i, l; if (!item) { return; } // this is a container object if (item.children) { for (i = 0, l = item.children.length; i < l; i++) { this.releaseTexture(item.children[i], safe); } } // this has a cache canvas if (item.cacheCanvas) { item.uncache(); } var foundImage = undefined; if (item._storeID !== undefined) { // this is a texture itself if (item === this._textureDictionary[item._storeID]) { this._killTextureObject(item); item._storeID = undefined; return; } // this is an image or canvas foundImage = item; } else if (item._webGLRenderStyle === 2) { // this is a Bitmap class foundImage = item.image; } else if (item._webGLRenderStyle === 1) { // this is a SpriteSheet, we can't tell which image we used from the list easily so remove them all! for (i = 0, l = item.spriteSheet._images.length; i < l; i++) { this.releaseTexture(item.spriteSheet._images[i], safe); } return; } // did we find anything if (foundImage === undefined) { if (this.vocalDebug) { console.log("No associated texture found on release"); } return; } // remove it var texture = this._textureDictionary[foundImage._storeID]; if (safe) { var data = texture._imageData; var index = data.indexOf(foundImage); if (index >= 0) { data.splice(index, 1); } foundImage._storeID = undefined; if (data.length === 0) { this._killTextureObject(texture); } } else { this._killTextureObject(texture); } }; /** * Similar to {{#crossLink "releaseTexture"}}{{/crossLink}}, but this function differs by searching for textures to * release. It works by assuming that it can purge any texture which was last used more than "count" draw calls ago. * Because this process is unaware of the objects and whether they may be used later on your stage, false positives can * occur. It is recommended to manually manage your memory with {{#crossLink "StageGL/releaseTexture"}}{{/crossLink}}, * however, there are many use cases where this is simpler and error-free. This process is also run by default under * the hood to prevent leaks. To disable it see the {{#crossLink "StageGL/autoPurge:property"}}{{/crossLink}} property. * @method purgeTextures * @param {Number} [count=100] How many renders ago the texture was last used */ p.purgeTextures = function (count) { if (!(count >= 0)){ count = 100; } var dict = this._textureDictionary; var l = dict.length; for (var i = 0; inot update the canvas element's width/height, but * the render surface's instead. This is necessary after manually resizing the canvas element on the DOM to avoid a * up/down scaled render. * @method updateViewport * @param {int} width The width of the render surface in pixels. * @param {int} height The height of the render surface in pixels. */ p.updateViewport = function (width, height) { width = Math.abs(width|0) || 1; height = Math.abs(height|0) || 1; this._updateDrawingSurface(width, height); if (this._bufferTextureOutput !== this && this._bufferTextureOutput !== null) { this.resizeTexture(this._bufferTextureOutput, this._viewportWidth, this._viewportHeight); } if (this._bufferTextureConcat !== null) { this.resizeTexture(this._bufferTextureConcat, this._viewportWidth, this._viewportHeight); } if (this._bufferTextureTemp !== null) { this.resizeTexture(this._bufferTextureTemp, this._viewportWidth, this._viewportHeight); } }; /** * Fetches the shader compiled and set up to work with the provided filter/object. The shader is compiled on first * use and returned on subsequent calls. * @method getFilterShader * @param {Filter|Object} filter The object which will provide the information needed to construct the filter shader. * @return {WebGLProgram} */ p.getFilterShader = function (filter) { if (!filter) { filter = this; } var gl = this._webGLContext; var targetShader = this._activeShader; if (filter._builtShader) { targetShader = filter._builtShader; if (filter.shaderParamSetup) { gl.useProgram(targetShader); filter.shaderParamSetup(gl, this, targetShader); } } else { try { targetShader = this._fetchShaderProgram( true, filter.VTX_SHADER_BODY, filter.FRAG_SHADER_BODY, filter.shaderParamSetup && filter.shaderParamSetup.bind(filter) ); filter._builtShader = targetShader; targetShader._name = filter.toString(); } catch (e) { console && console.log("SHADER SWITCH FAILURE", e); } } return targetShader; }; /** * Returns a base texture that has no image or data loaded. Not intended for loading images. It may return `null` * in some error cases, and trying to use a "null" texture can cause renders to fail. * @method getBaseTexture * @param {uint} [w=1] The width of the texture in pixels, defaults to 1 * @param {uint} [h=1] The height of the texture in pixels, defaults to 1 */ p.getBaseTexture = function (w, h) { var width = Math.ceil(w > 0 ? w : 1) || 1; var height = Math.ceil(h > 0 ? h : 1) || 1; var gl = this._webGLContext; var texture = gl.createTexture(); this.resizeTexture(texture, width, height); this.setTextureParams(gl, false); return texture; }; /** * Resizes a supplied texture element. May generate invalid textures in some error cases such as; when the texture * is too large, when an out of texture memory error occurs, or other error scenarios. Trying to use an invalid texture * can cause renders to hard stop on some devices. Check the WebGL bound texture after running this function. * * NOTE: The supplied texture must have been made with the WebGL "texImage2D" function, all default APIs in StageGL * use this, so this note only matters for library developers and plugins. * * @protected * @method resizeTexture * @param {WebGLTexture} texture The GL Texture to be modified. * @param {uint} width The width of the texture in pixels * @param {uint} height The height of the texture in pixels */ p.resizeTexture = function (texture, width,height) { if (texture.width === width && texture.height === height){ return; } var gl = this._webGLContext; gl.bindTexture(gl.TEXTURE_2D, texture); gl.texImage2D( gl.TEXTURE_2D, // target 0, // level of detail gl.RGBA, // internal format width, height, 0, // width, height, border (only for array/null sourced textures) gl.RGBA, // format (match internal format) gl.UNSIGNED_BYTE, // type of texture(pixel color depth) null // image data, we can do null because we're doing array data ); // set its width and height for spoofing as an image and tracking texture.width = width; texture.height = height; }; /** * Returns a base texture (see {{#crossLink "StageGL/getBaseTexture"}}{{/crossLink}}) for details. Also includes an * attached and linked render buffer in `texture._frameBuffer`. RenderTextures can be thought of as an internal * canvas on the GPU that can be drawn to. Being internal to the GPU they are much faster than "offscreen canvases". * @method getRenderBufferTexture * @param {Number} w The width of the texture in pixels. * @param {Number} h The height of the texture in pixels. * @return {WebGLTexture} the basic texture instance with a render buffer property. */ p.getRenderBufferTexture = function (w, h) { var gl = this._webGLContext; var renderTexture = this.getBaseTexture(w, h); if (!renderTexture) { return null; } var frameBuffer = gl.createFramebuffer(); if (!frameBuffer) { return null; } // set its width and height for spoofing as an image and tracking renderTexture.width = w; renderTexture.height = h; // attach frame buffer to texture and provide cross links to look up each other gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer); gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, renderTexture, 0); frameBuffer._renderTexture = renderTexture; renderTexture._frameBuffer = frameBuffer; // these keep track of themselves simply to reduce complexity of some lookup code renderTexture._storeID = this._textureDictionary.length; this._textureDictionary[renderTexture._storeID] = renderTexture; gl.bindFramebuffer(gl.FRAMEBUFFER, null); return renderTexture; }; /** * Common utility function used to apply the correct texture processing parameters for the bound texture. * @method setTextureParams * @param {WebGLRenderingContext} gl The canvas WebGL context object to draw into. * @param {Boolean} [isPOT=false] Marks whether the texture is "Power of Two", this may allow better quality AA. */ p.setTextureParams = function (gl, isPOT) { if (isPOT && this._antialias) { //non POT linear works in some devices, but performance is NOT good, investigate gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); } else { gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST); } gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); }; /** * Changes the webGL clear, aka "background" color to the provided value. A transparent clear is recommended, as * non-transparent colours may create undesired boxes around some visuals. * * The clear color will also be used for filters and other "render textures". The stage background will ignore the * transparency value and display a solid color normally. For the stage to recognize and use transparency it must be * created with the transparent flag set to `true` (see {{#crossLink "StageGL/constructor"}}{{/crossLink}})). * * Using "transparent white" to demonstrate, the valid data formats are as follows: *
    *
  • "#FFF"
  • *
  • "#FFFFFF"
  • *
  • "#FFFFFF00"
  • *
  • "rgba(255,255,255,0.0)"
  • *
* @method setClearColor * @param {String|int} [color=0x00000000] The new color to use as the background */ p.setClearColor = function (color) { this._clearColor = StageGL.colorToObj(color); }; /** * Returns a data url that contains a Base64-encoded image of the contents of the stage. The returned data url can * be specified as the src value of an image element. StageGL renders differently than Context2D and the information * of the last render is harder to get. For best results turn directDraw to false, or preserveBuffer to true and no * backgorund color. * @method toDataURL * @param {String} [backgroundColor=undefined] The background color to be used for the generated image. See setClearColor * for valid values. A value of undefined will make no adjustments to the existing background which may be significantly faster. * @param {String} [mimeType="image/png"] The MIME type of the image format to be create. The default is "image/png". If an unknown MIME type * is passed in, or if the browser does not support the specified MIME type, the default value will be used. * @return {String} a Base64 encoded image. **/ p.toDataURL = function(backgroundColor, mimeType) { var dataURL, gl = this._webGLContext; this.batchReason = "dataURL"; var clearBackup = this._clearColor; if (!this.canvas) { return; } if (!StageGL.isWebGLActive(gl)) { return this.Stage_toDataURL(backgroundColor, mimeType); } // if the buffer is preserved and we don't want a background we can just output what we have, otherwise we'll have to render it if(!this._preserveBuffer || backgroundColor !== undefined) { // render it onto the right background if(backgroundColor !== undefined) { this._clearColor = StageGL.colorToObj(backgroundColor); } this.clear(); // if we're not using directDraw then we can just trust the last buffer content if(!this._directDraw) { this._drawCover(null, this._bufferTextureOutput); } else { console.log("No stored/useable gl render info, result may be incorrect if content was changed since render"); this.draw(gl); } } // create the dataurl dataURL = this.canvas.toDataURL(mimeType||"image/png"); // reset the picture in the canvas if(!this._preserveBuffer || backgroundColor !== undefined) { if(backgroundColor !== undefined) { this._clearColor = clearBackup; } this.clear(); if(!this._directDraw) { this._drawCover(null, this._bufferTextureOutput); } else { this.draw(gl); } } return dataURL; }; // Docced in subclass p.toString = function () { return "[StageGL (name="+ this.name +")]"; }; // private methods: /** * Changes the active drawing surface and view matrix to the correct parameters without polluting the concept * of the current stage size * @param {uint} w The width of the surface in pixels, defaults to _viewportWidth * @param {uint} h The height of the surface in pixels, defaults to _viewportHeight */ p._updateDrawingSurface = function(w, h) { this._viewportWidth = w; this._viewportHeight = h; this._webGLContext.viewport(0, 0, this._viewportWidth, this._viewportHeight); // WebGL works with a -1,1 space on its screen. It also follows Y-Up // we need to flip the y, scale and then translate the co-ordinates to match this // additionally we offset into they Y so the polygons are inside the camera's "clipping" plane this._projectionMatrix = new Float32Array([ 2 / w, 0, 0, 0, 0, -2 / h, 0, 0, 0, 0, 1, 0, -1, 1, 0, 1 ]); }; /** * Returns a base texture that has no image or data loaded. Not intended for loading images. In some error cases, * the texture creation will fail. This function differs from {{#crossLink "StageGL/getBaseTexture"}}{{/crossLink}} * in that the failed textures will be replaced with a safe to render "nothing" texture. * @method _getSafeTexture * @param {uint} [w=1] The width of the texture in pixels, defaults to 1 * @param {uint} [h=1] The height of the texture in pixels, defaults to 1 * @protected */ p._getSafeTexture = function (w, h) { var texture = this.getBaseTexture(w, h); if (!texture) { var msg = "Problem creating texture, possible cause: using too much VRAM, please try releasing texture memory"; (console.error && console.error(msg)) || console.log(msg); texture = this._baseTextures[0]; } return texture; }; /** * Visually clear out the currently active FrameBuffer, does not rebind or adjust the frameBuffer in use. * @method _getSafeTexture * @param alpha * @protected */ p._clearFrameBuffer = function (alpha) { var gl = this._webGLContext; var cc = this._clearColor; if (alpha > 0) { alpha = 1; } if (alpha < 0) { alpha = 0; } // Use WebGL settings; adjust for pre multiplied alpha appropriate to scenario gl.clearColor(cc.r * alpha, cc.g * alpha, cc.b * alpha, alpha); gl.clear(gl.COLOR_BUFFER_BIT); gl.clearColor(0, 0, 0, 0); }; /** * Sets up and returns the WebGL context for the canvas. May return undefined in error scenarios. These can include * situations where the canvas element already has a context, 2D or GL. * @param {Canvas} canvas The DOM canvas element to attach to * @param {Object} options The options to be handed into the WebGL object, see WebGL spec * @method _fetchWebGLContext * @protected * @return {WebGLRenderingContext} The WebGL context, may return undefined in error scenarios */ p._fetchWebGLContext = function (canvas, options) { var gl; try { gl = canvas.getContext("webgl", options) || canvas.getContext("experimental-webgl", options); } catch (e) { // don't do anything in catch, null check will handle it } if (!gl) { var msg = "Could not initialize WebGL"; console.error?console.error(msg):console.log(msg); } else { gl.viewportWidth = canvas.width; gl.viewportHeight = canvas.height; } return gl; }; /** * Create the completed Shader Program from the vertex and fragment shaders. Allows building of custom shaders for * filters. Once compiled, shaders are saved so. If the Shader code requires dynamic alterations re-run this function * to generate a new shader. * @method _fetchShaderProgram * @param {Boolean} coverShader Is this a per object shader or a cover shader * Filter and override both accept the custom params. Regular and override have all features. Filter is a special case reduced feature shader meant to be over-ridden. * @param {String | undefined} [customVTX=undefined] Extra vertex shader information to replace a regular draw, see * {{#crossLink "StageGL/COVER_VERTEX_BODY"}}{{/crossLink}} for default and {{#crossLink "Filter"}}{{/crossLink}} for examples. * @param {String | undefined} [customFRAG=undefined] Extra fragment shader information to replace a regular draw, see * {{#crossLink "StageGL/COVER_FRAGMENT_BODY"}}{{/crossLink}} for default and {{#crossLink "Filter"}}{{/crossLink}} for examples. * @param {Function | undefined} [shaderParamSetup=undefined] Function to run so custom shader parameters can get applied for the render. * @protected * @return {WebGLProgram} The compiled and linked shader */ p._fetchShaderProgram = function (coverShader, customVTX, customFRAG, shaderParamSetup) { var gl = this._webGLContext; gl.useProgram(null); // safety to avoid collisions // build the correct shader string out of the right headers and bodies var targetFrag, targetVtx; if (coverShader) { targetVtx = StageGL.COVER_VERTEX_HEADER + (customVTX || StageGL.COVER_VERTEX_BODY); targetFrag = StageGL.COVER_FRAGMENT_HEADER + (customFRAG || StageGL.COVER_FRAGMENT_BODY); } else { targetVtx = StageGL.REGULAR_VERTEX_HEADER + (customVTX || StageGL.REGULAR_VERTEX_BODY); targetFrag = StageGL.REGULAR_FRAGMENT_HEADER + (customFRAG || StageGL.REGULAR_FRAGMENT_BODY); } // create the separate vars var vertexShader = this._createShader(gl, gl.VERTEX_SHADER, targetVtx); var fragmentShader = this._createShader(gl, gl.FRAGMENT_SHADER, targetFrag); // link them together var shaderProgram = gl.createProgram(); gl.attachShader(shaderProgram, vertexShader); gl.attachShader(shaderProgram, fragmentShader); gl.linkProgram(shaderProgram); // check compile status if (!gl.getProgramParameter(shaderProgram, gl.LINK_STATUS)) { gl.useProgram(this._activeShader); throw gl.getProgramInfoLog(shaderProgram); } // set up the parameters on the shader gl.useProgram(shaderProgram); // get the places in memory the shader is stored so we can feed information into them // then save it off on the shader because it's so tied to the shader itself shaderProgram.vertexPositionAttribute = gl.getAttribLocation(shaderProgram, "vertexPosition"); gl.enableVertexAttribArray(shaderProgram.vertexPositionAttribute); shaderProgram.uvPositionAttribute = gl.getAttribLocation(shaderProgram, "uvPosition"); gl.enableVertexAttribArray(shaderProgram.uvPositionAttribute); if (coverShader) { shaderProgram.samplerUniform = gl.getUniformLocation(shaderProgram, "uSampler"); gl.uniform1i(shaderProgram.samplerUniform, 0); // if there's some custom attributes be sure to hook them up if (shaderParamSetup) { shaderParamSetup(gl, this, shaderProgram); } } else { shaderProgram.textureIndexAttribute = gl.getAttribLocation(shaderProgram, "textureIndex"); gl.enableVertexAttribArray(shaderProgram.textureIndexAttribute); shaderProgram.alphaAttribute = gl.getAttribLocation(shaderProgram, "objectAlpha"); gl.enableVertexAttribArray(shaderProgram.alphaAttribute); var samplers = []; for (var i = 0; i < this._gpuTextureCount; i++) { samplers[i] = i; } shaderProgram.samplerData = samplers; shaderProgram.samplerUniform = gl.getUniformLocation(shaderProgram, "uSampler"); gl.uniform1iv(shaderProgram.samplerUniform, shaderProgram.samplerData); shaderProgram.pMatrixUniform = gl.getUniformLocation(shaderProgram, "pMatrix"); } shaderProgram._type = coverShader ? "cover" : "batch"; gl.useProgram(this._activeShader); return shaderProgram; }; /** * Creates a shader from the specified string replacing templates. Template items are defined via `{{` `key` `}}``. * @method _createShader * @param {WebGLRenderingContext} gl The canvas WebGL context object to draw into. * @param {Number} type The type of shader to create. gl.VERTEX_SHADER | gl.FRAGMENT_SHADER * @param {String} str The definition for the shader. * @return {WebGLShader} * @protected */ p._createShader = function (gl, type, str) { var textureCount = this._batchTextureCount; // inject the static number str = str.replace(/\{\{count}}/g, textureCount); if (type === gl.FRAGMENT_SHADER) { // resolve issue with no dynamic samplers by creating correct samplers in if else chain // TODO: WebGL 2.0 does not need this support var insert = ""; for (var i = 1; i gl.MAX_TEXTURE_SIZE || image.height > gl.MAX_TEXTURE_SIZE){ console && console.error("Oversized Texture: "+ image.width+"x"+image.height +" vs "+ gl.MAX_TEXTURE_SIZE +"max"); } } }; /** * Adds the texture to a spot in the current batch, forcing a draw if no spots are free. * @method _insertTextureInBatch * @param {WebGLRenderingContext} gl The canvas WebGL context object to draw into. * @param {WebGLTexture} texture The texture to be inserted. * @protected */ p._insertTextureInBatch = function (gl, texture) { var image; if (this._batchTextures[texture._activeIndex] !== texture) { // if it wasn't used last batch // we've got to find it a a spot. var found = -1; var start = (this._lastTextureInsert+1) % this._batchTextureCount; var look = start; do { if (this._batchTextures[look]._batchID !== this._batchID && !this._slotBlacklist[look]) { found = look; break; } look = (look+1) % this._batchTextureCount; } while (look !== start); // we couldn't find anywhere for it go, meaning we're maxed out if (found === -1) { this.batchReason = "textureOverflow"; this._renderBatch(); // <------------------------------------------------------------------------ found = start; //TODO: how do we optimize this to be smarter? } // lets put it into that spot this._batchTextures[found] = texture; texture._activeIndex = found; image = texture._imageData && texture._imageData[0]; // first come first served, potentially problematic if (image && ((image._invalid === undefined && image._isCanvas) || image._invalid)) { this._updateTextureImageData(gl, image); } else { // probably redundant, confirm functionality then remove from codebase //gl.activeTexture(gl.TEXTURE0 + found); //gl.bindTexture(gl.TEXTURE_2D, texture); //this.setTextureParams(gl); } this._lastTextureInsert = found; } else if (texture._drawID !== this._drawID) { // being active from previous draws doesn't mean up to date image = texture._imageData && texture._imageData[0]; if (image && ((image._invalid === undefined && image._isCanvas) || image._invalid)) { this._updateTextureImageData(gl, image); } } texture._drawID = this._drawID; texture._batchID = this._batchID; }; /** * Remove and clean the texture, expects a texture and is inflexible. Mostly for internal use, recommended to call * {{#crossLink "StageGL/releaseTexture"}}{{/crossLink}} instead as it will call this with the correct texture object(s). * Note: Testing shows this may not happen immediately, have to wait frames for WebGL to have actually adjust memory. * @method _killTextureObject * @param {WebGLTexture} texture The texture to be cleaned out * @protected */ p._killTextureObject = function (texture) { if (!texture) { return; } var gl = this._webGLContext; // remove linkage if (texture._storeID !== undefined && texture._storeID >= 0) { this._textureDictionary[texture._storeID] = undefined; for (var n in this._textureIDs) { if (this._textureIDs[n] === texture._storeID) { delete this._textureIDs[n]; } } var data = texture._imageData; if (data) { for (var i=data.length-1; i>=0; i--) { data[i]._storeID = undefined; } } texture._imageData = texture._storeID = undefined; } // make sure to drop it out of an active slot if (texture._activeIndex !== undefined && this._batchTextures[texture._activeIndex] === texture) { this._batchTextures[texture._activeIndex] = this._baseTextures[texture._activeIndex]; } // remove buffers if present try { if (texture._frameBuffer) { gl.deleteFramebuffer(texture._frameBuffer); } texture._frameBuffer = undefined; } catch(e) { /* suppress delete errors because it's already gone or didn't need deleting probably */ if (this.vocalDebug) { console.log(e); } } // remove entry try { gl.deleteTexture(texture); } catch(e) { /* suppress delete errors because it's already gone or didn't need deleting probably */ if (this.vocalDebug) { console.log(e); } } }; /** * Small utility function to keep internal API consistent and set the uniforms for a dual texture cover render * @method _setCoverMixShaderParams * @param {WebGLRenderingContext} gl The context where the drawing takes place * @param stage unused * @param shaderProgram unused * @protected */ p._setCoverMixShaderParams = function (gl, stage, shaderProgram) { gl.uniform1i( gl.getUniformLocation(shaderProgram, "uMixSampler"), 1 ); }; /** * Change the respective render settings and filters to the correct settings. Will build the shader on first use. * @method _updateRenderMode * @param {String} newMode Composite operation name * @protected */ p._updateRenderMode = function (newMode) { if ( newMode === null || newMode === undefined){ newMode = "source-over"; } var blendSrc = StageGL.BLEND_SOURCES[newMode]; if (blendSrc === undefined) { if (this.vocalDebug){ console.log("Unknown compositeOperation ["+ newMode +"], reverting to default"); } blendSrc = StageGL.BLEND_SOURCES[newMode = "source-over"]; } if (this._renderMode === newMode) { return; } var gl = this._webGLContext; var shaderData = this._builtShaders[newMode]; if (shaderData === undefined) { try { shaderData = this._builtShaders[newMode] = { eqRGB: gl[blendSrc.eqRGB || "FUNC_ADD"], srcRGB: gl[blendSrc.srcRGB || "ONE"], dstRGB: gl[blendSrc.dstRGB || "ONE_MINUS_SRC_ALPHA"], eqA: gl[blendSrc.eqA || "FUNC_ADD"], srcA: gl[blendSrc.srcA || "ONE"], dstA: gl[blendSrc.dstA || "ONE_MINUS_SRC_ALPHA"], immediate: blendSrc.shader !== undefined, shader: (blendSrc.shader || this._builtShaders["source-over"] === undefined) ? this._fetchShaderProgram( true, undefined, blendSrc.shader, this._setCoverMixShaderParams ) : this._builtShaders["source-over"].shader // re-use source-over when we don't need a new shader }; if (blendSrc.shader) { shaderData.shader._name = newMode; } } catch (e) { this._builtShaders[newMode] = undefined; console && console.log("SHADER SWITCH FAILURE", e); return; } } if (shaderData.immediate && this._directDraw) { if (this.vocalDebug) { console.log("Illegal compositeOperation ["+ newMode +"] due to StageGL.directDraw = true, reverting to default"); } return; } gl.bindFramebuffer(gl.FRAMEBUFFER, this._batchTextureOutput._frameBuffer); this.batchReason = "shaderSwap"; this._renderBatch(); // <-------------------------------------------------------------------------------- this._renderMode = newMode; this._immediateRender = shaderData.immediate; gl.blendEquationSeparate(shaderData.eqRGB, shaderData.eqA); gl.blendFuncSeparate(shaderData.srcRGB, shaderData.dstRGB, shaderData.srcA, shaderData.dstA); }; /** * Helper function for the standard content draw * @method _drawContent * @param {Stage | Container} content * @param {Boolean} ignoreCache * @protected */ p._drawContent = function (content, ignoreCache) { var gl = this._webGLContext; this._activeShader = this._mainShader; gl.bindFramebuffer(gl.FRAMEBUFFER, this._batchTextureOutput._frameBuffer); if(this._batchTextureOutput._frameBuffer !== null) { gl.clear(gl.COLOR_BUFFER_BIT); } this._appendToBatch(content, new createjs.Matrix2D(), this.alpha, ignoreCache); this.batchReason = "contentEnd"; this._renderBatch(); }; /** * Used to draw one or more textures potentially using a filter into the supplied buffer. * Mostly used for caches, filters, and outputting final render frames. * Draws `dst` into `out` after applying `srcFilter` depending on its current value. * @method _drawCover * @param {WebGLFramebuffer} out Buffer to draw the results into (null is the canvas element) * @param {WebGLTexture} dst Base texture layer aka "destination" in image blending terminology * @param {WebGLTexture | Filter} [srcFilter = undefined] Modification parameter for the draw. If a texture, the * current _renderMode applies it as a "source" image. If a Filter, the filter is applied to the dst with its params. * @protected */ p._drawCover = function (out, dst, srcFilter) { var gl = this._webGLContext; gl.bindFramebuffer(gl.FRAMEBUFFER, out); if (out !== null){ gl.clear(gl.COLOR_BUFFER_BIT); } gl.activeTexture(gl.TEXTURE0); gl.bindTexture(gl.TEXTURE_2D, dst); this.setTextureParams(gl); if (srcFilter instanceof createjs.Filter) { this._activeShader = this.getFilterShader(srcFilter); } else { if (srcFilter instanceof WebGLTexture) { gl.activeTexture(gl.TEXTURE1); gl.bindTexture(gl.TEXTURE_2D, srcFilter); this.setTextureParams(gl); } else if (srcFilter !== undefined && this.vocalDebug) { console.log("Unknown data handed to function: ", srcFilter); } this._activeShader = this._builtShaders[this._renderMode].shader; } this._renderCover(); }; /** * Returns a matrix that can be used to counter position the `target` so that it fits and scales to the `manager` * @param {DisplayObject} target The object to be counter positioned * @param {BitmapCache} manager The cache manager to be aligned to * @returns {Matrix2D} The matrix that can be used used to counter position the container * @method _alignTargetToCache * @private */ p._alignTargetToCache = function(target, manager) { if (manager._counterMatrix === null) { manager._counterMatrix = target.getMatrix(); } else { target.getMatrix(manager._counterMatrix) } var mtx = manager._counterMatrix; mtx.scale(1/manager.scale, 1/manager.scale); mtx = mtx.invert(); mtx.translate(-manager.offX/manager.scale*target.scaleX, -manager.offY/manager.scale*target.scaleY); return mtx; }; /** * Add all the contents of a container to the pending buffers, called recursively on each container. This may * trigger a draw if a buffer runs out of space. This is the main workforce of the render loop. * @method _appendToBatch * @param {Container} container The {{#crossLink "Container"}}{{/crossLink}} that contains everything to be drawn. * @param {Matrix2D} concatMtx The effective (concatenated) transformation matrix when beginning this container * @param {Number} concatAlpha The effective (concatenated) alpha when beginning this container * @param {Boolean} [ignoreCache=false] Don't use an element's cache during this draw * @protected */ p._appendToBatch = function (container, concatMtx, concatAlpha, ignoreCache) { var gl = this._webGLContext; // sort out shared properties var cMtx = container._glMtx; cMtx.copy(concatMtx); if (container.transformMatrix !== null) { cMtx.appendMatrix(container.transformMatrix); } else { cMtx.appendTransform( container.x, container.y, container.scaleX, container.scaleY, container.rotation, container.skewX, container.skewY, container.regX, container.regY ); } var previousRenderMode = this._renderMode; if (container.compositeOperation) { this._updateRenderMode(container.compositeOperation); } // sub components of figuring out the position an object holds var subL, subT, subR, subB; // actually apply its data to the buffers var l = container.children.length; for (var i = 0; i < l; i++) { var item = container.children[i]; var useCache = (!ignoreCache && item.cacheCanvas) || false; if (!(item.visible && concatAlpha > 0.0035)) { continue; } var itemAlpha = item.alpha; if (useCache === false) { if (item._updateState){ item._updateState(); } if(!this._directDraw && (!ignoreCache && item.cacheCanvas === null && item.filters !== null && item.filters.length)) { var bounds; if (item.bitmapCache === null) { bounds = item.getBounds(); item.bitmapCache = new createjs.BitmapCache(); item.bitmapCache._autoGenerated = true; } if (item.bitmapCache._autoGenerated) { this.batchReason = "cachelessFilterInterupt"; this._renderBatch(); // <---------------------------------------------------- item.alpha = 1; var shaderBackup = this._activeShader; bounds = bounds || item.getBounds(); item.bitmapCache.define(item, bounds.x, bounds.y, bounds.width, bounds.height, 1, {useGL:this}); useCache = item.bitmapCache._cacheCanvas; item.alpha = itemAlpha; this._activeShader = shaderBackup; gl.bindFramebuffer(gl.FRAMEBUFFER, this._batchTextureOutput._frameBuffer); } } } if (useCache === false && item.children) { this._appendToBatch(item, cMtx, itemAlpha * concatAlpha); continue; } var containerRenderMode = this._renderMode; if (item.compositeOperation) { this._updateRenderMode(item.compositeOperation); } // check for overflowing batch, if yes then force a render if (this._batchVertexCount + StageGL.INDICIES_PER_CARD > this._maxBatchVertexCount) { this.batchReason = "vertexOverflow"; this._renderBatch(); // <------------------------------------------------------------ } // keep track of concatenated position var iMtx = item._glMtx; iMtx.copy(cMtx); if (item.transformMatrix) { iMtx.appendMatrix(item.transformMatrix); } else { iMtx.appendTransform( item.x, item.y, item.scaleX, item.scaleY, item.rotation, item.skewX, item.skewY, item.regX, item.regY ); } var uvRect, texIndex, image, frame, texture, src; // get the image data, or abort if not present // BITMAP / Cached Canvas if (item._webGLRenderStyle === 2 || useCache !== false) { image = useCache === false ? item.image : useCache; // SPRITE } else if (item._webGLRenderStyle === 1) { frame = item.spriteSheet.getFrame(item.currentFrame); if (frame === null) { continue; } image = frame.image; // MISC (DOM objects render themselves later) } else { continue; } if (!image) { continue; } var uvs = this._uvs; var vertices = this._vertices; var texI = this._indices; var alphas = this._alphas; // calculate texture if (image._storeID === undefined) { // this texture is new to us so load it and add it to the batch texture = this._loadTextureImage(gl, image); } else { // fetch the texture (render textures know how to look themselves up to simplify this logic) texture = this._textureDictionary[image._storeID]; if (!texture){ //TODO: this should really not occur but has due to bugs, hopefully this can be removed eventually if (this.vocalDebug){ console.log("Image source should not be lookup a non existent texture, please report a bug."); } continue; } // put it in the batch if needed if (texture._batchID !== this._batchID) { this._insertTextureInBatch(gl, texture); } } texIndex = texture._activeIndex; image._drawID = this._drawID; // BITMAP / Cached Canvas if (item._webGLRenderStyle === 2 || useCache !== false) { if (useCache === false && item.sourceRect) { // calculate uvs if (!item._uvRect) { item._uvRect = {}; } src = item.sourceRect; uvRect = item._uvRect; uvRect.t = 1 - ((src.y)/image.height); uvRect.l = (src.x)/image.width; uvRect.b = 1 - ((src.y + src.height)/image.height); uvRect.r = (src.x + src.width)/image.width; // calculate vertices subL = 0; subT = 0; subR = src.width+subL; subB = src.height+subT; } else { // calculate uvs uvRect = StageGL.UV_RECT; // calculate vertices if (useCache === false) { subL = 0; subT = 0; subR = image.width+subL; subB = image.height+subT; } else { src = item.bitmapCache; subL = src.x+(src._filterOffX/src.scale); subT = src.y+(src._filterOffY/src.scale); subR = (src._drawWidth/src.scale)+subL; subB = (src._drawHeight/src.scale)+subT; } } // SPRITE } else if (item._webGLRenderStyle === 1) { var rect = frame.rect; // calculate uvs uvRect = frame.uvRect; if (!uvRect) { uvRect = StageGL.buildUVRects(item.spriteSheet, item.currentFrame, false); } // calculate vertices subL = -frame.regX; subT = -frame.regY; subR = rect.width-frame.regX; subB = rect.height-frame.regY; } // These must be calculated here else a forced draw might happen after they're set var offV1 = this._batchVertexCount; // offset for 1 component vectors var offV2 = offV1*2; // offset for 2 component vectors //DHG: See Matrix2D.transformPoint for why this math specifically // apply vertices vertices[offV2] = subL *iMtx.a + subT *iMtx.c +iMtx.tx; vertices[offV2+1] = subL *iMtx.b + subT *iMtx.d +iMtx.ty; vertices[offV2+2] = subL *iMtx.a + subB *iMtx.c +iMtx.tx; vertices[offV2+3] = subL *iMtx.b + subB *iMtx.d +iMtx.ty; vertices[offV2+4] = subR *iMtx.a + subT *iMtx.c +iMtx.tx; vertices[offV2+5] = subR *iMtx.b + subT *iMtx.d +iMtx.ty; vertices[offV2+6] = vertices[offV2+2]; vertices[offV2+7] = vertices[offV2+3]; vertices[offV2+8] = vertices[offV2+4]; vertices[offV2+9] = vertices[offV2+5]; vertices[offV2+10] = subR *iMtx.a + subB *iMtx.c +iMtx.tx; vertices[offV2+11] = subR *iMtx.b + subB *iMtx.d +iMtx.ty; // apply uvs uvs[offV2] = uvRect.l; uvs[offV2+1] = uvRect.t; uvs[offV2+2] = uvRect.l; uvs[offV2+3] = uvRect.b; uvs[offV2+4] = uvRect.r; uvs[offV2+5] = uvRect.t; uvs[offV2+6] = uvRect.l; uvs[offV2+7] = uvRect.b; uvs[offV2+8] = uvRect.r; uvs[offV2+9] = uvRect.t; uvs[offV2+10] = uvRect.r; uvs[offV2+11] = uvRect.b; // apply texture texI[offV1] = texI[offV1+1] = texI[offV1+2] = texI[offV1+3] = texI[offV1+4] = texI[offV1+5] = texIndex; // apply alpha alphas[offV1] = alphas[offV1+1] = alphas[offV1+2] = alphas[offV1+3] = alphas[offV1+4] = alphas[offV1+5] = itemAlpha * concatAlpha; this._batchVertexCount += StageGL.INDICIES_PER_CARD; if (this._immediateRender) { this._immediateBatchRender(); } if (this._renderMode !== containerRenderMode) { this._updateRenderMode(containerRenderMode); } } if (this._renderMode !== previousRenderMode) { this._updateRenderMode(previousRenderMode); } }; /** * The shader or effect needs to be drawn immediately, sub function of `_appendToBatch` * @method _immediateBatchRender * @protected */ p._immediateBatchRender = function() { var gl = this._webGLContext; if (this._batchTextureConcat === null){ this._batchTextureConcat = this.getRenderBufferTexture(this._viewportWidth, this._viewportHeight); } else { this.resizeTexture(this._batchTextureConcat, this._viewportWidth, this._viewportHeight); gl.bindFramebuffer(gl.FRAMEBUFFER, this._batchTextureConcat._frameBuffer); gl.clear(gl.COLOR_BUFFER_BIT); } if (this._batchTextureTemp === null){ this._batchTextureTemp = this.getRenderBufferTexture(this._viewportWidth, this._viewportHeight); gl.bindFramebuffer(gl.FRAMEBUFFER, this._batchTextureTemp._frameBuffer); } else { this.resizeTexture(this._batchTextureTemp, this._viewportWidth, this._viewportHeight); gl.bindFramebuffer(gl.FRAMEBUFFER, this._batchTextureTemp._frameBuffer); gl.clear(gl.COLOR_BUFFER_BIT); } var swap = this._batchTextureOutput; this._batchTextureOutput = this._batchTextureConcat; this._batchTextureConcat = swap; this._activeShader = this._mainShader; this.batchReason = "immediatePrep"; this._renderBatch();//<----------------------------------------------------------------------------------------- this.batchReason = "immediateResults"; this._drawCover(this._batchTextureOutput._frameBuffer, this._batchTextureConcat, this._batchTextureTemp); gl.bindFramebuffer(gl.FRAMEBUFFER, this._batchTextureOutput._frameBuffer); }; /** * Draws all the currently defined cards in the buffer to the render surface. * @method _renderBatch * @protected */ p._renderBatch = function () { if (this._batchVertexCount <= 0) { return; } // prevents error logs on stages filled with un-renederable content. var gl = this._webGLContext; if (this.vocalDebug) { console.log("Batch["+ this._drawID +":"+ this._batchID +"] : "+ this.batchReason); } var shaderProgram = this._activeShader; var vertexPositionBuffer = this._vertexPositionBuffer; var textureIndexBuffer = this._textureIndexBuffer; var uvPositionBuffer = this._uvPositionBuffer; var alphaBuffer = this._alphaBuffer; gl.useProgram(shaderProgram); gl.bindBuffer(gl.ARRAY_BUFFER, vertexPositionBuffer); gl.vertexAttribPointer(shaderProgram.vertexPositionAttribute, vertexPositionBuffer.itemSize, gl.FLOAT, false, 0, 0); gl.bufferSubData(gl.ARRAY_BUFFER, 0, this._vertices); gl.bindBuffer(gl.ARRAY_BUFFER, textureIndexBuffer); gl.vertexAttribPointer(shaderProgram.textureIndexAttribute, textureIndexBuffer.itemSize, gl.FLOAT, false, 0, 0); gl.bufferSubData(gl.ARRAY_BUFFER, 0, this._indices); gl.bindBuffer(gl.ARRAY_BUFFER, uvPositionBuffer); gl.vertexAttribPointer(shaderProgram.uvPositionAttribute, uvPositionBuffer.itemSize, gl.FLOAT, false, 0, 0); gl.bufferSubData(gl.ARRAY_BUFFER, 0, this._uvs); gl.bindBuffer(gl.ARRAY_BUFFER, alphaBuffer); gl.vertexAttribPointer(shaderProgram.alphaAttribute, alphaBuffer.itemSize, gl.FLOAT, false, 0, 0); gl.bufferSubData(gl.ARRAY_BUFFER, 0, this._alphas); gl.uniformMatrix4fv(shaderProgram.pMatrixUniform, gl.FALSE, this._projectionMatrix); for (var i = 0; i < this._batchTextureCount; i++) { gl.activeTexture(gl.TEXTURE0 + i); gl.bindTexture(gl.TEXTURE_2D, this._batchTextures[i]); } gl.drawArrays(gl.TRIANGLES, 0, this._batchVertexCount); this._batchVertexCount = 0; this._batchID++; }; /** * Draws a card that covers the entire render surface. Mainly used for filters and composite operations. * @method _renderCover * @protected */ p._renderCover = function () { var gl = this._webGLContext; if (this.vocalDebug) { console.log("Cover["+ this._drawID +":"+ this._batchID +"] : "+ this.batchReason); } var shaderProgram = this._activeShader; var vertexPositionBuffer = this._vertexPositionBuffer; var uvPositionBuffer = this._uvPositionBuffer; gl.useProgram(shaderProgram); gl.bindBuffer(gl.ARRAY_BUFFER, vertexPositionBuffer); gl.vertexAttribPointer(shaderProgram.vertexPositionAttribute, vertexPositionBuffer.itemSize, gl.FLOAT, false, 0, 0); gl.bufferSubData(gl.ARRAY_BUFFER, 0, StageGL.COVER_VERT); gl.bindBuffer(gl.ARRAY_BUFFER, uvPositionBuffer); gl.vertexAttribPointer(shaderProgram.uvPositionAttribute, uvPositionBuffer.itemSize, gl.FLOAT, false, 0, 0); gl.bufferSubData(gl.ARRAY_BUFFER, 0, StageGL.COVER_UV); gl.uniform1i(shaderProgram.samplerUniform, 0); gl.drawArrays(gl.TRIANGLES, 0, StageGL.INDICIES_PER_CARD); this._batchID++; // while this isn't a batch, this fixes issues with expected textures in expected places }; createjs.StageGL = createjs.promote(StageGL, "Stage"); }()); //############################################################################## // Bitmap.js //############################################################################## this.createjs = this.createjs||{}; (function() { /** * A Bitmap represents an Image, Canvas, or Video in the display list. A Bitmap can be instantiated using an existing * HTML element, or a string. * *

Example

* * var bitmap = new createjs.Bitmap("imagePath.jpg"); * * Notes: *
    *
  1. When using a video source that may loop or seek, use a {{#crossLink "VideoBuffer"}}{{/crossLink}} object to * prevent blinking / flashing. *
  2. When a string path or image tag that is not yet loaded is used, the stage may need to be redrawn before it * will be displayed.
  3. *
  4. Bitmaps with an SVG source currently will not respect an alpha value other than 0 or 1. To get around this, * the Bitmap can be cached.
  5. *
  6. Bitmaps with an SVG source will taint the canvas with cross-origin data, which prevents interactivity. This * happens in all browsers except recent Firefox builds.
  7. *
  8. Images loaded cross-origin will throw cross-origin security errors when interacted with using a mouse, using * methods such as `getObjectUnderPoint`, or using filters, or caching. You can get around this by setting * `crossOrigin` flags on your images before passing them to EaselJS, eg: `img.crossOrigin="Anonymous";`
  9. *
* * @class Bitmap * @extends DisplayObject * @constructor * @param {CanvasImageSource | String | Object} imageOrUri The source image to display. This can be a CanvasImageSource * (image, video, canvas), an object with a `getImage` method that returns a CanvasImageSource, or a string URL to an image. * If the latter, a new Image instance with the URL as its src will be used. **/ function Bitmap(imageOrUri) { this.DisplayObject_constructor(); // public properties: /** * The source image to display. This can be a CanvasImageSource * (image, video, canvas), an object with a `getImage` method that returns a CanvasImageSource, or a string URL to an image. * If the latter, a new Image instance with the URL as its src will be used. * @property image * @type CanvasImageSource | Object **/ if (typeof imageOrUri == "string") { this.image = document.createElement("img"); this.image.src = imageOrUri; } else { this.image = imageOrUri; } /** * Specifies an area of the source image to draw. If omitted, the whole image will be drawn. * Notes: *
    *
  • that video sources must have a width / height set to work correctly with `sourceRect`
  • *
  • Cached objects will ignore the `sourceRect` property
  • *
* @property sourceRect * @type Rectangle * @default null */ this.sourceRect = null; // private properties: // Docced in superclass this._webGLRenderStyle = createjs.DisplayObject._StageGL_BITMAP; } var p = createjs.extend(Bitmap, createjs.DisplayObject); // public methods: /** * Constructor alias for backwards compatibility. This method will be removed in future versions. * Subclasses should be updated to use {{#crossLink "Utility Methods/extends"}}{{/crossLink}}. * @method initialize * @deprecated in favour of `createjs.promote()` **/ p.initialize = Bitmap; // TODO: deprecated. /** * Returns true or false indicating whether the display object would be visible if drawn to a canvas. * This does not account for whether it would be visible within the boundaries of the stage. * * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method isVisible * @return {Boolean} Boolean indicating whether the display object would be visible if drawn to a canvas **/ p.isVisible = function() { var image = this.image; var hasContent = this.cacheCanvas || (image && (image.naturalWidth || image.getContext || image.readyState >= 2)); return !!(this.visible && this.alpha > 0 && this.scaleX != 0 && this.scaleY != 0 && hasContent); }; /** * Draws the display object into the specified context ignoring its visible, alpha, shadow, and transform. * Returns true if the draw was handled (useful for overriding functionality). * * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method draw * @param {CanvasRenderingContext2D} ctx The canvas 2D context object to draw into. * @param {Boolean} [ignoreCache=false] Indicates whether the draw operation should ignore any current cache. * For example, used for drawing the cache (to prevent it from simply drawing an existing cache back * into itself). * @return {Boolean} **/ p.draw = function(ctx, ignoreCache) { if (this.DisplayObject_draw(ctx, ignoreCache)) { return true; } var img = this.image, rect = this.sourceRect; if (img.getImage) { img = img.getImage(); } if (!img) { return true; } if (rect) { // some browsers choke on out of bound values, so we'll fix them: var x1 = rect.x, y1 = rect.y, x2 = x1 + rect.width, y2 = y1 + rect.height, x = 0, y = 0, w = img.width, h = img.height; if (x1 < 0) { x -= x1; x1 = 0; } if (x2 > w) { x2 = w; } if (y1 < 0) { y -= y1; y1 = 0; } if (y2 > h) { y2 = h; } ctx.drawImage(img, x1, y1, x2-x1, y2-y1, x, y, x2-x1, y2-y1); } else { ctx.drawImage(img, 0, 0); } return true; }; //Note, the doc sections below document using the specified APIs (from DisplayObject) from //Bitmap. This is why they have no method implementations. /** * Because the content of a Bitmap is already in a simple format, cache is unnecessary for Bitmap instances. * You should not cache Bitmap instances as it can degrade performance. * * However: If you want to use a filter on a Bitmap, you MUST cache it, or it will not work. * To see the API for caching, please visit the DisplayObject {{#crossLink "DisplayObject/cache"}}{{/crossLink}} * method. * @method cache **/ /** * Because the content of a Bitmap is already in a simple format, cache is unnecessary for Bitmap instances. * You should not cache Bitmap instances as it can degrade performance. * * However: If you want to use a filter on a Bitmap, you MUST cache it, or it will not work. * To see the API for caching, please visit the DisplayObject {{#crossLink "DisplayObject/cache"}}{{/crossLink}} * method. * @method updateCache **/ /** * Because the content of a Bitmap is already in a simple format, cache is unnecessary for Bitmap instances. * You should not cache Bitmap instances as it can degrade performance. * * However: If you want to use a filter on a Bitmap, you MUST cache it, or it will not work. * To see the API for caching, please visit the DisplayObject {{#crossLink "DisplayObject/cache"}}{{/crossLink}} * method. * @method uncache **/ // Docced in superclass p.getBounds = function() { var rect = this.DisplayObject_getBounds(); if (rect) { return rect; } var image = this.image, o = this.sourceRect || image; var hasContent = (image && (image.naturalWidth || image.getContext || image.readyState >= 2)); return hasContent ? this._rectangle.setValues(0, 0, o.width, o.height) : null; }; /** * Returns a clone of the Bitmap instance. * @method clone * @param {Boolean} node Whether the underlying dom element should be cloned as well. * @return {Bitmap} a clone of the Bitmap instance. **/ p.clone = function(node) { var image = this.image; if(image && node){ image = image.cloneNode(); image.src = image.src; // IE cloneNode bug fix } var o = new Bitmap(image); if (this.sourceRect) { o.sourceRect = this.sourceRect.clone(); } this._cloneProps(o); return o; }; /** * Returns a string representation of this object. * @method toString * @return {String} a string representation of the instance. **/ p.toString = function() { return "[Bitmap (name="+ this.name +")]"; }; createjs.Bitmap = createjs.promote(Bitmap, "DisplayObject"); }()); //############################################################################## // Sprite.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * Displays a frame or sequence of frames (ie. an animation) from a SpriteSheet instance. A sprite sheet is a series of * images (usually animation frames) combined into a single image. For example, an animation consisting of 8 100x100 * images could be combined into a 400x200 sprite sheet (4 frames across by 2 high). You can display individual frames, * play frames as an animation, and even sequence animations together. * * See the {{#crossLink "SpriteSheet"}}{{/crossLink}} class for more information on setting up frames and animations. * *

Example

* * var instance = new createjs.Sprite(spriteSheet); * instance.gotoAndStop("frameName"); * * Until {{#crossLink "Sprite/gotoAndStop"}}{{/crossLink}} or {{#crossLink "Sprite/gotoAndPlay"}}{{/crossLink}} is called, * only the first defined frame defined in the sprite sheet will be displayed. * * @class Sprite * @extends DisplayObject * @constructor * @param {SpriteSheet} spriteSheet The SpriteSheet instance to play back. This includes the source image(s), frame * dimensions, and frame data. See {{#crossLink "SpriteSheet"}}{{/crossLink}} for more information. * @param {String|Number} [frameOrAnimation] The frame number or animation to play initially. **/ function Sprite(spriteSheet, frameOrAnimation) { this.DisplayObject_constructor(); // public properties: /** * The frame index that will be drawn when draw is called. Note that with some {{#crossLink "SpriteSheet"}}{{/crossLink}} * definitions, this will advance non-sequentially. This will always be an integer value. * @property currentFrame * @type {Number} * @default 0 * @readonly **/ this.currentFrame = 0; /** * Returns the name of the currently playing animation. * @property currentAnimation * @type {String} * @final * @readonly **/ this.currentAnimation = null; /** * Prevents the animation from advancing each tick automatically. For example, you could create a sprite * sheet of icons, set paused to true, and display the appropriate icon by setting currentFrame. * @property paused * @type {Boolean} * @default false **/ this.paused = true; /** * The SpriteSheet instance to play back. This includes the source image, frame dimensions, and frame * data. See {{#crossLink "SpriteSheet"}}{{/crossLink}} for more information. * @property spriteSheet * @type {SpriteSheet} * @readonly **/ this.spriteSheet = spriteSheet; /** * Specifies the current frame index within the currently playing animation. When playing normally, this will increase * from 0 to n-1, where n is the number of frames in the current animation. * * This could be a non-integer value if * using time-based playback (see {{#crossLink "Sprite/framerate"}}{{/crossLink}}, or if the animation's speed is * not an integer. * @property currentAnimationFrame * @type {Number} * @default 0 **/ this.currentAnimationFrame = 0; /** * By default Sprite instances advance one frame per tick. Specifying a framerate for the Sprite (or its related * SpriteSheet) will cause it to advance based on elapsed time between ticks as appropriate to maintain the target * framerate. * * For example, if a Sprite with a framerate of 10 is placed on a Stage being updated at 40fps, then the Sprite will * advance roughly one frame every 4 ticks. This will not be exact, because the time between each tick will * vary slightly between frames. * * This feature is dependent on the tick event object (or an object with an appropriate "delta" property) being * passed into {{#crossLink "Stage/update"}}{{/crossLink}}. * @property framerate * @type {Number} * @default 0 **/ this.framerate = 0; // private properties: /** * Current animation object. * @property _animation * @protected * @type {Object} * @default null **/ this._animation = null; /** * Current frame index. * @property _currentFrame * @protected * @type {Number} * @default null **/ this._currentFrame = null; /** * Skips the next auto advance. Used by gotoAndPlay to avoid immediately jumping to the next frame * @property _skipAdvance * @protected * @type {Boolean} * @default false **/ this._skipAdvance = false; // Docced in superclass this._webGLRenderStyle = createjs.DisplayObject._StageGL_SPRITE; if (frameOrAnimation != null) { this.gotoAndPlay(frameOrAnimation); } } var p = createjs.extend(Sprite, createjs.DisplayObject); /** * Constructor alias for backwards compatibility. This method will be removed in future versions. * Subclasses should be updated to use {{#crossLink "Utility Methods/extends"}}{{/crossLink}}. * @method initialize * @deprecated in favour of `createjs.promote()` **/ p.initialize = Sprite; // TODO: Deprecated. This is for backwards support of Flash/Animate spritesheet export. // events: /** * Dispatched when an animation reaches its ends. * @event animationend * @param {Object} target The object that dispatched the event. * @param {String} type The event type. * @param {String} name The name of the animation that just ended. * @param {String} next The name of the next animation that will be played, or null. This will be the same as name if the animation is looping. * @since 0.6.0 */ /** * Dispatched any time the current frame changes. For example, this could be due to automatic advancement on a tick, * or calling gotoAndPlay() or gotoAndStop(). * @event change * @param {Object} target The object that dispatched the event. * @param {String} type The event type. */ // public methods: /** * Returns true or false indicating whether the display object would be visible if drawn to a canvas. * This does not account for whether it would be visible within the boundaries of the stage. * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method isVisible * @return {Boolean} Boolean indicating whether the display object would be visible if drawn to a canvas **/ p.isVisible = function() { var hasContent = this.cacheCanvas || this.spriteSheet.complete; return !!(this.visible && this.alpha > 0 && this.scaleX != 0 && this.scaleY != 0 && hasContent); }; /** * Draws the display object into the specified context ignoring its visible, alpha, shadow, and transform. * Returns true if the draw was handled (useful for overriding functionality). * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method draw * @param {CanvasRenderingContext2D} ctx The canvas 2D context object to draw into. * @param {Boolean} ignoreCache Indicates whether the draw operation should ignore any current cache. * For example, used for drawing the cache (to prevent it from simply drawing an existing cache back * into itself). **/ p.draw = function(ctx, ignoreCache) { if (this.DisplayObject_draw(ctx, ignoreCache)) { return true; } this._normalizeFrame(); var o = this.spriteSheet.getFrame(this._currentFrame|0); if (!o) { return false; } var rect = o.rect; if (rect.width && rect.height) { ctx.drawImage(o.image, rect.x, rect.y, rect.width, rect.height, -o.regX, -o.regY, rect.width, rect.height); } return true; }; //Note, the doc sections below document using the specified APIs (from DisplayObject) from //Bitmap. This is why they have no method implementations. /** * Because the content of a Sprite is already in a raster format, cache is unnecessary for Sprite instances. * You should not cache Sprite instances as it can degrade performance. * @method cache **/ /** * Because the content of a Sprite is already in a raster format, cache is unnecessary for Sprite instances. * You should not cache Sprite instances as it can degrade performance. * @method updateCache **/ /** * Because the content of a Sprite is already in a raster format, cache is unnecessary for Sprite instances. * You should not cache Sprite instances as it can degrade performance. * @method uncache **/ /** * Play (unpause) the current animation. The Sprite will be paused if either {{#crossLink "Sprite/stop"}}{{/crossLink}} * or {{#crossLink "Sprite/gotoAndStop"}}{{/crossLink}} is called. Single frame animations will remain * unchanged. * @method play **/ p.play = function() { this.paused = false; }; /** * Stop playing a running animation. The Sprite will be playing if {{#crossLink "Sprite/gotoAndPlay"}}{{/crossLink}} * is called. Note that calling {{#crossLink "Sprite/gotoAndPlay"}}{{/crossLink}} or {{#crossLink "Sprite/play"}}{{/crossLink}} * will resume playback. * @method stop **/ p.stop = function() { this.paused = true; }; /** * Sets paused to false and plays the specified animation name, named frame, or frame number. * @method gotoAndPlay * @param {String|Number} frameOrAnimation The frame number or animation name that the playhead should move to * and begin playing. **/ p.gotoAndPlay = function(frameOrAnimation) { this.paused = false; this._skipAdvance = true; this._goto(frameOrAnimation); }; /** * Sets paused to true and seeks to the specified animation name, named frame, or frame number. * @method gotoAndStop * @param {String|Number} frameOrAnimation The frame number or animation name that the playhead should move to * and stop. **/ p.gotoAndStop = function(frameOrAnimation) { this.paused = true; this._goto(frameOrAnimation); }; /** * Advances the playhead. This occurs automatically each tick by default. * @param [time] {Number} The amount of time in ms to advance by. Only applicable if framerate is set on the Sprite * or its SpriteSheet. * @method advance */ p.advance = function(time) { var fps = this.framerate || this.spriteSheet.framerate; var t = (fps && time != null) ? time/(1000/fps) : 1; this._normalizeFrame(t); }; /** * Returns a {{#crossLink "Rectangle"}}{{/crossLink}} instance defining the bounds of the current frame relative to * the origin. For example, a 90 x 70 frame with regX=50 and regY=40 would return a * rectangle with [x=-50, y=-40, width=90, height=70]. This ignores transformations on the display object. * * Also see the SpriteSheet {{#crossLink "SpriteSheet/getFrameBounds"}}{{/crossLink}} method. * @method getBounds * @return {Rectangle} A Rectangle instance. Returns null if the frame does not exist, or the image is not fully * loaded. **/ p.getBounds = function() { // TODO: should this normalizeFrame? return this.DisplayObject_getBounds() || this.spriteSheet.getFrameBounds(this.currentFrame, this._rectangle); }; /** * Returns a clone of the Sprite instance. Note that the same SpriteSheet is shared between cloned * instances. * @method clone * @return {Sprite} a clone of the Sprite instance. **/ p.clone = function() { return this._cloneProps(new Sprite(this.spriteSheet)); }; /** * Returns a string representation of this object. * @method toString * @return {String} a string representation of the instance. **/ p.toString = function() { return "[Sprite (name="+ this.name +")]"; }; // private methods: /** * @method _cloneProps * @param {Sprite} o * @return {Sprite} o * @protected **/ p._cloneProps = function(o) { this.DisplayObject__cloneProps(o); o.currentFrame = this.currentFrame; o.currentAnimation = this.currentAnimation; o.paused = this.paused; o.currentAnimationFrame = this.currentAnimationFrame; o.framerate = this.framerate; o._animation = this._animation; o._currentFrame = this._currentFrame; o._skipAdvance = this._skipAdvance; return o; }; /** * Advances the currentFrame if paused is not true. This is called automatically when the {{#crossLink "Stage"}}{{/crossLink}} * ticks. * @param {Object} evtObj An event object that will be dispatched to all tick listeners. This object is reused between dispatchers to reduce construction & GC costs. * @protected * @method _tick **/ p._tick = function(evtObj) { if (!this.paused) { if (!this._skipAdvance) { this.advance(evtObj&&evtObj.delta); } this._skipAdvance = false; } this.DisplayObject__tick(evtObj); }; /** * Normalizes the current frame, advancing animations and dispatching callbacks as appropriate. * @protected * @method _normalizeFrame **/ p._normalizeFrame = function(frameDelta) { frameDelta = frameDelta || 0; var animation = this._animation; var paused = this.paused; var frame = this._currentFrame; var l; if (animation) { var speed = animation.speed || 1; var animFrame = this.currentAnimationFrame; l = animation.frames.length; if (animFrame + frameDelta * speed >= l) { var next = animation.next; if (this._dispatchAnimationEnd(animation, frame, paused, next, l - 1)) { // something changed in the event stack, so we shouldn't make any more changes here. return; } else if (next) { // sequence. Automatically calls _normalizeFrame again with the remaining frames. return this._goto(next, frameDelta - (l - animFrame) / speed); } else { // end. this.paused = true; animFrame = animation.frames.length - 1; } } else { animFrame += frameDelta * speed; } this.currentAnimationFrame = animFrame; this._currentFrame = animation.frames[animFrame | 0] } else { frame = (this._currentFrame += frameDelta); l = this.spriteSheet.getNumFrames(); if (frame >= l && l > 0) { if (!this._dispatchAnimationEnd(animation, frame, paused, l - 1)) { // looped. if ((this._currentFrame -= l) >= l) { return this._normalizeFrame(); } } } } frame = this._currentFrame | 0; if (this.currentFrame != frame) { this.currentFrame = frame; this.dispatchEvent("change"); } }; /** * Dispatches the "animationend" event. Returns true if a handler changed the animation (ex. calling {{#crossLink "Sprite/stop"}}{{/crossLink}}, * {{#crossLink "Sprite/gotoAndPlay"}}{{/crossLink}}, etc.) * @property _dispatchAnimationEnd * @private * @type {Function} **/ p._dispatchAnimationEnd = function(animation, frame, paused, next, end) { var name = animation ? animation.name : null; if (this.hasEventListener("animationend")) { var evt = new createjs.Event("animationend"); evt.name = name; evt.next = next; this.dispatchEvent(evt); } // did the animation get changed in the event stack?: var changed = (this._animation != animation || this._currentFrame != frame); // if the animation hasn't changed, but the sprite was paused, then we want to stick to the last frame: if (!changed && !paused && this.paused) { this.currentAnimationFrame = end; changed = true; } return changed; }; /** * Moves the playhead to the specified frame number or animation. * @method _goto * @param {String|Number} frameOrAnimation The frame number or animation that the playhead should move to. * @param {Boolean} [frame] The frame of the animation to go to. Defaults to 0. * @protected **/ p._goto = function(frameOrAnimation, frame) { this.currentAnimationFrame = 0; if (isNaN(frameOrAnimation)) { var data = this.spriteSheet.getAnimation(frameOrAnimation); if (data) { this._animation = data; this.currentAnimation = frameOrAnimation; this._normalizeFrame(frame); } } else { this.currentAnimation = this._animation = null; this._currentFrame = frameOrAnimation; this._normalizeFrame(); } }; createjs.Sprite = createjs.promote(Sprite, "DisplayObject"); }()); //############################################################################## // Shape.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * A Shape allows you to display vector art in the display list. It composites a {{#crossLink "Graphics"}}{{/crossLink}} * instance which exposes all of the vector drawing methods. The Graphics instance can be shared between multiple Shape * instances to display the same vector graphics with different positions or transforms. * * If the vector art will not * change between draws, you may want to use the {{#crossLink "DisplayObject/cache"}}{{/crossLink}} method to reduce the * rendering cost. * *

Example

* * var graphics = new createjs.Graphics().beginFill("#ff0000").drawRect(0, 0, 100, 100); * var shape = new createjs.Shape(graphics); * * //Alternatively use can also use the graphics property of the Shape class to renderer the same as above. * var shape = new createjs.Shape(); * shape.graphics.beginFill("#ff0000").drawRect(0, 0, 100, 100); * * @class Shape * @extends DisplayObject * @constructor * @param {Graphics} graphics Optional. The graphics instance to display. If null, a new Graphics instance will be created. **/ function Shape(graphics) { this.DisplayObject_constructor(); // public properties: /** * The graphics instance to display. * @property graphics * @type Graphics **/ this.graphics = graphics ? graphics : new createjs.Graphics(); } var p = createjs.extend(Shape, createjs.DisplayObject); // TODO: deprecated // p.initialize = function() {}; // searchable for devs wondering where it is. REMOVED. See docs for details. // public methods: /** * Returns true or false indicating whether the Shape would be visible if drawn to a canvas. * This does not account for whether it would be visible within the boundaries of the stage. * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method isVisible * @return {Boolean} Boolean indicating whether the Shape would be visible if drawn to a canvas **/ p.isVisible = function() { var hasContent = this.cacheCanvas || (this.graphics && !this.graphics.isEmpty()); return !!(this.visible && this.alpha > 0 && this.scaleX != 0 && this.scaleY != 0 && hasContent); }; /** * Draws the Shape into the specified context ignoring its visible, alpha, shadow, and transform. Returns true if * the draw was handled (useful for overriding functionality). * * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method draw * @param {CanvasRenderingContext2D} ctx The canvas 2D context object to draw into. * @param {Boolean} [ignoreCache=false] Indicates whether the draw operation should ignore any current cache. For example, * used for drawing the cache (to prevent it from simply drawing an existing cache back into itself). * @return {Boolean} **/ p.draw = function(ctx, ignoreCache) { if (this.DisplayObject_draw(ctx, ignoreCache)) { return true; } this.graphics.draw(ctx, this); return true; }; /** * Returns a clone of this Shape. Some properties that are specific to this instance's current context are reverted to * their defaults (for example .parent). * @method clone * @param {Boolean} recursive If true, this Shape's {{#crossLink "Graphics"}}{{/crossLink}} instance will also be * cloned. If false, the Graphics instance will be shared with the new Shape. **/ p.clone = function(recursive) { var g = (recursive && this.graphics) ? this.graphics.clone() : this.graphics; return this._cloneProps(new Shape(g)); }; /** * Returns a string representation of this object. * @method toString * @return {String} a string representation of the instance. **/ p.toString = function() { return "[Shape (name="+ this.name +")]"; }; createjs.Shape = createjs.promote(Shape, "DisplayObject"); }()); //############################################################################## // Text.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * Display one or more lines of dynamic text (not user editable) in the display list. Line wrapping support (using the * lineWidth) is very basic, wrapping on spaces and tabs only. Note that as an alternative to Text, you can position HTML * text above or below the canvas relative to items in the display list using the {{#crossLink "DisplayObject/localToGlobal"}}{{/crossLink}} * method, or using {{#crossLink "DOMElement"}}{{/crossLink}}. * * Please note that Text does not support HTML text, and can only display one font style at a time. To use * multiple font styles, you will need to create multiple text instances, and position them manually. * *

Example

* * var text = new createjs.Text("Hello World", "20px Arial", "#ff7700"); * text.x = 100; * text.textBaseline = "alphabetic"; * * CreateJS Text supports web fonts (the same rules as Canvas). The font must be loaded and supported by the browser * before it can be displayed. * * Note: Text can be expensive to generate, so cache instances where possible. Be aware that not all * browsers will render Text exactly the same. * @class Text * @extends DisplayObject * @constructor * @param {String} [text] The text to display. * @param {String} [font] The font style to use. Any valid value for the CSS font attribute is acceptable (ex. "bold * 36px Arial"). * @param {String} [color] The color to draw the text in. Any valid value for the CSS color attribute is acceptable (ex. * "#F00", "red", or "#FF0000"). **/ function Text(text, font, color) { this.DisplayObject_constructor(); // public properties: /** * The text to display. * @property text * @type String **/ this.text = text; /** * The font style to use. Any valid value for the CSS font attribute is acceptable (ex. "bold 36px Arial"). * @property font * @type String **/ this.font = font; /** * The color to draw the text in. Any valid value for the CSS color attribute is acceptable (ex. "#F00"). Default is "#000". * It will also accept valid canvas fillStyle values. * @property color * @type String **/ this.color = color; /** * The horizontal text alignment. Any of "start", "end", "left", "right", and "center". For detailed * information view the * * whatwg spec. Default is "left". * @property textAlign * @type String **/ this.textAlign = "left"; /** * The vertical alignment point on the font. Any of "top", "hanging", "middle", "alphabetic", "ideographic", or * "bottom". For detailed information view the * whatwg spec. Default is "top". * @property textBaseline * @type String */ this.textBaseline = "top"; /** * The maximum width to draw the text. If maxWidth is specified (not null), the text will be condensed or * shrunk to make it fit in this width. For detailed information view the * * whatwg spec. * @property maxWidth * @type Number */ this.maxWidth = null; /** * If greater than 0, the text will be drawn as a stroke (outline) of the specified width. * @property outline * @type Number **/ this.outline = 0; /** * Indicates the line height (vertical distance between baselines) for multi-line text. If null or 0, * the value of getMeasuredLineHeight is used. * @property lineHeight * @type Number **/ this.lineHeight = 0; /** * Indicates the maximum width for a line of text before it is wrapped to multiple lines. If null, * the text will not be wrapped. * @property lineWidth * @type Number **/ this.lineWidth = null; } var p = createjs.extend(Text, createjs.DisplayObject); // TODO: deprecated // p.initialize = function() {}; // searchable for devs wondering where it is. REMOVED. See docs for details. // static properties: /** * @property _workingContext * @type CanvasRenderingContext2D * @private **/ var canvas = (createjs.createCanvas?createjs.createCanvas():document.createElement("canvas")); if (canvas.getContext) { Text._workingContext = canvas.getContext("2d"); canvas.width = canvas.height = 1; } // constants: /** * Lookup table for the ratio to offset bounds x calculations based on the textAlign property. * @property H_OFFSETS * @type Object * @protected * @static **/ Text.H_OFFSETS = {start: 0, left: 0, center: -0.5, end: -1, right: -1}; /** * Lookup table for the ratio to offset bounds y calculations based on the textBaseline property. * @property H_OFFSETS * @type Object * @protected * @static **/ Text.V_OFFSETS = {top: 0, hanging: -0.01, middle: -0.4, alphabetic: -0.8, ideographic: -0.85, bottom: -1}; // public methods: /** * Returns true or false indicating whether the display object would be visible if drawn to a canvas. * This does not account for whether it would be visible within the boundaries of the stage. * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method isVisible * @return {Boolean} Whether the display object would be visible if drawn to a canvas **/ p.isVisible = function() { var hasContent = this.cacheCanvas || (this.text != null && this.text !== ""); return !!(this.visible && this.alpha > 0 && this.scaleX != 0 && this.scaleY != 0 && hasContent); }; /** * Draws the Text into the specified context ignoring its visible, alpha, shadow, and transform. * Returns true if the draw was handled (useful for overriding functionality). * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method draw * @param {CanvasRenderingContext2D} ctx The canvas 2D context object to draw into. * @param {Boolean} ignoreCache Indicates whether the draw operation should ignore any current cache. * For example, used for drawing the cache (to prevent it from simply drawing an existing cache back * into itself). **/ p.draw = function(ctx, ignoreCache) { if (this.DisplayObject_draw(ctx, ignoreCache)) { return true; } var col = this.color || "#000"; if (this.outline) { ctx.strokeStyle = col; ctx.lineWidth = this.outline*1; } else { ctx.fillStyle = col; } this._drawText(this._prepContext(ctx)); return true; }; /** * Returns the measured, untransformed width of the text without wrapping. Use getBounds for a more robust value. * @method getMeasuredWidth * @return {Number} The measured, untransformed width of the text. **/ p.getMeasuredWidth = function() { return this._getMeasuredWidth(this.text); }; /** * Returns an approximate line height of the text, ignoring the lineHeight property. This is based on the measured * width of a "M" character multiplied by 1.2, which provides an approximate line height for most fonts. * @method getMeasuredLineHeight * @return {Number} an approximate line height of the text, ignoring the lineHeight property. This is * based on the measured width of a "M" character multiplied by 1.2, which approximates em for most fonts. **/ p.getMeasuredLineHeight = function() { return this._getMeasuredWidth("M")*1.2; }; /** * Returns the approximate height of multi-line text by multiplying the number of lines against either the * lineHeight (if specified) or {{#crossLink "Text/getMeasuredLineHeight"}}{{/crossLink}}. Note that * this operation requires the text flowing logic to run, which has an associated CPU cost. * @method getMeasuredHeight * @return {Number} The approximate height of the untransformed multi-line text. **/ p.getMeasuredHeight = function() { return this._drawText(null,{}).height; }; // Docced in superclass p.getBounds = function() { var rect = this.DisplayObject_getBounds(); if (rect) { return rect; } if (this.text == null || this.text === "") { return null; } var o = this._drawText(null, {}); var w = (this.maxWidth && this.maxWidth < o.width) ? this.maxWidth : o.width; var x = w * Text.H_OFFSETS[this.textAlign||"left"]; var lineHeight = this.lineHeight||this.getMeasuredLineHeight(); var y = lineHeight * Text.V_OFFSETS[this.textBaseline||"top"]; return this._rectangle.setValues(x, y, w, o.height); }; /** * Returns an object with width, height, and lines properties. The width and height are the visual width and height * of the drawn text. The lines property contains an array of strings, one for * each line of text that will be drawn, accounting for line breaks and wrapping. These strings have trailing * whitespace removed. * @method getMetrics * @return {Object} An object with width, height, and lines properties. **/ p.getMetrics = function() { var o = {lines:[]}; o.lineHeight = this.lineHeight || this.getMeasuredLineHeight(); o.vOffset = o.lineHeight * Text.V_OFFSETS[this.textBaseline||"top"]; return this._drawText(null, o, o.lines); }; /** * Returns a clone of the Text instance. * @method clone * @return {Text} a clone of the Text instance. **/ p.clone = function() { return this._cloneProps(new Text(this.text, this.font, this.color)); }; /** * Returns a string representation of this object. * @method toString * @return {String} a string representation of the instance. **/ p.toString = function() { return "[Text (text="+ (this.text.length > 20 ? this.text.substr(0, 17)+"..." : this.text) +")]"; }; // private methods: /** * @method _cloneProps * @param {Text} o * @protected * @return {Text} o **/ p._cloneProps = function(o) { this.DisplayObject__cloneProps(o); o.textAlign = this.textAlign; o.textBaseline = this.textBaseline; o.maxWidth = this.maxWidth; o.outline = this.outline; o.lineHeight = this.lineHeight; o.lineWidth = this.lineWidth; return o; }; /** * @method _getWorkingContext * @param {CanvasRenderingContext2D} ctx * @return {CanvasRenderingContext2D} * @protected **/ p._prepContext = function(ctx) { ctx.font = this.font||"10px sans-serif"; ctx.textAlign = this.textAlign||"left"; ctx.textBaseline = this.textBaseline||"top"; ctx.lineJoin = "miter"; ctx.miterLimit = 2.5; return ctx; }; /** * Draws multiline text. * @method _drawText * @param {CanvasRenderingContext2D} ctx * @param {Object} o * @param {Array} lines * @return {Object} * @protected **/ p._drawText = function(ctx, o, lines) { var paint = !!ctx; if (!paint) { ctx = Text._workingContext; ctx.save(); this._prepContext(ctx); } var lineHeight = this.lineHeight||this.getMeasuredLineHeight(); var maxW = 0, count = 0; var hardLines = String(this.text).split(/(?:\r\n|\r|\n)/); for (var i=0, l=hardLines.length; i this.lineWidth) { // text wrapping: var words = str.split(/(\s)/); str = words[0]; w = ctx.measureText(str).width; for (var j=1, jl=words.length; j this.lineWidth) { if (paint) { this._drawTextLine(ctx, str, count*lineHeight); } if (lines) { lines.push(str); } if (w > maxW) { maxW = w; } str = words[j+1]; w = ctx.measureText(str).width; count++; } else { str += words[j] + words[j+1]; w += wordW; } } } if (paint) { this._drawTextLine(ctx, str, count*lineHeight); } if (lines) { lines.push(str); } if (o && w == null) { w = ctx.measureText(str).width; } if (w > maxW) { maxW = w; } count++; } if (o) { o.width = maxW; o.height = count*lineHeight; } if (!paint) { ctx.restore(); } return o; }; /** * @method _drawTextLine * @param {CanvasRenderingContext2D} ctx * @param {String} text * @param {Number} y * @protected **/ p._drawTextLine = function(ctx, text, y) { // Chrome 17 will fail to draw the text if the last param is included but null, so we feed it a large value instead: if (this.outline) { ctx.strokeText(text, 0, y, this.maxWidth||0xFFFF); } else { ctx.fillText(text, 0, y, this.maxWidth||0xFFFF); } }; /** * @method _getMeasuredWidth * @param {String} text * @protected **/ p._getMeasuredWidth = function(text) { var ctx = Text._workingContext; ctx.save(); var w = this._prepContext(ctx).measureText(text).width; ctx.restore(); return w; }; createjs.Text = createjs.promote(Text, "DisplayObject"); }()); //############################################################################## // BitmapText.js //############################################################################## this.createjs = this.createjs || {}; (function () { "use strict"; // constructor: /** * Displays text using bitmap glyphs defined in a sprite sheet. Multi-line text is supported using new line characters, * but automatic wrapping is not supported. See the {{#crossLink "BitmapText/spriteSheet:property"}}{{/crossLink}} * property for more information on defining glyphs. * * Important: While BitmapText extends Container, it is not designed to be used as one. * As such, methods like addChild and removeChild are disabled. * * * @class BitmapText * @extends DisplayObject * @param {String} [text=""] The text to display. * @param {SpriteSheet} [spriteSheet=null] The spritesheet that defines the character glyphs. * @constructor **/ function BitmapText(text, spriteSheet) { this.Container_constructor(); // public properties: /** * The text to display. * @property text * @type String * @default "" **/ this.text = text||""; /** * A SpriteSheet instance that defines the glyphs for this bitmap text. Each glyph/character * should have a single frame animation defined in the sprite sheet named the same as * corresponding character. For example, the following animation definition: * * "A": {frames: [0]} * * would indicate that the frame at index 0 of the spritesheet should be drawn for the "A" character. The short form * is also acceptable: * * "A": 0 * * Note that if a character in the text is not found in the sprite sheet, it will also * try to use the alternate case (upper or lower). * * See SpriteSheet for more information on defining sprite sheet data. * @property spriteSheet * @type SpriteSheet * @default null **/ this.spriteSheet = spriteSheet; /** * The height of each line of text. If 0, then it will use a line height calculated * by checking for the height of the "1", "T", or "L" character (in that order). If * those characters are not defined, it will use the height of the first frame of the * sprite sheet. * @property lineHeight * @type Number * @default 0 **/ this.lineHeight = 0; /** * This spacing (in pixels) will be added after each character in the output. * @property letterSpacing * @type Number * @default 0 **/ this.letterSpacing = 0; /** * If a space character is not defined in the sprite sheet, then empty pixels equal to * spaceWidth will be inserted instead. If 0, then it will use a value calculated * by checking for the width of the "1", "l", "E", or "A" character (in that order). If * those characters are not defined, it will use the width of the first frame of the * sprite sheet. * @property spaceWidth * @type Number * @default 0 **/ this.spaceWidth = 0; // private properties: /** * @property _oldProps * @type Object * @protected **/ this._oldProps = {text:0,spriteSheet:0,lineHeight:0,letterSpacing:0,spaceWidth:0}; /** * Used to track the object which this class attached listeners to, helps optimize listener attachment. * @property _oldStage * @type Stage * @protected */ this._oldStage = null; /** * The event listener proxy triggered drawing draw for special circumstances. * @property _drawAction * @type function * @protected */ this._drawAction = null; } var p = createjs.extend(BitmapText, createjs.Container); // static properties: /** * BitmapText uses Sprite instances to draw text. To reduce the creation and destruction of instances (and thus garbage collection), it maintains * an internal object pool of sprite instances to reuse. Increasing this value can cause more sprites to be * retained, slightly increasing memory use, but reducing instantiation. * @property maxPoolSize * @type Number * @static * @default 100 **/ BitmapText.maxPoolSize = 100; /** * Sprite object pool. * @property _spritePool * @type {Array} * @static * @private */ BitmapText._spritePool = []; // public methods: // Docced in superclass p.draw = function(ctx, ignoreCache) { if (this.DisplayObject_draw(ctx, ignoreCache)) { return; } this._updateState(); this.Container_draw(ctx, ignoreCache); }; // Docced in superclass p.getBounds = function() { this._updateText(); return this.Container_getBounds(); }; /** * Returns true or false indicating whether the display object would be visible if drawn to a canvas. * This does not account for whether it would be visible within the boundaries of the stage. * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method isVisible * @return {Boolean} Boolean indicating whether the display object would be visible if drawn to a canvas **/ p.isVisible = function() { var hasContent = this.cacheCanvas || (this.spriteSheet && this.spriteSheet.complete && this.text); return !!(this.visible && this.alpha > 0 && this.scaleX !== 0 && this.scaleY !== 0 && hasContent); }; p.clone = function() { return this._cloneProps(new BitmapText(this.text, this.spriteSheet)); }; /** * Disabled in BitmapText. * @method addChild **/ /** * Disabled in BitmapText. * @method addChildAt **/ /** * Disabled in BitmapText. * @method removeChild **/ /** * Disabled in BitmapText. * @method removeChildAt **/ /** * Disabled in BitmapText. * @method removeAllChildren **/ p.addChild = p.addChildAt = p.removeChild = p.removeChildAt = p.removeAllChildren = function() {}; // private methods: // Docced in superclass p._updateState = function() { this._updateText(); }; /** * @method _cloneProps * @param {BitmapText} o * @return {BitmapText} o * @protected **/ p._cloneProps = function(o) { this.Container__cloneProps(o); o.lineHeight = this.lineHeight; o.letterSpacing = this.letterSpacing; o.spaceWidth = this.spaceWidth; return o; }; /** * @method _getFrameIndex * @param {String} character * @param {SpriteSheet} spriteSheet * @return {Number} * @protected **/ p._getFrameIndex = function(character, spriteSheet) { var c, o = spriteSheet.getAnimation(character); if (!o) { (character != (c = character.toUpperCase())) || (character != (c = character.toLowerCase())) || (c=null); if (c) { o = spriteSheet.getAnimation(c); } } return o && o.frames[0]; }; /** * @method _getFrame * @param {String} character * @param {SpriteSheet} spriteSheet * @return {Object} * @protected **/ p._getFrame = function(character, spriteSheet) { var index = this._getFrameIndex(character, spriteSheet); return index == null ? index : spriteSheet.getFrame(index); }; /** * @method _getLineHeight * @param {SpriteSheet} ss * @return {Number} * @protected **/ p._getLineHeight = function(ss) { var frame = this._getFrame("1",ss) || this._getFrame("T",ss) || this._getFrame("L",ss) || ss.getFrame(0); return frame ? frame.rect.height : 1; }; /** * @method _getSpaceWidth * @param {SpriteSheet} ss * @return {Number} * @protected **/ p._getSpaceWidth = function(ss) { var frame = this._getFrame("1",ss) || this._getFrame("l",ss) || this._getFrame("e",ss) || this._getFrame("a",ss) || ss.getFrame(0); return frame ? frame.rect.width : 1; }; /** * @method _updateText * @protected **/ p._updateText = function() { var x=0, y=0, o=this._oldProps, change=false, spaceW=this.spaceWidth, lineH=this.lineHeight, ss=this.spriteSheet; var pool=BitmapText._spritePool, kids=this.children, childIndex=0, numKids=kids.length, sprite; for (var n in o) { if (o[n] != this[n]) { o[n] = this[n]; change = true; } } if (!change) { return; } var hasSpace = !!this._getFrame(" ", ss); if (!hasSpace && !spaceW) { spaceW = this._getSpaceWidth(ss); } if (!lineH) { lineH = this._getLineHeight(ss); } for(var i=0, l=this.text.length; i childIndex) { // faster than removeChild. pool.push(sprite = kids.pop()); sprite.parent = null; numKids--; } if (pool.length > BitmapText.maxPoolSize) { pool.length = BitmapText.maxPoolSize; } }; createjs.BitmapText = createjs.promote(BitmapText, "Container"); }()); //############################################################################## // MovieClip.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * The MovieClip class associates a TweenJS Timeline with an EaselJS {{#crossLink "Container"}}{{/crossLink}}. It allows * you to create objects which encapsulate timeline animations, state changes, and synched actions. The MovieClip * class has been included in the EaselJS minified file since 0.7.0. * * Currently MovieClip only works properly if it is tick based (as opposed to time based) though some concessions have * been made to support time-based timelines in the future. * *

Example

* This example animates two shapes back and forth. The grey shape starts on the left, but we jump to a mid-point in * the animation using {{#crossLink "MovieClip/gotoAndPlay"}}{{/crossLink}}. * * var stage = new createjs.Stage("canvas"); * createjs.Ticker.addEventListener("tick", stage); * * var mc = new createjs.MovieClip({loop:-1, labels:{myLabel:20}}); * stage.addChild(mc); * * var child1 = new createjs.Shape( * new createjs.Graphics().beginFill("#999999") * .drawCircle(30,30,30)); * var child2 = new createjs.Shape( * new createjs.Graphics().beginFill("#5a9cfb") * .drawCircle(30,30,30)); * * mc.timeline.addTween( * createjs.Tween.get(child1) * .to({x:0}).to({x:60}, 50).to({x:0}, 50)); * mc.timeline.addTween( * createjs.Tween.get(child2) * .to({x:60}).to({x:0}, 50).to({x:60}, 50)); * * mc.gotoAndPlay("start"); * * It is recommended to use `tween.to()` to animate and set properties (use no duration to have it set * immediately), and the `tween.wait()`method to create delays between animations. Note that using the * `tween.set()` method to affect properties will likely not provide the desired result. * * @class MovieClip * @main MovieClip * @param {Object} [props] The configuration properties to apply to this instance (ex. `{mode:MovieClip.SYNCHED}`). * Supported props for the MovieClip are listed below. These props are set on the corresponding instance properties * except where specified.
    *
  • `mode`
  • *
  • `startPosition`
  • *
  • `frameBounds`
  • *
* * This object will also be passed into the Timeline instance associated with this MovieClip. See the documentation * for Timeline for a list of supported props (ex. `paused`, `labels`, `loop`, `reversed`, etc.) * @extends Container * @constructor **/ function MovieClip(props) { this.Container_constructor(); !MovieClip.inited&&MovieClip.init(); // static init var mode, startPosition, loop, labels; // handle old params (mode, startPosition, loop, labels): // TODO: deprecated param handling: if (props instanceof String || arguments.length > 1) { mode = props; startPosition = arguments[1]; loop = arguments[2]; labels = arguments[3]; if (loop == null) { loop = -1; } props = null; } else if (props) { mode = props.mode; startPosition = props.startPosition; loop = props.loop; labels = props.labels; } if (!props) { props = {labels:labels}; } // public properties: /** * Controls how this MovieClip advances its time. Must be one of 0 (INDEPENDENT), 1 (SINGLE_FRAME), or 2 (SYNCHED). * See each constant for a description of the behaviour. * @property mode * @type String * @default null **/ this.mode = mode||MovieClip.INDEPENDENT; /** * Specifies what the first frame to play in this movieclip, or the only frame to display if mode is SINGLE_FRAME. * @property startPosition * @type Number * @default 0 */ this.startPosition = startPosition||0; /** * Specifies how many times this MovieClip should loop. A value of -1 indicates it should loop indefinitely. A value of * 1 would cause it to loop once (ie. play a total of twice). * @property loop * @type Number * @default -1 */ this.loop = loop === true ? -1 : (loop || 0); /** * The current frame of the movieclip. * @property currentFrame * @type Number * @default 0 * @readonly */ this.currentFrame = 0; /** * If true, the MovieClip's position will not advance when ticked. * @property paused * @type Boolean * @default false */ this.paused = props.paused||false; /** * If true, actions in this MovieClip's tweens will be run when the playhead advances. * @property actionsEnabled * @type Boolean * @default true */ this.actionsEnabled = true; /** * If true, the MovieClip will automatically be reset to its first frame whenever the timeline adds * it back onto the display list. This only applies to MovieClip instances with `mode` of "INDEPENDENT". * For example, if you had a character animation with a "body" child MovieClip instance with different costumes * on each frame, you could set `body.autoReset = false`, so that you can manually change the frame it is on, * without worrying that it will be reset automatically. * @property autoReset * @type Boolean * @default true */ this.autoReset = true; /** * An array of bounds for each frame in the MovieClip. This is mainly intended for tool output. * @property frameBounds * @type Array * @default null */ this.frameBounds = this.frameBounds||props.frameBounds; // frameBounds are set on the prototype in Animate. /** * By default MovieClip instances advance one frame per tick. Specifying a framerate for the MovieClip * will cause it to advance based on elapsed time between ticks as appropriate to maintain the target * framerate. * * For example, if a MovieClip with a framerate of 10 is placed on a Stage being updated at 40fps, then the MovieClip will * advance roughly one frame every 4 ticks. This will not be exact, because the time between each tick will * vary slightly between frames. * * This feature is dependent on the tick event object (or an object with an appropriate "delta" property) being * passed into {{#crossLink "Stage/update"}}{{/crossLink}}. * @property framerate * @type {Number} * @default null **/ this.framerate = null; // set up the needed props for Timeline: props.useTicks = props.paused = true; /** * The TweenJS Timeline that is associated with this MovieClip. This is created automatically when the MovieClip * instance is initialized. Animations are created by adding TweenJS Tween * instances to the timeline. * *

Example

* * var tween = createjs.Tween.get(target).to({x:0}).to({x:100}, 30); * var mc = new createjs.MovieClip(); * mc.timeline.addTween(tween); * * Elements can be added and removed from the timeline by toggling an "_off" property * using the `tweenInstance.to()` method. Note that using `Tween.set` is not recommended to create MovieClip * animations. The following example will toggle the target off on frame 0, and then back on for frame 1. You * can use the "visible" property to achieve the same effect. * * var tween = createjs.Tween.get(target).to({_off:false}) * .wait(1).to({_off:true}) * .wait(1).to({_off:false}); * * @property timeline * @type Timeline * @default null */ this.timeline = new createjs.Timeline(props); // private properties: /** * @property _synchOffset * @type Number * @default 0 * @private */ this._synchOffset = 0; /** * @property _rawPosition * @type Number * @default -1 * @private */ this._rawPosition = -1; // TODO: evaluate using a ._reset Boolean prop instead of -1. /** * @property _bound_resolveState * @type Function * @private */ this._bound_resolveState = this._resolveState.bind(this); /** * The time remaining from the previous tick, only applicable when .framerate is set. * @property _t * @type Number * @private */ this._t = 0; /** * List of display objects that are actively being managed by the MovieClip. * @property _managed * @type Object * @private */ this._managed = {}; } var p = createjs.extend(MovieClip, createjs.Container); // constants: /** * The MovieClip will advance independently of its parent, even if its parent is paused. * This is the default mode. * @property INDEPENDENT * @static * @type String * @default "independent" * @readonly **/ MovieClip.INDEPENDENT = "independent"; /** * The MovieClip will only display a single frame (as determined by the startPosition property). * @property SINGLE_FRAME * @static * @type String * @default "single" * @readonly **/ MovieClip.SINGLE_FRAME = "single"; /** * The MovieClip will be advanced only when its parent advances and will be synched to the position of * the parent MovieClip. * @property SYNCHED * @static * @type String * @default "synched" * @readonly **/ MovieClip.SYNCHED = "synched"; // static properties: MovieClip.inited = false; // static methods: MovieClip.init = function() { if (MovieClip.inited) { return; } // plugins introduce some overhead to Tween, so we only install this if an MC is instantiated. MovieClipPlugin.install(); MovieClip.inited = true; }; // getter / setters: /** * Use the {{#crossLink "MovieClip/labels:property"}}{{/crossLink}} property instead. * @method _getLabels * @protected * @return {Array} **/ p._getLabels = function() { return this.timeline.getLabels(); }; /** * Use the {{#crossLink "MovieClip/labels:property"}}{{/crossLink}} property instead. * @method getLabels * @deprecated */ // MovieClip.getLabels is @deprecated. Remove for 1.1+ p.getLabels = createjs.deprecate(p._getLabels, "MovieClip.getLabels"); /** * Use the {{#crossLink "MovieClip/currentLabel:property"}}{{/crossLink}} property instead. * @method _getCurrentLabel * @protected * @return {String} **/ p._getCurrentLabel = function() { return this.timeline.currentLabel; }; /** * Use the {{#crossLink "MovieClip/currentLabel:property"}}{{/crossLink}} property instead. * @method getCurrentLabel * @deprecated */ // MovieClip.getCurrentLabel is @deprecated. Remove for 1.1+ p.getCurrentLabel = createjs.deprecate(p._getCurrentLabel, "MovieClip.getCurrentLabel"); /** * Use the {{#crossLink "MovieClip/duration:property"}}{{/crossLink}} property instead. * @method _getDuration * @protected * @return {Number} **/ p._getDuration = function() { return this.timeline.duration; }; /** * Use the {{#crossLink "MovieClip/duration:property"}}{{/crossLink}} property instead. * @method getDuration * @deprecated */ // MovieClip.getDuration is @deprecated. Remove for 1.1+ p.getDuration = createjs.deprecate(p._getDuration, "MovieClip.getDuration"); /** * Returns an array of objects with label and position (aka frame) properties, sorted by position. * @property labels * @type {Array} * @readonly **/ /** * Returns the name of the label on or immediately before the current frame. * @property currentLabel * @type {String} * @readonly **/ /** * Returns the duration of this MovieClip in seconds or ticks. * @property totalFrames * @type {Number} * @readonly **/ /** * Returns the duration of this MovieClip in seconds or ticks. * @property duration * @type {Number} * @readonly **/ try { Object.defineProperties(p, { labels: { get: p._getLabels }, currentLabel: { get: p._getCurrentLabel }, totalFrames: { get: p._getDuration }, duration: { get: p._getDuration } // TODO: can we just proxy .currentFrame to tl.position as well? Ditto for .loop (or just remove entirely). }); } catch (e) {} // public methods: /** * Constructor alias for backwards compatibility. This method will be removed in future versions. * Subclasses should be updated to use {{#crossLink "Utility Methods/extend"}}{{/crossLink}} and * {{#crossLink "Utility Methods/promote"}}{{/crossLink}} instead. * @method initialize * @deprecated **/ p.initialize = MovieClip; // TODO: Deprecated. This is for backwards support of Adobe Flash/Animate /** * Returns true or false indicating whether the display object would be visible if drawn to a canvas. * This does not account for whether it would be visible within the boundaries of the stage. * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method isVisible * @return {Boolean} Boolean indicating whether the display object would be visible if drawn to a canvas **/ p.isVisible = function() { // children are placed in draw, so we can't determine if we have content. return !!(this.visible && this.alpha > 0 && this.scaleX != 0 && this.scaleY != 0); }; /** * Draws the display object into the specified context ignoring its visible, alpha, shadow, and transform. * Returns true if the draw was handled (useful for overriding functionality). * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method draw * @param {CanvasRenderingContext2D} ctx The canvas 2D context object to draw into. * @param {Boolean} ignoreCache Indicates whether the draw operation should ignore any current cache. * For example, used for drawing the cache (to prevent it from simply drawing an existing cache back * into itself). **/ p.draw = function(ctx, ignoreCache) { // draw to cache first: if (this.DisplayObject_draw(ctx, ignoreCache)) { return true; } this._updateState(); this.Container_draw(ctx, ignoreCache); return true; }; /** * Sets paused to false. * @method play **/ p.play = function() { this.paused = false; }; /** * Sets paused to true. * @method stop **/ p.stop = function() { this.paused = true; }; /** * Advances this movie clip to the specified position or label and sets paused to false. * @method gotoAndPlay * @param {String|Number} positionOrLabel The animation name or frame number to go to. **/ p.gotoAndPlay = function(positionOrLabel) { this.paused = false; this._goto(positionOrLabel); }; /** * Advances this movie clip to the specified position or label and sets paused to true. * @method gotoAndStop * @param {String|Number} positionOrLabel The animation or frame name to go to. **/ p.gotoAndStop = function(positionOrLabel) { this.paused = true; this._goto(positionOrLabel); }; /** * Advances the playhead. This occurs automatically each tick by default. * @param [time] {Number} The amount of time in ms to advance by. Only applicable if framerate is set. * @method advance */ p.advance = function(time) { var independent = MovieClip.INDEPENDENT; if (this.mode !== independent) { return; } // update happens in draw for synched clips // if this MC doesn't have a framerate, hunt ancestors for one: var o=this, fps = o.framerate; while ((o = o.parent) && fps === null) { if (o.mode === independent) { fps = o._framerate; } } this._framerate = fps; if (this.paused) { return; } // calculate how many frames to advance: var t = (fps !== null && fps !== -1 && time !== null) ? time/(1000/fps) + this._t : 1; var frames = t|0; this._t = t-frames; // leftover time, save to add to next advance. while (frames--) { this._updateTimeline(this._rawPosition+1, false); } }; /** * MovieClip instances cannot be cloned. * @method clone **/ p.clone = function() { // TODO: add support for this? Need to clone the Timeline & retarget tweens - pretty complex. throw("MovieClip cannot be cloned."); }; /** * Returns a string representation of this object. * @method toString * @return {String} a string representation of the instance. **/ p.toString = function() { return "[MovieClip (name="+ this.name +")]"; }; // private methods: p._updateState = function() { if (this._rawPosition === -1 || this.mode !== MovieClip.INDEPENDENT) { this._updateTimeline(-1); } }; /** * @method _tick * @param {Object} evtObj An event object that will be dispatched to all tick listeners. This object is reused between dispatchers to reduce construction & GC costs. * function. * @protected **/ p._tick = function(evtObj) { this.advance(evtObj&&evtObj.delta); this.Container__tick(evtObj); }; /** * @method _goto * @param {String|Number} positionOrLabel The animation name or frame number to go to. * @protected **/ p._goto = function(positionOrLabel) { var pos = this.timeline.resolve(positionOrLabel); if (pos == null) { return; } this._t = 0; this._updateTimeline(pos, true); }; /** * @method _reset * @private **/ p._reset = function() { this._rawPosition = -1; this._t = this.currentFrame = 0; this.paused = false; }; /** * @method _updateTimeline * @param {Boolean} jump Indicates whether this update is due to jumping (via gotoAndXX) to a new position. * @protected **/ p._updateTimeline = function(rawPosition, jump) { var synced = this.mode !== MovieClip.INDEPENDENT, tl = this.timeline; if (synced) { rawPosition = this.startPosition + (this.mode===MovieClip.SINGLE_FRAME?0:this._synchOffset); } if (rawPosition < 0) { rawPosition = 0; } if (this._rawPosition === rawPosition && !synced) { return; } this._rawPosition = rawPosition; // update timeline position, ignoring actions if this is a graphic. tl.loop = this.loop; // TODO: should we maintain this on MovieClip, or just have it on timeline? tl.setPosition(rawPosition, synced || !this.actionsEnabled, jump, this._bound_resolveState); }; /** * Renders position 0 without running actions or updating _rawPosition. * Primarily used by Animate CC to build out the first frame in the constructor of MC symbols. * NOTE: not tested when run after the MC advances past the first frame. * @method _renderFirstFrame * @protected **/ p._renderFirstFrame = function() { var tl = this.timeline, pos = tl.rawPosition; tl.setPosition(0, true, true, this._bound_resolveState); tl.rawPosition = pos; }; /** * Runs via a callback after timeline property updates and before actions. * @method _resolveState * @protected **/ p._resolveState = function() { var tl = this.timeline; this.currentFrame = tl.position; for (var n in this._managed) { this._managed[n] = 1; } var tweens = tl.tweens; for (var i=0, l=tweens.length; i=0; i--) { var id = kids[i].id; if (this._managed[id] === 1) { this.removeChildAt(i); delete(this._managed[id]); } } }; /** * @method _setState * @param {Array} state * @param {Number} offset * @protected **/ p._setState = function(state, offset) { if (!state) { return; } for (var i=state.length-1;i>=0;i--) { var o = state[i]; var target = o.t; var props = o.p; for (var n in props) { target[n] = props[n]; } this._addManagedChild(target, offset); } }; /** * Adds a child to the timeline, and sets it up as a managed child. * @method _addManagedChild * @param {MovieClip} child The child MovieClip to manage * @param {Number} offset * @private **/ p._addManagedChild = function(child, offset) { if (child._off) { return; } this.addChildAt(child,0); if (child instanceof MovieClip) { child._synchOffset = offset; // TODO: this does not precisely match Adobe Flash/Animate, which loses track of the clip if it is renamed or removed from the timeline, which causes it to reset. // TODO: should also reset when MovieClip loops, though that will be a bit tricky to detect. if (child.mode === MovieClip.INDEPENDENT && child.autoReset && (!this._managed[child.id])) { child._reset(); } } this._managed[child.id] = 2; }; /** * @method _getBounds * @param {Matrix2D} matrix * @param {Boolean} ignoreTransform * @return {Rectangle} * @protected **/ p._getBounds = function(matrix, ignoreTransform) { var bounds = this.DisplayObject_getBounds(); if (!bounds) { if (this.frameBounds) { bounds = this._rectangle.copy(this.frameBounds[this.currentFrame]); } } if (bounds) { return this._transformBounds(bounds, matrix, ignoreTransform); } return this.Container__getBounds(matrix, ignoreTransform); }; createjs.MovieClip = createjs.promote(MovieClip, "Container"); // MovieClipPlugin for TweenJS: /** * This plugin works with TweenJS to prevent the startPosition * property from tweening. * @private * @class MovieClipPlugin * @constructor **/ function MovieClipPlugin() { throw("MovieClipPlugin cannot be instantiated.") } /** * @property priority * @type {Number} * @static * @readonly **/ MovieClipPlugin.priority = 100; // very high priority, should run first /** * @property ID * @type {String} * @static * @readonly **/ MovieClipPlugin.ID = "MovieClip"; /** * @method install * @static **/ MovieClipPlugin.install = function() { createjs.Tween._installPlugin(MovieClipPlugin); }; /** * @method init * @param {Tween} tween * @param {String} prop * @param {*} value * @static **/ MovieClipPlugin.init = function(tween, prop, value) { if (prop === "startPosition" && tween.target instanceof MovieClip) { tween._addPlugin(MovieClipPlugin); } }; /** * @method step * @param {Tween} tween * @param {TweenStep} step * @param {Object} props * @static **/ MovieClipPlugin.step = function(tween, step, props) {}; /** * @method change * @param {Tween} tween * @param {TweenStep} step * @param {*} value * @param {Number} ratio * @param {Object} end * @return {*} * @static */ MovieClipPlugin.change = function(tween, step, prop, value, ratio, end) { if (prop === "startPosition") { return (ratio === 1 ? step.props[prop] : step.prev.props[prop]); } }; }()); //############################################################################## // SpriteSheetUtils.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * The SpriteSheetUtils class is a collection of static methods for working with {{#crossLink "SpriteSheet"}}{{/crossLink}}s. * A sprite sheet is a series of images (usually animation frames) combined into a single image on a regular grid. For * example, an animation consisting of 8 100x100 images could be combined into a 400x200 sprite sheet (4 frames across * by 2 high). The SpriteSheetUtils class uses a static interface and should not be instantiated. * @class SpriteSheetUtils * @static **/ function SpriteSheetUtils() { throw "SpriteSheetUtils cannot be instantiated"; } // private static properties: /** * @property _workingCanvas * @static * @type HTMLCanvasElement | Object * @protected */ /** * @property _workingContext * @static * @type CanvasRenderingContext2D * @protected */ var canvas = (createjs.createCanvas?createjs.createCanvas():document.createElement("canvas")); if (canvas.getContext) { SpriteSheetUtils._workingCanvas = canvas; SpriteSheetUtils._workingContext = canvas.getContext("2d"); canvas.width = canvas.height = 1; } // public static methods: /** * Returns a single frame of the specified sprite sheet as a new PNG image. An example of when this may be useful is * to use a spritesheet frame as the source for a bitmap fill. * * WARNING: In almost all cases it is better to display a single frame using a {{#crossLink "Sprite"}}{{/crossLink}} * with a {{#crossLink "Sprite/gotoAndStop"}}{{/crossLink}} call than it is to slice out a frame using this * method and display it with a Bitmap instance. You can also crop an image using the {{#crossLink "Bitmap/sourceRect"}}{{/crossLink}} * property of {{#crossLink "Bitmap"}}{{/crossLink}}. * * The extractFrame method may cause cross-domain warnings since it accesses pixels directly on the canvas. * @method extractFrame * @static * @param {SpriteSheet} spriteSheet The SpriteSheet instance to extract a frame from. * @param {Number|String} frameOrAnimation The frame number or animation name to extract. If an animation * name is specified, only the first frame of the animation will be extracted. * @return {HTMLImageElement} a single frame of the specified sprite sheet as a new PNG image. */ SpriteSheetUtils.extractFrame = function(spriteSheet, frameOrAnimation) { if (isNaN(frameOrAnimation)) { frameOrAnimation = spriteSheet.getAnimation(frameOrAnimation).frames[0]; } var data = spriteSheet.getFrame(frameOrAnimation); if (!data) { return null; } var r = data.rect; var canvas = SpriteSheetUtils._workingCanvas; canvas.width = r.width; canvas.height = r.height; SpriteSheetUtils._workingContext.drawImage(data.image, r.x, r.y, r.width, r.height, 0, 0, r.width, r.height); var img = document.createElement("img"); img.src = canvas.toDataURL("image/png"); return img; }; /** * Use the {{#crossLink "DisplayObject/scaleX:property"}}{{/crossLink}} property instead. * @method addFlippedFrames * @deprecated */ // SpriteSheetUtils.addFlippedFrames is @deprecated. Remove for 1.1+ SpriteSheetUtils.addFlippedFrames = createjs.deprecate(null, "SpriteSheetUtils.addFlippedFrames"); /** * Use the {{#crossLink "AlphaMapFilter"}}{{/crossLink}} instead. * @method mergeAlpha * @deprecated */ // SpriteSheetUtils.mergeAlpha is @deprecated. Remove for 1.1+ SpriteSheetUtils.mergeAlpha = createjs.deprecate(null, "SpriteSheetUtils.mergeAlpha"); // private static methods: SpriteSheetUtils._flip = function(spriteSheet, count, h, v) { var imgs = spriteSheet._images; var canvas = SpriteSheetUtils._workingCanvas; var ctx = SpriteSheetUtils._workingContext; var il = imgs.length/count; for (var i=0;i this.maxHeight) { throw SpriteSheetBuilder.ERR_DIMENSIONS; } var y=0, x=0; var img = 0; while (frames.length) { var o = this._fillRow(frames, y, img, dataFrames, pad); if (o.w > x) { x = o.w; } y += o.h; if (!o.h || !frames.length) { var canvas = createjs.createCanvas?createjs.createCanvas():document.createElement("canvas"); canvas.width = this._getSize(x,this.maxWidth); canvas.height = this._getSize(y,this.maxHeight); this._data.images[img] = canvas; if (!o.h) { x=y=0; img++; } } } }; /** * @method _setupMovieClipFrame * @protected * @return {Number} The width & height of the row. **/ p._setupMovieClipFrame = function(source, data) { var ae = source.actionsEnabled; source.actionsEnabled = false; source.gotoAndStop(data.i); source.actionsEnabled = ae; data.f&&data.f(source, data.d, data.i); }; /** * @method _getSize * @protected * @return {Number} The width & height of the row. **/ p._getSize = function(size,max) { var pow = 4; while (Math.pow(2,++pow) < size){} return Math.min(max,Math.pow(2,pow)); }; /** * @method _fillRow * @param {Array} frames * @param {Number} y * @param {HTMLImageElement} img * @param {Object} dataFrames * @param {Number} pad * @protected * @return {Number} The width & height of the row. **/ p._fillRow = function(frames, y, img, dataFrames, pad) { var w = this.maxWidth; var maxH = this.maxHeight; y += pad; var h = maxH-y; var x = pad; var height = 0; for (var i=frames.length-1; i>=0; i--) { var frame = frames[i]; var sc = this._scale*frame.scale; var rect = frame.sourceRect; var source = frame.source; var rx = Math.floor(sc*rect.x-pad); var ry = Math.floor(sc*rect.y-pad); var rh = Math.ceil(sc*rect.height+pad*2); var rw = Math.ceil(sc*rect.width+pad*2); if (rw > w) { throw SpriteSheetBuilder.ERR_DIMENSIONS; } if (rh > h || x+rw > w) { continue; } frame.img = img; frame.rect = new createjs.Rectangle(x,y,rw,rh); height = height || rh; frames.splice(i,1); dataFrames[frame.index] = [x,y,rw,rh,img,Math.round(-rx+sc*source.regX-pad),Math.round(-ry+sc*source.regY-pad)]; x += rw; } return {w:x, h:height}; }; /** * @method _endBuild * @protected **/ p._endBuild = function() { this.spriteSheet = new createjs.SpriteSheet(this._data); this._data = null; this.progress = 1; this.dispatchEvent("complete"); }; /** * @method _run * @protected **/ p._run = function() { var ts = Math.max(0.01, Math.min(0.99, this.timeSlice||0.3))*50; var t = (new Date()).getTime()+ts; var complete = false; while (t > (new Date()).getTime()) { if (!this._drawNext()) { complete = true; break; } } if (complete) { this._endBuild(); } else { var _this = this; this._timerID = setTimeout(function() { _this._run(); }, 50-ts); } var p = this.progress = this._index/this._frames.length; if (this.hasEventListener("progress")) { var evt = new createjs.Event("progress"); evt.progress = p; this.dispatchEvent(evt); } }; /** * @method _drawNext * @protected * @return Boolean Returns false if this is the last draw. **/ p._drawNext = function() { var frame = this._frames[this._index]; var sc = frame.scale*this._scale; var rect = frame.rect; var sourceRect = frame.sourceRect; var canvas = this._data.images[frame.img]; var ctx = canvas.getContext("2d"); frame.funct&&frame.funct(frame.source, frame.data); ctx.save(); ctx.beginPath(); ctx.rect(rect.x, rect.y, rect.width, rect.height); ctx.clip(); ctx.translate(Math.ceil(rect.x-sourceRect.x*sc), Math.ceil(rect.y-sourceRect.y*sc)); ctx.scale(sc,sc); frame.source.draw(ctx); // display object will draw itself. ctx.restore(); return (++this._index) < this._frames.length; }; createjs.SpriteSheetBuilder = createjs.promote(SpriteSheetBuilder, "EventDispatcher"); }()); //############################################################################## // DOMElement.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * A DOMElement allows you to associate a HTMLElement with the display list. It will be transformed * within the DOM as though it is child of the {{#crossLink "Container"}}{{/crossLink}} it is added to. However, it is * not rendered to canvas, and as such will retain whatever z-index it has relative to the canvas (ie. it will be * drawn in front of or behind the canvas). * * The position of a DOMElement is relative to their parent node in the DOM. It is recommended that * the DOM Object be added to a div that also contains the canvas so that they share the same position * on the page. * * DOMElement is useful for positioning HTML elements over top of canvas content, and for elements * that you want to display outside the bounds of the canvas. For example, a tooltip with rich HTML * content. * *

Mouse Interaction

* * DOMElement instances are not full EaselJS display objects, and do not participate in EaselJS mouse * events or support methods like hitTest. To get mouse events from a DOMElement, you must instead add handlers to * the htmlElement (note, this does not support EventDispatcher) * * var domElement = new createjs.DOMElement(htmlElement); * domElement.htmlElement.onclick = function() { * console.log("clicked"); * } * * Important: This class needs to be notified it is about to be drawn, this will happen automatically * if you call stage.update, calling stage.draw or disabling tickEnabled will miss important steps and it will render * stale information. * * @class DOMElement * @extends DisplayObject * @constructor * @param {HTMLElement} htmlElement A reference or id for the DOM element to manage. */ function DOMElement(htmlElement) { this.DisplayObject_constructor(); if (typeof(htmlElement)=="string") { htmlElement = document.getElementById(htmlElement); } this.mouseEnabled = false; var style = htmlElement.style; style.position = "absolute"; style.transformOrigin = style.WebkitTransformOrigin = style.msTransformOrigin = style.MozTransformOrigin = style.OTransformOrigin = "0% 0%"; // public properties: /** * The DOM object to manage. * @property htmlElement * @type HTMLElement */ this.htmlElement = htmlElement; // private properties: /** * @property _oldMtx * @type Matrix2D * @protected */ this._oldProps = null; /** * Used to track the object which this class attached listeners to, helps optimize listener attachment. * @property _oldStage * @type Stage * @protected */ this._oldStage = null; /** * The event listener proxy triggered drawing draw for special circumstances. * @property _drawAction * @type function * @protected */ this._drawAction = null; } var p = createjs.extend(DOMElement, createjs.DisplayObject); // TODO: deprecated // p.initialize = function() {}; // searchable for devs wondering where it is. REMOVED. See docs for details. // public methods: /** * Returns true or false indicating whether the display object would be visible if drawn to a canvas. * This does not account for whether it would be visible within the boundaries of the stage. * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method isVisible * @return {Boolean} Boolean indicating whether the display object would be visible if drawn to a canvas */ p.isVisible = function() { return this.htmlElement != null; }; /** * Draws the display object into the specified context ignoring its visible, alpha, shadow, and transform. * Returns true if the draw was handled (useful for overriding functionality). * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. * @method draw * @param {CanvasRenderingContext2D} ctx The canvas 2D context object to draw into. * @param {Boolean} ignoreCache Indicates whether the draw operation should ignore any current cache. * For example, used for drawing the cache (to prevent it from simply drawing an existing cache back * into itself). * @return {Boolean} */ p.draw = function(ctx, ignoreCache) { // this relies on the _tick method because draw isn't called if the parent is not visible. // the actual update happens in _handleDrawEnd return true; }; /** * Not applicable to DOMElement. * @method cache */ p.cache = function() {}; /** * Not applicable to DOMElement. * @method uncache */ p.uncache = function() {}; /** * Not applicable to DOMElement. * @method updateCache */ p.updateCache = function() {}; /** * Not applicable to DOMElement. * @method hitTest */ p.hitTest = function() {}; /** * Not applicable to DOMElement. * @method localToGlobal */ p.localToGlobal = function() {}; /** * Not applicable to DOMElement. * @method globalToLocal */ p.globalToLocal = function() {}; /** * Not applicable to DOMElement. * @method localToLocal */ p.localToLocal = function() {}; /** * DOMElement cannot be cloned. Throws an error. * @method clone */ p.clone = function() { throw("DOMElement cannot be cloned.") }; /** * Returns a string representation of this object. * @method toString * @return {String} a string representation of the instance. */ p.toString = function() { return "[DOMElement (name="+ this.name +")]"; }; /** * Interaction events should be added to `htmlElement`, and not the DOMElement instance, since DOMElement instances * are not full EaselJS display objects and do not participate in EaselJS mouse events. * @event click */ /** * Interaction events should be added to `htmlElement`, and not the DOMElement instance, since DOMElement instances * are not full EaselJS display objects and do not participate in EaselJS mouse events. * @event dblClick */ /** * Interaction events should be added to `htmlElement`, and not the DOMElement instance, since DOMElement instances * are not full EaselJS display objects and do not participate in EaselJS mouse events. * @event mousedown */ /** * The HTMLElement can listen for the mouseover event, not the DOMElement instance. * Since DOMElement instances are not full EaselJS display objects and do not participate in EaselJS mouse events. * @event mouseover */ /** * Not applicable to DOMElement. * @event tick */ // private methods: /** * @method _tick * @param {Object} evtObj An event object that will be dispatched to all tick listeners. This object is reused between dispatchers to reduce construction & GC costs. * function. * @protected */ p._tick = function(evtObj) { var stage = this.stage; if(stage && stage !== this._oldStage) { this._drawAction && stage.off("drawend", this._drawAction); this._drawAction = stage.on("drawend", this._handleDrawEnd, this); this._oldStage = stage; } this.DisplayObject__tick(evtObj); }; /** * @method _handleDrawEnd * @param {Event} evt * @protected */ p._handleDrawEnd = function(evt) { var o = this.htmlElement; if (!o) { return; } var style = o.style; var props = this.getConcatenatedDisplayProps(this._props), mtx = props.matrix; var visibility = props.visible ? "visible" : "hidden"; if (visibility != style.visibility) { style.visibility = visibility; } if (!props.visible) { return; } var oldProps = this._oldProps, oldMtx = oldProps&&oldProps.matrix; var n = 10000; // precision if (!oldMtx || !oldMtx.equals(mtx)) { var str = "matrix(" + (mtx.a*n|0)/n +","+ (mtx.b*n|0)/n +","+ (mtx.c*n|0)/n +","+ (mtx.d*n|0)/n +","+ (mtx.tx+0.5|0); style.transform = style.WebkitTransform = style.OTransform = style.msTransform = str +","+ (mtx.ty+0.5|0) +")"; style.MozTransform = str +"px,"+ (mtx.ty+0.5|0) +"px)"; if (!oldProps) { oldProps = this._oldProps = new createjs.DisplayProps(true, null); } oldProps.matrix.copy(mtx); } if (oldProps.alpha != props.alpha) { style.opacity = ""+(props.alpha*n|0)/n; oldProps.alpha = props.alpha; } }; createjs.DOMElement = createjs.promote(DOMElement, "DisplayObject"); }()); //############################################################################## // Filter.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * Base class that all filters should inherit from. Appli * * When on a regular Stage apply the Filters and then cache the object using the {{#crossLink "DisplayObject/cache"}}{{/crossLink}} method. * When a cached object changes, please use {{#crossLink "DisplayObject/updateCache"}}{{/crossLink}}. * When on a StageGL simply setting content in the `.filters` array will trigger an automatic and constantly updated cache. * *

Example

* * myInstance.filters = [ * new createjs.ColorFilter(0, 0, 0, 1, 255, 0, 0), * new createjs.BlurFilter(5, 5, 10) * ]; * myInstance.cache(0,0, 100, 100); * * Note that each filter can implement a {{#crossLink "Filter/getBounds"}}{{/crossLink}} method, which returns the * margins that need to be applied in order to fully display the filter. For example, the {{#crossLink "BlurFilter"}}{{/crossLink}} * will cause an object to feather outwards, resulting in a margin around the shape. * * Any filter that consumes an external image stretches the image to cover the cached bounds. If this is an undesired * visual result, then use an intermediary cache to properly size and layout your data before passing it to a filter. * * *

EaselJS Filters

* EaselJS comes with a number of pre-built filters: *
    *
  • {{#crossLink "AberrationFilter"}}{{/crossLink}} : Shift the RGB components separately along a given vector
  • *
  • {{#crossLink "AlphaMapFilter"}}{{/crossLink}} : Map a greyscale image to the alpha channel of a display object
  • *
  • {{#crossLink "AlphaMaskFilter"}}{{/crossLink}}: Map an image's alpha channel to the alpha channel of a display object
  • *
  • {{#crossLink "BlurFilter"}}{{/crossLink}}: Apply vertical and horizontal blur to a display object
  • *
  • {{#crossLink "ColorFilter"}}{{/crossLink}}: Color transform a display object
  • *
  • {{#crossLink "ColorMatrixFilter"}}{{/crossLink}}: Transform an image using a {{#crossLink "ColorMatrix"}}{{/crossLink}}
  • *
  • {{#crossLink "DisplacementFilter"}}{{/crossLink}}: Create localized distortions in supplied display object
  • *
* * @class Filter * @constructor **/ function Filter() { /** * A flag stating that this filter uses a context draw mode and cannot be batched into imageData processing. * @property usesContext * @type {boolean} * @default false */ this.usesContext = false; /** * Another filter that is required to act as part of this filter and created and managed under the hood. * @private * @property _multiPass * @type {Filter} * @default null */ this._multiPass = null; /** * Pre-processed template shader code. It will be parsed before being fed in into the shader compiler. * This should be based upon StageGL.SHADER_VERTEX_BODY_REGULAR * @property VTX_SHADER * @type {String} * @readonly */ this.VTX_SHADER_BODY = null; /** * Pre-processed template shader code. It will be parsed before being fed in into the shader compiler. * This should be based upon StageGL.SHADER_FRAGMENT_BODY_REGULAR * @property FRAG_SHADER * @type {String} * @readonly */ this.FRAG_SHADER_BODY = null; } var p = Filter.prototype; // static methods: /** * Check to see if an image source being provided is one that is valid. *

Valid Sources:

*
    *
  • Image Object
  • *
  • HTML Canvas Element
  • *
  • `.cacheCanvas` on an object with the same stage
  • *
* WebGLTextures CANNOT be shared between multiple WebGL contexts. This means the only safe source for a WebGLTexture * is an object cached using the same StageGL as the object trying to use it in a filter. This function does not * enforce that restriction, as it is difficult or expensive to detect. The render will crash or fail to load the * image data if the rule isn't followed. * @param {HTMLImageElement|HTMLCanvasElement|WebGLTexture} src The element to check for validity * @return Boolean Whether the source is valid */ Filter.isValidImageSource = function(src) { return Boolean(src) && ( src instanceof Image || src instanceof WebGLTexture || src instanceof HTMLCanvasElement ); }; // public methods: /** * Provides padding values for this filter. That is, how much the filter will extend the visual bounds of an object it is applied to. * @method getBounds * @param {Rectangle} [rect] If specified, the provided Rectangle instance will be expanded by the padding amounts and returned. * @return {Rectangle} If a `rect` param was provided, it is returned. If not, either a new rectangle with the padding values, or null if no padding is required for this filter. **/ p.getBounds = function(rect) { return rect; }; /** * Assign any unique uniforms or other setup functionality here. * @method shaderParamSetup * @param {WebGLContext} gl The context associated with the stage performing the render. * @param {StageGL} stage The stage instance that will be rendering. * @param {ShaderProgram} shaderProgram The compiled shader that is going to be used to perform the render. */ p.shaderParamSetup = function(gl, stage, shaderProgram) {}; /** * Applies the filter to the specified context. * @method applyFilter * @param {CanvasRenderingContext2D} ctx The 2D context to use as the source. * @param {Number} x The x position to use for the source rect. * @param {Number} y The y position to use for the source rect. * @param {Number} width The width to use for the source rect. * @param {Number} height The height to use for the source rect. * @param {CanvasRenderingContext2D} [targetCtx=ctx] The 2D context to draw the result to. Defaults to the context passed to ctx. * @return {Boolean} If the filter was applied successfully. **/ p.applyFilter = function(ctx, x, y, width, height, targetCtx) { // this is the default behaviour because most filters access pixel data. It is overridden when not needed. targetCtx = targetCtx || ctx; try { var imageData = ctx.getImageData(x, y, width, height); } catch (e) { return false; } if (this._applyFilter(imageData)) { targetCtx.putImageData(imageData, x, y); return true; } return false; }; /** * Returns a string representation of this object. * @method toString * @return {String} a string representation of the instance. **/ p.toString = function() { return "[Filter]"; }; /** * Returns a clone of this Filter instance. * @method clone * @return {Filter} A clone of the current Filter instance. **/ p.clone = function() { return new Filter(); }; // private methods: /** * @method _applyFilter * @param {ImageData} imageData Target ImageData instance. * @return {Boolean} **/ p._applyFilter = function(imageData) { return true; }; createjs.Filter = Filter; }()); //############################################################################## // BitmapCache.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * The BitmapCache is an internal representation of all the cache properties and logic required in order to "cache" * an object. This information and functionality used to be located on a {{#crossLink "DisplayObject/cache"}}{{/crossLink}} * method in {{#crossLink "DisplayObject"}}{{/crossLink}}, but was moved to its own class. * * Caching in this context is purely visual, and will render the DisplayObject out into an image to be used instead * of the object. The actual cache itself is still stored on the target with the {{#crossLink "DisplayObject/cacheCanvas:property"}}{{/crossLink}}. * Working with a singular image like a {{#crossLink "Bitmap"}}{{/crossLink}} there is little benefit to performing * a cache as it is already a single image. Caching is best done on containers containing multiple complex parts that * do not move often, so that rendering the image instead will improve overall rendering speed. A cached object will * not visually update until explicitly told to do so with a call to update, much like a Stage. If a cache is being * updated every frame it is likely not improving rendering performance. Cache are best used when updates will be sparse. * * Caching is also a co-requisite for applying filters to prevent expensive filters running constantly without need, * and to physically enable some effects. The BitmapCache is also responsible for applying filters to objects and * reads each {{#crossLink "Filter"}}{{/crossLink}} due to this relationship. Real-time Filters are not recommended * performance wise when dealing with a Context2D canvas. On a StageGL performance is better so the presence of a * filter will automatically create a cache if one is not made manually. * * Some visual effects can be achieved with a {{#crossLink "DisplayObject/compositeOperation:property"}}{{/crossLink}} * so check out that setting before settling on a filter. * @class BitmapCache * @constructor **/ function BitmapCache() { // public: /** * Width of the cache relative to the target object. * @property width * @protected * @type {Number} * @default undefined **/ this.width = undefined; /** * Height of the cache relative to the target object. * @property height * @protected * @type {Number} * @default undefined * @todo Should the width and height be protected? **/ this.height = undefined; /** * Horizontal position of the cache relative to the target's origin. * @property x * @protected * @type {Number} * @default undefined **/ this.x = undefined; /** * Vertical position of the cache relative to target's origin. * @property y * @protected * @type {Number} * @default undefined **/ this.y = undefined; /** * The internal scale of the cache image, does not affects display size. This is useful to both increase and * decrease render quality. Objects with increased scales are more likely to look good when scaled up or rotated. * Objects with decreased scales can save on rendering performance. * @property scale * @protected * @type {Number} * @default 1 **/ this.scale = 1; /** * The x offset used for drawing into the cache itself, accounts for both transforms applied. * @property offX * @protected * @type {Number} * @default 0 **/ this.offX = 0; /** * The y offset used for drawing into the cache itself, accounts for both transforms applied. * @property offY * @protected * @type {Number} * @default 0 **/ this.offY = 0; /** * Track how many times the cache has been updated, mostly used for preventing duplicate cacheURLs. * This can be useful to see if a cache has been updated. * @property cacheID * @type {Number} * @default 0 **/ this.cacheID = 0; // protected: /** * The number of filters found to process this update, used to optimize some decisions and surfaces * @type {number} * @private */ this._filterCount = 0; /** * The relative offset of the filter's x position, used for drawing the cache onto its container. * Re-calculated every update call before drawing. * @property _filterOffY * @protected * @type {Number} * @default 0 **/ this._filterOffX = 0; /** * The relative offset of the filter's y position, used for drawing the cache onto its container. * Re-calculated every update call before drawing. * @property _filterOffY * @protected * @type {Number} * @default 0 **/ this._filterOffY = 0; /** * Internal tracking of the disabled state, use the getter/setters. * @property _disabled * @type {boolean} * @protected */ this._disabled = false; /** * Internal tracking of whether this cache was automatically created and thus automatically controlled * @type {boolean} * @protected */ this._autoGenerated = false; /** * Internal tracking of intended cacheCanvas, may or may not be assigned based on disabled state. * @property _cacheCanvas * @type {HTMLCanvasElement | WebGLTexture | Object} * @protected */ this._cacheCanvas = null; /** * Output StageGL target for GL drawing * @property _stageGL * @type {StageGL} * @protected */ this._stageGL = null; /** * The cacheID when a DataURL was requested. * @property _cacheDataURLID * @protected * @type {Number} * @default 0 **/ this._cacheDataURLID = 0; /** * The cache's DataURL, generated on-demand using the getter. * @property _cacheDataURL * @protected * @type {String} * @default null **/ this._cacheDataURL = null; /** * Internal tracking of final bounding width, approximately width*scale; however, filters can complicate the actual value. * @property _drawWidth * @protected * @type {Number} * @default 0 **/ this._drawWidth = 0; /** * Internal tracking of final bounding height, approximately height*scale; however, filters can complicate the actual value. * @property _drawHeight * @protected * @type {Number} * @default 0 **/ this._drawHeight = 0; /** * Internal tracking of the last requested bounds, may happen repeadtedly so stored to avoid object creation * @property _boundRect * @protected * @type {Rectangle} * @default 0 **/ this._boundRect = new createjs.Rectangle(); // semi protected: not public API but modified by other classes /** * Storage for the StageGL counter positioning matrix used on the object being cached * @property _counterMatrix * @type {Matrix2D} */ this._counterMatrix = null; /** * One of the major render buffers used in composite blending and filter drawing. Do not expect this to always be the same object. * "What you're drawing to", object occasionally swaps with concat. * @property _bufferTextureOutput * @type {WebGLTexture} */ this._bufferTextureOutput = null; /** * One of the major render buffers used in composite blending and filter drawing. Do not expect this to always be the same object. * "What you've draw before now", object occasionally swaps with output. * @property _bufferTextureConcat * @type {WebGLTexture} */ this._bufferTextureConcat = null; /** * One of the major render buffers used only for composite blending draws. * "Temporary mixing surface" * @property _bufferTextureTemp * @type {WebGLTexture} */ this._bufferTextureTemp = null; } var p = BitmapCache.prototype; p._get_disabled = function () { return this._disabled; }; p._set_disabled = function (value) { this._disabled = !!value; if (this.target) { this.target.cacheCanvas = (this._disabled || this._autoGenerated) ? null : this._cacheCanvas; } }; try { Object.defineProperties(p, { /** * Disable or enable the BitmapCache from displaying. Does not cause or block cache or cache updates when toggled. * Best used if the cached state is always identical, but the object will need temporary uncaching. * @property autoPurge * @type {Boolean} * @default false */ disabled: { get: p._get_disabled, set: p._set_disabled } }); } catch (e) {} // TODO: use Log /** * Returns the bounds that surround all applied filters, relies on each filter to describe how it changes bounds. * @method getFilterBounds * @param {DisplayObject} target The object to check the filter bounds for. * @param {Rectangle} [output=null] Optional parameter, if provided then calculated bounds will be applied to that object. * @return {Rectangle} bounds object representing the bounds with filters. * @static **/ BitmapCache.getFilterBounds = function(target, output) { if (!output){ output = new createjs.Rectangle(); } var filters = target.filters; var filterCount = filters && filters.length; if (!!filterCount <= 0) { return output; } for (var i=0; iWebGL cache with a 2D context * * var stage = new createjs.Stage(); * var bmp = new createjs.Bitmap(src); * bmp.cache(0, 0, bmp.width, bmp.height, 1, {gl: "new"}); // no StageGL to use, so make one * * var shape = new createjs.Shape(); * shape.graphics.clear().fill("red").drawRect(0,0,20,20); * shape.cache(0, 0, 20, 20, 1); // cannot use WebGL cache * *

WebGL cache with a WebGL context

* * var stageGL = new createjs.StageGL(); * var bmp = new createjs.Bitmap(src); * * // option 1 * stageGL.addChild(bmp); * bmp.cache(0, 0, bmp.width, bmp.height, 1, {gl: "stage"}); // when added to the display list we can look it up * // option 2 * bmp.cache(0, 0, bmp.width, bmp.height, 1, {gl: stageGL}); // we can specify it explicitly if we add it later * stageGL.addChild(bmp); * * var shape = new createjs.Shape(); * shape.graphics.clear().fill("red").drawRect(0,0,20,20); * shape.cache(0, 0, 20, 20, 1); // cannot use WebGL cache * * You may wish to create your own StageGL instance to control factors like clear color, transparency, AA, and * others. If the specified stage is not rendering content and just the cache set{{#crossLink "StageGL/isCacheControlled"}}{{/crossLink}} * to true on your instance. This will trigger it to behave correctly for rendering your output. * * @public * @method define * @param {Number} x The x coordinate origin for the cache region. * @param {Number} y The y coordinate origin for the cache region. * @param {Number} width The width of the cache region. * @param {Number} height The height of the cache region. * @param {Number} [scale=1] The scale at which the cache will be created. For example, if you cache a vector shape * using myShape.cache(0,0,100,100,2) then the resulting cacheCanvas will be 200x200 px. This lets you scale and * rotate cached elements with greater fidelity. Default is 1. * @param {Object} [options=undefined] Specify additional parameters for the cache logic * @param {undefined|"new"|"stage"|StageGL} [options.useGL=undefined] Select whether to use context 2D, or WebGL rendering, and * whether to make a new stage instance or use an existing one. See above for extensive details on use. * @for BitmapCache */ p.define = function(target, x, y, width, height, scale, options) { if (!target){ throw "No symbol to cache"; } this._options = options; this.target = target; this.width = width >= 1 ? width : 1; this.height = height >= 1 ? height : 1; this.x = x || 0; this.y = y || 0; this.scale = scale || 1; this.update(); }; /** * Directly called via {{#crossLink "DisplayObject/updateCache:method"}}{{/crossLink}}, but also internally. This * has the dual responsibility of making sure the surface is ready to be drawn to, and performing the draw. For * full details of each behaviour, check the protected functions {{#crossLink "BitmapCache/_updateSurface"}}{{/crossLink}} * and {{#crossLink "BitmapCache/_drawToCache"}}{{/crossLink}} respectively. * @method update * @param {String} [compositeOperation=null] The DisplayObject this cache is linked to. **/ p.update = function(compositeOperation) { if (!this.target) { throw "define() must be called before update()"; } var filterBounds = BitmapCache.getFilterBounds(this.target); var surface = this._cacheCanvas; this._drawWidth = Math.ceil(this.width*this.scale) + filterBounds.width; this._drawHeight = Math.ceil(this.height*this.scale) + filterBounds.height; this._filterCount = this.target.filters && this.target.filters.reduce(BitmapCache.filterCounter, 0); if (!surface || this._drawWidth !== surface.width || this._drawHeight !== surface.height) { this._updateSurface(); } if (this._stageGL) { if (this._bufferTextureOutput === null) { this._bufferTextureOutput = this._stageGL.getRenderBufferTexture(this._drawWidth, this._drawHeight); } else { this._stageGL.resizeTexture(this._bufferTextureOutput, this._drawWidth, this._drawHeight); } if (this._cacheCanvas === null){ this._cacheCanvas = this._bufferTextureOutput; this.disabled = this._disabled; } if (this._filterCount >= 1) { if (this._bufferTextureConcat === null) { this._bufferTextureConcat = this._stageGL.getRenderBufferTexture(this._drawWidth, this._drawHeight); } else { this._stageGL.resizeTexture(this._bufferTextureConcat, this._drawWidth, this._drawHeight); } } } this._filterOffX = filterBounds.x; this._filterOffY = filterBounds.y; this.offX = this.x*this.scale + this._filterOffX; this.offY = this.y*this.scale + this._filterOffY; this._drawToCache(compositeOperation); this.cacheID = this.cacheID?this.cacheID+1:1; }; /** * Reset and release all the properties and memory associated with this cache. * @method release **/ p.release = function() { if (this._stageGL) { if (this._bufferTextureOutput !== null){ this._stageGL._killTextureObject(this._bufferTextureOutput); } if (this._bufferTextureConcat !== null){ this._stageGL._killTextureObject(this._bufferTextureConcat); } if (this._bufferTextureTemp !== null){ this._stageGL._killTextureObject(this._bufferTextureTemp); } // set the context to none and let the garbage collector get the rest when the canvas itself gets removed this._stageGL = false; } else { var stage = this.target.stage; if (stage instanceof createjs.StageGL) { stage.releaseTexture(this._cacheCanvas); } } this.disabled = true; this.target = this._cacheCanvas = null; this.cacheID = this._cacheDataURLID = this._cacheDataURL = undefined; this.width = this.height = this.x = this.y = this.offX = this.offY = 0; this.scale = 1; }; /** * Returns a data URL for the cache, or `null` if this display object is not cached. * Uses {{#crossLink "BitmapCache/cacheID:property"}}{{/crossLink}} to ensure a new data URL is not generated if the * cache has not changed. * @method getCacheDataURL * @return {String} The image data url for the cache. **/ p.getCacheDataURL = function() { var cacheCanvas = this.target && this._cacheCanvas; if (!cacheCanvas) { return null; } if (this.cacheID !== this._cacheDataURLID) { this._cacheDataURLID = this.cacheID; this._cacheDataURL = cacheCanvas.toDataURL ? cacheCanvas.toDataURL() : null; } return this._cacheDataURL; }; /** * Use context2D drawing commands to display the cache canvas being used. * @method draw * @param {CanvasRenderingContext2D} ctx The context to draw into. * @return {Boolean} Whether the draw was handled successfully. **/ p.draw = function(ctx) { if (!this.target) { return false; } ctx.drawImage(this._cacheCanvas, this.x + (this._filterOffX/this.scale), this.y + (this._filterOffY/this.scale), this._drawWidth/this.scale, this._drawHeight/this.scale ); return true; }; /** * Determine the bounds of the shape in local space. * @method getBounds * @return {Rectangle} */ p.getBounds = function() { var scale = this.scale; return this._boundRect.setValues( this.x, this.y, this.width/scale, this.height/scale ); }; /** * Fetch the correct filter in order, complicated by multipass filtering. * @param {Number} lookup The filter in the list to return */ p._getGLFilter = function(lookup) { if (this.target.filters === null || lookup < 0){ return undefined; } var i = 0; var result = this.target.filters[i]; while (result && --lookup >= 0) { result = result._multiPass ? result._multiPass : this.target.filters[++i]; } return result; }; // private methods: /** * Create or resize the invisible canvas/surface that is needed for the display object(s) to draw to, * and in turn be used in their stead when drawing. The surface is resized to the size defined * by the width and height, factoring in scaling and filters. Adjust them to adjust the output size. * @method _updateSurface * @protected **/ p._updateSurface = function() { var surface; if (!this._options || !this._options.useGL) { surface = this._cacheCanvas; // create it if it's missing if (!surface) { surface = this._cacheCanvas = createjs.createCanvas?createjs.createCanvas():document.createElement("canvas"); this.disabled = this._disabled; } // now size it surface.width = this._drawWidth; surface.height = this._drawHeight; return; } // create it if it's missing if (!this._stageGL) { if (this._options.useGL === "stage") { var targetStage = this.target.stage; // use the stage that this object belongs on as the WebGL context if (!(targetStage && targetStage.isWebGL)){ var error = "Cannot use 'stage' for cache because the object's parent stage is "; error += targetStage ? "non WebGL." : "not set, please addChild to the correct stage."; throw error; } this._stageGL = targetStage; } else if (this._options.useGL === "new") { // create a new WebGL context to run this cache this._cacheCanvas = document.createElement("canvas"); // low autopurge in case of filter swapping and low texture count this._stageGL = new createjs.StageGL(this._cacheCanvas, {antialias: true, transparent: true, autoPurge: 10}); if (!this._stageGL._webGLContext){ throw "GL Cache asked for but unavailable"; } this._stageGL.isCacheControlled = true; // use this flag to control stage sizing and final output } else if (this._options.useGL instanceof createjs.StageGL) { // use the provided WebGL context to run this cache, trust the user it works and is configured. this._stageGL = this._options.useGL; } else { throw "Invalid option provided to useGL, expected ['stage', 'new', StageGL, undefined], got "+ this._options.useGL; } } this.disabled = this._disabled; // if we have a dedicated stage we've got to size it var stageGL = this._stageGL; if (stageGL.isCacheControlled) { surface = this._cacheCanvas; surface.width = this._drawWidth; surface.height = this._drawHeight; stageGL.updateViewport(this._drawWidth, this._drawHeight); } }; /** * Perform the cache draw out for context 2D now that the setup properties have been performed. * @method _drawToCache * @protected **/ p._drawToCache = function(compositeOperation) { var surface = this._cacheCanvas; var target = this.target; var webGL = this._stageGL; if (webGL) { webGL.cacheDraw(target, this); } else { var ctx = surface.getContext("2d"); if (!compositeOperation) { ctx.clearRect(0, 0, this._drawWidth+1, this._drawHeight+1); } ctx.save(); ctx.globalCompositeOperation = compositeOperation; ctx.setTransform(this.scale,0,0,this.scale, -this._filterOffX,-this._filterOffY); ctx.translate(-this.x, -this.y); target.draw(ctx, true); ctx.restore(); if (target.filters && target.filters.length) { this._applyFilters(ctx); } } surface._invalid = true; }; /** * Work through every filter and apply its individual visual transformation. * @method _applyFilters * @protected **/ p._applyFilters = function(ctx) { var filters = this.target.filters; var w = this._drawWidth; var h = this._drawHeight; var data; var i = 0, filter = filters[i]; do { // this is safe because we wouldn't be in apply filters without a filter count of at least 1 if (filter.usesContext){ if (data) { ctx.putImageData(data, 0,0); data = null; } filter.applyFilter(ctx, 0,0, w,h); } else { if (!data) { data = ctx.getImageData(0,0, w,h); } filter._applyFilter(data); } // work through the multipass if it's there, otherwise move on filter = filter._multiPass !== null ? filter._multiPass : filters[++i]; } while (filter); //done if (data) { ctx.putImageData(data, 0,0); } }; createjs.BitmapCache = BitmapCache; }()); //############################################################################## // BlurFilter.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * Applies a box blur to DisplayObjects in context 2D and a Gaussian blur in webgl. Note that this filter is fairly * intensive, particularly if the quality is set higher than 1. * *

Example

* This example creates a red circle, and then applies a 5 pixel blur to it. It uses the {{#crossLink "Filter/getBounds"}}{{/crossLink}} * method to account for the spread that the blur causes. * * var shape = new createjs.Shape().set({x:100,y:100}); * shape.graphics.beginFill("#ff0000").drawCircle(0,0,50); * * var blurFilter = new createjs.BlurFilter(5, 5, 1); * shape.filters = [blurFilter]; * var bounds = blurFilter.getBounds(); * * shape.cache(-50+bounds.x, -50+bounds.y, 100+bounds.width, 100+bounds.height); * * See {{#crossLink "Filter"}}{{/crossLink}} for an more information on applying filters. * @class BlurFilter * @extends Filter * @constructor * @param {Number} [blurX=0] The horizontal blur radius in pixels. * @param {Number} [blurY=0] The vertical blur radius in pixels. * @param {Number} [quality=1] The number of blur iterations. **/ function BlurFilter( blurX, blurY, quality) { this.Filter_constructor(); // public properties: /** * Horizontal blur radius in pixels * @property blurX * @default 0 * @type Number **/ this._blurX = blurX; this._blurXTable = []; this._lastBlurX = null; /** * Vertical blur radius in pixels * @property blurY * @default 0 * @type Number **/ this._blurY = blurY; this._blurYTable = []; this._lastBlurY = null; /** * Number of blur iterations. For example, a value of 1 will produce a rough blur. A value of 2 will produce a * smoother blur, but take twice as long to run. * @property quality * @default 1 * @type Number **/ this._quality; this._lastQuality = null; // This is a template to generate the shader for BlurFilter.FRAG_SHADER_BODY. this.FRAG_SHADER_TEMPLATE = ( "uniform float xWeight[{{blurX}}];" + "uniform float yWeight[{{blurY}}];" + "uniform vec2 textureOffset;" + "void main(void) {" + "vec4 color = vec4(0.0);" + "float xAdj = ({{blurX}}.0-1.0)/2.0;" + "float yAdj = ({{blurY}}.0-1.0)/2.0;" + "vec2 sampleOffset;" + "for(int i=0; i<{{blurX}}; i++) {" + "for(int j=0; j<{{blurY}}; j++) {" + "sampleOffset = vTextureCoord + (textureOffset * vec2(float(i)-xAdj, float(j)-yAdj));" + "color += texture2D(uSampler, sampleOffset) * (xWeight[i] * yWeight[j]);" + "}" + "}" + "gl_FragColor = color.rgba;" + "}" ); // update the filter using the setters if(isNaN(quality) || quality < 1){ quality = 1; } this.setQuality(quality|0); } var p = createjs.extend(BlurFilter, createjs.Filter); // TODO: deprecated // p.initialize = function() {}; // searchable for devs wondering where it is. REMOVED. See docs for details. p.getBlurX = function() { return this._blurX; }; p.getBlurY = function() { return this._blurY; }; p.setBlurX = function(value) { if(isNaN(value) || value < 0){ value = 0; } this._blurX = value; }; p.setBlurY = function(value) { if(isNaN(value) || value < 0){ value = 0; } this._blurY = value; }; p.getQuality = function() { return this._quality; }; p.setQuality = function(value) { if(isNaN(value) || value < 0){ value = 0; } this._quality = value | 0; }; p._getShader = function() { var xChange = this._lastBlurX !== this._blurX; var yChange = this._lastBlurY !== this._blurY; var qChange = this._lastQuality !== this._quality; if(xChange || yChange || qChange) { if(xChange || qChange) { this._blurXTable = this._getTable(this._blurX * this._quality); } if(yChange || qChange) { this._blurYTable = this._getTable(this._blurY * this._quality); } this._updateShader(); this._lastBlurX = this._blurX; this._lastBlurY = this._blurY; this._lastQuality = this._quality; return undefined; // force a rebuild } return this._compiledShader; }; p._setShader = function(value) { this._compiledShader = value; }; try { Object.defineProperties(p, { blurX: { get: p.getBlurX, set: p.setBlurX }, blurY: { get: p.getBlurY, set: p.setBlurY }, quality: { get: p.getQuality, set: p.setQuality }, _builtShader: { get: p._getShader, set: p._setShader} }); } catch (e) { console.log(e); } /** * Internal lookup function to create gaussian distribution. * @method _getTable * @param {Number} spread How many steps in the curve. * @return {Array} An array with Math.ceil(spread*2) entries with appropriately distributed weights. */ p._getTable = function(spread) { var EDGE = 4.2; if(spread<=1) { return [1]; } var result = []; var count = Math.ceil(spread*2); count += (count%2)?0:1; var adjust = (count/2)|0; for(var i = -adjust; i<=adjust; i++) { var x = (i/adjust)*EDGE; result.push(1/Math.sqrt(2*Math.PI) * Math.pow(Math.E, -(Math.pow(x,2)/4))); } var factor = result.reduce(function(a, b) { return a + b; }); return result.map(function(currentValue, index, array) { return currentValue/factor; }); }; /** * Internal update function to create shader properties. * @method _updateShader */ p._updateShader = function() { if(this._blurX === undefined || this._blurY === undefined){ return; } var result = this.FRAG_SHADER_TEMPLATE; result = result.replace(/\{\{blurX\}\}/g, (this._blurXTable.length).toFixed(0)); result = result.replace(/\{\{blurY\}\}/g, (this._blurYTable.length).toFixed(0)); this.FRAG_SHADER_BODY = result; }; // Docced in superclass p.shaderParamSetup = function(gl, stage, shaderProgram) { // load the normalized gaussian weight tables gl.uniform1fv( gl.getUniformLocation(shaderProgram, "xWeight"), this._blurXTable ); gl.uniform1fv( gl.getUniformLocation(shaderProgram, "yWeight"), this._blurYTable ); // what is the size of a single pixel in -1, 1 (webGL) space gl.uniform2f( gl.getUniformLocation(shaderProgram, "textureOffset"), 2/(stage._viewportWidth*this._quality), 2/(stage._viewportHeight*this._quality) ); }; // constants: /** * Array of multiply values for blur calculations. * @property MUL_TABLE * @type Array * @protected * @static **/ BlurFilter.MUL_TABLE = [1, 171, 205, 293, 57, 373, 79, 137, 241, 27, 391, 357, 41, 19, 283, 265, 497, 469, 443, 421, 25, 191, 365, 349, 335, 161, 155, 149, 9, 278, 269, 261, 505, 245, 475, 231, 449, 437, 213, 415, 405, 395, 193, 377, 369, 361, 353, 345, 169, 331, 325, 319, 313, 307, 301, 37, 145, 285, 281, 69, 271, 267, 263, 259, 509, 501, 493, 243, 479, 118, 465, 459, 113, 446, 55, 435, 429, 423, 209, 413, 51, 403, 199, 393, 97, 3, 379, 375, 371, 367, 363, 359, 355, 351, 347, 43, 85, 337, 333, 165, 327, 323, 5, 317, 157, 311, 77, 305, 303, 75, 297, 294, 73, 289, 287, 71, 141, 279, 277, 275, 68, 135, 67, 133, 33, 262, 260, 129, 511, 507, 503, 499, 495, 491, 61, 121, 481, 477, 237, 235, 467, 232, 115, 457, 227, 451, 7, 445, 221, 439, 218, 433, 215, 427, 425, 211, 419, 417, 207, 411, 409, 203, 202, 401, 399, 396, 197, 49, 389, 387, 385, 383, 95, 189, 47, 187, 93, 185, 23, 183, 91, 181, 45, 179, 89, 177, 11, 175, 87, 173, 345, 343, 341, 339, 337, 21, 167, 83, 331, 329, 327, 163, 81, 323, 321, 319, 159, 79, 315, 313, 39, 155, 309, 307, 153, 305, 303, 151, 75, 299, 149, 37, 295, 147, 73, 291, 145, 289, 287, 143, 285, 71, 141, 281, 35, 279, 139, 69, 275, 137, 273, 17, 271, 135, 269, 267, 133, 265, 33, 263, 131, 261, 130, 259, 129, 257, 1]; /** * Array of shift values for blur calculations. * @property SHG_TABLE * @type Array * @protected * @static **/ BlurFilter.SHG_TABLE = [0, 9, 10, 11, 9, 12, 10, 11, 12, 9, 13, 13, 10, 9, 13, 13, 14, 14, 14, 14, 10, 13, 14, 14, 14, 13, 13, 13, 9, 14, 14, 14, 15, 14, 15, 14, 15, 15, 14, 15, 15, 15, 14, 15, 15, 15, 15, 15, 14, 15, 15, 15, 15, 15, 15, 12, 14, 15, 15, 13, 15, 15, 15, 15, 16, 16, 16, 15, 16, 14, 16, 16, 14, 16, 13, 16, 16, 16, 15, 16, 13, 16, 15, 16, 14, 9, 16, 16, 16, 16, 16, 16, 16, 16, 16, 13, 14, 16, 16, 15, 16, 16, 10, 16, 15, 16, 14, 16, 16, 14, 16, 16, 14, 16, 16, 14, 15, 16, 16, 16, 14, 15, 14, 15, 13, 16, 16, 15, 17, 17, 17, 17, 17, 17, 14, 15, 17, 17, 16, 16, 17, 16, 15, 17, 16, 17, 11, 17, 16, 17, 16, 17, 16, 17, 17, 16, 17, 17, 16, 17, 17, 16, 16, 17, 17, 17, 16, 14, 17, 17, 17, 17, 15, 16, 14, 16, 15, 16, 13, 16, 15, 16, 14, 16, 15, 16, 12, 16, 15, 16, 17, 17, 17, 17, 17, 13, 16, 15, 17, 17, 17, 16, 15, 17, 17, 17, 16, 15, 17, 17, 14, 16, 17, 17, 16, 17, 17, 16, 15, 17, 16, 14, 17, 16, 15, 17, 16, 17, 17, 16, 17, 15, 16, 17, 14, 17, 16, 15, 17, 16, 17, 13, 17, 16, 17, 17, 16, 17, 14, 17, 16, 17, 16, 17, 16, 17, 9]; // public methods: // Docced in superclass p.getBounds = function (rect) { var x = this.blurX|0, y = this.blurY| 0; if(x <= 0 && y <= 0) { return rect; } var q = Math.pow(this.quality, 0.2); return (rect || new createjs.Rectangle()).pad(y*q+1,x*q+1,y*q+1,x*q+1); }; // Docced in superclass p.clone = function() { return new BlurFilter(this.blurX, this.blurY, this.quality); }; // Docced in superclass p.toString = function() { return "[BlurFilter]"; }; // private methods: // Docced in superclass p._applyFilter = function (imageData) { var radiusX = this._blurX >> 1; if (isNaN(radiusX) || radiusX < 0) return false; var radiusY = this._blurY >> 1; if (isNaN(radiusY) || radiusY < 0) return false; if (radiusX == 0 && radiusY == 0) return false; var iterations = this.quality; if (isNaN(iterations) || iterations < 1) iterations = 1; iterations |= 0; if (iterations > 3) iterations = 3; if (iterations < 1) iterations = 1; var px = imageData.data; var x=0, y=0, i=0, p=0, yp=0, yi=0, yw=0, r=0, g=0, b=0, a=0, pr=0, pg=0, pb=0, pa=0; var divx = (radiusX + radiusX + 1) | 0; var divy = (radiusY + radiusY + 1) | 0; var w = imageData.width | 0; var h = imageData.height | 0; var w1 = (w - 1) | 0; var h1 = (h - 1) | 0; var rxp1 = (radiusX + 1) | 0; var ryp1 = (radiusY + 1) | 0; var ssx = {r:0,b:0,g:0,a:0}; var sx = ssx; for ( i = 1; i < divx; i++ ) { sx = sx.n = {r:0,b:0,g:0,a:0}; } sx.n = ssx; var ssy = {r:0,b:0,g:0,a:0}; var sy = ssy; for ( i = 1; i < divy; i++ ) { sy = sy.n = {r:0,b:0,g:0,a:0}; } sy.n = ssy; var si = null; var mtx = BlurFilter.MUL_TABLE[radiusX] | 0; var stx = BlurFilter.SHG_TABLE[radiusX] | 0; var mty = BlurFilter.MUL_TABLE[radiusY] | 0; var sty = BlurFilter.SHG_TABLE[radiusY] | 0; while (iterations-- > 0) { yw = yi = 0; var ms = mtx; var ss = stx; for (y = h; --y > -1;) { r = rxp1 * (pr = px[(yi) | 0]); g = rxp1 * (pg = px[(yi + 1) | 0]); b = rxp1 * (pb = px[(yi + 2) | 0]); a = rxp1 * (pa = px[(yi + 3) | 0]); sx = ssx; for( i = rxp1; --i > -1; ) { sx.r = pr; sx.g = pg; sx.b = pb; sx.a = pa; sx = sx.n; } for( i = 1; i < rxp1; i++ ) { p = (yi + ((w1 < i ? w1 : i) << 2)) | 0; r += ( sx.r = px[p]); g += ( sx.g = px[p+1]); b += ( sx.b = px[p+2]); a += ( sx.a = px[p+3]); sx = sx.n; } si = ssx; for ( x = 0; x < w; x++ ) { px[yi++] = (r * ms) >>> ss; px[yi++] = (g * ms) >>> ss; px[yi++] = (b * ms) >>> ss; px[yi++] = (a * ms) >>> ss; p = ((yw + ((p = x + radiusX + 1) < w1 ? p : w1)) << 2); r -= si.r - ( si.r = px[p]); g -= si.g - ( si.g = px[p+1]); b -= si.b - ( si.b = px[p+2]); a -= si.a - ( si.a = px[p+3]); si = si.n; } yw += w; } ms = mty; ss = sty; for (x = 0; x < w; x++) { yi = (x << 2) | 0; r = (ryp1 * (pr = px[yi])) | 0; g = (ryp1 * (pg = px[(yi + 1) | 0])) | 0; b = (ryp1 * (pb = px[(yi + 2) | 0])) | 0; a = (ryp1 * (pa = px[(yi + 3) | 0])) | 0; sy = ssy; for( i = 0; i < ryp1; i++ ) { sy.r = pr; sy.g = pg; sy.b = pb; sy.a = pa; sy = sy.n; } yp = w; for( i = 1; i <= radiusY; i++ ) { yi = ( yp + x ) << 2; r += ( sy.r = px[yi]); g += ( sy.g = px[yi+1]); b += ( sy.b = px[yi+2]); a += ( sy.a = px[yi+3]); sy = sy.n; if( i < h1 ) { yp += w; } } yi = x; si = ssy; if ( iterations > 0 ) { for ( y = 0; y < h; y++ ) { p = yi << 2; px[p+3] = pa =(a * ms) >>> ss; if ( pa > 0 ) { px[p] = ((r * ms) >>> ss ); px[p+1] = ((g * ms) >>> ss ); px[p+2] = ((b * ms) >>> ss ); } else { px[p] = px[p+1] = px[p+2] = 0 } p = ( x + (( ( p = y + ryp1) < h1 ? p : h1 ) * w )) << 2; r -= si.r - ( si.r = px[p]); g -= si.g - ( si.g = px[p+1]); b -= si.b - ( si.b = px[p+2]); a -= si.a - ( si.a = px[p+3]); si = si.n; yi += w; } } else { for ( y = 0; y < h; y++ ) { p = yi << 2; px[p+3] = pa =(a * ms) >>> ss; if ( pa > 0 ) { pa = 255 / pa; px[p] = ((r * ms) >>> ss ) * pa; px[p+1] = ((g * ms) >>> ss ) * pa; px[p+2] = ((b * ms) >>> ss ) * pa; } else { px[p] = px[p+1] = px[p+2] = 0 } p = ( x + (( ( p = y + ryp1) < h1 ? p : h1 ) * w )) << 2; r -= si.r - ( si.r = px[p]); g -= si.g - ( si.g = px[p+1]); b -= si.b - ( si.b = px[p+2]); a -= si.a - ( si.a = px[p+3]); si = si.n; yi += w; } } } } return true; }; createjs.BlurFilter = createjs.promote(BlurFilter, "Filter"); }()); //############################################################################## // AlphaMapFilter.js //############################################################################## this.createjs = this.createjs || {}; (function () { "use strict"; // constructor: /** * Applies a greyscale alpha map image (or canvas) to the target, such that the alpha channel of the result will * be copied from the red channel of the map, and the RGB channels will be copied from the target. * * Generally, it is recommended that you use {{#crossLink "AlphaMaskFilter"}}{{/crossLink}}, because it has much * better performance. * *

Example

* This example draws a red->blue box, caches it, and then uses the cache canvas as an alpha map on a 100x100 image. * * var box = new createjs.Shape(); * box.graphics.beginLinearGradientFill(["#ff0000", "#0000ff"], [0, 1], 0, 0, 0, 100) * box.graphics.drawRect(0, 0, 100, 100); * box.cache(0, 0, 100, 100); * * var bmp = new createjs.Bitmap("path/to/image.jpg"); * bmp.filters = [ * new createjs.AlphaMapFilter(box.cacheCanvas) * ]; * bmp.cache(0, 0, 100, 100); * stage.addChild(bmp); * * See {{#crossLink "Filter"}}{{/crossLink}} for more information on applying filters. * @class AlphaMapFilter * @extends Filter * @constructor * @param {HTMLImageElement|HTMLCanvasElement|WebGLTexture} alphaMap The greyscale image (or canvas) to use as the alpha value for the * result. This should be exactly the same dimensions as the target. **/ function AlphaMapFilter(alphaMap) { this.Filter_constructor(); if (!createjs.Filter.isValidImageSource(alphaMap)) { throw "Must provide valid image source for alpha map, see Filter.isValidImageSource"; } // public properties: /** * The greyscale image (or canvas) to use as the alpha value for the result. This should be exactly the same * dimensions as the target. * @property alphaMap * @type HTMLImageElement|HTMLCanvasElement **/ this.alphaMap = alphaMap; // private properties: /** * @property _map * @protected * @type HTMLImageElement|HTMLCanvasElement **/ this._map = null; /** * @property _mapCtx * @protected * @type CanvasRenderingContext2D **/ this._mapCtx = null; /** * @property _mapTexture * @protected * @type WebGLTexture */ this._mapTexture = null; this.FRAG_SHADER_BODY = ( "uniform sampler2D uAlphaSampler;"+ "void main(void) {" + "vec4 color = texture2D(uSampler, vTextureCoord);" + "vec4 alphaMap = texture2D(uAlphaSampler, vTextureCoord);" + // some image formats can have transparent white rgba(1,1,1, 0) when put on the GPU, this means we need a slight tweak // using ceil ensure that the colour will be used so long as it exists but pure transparency will be treated black "float newAlpha = alphaMap.r * ceil(alphaMap.a);" + "gl_FragColor = vec4(clamp(color.rgb/color.a, 0.0, 1.0) * newAlpha, newAlpha);" + "}" ); if(alphaMap instanceof WebGLTexture) { this._mapTexture = alphaMap; } } var p = createjs.extend(AlphaMapFilter, createjs.Filter); // TODO: deprecated // p.initialize = function() {}; // searchable for devs wondering where it is. REMOVED. See docs for details. // Docced in superclass p.shaderParamSetup = function(gl, stage, shaderProgram) { if(this._mapTexture === null) { this._mapTexture = gl.createTexture(); } gl.activeTexture(gl.TEXTURE1); gl.bindTexture(gl.TEXTURE_2D, this._mapTexture); stage.setTextureParams(gl); if (this.alphaMap !== this._mapTexture) { gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, this.alphaMap); } gl.uniform1i( gl.getUniformLocation(shaderProgram, "uAlphaSampler"), 1 ); }; // public methods: // Docced in superclass p.clone = function () { var o = new AlphaMapFilter(this.alphaMap); return o; }; // Docced in superclass p.toString = function () { return "[AlphaMapFilter]"; }; // private methods: // Docced in superclass p._applyFilter = function (imageData) { if (!this._prepAlphaMap()) { return false; } var outArray = imageData.data; var width = imageData.width; var height = imageData.height; var rowOffset, pixelStart; var sampleData = this._mapCtx.getImageData(0,0, this._map.width,this._map.height); var sampleArray = sampleData.data; var sampleWidth = sampleData.width; var sampleHeight = sampleData.height; var sampleRowOffset, samplePixelStart; var widthRatio = sampleWidth/width; var heightRatio = sampleHeight/height; // performance optimizing lookup // the x and y need to stretch separately, nesting the for loops simplifies this logic even if the array is flat for (var i=0; iIMPORTANT NOTE: This filter currently does not support the targetCtx, or targetX/Y parameters correctly. * *

Example

* This example draws a gradient box, then caches it and uses the "cacheCanvas" as the alpha mask on a 100x100 image. * * var box = new createjs.Shape(); * box.graphics.beginLinearGradientFill(["#000000", "rgba(0, 0, 0, 0)"], [0, 1], 0, 0, 100, 100) * box.graphics.drawRect(0, 0, 100, 100); * box.cache(0, 0, 100, 100); * * var bmp = new createjs.Bitmap("path/to/image.jpg"); * bmp.filters = [ * new createjs.AlphaMaskFilter(box.cacheCanvas) * ]; * bmp.cache(0, 0, 100, 100); * * See {{#crossLink "Filter"}}{{/crossLink}} for more information on applying filters. * @class AlphaMaskFilter * @extends Filter * @constructor * @param {HTMLImageElement|HTMLCanvasElement|WebGLTexture} mask **/ function AlphaMaskFilter(mask) { this.Filter_constructor(); if (!createjs.Filter.isValidImageSource(mask)) { throw "Must provide valid image source for alpha mask, see Filter.isValidImageSource"; } // public properties: /** * The image (or canvas) to use as the mask. * @property mask * @type HTMLImageElement|HTMLCanvasElement **/ this.mask = mask; // Docced in superclass this.usesContext = true; this.FRAG_SHADER_BODY = ( "uniform sampler2D uAlphaSampler;"+ "void main(void) {" + "vec4 color = texture2D(uSampler, vTextureCoord);" + "vec4 alphaMap = texture2D(uAlphaSampler, vTextureCoord);" + "gl_FragColor = vec4(color.rgb * alphaMap.a, color.a * alphaMap.a);" + "}" ); } var p = createjs.extend(AlphaMaskFilter, createjs.Filter); // TODO: deprecated // p.initialize = function() {}; // searchable for devs wondering where it is. REMOVED. See docs for details. // Docced in superclass p.shaderParamSetup = function(gl, stage, shaderProgram) { if(!this._mapTexture) { this._mapTexture = gl.createTexture(); } gl.activeTexture(gl.TEXTURE1); gl.bindTexture(gl.TEXTURE_2D, this._mapTexture); stage.setTextureParams(gl); if (this.mask !== this._mapTexture) { gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, this.mask); } gl.uniform1i( gl.getUniformLocation(shaderProgram, "uAlphaSampler"), 1 ); }; // public methods: /** * Applies the filter to the specified context. * * IMPORTANT NOTE: This filter currently does not support the targetCtx, or targetX/Y parameters * correctly. * @method applyFilter * @param {CanvasRenderingContext2D} ctx The 2D context to use as the source. * @param {Number} x The x position to use for the source rect. * @param {Number} y The y position to use for the source rect. * @param {Number} width The width to use for the source rect. * @param {Number} height The height to use for the source rect. * @param {CanvasRenderingContext2D} [targetCtx] The 2D context to draw the result to. Defaults to the context passed to ctx. * @return {Boolean} If the filter was applied successfully. **/ p.applyFilter = function (ctx, x, y, width, height, targetCtx) { if (!this.mask) { return true; } if (targetCtx === undefined) { targetCtx = ctx; } if (targetCtx !== ctx) { targetCtx.drawImage(ctx.canvas, 0, 0, ctx.canvas.width, ctx.canvas.height, 0, 0, targetCtx.canvas.width, targetCtx.canvas.height ); } targetCtx.save(); targetCtx.globalCompositeOperation = "destination-in"; targetCtx.drawImage(this.mask, 0,0, this.mask.width,this.mask.height, x,y, width,height); targetCtx.restore(); return true; }; // Docced in superclass p.clone = function () { return new AlphaMaskFilter(this.mask); }; // Docced in superclass p.toString = function () { return "[AlphaMaskFilter]"; }; createjs.AlphaMaskFilter = createjs.promote(AlphaMaskFilter, "Filter"); }()); //############################################################################## // ColorFilter.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * Applies a color transform to DisplayObjects. * *

Example

* This example draws a red circle, and then transforms it to Blue. This is accomplished by multiplying all the channels * to 0 (except alpha, which is set to 1), and then adding 255 to the blue channel. * * var shape = new createjs.Shape().set({x:100,y:100}); * shape.graphics.beginFill("#ff0000").drawCircle(0,0,50); * * shape.filters = [ * new createjs.ColorFilter(0,0,0,1, 0,0,255,0) * ]; * shape.cache(-50, -50, 100, 100); * * See {{#crossLink "Filter"}}{{/crossLink}} for an more information on applying filters. * @class ColorFilter * @param {Number} [redMultiplier=1] The amount to multiply against the red channel. This is a range between 0 and 1. * @param {Number} [greenMultiplier=1] The amount to multiply against the green channel. This is a range between 0 and 1. * @param {Number} [blueMultiplier=1] The amount to multiply against the blue channel. This is a range between 0 and 1. * @param {Number} [alphaMultiplier=1] The amount to multiply against the alpha channel. This is a range between 0 and 1. * @param {Number} [redOffset=0] The amount to add to the red channel after it has been multiplied. This is a range * between -255 and 255. * @param {Number} [greenOffset=0] The amount to add to the green channel after it has been multiplied. This is a range * between -255 and 255. * @param {Number} [blueOffset=0] The amount to add to the blue channel after it has been multiplied. This is a range * between -255 and 255. * @param {Number} [alphaOffset=0] The amount to add to the alpha channel after it has been multiplied. This is a range * between -255 and 255. * @constructor * @extends Filter **/ function ColorFilter(redMultiplier, greenMultiplier, blueMultiplier, alphaMultiplier, redOffset, greenOffset, blueOffset, alphaOffset) { this.Filter_constructor(); // public properties: /** * Red channel multiplier. * @property redMultiplier * @type Number **/ this.redMultiplier = redMultiplier != null ? redMultiplier : 1; /** * Green channel multiplier. * @property greenMultiplier * @type Number **/ this.greenMultiplier = greenMultiplier != null ? greenMultiplier : 1; /** * Blue channel multiplier. * @property blueMultiplier * @type Number **/ this.blueMultiplier = blueMultiplier != null ? blueMultiplier : 1; /** * Alpha channel multiplier. * @property alphaMultiplier * @type Number **/ this.alphaMultiplier = alphaMultiplier != null ? alphaMultiplier : 1; /** * Red channel offset (added to value). * @property redOffset * @type Number **/ this.redOffset = redOffset || 0; /** * Green channel offset (added to value). * @property greenOffset * @type Number **/ this.greenOffset = greenOffset || 0; /** * Blue channel offset (added to value). * @property blueOffset * @type Number **/ this.blueOffset = blueOffset || 0; /** * Alpha channel offset (added to value). * @property alphaOffset * @type Number **/ this.alphaOffset = alphaOffset || 0; this.FRAG_SHADER_BODY = ( "uniform vec4 uColorMultiplier;" + "uniform vec4 uColorOffset;" + "void main(void) {" + "vec4 color = texture2D(uSampler, vTextureCoord);" + "color = clamp(vec4(0.0), vec4(1.0), vec4(vec3(color.rgb / color.a), color.a));" + "color = clamp(vec4(0.0), vec4(1.0), color * uColorMultiplier + uColorOffset);" + "gl_FragColor = vec4(color.rgb * color.a, color.a);" + "}" ); } var p = createjs.extend(ColorFilter, createjs.Filter); // TODO: deprecated // p.initialize = function() {}; // searchable for devs wondering where it is. REMOVED. See docs for details. // public methods: // Docced in superclass p.shaderParamSetup = function(gl, stage, shaderProgram) { gl.uniform4f( gl.getUniformLocation(shaderProgram, "uColorMultiplier"), this.redMultiplier, this.greenMultiplier, this.blueMultiplier, this.alphaMultiplier ); gl.uniform4f( gl.getUniformLocation(shaderProgram, "uColorOffset"), this.redOffset/255, this.greenOffset/255, this.blueOffset/255, this.alphaOffset/255 ); }; // Docced in superclass p.toString = function() { return "[ColorFilter]"; }; // Docced in superclass p.clone = function() { return new ColorFilter( this.redMultiplier, this.greenMultiplier, this.blueMultiplier, this.alphaMultiplier, this.redOffset, this.greenOffset, this.blueOffset, this.alphaOffset ); }; // private methods: // Docced in superclass p._applyFilter = function(imageData) { var data = imageData.data; var l = data.length; for (var i=0; iExample * * myColorMatrix.adjustHue(20).adjustBrightness(50); * * See {{#crossLink "Filter"}}{{/crossLink}} for an example of how to apply filters, or {{#crossLink "ColorMatrixFilter"}}{{/crossLink}} * for an example of how to use ColorMatrix to change a DisplayObject's color. * @class ColorMatrix * @param {Number} brightness * @param {Number} contrast * @param {Number} saturation * @param {Number} hue * @constructor **/ function ColorMatrix(brightness, contrast, saturation, hue) { this.setColor(brightness, contrast, saturation, hue); } var p = ColorMatrix.prototype; // constants: /** * Array of delta values for contrast calculations. * @property DELTA_INDEX * @type Array * @protected * @static **/ ColorMatrix.DELTA_INDEX = [ 0, 0.01, 0.02, 0.04, 0.05, 0.06, 0.07, 0.08, 0.1, 0.11, 0.12, 0.14, 0.15, 0.16, 0.17, 0.18, 0.20, 0.21, 0.22, 0.24, 0.25, 0.27, 0.28, 0.30, 0.32, 0.34, 0.36, 0.38, 0.40, 0.42, 0.44, 0.46, 0.48, 0.5, 0.53, 0.56, 0.59, 0.62, 0.65, 0.68, 0.71, 0.74, 0.77, 0.80, 0.83, 0.86, 0.89, 0.92, 0.95, 0.98, 1.0, 1.06, 1.12, 1.18, 1.24, 1.30, 1.36, 1.42, 1.48, 1.54, 1.60, 1.66, 1.72, 1.78, 1.84, 1.90, 1.96, 2.0, 2.12, 2.25, 2.37, 2.50, 2.62, 2.75, 2.87, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.3, 4.7, 4.9, 5.0, 5.5, 6.0, 6.5, 6.8, 7.0, 7.3, 7.5, 7.8, 8.0, 8.4, 8.7, 9.0, 9.4, 9.6, 9.8, 10.0 ]; /** * Identity matrix values. * @property IDENTITY_MATRIX * @type Array * @protected * @static **/ ColorMatrix.IDENTITY_MATRIX = [ 1,0,0,0,0, 0,1,0,0,0, 0,0,1,0,0, 0,0,0,1,0, 0,0,0,0,1 ]; /** * The constant length of a color matrix. * @property LENGTH * @type Number * @protected * @static **/ ColorMatrix.LENGTH = ColorMatrix.IDENTITY_MATRIX.length; // static methods: /** * Create an instance of ColorMatrix using the Sepia preset * @returns {ColorMatrix} */ ColorMatrix.createSepiaPreset = function() { return (new ColorMatrix()).copy([ 0.4977, 0.9828, 0.1322, 0.0000, 14, 0.4977, 0.9828, 0.1322, 0.0000, -14, 0.4977, 0.9828, 0.1322, 0.0000, -47, 0.0000, 0.0000, 0.0000, 1.0000, 0, 0, 0, 0, 0, 1 ]); }; /** * Create an instance of ColorMatrix using an invert color preset * @returns {ColorMatrix} */ ColorMatrix.createInvertPreset = function() { return (new ColorMatrix()).copy([ -1.0000, 0.0000, 0.0000, 0.0000, 255, 0.0000, -1.0000, 0.0000, 0.0000, 255, 0.0000, 0.0000, -1.0000, 0.0000, 255, 0.0000, 0.0000, 0.0000, 1.0000, 0, 0, 0, 0, 0, 1 ]); }; /** * Create an instance of ColorMatrix using the Greyscale preset. * Note: -100 saturation accounts for perceived brightness, the greyscale preset treats all channels equally. * @returns {ColorMatrix} */ ColorMatrix.createGreyscalePreset = function() { return (new ColorMatrix()).copy([ 0.3333, 0.3334, 0.3333, 0.0000, 0, 0.3333, 0.3334, 0.3333, 0.0000, 0, 0.3333, 0.3334, 0.3333, 0.0000, 0, 0.0000, 0.0000, 0.0000, 1.0000, 0, 0, 0, 0, 0, 1 ]); }; //TODO: some "fun" filters // public methods: /** * Resets the instance with the specified values. * @method setColor * @param {Number} brightness * @param {Number} contrast * @param {Number} saturation * @param {Number} hue * @return {ColorMatrix} The ColorMatrix instance the method is called on (useful for chaining calls.) * @chainable */ p.setColor = function(brightness,contrast,saturation,hue) { return this.reset().adjustColor(brightness,contrast,saturation,hue); }; /** * Resets the matrix to identity values. * @method reset * @return {ColorMatrix} The ColorMatrix instance the method is called on (useful for chaining calls.) * @chainable */ p.reset = function() { return this.copy(ColorMatrix.IDENTITY_MATRIX); }; /** * Shortcut method to adjust brightness, contrast, saturation and hue. * Equivalent to calling adjustHue(hue), adjustContrast(contrast), * adjustBrightness(brightness), adjustSaturation(saturation), in that order. * @method adjustColor * @param {Number} brightness * @param {Number} contrast * @param {Number} saturation * @param {Number} hue * @return {ColorMatrix} The ColorMatrix instance the method is called on (useful for chaining calls.) * @chainable **/ p.adjustColor = function(brightness,contrast,saturation,hue) { this.adjustHue(hue); this.adjustContrast(contrast); this.adjustBrightness(brightness); return this.adjustSaturation(saturation); }; /** * Adjusts the brightness of pixel color by adding the specified value to the red, green and blue channels. * Positive values will make the image brighter, negative values will make it darker. * @method adjustBrightness * @param {Number} value A value between -255 & 255 that will be added to the RGB channels. * @return {ColorMatrix} The ColorMatrix instance the method is called on (useful for chaining calls.) * @chainable **/ p.adjustBrightness = function(value) { if (value == 0 || isNaN(value)) { return this; } value = this._cleanValue(value,255); this._multiplyMatrix([ 1,0,0,0,value, 0,1,0,0,value, 0,0,1,0,value, 0,0,0,1,0, 0,0,0,0,1 ]); return this; }; /** * Adjusts the colour offset of pixel color by adding the specified value to the red, green and blue channels. * Positive values will make the image brighter, negative values will make it darker. * @method adjustBrightness * @param {Number} r A value between -255 & 255 that will be added to the Red channel. * @param {Number} g A value between -255 & 255 that will be added to the Green channel. * @param {Number} b A value between -255 & 255 that will be added to the Blue channel. * @return {ColorMatrix} The ColorMatrix instance the method is called on (useful for chaining calls.) * @chainable **/ p.adjustOffset = function(r,g,b) { if (isNaN(r) || isNaN(g) || isNaN(b)) { return this; } this[4] = this._cleanValue(this[4] + r,255); this[9] = this._cleanValue(this[9] + g,255); this[14] = this._cleanValue(this[14] + b,255); return this; }; /** * Adjusts the contrast of pixel color. * Positive values will increase contrast, negative values will decrease contrast. * @method adjustContrast * @param {Number} value A value between -100 & 100. * @return {ColorMatrix} The ColorMatrix instance the method is called on (useful for chaining calls.) * @chainable **/ p.adjustContrast = function(value) { if (value == 0 || isNaN(value)) { return this; } value = this._cleanValue(value,100); var x; if (value<0) { x = 127+value/100*127; } else { x = value%1; if (x == 0) { x = ColorMatrix.DELTA_INDEX[value]; } else { x = ColorMatrix.DELTA_INDEX[(value<<0)]*(1-x)+ColorMatrix.DELTA_INDEX[(value<<0)+1]*x; // use linear interpolation for more granularity. } x = x*127+127; } this._multiplyMatrix([ x/127,0,0,0,0.5*(127-x), 0,x/127,0,0,0.5*(127-x), 0,0,x/127,0,0.5*(127-x), 0,0,0,1,0, 0,0,0,0,1 ]); return this; }; /** * Adjusts the color saturation of the pixel. * Positive values will increase saturation, negative values will decrease saturation (trend towards greyscale). * @method adjustSaturation * @param {Number} value A value between -100 & 100. * @return {ColorMatrix} The ColorMatrix instance the method is called on (useful for chaining calls.) * @chainable **/ p.adjustSaturation = function(value) { if (value == 0 || isNaN(value)) { return this; } value = this._cleanValue(value,100); var x = 1+((value > 0) ? 3*value/100 : value/100); var lumR = 0.3086; var lumG = 0.6094; var lumB = 0.0820; this._multiplyMatrix([ lumR*(1-x)+x,lumG*(1-x),lumB*(1-x),0,0, lumR*(1-x),lumG*(1-x)+x,lumB*(1-x),0,0, lumR*(1-x),lumG*(1-x),lumB*(1-x)+x,0,0, 0,0,0,1,0, 0,0,0,0,1 ]); return this; }; /** * Adjusts the hue of the pixel color. * @method adjustHue * @param {Number} value A value between -180 & 180. * @return {ColorMatrix} The ColorMatrix instance the method is called on (useful for chaining calls.) * @chainable **/ p.adjustHue = function(value) { if (value == 0 || isNaN(value)) { return this; } value = this._cleanValue(value,180)/180*Math.PI; var cosVal = Math.cos(value); var sinVal = Math.sin(value); var lumR = 0.213; var lumG = 0.715; var lumB = 0.072; this._multiplyMatrix([ lumR+cosVal*(1-lumR)+sinVal*(-lumR),lumG+cosVal*(-lumG)+sinVal*(-lumG),lumB+cosVal*(-lumB)+sinVal*(1-lumB),0,0, lumR+cosVal*(-lumR)+sinVal*(0.143),lumG+cosVal*(1-lumG)+sinVal*(0.140),lumB+cosVal*(-lumB)+sinVal*(-0.283),0,0, lumR+cosVal*(-lumR)+sinVal*(-(1-lumR)),lumG+cosVal*(-lumG)+sinVal*(lumG),lumB+cosVal*(1-lumB)+sinVal*(lumB),0,0, 0,0,0,1,0, 0,0,0,0,1 ]); return this; }; /** * Concatenates (multiplies) the specified matrix with this one. * @method concat * @param {Array} matrix An array or ColorMatrix instance. * @return {ColorMatrix} The ColorMatrix instance the method is called on (useful for chaining calls.) * @chainable **/ p.concat = function(matrix) { matrix = this._fixMatrix(matrix); if (matrix.length != ColorMatrix.LENGTH) { return this; } this._multiplyMatrix(matrix); return this; }; /** * Returns a clone of this ColorMatrix. * @method clone * @return {ColorMatrix} A clone of this ColorMatrix. **/ p.clone = function() { return (new ColorMatrix()).copy(this); }; /** * Return a length 25 (5x5) array instance containing this matrix's values. * @method toArray * @return {Array} An array holding this matrix's values. **/ p.toArray = function() { var arr = []; for (var i= 0, l=ColorMatrix.LENGTH; i ColorMatrix.LENGTH) { matrix = matrix.slice(0,ColorMatrix.LENGTH); } return matrix; }; createjs.ColorMatrix = ColorMatrix; }()); //############################################################################## // ColorMatrixFilter.js //############################################################################## this.createjs = this.createjs||{}; (function() { "use strict"; // constructor: /** * Allows you to carry out complex color operations such as modifying saturation, brightness, or inverting. See the * {{#crossLink "ColorMatrix"}}{{/crossLink}} for more information on changing colors. For an easier color transform, * consider the {{#crossLink "ColorFilter"}}{{/crossLink}}. * *

Example

* This example creates a red circle, inverts its hue, and then saturates it to brighten it up. * * var shape = new createjs.Shape().set({x:100,y:100}); * shape.graphics.beginFill("#ff0000").drawCircle(0,0,50); * * var matrix = new createjs.ColorMatrix().adjustHue(180).adjustSaturation(100); * shape.filters = [ * new createjs.ColorMatrixFilter(matrix) * ]; * * shape.cache(-50, -50, 100, 100); * *

Example

* This example uses a preset to generate a sepia photograph effect * * var shape = new createjs.Shape().set({x:100,y:100}); * shape.graphics.beginFill("#ff0000").drawCircle(0,0,50); * * shape.filters = [ * new createjs.ColorMatrixFilter( createjs.ColorMatrix.createSepiaPreset() ) * ]; * * shape.cache(-50, -50, 100, 100); * * See {{#crossLink "Filter"}}{{/crossLink}} for an more information on applying filters. * @class ColorMatrixFilter * @constructor * @extends Filter * @param {Array | ColorMatrix} matrix A 4x5 matrix describing the color operation to perform. See also the {{#crossLink "ColorMatrix"}}{{/crossLink}} * class. **/ function ColorMatrixFilter(matrix) { this.Filter_constructor(); // public properties: /** * A 4x5 matrix describing the color operation to perform. See also the {{#crossLink "ColorMatrix"}}{{/crossLink}} * @property matrix * @type Array | ColorMatrix **/ this.matrix = matrix; this.FRAG_SHADER_BODY = ( "uniform mat4 uColorMatrix;" + "uniform vec4 uColorMatrixOffset;" + "void main(void) {" + "vec4 color = texture2D(uSampler, vTextureCoord);" + "mat4 m = uColorMatrix;" + "vec4 newColor = vec4(" + "color.r*m[0][0] + color.g*m[0][1] + color.b*m[0][2] + color.a*m[0][3]," + "color.r*m[1][0] + color.g*m[1][1] + color.b*m[1][2] + color.a*m[1][3]," + "color.r*m[2][0] + color.g*m[2][1] + color.b*m[2][2] + color.a*m[2][3]," + "color.r*m[3][0] + color.g*m[3][1] + color.b*m[3][2] + color.a*m[3][3]" + ");" + "gl_FragColor = newColor + uColorMatrixOffset;" + "}" ); } var p = createjs.extend(ColorMatrixFilter, createjs.Filter); // TODO: deprecated // p.initialize = function() {}; // searchable for devs wondering where it is. REMOVED. See docs for details. // Docced in superclass p.shaderParamSetup = function(gl, stage, shaderProgram) { var mat = this.matrix; var colorMatrix = new Float32Array([ mat[0],mat[1],mat[2],mat[3], mat[5],mat[6],mat[7],mat[8], mat[10],mat[11],mat[12],mat[13], mat[15],mat[16],mat[17],mat[18] ]); gl.uniformMatrix4fv( gl.getUniformLocation(shaderProgram, "uColorMatrix"), false, colorMatrix ); gl.uniform4f( gl.getUniformLocation(shaderProgram, "uColorMatrixOffset"), mat[4]/255, mat[9]/255, mat[14]/255, mat[19]/255 ); }; // public methods: // Docced in superclass p.toString = function() { return "[ColorMatrixFilter]"; }; // Docced in superclass p.clone = function() { return new ColorMatrixFilter(this.matrix); }; // private methods: // Docced in superclass p._applyFilter = function(imageData) { var data = imageData.data; var l = data.length; var r,g,b,a; var mtx = this.matrix; var m0 = mtx[0], m1 = mtx[1], m2 = mtx[2], m3 = mtx[3], m4 = mtx[4]; var m5 = mtx[5], m6 = mtx[6], m7 = mtx[7], m8 = mtx[8], m9 = mtx[9]; var m10 = mtx[10], m11 = mtx[11], m12 = mtx[12], m13 = mtx[13], m14 = mtx[14]; var m15 = mtx[15], m16 = mtx[16], m17 = mtx[17], m18 = mtx[18], m19 = mtx[19]; for (var i=0; iExample * * var stage = new createjs.Stage("canvasId"); * createjs.Touch.enable(stage); * * Note: It is important to disable Touch on a stage that you are no longer using: * * createjs.Touch.disable(stage); * * @class Touch * @static **/ function Touch() { throw "Touch cannot be instantiated"; } // public static methods: /** * Returns `true` if touch is supported in the current browser. * @method isSupported * @return {Boolean} Indicates whether touch is supported in the current browser. * @static **/ Touch.isSupported = function() { return !!(('ontouchstart' in window) // iOS & Android || (window.MSPointerEvent && window.navigator.msMaxTouchPoints > 0) // IE10 || (window.PointerEvent && window.navigator.maxTouchPoints > 0)); // IE11+ }; /** * Enables touch interaction for the specified EaselJS {{#crossLink "Stage"}}{{/crossLink}}. Currently supports iOS * (and compatible browsers, such as modern Android browsers), and IE10/11. Supports both single touch and * multi-touch modes. Extends the EaselJS {{#crossLink "MouseEvent"}}{{/crossLink}} model, but without support for * double click or over/out events. See the MouseEvent {{#crossLink "MouseEvent/pointerId:property"}}{{/crossLink}} * for more information. * @method enable * @param {Stage} stage The {{#crossLink "Stage"}}{{/crossLink}} to enable touch on. * @param {Boolean} [singleTouch=false] If `true`, only a single touch will be active at a time. * @param {Boolean} [allowDefault=false] If `true`, then default gesture actions (ex. scrolling, zooming) will be * allowed when the user is interacting with the target canvas. * @return {Boolean} Returns `true` if touch was successfully enabled on the target stage. * @static **/ Touch.enable = function(stage, singleTouch, allowDefault) { if (!stage || !stage.canvas || !Touch.isSupported()) { return false; } if (stage.__touch) { return true; } // inject required properties on stage: stage.__touch = {pointers:{}, multitouch:!singleTouch, preventDefault:!allowDefault, count:0}; // note that in the future we may need to disable the standard mouse event model before adding // these to prevent duplicate calls. It doesn't seem to be an issue with iOS devices though. if ('ontouchstart' in window) { Touch._IOS_enable(stage); } else if (window.PointerEvent || window.MSPointerEvent) { Touch._IE_enable(stage); } return true; }; /** * Removes all listeners that were set up when calling `Touch.enable()` on a stage. * @method disable * @param {Stage} stage The {{#crossLink "Stage"}}{{/crossLink}} to disable touch on. * @static **/ Touch.disable = function(stage) { if (!stage) { return; } if ('ontouchstart' in window) { Touch._IOS_disable(stage); } else if (window.PointerEvent || window.MSPointerEvent) { Touch._IE_disable(stage); } delete stage.__touch; }; // Private static methods: /** * @method _IOS_enable * @protected * @param {Stage} stage * @static **/ Touch._IOS_enable = function(stage) { var canvas = stage.canvas; var f = stage.__touch.f = function(e) { Touch._IOS_handleEvent(stage,e); }; canvas.addEventListener("touchstart", f, false); canvas.addEventListener("touchmove", f, false); canvas.addEventListener("touchend", f, false); canvas.addEventListener("touchcancel", f, false); }; /** * @method _IOS_disable * @protected * @param {Stage} stage * @static **/ Touch._IOS_disable = function(stage) { var canvas = stage.canvas; if (!canvas) { return; } var f = stage.__touch.f; canvas.removeEventListener("touchstart", f, false); canvas.removeEventListener("touchmove", f, false); canvas.removeEventListener("touchend", f, false); canvas.removeEventListener("touchcancel", f, false); }; /** * @method _IOS_handleEvent * @param {Stage} stage * @param {Object} e The event to handle * @protected * @static **/ Touch._IOS_handleEvent = function(stage, e) { if (!stage) { return; } if (stage.__touch.preventDefault) { e.preventDefault&&e.preventDefault(); } var touches = e.changedTouches; var type = e.type; for (var i= 0,l=touches.length; i