如何检查单击的对象是否在C＃XNA中最顶部？

Question

I'm trying to reproduce the simple window interface objects in C# XNA like labels, listboxes, textboxes and panels. All objects consequentially derive from basic abstract class (XNAInterfaceObject) that draws an object and updates it. In update method it interacts with a mouse and keyboard and raises various events. The problem is when two interface objects are one over another (eg popup context menu over listbox) and both have non-null events - the code fires both events, when I just need the event of the topmost object. How can I check which object is the topmost? Or make somehow the top object overlap the lower. I thought about global variable which would keep the reference for the last clicked object, and other objects would check if this variable is null to proceed with their events, but I think it is a rough solution and there exists far more elegant one.

Sorry for my language, I'm not a native English-speaker.

Answer 1

I would probably break this issue down into two components:

1. Determining the order of interface objects.
2. Only triggering the events on the top-most object when there's an overlap.

Addressing part one is simple. Include a 'layer' field/property in the base class that specifies the depth of the object. In most game node classes I include this regardless, as it's useful in drawing. You may want a separate layering system for interface ordering if things get a bit more complex, and the downside to this approach is that you can get overlaps in which the layers are the same.

As @Attila has suggested, you can otherwise manage a Z-Ordered list of interface elements. In this case ordering is managed by index, and it's easy to manage but you can't also use this information for drawing without some additional processing and it won't be as quick as a simple value comparison.

Property

public class InterfaceComponent
{
    // Class members...
    private float layer;
    public float Layer { get { return layer; } set { layer = Math.Abs(value); } }

    public bool InFrontOf(InterfaceComponent other) { return this.Layer < other.Layer; }
}

Z-Ordered List

public class InterfaceComponent
{
    private static List<InterfaceComponent> zOrder = new List<InterfaceComponent>();

    // Class Members....

    public InterfaceComponent()
    {
        // Construct class...
        zOrder.Add(this);
    }

    private void SetZOrder(int order)
    {
        if (order < 0 || order >= zOrder.Count)
            return;

        zOrder.Remove(this);
        zOrder.Insert(order, this);
        // There are more efficient ways, but you get the idea.
    }

    public void SendBack() { SetZOrder(zOrder.indexOf(this) + 1); }
    public void SendToFront() { SetZOrder(0); }
    // etc...
}

Part Two There are multiple ways to approach part two. The most obvious is to run a check against all interface components for intersection and layer property, or in the case of a Z-Ordered list, all components higher up the list (approaching 0 in my example) for intersection.

This can end up being pretty expensive, even if you use screens to make the list smaller. Instead you can manage a list of raised events and process them after you handle input. For example...

public static class InterfaceEvents
{
    public static List<EventData> List = new List<EventData>();

    public static void Resolve()
    {
        while (List.Count > 0)
        {
            for (int i = List.Count - 1; i > 0; i--)
            {
                if (List[i].EventType == List[0].EventType && List[i].Sender.Intersects(List[0].Sender))
                {
                    if (List[i].Sender.Layer < List[0].Layer) // However you choose to manage it.
                    {
                        List[0] = List[i];
                        List.RemoveAt(i);
                    }
                    else
                        List.RemoveAt(i);
                }
            }
            // Toggle event from List[0]
            List.RemoveAt(0);
        }
    }
}

public struct EventData
{
    public InterfaceComponent Sender;
    public int EventType;
}

Anyway, those are my thoughts. It's pretty late at night, so I hope everything's remained sensible and there are no glaring mistakes.

Answer 2

Usually in GUI there is a list of visibility ordering (z-order) that maintains what is on top of what. Using this technique (assigning az order to each of your component) you can check if there is anything more toward the top of a clicked component that also includes the clicked coordinates -- if there is, do not handle the click (som other component is on top, that will handle it); otherwise this component is the topmost one to handle the click

Answer 3

A simple solution is creating a list in your Game class:

List<XNAInterfaceObject> controls;

You can then use the order of the list for your problem. Think of the first element in your list as the control that is at the front. In the GetControlAt() method of your game, you can loop through the controls from front to back:

protected override void Update(GameTime gameTime)
{
    ...

    MouseState ms = Mouse.GetState();
    if (ms.LeftButton == ButtonState.Pressed)
    {
        XNAInterfaceObject control = GetControlAt(ms.X, ms.Y);
        if (control != null)
            control.MouseClickMethod(ms);
    }

    ...
}

private XNAInterfaceObject GetControlAt(int x, int y)
{
    for (int i = 0; i < controls.Count; i++)
    {
        if (controls[i].Rectangle.Contains(x, y)
        {
            return controls[i];
        }
    }
    return null;
}

This means that a XNAInterfaceObject should have a Rectangle property and a MouseClickMethod(). Keep in mind that when drawing your controls, you have to loop through the list backwards.