/// <summary>
/// Clear all plottables of the same type as the one that is given
/// </summary>
public void Clear(IRenderable examplePlottable)
{
settings.Plottables.RemoveAll(x => x.GetType() == examplePlottable.GetType());
if (settings.Plottables.Count == 0)
{
settings.ResetAxisLimits();
}
}
public virtual IFormsRenderer GetRenderer(IRenderable element)
{
if (element.Renderer == null)
{
//Lookup renderer for type
IFormsRenderer render = null;
if (!_renderers.TryGetValue(element.GetType(), out render))
{
throw new RenderException(string.Format("A renderer was not found for type {0}.", element.GetType().FullName));
}
element.Renderer = render;
}
return(element.Renderer as IFormsRenderer);
}
public static void setScene(IRenderable newScene)
{
if (newScene.GetType() == typeof(UIScene))
{
currentElement = (UIScene)newScene;
}
else
{
currentElement = new UIScene(new IRenderable[] { newScene }, new int[][] { new int[] { 1, 1 } }, new string[] { "" }, newScene.Height + 2, newScene.Width + 2);
}
Console.WindowWidth = currentElement.Width;
Console.WindowHeight = currentElement.Height + 1;
//Console.BufferHeight = currentElement.Height + 1;
//Console.BufferWidth = currentElement.Width + 1;
Console.SetBufferSize(currentElement.Width + 1, currentElement.Height + 1);
}
public static void setScene(IRenderable newScene)
{
if (newScene.GetType() == typeof(UIScene))
{
currentElement = (UIScene)newScene;
}
else
{
currentElement = new UIScene(new IRenderable[] { newScene }, new int[][] { new int[] { 1, 1 } }, new string[] { "" }, newScene.Height + 2, newScene.Width + 2);
}
Console.WindowWidth = currentElement.Width;
Console.WindowHeight = currentElement.Height + 1;
//Console.BufferHeight = currentElement.Height + 1;
//Console.BufferWidth = currentElement.Width + 1;
Console.SetBufferSize(currentElement.Width + 1, currentElement.Height + 1);
}
public void EnqueueForRendering(IRenderable obj)
{
char[,] objImage = this.images[obj.GetType()];
int imageRows = objImage.GetLength(0);
int imageCols = objImage.GetLength(1);
MatrixCoords objTopLeft = obj.TopLeft;
int lastRow = Math.Min(objTopLeft.Row + imageRows, this.WorldRows);
int lastCol = Math.Min(objTopLeft.Col + imageCols, this.WorldCols);
for (int row = obj.TopLeft.Row; row < lastRow; row++)
{
for (int col = obj.TopLeft.Col; col < lastCol; col++)
{
if (row >= 0 && col >= 0)
{
this.renderMatrix[row, col] = objImage[row - obj.TopLeft.Row, col - obj.TopLeft.Col];
}
}
}
}
/// <summary>
/// Register a renderable object.
/// </summary>
public void RegisterRenderable(IRenderable renderable)
{
Argument.NotNull(() => renderable);
if (renderables.Contains(renderable))
{
throw new FormattedException("Renderable {TypeName} is already registered.", renderable.GetType().Name);
}
this.renderables.Add(renderable);
}
public void Render(IRenderable element)
{
if (element is IBlock)
{
Render((IBlock)element);
return;
}
if (element is IText)
{
Render((IText)element);
return;
}
if (element is INumeric)
{
Render((INumeric)element);
return;
}
throw new ArgumentException(string.Format("Unsupported type received in renderer: {0}", element.GetType().FullName));
}
public void ApplyPatches(IRenderable item, RenderObject renderObject, GameObject gameObject, GameObject tableGameObject)
{
foreach (var patcher in _patchers)
{
var methods = patcher.GetType().GetMembers().Where(member => member.MemberType == MemberTypes.Method);
foreach (var method in methods)
{
var methodMatchers = Attribute
.GetCustomAttributes(method, typeof(ItemMatchAttribute))
.Select(a => a as ItemMatchAttribute)
.Where(a => a != null);
var methodInfo = method as MethodInfo;
if (methodInfo != null)
{
foreach (var methodMatcher in methodMatchers)
{
var validArgs = true;
if (methodMatcher.Matches(_table, item, renderObject, gameObject))
{
var patcherParamInfos = methodInfo.GetParameters();
var patcherParams = new object[patcherParamInfos.Length];
foreach (var pi in patcherParamInfos)
{
if (pi.ParameterType == typeof(GameObject))
{
patcherParams[pi.Position] = gameObject;
}
else if (pi.ParameterType == typeof(GameObject).MakeByRefType())
{
if (methodMatcher.Ref == null)
{
Logger.Warn($"No Ref provided in {pi.ParameterType} {pi.Name} in patch method {patcher.GetType()}.{methodInfo.Name}(), skipping (item is of type {item.GetType().Name}).");
validArgs = false;
}
else
{
var goRef = tableGameObject.transform.Find(methodMatcher.Ref);
if (goRef == null)
{
Logger.Warn($"No GameObject named {methodMatcher.Ref} found in {pi.ParameterType} {pi.Name} in patch method {patcher.GetType()}.{methodInfo.Name}(), skipping (item is of type {item.GetType().Name}).");
validArgs = false;
}
else
{
patcherParams[pi.Position] = goRef.gameObject;
}
}
}
else if (pi.ParameterType == typeof(Table))
{
patcherParams[pi.Position] = _table;
}
else if (pi.ParameterType.GetInterfaces().Contains(typeof(IItem)) && item.GetType() == pi.ParameterType)
{
patcherParams[pi.Position] = item;
}
else if (pi.ParameterType == typeof(IRenderable) && item.GetType().GetInterfaces().Contains(typeof(IRenderable)))
{
patcherParams[pi.Position] = item;
}
else
{
Logger.Warn($"Unknown parameter {pi.ParameterType} {pi.Name} in patch method {patcher.GetType()}.{methodInfo.Name}(), skipping (item is of type {item.GetType().Name}).");
validArgs = false;
}
}
if (validArgs)
{
Logger.Info($"Patching element {item.Name} based on match by {patcher.GetType().Name}.{method.Name}");
methodInfo.Invoke(patcher, patcherParams);
}
}
}
}
}
}
}
public void Render(IRenderable renderable, CommonSet commonSet, IFramebufferHolder framebuffer, CommandList cl,
GraphicsDevice device)
{
if (cl == null)
{
throw new ArgumentNullException(nameof(cl));
}
if (commonSet == null)
{
throw new ArgumentNullException(nameof(commonSet));
}
if (framebuffer == null)
{
throw new ArgumentNullException(nameof(framebuffer));
}
if (renderable is not EtmWindow window)
{
throw new ArgumentException($"{GetType().Name} was passed renderable of unexpected type {renderable?.GetType().Name ?? "null"}", nameof(renderable));
}
var tilemap = window.Tilemap;
cl.PushDebugGroup($"Tiles3D:{tilemap.Name}");
cl.SetPipeline(tilemap.RendererId == DungeonTilemapPipeline.NoCulling
? _nonCullingPipeline.Pipeline
: _normalPipeline.Pipeline);
cl.SetGraphicsResourceSet(0, tilemap.ResourceSet.ResourceSet);
cl.SetGraphicsResourceSet(1, commonSet.ResourceSet);
cl.SetVertexBuffer(0, _vertexBuffer.DeviceBuffer);
cl.SetVertexBuffer(1, tilemap.TileBuffer);
cl.SetIndexBuffer(_indexBuffer.DeviceBuffer, IndexFormat.UInt16);
cl.SetFramebuffer(framebuffer.Framebuffer);
cl.DrawIndexed((uint)Cube.Indices.Length, (uint)tilemap.Tiles.Length, 0, 0, 0);
cl.PopDebugGroup();
}
public void EnqueueForRendering(IRenderable obj)
{
char[,] objImage = this.images[obj.GetType()];
int imageRows = objImage.GetLength(0);
int imageCols = objImage.GetLength(1);
MatrixCoords objTopLeft = obj.TopLeft;
int lastRow = Math.Min(objTopLeft.Row + imageRows, this.WorldRows);
int lastCol = Math.Min(objTopLeft.Col + imageCols, this.WorldCols);
for (int row = obj.TopLeft.Row; row < lastRow; row++)
{
for (int col = obj.TopLeft.Col; col < lastCol; col++)
{
if (row >= 0 && col >= 0)
{
this.renderMatrix[row, col] = objImage[row - obj.TopLeft.Row, col - obj.TopLeft.Col];
}
}
}
}
public void Render(IRenderable renderable, CommonSet commonSet, IFramebufferHolder framebuffer, CommandList cl, GraphicsDevice device)
{
if (cl == null)
{
throw new ArgumentNullException(nameof(cl));
}
if (device == null)
{
throw new ArgumentNullException(nameof(device));
}
if (renderable is not DebugGuiRenderable)
{
throw new ArgumentException($"{GetType().Name} was passed renderable of unexpected type {renderable?.GetType().Name ?? "null"}", nameof(renderable));
}
_imguiRenderer.Render(device, cl);
cl.SetFullScissorRects();
}
/// <summary>
/// Pre-patches are match methods that purely contain the item as parameter
/// </summary>
/// <param name="item"></param>
public void ApplyPrePatches(IRenderable item)
{
foreach (var patcher in _patchers)
{
var methods = patcher.GetType().GetMembers().Where(member => member.MemberType == MemberTypes.Method);
foreach (var method in methods)
{
var methodMatchers = Attribute
.GetCustomAttributes(method, typeof(ItemMatchAttribute))
.Select(a => a as ItemMatchAttribute)
.Where(a => a != null);
var methodInfo = method as MethodInfo;
if (methodInfo != null)
{
foreach (var methodMatcher in methodMatchers)
{
var validArgs = true;
if (methodMatcher.Matches(_table, item, null))
{
var patcherParamInfos = methodInfo.GetParameters();
var patcherParams = new object[patcherParamInfos.Length];
foreach (var pi in patcherParamInfos)
{
if (pi.ParameterType.GetInterfaces().Contains(typeof(IItem)) && item.GetType() == pi.ParameterType)
{
patcherParams[pi.Position] = item;
}
else if (pi.ParameterType == typeof(IRenderable) && item.GetType().GetInterfaces().Contains(typeof(IRenderable)))
{
patcherParams[pi.Position] = item;
}
else
{
validArgs = false;
}
}
if (validArgs)
{
Logger.Info($"Patching element {item.Name} based on match by {patcher.GetType().Name}.{method.Name}");
methodInfo.Invoke(patcher, patcherParams);
}
}
}
}
}
}
}
/// <summary>
/// This method checks if the given renderable should be handled by the layer.
/// </summary>
/// <param name="renderable">The renderable.</param>
/// <returns>True if the renderable should be handled by the layer.</returns>
protected virtual bool MatchRenderable(IRenderable renderable)
{
var result = this.RenderableTypes.FirstOrDefault(e => e.IsAssignableFrom(renderable.GetType())) != null;
var namable = renderable as INamable;
if (result == true && String.IsNullOrEmpty(this.StartsWithName) == false)
{
result = namable != null && String.IsNullOrEmpty(namable.Name) == false && namable.Name.StartsWith(this.StartsWithName);
}
return result;
}
