bool DrawingLineWallCtrller::PreRender3D()
{
SetEnable( StatusMgr::GetInstance().DrawingState_ == StatusMgr::EDS_LINE_WALL );
if ( !IsEnable() )
{
Reset();
return false;
}
UpdateMesh();
Checker_ = true;
auto smgr = GetRenderContextSPtr()->Smgr_.get();
auto line = smgr->getSceneCollisionManager()->getRayFromScreenCoordinates(CursorIPos_);
s_PntPlane.getIntersectionWithLine(line.start, line.getVector(), CurrentPos_);
switch (State_)
{
case DrawingLineWallCtrller::EDWLS_BEGIN:
//break;
case DrawingLineWallCtrller::EDWLS_DRAWING:
{
auto smgr = GetRenderContextSPtr()->Smgr_.get();
if ( !Pnts_.empty() && (Pnts_.back().getDistanceFromSQ(CurrentPos_) < WallThickness_*WallThickness_) )
{
Checker_ = false;
}
bool foundAlign = false;
//吸附已生成的点
for ( auto& existPnt : Pnts_ )
{
if ( existPnt.getDistanceFromSQ(CurrentPos_) <= 100 * 100 )
{
CurrentPos_ = existPnt;
foundAlign = true;
break;
}
}
//吸附其他墙面
if ( !foundAlign )
{
gp_Pnt curPnt(CurrentPos_.X, CurrentPos_.Y, CurrentPos_.Z);
auto curVertex = BRepBuilderAPI_MakeVertex(curPnt).Vertex();
Bnd_Box bb;
bb.Add(curPnt);
assert(!CurrentRoot_.expired());
auto spRoot = CurrentRoot_.lock();
for ( auto& curGroup : spRoot->GetChildrenList() )
{
if ( curGroup->GetType() != EODLT_GROUP )
{
continue;
}
if ( curGroup->GetBaseBndBox().Distance(bb.Transformed(curGroup->GetAbsoluteTransform().Inverted())) > WallThickness_/2 )
{
continue;
}
auto needBreak = false;
for ( auto& curWall : curGroup->GetChildrenList() )
{
if ( curWall->GetType() != EODLT_WALL )
{
continue;
}
auto inverted = curWall->GetAbsoluteTransform().Inverted();
if ( curWall->GetBaseBndBox().Distance(bb.Transformed(inverted)) > WallThickness_/2 )
{
continue;
}
auto& selector = curWall->GetBaseSelector();
selector.LoadS2(curVertex.Moved(inverted));
selector.Perform();
if ( 0 == selector.NbSolution() )
{
continue;
}
auto distance = selector.Value();
if ( distance > WallThickness_/2 )
{
continue;
}
if ( BRepExtrema_IsVertex == selector.SupportTypeShape1(1) )
{
curVertex = TopoDS::Vertex(selector.SupportOnShape1(1));
curPnt = BRep_Tool::Pnt(curVertex);
}
else if ( BRepExtrema_IsOnEdge == selector.SupportTypeShape1(1) )
{
Standard_Real curPar;
selector.ParOnEdgeS1(1, curPar);
auto curEdge = TopoDS::Edge(selector.SupportOnShape1(1));
BRepAdaptor_Curve edgeAdaptor(curEdge);
auto firstL = BRepGProp_EdgeTool::FirstParameter(edgeAdaptor);
auto lastL = BRepGProp_EdgeTool::LastParameter(edgeAdaptor);
auto fVertex = BRep_Tool::Pnt(TopExp::FirstVertex(curEdge));
auto lVertex = BRep_Tool::Pnt(TopExp::LastVertex(curEdge));
auto adjCurPar = curPar - firstL;
auto adjLastL = lastL - firstL;
if ( adjCurPar < WallThickness_/2 )//起点
{
curVertex = TopExp::FirstVertex(curEdge);
curPnt = BRep_Tool::Pnt(curVertex);
}
else if ( adjLastL - adjCurPar < WallThickness_/2 )//终点
{
curVertex = TopExp::LastVertex(curEdge);
curPnt = BRep_Tool::Pnt(curVertex);
}
else if ( std::abs(WallThickness_ - adjCurPar) < WallThickness_/2 )
{
edgeAdaptor.D0(firstL+WallThickness_, curPnt);
}
else if ( std::abs(adjLastL-WallThickness_ - adjCurPar) < WallThickness_/2 )
{
edgeAdaptor.D0(lastL-WallThickness_, curPnt);
}
else
{
curPnt = selector.PointOnShape1(1);
}
}
else if ( BRepExtrema_IsInFace == selector.SupportTypeShape1(1) )
{
Standard_Real u,v, uMin,uMax,vMin,vMax;
selector.ParOnFaceS1(1, u, v);
auto curFace = TopoDS::Face(selector.SupportOnShape1(1));
BRepAdaptor_Surface bs(curFace);
uMin = bs.FirstUParameter();
uMax = bs.LastUParameter();
vMin = bs.FirstVParameter();
vMax = bs.LastVParameter();
auto adjU = u - uMin;
auto adjV = v - vMin;
auto adjUMax = uMax - uMin;
auto adjVMax = vMax - vMin;
auto uDis = adjU<uMax-adjU ? adjU : uMax-adjU;
auto vDis = adjV<vMax-adjV ? adjV : vMax-adjV;
if ( uDis < vDis )
{
adjU = adjU<uMax-adjU ? 0 : uMax;
if ( std::abs(adjV-WallThickness_) < WallThickness_/2 )
{
adjV = WallThickness_;
}
else if ( std::abs((adjVMax-WallThickness_) - adjV) < WallThickness_/2 )
{
adjV = adjVMax - WallThickness_;
}
}
else
{
adjV = adjV<vMax-adjV ? 0 : vMax;
if ( std::abs(adjU-WallThickness_) < WallThickness_/2 )
{
adjU = WallThickness_;
}
else if ( std::abs((adjUMax-WallThickness_) - adjU) < WallThickness_/2 )
{
adjU = adjUMax - WallThickness_;
}
}
bs.D0(adjU+uMin, adjV+vMin, curPnt);
}
curPnt.Transform(curWall->GetAbsoluteTransform());
needBreak = true;
break;
}
if ( needBreak )
{
CurrentPos_.X = static_cast<float>(curPnt.X());
CurrentPos_.Y = static_cast<float>(curPnt.Y());
CurrentPos_.Z = static_cast<float>(curPnt.Z());
foundAlign = true;
break;
}
}
}
if ( !foundAlign )
{
if ( StatusMgr::GetInstance().GridAlign_ )
{
CurrentPos_ = *StatusMgr::GetInstance().GridAlign_;
}
}
//检查角度
if ( Pnts_.size() >= 2 )
{
auto& back2 = Pnts_[Pnts_.size()-2];
auto vec1 = (back2 - Pnts_.back()).normalize();
auto vec2 = (CurrentPos_ - Pnts_.back()).normalize();
if ( vec1.dotProduct(vec2) > std::cos(irr::core::degToRad(15.f)) )
{
Checker_ = false;
}
}
//极轴追踪
if ( !Pnts_.empty() && !foundAlign && !StatusMgr::GetInstance().GridAlign_ && Checker_ )
{
vector3df refDir;
if ( Pnts_.size() > 1 )
{
refDir = (Pnts_.back()-Pnts_[Pnts_.size()-2]).normalize();
}
else
{
auto p1 = smgr->getVideoDriver()->getViewPort().UpperLeftCorner;
auto p2 = smgr->getVideoDriver()->getViewPort().LowerRightCorner;
auto line1 = smgr->getSceneCollisionManager()->getRayFromScreenCoordinates(p1);
auto line2 = smgr->getSceneCollisionManager()->getRayFromScreenCoordinates(vector2di(p2.X, p1.Y));
vector3df wp1,wp2;
s_PntPlane.getIntersectionWithLine(line1.start, line1.getVector(), wp1);
s_PntPlane.getIntersectionWithLine(line2.start, line2.getVector(), wp2);
refDir = (wp2-wp1).normalize();
}
auto curVec = CurrentPos_ - Pnts_.back();
auto curDir = curVec;
auto curLength = curVec.getLength();
curDir.normalize();
gp_Dir dRef(refDir.X, refDir.Y, refDir.Z);
gp_Dir dDir(curDir.X, curDir.Y, curDir.Z);
auto rad = dRef.AngleWithRef(dDir, gp::DY());
rad = rad < 0 ? M_PI * 2 + rad : rad;
auto angle = irr::core::radToDeg(rad);
auto rest = std::fmod(angle, PolarAngle_);
if ( rest < PolarAngleRange_/2 )
{
angle -= rest;
}
if ( PolarAngle_-rest < PolarAngleRange_/2 )
{
angle += PolarAngle_ - rest;
}
auto newDir = dRef.Rotated(gp::OY(), irr::core::degToRad(angle));
CurrentPos_ = Pnts_.back() + vector3df(static_cast<float>(newDir.X()), static_cast<float>(newDir.Y()), static_cast<float>(newDir.Z())) * curLength;
}
if ( !Pnts_.empty() )
{//TmpRect_
auto& lastPnt = Pnts_.back();
vector3df dirVec = CurrentPos_ - lastPnt;
auto thickDir = dirVec.normalize().crossProduct(s_PntNormal);
TmpRect_->getPosition(0) = lastPnt;
TmpRect_->getPosition(1) = CurrentPos_;
TmpRect_->getPosition(2) = CurrentPos_ + thickDir * WallThickness_;
TmpRect_->getPosition(3) = lastPnt + thickDir * WallThickness_;
}
}
break;
case DrawingLineWallCtrller::EDWLS_FINISH:
{
if ( Pnts_.size() <= 1 )
{
FaceShape_.Nullify();
}
if ( !FaceShape_.IsNull() )
{
auto newGroup = CGroupODL::CreateByWallPath(GetRenderContextSPtr(), FaceShape_, Pnts_, StatusMgr::GetInstance().CreateWallHeight_);
CurrentRoot_.lock()->AddChild(newGroup);
}
StatusMgr::GetInstance().DrawingState_ = StatusMgr::EDS_NONE;
Reset();
}
break;
case DrawingLineWallCtrller::EDWLS_COUNT:
break;
default:
break;
}
return false;
}
bool RoomLayoutPillarController::PreRender3D()
{
auto& imp_ = *ImpUPtr_;
plane3df plan(0,0,0,0,1,0);
auto line = GetRenderContextSPtr()->Smgr_->getSceneCollisionManager()->getRayFromScreenCoordinates(imp_.CursorIPos_);
plan.getIntersectionWithLine(line.start, line.getVector(), imp_.CurrentPos_);
imp_.CurrentPos_.Y = 0;
gp_Pnt cursorPnt(imp_.CurrentPos_.X, imp_.CurrentPos_.Y, imp_.CurrentPos_.Z);
switch (imp_.State_)
{
case EPilarState::EPS_SWEEPING:
{
if ( GetPickingODL().expired() )
{
break;
}
auto activePilar = std::static_pointer_cast<PillarODL>(GetPickingODL().lock());
activePilar->SetSweeping(true);
if ( imp_.CtrllHolding_ )
{
imp_.State_ = EPilarState::EPS_MODIFY_INIT;
break;
}
if ( imp_.LMousePressDown_ )
{
auto box = activePilar->GetBaseBndBox();
auto pos = activePilar->GetTranslation();
Standard_Real xMin,xMax,yMin,yMax,zMin,zMax;
box.Get(xMin, yMin, zMin, xMax, yMax, zMax);
imp_.EventInfo_ = SEventPillarInfo();
imp_.EventInfo_->XLength_ = static_cast<float>(xMax-xMin);
imp_.EventInfo_->YLength_ = static_cast<float>(yMax-yMin);
imp_.EventInfo_->ZLength_ = static_cast<float>(zMax-zMin);
imp_.EventInfo_->OffsetHeight_ = activePilar->GetOffsetHeight();
imp_.SavePos_ = imp_.CurrentPos_;
imp_.State_ = EPilarState::EPS_MOUSEHOLDING;
}
}
break;
case EPilarState::EPS_MODIFY_INIT:
{
auto activePilar = std::static_pointer_cast<PillarODL>(GetPickingODL().lock());
activePilar->SetSweeping(true);
if ( !imp_.CtrllHolding_ )
{
GetRenderContextSPtr()->CursorControl_->setActiveIcon(gui::ECI_NORMAL);
imp_.State_ = EPilarState::EPS_SWEEPING;
imp_.CtrllHolding_ = false;
break;
}
auto box = activePilar->GetBaseBndBox();
Standard_Real xMin,xMax,yMin,yMax,zMin,zMax;
box.Get(xMin, yMin, zMin, xMax, yMax, zMax);
auto modifyAlign = 100;
Bnd_Box smallBox,bigBox;
smallBox.Update(xMin+modifyAlign < 0 ? xMin+modifyAlign : 0, yMin+modifyAlign < 0 ? yMin+modifyAlign : 0, zMin+modifyAlign < 0 ? zMin+modifyAlign : 0,
xMax-modifyAlign > 0 ? xMax-modifyAlign : 0, yMax-modifyAlign > 0 ? yMax-modifyAlign : 0, zMax-modifyAlign > 0 ? zMax-modifyAlign : 0);
bigBox.Update(xMin-modifyAlign, yMin-modifyAlign, zMin-modifyAlign, xMax+modifyAlign, yMax+modifyAlign, zMax+modifyAlign);
auto relationCursorPnt = cursorPnt.Transformed(activePilar->GetAbsoluteTransform().Inverted());
relationCursorPnt.SetY(0);
if ( Standard_True == bigBox.IsOut(relationCursorPnt) )
{
GetRenderContextSPtr()->CursorControl_->setActiveIcon(gui::ECI_NORMAL);
imp_.State_ = EPilarState::EPS_SWEEPING;
imp_.CtrllHolding_ = false;
break;
}
if ( Standard_False == smallBox.IsOut(relationCursorPnt) )
{
GetRenderContextSPtr()->CursorControl_->setActiveIcon(gui::ECI_NORMAL);
break;
}
gp_Dir cursorDir = gp_Vec(gp::Origin(), relationCursorPnt);
{
auto rad = gp::DX().AngleWithRef(cursorDir, gp::DY());
rad = rad < 0 ? M_PI * 2 + rad : rad;
auto mod = std::fmod(rad, M_PI_2);
if ( mod < M_PI_4 )
{
rad -= mod;
}
else
{
rad = rad - mod + M_PI_2;
}
cursorDir = gp::DX().Rotated(gp::OY(), rad);
mod = std::fmod(rad, M_PI);
if ( mod < Precision::Angular() )
{
GetRenderContextSPtr()->CursorControl_->setActiveIcon(gui::ECI_SIZEWE);
}
else
{
GetRenderContextSPtr()->CursorControl_->setActiveIcon(gui::ECI_SIZENS);
}
}
if ( imp_.LMousePressDown_ )
{
auto edge = BRepBuilderAPI_MakeEdge(gp_Lin(gp::Origin().Transformed(activePilar->GetAbsoluteTransform()), cursorDir.Transformed(activePilar->GetAbsoluteTransform()))).Edge();
BRepAdaptor_Curve moveBC(edge);
GeomAPI_ProjectPointOnCurve ppc(relationCursorPnt.Transformed(activePilar->GetAbsoluteTransform()), moveBC.Curve().Curve());
imp_.ModifyEdge_ = moveBC;
imp_.ModifyPar_ = ppc.LowerDistanceParameter();
imp_.State_ = EPilarState::EPS_MODIFY;
break;
}
}
break;
case EPilarState::EPS_MODIFY:
{
auto activePilar = std::static_pointer_cast<PillarODL>(GetPickingODL().lock());
activePilar->SetPicking(true);
if ( imp_.LMouseLeftUp_ )
{
activePilar->UpdateMesh();
imp_.State_ = EPilarState::EPS_SWEEPING;
break;
}
GeomAPI_ProjectPointOnCurve ppcCur(cursorPnt, imp_.ModifyEdge_.Curve().Curve());
auto curPar = ppcCur.LowerDistanceParameter();
if ( std::abs(curPar - imp_.ModifyPar_) < Precision::Confusion() )
{
break;
}
//偏移的起始点、终点（绝对）
gp_Pnt fromPnt,toPnt;
imp_.ModifyEdge_.D0(imp_.ModifyPar_, fromPnt);
imp_.ModifyEdge_.D0(curPar, toPnt);
gp_Vec moveOffset(fromPnt, toPnt);
auto relationMoveOffset = moveOffset.Transformed(activePilar->GetAbsoluteTransform().Inverted());
auto modifyDir = imp_.ModifyEdge_.Line().Direction().Transformed(activePilar->GetAbsoluteTransform().Inverted());
auto modifyOffset = relationMoveOffset;
{
modifyOffset.SetX(modifyOffset.X() * modifyDir.X());
modifyOffset.SetY(modifyOffset.Y() * modifyDir.Y());
modifyOffset.SetZ(modifyOffset.Z() * modifyDir.Z());
}
auto curPillarSize = activePilar->GetSize();
if ( Standard_False == imp_.ModifyEdge_.Line().Direction().IsEqual(gp_Dir(moveOffset), Precision::Angular()) )
{//防止大小缩成0
auto testSize = curPillarSize + modifyOffset.XYZ();
auto minSize = 100;
auto alignSize = testSize - gp_XYZ(minSize,minSize,minSize);
if ( alignSize.X() < Precision::Confusion() || alignSize.Y() < Precision::Confusion() || alignSize.Z() < Precision::Confusion() )
{
break;
}
}
Bnd_Box pillarBox;
auto pillarBoxSize = curPillarSize + modifyOffset.XYZ();
gp_Trsf pillarTranslation,pillarRotation,pillarTransformation;
{
pillarBox.Update(-pillarBoxSize.X()/2, -pillarBoxSize.Y()/2, -pillarBoxSize.Z()/2, pillarBoxSize.X()/2, pillarBoxSize.Y()/2, pillarBoxSize.Z()/2);
auto translation = activePilar->GetTranslation() + relationMoveOffset.XYZ()/2;
pillarTranslation.SetTranslationPart(translation);
pillarRotation.SetRotation(activePilar->GetRotation());
}
pillarTransformation = pillarTranslation * pillarRotation;
auto offsetHeight = activePilar->GetOffsetHeight();
//新的位置
gp_Pnt newPnt = gp::Origin().Transformed(pillarTransformation);
//吸附距离
static auto alignDis = 200.0;
//当前的吸附物体
auto alignODLs = activePilar->GetAlignList();
alignODLs.erase(std::remove_if(alignODLs.begin(), alignODLs.end(), [&pillarBox,&pillarTransformation](const BaseODLSPtr& alignODL)
{
if ( !alignODL )
{
return true;
}
return alignODL->GetBaseBndBox().Distance(pillarBox.Transformed(alignODL->GetAbsoluteTransform().Inverted() * pillarTransformation)) > alignDis;
}), alignODLs.end());
activePilar->SetAlignList(BaseODLList());
std::multimap<double,BaseODLSPtr> disMap;
for ( auto& curODL : RootODL_.lock()->GetChildrenList() )
{
if ( EODLT_PILLAR != curODL->GetType() && EODLT_WALL != curODL->GetType() )
{
continue;
}
if ( std::find(alignODLs.begin(), alignODLs.end(), curODL) != alignODLs.end() )
{
continue;
}
if ( EODLT_PILLAR == curODL->GetType() && curODL == activePilar )
{
continue;
}
auto dis = curODL->GetBaseBndBox().Distance(pillarBox.Transformed(curODL->GetAbsoluteTransform().Inverted() * pillarTransformation));
if ( dis > alignDis )
{
continue;
}
disMap.emplace(dis, curODL);
}
for ( auto& curODL : disMap )
{
alignODLs.push_back(curODL.second);
}
for ( auto& curODL : alignODLs )
{
auto alignTransformation = curODL->GetAbsoluteTransform();
//调整柱box的旋转
auto activeRotationPillarBox = pillarBox;
{
gp_Trsf tfsODL;
tfsODL.SetRotation(alignTransformation.GetRotation());
activeRotationPillarBox = activeRotationPillarBox.Transformed(tfsODL.Inverted() * pillarRotation);
}
Bnd_Box movingBox,alignODLBox;
{
auto curBox = curODL->GetBaseBndBox();
Standard_Real xAlignMin,yAlignMin,zAlignMin,xAlignMax,yAlignMax,zAlignMax;
curBox.Get(xAlignMin, yAlignMin, zAlignMin, xAlignMax, yAlignMax, zAlignMax);
Standard_Real xPillarMin,yPillarMin,zPillarMin,xPillarMax,yPillarMax,zPillarMax;
activeRotationPillarBox.Get(xPillarMin, yPillarMin, zPillarMin, xPillarMax, yPillarMax, zPillarMax);
movingBox.Update(xAlignMin+xPillarMin, yAlignMin+yPillarMin, zAlignMin+zPillarMin,
xAlignMax+xPillarMax, yAlignMax+yPillarMax, zAlignMax+zPillarMax);
alignODLBox.Update(xAlignMin+xPillarMin-alignDis, yAlignMin+yPillarMin-alignDis, zAlignMin+zPillarMin-alignDis,
xAlignMax+xPillarMax+alignDis, yAlignMax+yPillarMax+alignDis, zAlignMax+zPillarMax+alignDis);
}
auto inODLPnt = newPnt.Transformed(curODL->GetAbsoluteTransform().Inverted());
if ( Standard_True == alignODLBox.IsOut(inODLPnt) )
{
continue;
}
//当前被停靠物体的box shape
Standard_Real xMin,yMin,zMin,xMax,yMax,zMax;
movingBox.Get(xMin, yMin, zMin, xMax, yMax, zMax);
auto alignBoxShape = BRepPrimAPI_MakeBox(gp_Pnt(xMin, yMin, zMin), gp_Pnt(xMax, yMax, zMax)).Shape();
TopExp_Explorer exp(alignBoxShape, TopAbs_SHELL);
BRepExtrema_DistShapeShape dss(imp_.ModifyEdge_.Edge().Moved(curODL->GetAbsoluteTransform().Inverted()), exp.Current());
auto needContinue = false;
std::map<double, gp_Pnt> tmp;
for ( auto index=1; index<=dss.NbSolution(); ++index )
{
if ( dss.SupportTypeShape2(index) == BRepExtrema_IsOnEdge )
{
activePilar->AddAlign(curODL);
needContinue = true;
break;
}
auto pntOnEdge = dss.PointOnShape1(index);
auto pntOnBox = dss.PointOnShape2(index);
if ( pntOnEdge.Distance(pntOnBox) > Precision::Confusion() )
{
continue;
}
tmp.emplace(pntOnEdge.Distance(inODLPnt), pntOnEdge);
}
if ( needContinue )
{
continue;
}
auto foundPnt = tmp.begin()->second.Transformed(curODL->GetAbsoluteTransform());
if ( foundPnt.Distance(newPnt) < 1)
{
activePilar->AddAlign(curODL);
continue;
}
else
{
newPnt = foundPnt;
break;
}
}
auto finalOffset = gp_Vec(pillarTranslation.TranslationPart(), newPnt);
auto finalRelationOffset = finalOffset.Transformed(pillarTransformation.Inverted());
auto finalModifyOffset = finalRelationOffset;
{
finalModifyOffset.SetX(finalModifyOffset.X()*modifyDir.X());
finalModifyOffset.SetY(finalModifyOffset.Y()*modifyDir.Y());
finalModifyOffset.SetZ(finalModifyOffset.Z()*modifyDir.Z());
}
auto finalSize = pillarBoxSize + finalModifyOffset.XYZ();
auto finalTranslation = pillarTranslation.TranslationPart() + finalRelationOffset.XYZ()/2;
activePilar->SetSize(finalSize);
activePilar->SetTranslation(finalTranslation);
{
vector3df newPos(static_cast<float>(finalTranslation.X()), static_cast<float>(finalTranslation.Y()), static_cast<float>(finalTranslation.Z()));
activePilar->GetDataSceneNode()->setPosition(newPos);
}
activePilar->Update2DMesh();
imp_.ModifyPar_ = curPar;
}
break;
case EPilarState::EPS_MOUSEHOLDING:
{
auto activePillar = std::static_pointer_cast<PillarODL>(GetPickingODL().lock());
activePillar->SetPicking(true);
if ( imp_.SavePos_.getDistanceFromSQ(imp_.CurrentPos_) > 100 * 100 )
{
imp_.State_ = EPilarState::EPS_MOVING;
imp_.Valid_ = true;
}
else
if ( imp_.LMouseLeftUp_ )
{
imp_.PropertyCallBack_ = boost::none;
imp_.State_ = EPilarState::EPS_PROPERTY;
auto pointer = reinterpret_cast<int>(static_cast<void*>(&(*imp_.EventInfo_)));
::PostMessage((HWND)GetRenderContextSPtr()->GetHandle(), WM_IRR_DLG_MSG, WM_USER_ROOMLAYOUT_PILLAR_PROPERTY, pointer);
}
}
break;
case EPilarState::EPS_PROPERTY:
{
if ( !imp_.PropertyCallBack_ )
{
break;
}
auto activePillar = std::static_pointer_cast<PillarODL>(GetPickingODL().lock());
switch (*(imp_.PropertyCallBack_))
{
case EUT_ROOMLAYOUT_PILLAR_NONE:
{
imp_.State_ = EPilarState::EPS_SWEEPING;
}
break;
case EUT_ROOMLAYOUT_PILLAR_UPDATE:
{
activePillar->SetSize(imp_.EventInfo_->XLength_, imp_.EventInfo_->YLength_, imp_.EventInfo_->ZLength_);
activePillar->SetOffsetHeight(imp_.EventInfo_->OffsetHeight_);
{
auto curTrans = activePillar->GetTranslation();
curTrans.SetY(imp_.EventInfo_->YLength_/2 + imp_.EventInfo_->OffsetHeight_);
activePillar->SetTranslation(curTrans);
auto curPos = activePillar->GetDataSceneNode()->getPosition();
curPos.Y = static_cast<float>(imp_.EventInfo_->YLength_/2 + imp_.EventInfo_->OffsetHeight_);
activePillar->GetDataSceneNode()->setPosition(curPos);
}
activePillar->UpdateMesh();
imp_.State_ = EPilarState::EPS_SWEEPING;
}
break;
case EUT_ROOMLAYOUT_PILLAR_MOVE:
{
imp_.State_ = EPilarState::EPS_MOVING;
}
break;
case EUT_ROOMLAYOUT_PILLAR_DELETE:
{
activePillar->RemoveFromParent();
imp_.State_ = EPilarState::EPS_SWEEPING;
}
break;
default:
assert(0);
break;
}
}
break;
case EPilarState::EPS_CREATING_INIT:
{
assert(imp_.EventInfo_);
auto newPilar = PillarODL::Create<PillarODL>(GetRenderContextSPtr());
newPilar->SetSize(imp_.EventInfo_->XLength_, imp_.EventInfo_->YLength_, imp_.EventInfo_->ZLength_);
newPilar->SetOffsetHeight(imp_.EventInfo_->OffsetHeight_);
newPilar->UpdateMesh();
RootODL_.lock()->AddChild(newPilar);
auto newPos = imp_.CurrentPos_;
newPos.Y = imp_.EventInfo_->YLength_/2;
newPilar->SetTranslation(gp_XYZ(newPos.X, newPos.Y, newPos.Z));
newPilar->GetDataSceneNode()->setPosition(newPos);
SetPickingODL(newPilar);
imp_.State_ = EPilarState::EPS_MOVING;
}
break;
case EPilarState::EPS_MOVING:
{
auto activePilar = std::static_pointer_cast<PillarODL>(GetPickingODL().lock());
activePilar->SetPicking(true);
activePilar->SetVaildPosition(imp_.Valid_);
if ( imp_.LMouseLeftUp_ )
{
if ( imp_.Valid_ )
{
ImpUPtr_->Valid_ = false;
ImpUPtr_->EventInfo_ = boost::none;
imp_.State_ = EPilarState::EPS_SWEEPING;
break;
}
}
if ( imp_.EscapePressDown_ )
{
activePilar->RemoveFromParent();
imp_.State_ = EPilarState::EPS_SWEEPING;
break;
}
//当前柱的Box
auto activeTransitionBox = activePilar->GetBaseBndBox();
{
gp_Trsf tfs;
tfs.SetTranslationPart(activePilar->GetTranslation());
activeTransitionBox = activeTransitionBox.Transformed(tfs);
}
activePilar->SetRotation(gp_Quaternion(gp::DZ(), gp::DZ()));
activePilar->GetDataSceneNode()->setRotation(vector3df(0));
auto size = activePilar->GetSize();
auto offset = activePilar->GetOffsetHeight();
//新的位置
auto newPos = imp_.CurrentPos_;
newPos.Y = static_cast<float>(size.Y()/2) + offset;
gp_Pnt newPnt(newPos.X, newPos.Y, newPos.Z);
//吸附距离
static auto alignDis = 200.0;
//当前的吸附物体
auto alignODLs = activePilar->GetAlignList();
alignODLs.erase(std::remove_if(alignODLs.begin(), alignODLs.end(), [&activePilar, &activeTransitionBox](const BaseODLSPtr& alignODL)
{
if ( !alignODL )
{
return true;
}
return alignODL->GetBaseBndBox().Distance(activeTransitionBox.Transformed(alignODL->GetAbsoluteTransform().Inverted())) > alignDis;
}), alignODLs.end());
activePilar->SetAlignList(BaseODLList());
std::multimap<double,BaseODLSPtr> disMap;
for ( auto& curODL : RootODL_.lock()->GetChildrenList() )
{
if ( EODLT_PILLAR != curODL->GetType() && EODLT_WALL != curODL->GetType() )
{
continue;
}
if ( std::find(alignODLs.begin(), alignODLs.end(), curODL) != alignODLs.end() )
{
continue;
}
if ( EODLT_PILLAR == curODL->GetType() && curODL == activePilar )
{
continue;
}
auto dis = curODL->GetBaseBndBox().Distance(activeTransitionBox.Transformed(curODL->GetAbsoluteTransform().Inverted()));
if ( dis > alignDis )
{
continue;
}
disMap.emplace(dis, curODL);
}
for ( auto& curODL : disMap )
{
alignODLs.push_back(curODL.second);
}
//锁定旋转
auto lockRotation = false;
//锁定位置
auto lockPosition = false;
//移动方向
TopoDS_Edge movingEdge;
for ( auto& curODL : alignODLs )
{
auto alignTransformation = curODL->GetAbsoluteTransform();
//如果锁定了旋转，则调整柱的box
auto activeRotationPillarBox = activePilar->GetBaseBndBox();
if ( lockRotation )
{
gp_Trsf tfsODL, tfsPillar;
tfsODL.SetRotation(alignTransformation.GetRotation());
tfsPillar.SetRotation(activePilar->GetRotation());
activeRotationPillarBox = activeRotationPillarBox.Transformed(tfsODL.Inverted() * tfsPillar);
}
Bnd_Box movingBox;
{
auto curBox = curODL->GetBaseBndBox();
Standard_Real xAlignMin,yAlignMin,zAlignMin,xAlignMax,yAlignMax,zAlignMax;
curBox.Get(xAlignMin, yAlignMin, zAlignMin, xAlignMax, yAlignMax, zAlignMax);
Standard_Real xPillarMin,yPillarMin,zPillarMin,xPillarMax,yPillarMax,zPillarMax;
activeRotationPillarBox.Get(xPillarMin, yPillarMin, zPillarMin, xPillarMax, yPillarMax, zPillarMax);
movingBox.Update(xAlignMin+xPillarMin, yAlignMin+yPillarMin, zAlignMin+zPillarMin,
xAlignMax+xPillarMax, yAlignMax+yPillarMax, zAlignMax+zPillarMax);
}
auto inODLPnt = newPnt.Transformed(curODL->GetAbsoluteTransform().Inverted());
//当位置锁定了以后，只需要判断是不是相交
if ( lockPosition )
{
if ( Standard_True == movingBox.IsOut(inODLPnt) )
{
continue;
}
Bnd_Box pntBox;
pntBox.Add(inODLPnt);
if ( pntBox.Distance(movingBox) < Precision::Confusion() )
{
continue;
}
imp_.Valid_ = false;
break;
}
Bnd_Box alignODLBox;
{
auto curBox = curODL->GetBaseBndBox();
Standard_Real xAlignMin,yAlignMin,zAlignMin,xAlignMax,yAlignMax,zAlignMax;
curBox.Get(xAlignMin, yAlignMin, zAlignMin, xAlignMax, yAlignMax, zAlignMax);
Standard_Real xPillarMin,yPillarMin,zPillarMin,xPillarMax,yPillarMax,zPillarMax;
activeRotationPillarBox.Get(xPillarMin, yPillarMin, zPillarMin, xPillarMax, yPillarMax, zPillarMax);
alignODLBox.Update(xAlignMin+xPillarMin-alignDis, yAlignMin+yPillarMin-alignDis, zAlignMin+zPillarMin-alignDis,
xAlignMax+xPillarMax+alignDis, yAlignMax+yPillarMax+alignDis, zAlignMax+zPillarMax+alignDis);
}
if ( Standard_True == alignODLBox.IsOut(inODLPnt) )
{
continue;
}
//当前被停靠物体的box shape
Standard_Real xMin,yMin,zMin,xMax,yMax,zMax;
movingBox.Get(xMin, yMin, zMin, xMax, yMax, zMax);
auto alignBoxShape = BRepPrimAPI_MakeBox(gp_Pnt(xMin, yMin, zMin), gp_Pnt(xMax, yMax, zMax)).Shape();
TopExp_Explorer exp(alignBoxShape, TopAbs_SHELL);
if ( !lockRotation )
{//找到第一个被停靠物体
BRepExtrema_DistShapeShape dss(BRepBuilderAPI_MakeVertex(inODLPnt).Shape(), exp.Current());
assert(0 != dss.NbSolution());
inODLPnt = dss.PointOnShape2(1);
newPnt = inODLPnt.Transformed(curODL->GetAbsoluteTransform()).XYZ();
auto rot = curODL->GetAbsoluteTransform().GetRotation();
Standard_Real rX,rY,rZ;
rot.GetEulerAngles(gp_Extrinsic_XYZ, rX, rY, rZ);
vector3df rotation(static_cast<float>(irr::core::radToDeg(rX)), static_cast<float>(irr::core::radToDeg(rY)), static_cast<float>(irr::core::radToDeg(rZ)));
activePilar->GetDataSceneNode()->setRotation(rotation);
activePilar->SetRotation(rot);
gp_Dir movingDir;
if ( std::abs(std::abs(inODLPnt.X()) - xMax) < Precision::Confusion() )
{
movingDir = gp::DZ();
}
else
{
movingDir = gp::DX();
}
auto curMovingEdge = BRepBuilderAPI_MakeEdge(gp_Lin(inODLPnt, movingDir)).Edge();
movingEdge = TopoDS::Edge(curMovingEdge.Moved(curODL->GetAbsoluteTransform()));
activePilar->AddAlign(curODL);
imp_.Valid_ = true;
lockRotation = true;
}
else
{//第二个被停靠物体
BRepExtrema_DistShapeShape dss(movingEdge.Moved(curODL->GetAbsoluteTransform().Inverted()), exp.Current());
auto foundSecond = false;
std::map<double, gp_Pnt> tmp;
for ( auto index=1; index<=dss.NbSolution(); ++index )
{
auto pntOnEdge = dss.PointOnShape1(index);
auto pntOnBox = dss.PointOnShape2(index);
if ( pntOnEdge.Distance(pntOnBox) > Precision::Confusion() )
{
continue;
}
tmp.emplace(pntOnEdge.Distance(inODLPnt), pntOnEdge);
foundSecond = true;
}
if ( !foundSecond )
{
imp_.Valid_ = false;
break;
}
newPnt = tmp.begin()->second.Transformed(curODL->GetAbsoluteTransform());
activePilar->AddAlign(curODL);
lockPosition = true;
}
}
if ( activePilar->GetAlignList().empty() )
{
imp_.Valid_ = true;
}
newPos.X = static_cast<float>(newPnt.X());
newPos.Y = static_cast<float>(newPnt.Y());
newPos.Z = static_cast<float>(newPnt.Z());
activePilar->GetDataSceneNode()->setPosition(newPos);
activePilar->SetTranslation(newPnt.XYZ());
for ( auto& curAlign : activePilar->GetAlignList() )
{
curAlign->SetSweeping(true);
}
}
break;
default:
break;
}
imp_.LMousePressDown_ = false;
imp_.LMouseLeftUp_ = false;
imp_.EscapePressDown_ = false;
return false;
}