'use strict';
exports.__esModule = true;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _utils = require('../utils');
var _math = require('../math');
var _const = require('../const');
var _settings = require('../settings');
var _settings2 = _interopRequireDefault(_settings);
var _Container = require('../display/Container');
var _Container2 = _interopRequireDefault(_Container);
var _RenderTexture = require('../textures/RenderTexture');
var _RenderTexture2 = _interopRequireDefault(_RenderTexture);
var _eventemitter = require('eventemitter3');
var _eventemitter2 = _interopRequireDefault(_eventemitter);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var tempMatrix = new _math.Matrix();
var RESOLUTION = _settings2.default.RESOLUTION,
RENDER_OPTIONS = _settings2.default.RENDER_OPTIONS;
/**
* The SystemRenderer is the base for a Pixi Renderer. It is extended by the {@link PIXI.CanvasRenderer}
* and {@link PIXI.WebGLRenderer} which can be used for rendering a Pixi scene.
*
* @abstract
* @class
* @extends EventEmitter
* @memberof PIXI
*/
var SystemRenderer = function (_EventEmitter) {
_inherits(SystemRenderer, _EventEmitter);
/**
* @param {string} system - The name of the system this renderer is for.
* @param {number} [width=800] - the width of the canvas view
* @param {number} [height=600] - the height of the canvas view
* @param {object} [options] - The optional renderer parameters
* @param {HTMLCanvasElement} [options.view] - the canvas to use as a view, optional
* @param {boolean} [options.transparent=false] - If the render view is transparent, default false
* @param {boolean} [options.autoResize=false] - If the render view is automatically resized, default false
* @param {boolean} [options.antialias=false] - sets antialias (only applicable in chrome at the moment)
* @param {number} [options.resolution=1] - The resolution / device pixel ratio of the renderer. The
* resolution of the renderer retina would be 2.
* @param {boolean} [options.clearBeforeRender=true] - This sets if the CanvasRenderer will clear the canvas or
* not before the new render pass.
* @param {number} [options.backgroundColor=0x000000] - The background color of the rendered area
* (shown if not transparent).
* @param {boolean} [options.roundPixels=false] - If true Pixi will Math.floor() x/y values when rendering,
* stopping pixel interpolation.
*/
function SystemRenderer(system, width, height, options) {
_classCallCheck(this, SystemRenderer);
var _this = _possibleConstructorReturn(this, _EventEmitter.call(this));
(0, _utils.sayHello)(system);
// prepare options
if (options) {
for (var i in RENDER_OPTIONS) {
if (typeof options[i] === 'undefined') {
options[i] = RENDER_OPTIONS[i];
}
}
} else {
options = RENDER_OPTIONS;
}
/**
* The type of the renderer.
*
* @member {number}
* @default PIXI.RENDERER_TYPE.UNKNOWN
* @see PIXI.RENDERER_TYPE
*/
_this.type = _const.RENDERER_TYPE.UNKNOWN;
/**
* The width of the canvas view
*
* @member {number}
* @default 800
*/
_this.width = width || 800;
/**
* The height of the canvas view
*
* @member {number}
* @default 600
*/
_this.height = height || 600;
/**
* The canvas element that everything is drawn to
*
* @member {HTMLCanvasElement}
*/
_this.view = options.view || document.createElement('canvas');
/**
* The resolution / device pixel ratio of the renderer
*
* @member {number}
* @default 1
*/
_this.resolution = options.resolution || RESOLUTION;
/**
* Whether the render view is transparent
*
* @member {boolean}
*/
_this.transparent = options.transparent;
/**
* Whether the render view should be resized automatically
*
* @member {boolean}
*/
_this.autoResize = options.autoResize || false;
/**
* Tracks the blend modes useful for this renderer.
*
* @member {object<string, mixed>}
*/
_this.blendModes = null;
/**
* The value of the preserveDrawingBuffer flag affects whether or not the contents of
* the stencil buffer is retained after rendering.
*
* @member {boolean}
*/
_this.preserveDrawingBuffer = options.preserveDrawingBuffer;
/**
* This sets if the CanvasRenderer will clear the canvas or not before the new render pass.
* If the scene is NOT transparent Pixi will use a canvas sized fillRect operation every
* frame to set the canvas background color. If the scene is transparent Pixi will use clearRect
* to clear the canvas every frame. Disable this by setting this to false. For example if
* your game has a canvas filling background image you often don't need this set.
*
* @member {boolean}
* @default
*/
_this.clearBeforeRender = options.clearBeforeRender;
/**
* If true Pixi will Math.floor() x/y values when rendering, stopping pixel interpolation.
* Handy for crisp pixel art and speed on legacy devices.
*
* @member {boolean}
*/
_this.roundPixels = options.roundPixels;
/**
* The background color as a number.
*
* @member {number}
* @private
*/
_this._backgroundColor = 0x000000;
/**
* The background color as an [R, G, B] array.
*
* @member {number[]}
* @private
*/
_this._backgroundColorRgba = [0, 0, 0, 0];
/**
* The background color as a string.
*
* @member {string}
* @private
*/
_this._backgroundColorString = '#000000';
_this.backgroundColor = options.backgroundColor || _this._backgroundColor; // run bg color setter
/**
* This temporary display object used as the parent of the currently being rendered item
*
* @member {PIXI.DisplayObject}
* @private
*/
_this._tempDisplayObjectParent = new _Container2.default();
/**
* The last root object that the renderer tried to render.
*
* @member {PIXI.DisplayObject}
* @private
*/
_this._lastObjectRendered = _this._tempDisplayObjectParent;
return _this;
}
/**
* Resizes the canvas view to the specified width and height
*
* @param {number} width - the new width of the canvas view
* @param {number} height - the new height of the canvas view
*/
SystemRenderer.prototype.resize = function resize(width, height) {
this.width = width * this.resolution;
this.height = height * this.resolution;
this.view.width = this.width;
this.view.height = this.height;
if (this.autoResize) {
this.view.style.width = this.width / this.resolution + 'px';
this.view.style.height = this.height / this.resolution + 'px';
}
};
/**
* Useful function that returns a texture of the display object that can then be used to create sprites
* This can be quite useful if your displayObject is complicated and needs to be reused multiple times.
*
* @param {PIXI.DisplayObject} displayObject - The displayObject the object will be generated from
* @param {number} scaleMode - Should be one of the scaleMode consts
* @param {number} resolution - The resolution / device pixel ratio of the texture being generated
* @return {PIXI.Texture} a texture of the graphics object
*/
SystemRenderer.prototype.generateTexture = function generateTexture(displayObject, scaleMode, resolution) {
var bounds = displayObject.getLocalBounds();
var renderTexture = _RenderTexture2.default.create(bounds.width | 0, bounds.height | 0, scaleMode, resolution);
tempMatrix.tx = -bounds.x;
tempMatrix.ty = -bounds.y;
this.render(displayObject, renderTexture, false, tempMatrix, true);
return renderTexture;
};
/**
* Removes everything from the renderer and optionally removes the Canvas DOM element.
*
* @param {boolean} [removeView=false] - Removes the Canvas element from the DOM.
*/
SystemRenderer.prototype.destroy = function destroy(removeView) {
if (removeView && this.view.parentNode) {
this.view.parentNode.removeChild(this.view);
}
this.type = _const.RENDERER_TYPE.UNKNOWN;
this.width = 0;
this.height = 0;
this.view = null;
this.resolution = 0;
this.transparent = false;
this.autoResize = false;
this.blendModes = null;
this.preserveDrawingBuffer = false;
this.clearBeforeRender = false;
this.roundPixels = false;
this._backgroundColor = 0;
this._backgroundColorRgba = null;
this._backgroundColorString = null;
this.backgroundColor = 0;
this._tempDisplayObjectParent = null;
this._lastObjectRendered = null;
};
/**
* The background color to fill if not transparent
*
* @member {number}
* @memberof PIXI.SystemRenderer#
*/
_createClass(SystemRenderer, [{
key: 'backgroundColor',
get: function get() {
return this._backgroundColor;
}
/**
* Sets the background color.
*
* @param {number} value - The value to set to.
*/
,
set: function set(value) {
this._backgroundColor = value;
this._backgroundColorString = (0, _utils.hex2string)(value);
(0, _utils.hex2rgb)(value, this._backgroundColorRgba);
}
}]);
return SystemRenderer;
}(_eventemitter2.default);
exports.default = SystemRenderer;
//# sourceMappingURL=SystemRenderer.js.map
