mxdraw 0.1.1 → 0.1.4

package/dist/lib/MxModule/MxDbLine/MxDbLine.js

@@ -0,0 +1,94 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+///////////////////////////////////////////////////////////////////////////////
+//版权所有（C）2002-2022，成都梦想凯德科技有限公司。
+//本软件代码及其文档和相关资料归成都梦想凯德科技有限公司,应用包含本软件的程序必须包括以下版权声明
+//此应用程序与成都梦想凯德科技有限公司成协议。通过使用本软件、其文档或相关材料
+///////////////////////////////////////////////////////////////////////////////
+/** @module MxDbLine*/
+var THREE = require("three");
+var MxDbEntity_1 = require("../MxDbEntity");
+/**
+ * MxDbLine 直线对象.
+ */
+var MxDbLine = /** @class */ (function (_super) {
+    __extends(MxDbLine, _super);
+    function MxDbLine() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        // pt1,pt2
+        _this.pt1 = new THREE.Vector3();
+        _this.pt2 = new THREE.Vector3();
+        return _this;
+    }
+    MxDbLine.prototype.getTypeName = function () {
+        return 'MxDbLine';
+    };
+    MxDbLine.prototype.worldDraw = function (pWorldDraw) {
+        pWorldDraw.drawLine(this.pt1, this.pt2);
+    };
+    MxDbLine.prototype.setPoint1 = function (pt1) {
+        this.pt1 = pt1;
+    };
+    MxDbLine.prototype.getPoint1 = function () {
+        return this.pt1;
+    };
+    MxDbLine.prototype.setPoint2 = function (pt2) {
+        this.pt2 = pt2;
+    };
+    MxDbLine.prototype.getPoint2 = function () {
+        return this.pt2;
+    };
+    MxDbLine.prototype.getGripPoints = function () {
+        var ret = [];
+        ret.push(this.pt1);
+        ret.push(this.pt2);
+        var midPoint = new THREE.Vector3(this.pt1.x + (this.pt2.x - this.pt1.x) * 0.5, this.pt1.y + (this.pt2.y - this.pt1.y) * 0.5, 0);
+        ret.push(midPoint);
+        return ret;
+    };
+    MxDbLine.prototype.moveGripPointsAt = function (index, offset) {
+        if (index == 0) {
+            this.pt1.add(offset);
+        }
+        else if (index == 1) {
+            this.pt2.add(offset);
+        }
+        else if (index == 2) {
+            this.pt1.add(offset);
+            this.pt2.add(offset);
+        }
+        return true;
+    };
+    MxDbLine.prototype.dwgIn = function (obj) {
+        this.onDwgIn(obj);
+        this.pt1.copy(obj['pt1']);
+        this.pt2.copy(obj['pt2']);
+        return true;
+    };
+    MxDbLine.prototype.dwgOut = function (obj) {
+        this.onDwgOut(obj);
+        obj['pt1'] = this.pt1;
+        obj['pt2'] = this.pt2;
+        return obj;
+    };
+    MxDbLine.prototype.create = function () {
+        return new MxDbLine();
+    };
+    return MxDbLine;
+}(MxDbEntity_1.default));
+exports.default = MxDbLine;

package/dist/lib/MxModule/MxDbLine/index.js

@@ -0,0 +1,5 @@
+"use strict";
+/** @module McEdGetPointWorldDrawObject*/
+Object.defineProperty(exports, "__esModule", { value: true });
+var MxDbLine_1 = require("./MxDbLine");
+exports.default = MxDbLine_1.default;

package/dist/lib/MxModule/MxDbRect/MxDbRect.js

@@ -0,0 +1,219 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var MxDbEntity_1 = require("../MxDbEntity");
+var three_1 = require("three");
+var index_1 = require("../../tools/three/index");
+var MxFun_1 = require("../MxFun");
+/**
+ * MxRectEntity 矩形对象.
+ */
+var MxDbRect = /** @class */ (function (_super) {
+    __extends(MxDbRect, _super);
+    function MxDbRect() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        /**
+         * pt1: 构成矩形的第一个点
+         * */
+        _this.pt1 = new three_1.Vector3();
+        /**
+         * pt1: 构成矩形的第二个点(对角点)
+         * */
+        _this.pt2 = new three_1.Vector3();
+        /**
+         * width: 在绘制时自动计算矩形像素宽度 单位px
+         * */
+        _this.width = 0;
+        /**
+         * height: 在绘制时自动计算矩形像素高度 单位px
+         * */
+        _this.height = 0;
+        /**
+         * cornerRadius(优先级大于radius属性): 圆角的半径  如[3, 2, 1, 4]分别对应左上角圆角半径3  右上角2  右下角1 左下角4
+         * */
+        _this.cornerRadius = [];
+        /**
+         * transparent 开启透明度
+         * */
+        _this.transparent = true;
+        /**
+         * opacity 设置透明度 0 ~ 1
+         * */
+        _this.opacity = 1;
+        /**
+         * visible 该矩形对象是否可见
+         * */
+        _this.visible = true;
+        return _this;
+    }
+    MxDbRect.prototype.worldDraw = function (pWorldDraw) {
+        var _this = this;
+        //    根据第一个点和对角点 计算矩形的四个点位
+        var points = (0, index_1.computeRectPoints)(this.pt1, this.pt2);
+        // 计算圆角顶点坐标
+        if (this.cornerRadius.length <= 0 && this.radius) {
+            this.cornerRadius = [
+                MxFun_1.default.screenCoordLong2Doc(this.radius),
+                MxFun_1.default.screenCoordLong2Doc(this.radius),
+                MxFun_1.default.screenCoordLong2Doc(this.radius),
+                MxFun_1.default.screenCoordLong2Doc(this.radius)
+            ];
+        }
+        if (this.cornerRadius.length > 0) {
+            points = (0, index_1.getToGenerateRoundedCorners)(points, this.cornerRadius);
+        }
+        var geometry;
+        var material;
+        var line = new three_1.Object3D();
+        // 公共的material参数
+        var materialParam = {
+            transparent: this.transparent,
+            opacity: this.opacity,
+            visible: this.visible
+        };
+        // 如果是填充模式
+        if (this.fillColor || this.fillImageSrc) {
+            // 三维坐标转二位坐标
+            points = points.map(function (_a) {
+                var x = _a.x, y = _a.y;
+                return new three_1.Vector2(x, y);
+            });
+            // 计算矩形宽高
+            geometry = new three_1.ShapeGeometry(new three_1.Shape(points));
+            geometry.computeBoundingBox();
+            var size = new three_1.Vector3();
+            geometry.boundingBox.getSize(size);
+            this.width = MxFun_1.default.docCoord2Screen(size.x).x;
+            this.height = MxFun_1.default.docCoord2Screen(size.y).x;
+            // 如果是图片填充
+            if (this.fillImageSrc) {
+                var imgSrc = this.fillImageSrc;
+                MxFun_1.default.loadImageMaterial(imgSrc, function (mate) {
+                    if (!mate)
+                        return;
+                    material = mate;
+                    geometry = new three_1.ShapeGeometry(new three_1.Shape(points));
+                    // 修复集合体的uv坐标
+                    geometry = (0, index_1.repairGeometryFaceVertexUvs)(geometry);
+                    // 纹理属性设置
+                    var map = mate.map;
+                    if (_this.fillImageParam) {
+                        if (_this.fillImageParam.center)
+                            map.center = _this.fillImageParam.center;
+                        if (_this.fillImageParam.offset)
+                            map.offset = _this.fillImageParam.offset;
+                        if (_this.fillImageParam.repeat)
+                            map.repeat = _this.fillImageParam.repeat;
+                        if (_this.fillImageParam.rotation)
+                            map.rotation = _this.fillImageParam.rotation;
+                    }
+                    // 有滤镜对象使用自定义着色器
+                    if (_this.filter) {
+                        var data = _this.filter._getFilterShaderData(map);
+                        material = new three_1.ShaderMaterial(__assign(__assign({}, data), materialParam));
+                    }
+                    // 设置材质属性
+                    material.depthTest = false;
+                    material.transparent = _this.transparent;
+                    material.opacity = _this.opacity;
+                    material.visible = _this.visible;
+                    line = new three_1.Mesh(geometry, material);
+                    pWorldDraw.drawEntity(line);
+                });
+                return;
+            }
+            else {
+                //   颜色填充
+                material = new three_1.MeshBasicMaterial(__assign({ color: this.filter
+                        ? this.filter._getFilterColor(this.fillColor, this.opacity)
+                        : new three_1.Color(this.fillColor) }, materialParam));
+                line = new three_1.Mesh(geometry, material);
+            }
+        }
+        else {
+            // 线框模式
+            geometry = new three_1.BufferGeometry().setFromPoints(points);
+            material = new three_1.LineBasicMaterial(__assign({ color: this.getColor() }, materialParam));
+            line = new three_1.LineLoop(geometry, material);
+        }
+        pWorldDraw.drawEntity(line);
+    };
+    MxDbRect.prototype.getGripPoints = function () {
+        var ret = [];
+        ret.push(this.pt1);
+        var lineMath = new three_1.Line3(this.pt1, this.pt2);
+        var corePt = new three_1.Vector3();
+        lineMath.getCenter(corePt);
+        ret.push(corePt);
+        ret.push(this.pt2);
+        return ret;
+    };
+    MxDbRect.prototype.moveGripPointsAt = function (index, offset) {
+        if (index == 0) {
+            this.pt1.add(offset);
+        }
+        else if (index == 1) {
+            this.pt1.add(offset);
+            this.pt2.add(offset);
+        }
+        else if (index == 2) {
+            this.pt2.add(offset);
+        }
+        return true;
+    };
+    MxDbRect.prototype.dwgIn = function (obj) {
+        this.onDwgIn(obj);
+        this.pt1.copy(obj['pt1']);
+        this.pt2.copy(obj['pt2']);
+        this.cornerRadius = obj['cornerRadius'];
+        this.radius = obj['radius'];
+        this.filter = obj['filter'];
+        return true;
+    };
+    MxDbRect.prototype.dwgOut = function (obj) {
+        this.onDwgOut(obj);
+        obj['pt1'] = this.pt1;
+        obj['pt2'] = this.pt2;
+        obj['cornerRadius'] = this.cornerRadius;
+        obj['radius'] = this.radius;
+        obj['filter'] = this.filter;
+        return obj;
+    };
+    MxDbRect.prototype.create = function () {
+        return new MxDbRect();
+    };
+    MxDbRect.prototype.transformBy = function (mat) {
+        this.pt1.applyMatrix4(mat);
+        this.pt2.applyMatrix4(mat);
+    };
+    MxDbRect.prototype.getTypeName = function () {
+        return 'MxRectEntity';
+    };
+    return MxDbRect;
+}(MxDbEntity_1.default));
+exports.default = MxDbRect;

package/dist/lib/MxModule/MxDbRect/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var MxDbRect_1 = require("./MxDbRect");
+exports.default = MxDbRect_1.default;

package/dist/lib/MxModule/MxDbSVG/MxDbSVG.js

@@ -0,0 +1,208 @@
+"use strict";
+///////////////////////////////////////////////////////////////////////////////
+//版权所有（C）2002-2022，成都梦想凯德科技有限公司。
+//本软件代码及其文档和相关资料归成都梦想凯德科技有限公司,应用包含本软件的程序必须包括以下版权声明
+//此应用程序与成都梦想凯德科技有限公司成协议。通过使用本软件、其文档或相关材料
+///////////////////////////////////////////////////////////////////////////////
+/** @module MxDbSVG*/
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var THREE = require("three");
+var MxDbEntity_1 = require("../MxDbEntity");
+var MxFun_1 = require("../MxFun");
+var MxThreeJS_1 = require("../MxThreeJS");
+var MxType_1 = require("../MxType");
+/**
+ * MxDbSVG SVG对象.
+ */
+var MxDbSVG = /** @class */ (function (_super) {
+    __extends(MxDbSVG, _super);
+    function MxDbSVG() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.svgPos = new THREE.Vector3();
+        _this.svgPath = '';
+        _this.svgSize = new THREE.Vector2(50, 50);
+        _this.svgAlignmentRatio = new THREE.Vector2(0, 0);
+        _this.isSvgDirtyLocation = false;
+        _this.isLoadFromPath = true;
+        _this.txtPos = new THREE.Vector3();
+        _this.txt = '';
+        _this.txtHeight = 1;
+        return _this;
+    }
+    MxDbSVG.prototype.worldDraw = function (pWorldDraw) {
+        this.calcSvgPosition();
+        if (this.txt.length > 0) {
+            var posTxt = new THREE.Vector3(this.txtPos.x, this.txtPos.y, 0);
+            pWorldDraw.drawText(this.txt, this.txtHeight, 0, posTxt);
+        }
+        var svgPosX = this.svgPos.x - this.svgSize.x * this.svgAlignmentRatio.x;
+        var svgPosY = this.svgPos.y - this.svgSize.y * this.svgAlignmentRatio.y;
+        var pt1 = new THREE.Vector3(svgPosX, svgPosY, 0);
+        var pt2 = new THREE.Vector3(svgPosX + this.svgSize.x, svgPosY + this.svgSize.y, 0);
+        if (pWorldDraw.getType() == 1) {
+            if (this.svg) {
+                pWorldDraw.drawEntity(this.svg);
+            }
+            else {
+                if (this.svgPath.length > 0 && this.isLoadFromPath) {
+                    var myThis_1 = this;
+                    MxThreeJS_1.default.loadSVG(this.svgPath, undefined, function (obj) {
+                        if (obj) {
+                            var box = new THREE.Box3().setFromObject(obj);
+                            obj.scale.x = myThis_1.svgSize.x / (box.max.x - box.min.x);
+                            obj.scale.y = myThis_1.svgSize.y / (box.max.y - box.min.y);
+                            obj.scale.z = obj.scale.x;
+                            myThis_1.isSvgDirtyLocation = true;
+                            obj.traverse(function (child) {
+                                if (child.material) {
+                                    child.material.transparent = true;
+                                }
+                            });
+                            //this.svgPos.multiply
+                            myThis_1.svg = obj;
+                            myThis_1.setNeedUpdateDisplay(true);
+                            MxFun_1.default.updateDisplay();
+                        }
+                        myThis_1.isLoadFromPath = false;
+                    });
+                }
+            }
+            pWorldDraw.drawSelectLine(pt1.x, pt1.y, pt2.x, pt2.y);
+            pWorldDraw.drawSelectLine(pt1.x, pt2.y, pt2.x, pt1.y);
+        }
+        else {
+            pWorldDraw.drawLine(pt1.x, pt1.y, pt1.x, pt2.y);
+            pWorldDraw.drawLine(pt1.x, pt2.y, pt2.x, pt2.y);
+            pWorldDraw.drawLine(pt2.x, pt2.y, pt2.x, pt1.y);
+            pWorldDraw.drawLine(pt2.x, pt1.y, pt1.x, pt1.y);
+        }
+    };
+    MxDbSVG.prototype.setSvgPath = function (path) {
+        this.svgPath = path;
+        this.svg = null;
+        this.isLoadFromPath = true;
+    };
+    MxDbSVG.prototype.getSvgPath = function () {
+        return this.svgPath;
+    };
+    MxDbSVG.prototype.setSvgPostion = function (pos) {
+        this.svgPos = pos;
+        this.isSvgDirtyLocation = true;
+    };
+    MxDbSVG.prototype.getSvgPostion = function () {
+        return this.svgPos;
+    };
+    MxDbSVG.prototype.setSvgSize = function (size) {
+        this.svgSize = size;
+        this.isSvgDirtyLocation = true;
+    };
+    MxDbSVG.prototype.getSvgSize = function () {
+        return this.svgSize;
+    };
+    MxDbSVG.prototype.setSvgAlignmentRatio = function (alignmentRatio) {
+        this.svgAlignmentRatio = alignmentRatio;
+        this.isSvgDirtyLocation = true;
+    };
+    MxDbSVG.prototype.getSvgAlignmentRatio = function () {
+        return this.svgAlignmentRatio;
+    };
+    //
+    MxDbSVG.prototype.setTextHeight = function (height) {
+        this.txtHeight = height;
+    };
+    MxDbSVG.prototype.getTextHeight = function () {
+        return this.txtHeight;
+    };
+    MxDbSVG.prototype.setText = function (txt) {
+        this.txt = txt;
+    };
+    MxDbSVG.prototype.getText = function () {
+        return this.txt;
+    };
+    MxDbSVG.prototype.setTextPostion = function (pos) {
+        this.txtPos = pos;
+    };
+    MxDbSVG.prototype.getTextPostion = function () {
+        return this.txtPos;
+    };
+    MxDbSVG.prototype.getGripPoints = function () {
+        var ret = [];
+        ret.push(this.svgPos);
+        return ret;
+    };
+    MxDbSVG.prototype.moveGripPointsAt = function (index, offset) {
+        if (index == 0) {
+            this.svgPos.add(offset);
+            this.txtPos.add(offset);
+        }
+        this.isSvgDirtyLocation = true;
+        return true;
+    };
+    MxDbSVG.prototype.calcSvgPosition = function () {
+        if (!this.svg || !this.isSvgDirtyLocation) {
+            return;
+        }
+        this.isSvgDirtyLocation = false;
+        this.svg.position.x = this.svgPos.x - this.svgSize.x * this.svgAlignmentRatio.x;
+        this.svg.position.y = this.svgPos.y - this.svgSize.y * this.svgAlignmentRatio.y;
+    };
+    MxDbSVG.prototype.dwgIn = function (obj) {
+        this.onDwgIn(obj);
+        if (obj.type == MxType_1.default.MxCloneType.kClone && obj['svg']) {
+            this.svg = obj['svg'].clone();
+        }
+        this.svgPos.copy(obj['svgPos']);
+        this.svgPath = obj['svgPath'].substr(0);
+        this.svgSize.copy(obj['svgSize']);
+        this.svgAlignmentRatio.copy(obj['svgAlignmentRatio']);
+        this.isSvgDirtyLocation = true;
+        if (!this.svg)
+            this.isLoadFromPath = true;
+        this.txt = obj['txt'];
+        this.txtHeight = obj['txtHeight'];
+        this.txtPos.copy(obj['txtPos']);
+        return true;
+    };
+    MxDbSVG.prototype.dwgOut = function (obj) {
+        this.onDwgOut(obj);
+        if (obj.type == MxType_1.default.MxCloneType.kClone) {
+            obj['svg'] = this.svg;
+        }
+        obj['svgPath'] = this.svgPath;
+        obj['svgPos'] = this.svgPos;
+        obj['svgSize'] = this.svgSize;
+        obj['svgAlignmentRatio'] = this.svgAlignmentRatio;
+        obj['txt'] = this.txt;
+        obj['txtHeight'] = this.txtHeight;
+        obj['txtPos'] = this.txtPos;
+        return obj;
+    };
+    MxDbSVG.prototype.create = function () {
+        return new MxDbSVG();
+    };
+    MxDbSVG.prototype.transformBy = function (mat) {
+        this.svgPos.applyMatrix4(mat);
+        this.txtPos.applyMatrix4(mat);
+        this.isSvgDirtyLocation = true;
+    };
+    MxDbSVG.prototype.getTypeName = function () {
+        return 'MxDbSVG';
+    };
+    return MxDbSVG;
+}(MxDbEntity_1.default));
+exports.default = MxDbSVG;

package/dist/lib/MxModule/MxDbSVG/index.js

@@ -0,0 +1,5 @@
+"use strict";
+/** @module McEdGetPointWorldDrawObject*/
+Object.defineProperty(exports, "__esModule", { value: true });
+var MxDbSVG_1 = require("./MxDbSVG");
+exports.default = MxDbSVG_1.default;