mxdraw 0.1.1 → 0.1.4

package/README.md

@@ -56,7 +56,7 @@ Mx.loadCoreCode().then(()=> {
   // 创建控件对象
   Mx.MxFun.createMxObject({
       canvasId: "mxcad", // canvas元素的id
-      drawName："test2.dwg", // 服务器中图纸名称
+      cadFile"test2.dwg", // 服务器中图纸名称
       callback: (mxDraw, {
           canvas,
           canvasParent
@@ -169,29 +169,33 @@ loadCoreCode().then(()=> {
 })
 ```
 ### MxFun 方法集合
-> MxFun提供了核心方法， 其中最重要的两个方法就是`setMxServer`设置服务器地址([什么是服务器地址
-
-](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/MxFun.html#setMxServer) )和`createMxObject`创建控制对象
-* [MxFun.setMxServer](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/MxFun.html#setMxServer) 
-* [MxFun.createMxObject](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/MxFun.html#createMxObject) 
+> MxFun提供了核心方法， 其中最重要的两个方法就是[setMxServer](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/MxFun.html#setMxServer)设置服务器地址
+以及 [createMxObject](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/MxFun.html#createMxObject) 创建控制对象
+* 服务器地址就是[MxDraw云图开发包](https://www.mxdraw.com/download.html) 所启动的后台服务地址...[详情](https://help.mxdraw.com/?pid=32&keywords=)
 
 ### MxDrawObject 控件对象
 > [MxFun.createMxObject](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/MxFun.html#createMxObject) 创建的控件对象可以对canvas画布上展示的图纸进行控制修改以及添加three.js中各种组合图形等功能[详情](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/MxDrawObject.html)
 
 ### MxThreeJS 创建THREE图形物体对象
-> [MxThreeJS](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/MxThreeJS.html)是根据Three.js提供的APi 创建各种常见的基础图形文字以及加载的图片/SVG等的方法集合， 一般情况最终创建返回的都是基于THREE.Object3D的物体对象，可以通过[MxDrawObject控件对象的addObject](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/MxDrawObject.html#addObject) 方法添加到场景中，最后通过[MxDrawObject.updateDisplay](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/MxDrawObject.html#updateDisplay)更新显示场景，就可以将物体对象渲染到canvas画布上了。当然也可以不使用MxThreeJS提供的创建物体的方式，可以用three.js自定义创建各种需要的物体图形模型。
+> [MxThreeJS](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/MxThreeJS.html)是根据Three.js提供的APi 创建各种常见的基础图形文字以及加载的图片/SVG等的方法集合
+* 一般情况最终创建返回的都是基于THREE.Object3D的物体对象，可以通过[MxDrawObject控件对象的addObject](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/MxDrawObject.html#addObject) 方法添加到场景中，最后通过[MxDrawObject.updateDisplay](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/MxDrawObject.html#updateDisplay)更新显示场景，就可以将物体对象渲染到canvas画布上了。
+* 当然也可以不使用MxThreeJS提供的创建物体的方式，可以用three.js自定义创建各种需要的物体图形模型。
 
 ### McEdGetPointWorldDrawObject / MrxDbgUiPrPoint / MrxDbgUiPrBaseReturn 动态绘制
-> [McEdGetPointWorldDrawObject](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/McEdGetPointWorldDrawObject.html)是动态绘制对象的类， 一个McEdGetPointWorldDrawObject实例可以使用setDraw方法设置动态的回调函数，一般情况下回调函数中会通过drawCustomEntity或者提供的其他方法绘制出需要动态绘制的部分(鼠标移动将会触发动态回调函数)
-> [MrxDbgUiPrPoint](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/MrxDbgUiPrPoint.html)是一个配合动态绘制的鼠标去点的类，实例化后通过go或者goWhile 方式设置鼠标点击回调事件， 通过setUserDraw方法设置动态绘制对象， 此时动态绘制对象生效，在鼠标移动时会触发其动态回调函数
-> [MrxDbgUiPrBaseReturn](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/MrxDbgUiPrBaseReturn.html)是MrxDbgUiPrPoint的go或者goWhile的回调参数判断点击类型的一个枚举类型。
-> McEdGetPointWorldDrawObject / MrxDbgUiPrPoint 配合使用 就能够完成大部分图形动态绘制的需求，例：[如何实现一个画线的功能命令?](#%E7%94%A8%E6%B3%95)
+* [McEdGetPointWorldDrawObject](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/McEdGetPointWorldDrawObject.html)是动态绘制对象的类， 一个McEdGetPointWorldDrawObject实例可以使用setDraw方法设置动态的回调函数，一般情况下回调函数中会通过drawCustomEntity或者提供的其他方法绘制出需要动态绘制的部分(鼠标移动将会触发动态回调函数)
+* [MrxDbgUiPrPoint](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/MrxDbgUiPrPoint.html)是一个配合动态绘制的鼠标去点的类，实例化后通过go或者goWhile 方式设置鼠标点击回调事件， 通过setUserDraw方法设置动态绘制对象， 此时动态绘制对象生效，在鼠标移动时会触发其动态回调函数
+* [MrxDbgUiPrBaseReturn](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/MrxDbgUiPrBaseReturn.html)是MrxDbgUiPrPoint的go或者goWhile的回调参数判断点击类型的一个枚举类型。
+* McEdGetPointWorldDrawObject / MrxDbgUiPrPoint 配合使用 就能够完成大部分图形动态绘制的需求，例：[如何实现一个画线的功能命令?](#%E7%94%A8%E6%B3%95)
 
 ### MxDbEntity / McGiWorldDraw / McGiWorldDrawType 自定义对象
-> 自定义对象是为了更加方便的控制一个图形物体对象创建的一个控制器， 在需要对已经绘制在画布上的图形物体进行动态改动操作时，有一系列繁琐的过程，选取对象/选取状态/生成可改动的顶点/拖动改变顶点位置/动态绘制... 如果遵循自定义对象的规范(实现MxDbEntity抽象类)，就可以忽略这些步骤，在实现了预设行为(抽象方法)后，鼠标操作就可以完成对物体对象的顶点操作，从而改变图形物体。
-> [MxDbEntity](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/MxDbEntity.html)抽象类 通过继承的方式实现一个自定义对象
-> [McGiWorldDraw](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/McGiWorldDraw.html) 是 [MxDbEntity.worldDraw](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/MxDbEntity.html#worldDraw)抽象方法的回调对象 可以实现再鼠标拖动过程中的一些动态绘制任务
-> [McGiWorldDrawType](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/McGiWorldDrawType.html) 是[McGiWorldDraw.getType](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/McGiWorldDraw.html#getType)方法返回的枚举类型表示MxDbEntity.worldDraw的绘制类型
+> 自定义对象是为了更加方便的控制一个图形物体对象创建的一个控制器， 在需要对已经绘制在画布上的图形物体进行动态改动操作时，有一系列繁琐的过程，选取对象/选取状态/生成可改动的顶点/拖动改变顶点位置/动态绘制...
+
+> 如果遵循自定义对象的规范(实现MxDbEntity抽象类)，就可以忽略这些步骤，在实现了预设行为(抽象方法)后，鼠标操作就可以完成对物体对象的顶点操作，从而改变图形物体。
+
+
+* [MxDbEntity](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/MxDbEntity.html)抽象类 通过继承的方式实现一个自定义对象
+* [McGiWorldDraw](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/McGiWorldDraw.html) 是 [MxDbEntity.worldDraw](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/MxDbEntity.html#worldDraw)抽象方法的回调对象 可以实现再鼠标拖动过程中的一些动态绘制任务
+* [McGiWorldDrawType](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/McGiWorldDrawType.html) 是[McGiWorldDraw.getType](https://mxtmpweb.mxdraw.f3322.net:3562/mxdrawcloud/classes/McGiWorldDraw.html#getType)方法返回的枚举类型表示MxDbEntity.worldDraw的绘制类型
 
 
 ## 按需引入配置 

package/dist/lib/MxModule/McEdGetPointWorldDrawObject/McEdGetPointWorldDrawObjectClass.js

@@ -126,4 +126,3 @@ var McEdGetPointWorldDrawObject = /** @class */ (function () {
     return McEdGetPointWorldDrawObject;
 }());
 exports.default = McEdGetPointWorldDrawObject;
-//# sourceMappingURL=McEdGetPointWorldDrawObjectClass.js.map

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

@@ -3,4 +3,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 var McEdGetPointWorldDrawObjectClass_1 = require("./McEdGetPointWorldDrawObjectClass");
 exports.default = McEdGetPointWorldDrawObjectClass_1.default;
-//# sourceMappingURL=index.js.map

package/dist/lib/MxModule/McGeVector3d/McGeVector3d.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,3 @@
+"use strict";
+/** @module MrxDbgUiPrPointClass */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/MxModule/McGiWorldDraw/McGiWorldDraw.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=McGiWorldDraw.js.map

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

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=index.js.map

package/dist/lib/MxModule/McGiWorldDrawType/McGiWorldDrawType.js

@@ -17,4 +17,3 @@ var McGiWorldDrawType;
     McGiWorldDrawType[McGiWorldDrawType["kSelectDraw"] = 3] = "kSelectDraw";
 })(McGiWorldDrawType || (McGiWorldDrawType = {}));
 exports.default = McGiWorldDrawType;
-//# sourceMappingURL=McGiWorldDrawType.js.map

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

@@ -2,4 +2,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 var McGiWorldDrawType_1 = require("./McGiWorldDrawType");
 exports.default = McGiWorldDrawType_1.default;
-//# sourceMappingURL=index.js.map

package/dist/lib/MxModule/MrxDbgUiPrBaseReturn/MrxDbgUiPrBaseReturn.js

@@ -29,4 +29,3 @@ var MrxDbgUiPrBaseReturn;
     MrxDbgUiPrBaseReturn[MrxDbgUiPrBaseReturn["kKeyWord"] = 1] = "kKeyWord";
 })(MrxDbgUiPrBaseReturn || (MrxDbgUiPrBaseReturn = {}));
 exports.default = MrxDbgUiPrBaseReturn;
-//# sourceMappingURL=MrxDbgUiPrBaseReturn.js.map

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

@@ -3,4 +3,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 var MrxDbgUiPrBaseReturn_1 = require("./MrxDbgUiPrBaseReturn");
 exports.default = MrxDbgUiPrBaseReturn_1.default;
-//# sourceMappingURL=index.js.map

package/dist/lib/MxModule/MrxDbgUiPrPoint/MrxDbgUiPrPointClass.js

@@ -131,4 +131,3 @@ var MrxDbgUiPrPoint = /** @class */ (function () {
     return MrxDbgUiPrPoint;
 }());
 exports.default = MrxDbgUiPrPoint;
-//# sourceMappingURL=MrxDbgUiPrPointClass.js.map

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

@@ -3,4 +3,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 var MrxDbgUiPrPointClass_1 = require("./MrxDbgUiPrPointClass");
 exports.default = MrxDbgUiPrPointClass_1.default;
-//# sourceMappingURL=index.js.map

package/dist/lib/MxModule/MxDbAlignedDimension/MxDbAlignedDimension.js

@@ -0,0 +1,213 @@
+"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 MxDbAlignedDimension*/
+var THREE = require("three");
+var McGiWorldDrawType_1 = require("../McGiWorldDrawType");
+var MxDbEntity_1 = require("../MxDbEntity");
+var MxFun_1 = require("../MxFun");
+var MxThreeJS_1 = require("../MxThreeJS");
+/**
+ * MxDbAlignedDimension 尺寸对象.
+ */
+var MxDbAlignedDimension = /** @class */ (function (_super) {
+    __extends(MxDbAlignedDimension, _super);
+    function MxDbAlignedDimension() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.pt1 = new THREE.Vector3();
+        _this.pt2 = new THREE.Vector3();
+        return _this;
+    }
+    MxDbAlignedDimension.prototype.getTypeName = function () {
+        return 'MxDbAlignedDimension';
+    };
+    //获得标注方向
+    MxDbAlignedDimension.prototype.getDirection = function (v2ndPtTo1stPt, i3DFirstPt, i3DSecondPt) {
+        var vDirection = new THREE.Vector3(v2ndPtTo1stPt.x, v2ndPtTo1stPt.y, 0);
+        var mXnormal = new THREE.Vector3(1, 0, 0);
+        var fAngle = v2ndPtTo1stPt.angleTo(mXnormal);
+        //标尺与X的角度接近PI 靠近X轴；第二个点在右 或 标尺与X的角度接近0 靠近X轴；第二个点在左
+        var fMarkDirAnlge = -1;
+        if (fAngle < (Math.PI * 7) / 18 || fAngle > (Math.PI * 10) / 18) {
+            if (i3DFirstPt.x > i3DSecondPt.x) {
+                fMarkDirAnlge = 1;
+            }
+        }
+        var rotationWorldMatrix = new THREE.Matrix4();
+        rotationWorldMatrix.makeRotationZ((Math.PI / 2) * fMarkDirAnlge);
+        vDirection.applyMatrix4(rotationWorldMatrix);
+        return vDirection;
+    };
+    // 绘制尺寸标注.
+    MxDbAlignedDimension.prototype.worldDraw = function (pWorldDraw) {
+        if (pWorldDraw.getType() == McGiWorldDrawType_1.default.kWorldDraw ||
+            pWorldDraw.getType() == McGiWorldDrawType_1.default.kDynDragDraw) {
+            var pt1 = this.pt1;
+            var pt2 = this.pt2;
+            //标注的三条线
+            var line1;
+            var line2;
+            var line3;
+            var text;
+            var mTriangle1;
+            var mTriangle2;
+            var mPoint1;
+            var mPoint2;
+            var v2ndPtTo1stPt = new THREE.Vector3(pt1.x - pt2.x, pt1.y - pt2.y, 0);
+            var vDirection = this.getDirection(v2ndPtTo1stPt, pt1, pt2);
+            var fLen = v2ndPtTo1stPt.length();
+            var scaleWorldMatrix = new THREE.Matrix4();
+            scaleWorldMatrix.makeScale(0.01, 0.01, 0.01);
+            var vTemp = new THREE.Vector3(vDirection.x, vDirection.y, 0);
+            vTemp.applyMatrix4(scaleWorldMatrix);
+            var mTopPt1 = new THREE.Vector3(pt1.x + vTemp.x, pt1.y + vTemp.y, 0);
+            var mTopPt2 = new THREE.Vector3(pt2.x + vTemp.x, pt2.y + vTemp.y, 0);
+            var color = 0xffffff;
+            //画点
+            {
+                mPoint1 = MxThreeJS_1.default.createPoint(pt1, color);
+                mPoint2 = MxThreeJS_1.default.createPoint(pt2, color);
+            }
+            //画线
+            {
+                scaleWorldMatrix.identity();
+                scaleWorldMatrix.makeScale(0.2, 0.2, 0);
+                var vTemp1 = new THREE.Vector3(vDirection.x, vDirection.y, 0);
+                vTemp1.applyMatrix4(scaleWorldMatrix);
+                scaleWorldMatrix.identity();
+                scaleWorldMatrix.makeScale(0.02, 0.02, 0);
+                var vTemp2 = new THREE.Vector3(vDirection.x, vDirection.y, 0);
+                vTemp2.applyMatrix4(scaleWorldMatrix);
+                pWorldDraw.drawLine(mTopPt1, mTopPt2);
+                line2 = MxThreeJS_1.default.createLine(new THREE.Vector3(mTopPt1.x + vTemp2.x * 2, mTopPt1.y + vTemp2.y * 2, 0), new THREE.Vector3(pt1.x + vTemp2.x, pt1.y + vTemp2.y, 0), color);
+                line3 = MxThreeJS_1.default.createLine(new THREE.Vector3(mTopPt2.x + vTemp2.x * 2, mTopPt2.y + vTemp2.y * 2, 0), new THREE.Vector3(pt2.x + vTemp2.x, pt2.y + vTemp2.y, 0), color);
+            }
+            //画文字
+            {
+                var mXnormal = new THREE.Vector3(1, 0, 0);
+                var fAngle = v2ndPtTo1stPt.angleTo(mXnormal);
+                // vTemp 标注线垂直方向 。
+                var vTemp = new THREE.Vector3(vDirection.x, vDirection.y, 0);
+                vTemp.normalize();
+                var fSize = pt1.distanceTo(pt2);
+                if (v2ndPtTo1stPt.y < 0) {
+                    if (fAngle < Math.PI / 2) {
+                        fAngle = 2 * Math.PI - fAngle;
+                    }
+                    else {
+                        fAngle = Math.PI - fAngle;
+                    }
+                }
+                else {
+                    if (fAngle > Math.PI / 2) {
+                        fAngle = Math.PI + fAngle;
+                    }
+                }
+                fLen = MxFun_1.default.worldCoordLong2Doc(fLen);
+                text = MxThreeJS_1.default.creatTextSprite(fLen.toFixed(3), new THREE.Vector3(mTopPt2.x + v2ndPtTo1stPt.x / 2 + (vTemp.x * fSize) / 30, mTopPt2.y + v2ndPtTo1stPt.y / 2 + (vTemp.y * fSize) / 30, 0), fSize * 0.07, // 文字高度，取两点距离的0.1
+                fAngle, color);
+                if (text != null)
+                    pWorldDraw.drawEntity(text);
+            }
+            //画三角形
+            {
+                scaleWorldMatrix.identity();
+                scaleWorldMatrix.makeScale(0.08, 0.08, 0.08);
+                var rotationWorldMatrix = new THREE.Matrix4();
+                rotationWorldMatrix.makeRotationZ((Math.PI * 17) / 18);
+                var vTrianglePt1Dir = new THREE.Vector3(v2ndPtTo1stPt.x, v2ndPtTo1stPt.y, 0);
+                vTrianglePt1Dir.applyMatrix4(scaleWorldMatrix);
+                vTrianglePt1Dir.applyMatrix4(rotationWorldMatrix);
+                rotationWorldMatrix.identity();
+                rotationWorldMatrix.makeRotationZ((-Math.PI * 17) / 18);
+                var vTrianglePt2Dir = new THREE.Vector3(v2ndPtTo1stPt.x, v2ndPtTo1stPt.y, 0);
+                vTrianglePt2Dir.applyMatrix4(scaleWorldMatrix);
+                vTrianglePt2Dir.applyMatrix4(rotationWorldMatrix);
+                var pts1 = new Array();
+                pts1.push(new THREE.Vector3(mTopPt1.x, mTopPt1.y, 0), new THREE.Vector3(mTopPt1.x + vTrianglePt1Dir.x, mTopPt1.y + vTrianglePt1Dir.y, 0), new THREE.Vector3(mTopPt1.x + vTrianglePt2Dir.x, mTopPt1.y + vTrianglePt2Dir.y, 0));
+                mTriangle1 = MxThreeJS_1.default.createTriangle(pts1, color);
+                rotationWorldMatrix.identity();
+                rotationWorldMatrix.makeRotationZ(Math.PI / 18);
+                vTrianglePt1Dir = new THREE.Vector3(v2ndPtTo1stPt.x, v2ndPtTo1stPt.y, 0);
+                vTrianglePt1Dir.applyMatrix4(scaleWorldMatrix);
+                vTrianglePt1Dir.applyMatrix4(rotationWorldMatrix);
+                rotationWorldMatrix.identity();
+                rotationWorldMatrix.makeRotationZ(-Math.PI / 18);
+                vTrianglePt2Dir = new THREE.Vector3(v2ndPtTo1stPt.x, v2ndPtTo1stPt.y, 0);
+                vTrianglePt2Dir.applyMatrix4(scaleWorldMatrix);
+                vTrianglePt2Dir.applyMatrix4(rotationWorldMatrix);
+                var pts2 = new Array();
+                pts2.push(new THREE.Vector3(mTopPt2.x, mTopPt2.y, 0), new THREE.Vector3(mTopPt2.x + vTrianglePt1Dir.x, mTopPt2.y + vTrianglePt1Dir.y, 0), new THREE.Vector3(mTopPt2.x + vTrianglePt2Dir.x, mTopPt2.y + vTrianglePt2Dir.y, 0));
+                mTriangle2 = MxThreeJS_1.default.createTriangle(pts2, color);
+            }
+            pWorldDraw.drawEntity(line2);
+            pWorldDraw.drawEntity(line3);
+            if (mTriangle1)
+                pWorldDraw.drawEntity(mTriangle1);
+            if (mTriangle2)
+                pWorldDraw.drawEntity(mTriangle2);
+            pWorldDraw.drawEntity(mPoint1);
+            pWorldDraw.drawEntity(mPoint2);
+        }
+        else {
+            pWorldDraw.drawLine(this.pt1, this.pt2);
+        }
+    };
+    MxDbAlignedDimension.prototype.setPoint1 = function (pt1) {
+        this.pt1 = pt1;
+    };
+    MxDbAlignedDimension.prototype.setPoint2 = function (pt2) {
+        this.pt2 = pt2;
+    };
+    MxDbAlignedDimension.prototype.getGripPoints = function () {
+        var ret = [];
+        ret.push(this.pt1);
+        ret.push(this.pt2);
+        return ret;
+    };
+    MxDbAlignedDimension.prototype.moveGripPointsAt = function (index, offset) {
+        if (index == 0) {
+            this.pt1.add(offset);
+        }
+        else if ((index = 1)) {
+            this.pt2.add(offset);
+        }
+        return true;
+    };
+    MxDbAlignedDimension.prototype.dwgIn = function (obj) {
+        this.onDwgIn(obj);
+        this.pt1.copy(obj['pt1']);
+        this.pt2.copy(obj['pt2']);
+        return true;
+    };
+    MxDbAlignedDimension.prototype.dwgOut = function (obj) {
+        this.onDwgOut(obj);
+        obj['pt1'] = this.pt1;
+        obj['pt2'] = this.pt2;
+        return obj;
+    };
+    MxDbAlignedDimension.prototype.create = function () {
+        return new MxDbAlignedDimension();
+    };
+    return MxDbAlignedDimension;
+}(MxDbEntity_1.default));
+exports.default = MxDbAlignedDimension;

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

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

package/dist/lib/MxModule/MxDbEntity/MxDbEntity.js

@@ -1,6 +1,8 @@
 "use strict";
 /** @module MxDbEntity*/
 Object.defineProperty(exports, "__esModule", { value: true });
+var MxType_1 = require("../MxType");
+var store_1 = require("../store/store");
 /**
  * MxDbEntity 用于构建一个自定义对象的抽象类(该类无法实例化 请通过继承的方式对其抽象方法进行实现)
  * @description MxDbEntity 属于 abstract class(抽象类) 主要用途是通过继承这个类实现一个用于动态绘制的回调对象
@@ -24,7 +26,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var MxDbEntity = /** @class */ (function () {
     function MxDbEntity() {
         this.iColor = 0xffffff;
+        this.iRenderOrder = 30;
     }
+    /**
+     * 自定义实体的坐标变换.
+     * @param
+     * @returns void
+     * @example
+     *  }
+     * ```
+     */
+    MxDbEntity.prototype.transformBy = function (mat) { };
     MxDbEntity.prototype.getImp = function () {
         var myThis = this;
         var imp = myThis['MxDbEntityImp'];
@@ -39,15 +51,39 @@ var MxDbEntity = /** @class */ (function () {
      *
      * ```
      */
-    MxDbEntity.prototype.upDisplay = function () {
+    MxDbEntity.prototype.setNeedUpdateDisplay = function (isImmediate) {
         var imp = this.getImp();
         if (imp) {
-            return imp.upDisplay();
+            if (isImmediate) {
+                imp.upDisplay();
+            }
+            else {
+                imp.setDirtyDisplay(true);
+            }
+            return true;
         }
         else {
             return false;
         }
     };
+    /**
+     * 得到对象的id.
+     * @param
+     * @returns number
+     * @example
+     * ``` typescript
+     *
+     * ```
+     */
+    MxDbEntity.prototype.objectId = function () {
+        var imp = this.getImp();
+        if (imp) {
+            return imp.objectId();
+        }
+        else {
+            return 0;
+        }
+    };
     /**
      * 删除对象
      * @param
@@ -91,16 +127,20 @@ var MxDbEntity = /** @class */ (function () {
         return this.iColor;
     };
     /**
-     * 得到对象类型名
+     * 复制对象。
      * @param
-     * @returns string
+     * @returns MxDbEntity
      * @example
      * ``` typescript
      *
      * ```
      */
-    MxDbEntity.prototype.getTypeName = function () {
-        return 'MxDbEntity';
+    MxDbEntity.prototype.clone = function (type) {
+        var ret = this.create();
+        var objData = { type: type ? type : MxType_1.default.MxCloneType.kClone };
+        this.dwgOut(objData);
+        ret.dwgIn(objData);
+        return ret;
     };
     /**
      * 自定义对象内部数据输入同步（实现dwgIn抽象方法 必须在实现中调用 this.onDwgIn()）
@@ -108,6 +148,7 @@ var MxDbEntity = /** @class */ (function () {
      */
     MxDbEntity.prototype.onDwgIn = function (obj) {
         this.iColor = obj['iColor'];
+        this.iRenderOrder = obj['iRenderOrder'];
     };
     /**
      * 自定义对象内部数据输出同步（实现dwgIn抽象方法 必须在实现中调用 this.onDwgIn()
@@ -115,8 +156,45 @@ var MxDbEntity = /** @class */ (function () {
      */
     MxDbEntity.prototype.onDwgOut = function (obj) {
         obj['iColor'] = this.iColor;
+        obj['iRenderOrder'] = this.iRenderOrder;
+    };
+    /**
+     * 初始自定义对象的类型信息.
+     * @param
+     * @returns
+     * @example
+     * ``` typescript
+     *
+     * ```
+     */
+    MxDbEntity.prototype.rxInit = function () {
+        ;
+        store_1.default.state.MxFun.initMxDbEntityType(this);
+    };
+    /**
+     * 设置显示顺序
+     * @param
+     * @returns boolean
+     * @example
+     * ``` typescript
+     *
+     * ```
+     */
+    MxDbEntity.prototype.setRenderOrder = function (iRenderOrder) {
+        this.iRenderOrder = iRenderOrder;
+    };
+    /**
+     * 得到显示顺序
+     * @param
+     * @returns boolean
+     * @example
+     * ``` typescript
+     *
+     * ```
+     */
+    MxDbEntity.prototype.getRenderOrder = function () {
+        return this.iRenderOrder;
     };
     return MxDbEntity;
 }());
 exports.default = MxDbEntity;
-//# sourceMappingURL=MxDbEntity.js.map

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

@@ -3,4 +3,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 var MxDbEntity_1 = require("./MxDbEntity");
 exports.default = MxDbEntity_1.default;
-//# sourceMappingURL=index.js.map

package/dist/lib/MxModule/MxDbImage/MxDbImage.js

@@ -0,0 +1,147 @@
+"use strict";
+///////////////////////////////////////////////////////////////////////////////
+//版权所有（C）2002-2022，成都梦想凯德科技有限公司。
+//本软件代码及其文档和相关资料归成都梦想凯德科技有限公司,应用包含本软件的程序必须包括以下版权声明
+//此应用程序与成都梦想凯德科技有限公司成协议。通过使用本软件、其文档或相关材料
+///////////////////////////////////////////////////////////////////////////////
+/** @module MxDbImage*/
+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");
+/**
+ * MxDbImage 图片对象.
+ */
+var MxDbImage = /** @class */ (function (_super) {
+    __extends(MxDbImage, _super);
+    function MxDbImage() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        // pt1,pt2是图片的两个对角点.
+        _this.pt1 = new THREE.Vector3();
+        _this.pt2 = new THREE.Vector3();
+        _this.imagePath = '';
+        _this.isLoadMaterialFromPath = true;
+        _this.material = null;
+        return _this;
+    }
+    MxDbImage.prototype.getTypeName = function () {
+        return 'MxDbImage';
+    };
+    // 图片对象的绘制
+    MxDbImage.prototype.worldDraw = function (pWorldDraw) {
+        var _this = this;
+        var pt3 = new THREE.Vector3(this.pt1.x, this.pt2.y);
+        var pt4 = new THREE.Vector3(this.pt2.x, this.pt1.y);
+        pWorldDraw.drawLine(this.pt1, pt3);
+        pWorldDraw.drawLine(pt3, this.pt2);
+        pWorldDraw.drawLine(this.pt2, pt4);
+        pWorldDraw.drawLine(pt4, this.pt1);
+        if (pWorldDraw.getType() == 1) {
+            // 图片正常的显示绘制.
+            if (this.material) {
+                var w = Math.abs(this.pt1.x - this.pt2.x);
+                var h = Math.abs(this.pt1.y - this.pt2.y);
+                var geometry = new THREE.PlaneGeometry(w, h);
+                var x = Math.min(this.pt1.x, this.pt2.x);
+                var y = Math.min(this.pt1.y, this.pt2.y);
+                for (var i = 0; i < geometry.vertices.length; i++) {
+                    geometry.vertices[i].x += x + w * 0.5;
+                    geometry.vertices[i].y += y + h * 0.5;
+                    geometry.vertices[i].z = 0;
+                }
+                var mesh = new THREE.Mesh(geometry, this.material);
+                mesh.material['depthTest'] = false;
+                pWorldDraw.drawEntity(mesh);
+            }
+            else if (this.imagePath.length > 0 && this.isLoadMaterialFromPath) {
+                var myThis_1 = this;
+                MxFun_1.default.loadImageMaterial('./models/img/mxcad.jpg', function (material) {
+                    _this.isLoadMaterialFromPath = false;
+                    if (!material) {
+                        return;
+                    }
+                    myThis_1.setMaterial(material);
+                    myThis_1.setNeedUpdateDisplay();
+                    MxFun_1.default.updateDisplay();
+                });
+            }
+        }
+    };
+    MxDbImage.prototype.setImagePath = function (sPath) {
+        this.imagePath = sPath;
+        this.isLoadMaterialFromPath = true;
+        this.material = null;
+    };
+    MxDbImage.prototype.getImagePath = function () {
+        return this.imagePath;
+    };
+    MxDbImage.prototype.setMaterial = function (material) {
+        this.material = material;
+    };
+    MxDbImage.prototype.setPoint1 = function (pt1) {
+        this.pt1 = pt1;
+    };
+    MxDbImage.prototype.getPoint1 = function () {
+        return this.pt1;
+    };
+    MxDbImage.prototype.setPoint2 = function (pt2) {
+        this.pt2 = pt2;
+    };
+    MxDbImage.prototype.getPoint2 = function () {
+        return this.pt2;
+    };
+    // 返回图片的可编辑的夹点.
+    MxDbImage.prototype.getGripPoints = function () {
+        var ret = [];
+        ret.push(this.pt1);
+        ret.push(this.pt2);
+        return ret;
+    };
+    // 图片的夹点拖动编辑.
+    MxDbImage.prototype.moveGripPointsAt = function (index, offset) {
+        if (index == 0) {
+            this.pt1.add(offset);
+        }
+        else if ((index = 1)) {
+            this.pt2.add(offset);
+        }
+        return true;
+    };
+    // 图片数据的保存.
+    MxDbImage.prototype.dwgIn = function (obj) {
+        this.onDwgIn(obj);
+        this.pt1.copy(obj['pt1']);
+        this.pt2.copy(obj['pt2']);
+        this.imagePath = obj['imagePath'].substr(0);
+        this.isLoadMaterialFromPath = true;
+        return true;
+    };
+    // 图片数据的恢复.
+    MxDbImage.prototype.dwgOut = function (obj) {
+        this.onDwgOut(obj);
+        obj['pt1'] = this.pt1;
+        obj['pt2'] = this.pt2;
+        obj['imagePath'] = this.imagePath;
+        return obj;
+    };
+    MxDbImage.prototype.create = function () {
+        return new MxDbImage();
+    };
+    return MxDbImage;
+}(MxDbEntity_1.default));
+exports.default = MxDbImage;

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

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