459 lines
18 KiB
C#
459 lines
18 KiB
C#
using Microsoft.Xna.Framework;
|
|
using Microsoft.Xna.Framework.Graphics;
|
|
using System;
|
|
using Barotrauma.IO;
|
|
using System.Linq;
|
|
using System.Collections.Generic;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace Barotrauma
|
|
{
|
|
public partial class Sprite
|
|
{
|
|
public Identifier Identifier { get; private set; }
|
|
public static IEnumerable<Sprite> LoadedSprites
|
|
{
|
|
get
|
|
{
|
|
List<Sprite> retVal = null;
|
|
lock (list)
|
|
{
|
|
retVal = list.Select(wRef =>
|
|
{
|
|
if (wRef.TryGetTarget(out Sprite spr))
|
|
{
|
|
return spr;
|
|
}
|
|
return null;
|
|
}).Where(s => s != null).ToList();
|
|
}
|
|
return retVal;
|
|
}
|
|
}
|
|
|
|
private static readonly List<WeakReference<Sprite>> list = new List<WeakReference<Sprite>>();
|
|
|
|
static partial void AddToList(Sprite elem)
|
|
{
|
|
lock (list)
|
|
{
|
|
list.Add(new WeakReference<Sprite>(elem));
|
|
}
|
|
}
|
|
|
|
static partial void RemoveFromList(Sprite sprite)
|
|
{
|
|
lock (list)
|
|
{
|
|
list.RemoveAll(wRef => !wRef.TryGetTarget(out Sprite s) || s == sprite);
|
|
}
|
|
}
|
|
|
|
private class TextureRefCounter
|
|
{
|
|
public Texture2D Texture;
|
|
public int RefCount;
|
|
}
|
|
|
|
private readonly static Dictionary<Identifier, TextureRefCounter> textureRefCounts = new Dictionary<Identifier, TextureRefCounter>();
|
|
|
|
private bool cannotBeLoaded;
|
|
|
|
protected volatile bool loadingAsync = false;
|
|
|
|
protected Texture2D texture { get; private set; }
|
|
public Texture2D Texture
|
|
{
|
|
get
|
|
{
|
|
EnsureLazyLoaded();
|
|
return texture;
|
|
}
|
|
}
|
|
|
|
private string disposeStackTrace;
|
|
|
|
public bool Loaded
|
|
{
|
|
get { return texture != null && !cannotBeLoaded; }
|
|
}
|
|
|
|
public Sprite(Sprite other) : this(other.texture, other.sourceRect, other.offset, other.rotation, other.FilePath.Value)
|
|
{
|
|
Compress = other.Compress;
|
|
size = other.size;
|
|
effects = other.effects;
|
|
}
|
|
|
|
public Sprite(Texture2D texture, Rectangle? sourceRectangle, Vector2? newOffset, float newRotation = 0.0f, string path = null)
|
|
{
|
|
this.texture = texture;
|
|
sourceRect = sourceRectangle ?? new Rectangle(0, 0, texture.Width, texture.Height);
|
|
offset = newOffset ?? Vector2.Zero;
|
|
size = new Vector2(sourceRect.Width, sourceRect.Height);
|
|
origin = Vector2.Zero;
|
|
effects = SpriteEffects.None;
|
|
rotation = newRotation;
|
|
FilePath = ContentPath.FromRaw(path);
|
|
AddToList(this);
|
|
if (!string.IsNullOrEmpty(path))
|
|
{
|
|
Identifier fullPath = Path.GetFullPath(path).CleanUpPathCrossPlatform(correctFilenameCase: false).ToIdentifier();
|
|
lock (list)
|
|
{
|
|
if (!textureRefCounts.TryAdd(fullPath, new TextureRefCounter { RefCount = 1, Texture = texture }))
|
|
{
|
|
textureRefCounts[fullPath].RefCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
partial void LoadTexture(ref Vector4 sourceVector, ref bool shouldReturn)
|
|
{
|
|
texture = LoadTexture(FilePath.Value, Compress, contentPackage: SourceElement?.ContentPackage);
|
|
|
|
if (texture == null)
|
|
{
|
|
shouldReturn = true;
|
|
return;
|
|
}
|
|
|
|
if (sourceVector.Z == 0.0f) sourceVector.Z = texture.Width;
|
|
if (sourceVector.W == 0.0f) sourceVector.W = texture.Height;
|
|
}
|
|
|
|
public async Task LazyLoadAsync()
|
|
{
|
|
await Task.Yield();
|
|
if (!LazyLoad || texture != null || cannotBeLoaded || loadingAsync) { return; }
|
|
EnsureLazyLoaded(isAsync: true);
|
|
}
|
|
|
|
public void EnsureLazyLoaded(bool isAsync = false)
|
|
{
|
|
if (!LazyLoad || texture != null || cannotBeLoaded || loadingAsync) { return; }
|
|
loadingAsync = isAsync;
|
|
|
|
Vector4 sourceVector = Vector4.Zero;
|
|
bool temp2 = false;
|
|
int maxLoadRetries = File.Exists(FilePath) ? 3 : 0;
|
|
for (int i = 0; i <= maxLoadRetries; i++)
|
|
{
|
|
try
|
|
{
|
|
LoadTexture(ref sourceVector, ref temp2);
|
|
}
|
|
catch (System.IO.IOException)
|
|
{
|
|
if (i == maxLoadRetries || !File.Exists(FilePath)) { throw; }
|
|
DebugConsole.NewMessage("Loading sprite \"" + FilePath + "\" failed, retrying in 250 ms...");
|
|
System.Threading.Thread.Sleep(500);
|
|
}
|
|
}
|
|
|
|
if (sourceRect.Width == 0 && sourceRect.Height == 0)
|
|
{
|
|
sourceRect = new Rectangle((int)sourceVector.X, (int)sourceVector.Y, (int)sourceVector.Z, (int)sourceVector.W);
|
|
size = SourceElement.GetAttributeVector2("size", Vector2.One);
|
|
size.X *= sourceRect.Width;
|
|
size.Y *= sourceRect.Height;
|
|
RelativeOrigin = SourceElement.GetAttributeVector2("origin", new Vector2(0.5f, 0.5f));
|
|
}
|
|
if (texture == null)
|
|
{
|
|
cannotBeLoaded = true;
|
|
}
|
|
}
|
|
|
|
public void ReloadTexture()
|
|
{
|
|
var oldTexture = texture;
|
|
if (texture == null)
|
|
{
|
|
DebugConsole.ThrowError("Sprite: Failed to reload the texture, texture is null.");
|
|
return;
|
|
}
|
|
texture.Dispose();
|
|
texture = TextureLoader.FromFile(FilePath.Value, Compress, contentPackage: SourceElement?.ContentPackage);
|
|
Identifier pathKey = FullPath.ToIdentifier();
|
|
if (textureRefCounts.ContainsKey(pathKey))
|
|
{
|
|
textureRefCounts[pathKey].Texture = texture;
|
|
}
|
|
foreach (Sprite sprite in LoadedSprites)
|
|
{
|
|
if (sprite.texture == oldTexture)
|
|
{
|
|
sprite.texture = texture;
|
|
}
|
|
}
|
|
}
|
|
|
|
partial void CalculateSourceRect()
|
|
{
|
|
sourceRect = new Rectangle(0, 0, texture.Width, texture.Height);
|
|
}
|
|
|
|
public static Texture2D LoadTexture(string file, bool compress = true, ContentPackage contentPackage = null)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(file))
|
|
{
|
|
Texture2D t = null;
|
|
CrossThread.RequestExecutionOnMainThread(() =>
|
|
{
|
|
t = new Texture2D(GameMain.GraphicsDeviceManager.GraphicsDevice, 1, 1);
|
|
});
|
|
return t;
|
|
}
|
|
Identifier fullPath = Path.GetFullPath(file).CleanUpPathCrossPlatform(correctFilenameCase: false).ToIdentifier();
|
|
lock (list)
|
|
{
|
|
if (textureRefCounts.ContainsKey(fullPath))
|
|
{
|
|
textureRefCounts[fullPath].RefCount++;
|
|
return textureRefCounts[fullPath].Texture;
|
|
}
|
|
}
|
|
|
|
if (File.Exists(file))
|
|
{
|
|
if (!ToolBox.IsProperFilenameCase(file))
|
|
{
|
|
#if DEBUG
|
|
DebugConsole.ThrowError("Texture file \"" + file + "\" has incorrect case!", contentPackage: contentPackage);
|
|
#endif
|
|
}
|
|
|
|
Texture2D newTexture = TextureLoader.FromFile(file, compress, contentPackage: contentPackage);
|
|
lock (list)
|
|
{
|
|
if (!textureRefCounts.TryAdd(fullPath,
|
|
new TextureRefCounter { RefCount = 1, Texture = newTexture }))
|
|
{
|
|
CrossThread.RequestExecutionOnMainThread(() => newTexture.Dispose());
|
|
textureRefCounts[fullPath].RefCount++;
|
|
return textureRefCounts[fullPath].Texture;
|
|
}
|
|
}
|
|
return newTexture;
|
|
}
|
|
else
|
|
{
|
|
DebugConsole.ThrowError($"Sprite \"{file}\" not found!", contentPackage: contentPackage);
|
|
DebugConsole.Log(Environment.StackTrace.CleanupStackTrace());
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public void Draw(ISpriteBatch spriteBatch, Vector2 pos, float rotate = 0.0f, float scale = 1.0f, SpriteEffects spriteEffect = SpriteEffects.None)
|
|
{
|
|
this.Draw(spriteBatch, pos, Color.White, rotate, scale, spriteEffect);
|
|
}
|
|
|
|
public void Draw(ISpriteBatch spriteBatch, Vector2 pos, Color color, float rotate = 0.0f, float scale = 1.0f, SpriteEffects spriteEffect = SpriteEffects.None, float? depth = null)
|
|
{
|
|
this.Draw(spriteBatch, pos, color, this.origin, rotate, new Vector2(scale, scale), spriteEffect, depth);
|
|
}
|
|
|
|
public void Draw(ISpriteBatch spriteBatch, Vector2 pos, Color color, Vector2 origin, float rotate = 0.0f, float scale = 1.0f, SpriteEffects spriteEffect = SpriteEffects.None, float? depth = null)
|
|
{
|
|
this.Draw(spriteBatch, pos, color, origin, rotate, new Vector2(scale, scale), spriteEffect, depth);
|
|
}
|
|
|
|
public virtual void Draw(ISpriteBatch spriteBatch, Vector2 pos, Color color, Vector2 origin, float rotate, Vector2 scale, SpriteEffects spriteEffect = SpriteEffects.None, float? depth = null)
|
|
{
|
|
if (Texture == null) { return; }
|
|
//DrawSilhouette(spriteBatch, pos, origin, rotate, scale, spriteEffect, depth);
|
|
spriteBatch.Draw(texture, pos + offset, sourceRect, color, rotation + rotate, origin, scale, spriteEffect, depth ?? this.depth);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a silhouette for the sprite (or outline if the sprite is rendered on top of it)
|
|
/// </summary>
|
|
public void DrawSilhouette(SpriteBatch spriteBatch, Vector2 pos, Vector2 origin, float rotate, Vector2 scale, SpriteEffects spriteEffect = SpriteEffects.None, float? depth = null)
|
|
{
|
|
if (Texture == null) { return; }
|
|
for (int x = -1; x <= 1; x += 2)
|
|
{
|
|
for (int y = -1; y <= 1; y += 2)
|
|
{
|
|
spriteBatch.Draw(texture, pos + offset + new Vector2(x, y), sourceRect, Color.Black, rotation + rotate, origin, scale, spriteEffect, (depth ?? this.depth) + 0.01f);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Last version of the game that had broken handling of sprites that were scaled, flipped and offset
|
|
/// </summary>
|
|
public static readonly Version LastBrokenTiledSpriteGameVersion = new Version(major: 1, minor: 2, build: 7, revision: 0);
|
|
|
|
public void DrawTiled(ISpriteBatch spriteBatch,
|
|
Vector2 position,
|
|
Vector2 targetSize,
|
|
float rotation = 0f,
|
|
Vector2? origin = null,
|
|
Color? color = null,
|
|
Vector2? startOffset = null,
|
|
Vector2? textureScale = null,
|
|
float? depth = null,
|
|
SpriteEffects? spriteEffects = null)
|
|
{
|
|
if (Texture == null) { return; }
|
|
|
|
spriteEffects ??= effects;
|
|
|
|
bool flipHorizontal = spriteEffects.Value.HasFlag(SpriteEffects.FlipHorizontally);
|
|
bool flipVertical = spriteEffects.Value.HasFlag(SpriteEffects.FlipVertically);
|
|
|
|
float addedRotation = rotation + this.rotation;
|
|
if (flipHorizontal != flipVertical) { addedRotation = -addedRotation; }
|
|
|
|
Vector2 advanceX = addedRotation == 0.0f ? Vector2.UnitX : new Vector2((float)Math.Cos(addedRotation), (float)Math.Sin(addedRotation));
|
|
Vector2 advanceY = new Vector2(-advanceX.Y, advanceX.X);
|
|
|
|
//Init optional values
|
|
Vector2 drawOffset = startOffset ?? Vector2.Zero;
|
|
Vector2 scale = textureScale ?? Vector2.One;
|
|
Color drawColor = color ?? Color.White;
|
|
Vector2 transformedOrigin = origin ?? Vector2.Zero;
|
|
|
|
transformedOrigin = advanceX * transformedOrigin.X + advanceY * transformedOrigin.Y;
|
|
|
|
void drawSection(Vector2 slicePos, Rectangle sliceRect)
|
|
{
|
|
Vector2 transformedPos = slicePos;
|
|
|
|
if (flipHorizontal)
|
|
{
|
|
transformedPos.X = targetSize.X - transformedPos.X - sliceRect.Width * scale.X;
|
|
}
|
|
if (flipVertical)
|
|
{
|
|
transformedPos.Y = targetSize.Y - transformedPos.Y - sliceRect.Height * scale.Y;
|
|
}
|
|
|
|
transformedPos = advanceX * transformedPos.X + advanceY * transformedPos.Y;
|
|
transformedPos += position - transformedOrigin;
|
|
spriteBatch.Draw(
|
|
texture: texture,
|
|
position: transformedPos,
|
|
sourceRectangle: sliceRect,
|
|
color: drawColor,
|
|
rotation: addedRotation,
|
|
origin: Vector2.Zero,
|
|
scale: scale,
|
|
effects: spriteEffects.Value,
|
|
layerDepth: depth ?? this.depth);
|
|
}
|
|
|
|
//wrap the drawOffset inside the sourceRect
|
|
drawOffset.X = (drawOffset.X / scale.X) % sourceRect.Width;
|
|
drawOffset.Y = (drawOffset.Y / scale.Y) % sourceRect.Height;
|
|
|
|
//how many times the texture needs to be drawn on the x-axis
|
|
int xTiles = (int)Math.Ceiling((targetSize.X + drawOffset.X * scale.X) / (sourceRect.Width * scale.X));
|
|
//how many times the texture needs to be drawn on the y-axis
|
|
int yTiles = (int)Math.Ceiling((targetSize.Y + drawOffset.Y * scale.Y) / (sourceRect.Height * scale.Y));
|
|
|
|
//where the current tile is being drawn;
|
|
Vector2 currDrawPosition = -drawOffset;
|
|
//which part of the texture we are currently drawing
|
|
Rectangle texPerspective = sourceRect;
|
|
|
|
|
|
for (int x = 0; x < xTiles; x++)
|
|
{
|
|
texPerspective.X = sourceRect.X;
|
|
texPerspective.Width = sourceRect.Width;
|
|
texPerspective.Height = sourceRect.Height;
|
|
|
|
//offset to the left, draw a partial slice
|
|
if (currDrawPosition.X < 0)
|
|
{
|
|
float diff = -currDrawPosition.X;
|
|
currDrawPosition.X += diff;
|
|
texPerspective.Width -= (int)diff;
|
|
|
|
texPerspective.X += (int)diff;
|
|
}
|
|
//make sure the rightmost tiles don't go over the right side
|
|
if (x == xTiles - 1)
|
|
{
|
|
int diff = (int)(((currDrawPosition.X + texPerspective.Width * scale.X) - targetSize.X) / scale.X);
|
|
texPerspective.Width -= diff;
|
|
}
|
|
|
|
currDrawPosition.Y = -drawOffset.Y;
|
|
|
|
for (int y = 0; y < yTiles; y++)
|
|
{
|
|
texPerspective.Y = sourceRect.Y;
|
|
texPerspective.Height = sourceRect.Height;
|
|
|
|
//offset above the top, draw a partial slice
|
|
if (currDrawPosition.Y < 0f)
|
|
{
|
|
float diff = -currDrawPosition.Y;
|
|
currDrawPosition.Y += diff;
|
|
texPerspective.Height -= (int)diff;
|
|
texPerspective.Y += (int)diff;
|
|
}
|
|
|
|
//make sure the bottommost tiles don't go over the bottom
|
|
if (y == yTiles - 1)
|
|
{
|
|
int diff = (int)(((currDrawPosition.Y + texPerspective.Height * scale.Y) - targetSize.Y) / scale.Y);
|
|
texPerspective.Height -= diff;
|
|
}
|
|
|
|
drawSection(currDrawPosition, texPerspective);
|
|
|
|
currDrawPosition.Y += texPerspective.Height * scale.Y;
|
|
}
|
|
|
|
currDrawPosition.X += texPerspective.Width * scale.X;
|
|
}
|
|
}
|
|
|
|
partial void DisposeTexture()
|
|
{
|
|
disposeStackTrace = Environment.StackTrace;
|
|
if (texture != null)
|
|
{
|
|
//check if another sprite is using the same texture
|
|
lock (list)
|
|
{
|
|
if (!FilePath.IsNullOrEmpty()) //file can be empty if the sprite is created directly from a Texture2D instance
|
|
{
|
|
Identifier pathKey = FullPath.ToIdentifier();
|
|
if (!pathKey.IsEmpty && textureRefCounts.ContainsKey(pathKey))
|
|
{
|
|
textureRefCounts[pathKey].RefCount--;
|
|
if (textureRefCounts[pathKey].RefCount <= 0)
|
|
{
|
|
textureRefCounts.Remove(pathKey);
|
|
}
|
|
else
|
|
{
|
|
texture = null;
|
|
FilePath = ContentPath.Empty;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//if not, free the texture
|
|
CrossThread.RequestExecutionOnMainThread(() =>
|
|
{
|
|
texture.Dispose();
|
|
});
|
|
texture = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|