@rings-webgpu/core 1.0.1 → 1.0.2

package/dist/src/components/gui/core/GUIQuad.js

@@ -0,0 +1,154 @@
+import { ImageType } from "../GUIConfig";
+import { Engine3D } from "../../../Engine3D";
+import { Matrix3 } from "../../../math/Matrix3";
+import { Color } from "../../../math/Color";
+import { PoolNode } from "../../../core/pool/ObjectPool";
+import { GUIQuadAttrEnum } from "./GUIDefine";
+let gui_help_mtx3;
+/**
+ * 图形界面最小单位
+ * @group GPU GUI
+ */
+export class GUIQuad {
+    constructor() {
+        this.x = 0;
+        this.y = 0;
+        this.z = 0;
+        this.width = 1;
+        this.height = 1;
+        this._globalX = 0;
+        this._globalY = 0;
+        this._globalWidth = 0;
+        this._globalHeight = 0;
+        this._visible = true;
+        this._offsetX = 0;
+        this._offsetY = 0;
+        this._sprite = Engine3D.res.defaultGUISprite;
+        this._color = new Color(1, 1, 1, 1);
+        this._imageType = ImageType.Simple;
+        this.dirtyAttributes = GUIQuadAttrEnum.MAX;
+        this.cacheTextureId = -1;
+    }
+    static get quadPool() {
+        this.textPool ||= new PoolNode();
+        return this.textPool;
+    }
+    static recycleQuad(quad) {
+        quad.sprite = null;
+        quad.dirtyAttributes = GUIQuadAttrEnum.MAX;
+        quad.x = 0;
+        quad.y = 0;
+        quad.z = -1;
+        quad.cacheTextureId = -1;
+        GUIQuad.quadPool.pushBack(quad);
+    }
+    static spawnQuad() {
+        let quad = GUIQuad.quadPool.getOne(GUIQuad);
+        return quad;
+    }
+    get imageType() {
+        return this._imageType;
+    }
+    set imageType(value) {
+        this._imageType = value;
+        this.setAttrChange(GUIQuadAttrEnum.SPRITE | GUIQuadAttrEnum.POSITION);
+    }
+    get color() {
+        return this._color;
+    }
+    set color(value) {
+        this._color.copyFrom(value);
+        this.setAttrChange(GUIQuadAttrEnum.COLOR);
+    }
+    get visible() {
+        return this._visible;
+    }
+    set visible(value) {
+        if (value != this._visible) {
+            this._visible = value;
+            this.setAttrChange(GUIQuadAttrEnum.SPRITE);
+        }
+    }
+    get sprite() {
+        return this._sprite;
+    }
+    set sprite(value) {
+        if (this._sprite != value) {
+            this._sprite = value;
+            this.setAttrChange(GUIQuadAttrEnum.SPRITE | GUIQuadAttrEnum.POSITION);
+        }
+    }
+    get left() {
+        return this._globalX - this._offsetX; // + this.x;
+    }
+    get right() {
+        return this.left + this._globalWidth;
+    }
+    get top() {
+        return this._globalY - this._offsetY; // + this.y;
+    }
+    get bottom() {
+        return this.top + this._globalHeight;
+    }
+    setSize(width, height) {
+        this.width = width;
+        this.height = height;
+        this.setAttrChange(GUIQuadAttrEnum.POSITION);
+    }
+    setXY(x, y) {
+        this.x = x;
+        this.y = y;
+        this.setAttrChange(GUIQuadAttrEnum.POSITION);
+    }
+    setAttrChange(attr) {
+        this.dirtyAttributes = this.dirtyAttributes | attr;
+    }
+    applyTransform(transform) {
+        this.setAttrChange(GUIQuadAttrEnum.POSITION);
+        let item = this._sprite;
+        let _worldMatrix = transform.getWorldMatrix();
+        if (this.x != 0 || this.y != 0) {
+            _worldMatrix = this.getQuadMatrix(_worldMatrix);
+        }
+        let matrixScaleX = _worldMatrix.getScaleX();
+        let matrixScaleY = _worldMatrix.getScaleY();
+        let isSliced = item.isSliced && this._imageType == ImageType.Sliced;
+        //计算trim图偏移量
+        this._offsetX = transform.width * 0.5 * matrixScaleX;
+        this._offsetY = transform.height * 0.5 * matrixScaleY;
+        if (isSliced) {
+            //去除边缘
+            this._globalWidth =
+                matrixScaleX *
+                    (transform.width - (item.offsetSize.z - item.trimSize.x));
+            this._globalHeight =
+                matrixScaleY *
+                    (transform.height - (item.offsetSize.w - item.trimSize.y));
+            this._globalX = _worldMatrix.tx + item.offsetSize.x * matrixScaleX;
+            this._globalY = _worldMatrix.ty + item.offsetSize.y * matrixScaleY;
+        }
+        else {
+            let transformScaleX = this.width / item.offsetSize.z;
+            let transformScaleY = this.height / item.offsetSize.w;
+            this._globalWidth = matrixScaleX * item.trimSize.x * transformScaleX;
+            this._globalHeight = matrixScaleY * item.trimSize.y * transformScaleY;
+            this._globalX =
+                _worldMatrix.tx + item.offsetSize.x * transformScaleX * matrixScaleX;
+            this._globalY =
+                _worldMatrix.ty + item.offsetSize.y * transformScaleY * matrixScaleY;
+        }
+        return this;
+    }
+    getQuadMatrix(world) {
+        gui_help_mtx3 ||= new Matrix3();
+        gui_help_mtx3.identity();
+        gui_help_mtx3.setTranslate(this.x, this.y);
+        gui_help_mtx3.mul(world);
+        return gui_help_mtx3;
+    }
+    writeToGeometry(guiGeometry, transform) {
+        guiGeometry.fillQuad(this, transform);
+        this.dirtyAttributes = GUIQuadAttrEnum.NONE;
+        return this;
+    }
+}

package/dist/src/components/gui/core/GUIRenderer.d.ts

@@ -0,0 +1,15 @@
+import { GeometryBase } from "../../..";
+import { View3D } from "../../../core/View3D";
+import { ClusterLightingBuffer } from "../../../gfx/renderJob/passRenderer/cluster/ClusterLightingBuffer";
+import { RendererPassState } from "../../../gfx/renderJob/passRenderer/state/RendererPassState";
+import { PassType } from "../../../gfx/renderJob/passRenderer/state/PassType";
+import { MeshRenderer } from "../../renderer/MeshRenderer";
+import { GUIGeometry } from "./GUIGeometry";
+export declare class GUIRenderer extends MeshRenderer {
+    protected _guiGeometry: GUIGeometry;
+    init(param?: any): void;
+    get geometry(): GeometryBase;
+    set geometry(value: GeometryBase);
+    nodeUpdate(view: View3D, rendererType: PassType, renderPassState: RendererPassState, clusterLightingBuffer: ClusterLightingBuffer): void;
+    onUpdate(view?: View3D): void;
+}

package/dist/src/components/gui/core/GUIRenderer.js

@@ -0,0 +1,42 @@
+import { RendererMask } from "../../../gfx/renderJob/passRenderer/state/RendererMask";
+import { MeshRenderer } from "../../renderer/MeshRenderer";
+export class GUIRenderer extends MeshRenderer {
+    init(param) {
+        super.init();
+        this.addRendererMask(RendererMask.UI);
+        this.removeRendererMask(RendererMask.Default);
+        this.castGI = false;
+        this.castShadow = false;
+        this.alwaysRender = true;
+        this._ignoreEnvMap = this._ignorePrefilterMap = true;
+    }
+    get geometry() {
+        return super.geometry;
+    }
+    set geometry(value) {
+        super.geometry = value;
+        this._guiGeometry = value;
+    }
+    nodeUpdate(view, rendererType, renderPassState, clusterLightingBuffer) {
+        for (let i = 0; i < this.materials.length; i++) {
+            const material = this.materials[i];
+            let passes = material.getPass(rendererType);
+            let vPosition = this._guiGeometry.getPositionBuffer();
+            let vSprite = this._guiGeometry.getSpriteBuffer();
+            let vColor = this._guiGeometry.getColorBuffer();
+            if (passes) {
+                for (let j = 0; j < passes.length; j++) {
+                    const renderShader = passes[j];
+                    if (!renderShader.pipeline) {
+                        renderShader.setStorageBuffer("vPositionBuffer", vPosition);
+                        renderShader.setStorageBuffer("vSpriteBuffer", vSprite);
+                        renderShader.setStorageBuffer("vColorBuffer", vColor);
+                    }
+                }
+            }
+        }
+        super.nodeUpdate(view, rendererType, renderPassState, clusterLightingBuffer);
+    }
+    // todo
+    onUpdate(view) { }
+}

package/dist/src/components/gui/core/GUIShader.d.ts

@@ -0,0 +1,8 @@
+export declare class GUIShader {
+    private static bindTextureArray;
+    private static sampleTexture;
+    private static readonly fs;
+    private static readonly GUI_common_vs;
+    static readonly GUI_shader_view: string;
+    static readonly GUI_shader_world: string;
+}

package/dist/src/components/gui/core/GUIShader.js

@@ -0,0 +1,267 @@
+import { GlobalUniform } from "../../../assets/shader/core/common/GlobalUniform";
+import { WorldMatrixUniform } from "../../../assets/shader/core/common/WorldMatrixUniform";
+import { FragmentOutput } from "../../../assets/shader/core/struct/FragmentOutput";
+export class GUIShader {
+    static bindTextureArray() {
+        let value = ``;
+        for (let i = 0; i < 7; i++) {
+            value += `
+        @group(1) @binding(auto)
+        var tex_${i}Sampler: sampler;
+        @group(1) @binding(auto)
+#if VideoTexture${i}
+        var tex_${i}: texture_external;
+#else
+        var tex_${i}: texture_2d<f32>;
+#endif
+`;
+        }
+        return value;
+    }
+    static sampleTexture(index) {
+        return `
+#if VideoTexture${index}
+            let size = textureDimensions(tex_${index}).xy - 1;
+            uv.y = 1.0 - uv.y;
+            let iuv = vec2<i32>(uv * vec2<f32>(size));
+            color = textureLoad(tex_${index}, iuv) ;
+#else
+            color = textureSampleLevel(tex_${index}, tex_${index}Sampler, uv, 0.0);
+#endif        `;
+    }
+    static { this.fs = `
+        ${FragmentOutput}
+        ${this.bindTextureArray()}
+        var<private> fragmentOutput: FragmentOutput;
+        var<private> uvSlice: vec2<f32>;
+        var<private> EPSILON: f32 = 0.001;
+
+        fn sliceBorder(uv:f32, scale:f32, border:vec2<f32>) -> f32 
+        {
+            var s = uv * scale;
+            if(s > border.x){
+                s -= border.x;
+                let centerPartMax = scale - border.x - border.y;
+                let centerPartMin = 1.0 - border.x - border.y;
+                if(s < centerPartMax){
+                    s = border.x + (s / centerPartMax) * centerPartMin;
+                }else{
+                    s = s - centerPartMax + border.x + centerPartMin;
+                };
+            }
+            return s;
+        }
+
+        fn isInsideAlpha(coord:vec2<f32>, rect:vec4<f32>, cornerRadius0:f32, fadeOutSize0:f32) -> f32
+        {
+            var minX = min(rect.x, rect.z);
+            var maxX = max(rect.x, rect.z);
+            var minY = min(rect.y, rect.w);
+            var maxY = max(rect.y, rect.w);
+            var cornerRadius = max(EPSILON, cornerRadius0);
+            var center = vec2<f32>(minX + maxX, minY + maxY) * 0.5;
+            var extents = vec2<f32>(maxX - minX, maxY - minY) * 0.5;
+
+            cornerRadius = min(extents.x, cornerRadius);
+            cornerRadius = min(extents.y, cornerRadius);
+            
+            var extendsMin = max(vec2<f32>(0.0), extents - cornerRadius);
+            
+            var toCenter = abs(coord - center);
+            var outerDist = toCenter - extents;
+            var innerDist = toCenter - extendsMin;
+            
+            if(innerDist.x <= 0 && innerDist.y <= 0){
+                return 1.0;
+            }else if(outerDist.x <= 0 && outerDist.y <= 0){
+                var fadeOutPercent = clamp(fadeOutSize0, EPSILON, cornerRadius) / cornerRadius;
+                innerDist = max(vec2(EPSILON), innerDist);
+                var distance = min(cornerRadius, length(innerDist));
+                var alpha = 1.0 - distance / cornerRadius;
+                alpha /= fadeOutPercent;
+                alpha = clamp(alpha, 0.0, 1.0);
+                return alpha;
+            }
+            return 0.0;
+        }
+
+        @fragment
+        fn FragMain(@location(auto) vUV: vec2<f32>, @location(auto) vColor4: vec4<f32>, @location(auto) vLocalPos: vec2<f32>, @location(auto) vUvRec: vec4<f32>,
+            @location(auto) vUvBorder: vec4<f32>, @location(auto) vUvSlice: vec2<f32>, @location(auto) vTextureID: f32, @builtin(front_facing) face: bool,
+            @builtin(position) fragCoord : vec4<f32>) -> FragmentOutput {
+                var scissorAlpha = 1.0;
+                #if SCISSOR_ENABLE
+                            scissorAlpha = isInsideAlpha(
+                                vLocalPos.xy,
+                                materialUniform.scissorRect,
+                                materialUniform.scissorCornerRadius,
+                                materialUniform.scissorFadeOutSize);
+
+                            if(scissorAlpha < EPSILON){
+                                discard;
+                            }
+                #endif
+
+                uvSlice = vUvSlice;
+            
+                var uv:vec2<f32> = vUV;
+                if(uvSlice.x > 1.0){ uv.x = sliceBorder(uv.x, uvSlice.x, vUvBorder.xz);}
+                if(uvSlice.y > 1.0){ uv.y = sliceBorder(uv.y, uvSlice.y, vUvBorder.yw);}
+                uv = uv * vUvRec.zw + vUvRec.xy;
+                var color = vec4<f32>(0.0,0.0,0.0,1.0);
+                let texId = i32(vTextureID + 0.5);
+                var texSize = vec2<i32>(0);
+                var coord = vec2<i32>(0);
+                
+                if(texId == 0){
+                    ${this.sampleTexture(0)}
+                }else if(texId == 1){
+                    ${this.sampleTexture(1)}
+                }else if(texId == 2){
+                    ${this.sampleTexture(2)}
+                }else if(texId == 3){            
+                    ${this.sampleTexture(3)}
+                }else if(texId == 4){            
+                    ${this.sampleTexture(4)}
+                }else if(texId == 5){            
+                    ${this.sampleTexture(5)}
+                }else if(texId == 6){            
+                    ${this.sampleTexture(6)}
+                }
+                var rgb = color.rgb;
+                var alpha = color.a;
+
+                rgb *= vColor4.rgb;
+                alpha *= vColor4.a;
+                alpha *= scissorAlpha;
+                if(color.a < EPSILON)
+                { 
+                    discard;
+                }
+
+                fragmentOutput.color = vec4<f32>(rgb, alpha);
+                return fragmentOutput;
+            }
+  `; }
+    static { this.GUI_common_vs = `
+        ${WorldMatrixUniform}
+        ${GlobalUniform}
+
+        struct VertexSpriteBuffer {
+            vUvRec: vec4<f32>,
+            vUvBorder: vec4<f32>,
+            vUvSlice: vec2<f32>,
+            vTextureID: f32,
+            vVisible: f32
+        }
+                
+        struct MaterialUniform{
+            scissorRect:vec4<f32>,
+            screenSize:vec2<f32>,
+            scissorCornerRadius:f32,
+            scissorFadeOutSize:f32,
+            pixelRatio:f32,
+            v3:vec3<f32>
+        }
+        
+        struct VertexOutput {
+            @location(auto) vUV: vec2<f32>,
+            @location(auto) vColor4: vec4<f32>,
+            @location(auto) vLocalPos: vec2<f32>,
+            @location(auto) vUvRec: vec4<f32>,
+            @location(auto) vUvBorder: vec4<f32>,
+            @location(auto) vUvSlice: vec2<f32>,
+            @location(auto) vTextureID: f32,
+            
+            @builtin(position) member: vec4<f32>
+        };
+        
+         struct VertexInput{
+            @builtin(instance_index) index : u32,
+            @location(auto) uv: vec2<f32>,
+            @location(auto) vIndex: f32,
+        }
+
+        @group(2) @binding(0) var<uniform> materialUniform : MaterialUniform;
+        @group(3) @binding(1) var<storage, read> vPositionBuffer: array<vec4<f32>>;
+        @group(3) @binding(2) var<storage, read> vSpriteBuffer: array<VertexSpriteBuffer>;
+        @group(3) @binding(3) var<storage, read> vColorBuffer: array<vec4<f32>>;
+
+        var<private> vertexOut: VertexOutput;
+
+        fn getVertexXY(quad:vec4<f32>, index:u32) -> vec2<f32>
+        {
+            var ret = vec2<f32>(0.0);
+            if(index == 0 || index == 3){
+                ret.x = quad.x;
+            }else{
+                ret.x = quad.z;
+            };
+            if(index == 0 || index == 1){
+                ret.y = quad.w;
+            }else{
+                ret.y = quad.y;
+            };
+            return ret;
+        }
+    `; }
+    static { this.GUI_shader_view = `
+        ${this.GUI_common_vs}
+
+        @vertex
+        fn VertMain( vertex:VertexInput ) -> VertexOutput {
+            var _m = models.matrix[0];
+            var _n = globalUniform.frame;
+            let vertexIndex = vertex.vIndex;
+            let quadIndex = u32(vertex.vIndex * 0.25);
+            let vertexPosition = getVertexXY(vPositionBuffer[quadIndex], u32(vertexIndex) % 4u);
+            var vSpriteData = vSpriteBuffer[quadIndex];
+            var op = vec2<f32>(0.0001);
+            let isValidVertex = vSpriteData.vVisible > 0.5;
+            if(isValidVertex){
+                op = 2.0 * vertexPosition * materialUniform.pixelRatio  / materialUniform.screenSize;
+            }
+
+            vertexOut.vLocalPos = vertexPosition;
+            vertexOut.member = vec4<f32>(op.x, op.y, vertexIndex * 0.0001, 1.0);
+            vertexOut.vUV = vec2<f32>(vertex.uv);
+            vertexOut.vUvRec = vSpriteData.vUvRec;
+            vertexOut.vUvBorder = vSpriteData.vUvBorder;
+            vertexOut.vUvSlice = vSpriteData.vUvSlice;
+            vertexOut.vTextureID = vSpriteData.vTextureID;
+            vertexOut.vColor4 = vColorBuffer[quadIndex];
+            return vertexOut;
+         }
+         
+         ${this.fs}
+        `; }
+    static { this.GUI_shader_world = `
+        ${this.GUI_common_vs}
+        @vertex
+        fn VertMain( vertex:VertexInput ) -> VertexOutput {
+            var modelMatrix = models.matrix[vertex.index];
+            let vertexIndex = vertex.vIndex;
+            let quadIndex = u32(vertex.vIndex * 0.25);
+            let vertexPosition = getVertexXY(vPositionBuffer[quadIndex], u32(vertexIndex) % 4u);
+            var localPos = vec4<f32>(vertexPosition.xy, vertexIndex * 0.0001, 1.0) ;
+            var op = vec4<f32>(0.0001);
+            var vSpriteData = vSpriteBuffer[quadIndex];
+
+            let isValidVertex = vSpriteData.vVisible > 0.5;
+            if(isValidVertex){
+                op = globalUniform.projMat * globalUniform.viewMat * modelMatrix * localPos ;
+            }
+            vertexOut.vLocalPos = vertexPosition;
+            vertexOut.member = op;
+            vertexOut.vUV = vec2<f32>(vertex.uv);
+            vertexOut.vUvRec = vSpriteData.vUvRec;
+            vertexOut.vUvBorder = vSpriteData.vUvBorder;
+            vertexOut.vUvSlice = vSpriteData.vUvSlice;
+            vertexOut.vTextureID = vSpriteData.vTextureID;
+            vertexOut.vColor4 = vColorBuffer[quadIndex];
+            return vertexOut;
+         }
+         
+         ${this.fs}
+        `; }
+}

package/dist/src/components/gui/core/GUISprite.d.ts

@@ -0,0 +1,19 @@
+import { Vector2 } from "../../../math/Vector2";
+import { Vector4 } from "../../../math/Vector4";
+import { GUITexture } from "./GUITexture";
+export declare class GUISprite {
+    id: string;
+    guiTexture: GUITexture;
+    uvRec: Vector4;
+    uvBorder: Vector4;
+    offsetSize: Vector4;
+    borderSize: Vector4;
+    trimSize: Vector2;
+    isSliced: boolean;
+    height: number;
+    width: number;
+    xadvance: number;
+    xoffset: number;
+    yoffset: number;
+    constructor(texture?: GUITexture);
+}

package/dist/src/components/gui/core/GUISprite.js

@@ -0,0 +1,19 @@
+import { Engine3D } from "../../../Engine3D";
+import { Vector2 } from "../../../math/Vector2";
+import { Vector4 } from "../../../math/Vector4";
+export class GUISprite {
+    constructor(texture) {
+        this.uvRec = new Vector4(0, 0, 1, 1);
+        this.uvBorder = new Vector4(0, 0, 0, 0);
+        this.offsetSize = new Vector4(0, 0, 4, 4);
+        this.borderSize = new Vector4(0, 0, 0, 0);
+        this.trimSize = new Vector2();
+        this.isSliced = false;
+        this.height = 4;
+        this.width = 4;
+        this.xadvance = 0;
+        this.xoffset = 0;
+        this.yoffset = 0;
+        this.guiTexture = texture || Engine3D.res.defaultGUITexture;
+    }
+}

package/dist/src/components/gui/core/GUITexture.d.ts

@@ -0,0 +1,12 @@
+import { Texture } from "../../../gfx/graphics/webGpu/core/texture/Texture";
+export declare class GUITexture {
+    private static _maxUid;
+    private readonly _staticId;
+    dynamicId: number;
+    texture: Texture;
+    width: number;
+    height: number;
+    get staticId(): number;
+    constructor(texture: Texture);
+    private init;
+}

package/dist/src/components/gui/core/GUITexture.js

@@ -0,0 +1,25 @@
+import { Engine3D } from "../../../Engine3D";
+export class GUITexture {
+    static { this._maxUid = -1; }
+    get staticId() {
+        return this._staticId;
+    }
+    constructor(texture) {
+        this._staticId = -1;
+        this.dynamicId = -1;
+        this.width = 1;
+        this.height = 1;
+        texture ||= Engine3D.res.whiteTexture;
+        texture.addressModeU = "clamp-to-edge";
+        texture.addressModeV = "clamp-to-edge";
+        this.texture = texture;
+        GUITexture._maxUid++;
+        this._staticId = GUITexture._maxUid;
+        this.init();
+    }
+    init() {
+        this.dynamicId = -1;
+        this.width = this.texture.width;
+        this.height = this.texture.height;
+    }
+}

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

@@ -0,0 +1,25 @@
+import { Object3D } from "../../../core/entities/Object3D";
+import { Ray } from "../../../math/Ray";
+import { Vector2 } from "../../../math/Vector2";
+import { Vector3 } from "../../../math/Vector3";
+export declare enum UIInteractiveStyle {
+    NORMAL = 0,
+    DOWN = 1,
+    OVER = 2,
+    DISABLE = 3
+}
+export type GUIHitInfo = {
+    intersectPoint?: Vector3;
+    distance: number;
+    collider?: IUIInteractive;
+};
+export interface IUIInteractive {
+    interactive: boolean;
+    enable: boolean;
+    visible: boolean;
+    object3D?: Object3D;
+    get interactiveVisible(): boolean;
+    rayPick(ray: Ray, panel: any, screenPos: Vector2, screenSize: Vector2): GUIHitInfo;
+    destroy(): void;
+    set mouseStyle(value: UIInteractiveStyle);
+}

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

@@ -0,0 +1,7 @@
+export var UIInteractiveStyle;
+(function (UIInteractiveStyle) {
+    UIInteractiveStyle[UIInteractiveStyle["NORMAL"] = 0] = "NORMAL";
+    UIInteractiveStyle[UIInteractiveStyle["DOWN"] = 1] = "DOWN";
+    UIInteractiveStyle[UIInteractiveStyle["OVER"] = 2] = "OVER";
+    UIInteractiveStyle[UIInteractiveStyle["DISABLE"] = 3] = "DISABLE";
+})(UIInteractiveStyle || (UIInteractiveStyle = {}));

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

@@ -0,0 +1,34 @@
+import { GUIQuad } from "../core/GUIQuad";
+import { UITextField } from "./UITextField";
+export declare enum TextAnchor {
+    UpperLeft = 0,
+    UpperCenter = 1,
+    UpperRight = 2,
+    MiddleLeft = 3,
+    MiddleCenter = 4,
+    MiddleRight = 5,
+    LowerLeft = 6,
+    LowerCenter = 7,
+    LowerRight = 8
+}
+export declare enum Vertical {
+    Upper = 0,
+    Middle = 1,
+    Lower = 2
+}
+export declare enum Horizontal {
+    Left = 0,
+    Center = 1,
+    Right = 2
+}
+export declare class TextFieldLine {
+    charList: string[];
+    quadList: GUIQuad[];
+    width: number;
+    index: number;
+}
+export declare class TextFieldLayout {
+    layout(target: UITextField): TextFieldLine[];
+    private makeTextLine;
+    private getAlignment;
+}