@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/components/gui/uiComponents/UIImageGroup.js

@@ -0,0 +1,87 @@
+import { GUIQuad } from "../core/GUIQuad";
+import { Engine3D } from "../../../Engine3D";
+import { UIRenderAble } from "./UIRenderAble";
+import { Vector2 } from "../../../math/Vector2";
+/**
+ * images/sprites/videos
+ * @group GPU GUI
+ */
+export class UIImageGroup extends UIRenderAble {
+    constructor() {
+        super();
+        this._count = 0;
+    }
+    init(param) {
+        super.init?.(param);
+        this._count = param ? param.count : 1;
+        for (let i = 0; i < this._count; i++) {
+            this.attachQuad(GUIQuad.spawnQuad());
+        }
+        this._uiTransform.resize(0, 0);
+    }
+    getQuad(index) {
+        return this._mainQuads[index];
+    }
+    cloneTo(obj) {
+        let component = obj.addComponent(UIImageGroup, { count: this._count });
+        component.copyComponent(this);
+    }
+    copyComponent(from) {
+        super.copyComponent(from);
+        for (let i = 0; i < from._count; i++) {
+            this.setSprite(i, from.getSprite(i));
+            this.setColor(i, from.getColor(i));
+            this.setImageType(i, from.getImageType(i));
+        }
+        return this;
+    }
+    setSprite(index, value) {
+        this._mainQuads[index].sprite = value || Engine3D.res.defaultGUISprite;
+        this.setShadowDirty();
+    }
+    getSprite(index) {
+        return this._mainQuads[index].sprite;
+    }
+    onUIComponentVisible(visible) {
+        this.applyComponentVisible();
+    }
+    onUITransformVisible(visible) {
+        this.applyComponentVisible();
+    }
+    applyComponentVisible() {
+        let isHidden = !this._visible || !this._uiTransform.globalVisible;
+        for (let item of this._mainQuads) {
+            item.visible = !isHidden;
+        }
+        this.setShadowDirty();
+    }
+    getColor(index) {
+        return this._mainQuads[index].color;
+    }
+    setColor(index, value) {
+        this._mainQuads[index].color = value;
+        this.setShadowDirty();
+    }
+    getImageType(index) {
+        return this._mainQuads[index].imageType;
+    }
+    setImageType(index, value) {
+        this._mainQuads[index].imageType = value;
+        this.setShadowDirty();
+    }
+    setSize(index, width, height) {
+        this._mainQuads[index].setSize(width, height);
+        this.setShadowDirty();
+    }
+    setXY(index, x, y) {
+        this._mainQuads[index].setXY(x, y);
+        this.setShadowDirty();
+    }
+    getXY(index, ret) {
+        ret ||= new Vector2();
+        let quad = this._mainQuads[index];
+        ret.x = quad.x;
+        ret.y = quad.y;
+        return ret;
+    }
+}

package/dist/src/components/gui/uiComponents/UIInteractive.d.ts

@@ -0,0 +1,25 @@
+import { UIComponentBase } from "./UIComponentBase";
+import { IUIInteractive, UIInteractiveStyle, GUIHitInfo } from "./IUIInteractive";
+import { Vector2 } from "../../../math/Vector2";
+import { Ray } from "../../../math/Ray";
+import { Object3D } from "../../../core/entities/Object3D";
+import { UIPanel } from "./UIPanel";
+/**
+ * 基本交互能力
+ * @group GPU GUI
+ */
+export declare class UIInteractive extends UIComponentBase implements IUIInteractive {
+    protected _style: UIInteractiveStyle;
+    protected _interactive: boolean;
+    set interactive(value: boolean);
+    get interactive(): boolean;
+    /**设置鼠标悬停时的样式 */
+    set mouseStyle(value: UIInteractiveStyle);
+    /**判断组件是否可见且可交互 */
+    get interactiveVisible(): boolean;
+    init(param?: any): void;
+    destroy(): void;
+    rayPick(ray: Ray, panel: UIPanel, screenPos: Vector2, screenSize: Vector2): GUIHitInfo;
+    cloneTo(obj: Object3D): void;
+    copyComponent(from: this): this;
+}

package/dist/src/components/gui/uiComponents/UIInteractive.js

@@ -0,0 +1,50 @@
+import { UIComponentBase } from "./UIComponentBase";
+import { UIInteractiveStyle, } from "./IUIInteractive";
+import { GUIPickHelper } from "../GUIPickHelper";
+/**
+ * 基本交互能力
+ * @group GPU GUI
+ */
+export class UIInteractive extends UIComponentBase {
+    constructor() {
+        super(...arguments);
+        this._style = UIInteractiveStyle.NORMAL;
+        this._interactive = false; // 设置是否可交互
+    }
+    set interactive(value) {
+        this._interactive = value;
+    }
+    get interactive() {
+        return this._interactive;
+    }
+    /**设置鼠标悬停时的样式 */
+    set mouseStyle(value) {
+        this._style = value;
+    }
+    /**判断组件是否可见且可交互 */
+    get interactiveVisible() {
+        return this._uiTransform.globalVisible && this._visible;
+    }
+    init(param) {
+        super.init(param);
+        this._uiTransform.addUIInteractive(this);
+    }
+    destroy() {
+        this._uiTransform.removeUIInteractive(this);
+        super.destroy();
+    }
+    rayPick(ray, panel, screenPos, screenSize) {
+        return GUIPickHelper.rayPick(ray, screenPos, screenSize, panel.space, panel.panelRatio, this._uiTransform, panel.transform.worldMatrix);
+    }
+    cloneTo(obj) {
+        let component = obj.getOrAddComponent(UIInteractive);
+        component.copyComponent(this);
+    }
+    copyComponent(from) {
+        super.copyComponent(from);
+        this.enable = from._enable;
+        this.interactive = from._interactive;
+        this.mouseStyle = from._style;
+        return this;
+    }
+}

package/dist/src/components/gui/uiComponents/UIPanel.d.ts

@@ -0,0 +1,38 @@
+import { View3D } from "../../../core/View3D";
+import { Object3D } from "../../../core/entities/Object3D";
+import { BillboardComponent } from "../../BillboardComponent";
+import { BillboardType } from "../GUIConfig";
+import { GUIGeometry } from "../core/GUIGeometry";
+import { GUIRenderer } from "../core/GUIRenderer";
+import { UIImage } from "./UIImage";
+export declare class UIPanel extends UIImage {
+    readonly space: number;
+    needUpdateGeometry: boolean;
+    panelOrder: number;
+    needSortOnCameraZ?: boolean;
+    protected _billboard: BillboardComponent;
+    private _rebuild;
+    scissorEnable: boolean;
+    scissorCornerRadius: number;
+    scissorFadeOutSize: number;
+    protected _uiRenderer: GUIRenderer;
+    protected _geometry: GUIGeometry;
+    protected _maxCount: number;
+    panelRatio: number;
+    readonly isUIPanel = true;
+    cloneTo(obj: Object3D): void;
+    copyComponent(from: this): this;
+    init(param?: any): void;
+    updateDrawCallSegment(index: number, indexStart: number, indexCount: number): void;
+    private create;
+    get quadMaxCount(): number;
+    get renderer(): GUIRenderer;
+    set billboard(type: BillboardType);
+    get billboard(): BillboardType;
+    set cullMode(value: GPUCullMode);
+    get cullMode(): GPUCullMode;
+    onUpdate(view?: View3D): void;
+    private _collectTransform;
+    private rebuildGUIMesh;
+    private updateGUIPixelRatio;
+}

package/dist/src/components/gui/uiComponents/UIPanel.js

@@ -0,0 +1,173 @@
+import { BoundingBox, Vector3 } from "../../..";
+import { webGPUContext } from "../../../gfx/graphics/webGpu/Context3D";
+import { BillboardComponent } from "../../BillboardComponent";
+import { BillboardType, GUIConfig, GUISpace } from "../GUIConfig";
+import { GUICanvas } from "../core/GUICanvas";
+import { GUIGeometry } from "../core/GUIGeometry";
+import { GUIGeometryRebuild } from "../core/GUIGeometryRebuild";
+import { GUIMaterial } from "../core/GUIMaterial";
+import { GUIRenderer } from "../core/GUIRenderer";
+import { UIImage } from "./UIImage";
+import { UITransform } from "./UITransform";
+export class UIPanel extends UIImage {
+    constructor() {
+        super(...arguments);
+        this.space = GUISpace.World;
+        this.needUpdateGeometry = true;
+        this.panelOrder = 0;
+        this.scissorEnable = false;
+        this.scissorCornerRadius = 0;
+        this.scissorFadeOutSize = 0;
+        this._maxCount = 128;
+        this.panelRatio = 1;
+        this.isUIPanel = true;
+        this._collectTransform = [];
+    }
+    cloneTo(obj) {
+        let component = obj.getOrAddComponent(UIPanel);
+        component.copyComponent(this);
+    }
+    copyComponent(from) {
+        super.copyComponent(from);
+        this.panelOrder = from.panelOrder;
+        this.needSortOnCameraZ = from.needSortOnCameraZ;
+        this.cullMode = from.cullMode;
+        this.billboard = from.billboard;
+        //scissor
+        this.scissorEnable = from.scissorEnable;
+        this.scissorCornerRadius = from.scissorCornerRadius;
+        this.scissorFadeOutSize = from.scissorFadeOutSize;
+        return this;
+    }
+    init(param) {
+        super.init(param);
+        this._uiTransform.resize(webGPUContext.canvas.width, webGPUContext.canvas.height);
+        this.create(this.space);
+        this.visible = false;
+    }
+    updateDrawCallSegment(index, indexStart, indexCount) {
+        this._geometry.updateSubGeometry(index, indexStart, indexCount);
+        let firstMaterial = this._uiRenderer.material;
+        let newMaterial = this._uiRenderer.materials[index];
+        if (!newMaterial) {
+            newMaterial = new GUIMaterial(this.space);
+            let newMaterials = this._uiRenderer.materials.slice();
+            newMaterials.push(newMaterial);
+            this._uiRenderer.materials = newMaterials;
+            newMaterial.cullMode = firstMaterial.cullMode;
+            newMaterial.depthCompare = firstMaterial.depthCompare;
+        }
+    }
+    create(space) {
+        this._maxCount =
+            this.space == GUISpace.World
+                ? GUIConfig.quadMaxCountForWorld
+                : GUIConfig.quadMaxCountForView;
+        this._uiRenderer = this.object3D.addComponent(GUIRenderer);
+        this._geometry = this._uiRenderer.geometry = new GUIGeometry(this._maxCount).create();
+        this._uiRenderer.material = new GUIMaterial(space);
+        this._uiRenderer.renderOrder = GUIConfig.SortOrderStartWorld;
+        this._rebuild = new GUIGeometryRebuild();
+        this.object3D.bound = new BoundingBox(new Vector3(), new Vector3(1, 1, 1).multiplyScalar(Number.MAX_VALUE * 0.1));
+    }
+    get quadMaxCount() {
+        return this._maxCount;
+    }
+    get renderer() {
+        return this._uiRenderer;
+    }
+    set billboard(type) {
+        if (this.space == GUISpace.View) {
+            type = BillboardType.None;
+            console.warn("Cannot enable billboard in view space");
+        }
+        if (type == BillboardType.BillboardXYZ ||
+            type == BillboardType.BillboardY) {
+            this._billboard = this.object3D.getOrAddComponent(BillboardComponent);
+            this._billboard.type = type;
+        }
+        else {
+            this.object3D.removeComponent(BillboardComponent);
+            this._billboard = null;
+        }
+    }
+    get billboard() {
+        return this._billboard ? this._billboard.type : BillboardType.None;
+    }
+    set cullMode(value) {
+        if (this.space == GUISpace.World) {
+            for (let item of this._uiRenderer.materials) {
+                item.cullMode = value;
+            }
+        }
+        else {
+            console.warn("Cannot change cullMode in view space");
+        }
+    }
+    get cullMode() {
+        return this._uiRenderer.material.cullMode;
+    }
+    onUpdate(view) {
+        super.onUpdate?.(view);
+        this.rebuildGUIMesh(view);
+    }
+    rebuildGUIMesh(view) {
+        let panel = this;
+        let transforms = panel._collectTransform;
+        transforms.length = 0;
+        panel.object3D.getComponents(UITransform, transforms);
+        if (transforms.length > 0) {
+            panel._rebuild.build(transforms, panel, panel.needUpdateGeometry);
+            for (const t of transforms) {
+                t.needUpdateQuads = false;
+            }
+        }
+        //calc render order
+        let canvas = panel.object3D.getComponentFromParent(GUICanvas);
+        let canvasIndex = canvas ? canvas.index : 0;
+        panel._uiRenderer.enable = transforms.length > 0;
+        let renderStart = panel["isViewPanel"]
+            ? GUIConfig.SortOrderStartView
+            : GUIConfig.SortOrderStartWorld;
+        panel._uiRenderer.renderOrder =
+            canvasIndex * GUIConfig.SortOrderCanvasSpan +
+                renderStart +
+                panel.panelOrder;
+        panel._uiRenderer.needSortOnCameraZ = panel.needSortOnCameraZ;
+        //update material
+        if (this.space == GUISpace.View) {
+            let sW = webGPUContext.canvas.clientWidth;
+            let sH = webGPUContext.canvas.clientHeight;
+            let pW = this._uiTransform.width;
+            let pH = this._uiTransform.height;
+            this.panelRatio = this.updateGUIPixelRatio(sW, sH, pW, pH);
+        }
+        else {
+            this.panelRatio = 1;
+        }
+        for (let item of panel["_uiRenderer"].materials) {
+            let material = item;
+            material.setPanelRatio(this.panelRatio);
+            material.setScreenSize(webGPUContext.canvas.clientWidth, webGPUContext.canvas.clientHeight);
+            material.setScissorEnable(panel.scissorEnable);
+            if (panel.scissorEnable) {
+                let maskQuad = panel.mainQuads[0];
+                material.setScissorRect(maskQuad.left, maskQuad.bottom, maskQuad.right, maskQuad.top);
+                material.setScissorCorner(panel.scissorCornerRadius, panel.scissorFadeOutSize);
+            }
+        }
+        panel.needUpdateGeometry = false;
+    }
+    updateGUIPixelRatio(sW, sH, pW, pH) {
+        let xyRatioSolution = pW / pH;
+        let xyRatioCurrent = sW / sH;
+        let panelRatio = 1;
+        if (xyRatioSolution < xyRatioCurrent) {
+            panelRatio = sH / pH;
+        }
+        else {
+            panelRatio = sW / pW;
+        }
+        return panelRatio;
+    }
+}

package/dist/src/components/gui/uiComponents/UIRenderAble.d.ts

@@ -0,0 +1,27 @@
+import { UIComponentBase } from "./UIComponentBase";
+import { GUIQuad } from "../core/GUIQuad";
+/**
+ * The basic class of render able GUI component
+ * @group GPU GUI
+ */
+export declare class UIRenderAble extends UIComponentBase {
+    protected _mainQuads: GUIQuad[];
+    protected _shadowRender: UIRenderAble;
+    protected _shadowSource: UIRenderAble;
+    isUIShadow?: boolean;
+    isShadowless?: boolean;
+    needUpdateShadow: boolean;
+    init(param?: any): void;
+    destroy(): void;
+    start(): void;
+    protected setShadowDirty(): void;
+    get mainQuads(): GUIQuad[];
+    setShadowRenderer(value: UIRenderAble): void;
+    setShadowSource(value: UIRenderAble): void;
+    getShadowRender(): UIRenderAble;
+    protected autoBindShadow(source: UIRenderAble, shadow: UIRenderAble): boolean;
+    protected recycleQuad(quad?: GUIQuad): GUIQuad;
+    protected attachQuad(quad: GUIQuad): this;
+    protected detachQuads(): this;
+    copyComponent(from: this): this;
+}

package/dist/src/components/gui/uiComponents/UIRenderAble.js

@@ -0,0 +1,106 @@
+import { UIComponentBase } from "./UIComponentBase";
+import { GUIQuad } from "../core/GUIQuad";
+/**
+ * The basic class of render able GUI component
+ * @group GPU GUI
+ */
+export class UIRenderAble extends UIComponentBase {
+    init(param) {
+        super.init?.(param);
+        this._mainQuads = [];
+    }
+    destroy() {
+        this.detachQuads();
+        this._shadowRender?.setShadowSource(null);
+        this._shadowSource?.setShadowRenderer(null);
+        super.destroy();
+        this._shadowRender = null;
+        this._shadowSource = null;
+    }
+    start() {
+        super.start?.();
+        if (this.isUIShadow) {
+            this.autoBindShadow(null, this);
+        }
+        else if (!this.isShadowless) {
+            this.autoBindShadow(this, null);
+        }
+        this.setShadowDirty();
+    }
+    setShadowDirty() {
+        this._shadowRender && (this._shadowRender.needUpdateShadow = true);
+    }
+    get mainQuads() {
+        return this._mainQuads;
+    }
+    setShadowRenderer(value) {
+        this._shadowRender = value;
+    }
+    setShadowSource(value) {
+        this._shadowSource = value;
+    }
+    getShadowRender() {
+        return this._shadowRender;
+    }
+    autoBindShadow(source, shadow) {
+        let values = this.object3D.components.values();
+        if (!source) {
+            for (let i of values) {
+                let item = i;
+                if (item.isShadowless || item.isUIShadow)
+                    continue;
+                if (item.mainQuads) {
+                    source = item;
+                    break;
+                }
+            }
+        }
+        if (!shadow) {
+            for (let i of values) {
+                let item = i;
+                if (item.isUIShadow && item.mainQuads) {
+                    shadow = item;
+                    break;
+                }
+            }
+        }
+        if (source && shadow) {
+            source.setShadowRenderer(shadow);
+            shadow.setShadowSource(source);
+            return true;
+        }
+        return false;
+    }
+    recycleQuad(quad) {
+        if (quad && this._mainQuads) {
+            let index = this._mainQuads.indexOf(quad);
+            if (index >= 0) {
+                this._mainQuads.splice(index, 1);
+                GUIQuad.recycleQuad(quad);
+            }
+            else {
+                quad = null;
+            }
+        }
+        return quad;
+    }
+    attachQuad(quad) {
+        this._mainQuads && this._mainQuads.push(quad);
+        return this;
+    }
+    detachQuads() {
+        if (this._mainQuads) {
+            while (this._mainQuads.length > 0) {
+                let quad = this._mainQuads.shift();
+                this.recycleQuad(quad);
+            }
+        }
+        return this;
+    }
+    copyComponent(from) {
+        super.copyComponent(from);
+        this.isUIShadow = from.isUIShadow;
+        this.isShadowless = from.isShadowless;
+        return this;
+    }
+}

package/dist/src/components/gui/uiComponents/UIShadow.d.ts

@@ -0,0 +1,31 @@
+import { View3D } from "../../../core/View3D";
+import { Object3D } from "../../../core/entities/Object3D";
+import { Color } from "../../../math/Color";
+import { Vector2 } from "../../../math/Vector2";
+import { UIRenderAble } from "./UIRenderAble";
+/**
+ * 阴影
+ * @group GPU GUI
+ */
+export declare class UIShadow extends UIRenderAble {
+    private _shadowQuality;
+    private _shadowOffset;
+    private _shadowRadius;
+    private _shadowColor;
+    private _subShadowColor;
+    needUpdateShadow: boolean;
+    init(param?: any): void;
+    cloneTo(obj: Object3D): void;
+    copyComponent(from: this): this;
+    get shadowColor(): Color;
+    set shadowColor(value: Color);
+    set shadowQuality(value: number);
+    get shadowQuality(): number;
+    set shadowOffset(value: Vector2);
+    get shadowOffset(): Vector2;
+    set shadowRadius(value: number);
+    get shadowRadius(): number;
+    onUpdate(view?: View3D): void;
+    private applyShadow;
+    private createQuadShadow;
+}

package/dist/src/components/gui/uiComponents/UIShadow.js

@@ -0,0 +1,117 @@
+import { Color } from "../../../math/Color";
+import { clamp } from "../../../math/MathUtil";
+import { Vector2 } from "../../../math/Vector2";
+import { GUIQuad } from "../core/GUIQuad";
+import { UIRenderAble } from "./UIRenderAble";
+/**
+ * 阴影
+ * @group GPU GUI
+ */
+export class UIShadow extends UIRenderAble {
+    constructor() {
+        super(...arguments);
+        this._shadowQuality = 1;
+        this.needUpdateShadow = false;
+    }
+    init(param) {
+        super.init?.(param);
+        this._shadowRadius = 2;
+        this._shadowQuality = 1;
+        this._shadowOffset = new Vector2(4, -4);
+        this._shadowColor = new Color(0.1, 0.1, 0.1, 0.8);
+        this._subShadowColor = this._shadowColor.clone();
+        this.isUIShadow = true;
+    }
+    cloneTo(obj) {
+        let component = obj.getOrAddComponent(UIShadow);
+        component.copyComponent(this);
+    }
+    copyComponent(from) {
+        super.copyComponent(this);
+        this._shadowColor = from._shadowColor;
+        this._shadowOffset = from._shadowOffset;
+        this._shadowRadius = from._shadowRadius;
+        this._shadowQuality = from.shadowQuality;
+        return this;
+    }
+    get shadowColor() {
+        return this._shadowColor;
+    }
+    set shadowColor(value) {
+        this._shadowColor.copyFrom(value);
+        this.needUpdateShadow = true;
+    }
+    set shadowQuality(value) {
+        value = clamp(value, 0, 4);
+        if (this._shadowQuality != value) {
+            this._shadowQuality = value;
+            this.needUpdateShadow = true;
+        }
+    }
+    get shadowQuality() {
+        return this._shadowQuality;
+    }
+    set shadowOffset(value) {
+        this._shadowOffset = value;
+        this.needUpdateShadow = true;
+    }
+    get shadowOffset() {
+        this._shadowOffset ||= new Vector2(4, -4);
+        return this._shadowOffset;
+    }
+    set shadowRadius(value) {
+        if (this._shadowRadius != value) {
+            this._shadowRadius = value;
+            this.applyShadow();
+        }
+    }
+    get shadowRadius() {
+        return this._shadowRadius;
+    }
+    onUpdate(view) {
+        if (this.needUpdateShadow) {
+            this.applyShadow();
+            this.needUpdateShadow = false;
+        }
+    }
+    applyShadow() {
+        this.detachQuads();
+        if (this._shadowSource) {
+            if (this._shadowQuality > 0) {
+                let quads = this._shadowSource.mainQuads;
+                if (quads.length > 0) {
+                    for (let quad of quads) {
+                        this.createQuadShadow(quad);
+                    }
+                }
+            }
+        }
+        this._uiTransform.setNeedUpdateUIPanel();
+    }
+    createQuadShadow(sourceQuad) {
+        let shadowCount = this._shadowQuality;
+        let pi2 = Math.PI * 2;
+        this._subShadowColor.copyFrom(this._shadowColor);
+        this._subShadowColor.a = 1 / Math.max(1, shadowCount);
+        for (let i = 0; i < shadowCount; i++) {
+            let item = GUIQuad.spawnQuad();
+            let offsetX = 0;
+            let offsetY = 0;
+            if (i == 0) {
+                item.color = this._shadowColor;
+            }
+            else {
+                let angle = (pi2 * (i - 1)) / (shadowCount - 1);
+                offsetX = Math.sin(angle) * this._shadowRadius;
+                offsetY = Math.cos(angle) * this._shadowRadius;
+                item.color = this._subShadowColor;
+            }
+            item.setXY(offsetX + this._shadowOffset.x + sourceQuad.x, offsetY + this._shadowOffset.y + sourceQuad.y);
+            item.setSize(sourceQuad.width, sourceQuad.height);
+            item.sprite = sourceQuad.sprite;
+            item.visible = sourceQuad.visible;
+            item.imageType = sourceQuad.imageType;
+            this.attachQuad(item);
+        }
+    }
+}

package/dist/src/components/gui/uiComponents/UITextField.d.ts

@@ -0,0 +1,36 @@
+import { Object3D } from "../../../core/entities/Object3D";
+import { Color } from "../../../math/Color";
+import { UIRenderAble } from "./UIRenderAble";
+import { TextAnchor } from "./TextFieldLayout";
+export declare class UITextField extends UIRenderAble {
+    private _font;
+    private _fontSize;
+    private _originSize;
+    private _alignment;
+    private _lineSpacing;
+    private _text;
+    private readonly _color;
+    constructor();
+    cloneTo(obj: Object3D): void;
+    copyComponent(from: this): this;
+    get originSize(): number;
+    get font(): string;
+    set font(value: string);
+    get fontSize(): number;
+    set fontSize(value: number);
+    get text(): string;
+    set text(value: string);
+    private textLine;
+    private layoutProxy;
+    private layoutText;
+    protected onUIComponentVisible(visible: boolean): void;
+    protected onUITransformVisible(visible: boolean): void;
+    private applyComponentVisible;
+    protected onTransformResize(): void;
+    get color(): Color;
+    set color(value: Color);
+    get alignment(): TextAnchor;
+    set alignment(value: TextAnchor);
+    get lineSpacing(): number;
+    set lineSpacing(value: number);
+}