public bool SetDrawable(IDrawn drawable)
{
if (!nameList.ContainsKey(drawable.Name))
{
return(false);
}
if (nameList[drawable.Name] != drawable.DrawnType)
{
return(false);
}
switch (drawable.DrawnType)
{
case DrawnType.Animation:
Animation animation = (Animation)drawable;
animationList[animation.Name] = animation;
return(true);
case DrawnType.Shape:
IDrawnShape shape = (IDrawnShape)drawable;
shapeList[shape.Name] = shape;
return(true);
case DrawnType.String:
DrawnString drawString = (DrawnString)drawable;
stringList[drawString.Name] = drawString;
return(true);
}
return(false);
}
public void UpdateCache(IDrawn drawnObject, string parentObjectName)
{
if (!Cache.ContainsKey(parentObjectName)) return;
ObjectCache objCache = Cache[parentObjectName];
if (!objCache.Cache.ContainsKey(drawnObject.Name)) return;
objCache.Cache[drawnObject.Name] = drawnObject;
}
internal void Register(IDrawn node)
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
{
if (!_Drawns.TryGetValue(node.ZOrder, out var set))
{
set = _Drawns[node.ZOrder] = new HashSet <IDrawn>();
}
set.Add(node);
}
for (int i = 0; i < Engine.MaxCameraGroupCount; i++)
{
var mask = 1u << i;
if (!HasBit(node.CameraGroup, mask))
{
continue;
}
var group = _Sorted[i];
if (!group.TryGetValue(node.ZOrder, out var set))
{
set = group[node.ZOrder] = new HashSet <IDrawn>();
}
set.Add(node);
}
}
public bool AddDrawable(IDrawn drawable)
{
switch (drawable.DrawnType)
{
case DrawnType.Animation:
Animation animation = (Animation) drawable;
if (nameList.ContainsKey(animation.Name)) return false;
animationList.Add(animation.Name, animation);
nameList.Add(animation.Name, DrawnType.Animation);
return true;
case DrawnType.Shape:
IDrawnShape shape = (IDrawnShape) drawable;
if (nameList.ContainsKey(shape.Name)) return false;
shapeList.Add(shape.Name, shape );
nameList.Add(shape.Name, DrawnType.Shape);
textureManager.PixelTextures.Add(shape.Name, CreatePixel(shape.Color));
return true;
case DrawnType.String:
DrawnString drawString = (DrawnString) drawable;
if (nameList.ContainsKey(drawString.Name)) return false;
nameList.Add(drawString.Name, DrawnType.String);
stringList.Add(drawString.Name, drawString);
return true;
}
return false;
}
internal void UpdateCameraGroup(IDrawn node, ulong old)
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
for (int i = 0; i < Engine.MaxCameraGroupCount; i++)
{
var mask = 1u << i;
if (HasBit(old, mask) && !HasBit(node.CameraGroup, mask))
{
// 削除
_Sorted[i][node.ZOrder].Remove(node);
}
if (!HasBit(old, mask) && HasBit(node.CameraGroup, mask))
{
// 追加
var group = _Sorted[i];
if (!group.TryGetValue(node.ZOrder, out var set))
{
set = group[node.ZOrder] = new HashSet <IDrawn>();
}
set.Add(node);
}
}
}
public void UpdateCache(IDrawn drawnObject)
{
foreach (KeyValuePair <string, ObjectCache> pair in Cache.Where(pair => pair.Value.Cache.ContainsKey(drawnObject.Name)))
{
pair.Value.Cache[drawnObject.Name] = drawnObject;
}
}
public void UpdateCache(IDrawn drawnObject)
{
foreach (KeyValuePair<string, ObjectCache> pair in Cache.Where(pair => pair.Value.Cache.ContainsKey(drawnObject.Name)))
{
pair.Value.Cache[drawnObject.Name] = drawnObject;
}
}
public bool UpdateDrawPosition(DrawParam param)
{
if (!drawList.ContainsKey(param.ObjectName))
{
return(false);
}
IDrawn drawObject = drawList[param.ObjectName];
drawObject.X = param.Position.X;
drawObject.Y = param.Position.Y;
drawList[param.ObjectName] = drawObject;
return(true);
}
public bool SetLoadedDrawn(IDrawn drawn, string parentObjectName)
{
if (!drawCache.Cache.ContainsKey(parentObjectName))
{
return(false);
}
drawCache.UpdateCache(drawn, parentObjectName);
if (drawList.ContainsKey(parentObjectName))
{
drawList[parentObjectName] = drawn;
}
return(true);
}
public void UpdateCache(IDrawn drawnObject, string parentObjectName)
{
if (!Cache.ContainsKey(parentObjectName))
{
return;
}
ObjectCache objCache = Cache[parentObjectName];
if (!objCache.Cache.ContainsKey(drawnObject.Name))
{
return;
}
objCache.Cache[drawnObject.Name] = drawnObject;
}
//TODO: Remove this method because the one below it is what I actually wanted to do. But updating the same animation on multiple objects may be useful
public bool SetLoadedDrawn(IDrawn drawn)
{
if (!nameList.ContainsKey(drawn.Name))
{
return(false);
}
if (nameList[drawn.Name] != drawn.DrawnType)
{
return(false);
}
drawCache.UpdateCache(drawn);
if (drawList.ContainsKey(drawn.Name))
{
drawList[drawn.Name] = drawn;
}
return(true);
}
internal void Unregister(IDrawn node)
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
_Drawns[node.ZOrder].Remove(node);
for (int i = 0; i < Engine.MaxCameraGroupCount; i++)
{
var mask = 1u << i;
if (!HasBit(node.CameraGroup, mask))
{
continue;
}
var group = _Sorted[i];
group[node.ZOrder].Remove(node);
}
}
public bool AddDrawable(IDrawn drawable)
{
switch (drawable.DrawnType)
{
case DrawnType.Animation:
Animation animation = (Animation)drawable;
if (nameList.ContainsKey(animation.Name))
{
return(false);
}
animationList.Add(animation.Name, animation);
nameList.Add(animation.Name, DrawnType.Animation);
return(true);
case DrawnType.Shape:
IDrawnShape shape = (IDrawnShape)drawable;
if (nameList.ContainsKey(shape.Name))
{
return(false);
}
shapeList.Add(shape.Name, shape);
nameList.Add(shape.Name, DrawnType.Shape);
textureManager.PixelTextures.Add(shape.Name, CreatePixel(shape.Color));
return(true);
case DrawnType.String:
DrawnString drawString = (DrawnString)drawable;
if (nameList.ContainsKey(drawString.Name))
{
return(false);
}
nameList.Add(drawString.Name, DrawnType.String);
stringList.Add(drawString.Name, drawString);
return(true);
}
return(false);
}
public bool SetLoadedDrawn(IDrawn drawn, string parentObjectName)
{
if (!drawCache.Cache.ContainsKey(parentObjectName)) return false;
drawCache.UpdateCache(drawn, parentObjectName);
if (drawList.ContainsKey(parentObjectName))
{
drawList[parentObjectName] = drawn;
}
return true;
}
//TODO: Remove this method because the one below it is what I actually wanted to do. But updating the same animation on multiple objects may be useful
public bool SetLoadedDrawn(IDrawn drawn)
{
if (!nameList.ContainsKey(drawn.Name)) return false;
if (nameList[drawn.Name] != drawn.DrawnType) return false;
drawCache.UpdateCache(drawn);
if (drawList.ContainsKey(drawn.Name))
{
drawList[drawn.Name] = drawn;
}
return true;
}
public bool SetDrawable(IDrawn drawable)
{
if (!nameList.ContainsKey(drawable.Name)) return false;
if (nameList[drawable.Name] != drawable.DrawnType) return false;
switch (drawable.DrawnType)
{
case DrawnType.Animation:
Animation animation = (Animation)drawable;
animationList[animation.Name] = animation;
return true;
case DrawnType.Shape:
IDrawnShape shape = (IDrawnShape)drawable;
shapeList[shape.Name] = shape;
return true;
case DrawnType.String:
DrawnString drawString = (DrawnString)drawable;
stringList[drawString.Name] = drawString;
return true;
}
return false;
}
public virtual void Render(IDrawn model, DrawParams param)
{
}
public override void Render(IDrawn model, DrawParams param)
{
_buf.Graphics.Clear(Color.Black);
model.Draw(_buf.Graphics, param);
_buf.Render();
}
public bool UpdateDrawList(DrawParam param)
{
if (!drawList.ContainsKey(param.ObjectName))
{
return(false);
}
if (drawCache.Cache.ContainsKey(param.ObjectName))
{
ObjectCache cache = drawCache.Cache[param.ObjectName];
if (cache.Cache.ContainsKey(param.DrawableName))
{
IDrawn drawableObject = cache.Cache[param.DrawableName];
drawableObject.X = param.Position.X;
drawableObject.Y = param.Position.Y;
switch (drawableObject.DrawnType)
{
case DrawnType.Animation:
Animation animation = (Animation)drawableObject;
animation.Reset();
drawList[param.ObjectName] = animation;
return(true);
default:
drawList[param.ObjectName] = drawableObject;
return(true);
}
}
}
else
{
drawCache.Cache.Add(param.ObjectName, new ObjectCache());
}
ObjectCache objCache = drawCache.Cache[param.ObjectName];
switch (param.DrawType)
{
case DrawnType.Animation:
if (!animationList.ContainsKey(param.DrawableName))
{
return(false);
}
Animation animation = animationList[param.DrawableName].CloneAnimation(param.DrawableName);
animation.Reset();
animation.X = param.Position.X;
animation.Y = param.Position.Y;
drawList.Add(param.ObjectName, animation);
objCache.Cache.Add(animation.Name, animation);
break;
case DrawnType.Shape:
if (!shapeList.ContainsKey(param.DrawableName))
{
return(false);
}
IDrawnShape shape = shapeList[param.DrawableName];
switch (shape.Shape)
{
case ShapeType.Line:
DrawnLine line = (DrawnLine)shape;
DrawnLine drawLine = line.Clone(line.Name);
drawLine.X = param.Position.X;
drawLine.Y = param.Position.Y;
drawList.Add(param.ObjectName, drawLine);
objCache.Cache.Add(drawLine.Name, drawLine);
return(true);
case ShapeType.Rectangle:
DrawnRectangle rectangle = (DrawnRectangle)shape;
DrawnRectangle drawRectangle = rectangle.Clone(rectangle.Name);
drawRectangle.X = param.Position.X;
drawRectangle.Y = param.Position.Y;
drawList.Add(param.ObjectName, drawRectangle);
objCache.Cache.Add(drawRectangle.Name, drawRectangle);
return(true);
}
break;
case DrawnType.String:
if (!stringList.ContainsKey(param.DrawableName))
{
return(false);
}
DrawnString drawString = stringList[param.DrawableName].Clone(param.DrawableName);
drawString.X = param.Position.X;
drawString.Y = param.Position.Y;
drawList.Add(param.ObjectName, drawString);
objCache.Cache.Add(drawString.Name, drawString);
return(true);
}
return(false);
}
