const Vector = require('engine/Vector');
const { removeItems } = require('engine/utils/array');
const Node = require('../Node');
const Sprite = require('../sprites/Sprite');
/**
* A BitmapText object will create a line or multiple lines of text using bitmap font. To
* split a line you can use '\n', '\r' or '\r\n' in your string. You can generate the fnt files using:
*
* A BitmapText can only be created when the font is loaded
*
* ```js
* // in this case the font is in a file called 'desyrel.fnt'
* var bitmapText = new BitmapText({
* text: "text using a fancy font!",
* font: "35px Desyrel",
* align: "right",
* });
* ```
*
* http://www.angelcode.com/products/bmfont/ for windows or
* http://www.bmglyph.com/ for mac.
*
* @class
* @extends Node
* @param text {string} The copy that you would like the text to display
* @param style {object} The style parameters
* @param style.font {string|object} The font descriptor for the object, can be passed as a string of form
* "24px FontName" or "FontName" or as an object with explicit name/size properties.
* @param [style.font.name] {string} The bitmap font id
* @param [style.font.size] {number} The size of the font in pixels, e.g. 24
* @param [style.align='left'] {string} Alignment for multiline text ('left', 'center' or 'right'), does not affect
* single line text
* @param [style.tint=0xFFFFFF] {number} The tint color
*/
class BitmapText extends Node {
constructor(text, style = {}) {
super();
/**
* The width of the overall text, different from fontSize,
* which is defined in the style object
*
* @member {number}
* @readOnly
*/
this.textWidth = 0;
/**
* The height of the overall text, different from fontSize,
* which is defined in the style object
*
* @member {number}
* @readOnly
*/
this.textHeight = 0;
/**
* Private tracker for the letter sprite pool.
*
* @member {Sprite[]}
* @private
*/
this._glyphs = [];
/**
* Private tracker for the current style.
*
* @member {object}
* @private
*/
this._font = {
tint: style.tint !== undefined ? style.tint : 0xFFFFFF,
align: style.align || 'left',
name: null,
size: 0,
};
/**
* Private tracker for the current font.
*
* @member {object}
* @private
*/
this.font = style.font; // run font setter
/**
* Private tracker for the current text.
*
* @member {string}
* @private
*/
this._text = text;
/**
* The max width of this bitmap text in pixels. If the text provided is longer than the value provided, line breaks will be automatically inserted in the last whitespace.
* Disable by setting value to 0
*
* @member {number}
*/
this.maxWidth = 0;
/**
* The max line height. This is useful when trying to use the total height of the Text, ie: when trying to vertically align.
*
* @member {number}
*/
this.maxLineHeight = 0;
/**
* The dirty state of this object.
*
* @member {boolean}
*/
this.dirty = false;
this.updateText();
}
/**
* Renders text and updates it when needed
*
* @private
*/
updateText() {
var data = BitmapText.fonts[this._font.name];
var pos = Vector.create();
var prevCharCode = null;
var chars = [];
var lastLineWidth = 0;
var maxLineWidth = 0;
var lineWidths = [];
var line = 0;
var scale = this._font.size / data.size;
var lastSpace = -1;
var maxLineHeight = 0;
for (var i = 0; i < this.text.length; i++) {
var charCode = this.text.charCodeAt(i);
lastSpace = /(\s)/.test(this.text.charAt(i)) ? i : lastSpace;
if (/(?:\r\n|\r|\n)/.test(this.text.charAt(i))) {
lineWidths.push(lastLineWidth);
maxLineWidth = Math.max(maxLineWidth, lastLineWidth);
line++;
pos.x = 0;
pos.y += data.lineHeight;
prevCharCode = null;
continue;
}
if (lastSpace !== -1 && this.maxWidth > 0 && pos.x * scale > this.maxWidth) {
removeItems(chars, lastSpace, i - lastSpace);
i = lastSpace;
lastSpace = -1;
lineWidths.push(lastLineWidth);
maxLineWidth = Math.max(maxLineWidth, lastLineWidth);
line++;
pos.x = 0;
pos.y += data.lineHeight;
prevCharCode = null;
continue;
}
var charData = data.chars[charCode];
if (!charData) {
continue;
}
if (prevCharCode && charData.kerning[prevCharCode]) {
pos.x += charData.kerning[prevCharCode];
}
chars.push({ texture:charData.texture, line: line, charCode: charCode, position: Vector.create(pos.x + charData.xOffset, pos.y + charData.yOffset) });
lastLineWidth = pos.x + (charData.texture.width + charData.xOffset);
pos.x += charData.xAdvance;
maxLineHeight = Math.max(maxLineHeight, (charData.yOffset + charData.texture.height));
prevCharCode = charCode;
}
lineWidths.push(lastLineWidth);
maxLineWidth = Math.max(maxLineWidth, lastLineWidth);
var lineAlignOffsets = [];
for (i = 0; i <= line; i++) {
var alignOffset = 0;
if (this._font.align === 'right') {
alignOffset = maxLineWidth - lineWidths[i];
}
else if (this._font.align === 'center') {
alignOffset = (maxLineWidth - lineWidths[i]) / 2;
}
lineAlignOffsets.push(alignOffset);
}
var lenChars = chars.length;
var tint = this.tint;
for (i = 0; i < lenChars; i++) {
var c = this._glyphs[i]; // get the next glyph sprite
if (c) {
c.texture = chars[i].texture;
}
else {
c = new Sprite(chars[i].texture);
this._glyphs.push(c);
}
c.position.x = (chars[i].position.x + lineAlignOffsets[chars[i].line]) * scale;
c.position.y = chars[i].position.y * scale;
c.scale.x = c.scale.y = scale;
c.tint = tint;
if (!c.parent) {
this.addChild(c);
}
}
// remove unnecessary children.
for (i = lenChars; i < this._glyphs.length; ++i) {
this.removeChild(this._glyphs[i]);
}
this.textWidth = maxLineWidth * scale;
this.textHeight = (pos.y + data.lineHeight) * scale;
this.maxLineHeight = maxLineHeight * scale;
}
/**
* Updates the transform of this object
*
* @private
*/
updateTransform() {
this.validate();
this.containerUpdateTransform();
}
/**
* Validates text before calling parent's getLocalBounds
*
* @return {Rectangle} The rectangular bounding area
*/
getLocalBounds() {
this.validate();
return super.getLocalBounds();
}
/**
* Updates text when needed
*
* @private
*/
validate() {
if (this.dirty) {
this.updateText();
this.dirty = false;
}
}
}
Object.defineProperties(BitmapText.prototype, {
/**
* The tint of the BitmapText object
*
* @member {number}
* @memberof extras.BitmapText#
*/
tint: {
get: function() {
return this._font.tint;
},
set: function(value) {
this._font.tint = (typeof value === 'number' && value >= 0) ? value : 0xFFFFFF;
this.dirty = true;
},
},
/**
* The alignment of the BitmapText object
*
* @member {string}
* @default 'left'
* @memberof extras.BitmapText#
*/
align: {
get: function() {
return this._font.align;
},
set: function(value) {
this._font.align = value || 'left';
this.dirty = true;
},
},
/**
* The font descriptor of the BitmapText object
*
* @member {Font}
* @memberof extras.BitmapText#
*/
font: {
get: function() {
return this._font;
},
set: function(value) {
if (!value) {
return;
}
if (typeof value === 'string') {
value = value.split(' ');
this._font.name = value.length === 1 ? value[0] : value.slice(1).join(' ');
this._font.size = value.length >= 2 ? parseInt(value[0], 10) : BitmapText.fonts[this._font.name].size;
}
else {
this._font.name = value.name;
this._font.size = typeof value.size === 'number' ? value.size : parseInt(value.size, 10);
}
this.dirty = true;
},
},
/**
* The text of the BitmapText object
*
* @member {string}
* @memberof extras.BitmapText#
*/
text: {
get: function() {
return this._text;
},
set: function(value) {
value = value.toString() || ' ';
if (this._text === value) {
return;
}
this._text = value;
this.dirty = true;
},
},
});
BitmapText.fonts = {};
module.exports = BitmapText;