void EditorBodyControl::Update(float32 timeElapsed)
{
Entity * selection = scene->GetProxy();
if (selection)
{
rotationCenter = selection->GetWorldTransform().GetTranslationVector();
ArrowsNode* arrowsNode = GetArrowsNode(true);
if (arrowsNode)
UpdateArrowsNode(selection);
}
else
{
ArrowsNode* arrowsNode = GetArrowsNode(false);
if (arrowsNode)
{
arrowsNode->SetVisible(false);
SceneData *activeScene = SceneDataManager::Instance()->SceneGetActive();
activeScene->RemoveSceneNode(arrowsNode);
}
}
if(cameraController)
{
cameraController->Update(timeElapsed);
}
if(currentLandscapeEditor)
{
currentLandscapeEditor->Update(timeElapsed);
}
UIControl::Update(timeElapsed);
}
void EditorBodyControl::InitMoving(const Vector2 & point)
{
//init planeNormal
ArrowsNode* arrowsNode = GetArrowsNode(false);
if (!arrowsNode) return;
switch (arrowsNode->GetModAxis())
{
case ArrowsNode::AXIS_X:
case ArrowsNode::AXIS_Y:
case ArrowsNode::AXIS_XY:
planeNormal = Vector3(0,0,1);
break;
case ArrowsNode::AXIS_Z:
case ArrowsNode::AXIS_YZ:
planeNormal = Vector3(1,0,0);
break;
case ArrowsNode::AXIS_XZ:
planeNormal = Vector3(0,1,0);
break;
default:
break;
}
Vector3 from, dir;
GetCursorVectors(&from, &dir, point);
GetIntersectionVectorWithPlane(from, dir, planeNormal, rotationCenter, startDragPoint);
}
void EditorBodyControl::SetModificationMode(ResourceEditor::eModificationActions mode)
{
modificationMode = mode;
ArrowsNode* arrowsNode = GetArrowsNode(false);
if (arrowsNode)
{
arrowsNode->SetActive(InModificationMode());
}
}
ArrowsNode* EditorBodyControl::GetArrowsNode(bool createIfNotExist)
{
DVASSERT(scene);
ArrowsNode* arrowsNode = dynamic_cast<ArrowsNode*>(scene->FindByName(ResourceEditor::EDITOR_ARROWS_NODE));
if (!arrowsNode && createIfNotExist)
{
arrowsNode = new ArrowsNode();
arrowsNode->SetName(ResourceEditor::EDITOR_ARROWS_NODE);
EditorScene *scene = SceneDataManager::Instance()->SceneGetActive()->GetScene();
scene->AddEditorEntity(arrowsNode);
arrowsNode->Release();
}
return arrowsNode;
}
void EditorBodyControl::UpdateArrowsNode(Entity* node)
{
ArrowsNode* arrowsNode = GetArrowsNode(false);
if (node && arrowsNode)
{
if (node == arrowsNode)
{
arrowsNode->SetVisible(false);
return;
}
Matrix4 nodeWT = node->GetWorldTransform();
Matrix4 arrowsNodeTransform;
arrowsNodeTransform.CreateTranslation(nodeWT.GetTranslationVector());
arrowsNode->SetLocalTransform(arrowsNodeTransform);
arrowsNode->SetVisible(true);
arrowsNode->SetActive(InModificationMode());
}
}
void EditorBodyControl::LandscapeEditorStarted()
{
RemoveControl(modificationPanel);
savedModificatioMode = modificationPanel->IsModificationMode();
UIControl *toolsPanel = currentLandscapeEditor->GetToolPanel();
if(!toolsPanel->GetParent())
{
AddControl(toolsPanel);
}
Entity* sceneNode = FindLandscapeEntity(scene);
if (sceneNode)
{
scene->SetSelection(sceneNode);
SelectNodeAtTree(NULL);
SelectNodeAtTree(sceneNode);
}
landscapeToolsSelection->Show();
ArrowsNode* arrowsNode = GetArrowsNode(false);
if (arrowsNode)
arrowsNode->SetVisible(false);
}
void EditorBodyControl::PrepareModMatrix(const Vector2 & point)
{
float32 winx = point.x - touchStart.x;
float32 winy = point.y - touchStart.y;
Matrix4 modification;
modification.Identity();
ArrowsNode* arrowsNode = GetArrowsNode(false);
if (!arrowsNode)
return;
if (GetModificationMode() == ResourceEditor::MODIFY_MOVE)
{
Vector3 from, dir;
GetCursorVectors(&from, &dir, point);
Vector3 currPoint;
bool result = GetIntersectionVectorWithPlane(from, dir, planeNormal, rotationCenter, currPoint);
if (result)
{
if (arrowsNode)
{
switch (arrowsNode->GetModAxis())
{
case ArrowsNode::AXIS_X:
currPoint.y = startDragPoint.y;
currPoint.z = startDragPoint.z;
break;
case ArrowsNode::AXIS_Y:
currPoint.x = startDragPoint.x;
currPoint.z = startDragPoint.z;
break;
case ArrowsNode::AXIS_Z:
currPoint.x = startDragPoint.x;
currPoint.y = startDragPoint.y;
break;
default:
break;
}
modification.CreateTranslation(currPoint - startDragPoint);
}
}
}
else if (GetModificationMode() == ResourceEditor::MODIFY_ROTATE)
{
Matrix4 d;
switch (arrowsNode->GetModAxis())
{
case ArrowsNode::AXIS_X:
case ArrowsNode::AXIS_Y:
modification.CreateRotation(vect[arrowsNode->GetModAxis()], winy / 100.0f);
break;
case ArrowsNode::AXIS_Z:
modification.CreateRotation(vect[arrowsNode->GetModAxis()], winx / 100.0f);
break;
case ArrowsNode::AXIS_XY:
modification.CreateRotation(vect[ArrowsNode::AXIS_X], winx / 100.0f);
d.CreateRotation(vect[ArrowsNode::AXIS_Y], winy / 100.0f);
modification *= d;
break;
case ArrowsNode::AXIS_YZ:
modification.CreateRotation(vect[ArrowsNode::AXIS_Y], winx / 100.0f);
d.CreateRotation(vect[ArrowsNode::AXIS_Z], winy / 100.0f);
modification *= d;
break;
case ArrowsNode::AXIS_XZ:
modification.CreateRotation(vect[ArrowsNode::AXIS_X], winx / 100.0f);
d.CreateRotation(vect[ArrowsNode::AXIS_Z], winy / 100.0f);
modification *= d;
break;
default:
break;
}
modification = (translate1 * modification) * translate2;
}
else if (GetModificationMode() == ResourceEditor::MODIFY_SCALE)
{
float kf = winx / 100.0f;
if (kf < -1.0)
kf = - kf - 2.0;
modification.CreateScale(Vector3(1,1,1) + Vector3(1,1,1) * kf);
modification = (translate1 * modification) * translate2;
}
currTransform = startTransform * modification;
}
bool EditorBodyControl::ProcessMouse(UIEvent *event)
{
Entity * selection = scene->GetProxy();
//selection with second mouse button
if (event->tid == UIEvent::BUTTON_1)
{
if (event->phase == UIEvent::PHASE_BEGAN)
{
isDrag = false;
inTouch = true;
touchStart = event->point;
if (selection)
{
modifiedNode = selection;
transformBeforeModification = selection->GetLocalTransform();
}
}
else if (event->phase == UIEvent::PHASE_DRAG)
{
if (!isDrag)
{
Vector2 d = event->point - touchStart;
if (selection && d.Length() > 5 && InModificationMode())
{
ArrowsNode* arrowsNode = GetArrowsNode(false);
if (arrowsNode && arrowsNode->GetModAxis() != ArrowsNode::AXIS_NONE)
{
isDrag = true;
if (InputSystem::Instance()->GetKeyboard()->IsKeyPressed(DVKEY_SHIFT))
{
originalNode = scene->GetProxy();
//create temporary node to calculate transform
modifiedNode = originalNode->Clone();
originalNode->GetParent()->AddNode(modifiedNode);
SelectNode(modifiedNode);
selection = modifiedNode;
//store original transform
transformBeforeModification = modifiedNode->GetLocalTransform();
}
if (selection)
{
scene->SetBulletUpdate(selection, false);
inTouch = true;
touchStart = event->point;
startTransform = selection->GetLocalTransform();
InitMoving(event->point);
translate1.CreateTranslation(-rotationCenter);
translate2.CreateTranslation(rotationCenter);
//calculate koefficient for moving
Camera * cam = scene->GetCurrentCamera();
const Vector3 & camPos = cam->GetPosition();
const Matrix4 & wt = selection->GetWorldTransform();
Vector3 objPos = Vector3(0,0,0) * wt;
Vector3 dir = objPos - camPos;
moveKf = (dir.Length() - cam->GetZNear()) * 0.003;
}
}
}
}
else
{
if (selection && InModificationMode())
{
Landscape *landscape = dynamic_cast<Landscape *>(selection);
if(!landscape)
{
PrepareModMatrix(event->point);
if (IsLandscapeRelative())
{
currTransform = currTransform * GetLandscapeOffset(currTransform);
}
selection->SetLocalTransform(currTransform);
if(currentGraph)
{
currentGraph->UpdateMatricesForCurrentNode();
}
}
}
}
}
else if (event->phase == UIEvent::PHASE_ENDED)
{
inTouch = false;
if (isDrag)
{
// originalNode should be non-zero only when clone node
if (originalNode)
{
// Get final transform from temporary node
Matrix4 transform = modifiedNode->GetLocalTransform();
// Remove temporary node
RemoveSelectedSGNode();
SafeRelease(modifiedNode);
CommandCloneAndTransform* cmd = new CommandCloneAndTransform(originalNode,
transform,
this,
scene->collisionWorld);
CommandsManager::Instance()->ExecuteAndRelease(cmd, scene);
originalNode = NULL;
// update selection to newly created node
selection = scene->GetProxy();
}
else
{
CommandsManager::Instance()->ExecuteAndRelease(new CommandTransformObject(modifiedNode,
transformBeforeModification,
modifiedNode->GetLocalTransform()),
scene);
}
if (selection)
{
scene->SetBulletUpdate(selection, true);
}
}
else
{
Vector3 from, dir;
GetCursorVectors(&from, &dir, event->point);
Vector3 to = from + dir * 1000.0f;
scene->TrySelection(from, to);
selection = scene->GetProxy();
SelectNodeAtTree(selection);
}
}
}
else
{
cameraController->SetSelection(selection);
if (event->phase == UIEvent::PHASE_KEYCHAR)
{
UITextField *tf = dynamic_cast<UITextField *>(UIControlSystem::Instance()->GetFocusedControl());
if(!tf)
{
cameraController->Input(event);
}
}
else
{
cameraController->Input(event);
}
}
ArrowsNode* arrowsNode = GetArrowsNode(false);
if (arrowsNode && arrowsNode->GetVisible() && !inTouch && event->phase != UIEvent::PHASE_KEYCHAR)
{
Vector3 from, dir;
GetCursorVectors(&from, &dir, event->point);
Vector3 to = from + dir * 1000.0f;
arrowsNode->ProcessMouse(event, from, dir);
}
return true;
}
void EditorBodyControl::Update(float32 timeElapsed)
{
Entity * selection = scene->GetProxy();
if (selection)
{
rotationCenter = selection->GetWorldTransform().GetTranslationVector();
ArrowsNode* arrowsNode = GetArrowsNode(true);
if (arrowsNode)
UpdateArrowsNode(selection);
}
else
{
ArrowsNode* arrowsNode = GetArrowsNode(false);
if (arrowsNode)
{
arrowsNode->SetVisible(false);
SceneData *activeScene = SceneDataManager::Instance()->SceneGetActive();
activeScene->RemoveSceneNode(arrowsNode);
}
}
if(cameraController)
{
cameraController->Update(timeElapsed);
}
if(currentLandscapeEditor)
{
currentLandscapeEditor->Update(timeElapsed);
}
UIControl::Update(timeElapsed);
BeastProxy::Instance()->Update(beastManager);
if(BeastProxy::Instance()->IsJobDone(beastManager))
{
PackLightmaps();
BeastProxy::Instance()->SafeDeleteManager(&beastManager);
Landscape *land = scene->GetLandscape(scene);
if(land)
{
FilePath textureName = land->GetTextureName(DAVA::Landscape::TEXTURE_COLOR);
textureName.ReplaceFilename("temp_beast.png");
FileSystem::Instance()->DeleteFile(textureName);
}
#if defined (__DAVAENGINE_WIN32__)
BeastCommandLineTool *beastTool = dynamic_cast<BeastCommandLineTool *>(CommandLineManager::Instance()->GetActiveCommandLineTool());
if(beastTool)
{
QtMainWindowHandler::Instance()->SaveScene(scene, beastTool->GetScenePathname());
bool forceClose = CommandLineParser::CommandIsFound(String("-force"))
|| CommandLineParser::CommandIsFound(String("-forceclose"));
if(forceClose)
Core::Instance()->Quit();
}
#endif //#if defined (__DAVAENGINE_WIN32__)
QtMainWindowHandler::Instance()->ReloadSceneTextures();
}
}