//----------------------------------------------------------------------------
void EditRenderView_TimeLine::_TrySelectCurveCtrlPoint(const APoint &pos)
{
APoint origin;
AVector direction;
mRenderStep->GetPickRay(pos.X(), pos.Z(), origin, direction);
Node *gridNode = PX2_EDIT.GetTimeLineEdit()->GetCurveEditNode_Grid();
Picker picker;
picker.Execute(gridNode, origin, direction, 0.0f, Mathf::MAX_REAL);
if ((int)(picker.Records.size()) > 0)
{
Movable *mov = picker.GetClosestNonnegative().Intersected;
CurveCtrl *ctrl = PX2_EDIT.GetTimeLineEdit()->TrySelectCurve(mov);
if (ctrl)
{
//UnToggleAllInterps();
//EnableInterps(true);
//ToggleInterp(ctrl->GetInterpCurveMode());
PX2_EDIT.GetTimeLineEdit()->SetSelectedCurveCtrl(ctrl);
}
else
{
PX2_EDIT.GetTimeLineEdit()->SetSelectedCurveCtrl(0);
}
}
else
{
PX2_EDIT.GetTimeLineEdit()->SetSelectedCurveCtrl(0);
}
}
//----------------------------------------------------------------------------
void EditRenderView_Scene::_ClickSelectPos(const APoint &scrPos)
{
Scene *scene = PX2_PROJ.GetScene();
RenderStep *renderStep = PX2_PROJ.GetSceneRenderStep();
APoint origin;
AVector direction;
renderStep->GetPickRay(scrPos.X(), scrPos.Z(), origin, direction);
ActorPicker actorPicker;
actorPicker.Execute(scene, origin, direction, 0.0f, Mathf::MAX_REAL);
if (actorPicker.Records.size() > 0)
{
const ActorPickRecord &record = actorPicker.GetClosestToZero();
mSelectPoint = origin + direction*record.T;
PX2_EDIT.SetPickPos(mSelectPoint);
}
else
{
PX2::TriMesh *xyPlane = PX2_GR.GetXYPlane();
xyPlane->WorldTransform.SetTranslate(APoint::ORIGIN);
Picker picker;
picker.Execute(xyPlane, origin, direction, 0.0f, Mathf::MAX_REAL);
if ((int)picker.Records.size() > 0)
{
const PickRecord &rec = picker.GetClosestToZero();
mSelectPoint = origin + direction*rec.T;
PX2_EDIT.SetPickPos(mSelectPoint);
}
}
}
//----------------------------------------------------------------------------
void EU_CanvasStage::_UpdateBrushPos(const APoint &scrPos)
{
Project *proj = Project::GetSingletonPtr();
if (!proj) return;
Scene *scene = proj->GetScene();
if (!scene) return;
Terrain *terrain = scene->GetTerrain();
if (!terrain) return;
Movable *pickObject = terrain;
#ifdef _DEBUG
pickObject = PX2_GR.GetXYPlane();
pickObject->WorldTransform.SetTranslate(APoint::ORIGIN);
#endif
Camera *camera = mStageCameraNode->GetCamera();
APoint origin;
AVector direction;
camera->GetPickRay(scrPos.X(), scrPos.Z(), GetSize(), origin, direction);
Picker picker;
picker.Execute(pickObject, origin, direction, 0.0f, Mathf::MAX_REAL);
if ((int)picker.Records.size() > 0)
{
PX2::PickRecord pickRecord = picker.GetClosestToZero();
PX2::APoint dest = origin + direction*pickRecord.T;
PX2_EDIT.GetTerrainEdit()->GetBrush()->SetPos(dest);
}
}
//----------------------------------------------------------------------------
void EU_CanvasStage::_ClickSelectScene(const APoint &scrPos)
{
if (!Project::GetSingletonPtr()) return;
Scene *scene = PX2_PROJ.GetScene();
if (!scene) return;
SelectMode mode = SM_SINGLE;
if (PX2_EDIT.IsCtrlDown) mode = SM_MULTI;
Camera *camera = mStageCameraNode->GetCamera();
APoint origin;
AVector direction;
camera->GetPickRay(scrPos.X(), scrPos.Z(), GetSize(), origin, direction);
Picker picker;
picker.Execute(scene, origin, direction, 0.0f, Mathf::MAX_REAL);
if ((int)picker.Records.size() > 0)
{
const PickRecord &record = picker.GetClosestToZero();
Object *recordObj = record.Intersected;
mSelectPoint = origin + direction*record.T;
PX2_EDIT.SetPickPos(mSelectPoint);
if (SM_SINGLE == mode)
{
int numObjs = PX2_SELECTM_E->GetNumObjects();
if (1 == numObjs && recordObj == PX2_SELECTM_E->GetFirstObject())
{
PX2_SELECTM_E->Clear();
}
else
{
PX2_SELECTM_E->Clear();
PX2_SELECTM_E->AddObject(recordObj);
}
}
else if (SM_MULTI == mode)
{
if (PX2_SELECTM_E->IsObjectIn(recordObj))
{
PX2_SELECTM_E->RemoveObject(recordObj);
}
else
{
PX2_SELECTM_E->AddObject(recordObj);
}
}
}
else
{
if (SM_SINGLE == mode)
{
PX2_SELECTM_E->Clear();
}
}
}
const int Soil::canBreak(const Picker& p)
{
if (type == stHard)
{
knocks += p.getStrength();
if (knocks >= getHardness())
{
knocks = 0;
return 1;
}
else
return 0;
}
else
return 1;
}
//----------------------------------------------------------------------------
void EU_CanvasStage::_ClickSelectPos(const APoint &scrPos)
{
if (!Project::GetSingletonPtr()) return;
Scene *scene = PX2_PROJ.GetScene();
if (!scene) return;
Camera *camera = mStageCameraNode->GetCamera();
APoint origin;
AVector direction;
camera->GetPickRay(scrPos.X(), scrPos.Z(), GetSize(), origin, direction);
Picker picker;
picker.Execute(scene, origin, direction, 0.0f, Mathf::MAX_REAL);
if ((int)picker.Records.size() > 0)
{
const PickRecord &record = picker.GetClosestToZero();
mSelectPoint = origin + direction*record.T;
PX2_EDIT.SetPickPos(mSelectPoint);
}
else
{
PX2::TriMesh *xyPlane = PX2_GR.GetXYPlane();
xyPlane->WorldTransform.SetTranslate(APoint::ORIGIN);
Picker picker;
picker.Execute(xyPlane, origin, direction, 0.0f, Mathf::MAX_REAL);
if ((int)picker.Records.size() > 0)
{
const PickRecord &rec = picker.GetClosestToZero();
mSelectPoint = origin + direction*rec.T;
PX2_EDIT.SetPickPos(mSelectPoint);
}
}
}
//----------------------------------------------------------------------------
void SceneNodeCtrl::OnMotion(bool leftDown, RenderStep *renderStep,
PX2::APoint posNow, PX2::APoint posBefore)
{
PX2_UNUSED(leftDown);
PX2_UNUSED(renderStep);
Renderer *renderer = renderStep->GetRenderer();
Camera *camera = renderStep->GetCamera();
// 光标移动更新
if (DT_NONE == mDragType)
{
GeoObjFactory factory;
DragType dt = GetDragType(renderStep, posNow);
Movable *ctrlMov = 0;
Float4 colorYellowAlpha = Float4(1.0f, 1.0f, 0.0f, 0.3f);
if (DT_X == dt)
{
ctrlMov = GetCurrentCtrlX();
factory.UpdateCtrlColor(renderer, ctrlMov, Float4::YELLOW);
}
else if (DT_Y == dt)
{
ctrlMov = GetCurrentCtrlY();
factory.UpdateCtrlColor(renderer, ctrlMov, Float4::YELLOW);
}
else if (DT_Z == dt)
{
ctrlMov = GetCurrentCtrlZ();
factory.UpdateCtrlColor(renderer, ctrlMov, Float4::YELLOW);
}
else if (DT_XY == dt)
{
factory.UpdateCtrlColor1(renderer, GetCurrentCtrlXY(), colorYellowAlpha);
factory.UpdateCtrlColor1(renderer, GetCurrentCtrlYZ(), Float4::ZERO);
factory.UpdateCtrlColor1(renderer, GetCurrentCtrlXZ(), Float4::ZERO);
}
else if (DT_YZ == dt)
{
factory.UpdateCtrlColor1(renderer, GetCurrentCtrlYZ(), colorYellowAlpha);
factory.UpdateCtrlColor1(renderer, GetCurrentCtrlXY(), Float4::ZERO);
factory.UpdateCtrlColor1(renderer, GetCurrentCtrlXZ(), Float4::ZERO);
}
else if (DT_XZ == dt)
{
factory.UpdateCtrlColor1(renderer, GetCurrentCtrlXZ(), colorYellowAlpha);
factory.UpdateCtrlColor1(renderer, GetCurrentCtrlXY(), Float4::ZERO);
factory.UpdateCtrlColor1(renderer, GetCurrentCtrlYZ(), Float4::ZERO);
}
else if (DT_XYZ == dt)
{
factory.UpdateCtrlColor1(renderer, GetCurrentCtrlXYZ(), Float4::YELLOW);
}
else if (DT_NONE == dt)
{
factory.UpdateCtrlColor(renderer, GetCurrentCtrlX(), Float4::RED);
factory.UpdateCtrlColor(renderer, GetCurrentCtrlY(), Float4::GREEN);
factory.UpdateCtrlColor(renderer, GetCurrentCtrlZ(), Float4::BLUE);
factory.UpdateCtrlColor1(renderer, GetCurrentCtrlXY(), Float4::ZERO);
factory.UpdateCtrlColor1(renderer, GetCurrentCtrlYZ(), Float4::ZERO);
factory.UpdateCtrlColor1(renderer, GetCurrentCtrlXZ(), Float4::ZERO);
factory.UpdateCtrlColor1(renderer, GetCurrentCtrlXYZ(), Float4::WHITE);
}
if (DT_NONE == dt)
{
Event *ent = EditEventSpace::CreateEventX(EditEventSpace::SceneNodeDrag);
ent->SetData<int>(0);
EventWorld::GetSingleton().BroadcastingLocalEvent(ent);
}
else
{
Event *ent = EditEventSpace::CreateEventX(EditEventSpace::SceneNodeDrag);
ent->SetData<int>(1);
EventWorld::GetSingleton().BroadcastingLocalEvent(ent);
}
}
if (DT_NONE == mDragType) return;
else
{
Event *ent = EditEventSpace::CreateEventX(EditEventSpace::SceneNodeDrag);
ent->SetData<int>(1);
EventWorld::GetSingleton().BroadcastingLocalEvent(ent);
}
int numObjs = PX2_SELECTION.GetNumObjects();
if (0 == numObjs)
return;
// get pickPoint with the plane
TriMesh *meshHelp = PX2_GR.GetXYPlane();
if (DT_X == mDragType)
{
if (LT_PERSPECTIVE == mLookType || LT_TOP == mLookType)
meshHelp = PX2_GR.GetXYPlane();
else if (LT_FRONT == mLookType)
meshHelp = PX2_GR.GetXZPlane();
}
else if (DT_Y == mDragType)
{
meshHelp = PX2_GR.GetXYPlane();
}
else if (DT_Z == mDragType)
{
AVector cameraDir = camera->GetDVector();
cameraDir.Normalize();
float dotVal = Mathf::FAbs(cameraDir.Dot(AVector::UNIT_X));
if (dotVal > 0.7f)
{
meshHelp = PX2_GR.GetYZPlane();
}
else
{
meshHelp = PX2_GR.GetXZPlane();
}
}
else if (DT_XY == mDragType)
{
meshHelp = PX2_GR.GetXYPlane();
}
else if (DT_YZ == mDragType)
{
meshHelp = PX2_GR.GetYZPlane();
}
else if (DT_XZ == mDragType)
{
meshHelp = PX2_GR.GetXZPlane();
}
else if (DT_XYZ == mDragType)
{
meshHelp = PX2_GR.GetXYPlane();
}
meshHelp->WorldTransform.SetTranslate(GetPosition());
// get pick ray
APoint rayOrigin_Now;
AVector rayDir_Now;
renderStep->GetPickRay(posNow.X(), posNow.Z(), rayOrigin_Now, rayDir_Now);
APoint rayOrigin_Before;
AVector rayDir_Before;
renderStep->GetPickRay(posBefore.X(), posBefore.Z(), rayOrigin_Before, rayDir_Before);
// pick
Picker pickerNow;
pickerNow.Execute(meshHelp, rayOrigin_Now, rayDir_Now, 0.0f, Mathf::MAX_REAL);
float lengthNow = pickerNow.GetClosestToZero().T;
APoint positionNow(rayOrigin_Now + rayDir_Now*lengthNow);
Picker pickerOrigin;
pickerOrigin.Execute(meshHelp, rayOrigin_Before, rayDir_Before, 0.0f, Mathf::MAX_REAL);
float lengthBefore = pickerOrigin.GetClosestToZero().T;
APoint positionBefore(rayOrigin_Before + rayDir_Before*lengthBefore);
if (pickerNow.Records.empty() || pickerOrigin.Records.empty()) return;
AVector transMoved = positionNow - positionBefore;
AVector transDir = transMoved;
transDir.Normalize();
float transValue = 0.0f;
float transValue1 = 0.0f;
AVector transVec;
AVector rolateVec;
AVector dirX = mDirX;
AVector dirY = mDirY;
AVector dirZ = mDirZ;
if (DT_X == mDragType)
{
transValue = transMoved.Dot(dirX);
transVec = dirX * transValue;
rolateVec.X() = transMoved.Length() *(1.0f - Mathf::FAbs(transDir.Dot(dirX)));
AVector vec = transDir.Cross(dirX);
rolateVec.X() *= Mathf::Sign(vec.Z());
}
else if (DT_Y == mDragType)
{
transValue = transMoved.Dot(dirY);
transVec = dirY * transValue;
rolateVec.Y() = transMoved.Length() *(1.0f - Mathf::FAbs(transDir.Dot(dirY)));
AVector vec = transDir.Cross(dirY);
rolateVec.Y() *= Mathf::Sign(vec.Z());
}
else if (DT_Z == mDragType)
{
transValue = transMoved.Dot(dirZ);
transVec = dirZ * transValue;
rolateVec.Z() = transMoved.Length() *(1.0f - Mathf::FAbs(transDir.Dot(dirZ)));
rolateVec.Z() *= Mathf::Sign(posNow.X() - posBefore.X());
}
else if (DT_XY == mDragType)
{
transValue = transMoved.Dot(dirX);
transValue1 = transMoved.Dot(dirY);
transVec = dirX * transValue + dirY * transValue1;
}
else if (DT_YZ == mDragType)
{
transValue = transMoved.Dot(dirY);
transValue1 = transMoved.Dot(dirZ);
transVec = dirY * transValue + dirZ * transValue1;
}
else if (DT_XZ == mDragType)
{
transValue = transMoved.Dot(dirX);
transValue1 = transMoved.Dot(dirZ);
transVec = dirX * transValue + dirZ * transValue1;
}
else if (DT_XYZ == mDragType)
{
float transValue0 = Mathf::FAbs(transMoved.Dot(dirX));
float transValue1 = Mathf::FAbs(transMoved.Dot(dirY));
float transValue2 = Mathf::FAbs(transMoved.Dot(dirZ));
float trans = (transValue0 + transValue1 + transValue2) / 3.0f;
trans *= Mathf::Sign(transMoved.Y());
transVec = AVector(trans, trans, trans);
}
if (CT_SCALE == mCtrlType)
transVec *= 0.5f;
HMatrix parentMat = mParentRotateMat.Inverse();
transVec = parentMat * transVec;
if (CT_TRANSLATE == mCtrlType)
{
PX2_SELECTION.Translate(transVec);
UpdateCtrlTrans();
}
else if (CT_ROLATE == mCtrlType)
{
PX2_SELECTION.AddRolate(rolateVec);
}
else if (CT_SCALE == mCtrlType)
{
if (DT_XYZ == mDragType)
PX2_SELECTION.AddScale(transVec);
}
Object *obj = PX2_SELECTION.GetFirstObject();
if (obj)
{
Event *ent = EditEventSpace::CreateEventX(
EditEventSpace::ObjectTransformChanged);
ent->SetData<Object*>(obj);
EventWorld::GetSingleton().BroadcastingLocalEvent(ent);
}
mCtrlsGroup->Update(Time::GetTimeInSeconds(), false);
}
