!1990 功能:单独插入拉手时,实现拉手的定位空间

pull/2015/head
ChenX 2 years ago
parent 6a0a99f30a
commit b07b875d6e

@ -28,6 +28,7 @@ export function IsDoor(en: Entity)
return false;
}
//抽屉空间
export function IsDrawer(en: Entity)
{
if (en.Template)
@ -40,6 +41,7 @@ export function IsDrawer(en: Entity)
return en.ProcessingGroupList.some(id => id && ((id.Object as ProcessingGroupRecord)?.Name === "抽屉"));;
}
//酒格
export function IsWinerack(en: Entity)
{
if (en.Template && en.Template.Object instanceof TemplateWineRackRecord)
@ -47,6 +49,8 @@ export function IsWinerack(en: Entity)
return en.ProcessingGroupList.some(id => id && ((id.Object as ProcessingGroupRecord)?.Name === "酒格"));
}
//格子抽
export function IsLattice(en: Entity)
{
if (en.Template && en.Template.Object instanceof TemplateLatticeRecord)
@ -55,6 +59,7 @@ export function IsLattice(en: Entity)
return en.ProcessingGroupList.some(id => id && ((id.Object as ProcessingGroupRecord)?.Name === "格子抽"));
}
//拉手
export function IsHandle(en: Entity)
{
if (en instanceof HardwareCompositeEntity)
@ -71,6 +76,8 @@ export function IsHandle(en: Entity)
}
}
}
//铰链
export function IsHinge(en: Entity)
{
if (en instanceof HardwareCompositeEntity)
@ -88,6 +95,7 @@ export function IsHinge(en: Entity)
}
}
//顶底板
export function isDingDiBan(b: Board)
{
if (b.BoardType === BoardType.Layer)

@ -0,0 +1,59 @@
import { Vector3 } from "three";
import { AutoRecord } from "../../AutoRecord";
import { Factory } from "../../CADFactory";
import { CADFiler } from "../../CADFiler";
import { Board } from "../../Entity/Board";
import { HardwareCompositeEntity } from "../../Hardware/HardwareCompositeEntity";
import { ObjectId } from "../../ObjectId";
import { Positioning } from "./Positioning";
/**
*
*/
@Factory
export class PositioningHandleSpace extends Positioning
{
constructor(_ObjectId?: ObjectId<Board | HardwareCompositeEntity>)
{
super();
this.ObjectId = _ObjectId;
}
@AutoRecord ObjectId: ObjectId<Board | HardwareCompositeEntity>;
/**
*
*/
async Positioning()
{
this.SpaceCS = undefined;
this.SpaceSize = undefined;
if (this.ObjectId && !this.ObjectId.IsErase)
{
let ent = this.ObjectId.Object;
this.SpaceCS = ent.SpaceOCS;
let box = ent.GetBoundingBoxInMtx(ent.SpaceOCSInv);
this.SpaceSize = box.getSize(new Vector3);
let baseP = box.min.applyMatrix4(this.SpaceCS);
this.SpaceCS.setPosition(baseP);
}
}
//#region File
ReadFile(file: CADFiler): void
{
let ver = file.Read();
this.ObjectId = file.ReadObjectId() as any;
}
WriteFile(file: CADFiler): void
{
file.Write(1);
file.WriteObjectId(this.ObjectId);
}
//#endregion
}

@ -425,9 +425,6 @@ export class TemplateRecord extends SymbolTableRecord
}
}
//相对定位. use PX PY PZ
this.UpdatePosition(paramMap, evaled);
//更新LWH(通过定位空间)
this.LParam.UpdateParam(this._CacheSpaceSize.x);
this.WParam.UpdateParam(this._CacheSpaceSize.y);
@ -450,6 +447,9 @@ export class TemplateRecord extends SymbolTableRecord
this.UpdateEntitys();
//相对定位. use PX PY PZ(这个代码在这里,保证所有的变量都是最新的. 这样我们就可以使用H/2自己定位到自己空间的一半位置)(这个只会修改定位,所以放在这里并不会影响其他的代码)
this.UpdatePosition(paramMap, evaled);
//变换到新的模版空间
for (let en of ens)
{

@ -442,7 +442,7 @@ export class TemplateParamDetail extends React.Component<{}> {
{
let num = safeEval(par.expr);
if (equaln(num, 0) || num < 0)
par.expr = 1e-3;
par.expr = "0.001";//使用字符串,避免下面校验错误
}
this.ChangeInputUIClass(par);
await this.ApplyParamExpr();

@ -3,7 +3,7 @@ import { observable } from 'mobx';
import { observer } from 'mobx-react';
import * as React from 'react';
import { AutoCutting } from '../../../Add-on/BoardCutting/AutoCuttingReactor';
import { IsDoor } from '../../../Add-on/HideSelect/HideSelectUtils';
import { IsDoor, IsHandle, IsHinge } from '../../../Add-on/HideSelect/HideSelectUtils';
import { ITempTagProps, templateTagCommand } from '../../../Add-on/Template/TemplateTagCommand';
import { ReadAutoCutConfig, UploadAutoCutConfig } from '../../../Add-on/TemplateSearch';
import { R2bReplaceProps } from '../../../Add-on/twoD2threeD/R2bConfigComponent';
@ -643,9 +643,11 @@ export class TemplateManage extends React.Component<ITemplateManage, {}> {
await CommandWrap(async () =>
{
let brRes = await app.Editor.GetSelection({
Msg: "选择绘制拉手的板件",
Msg: "选择需要绘制拉手的板件(不要选择无需绘制的板件!)",
Filter: {
filterTypes: [Board, HardwareCompositeEntity]
filterTypes: [Board, HardwareCompositeEntity],
//filterFunction: (obj, ent) => { return IsDoor(ent) || IsDrawer(ent); } //开放选择,无法单独选板绘制
filterFunction: (obj, ent) => { return !(IsHinge(ent) || IsHandle(ent)); }
}
});

@ -1,169 +1,152 @@
import { Vector3 } from "three";
import { app } from "../../../ApplicationServices/Application";
import { EBoardKeyList } from "../../../Common/BoardKeyList";
import { Entity } from "../../../DatabaseServices/Entity/Entity";
import { HardwareCompositeEntity } from "../../../DatabaseServices/Hardware/HardwareCompositeEntity";
import { TemplateVisualSpace } from "../../../DatabaseServices/Template/ProgramTempate/TemplateVisualSpace";
import { PositioningHandleSpace } from "../../../DatabaseServices/Template/Positioning/PositioningHandleSpace";
import { TemplateRecord } from "../../../DatabaseServices/Template/TemplateRecord";
import { Board, DuplicateRecordCloning } from "../../../ueapi";
import { BoardOpenDir } from "../../Store/BoardInterface";
import { DoorStore } from "../../Store/DoorDrawerStore/DoorStore";
import { HandleHorPos, HandleVePos } from "../../Store/DoorInterface";
/**
* handleDoorSpaceTr ( PX PY PZ)
* -handleRotateSpace ( RY)
* --handleTemp
*/
export class TemplateDrawHandleTool
{
AddHandleToDoor = async (door: Board | HardwareCompositeEntity, handleTemp: TemplateRecord) =>
{
const store = DoorStore.GetInstance() as DoorStore;
const isAuto = store.byOpenDir;
const doorStore = DoorStore.GetInstance() as DoorStore;
const isAuto = doorStore.byOpenDir;
const option = store.m_Option;
let doorTr = door.Template?.Object as TemplateRecord;
let handleSpaceTr = new TemplateVisualSpace().InitBaseParams();
(handleSpaceTr as TemplateVisualSpace).IsVisible = false;
handleSpaceTr.Name = "拉手根空间";
let thickness: number;
let openDir = BoardOpenDir.None;
let parentTem = door.Template;
//创建拉手根空间(用于门板定位)
let handleDoorSpaceTr = new TemplateRecord().InitBaseParams();
handleDoorSpaceTr.Name = "拉手根空间";//"拉手定位"
handleDoorSpaceTr.Positioning = new PositioningHandleSpace(door.Id);
app.Database.TemplateTable.Append(handleDoorSpaceTr);//加入图纸
if (doorTr) doorTr.Children.push(handleDoorSpaceTr.Id); //拉手根空间加入该板件家谱树
//#region 解析开门方向
let openDir = BoardOpenDir.None;
if (door instanceof Board)
{
handleSpaceTr.HParam.expr = door.Height;
handleSpaceTr.LParam.expr = door.Width;
handleSpaceTr.GetParam("BH").expr = parentTem ? "_BH" : "";
thickness = door.Thickness;
if (doorTr)
handleDoorSpaceTr.GetParam("BH").expr = "_BH";
openDir = door.OpenDir;
}
else
{
if (door.Template)
if (doorTr)
{
let temp = door.Template.Object as TemplateRecord;
if (temp.Parent)
if (doorTr.Parent)
{
const tempSpace = temp.Parent.Object as TemplateRecord;
if (tempSpace.Name === "门板空间")
const doorParentTr = doorTr.Parent.Object as TemplateRecord;
if (doorParentTr.Name === "门板空间")
{
handleSpaceTr.HParam.expr = temp.HParam.value;
handleSpaceTr.LParam.expr = temp.LParam.value;
thickness = Number(temp.WParam.value) || 0;
let doorGroup = tempSpace.Parent.Object as TemplateRecord;
let zkmPar = doorGroup.GetParam("ZKM");
let doorGroup = doorParentTr.Parent.Object as TemplateRecord;
let zkmPar = doorGroup.GetParam("ZKM");//左开门
if (zkmPar)
{
openDir = zkmPar.value === 1 ? BoardOpenDir.Left : BoardOpenDir.Right;
}
else
{
let skmPar = doorGroup.GetParam("SKM");
let skmPar = doorGroup.GetParam("SKM");//上开门
if (skmPar)
openDir = skmPar.value === 1 ? BoardOpenDir.Up : BoardOpenDir.Down;
}
}
}
}
if (thickness === undefined)
{
let size = door.BoundingBoxInOCS.getSize(new Vector3);
handleSpaceTr.HParam.expr = size.z;
handleSpaceTr.LParam.expr = size.x;
thickness = size.y;
}
}
handleSpaceTr.WParam.expr = 1;
app.Database.TemplateTable.Append(handleSpaceTr);
if (parentTem?.Object) (parentTem.Object as TemplateRecord).Children.push(handleSpaceTr.Id); //拉手根空间加入该板件家谱树
await handleSpaceTr.UpdateTemplateTree();
//#endregion
let box = door.GetBoundingBoxInMtx(door.SpaceOCSInv);
let min = box.min;
min.y = box.max.y;
min.applyMatrix4(door.SpaceOCS);
//#region 定位表达式
for (let id of handleSpaceTr.Objects)
{
let en = (id.Object as Entity);
en.ApplyMatrix(door.SpaceOCS);
en.Position = min;
}
let handleSpace = new TemplateRecord().InitBaseParams();
handleSpace.Name = "拉手空间";
handleSpace.HParam.expr = "0";
handleSpace.LParam.expr = "0";
handleSpace.WParam.expr = "0";
handleSpace.PYParam.expr = - thickness;
handleSpace.Params[9].expr = parentTem ? "_BH" : "";
let handleRotateSpace = new TemplateRecord().InitBaseParams();
handleRotateSpace.Name = "拉手空间";//中间旋转层 ->"拉手旋转"
handleRotateSpace.HParam.expr = "0";
handleRotateSpace.LParam.expr = "0";
handleRotateSpace.WParam.expr = "0";
handleRotateSpace.Params[9].expr = doorTr ? "_BH" : "";
app.Database.TemplateTable.Append(handleSpace);
app.Database.TemplateTable.Append(handleRotateSpace);
handleDoorSpaceTr.Children.push(handleRotateSpace.Id);
handleSpaceTr.Children.push(handleSpace.Id);
let handleHorPos = doorStore.m_Option.handleHorPos;//X轴定位方式(左右中)
let handleVerPos = doorStore.m_Option.handleVePos;//Z轴定位方式 (上下中)
let xExpr = "";
const doorStore = DoorStore.GetInstance() as DoorStore;
let handleHorPos = doorStore.m_Option.handleHorPos;
let handleVerPos = doorStore.m_Option.handleVePos;
let zjExpr = option.horSpacing.toString();
let yjExpr = option.horSpacing.toString();
let zjExpr = doorStore.m_Option.horSpacing.toString();//左距
let yjExpr = doorStore.m_Option.horSpacing.toString();//右距
switch (handleHorPos)
{
case HandleHorPos.Left:
xExpr = zjExpr;
if (isAuto && openDir === BoardOpenDir.Left)
xExpr = `_L-${yjExpr}`;
xExpr = `L-${yjExpr}`;
break;
case HandleHorPos.Right:
xExpr = `_L-${yjExpr}`;
xExpr = `L-${yjExpr}`;
if (isAuto && openDir === BoardOpenDir.Right)
xExpr = zjExpr;
break;
case HandleHorPos.Mid:
xExpr = `_L*0.5`;
xExpr = `L*0.5`;
default:
break;
}
let zExpr = "";
let sjExpr = option.veSpacing.toString();
let xjExpr = option.veSpacing.toString();
let sjExpr = doorStore.m_Option.veSpacing.toString();//上距
let xjExpr = doorStore.m_Option.veSpacing.toString();//下距
switch (handleVerPos)
{
case HandleVePos.Top:
zExpr = "_H-" + sjExpr;
zExpr = "H-" + sjExpr;
if (isAuto && openDir === BoardOpenDir.Up)
zExpr = xjExpr;
break;
case HandleVePos.Bottom:
zExpr = xjExpr;
if (isAuto && openDir === BoardOpenDir.Down)
zExpr = "_H-" + sjExpr;
zExpr = "H-" + sjExpr;
break;
case HandleVePos.Mid:
zExpr = `_H*0.5`;
zExpr = `H*0.5`;
default:
break;
}
handleSpace.PXParam.expr = xExpr;
handleSpace.PZParam.expr = zExpr;
handleDoorSpaceTr.PXParam.expr = xExpr;
handleDoorSpaceTr.PZParam.expr = zExpr;
//#endregion
//插入拉手模块
handleTemp = app.Database.WblockCloneObejcts([handleTemp], app.Database.TemplateTable, new Map(), DuplicateRecordCloning.Ignore)[0] as TemplateRecord;
handleSpace.Children.push(handleTemp.Id);
handleRotateSpace.Children.push(handleTemp.Id);
//保持这个代码 保证这个层旋转可以生效(注释这个代码后 拉手模块的空间将不能旋转,但是能保持正确的尺寸)
handleTemp.HParam.expr = "0";
handleTemp.LParam.expr = "0";
handleTemp.WParam.expr = "0";
handleTemp.RYParam.expr = doorStore.m_Option.handleAngle;
let rName: string;
let cName: string;
let bName: string;
handleRotateSpace.RYParam.expr = doorStore.m_Option.handleAngle;//旋转
//#region 房名 柜名
let rName: string;//房名
let cName: string;//柜名
let bName: string;//板名
if (door instanceof Board)
{
@ -187,6 +170,8 @@ export class TemplateDrawHandleTool
objId.Object.HardwareOption[EBoardKeyList.CabinetName] = cName;
}
}
await handleSpaceTr.UpdateTemplateTree();
//#endregion
await handleDoorSpaceTr.UpdateTemplateTree();
};
}

Loading…
Cancel
Save