private void _panel_MouseClick(object sender, MouseEventArgs e)
{
Point point = new Point(e.X, e.Y);
Engine.QueueForRenderDispatcher(() =>
{
if (e.Button == MouseButtons.Left)
{
Ray ray;
RaySceneQueryResult.Enumerator itr = GetRaySceneQuery(point.X, point.Y, out ray);
if (itr != null)
{
while (itr.MoveNext())
{
RaySceneQueryResultEntry entry = itr.Current;
SceneNode parentNode = entry.movable.ParentSceneNode;
PositionedInstance instance = Engine.SceneNodeStore.GetInstance(parentNode);
if (instance != null)
{
Engine.RunOnUIThread(() =>
{
IoC.Get <IExplorer>().SelectInstance(instance);
});
ActiveScene.SelectedInstance = instance;
SetActiveSelectedNode(parentNode);
return;
}
}
SceneNode node;
if (ExistsSelectedNode(out node))
{
PositionedInstance oldInstance = Engine.SceneNodeStore.GetInstance(node);
if (oldInstance != null)
{
SizedInstance oldSized = oldInstance as SizedInstance;
if (oldSized != null)
{
oldSized.IsSelected = false;
oldSized.IsBoundingBoxEnabled = false;
}
}
ActiveScene.SelectedInstance = null;
oldInstance.RemoveGizmoVisual();
ClearSelectedNode();
}
}
}
});
}
public void SetActiveSelectedNode(SceneNode newNode)
{
PositionedInstance instance = Engine.SceneNodeStore.GetInstance(newNode);
if (instance == null)
{
return;
}
SceneNode node;
if (ExistsSelectedNode(out node))
{
if (!newNode.Equals(node))
{
PositionedInstance oldInstance = Engine.SceneNodeStore.GetInstance(node);
if (oldInstance != null)
{
SizedInstance oldSized = oldInstance as SizedInstance;
if (oldSized != null)
{
oldSized.IsSelected = false;
oldSized.IsBoundingBoxEnabled = false;
}
oldInstance.RemoveGizmoVisual();
ClearSelectedNode();
}
SizedInstance sized = instance as SizedInstance;
if (sized != null)
{
sized.IsBoundingBoxEnabled = true;
sized.IsSelected = true;
}
SetSelectedNode(newNode);
instance.SetGizmoVisual(new GizmoVisual(_gizmoNode));
}
}
else
{
SizedInstance sized = instance as SizedInstance;
if (sized != null)
{
sized.IsBoundingBoxEnabled = true;
sized.IsSelected = true;
}
SetSelectedNode(newNode);
instance.SetGizmoVisual(new GizmoVisual(_gizmoNode));
}
}
public void AddToHoverNode(SceneNode newNode)
{
if (!IsAlreadyHovered(newNode))
{
if (!IsSelectedNode(newNode))
{
PositionedInstance instance = Engine.SceneNodeStore.GetInstance(newNode);
if (instance != null)
{
SizedInstance sized = instance as SizedInstance;
if (sized != null)
{
sized.IsBoundingBoxEnabled = true;
}
MarkAsHovered(newNode);
}
}
}
}
Task ICommandHandler <PasteInstanceCommandDefinition> .Run(Command command)
{
if (ActiveScene.CopiedInstance != null)
{
Instance instance = ActiveScene.CopiedInstance.clone();
SizedInstance positioned = instance as SizedInstance;
if (positioned != null)
{
Vector3 vector = Engine.GetBestLocationFromYDown(
new Vector3(
positioned.position.x + (positioned.size.x / 2),
positioned.position.y + (positioned.size.y / 2),
positioned.position.z + (positioned.size.z / 2)
),
positioned.position.y + (positioned.size.y / 2),
positioned.size.y / 2);
positioned.position.y = vector.y;
}
}
return(TaskUtility.Completed);
}
private void _panel_MouseMove(object sender, MouseEventArgs e)
{
if (_oldMousePosition == null)
{
_oldMousePosition = new Point(e.X, e.Y);
return;
}
Point point = new Point(e.X, e.Y);
Engine.QueueForRenderDispatcher(() =>
{
double deltaDirectionX = point.X - _oldMousePosition.X;
double deltaDirectionY = point.Y - _oldMousePosition.Y;
if (e.Button.HasFlag(MouseButtons.Right))
{
ActiveScene.Context.ActiveWorld.Camera.pitch(new Radian((float)-deltaDirectionY / 200f).ValueDegrees);
ActiveScene.Context.ActiveWorld.Camera.yaw(new Radian((float)-deltaDirectionX / 200f).ValueDegrees);
}
IEnumerable <SceneNode> selected = GetSelectedNode();
SceneNode selectedNode = null;
if (selected != null)
{
selectedNode = selected.FirstOrDefault();
}
if (_translateDragging != TransformDragging.NONE && ActiveScene.ActiveGizmoType == Misc.Runtime.GizmoType.TRANSLATE)
{
if (selectedNode != null)
{
Plane plane = new Plane();
if (_translateDragging == TransformDragging.X)
{
Vector3 normal = Vector3.UNIT_Y;
plane = new Plane(normal, selectedNode.Position);
}
else if (_translateDragging == TransformDragging.Y)
{
Vector3 normal = (Engine.Renderer.Camera.Position - selectedNode.Position).NormalisedCopy;
normal.y = 0;
plane = new Plane(normal, selectedNode.Position);
}
else if (_translateDragging == TransformDragging.Z)
{
Vector3 normal = Vector3.UNIT_Y;
plane = new Plane(normal, selectedNode.Position);
}
Vector3 translateVector;
if (GetRaySceneLocationWithPlane(point.X, point.Y, plane, out translateVector, selectedNode))
{
PositionedInstance instance = Engine.SceneNodeStore.GetInstance(selectedNode);
SizedInstance sized = instance as SizedInstance;
if (sized != null)
{
translateVector -= _translateDragDifference;
if (_translateDragging == TransformDragging.X)
{
instance.position.x = (float)System.Math.Round(translateVector.x - (sized.size.x / 2));
//PhysicsEngine.GetCollisionVectorResolvement(instance as PhysicsInstance);
}
else if (_translateDragging == TransformDragging.Y)
{
instance.position.y = (float)System.Math.Round(translateVector.y - (sized.size.y / 2));
//PhysicsEngine.GetCollisionVectorResolvement(instance as PhysicsInstance);
}
else if (_translateDragging == TransformDragging.Z)
{
instance.position.z = (float)System.Math.Round(translateVector.z - (sized.size.z / 2));
//PhysicsEngine.GetCollisionVectorResolvement(instance as PhysicsInstance);
}
}
}
}
}
else if (_scaleDragging != DirectionalTransformDragging.NONE && ActiveScene.ActiveGizmoType == Misc.Runtime.GizmoType.SCALE)
{
if (selectedNode != null)
{
Plane plane = new Plane();
if (_scaleDragging == DirectionalTransformDragging.XA || _scaleDragging == DirectionalTransformDragging.XB)
{
Vector3 normal = Vector3.UNIT_Y;
plane = new Plane(normal, selectedNode.Position);
}
else if (_scaleDragging == DirectionalTransformDragging.YA || _scaleDragging == DirectionalTransformDragging.YB)
{
Vector3 normal = (Engine.Renderer.Camera.Position - selectedNode.Position).NormalisedCopy;
normal.y = 0;
plane = new Plane(normal, selectedNode.Position);
}
else if (_scaleDragging == DirectionalTransformDragging.ZA || _scaleDragging == DirectionalTransformDragging.ZB)
{
Vector3 normal = Vector3.UNIT_Y;
plane = new Plane(normal, selectedNode.Position);
}
Vector3 scaleVector;
if (GetRaySceneLocationWithPlane(point.X, point.Y, plane, out scaleVector, selectedNode))
{
PositionedInstance instance = Engine.SceneNodeStore.GetInstance(selectedNode);
SizedInstance sized = instance as SizedInstance;
if (sized != null)
{
int magicOffsetA = 2;
if (_scaleDragging == DirectionalTransformDragging.XA)
{
sized.size.x = System.Math.Max(1, (float)System.Math.Round(scaleVector.x - (sized.position.x) - magicOffsetA));
}
else if (_scaleDragging == DirectionalTransformDragging.YA)
{
sized.size.y = System.Math.Max(1, (float)System.Math.Round(scaleVector.y - (sized.position.y) - magicOffsetA));
}
else if (_scaleDragging == DirectionalTransformDragging.ZA)
{
sized.size.z = System.Math.Max(1, (float)System.Math.Round(scaleVector.z - (sized.position.z) - magicOffsetA));
}
else if (_scaleDragging == DirectionalTransformDragging.XB)
{
//TODO: fix
float newX = scaleVector.x + (sized.size.x / 2) + _scaleDragDifference.x; //wtf?
float delta = (sized.position.x - newX);
float rounded = (float)System.Math.Round(delta);
sized.position.x -= rounded;
sized.size.x += rounded;
}
else if (_scaleDragging == DirectionalTransformDragging.YB)
{
}
else if (_scaleDragging == DirectionalTransformDragging.ZB)
{
}
}
}
}
}
Cursor cursor = null;
if (_translateFreeDragging && _scaleDragging == DirectionalTransformDragging.NONE && _translateDragging == TransformDragging.NONE)
{
if (selectedNode != null)
{
Plane plane = new Plane(Vector3.UNIT_Y, Engine.Renderer.Camera.Position.y - 16);
Vector3 vector;
if (GetRaySceneLocationWithPlane(point.X, point.Y, plane, out vector, selectedNode))
{
PositionedInstance instance = Engine.SceneNodeStore.GetInstance(selectedNode);
SizedInstance sized = instance as SizedInstance;
if (sized != null)
{
instance.position.x = (float)System.Math.Round(vector.x - (sized.size.x / 2));
instance.position.y = (float)System.Math.Round(vector.y - (sized.size.y / 2));
instance.position.z = (float)System.Math.Round(vector.z - (sized.size.z / 2));
}
}
cursor = Cursors.NoMove2D;
}
else
{
_translateFreeDragging = false;
}
}
Ray ray;
RaySceneQueryResult.Enumerator itr = GetRaySceneQuery(point.X, point.Y, out ray);
if (itr != null)
{
bool nothing = true;
while (itr.MoveNext())
{
RaySceneQueryResultEntry entry = itr.Current;
if (entry.movable.QueryFlags != (uint)QueryFlags.IGNORE_ALL)
{
nothing = false;
}
if (entry.movable.QueryFlags == (uint)QueryFlags.INSTANCE_ENTITY)
{
SceneNode parentNode = entry.movable.ParentSceneNode;
if (selectedNode != null && selectedNode.Equals(parentNode) && e.Button.HasFlag(MouseButtons.Left) && _translateDragging == TransformDragging.NONE)
{
if (System.Math.Abs(deltaDirectionX) >= TRANSLATE_DRAG_THRESHOLD || System.Math.Abs(deltaDirectionY) >= TRANSLATE_DRAG_THRESHOLD)
{
_translateFreeDragging = true;
}
}
if (!IsAlreadyHovered(parentNode))
{
IEnumerable <SceneNode> hovered = GetHoveredNodes();
if (hovered != null)
{
foreach (SceneNode node in hovered)
{
if (!IsSelectedNode(node))
{
PositionedInstance oldInstance = Engine.SceneNodeStore.GetInstance(node);
if (oldInstance != null)
{
SizedInstance oldSized = oldInstance as SizedInstance;
if (oldSized != null)
{
oldSized.IsBoundingBoxEnabled = false;
}
}
}
}
ClearHovered();
}
AddToHoverNode(parentNode);
}
break;
}
}
if (nothing)
{
if (cursor == null)
{
cursor = Cursors.Default;
}
IEnumerable <SceneNode> hovered = GetHoveredNodes();
if (hovered != null)
{
foreach (SceneNode node in hovered)
{
if (!IsSelectedNode(node))
{
PositionedInstance oldInstance = Engine.SceneNodeStore.GetInstance(node);
if (oldInstance != null)
{
SizedInstance oldSized = oldInstance as SizedInstance;
if (oldSized != null)
{
oldSized.IsBoundingBoxEnabled = false;
}
}
}
}
ClearHovered();
}
}
else
{
if (cursor == null)
{
cursor = Cursors.Hand;
}
}
}
if (cursor != null)
{
System.Windows.Application.Current.Dispatcher.InvokeAsync(() => _panel.Cursor = cursor, DispatcherPriority.Background);
}
_oldMousePosition = point;
});
}
