/// <summary>
/// Handle a RenderGroup action in the RenderOrder.
/// </summary>
/// <param name="action"></param>
private void HandleRenderOrderAction_RenderGroup(
RenderOrder.RenderGroup action, RenderableHandler renderAction)
{
var group = AllRenderables.GetSubnode(action.Name);
group.Render(action.Options, renderAction, SeenRenderables, SeenGroups, action.SkipDuplicates);
}
/// <summary>
/// Handle a RenderItem action in the RenderOrder.
/// </summary>
/// <param name="action"></param>
private void HandleRenderOrderAction_RenderItem(
RenderOrder.RenderItem action, RenderableHandler renderAction)
{
var renderable = AllRenderables.GetItem(action.Name);
if (!(action.SkipDuplicates && SeenRenderables.Contains(renderable)))
{
renderAction(renderable);
}
}
/// <summary>
/// Add an anonymous item to this layer.
/// </summary>
/// <param name="item"></param>
public void AddAnonymousItem(RenderableObject item)
{
if (MidRender)
{
renderablesToAdd.Add(new RenderableToAdd {
Name = null, Object = item, Anonymous = true
});
}
else
{
AllRenderables.AddAnonymousItem(item);
}
item.Layer = this;
}
/// <summary>
/// Add an anonymous item to the renderable group with the given name in this layer.
/// </summary>
/// <param name="groupName"></param>
/// <param name="item"></param>
public void AddAnonymousItem(string groupName, RenderableObject item)
{
if (MidRender)
{
renderablesToAdd.Add(new RenderableToAdd {
Name = groupName, Object = item, Anonymous = true
});
}
else
{
AllRenderables.AddAnonymousItem(groupName, item);
}
item.Layer = this;
targetChangeListeners.Add(item);
}
/// <summary>
/// Add a RenderableObject to this render layer.
/// </summary>
/// <param name="name"></param>
/// <param name="item"></param>
public void AddItem(string name, RenderableObject item)
{
if (MidRender)
{
renderablesToAdd.Add(new RenderableToAdd {
Name = name, Object = item
});
}
else
{
AllRenderables.InsertItem(name, item);
}
item.Layer = this;
targetChangeListeners.Add(item);
}
/// <summary>
/// Get the list of all RenderableObjects visible to the Camera.
/// </summary>
/// <returns></returns>
private IEnumerable <RenderableObject> GetCameraVisibleRenderables()
{
if (Camera is NullCamera)
{
return(AllRenderables.RetrieveAll());
}
var renderables = new HashSet <RenderableObject>();
var aabb = Camera.ViewAABB;
_world.QueryAABB(f =>
{
var obj = (RenderableObject)f.Body.UserData;
renderables.Add(obj); // A renderable object might have multiple fixtures, but
// we only want to render the object itself once.
return(true);
}, ref aabb);
return(renderables);
}
/// <summary>
/// Actually render the RenderableObjects.
/// </summary>
protected override void RenderItems()
{
var renderableHandler = GetRenderableHandler();
SeenRenderables.Clear();
SeenGroups.Clear();
// If no RenderOrder was set, just render everything.
if (RenderOrder == null)
{
AllRenderables.Render(
GlobalTraversalOptions, renderableHandler, SeenRenderables, SeenGroups);
}
// Otherwise, render in the order specified by the RenderOrder.
else
{
/* TODO: Make this faster (somehow).
*
* The problem with this is that we're iterating through EVERY RenderableObject and checking
* if the camera can see it, then rendering it. Ideally what we should be doing instead is
* iterating through every RenderableObject returned by the QueryAABB and somehow rendering
* only THOSE in order.
*
* For large worlds, the number of renderables visible to the camera can be MUCH less than the
* total number of RenderableObjects, which is a problem.
*
* Most likely what will be done is upon setting the layer's RenderOrder, some sort of mapping
* is created which assigns each RenderableObject a number indicating it's position in the sorted
* list of objects to render.
*/
foreach (var item in RenderOrder.Actions)
{
switch (item.ActionType)
{
case RenderOrder.RenderOrderActionType.RenderItem:
HandleRenderOrderAction_RenderItem((RenderOrder.RenderItem)item, renderableHandler);
break;
case RenderOrder.RenderOrderActionType.RenderGroup:
HandleRenderOrderAction_RenderGroup((RenderOrder.RenderGroup)item, renderableHandler);
break;
case RenderOrder.RenderOrderActionType.SetRenderProperties:
HandleRenderOrderAction_SetRenderProperties((RenderOrder.SetRenderProperties)item);
break;
case RenderOrder.RenderOrderActionType.RenderLayer:
throw new RenderOrderException(
String.Format(
"The RenderOrderAction `RenderLayer` cannot be used in the " +
"RenderOrder for layer '{0}'. This RenderOrderAction can only " +
"be used in a LayerManager's render order.", FullName));
default:
var handled = false;
if (UnknownRenderOrderActionHandlers.Count > 0)
{
var type = item.GetType();
if (UnknownRenderOrderActionHandlers.ContainsKey(type))
{
UnknownRenderOrderActionHandlers[type](this, item, renderableHandler);
handled = true;
}
}
if (!handled)
{
HandleUnknownRenderOrderAction(item, renderableHandler);
}
break;
}
}
}
}
/// <summary>
/// Add the renderable group with the given name to the layer.
/// </summary>
/// <param name="name"></param>
/// <param name="group"></param>
public void AddGroup(string name, RenderableGroup group)
{
AllRenderables.AddSubnode(name, group);
}
/// <summary>
/// Add the renderable group to the layer.
/// </summary>
/// <param name="group"></param>
public void AddGroup(RenderableGroup group)
{
AllRenderables.AddSubnode(group.Name, group);
}
/// <summary>
/// Add an empty group with the given name to the layer.
/// </summary>
/// <param name="name"></param>
public void AddGroup(string name)
{
AllRenderables.AddSubnode(name, new RenderableGroup(UriUtilities.GetLastPart(name)));
}
