static object GetValueForPropertyOnObject(SpriteSave sprite, string fieldOrProperty)
{
if (fieldOrProperty == "Alpha")
{
float valueToDivideBy = 255 / GraphicalEnumerations.MaxColorComponentValue;
return((255 - sprite.Fade) / valueToDivideBy);
}
else if (fieldOrProperty == "PixelSize")
{
return(sprite.ConstantPixelSize);
}
else if (fieldOrProperty == "CurrentChainName")
{
// This thing should use an AnimationChain
string animationChainRelative = sprite.AnimationChainsFile;
string animationChainFile = FileManager.RelativeDirectory + sprite.AnimationChainsFile;
AnimationChainListSave acls = AnimationChainListSave.FromFile(animationChainFile);
int index = sprite.CurrentChain;
if (index < acls.AnimationChains.Count)
{
return(acls.AnimationChains[index].Name);
}
else
{
return(null);
}
}
return(GetValueForPropertyOnObject <SpriteSave>(sprite, fieldOrProperty));
}
public static AnimationChainList AddAnimationChainList(string fileName)
{
AnimationChainList sameNamedList = null;
foreach (AnimationChainList list in mReferencedAnimationChains)
{
if (list.Name == fileName)
{
sameNamedList = list;
break;
}
}
if (sameNamedList == null)
{
AnimationChainListSave animationChainListSave = AnimationChainListSave.FromFile(fileName);
AnimationChainList list = animationChainListSave.ToAnimationChainList(SceneContentManager);
mReferencedAnimationChains.Add(list);
GuiData.ListWindow.Highlight(list);
return(list);
}
else
{
// highlight the list with the same name
GuiData.ListWindow.Highlight(sameNamedList);
return(sameNamedList);
}
}
private void SetAnimationChainOnSprite(Window callingWindow)
{
if (mSelectedObject != null)
{
mSelectedObject.AnimationChains =
AnimationChainListSave.FromFile(((FileTextBox)callingWindow).Text).ToAnimationChainList(this.ContentManagerName);
}
}
public TextureGrid <FlatRedBall.Graphics.Animation.AnimationChain> ToAnimationChainGrid(string contentManagerName,
float gridSpacing)
{
TextureGrid <FlatRedBall.Graphics.Animation.AnimationChain> toReturn = new TextureGrid <FlatRedBall.Graphics.Animation.AnimationChain>();
toReturn.FirstPaintedX = FirstPaintedX;
toReturn.LastPaintedX = new List <float>();
toReturn.FirstPaintedY = FirstPaintedY;
toReturn.LastPaintedY = toReturn.FirstPaintedY + (ReferenceGrid.Length - 1) * gridSpacing;
toReturn.GridSpacingX = gridSpacing;
toReturn.GridSpacingY = gridSpacing;
int yOn = 0;
toReturn.BaseTexture = null;
Dictionary <string, FlatRedBall.Graphics.Animation.AnimationChainList> animationChainListCache =
new Dictionary <string, FlatRedBall.Graphics.Animation.AnimationChainList>();
foreach (ReferencedAnimationChain[] racArray in ReferenceGrid)
{
List <FlatRedBall.Graphics.Animation.AnimationChain> newAnimationChainList =
new List <FlatRedBall.Graphics.Animation.AnimationChain>();
toReturn.Textures.Add(newAnimationChainList);
toReturn.LastPaintedX.Add(toReturn.FirstPaintedX[yOn] + gridSpacing * (racArray.Length - 1));
foreach (ReferencedAnimationChain rac in racArray)
{
FlatRedBall.Graphics.Animation.AnimationChainList acl = null;
if (!string.IsNullOrEmpty(rac.AnimationChainListFileName) && animationChainListCache.ContainsKey(rac.AnimationChainListFileName) == false)
{
AnimationChainListSave acls = AnimationChainListSave.FromFile(rac.AnimationChainListFileName);
animationChainListCache.Add(rac.AnimationChainListFileName,
acls.ToAnimationChainList(contentManagerName));
}
if (string.IsNullOrEmpty(rac.AnimationChainListFileName))
{
acl = null;
newAnimationChainList.Add(null);
}
else
{
acl = animationChainListCache[rac.AnimationChainListFileName];
newAnimationChainList.Add(acl[rac.AnimationChainName]);
}
}
yOn++;
}
return(toReturn);
}
public static SpriteFrame CreateSpriteFrame(string texture, string nameToUse)
{
SpriteFrame spriteFrame = SpriteManager.AddSpriteFrame(null, SpriteFrame.BorderSides.All);
try
{
if (texture.EndsWith(".ach") || texture.EndsWith(".achx"))
{
AnimationChainListSave listSave = AnimationChainListSave.FromFile(texture);
spriteFrame.AnimationChains = listSave.ToAnimationChainList(SceneContentManager);
if (spriteFrame.AnimationChains.Count != 0)
{
spriteFrame.CurrentChainName = (spriteFrame.AnimationChains[0].Name);
}
spriteFrame.Animate = true;
}
else if (texture.EndsWith(".tga") || texture.EndsWith(".png"))
{
spriteFrame.Texture =
FlatRedBallServices.Load <Texture2D>(texture, SceneContentManager);
}
else
{
spriteFrame.Texture =
FlatRedBallServices.Load <Texture2D>(texture, SceneContentManager);
}
}
catch (Microsoft.DirectX.Direct3D.InvalidDataException)
{
throw new Microsoft.DirectX.Direct3D.InvalidDataException();
}
if (string.IsNullOrEmpty(nameToUse) == false)
{
spriteFrame.Name = nameToUse;
}
else
{
spriteFrame.Name = FileManager.RemovePath(FileManager.RemoveExtension(texture));
}
StringFunctions.MakeNameUnique <SpriteFrame>(spriteFrame, mScene.SpriteFrames);
spriteFrame.X = Camera.X;
spriteFrame.Y = Camera.Y;
mScene.SpriteFrames.Add(spriteFrame);
return(spriteFrame);
}
private static AnimationChainListSave LoadAnimationChainListSave(IElement element, string rfsName)
{
AnimationChainListSave acls = null;
ReferencedFileSave rfs = element.GetReferencedFileSaveByInstanceNameRecursively(rfsName);
if (rfs != null)
{
string fullFileName = Facades.FacadeContainer.Self.ProjectValues.ContentDirectory + rfs.Name;
if (System.IO.File.Exists(fullFileName))
{
acls = AnimationChainListSave.FromFile(
fullFileName);
}
}
return(acls);
}
internal void LoadAnimationChain(string fileName)
{
// Reset all textures
LoaderManager.Self.CacheTextures = false;
LoaderManager.Self.CacheTextures = true;
AnimationChainListSave acls = AnimationChainListSave.FromFile(fileName);
AnimationChainListSave = acls;
FileName = fileName;
//Now just convert back to pixel when saving out
if (acls.CoordinateType == Graphics.TextureCoordinateType.Pixel)
{
acls.ConvertToUvCoordinates();
}
}
private AnimationChainListSave GetAnimationChainListFromScnxReference(NamedObjectSave referencedNos)
{
string sourceFileName = ContentDirectory + referencedNos.SourceFile;
string sourceFileDirectory = FlatRedBall.IO.FileManager.GetDirectory(sourceFileName);
AnimationChainListSave acls = null;
SpriteEditorScene ses;
if (System.IO.File.Exists(sourceFileName))
{
ses = SpriteEditorScene.FromFile(sourceFileName);
string truncatedName = referencedNos.SourceName.Substring(0, referencedNos.SourceName.LastIndexOf('(') - 1);
SpriteSave spriteSave = ses.FindSpriteByName(truncatedName);
if (spriteSave != null && !string.IsNullOrEmpty(spriteSave.AnimationChainsFile))
{
acls = AnimationChainListSave.FromFile(
sourceFileDirectory + spriteSave.AnimationChainsFile);
}
if (acls == null)
{
SpriteFrameSave sfs = ses.FindSpriteFrameSaveByName(truncatedName);
if (sfs != null)
{
acls = AnimationChainListSave.FromFile(
sourceFileDirectory + sfs.ParentSprite.AnimationChainsFile);
}
}
}
return(acls);
}
private void HandleForceSaveAll(object sender, EventArgs e)
{
foreach (var rfs in FlatRedBall.Glue.Elements.ObjectFinder.Self.GetAllReferencedFiles()
.Where(item => FileManager.GetExtension(item.Name) == "achx"))
{
string fullFileName = FlatRedBall.Glue.ProjectManager.MakeAbsolute(rfs.Name);
if (System.IO.File.Exists(fullFileName))
{
try
{
AnimationChainListSave acls = AnimationChainListSave.FromFile(fullFileName);
acls.Save(fullFileName);
PluginManager.ReceiveOutput("Re-saved " + rfs.ToString());
}
catch (Exception exc)
{
PluginManager.ReceiveError(exc.ToString());
}
}
}
}
public static void AddSprite(string textureOrAnimationFile)
{
Sprite newSprite = null;
if (FileManager.GetExtension(textureOrAnimationFile) == "achx")
{
AnimationChainListSave achs = AnimationChainListSave.FromFile(textureOrAnimationFile);
newSprite = SpriteManager.AddSprite(
achs.ToAnimationChainList(ContentManagerName));
mBlockingScene.Sprites.Add(newSprite);
newSprite.Name = FileManager.RemovePath(FileManager.RemoveExtension(textureOrAnimationFile));
}
else
{
newSprite = SpriteManager.AddSprite(textureOrAnimationFile, ContentManagerName);
mBlockingScene.Sprites.Add(newSprite);
newSprite.Name = FileManager.RemovePath(FileManager.RemoveExtension(textureOrAnimationFile));
}
SetNewlyCreatedSpriteProperties(newSprite);
}
public T LoadFromFile <T>(string assetName)
{
string extension = FileManager.GetExtension(assetName);
if (FileManager.IsRelative(assetName))
{
// get the absolute path using the current relative directory
assetName = FileManager.RelativeDirectory + assetName;
}
string fullNameWithType = assetName + typeof(T).Name;
// get the dictionary by the contentManagerName. If it doesn't exist, GetDisposableDictionaryByName
// will create it.
if (mDisposableDictionary.ContainsKey(fullNameWithType))
{
#if PROFILE
mHistory.Add(new ContentLoadHistory(
TimeManager.CurrentTime, typeof(T).Name, fullNameWithType, ContentLoadDetail.Cached));
#endif
return((T)mDisposableDictionary[fullNameWithType]);
}
else if (mNonDisposableDictionary.ContainsKey(fullNameWithType))
{
return((T)mNonDisposableDictionary[fullNameWithType]);
}
else
{
#if PROFILE
mHistory.Add(new ContentLoadHistory(
TimeManager.CurrentTime,
typeof(T).Name,
fullNameWithType,
ContentLoadDetail.HddFromFile));
#endif
#if DEBUG
// The ThrowExceptionIfFileDoesntExist
// call used to be done before the checks
// in the dictionaries. But whatever is held
// in there may not really be a file so let's check
// if the file exists after we check the dictionaries.
FileManager.ThrowExceptionIfFileDoesntExist(assetName);
#endif
IDisposable loadedAsset = null;
if (typeof(T) == typeof(Texture2D) || typeof(T) == typeof(Microsoft.Xna.Framework.Graphics.Texture2D))
{
// for now we'll create it here, eventually have it in a dictionary:
loadedAsset = textureContentLoader.Load(assetName);
}
#region Scene
else if (typeof(T) == typeof(FlatRedBall.Scene))
{
FlatRedBall.Scene scene = FlatRedBall.Content.Scene.SceneSave.FromFile(assetName).ToScene(mName);
object sceneAsObject = scene;
lock (mNonDisposableDictionary)
{
if (!mNonDisposableDictionary.ContainsKey(fullNameWithType))
{
mNonDisposableDictionary.Add(fullNameWithType, scene);
}
}
return((T)sceneAsObject);
}
#endregion
#region EmitterList
else if (typeof(T) == typeof(EmitterList))
{
EmitterList emitterList = EmitterSaveList.FromFile(assetName).ToEmitterList(mName);
mNonDisposableDictionary.Add(fullNameWithType, emitterList);
return((T)((object)emitterList));
}
#endregion
#region Image
#if !MONOGAME
else if (typeof(T) == typeof(Image))
{
switch (extension.ToLowerInvariant())
{
case "gif":
Image image = Image.FromFile(assetName);
loadedAsset = image;
break;
}
}
#endif
#endregion
#region BitmapList
#if !XBOX360 && !SILVERLIGHT && !WINDOWS_PHONE && !MONOGAME
else if (typeof(T) == typeof(BitmapList))
{
loadedAsset = BitmapList.FromFile(assetName);
}
#endif
#endregion
#region NodeNetwork
else if (typeof(T) == typeof(NodeNetwork))
{
NodeNetwork nodeNetwork = NodeNetworkSave.FromFile(assetName).ToNodeNetwork();
mNonDisposableDictionary.Add(fullNameWithType, nodeNetwork);
return((T)((object)nodeNetwork));
}
#endregion
#region ShapeCollection
else if (typeof(T) == typeof(ShapeCollection))
{
ShapeCollection shapeCollection =
ShapeCollectionSave.FromFile(assetName).ToShapeCollection();
mNonDisposableDictionary.Add(fullNameWithType, shapeCollection);
return((T)((object)shapeCollection));
}
#endregion
#region PositionedObjectList<Polygon>
else if (typeof(T) == typeof(PositionedObjectList <FlatRedBall.Math.Geometry.Polygon>))
{
PositionedObjectList <FlatRedBall.Math.Geometry.Polygon> polygons =
PolygonSaveList.FromFile(assetName).ToPolygonList();
mNonDisposableDictionary.Add(fullNameWithType, polygons);
return((T)((object)polygons));
}
#endregion
#region AnimationChainList
else if (typeof(T) == typeof(AnimationChainList))
{
if (assetName.EndsWith("gif"))
{
#if WINDOWS_8 || UWP || DESKTOP_GL
throw new NotImplementedException();
#else
AnimationChainList acl = new AnimationChainList();
acl.Add(FlatRedBall.Graphics.Animation.AnimationChain.FromGif(assetName, this.mName));
acl[0].ParentGifFileName = assetName;
loadedAsset = acl;
#endif
}
else
{
loadedAsset =
AnimationChainListSave.FromFile(assetName).ToAnimationChainList(mName);
}
mNonDisposableDictionary.Add(fullNameWithType, loadedAsset);
}
#endregion
else if (typeof(T) == typeof(Song))
{
var loader = new SongLoader();
return((T)(object)loader.Load(assetName));
}
#if MONOGAME
else if (typeof(T) == typeof(SoundEffect))
{
T soundEffect;
if (assetName.StartsWith(@".\") || assetName.StartsWith(@"./"))
{
soundEffect = base.Load <T>(assetName.Substring(2));
}
else
{
soundEffect = base.Load <T>(assetName);
}
return(soundEffect);
}
#endif
#region RuntimeCsvRepresentation
#if !SILVERLIGHT
else if (typeof(T) == typeof(RuntimeCsvRepresentation))
{
#if XBOX360
throw new NotImplementedException("Can't load CSV from file. Try instead to use the content pipeline.");
#else
return((T)((object)CsvFileManager.CsvDeserializeToRuntime(assetName)));
#endif
}
#endif
#endregion
#region SplineList
else if (typeof(T) == typeof(List <Spline>))
{
List <Spline> splineList = SplineSaveList.FromFile(assetName).ToSplineList();
mNonDisposableDictionary.Add(fullNameWithType, splineList);
object asObject = splineList;
return((T)asObject);
}
else if (typeof(T) == typeof(SplineList))
{
SplineList splineList = SplineSaveList.FromFile(assetName).ToSplineList();
mNonDisposableDictionary.Add(fullNameWithType, splineList);
object asObject = splineList;
return((T)asObject);
}
#endregion
#region BitmapFont
else if (typeof(T) == typeof(BitmapFont))
{
// We used to assume the texture is named the same as the font file
// But now FRB understands the .fnt file and gets the PNG from the font file
//string pngFile = FileManager.RemoveExtension(assetName) + ".png";
string fntFile = FileManager.RemoveExtension(assetName) + ".fnt";
BitmapFont bitmapFont = new BitmapFont(fntFile, this.mName);
object bitmapFontAsObject = bitmapFont;
return((T)bitmapFontAsObject);
}
#endregion
#region Text
else if (typeof(T) == typeof(string))
{
return((T)((object)FileManager.FromFileText(assetName)));
}
#endregion
#region Catch mistakes
#if DEBUG
else if (typeof(T) == typeof(Spline))
{
throw new Exception("Cannot load Splines. Try using the List<Spline> type instead.");
}
else if (typeof(T) == typeof(Emitter))
{
throw new Exception("Cannot load Emitters. Try using the EmitterList type instead.");
}
#endif
#endregion
#region else, exception!
else
{
throw new NotImplementedException("Cannot load content of type " +
typeof(T).AssemblyQualifiedName + " from file. If you are loading " +
"through the content pipeline be sure to remove the extension of the file " +
"name.");
}
#endregion
if (loadedAsset != null)
{
lock (mDisposableDictionary)
{
// Multiple threads could try to load this content simultaneously
if (!mDisposableDictionary.ContainsKey(fullNameWithType))
{
mDisposableDictionary.Add(fullNameWithType, loadedAsset);
}
}
}
return((T)loadedAsset);
}
}
public static List <string> GetNamedObjectsIn(string fileName)
{
string extension = FileManager.GetExtension(fileName);
List <string> listToReturn = new List <string>();
switch (extension)
{
#region case Scene (scnx)
case "scnx":
SpriteEditorScene ses = SpriteEditorScene.FromFile(fileName);
for (int i = 0; i < ses.PositionedModelSaveList.Count; i++)
{
listToReturn.Add(ses.PositionedModelSaveList[i].Name + " (PositionedModel)");
}
for (int i = 0; i < ses.SpriteFrameSaveList.Count; i++)
{
listToReturn.Add(ses.SpriteFrameSaveList[i].ParentSprite.Name + " (SpriteFrame)");
}
for (int i = 0; i < ses.SpriteGridList.Count; i++)
{
listToReturn.Add(ses.SpriteGridList[i].Name + " (SpriteGrid)");
}
for (int i = 0; i < ses.SpriteList.Count; i++)
{
listToReturn.Add(ses.SpriteList[i].Name + " (Sprite)");
}
for (int i = 0; i < ses.TextSaveList.Count; i++)
{
listToReturn.Add(ses.TextSaveList[i].Name + " (Text)");
}
break;
#endregion
#region case ShapeCollection (shcx)
case "shcx":
ShapeCollectionSave scs = ShapeCollectionSave.FromFile(fileName);
for (int i = 0; i < scs.AxisAlignedCubeSaves.Count; i++)
{
listToReturn.Add(scs.AxisAlignedCubeSaves[i].Name + " (AxisAlignedCube)");
}
for (int i = 0; i < scs.AxisAlignedRectangleSaves.Count; i++)
{
listToReturn.Add(scs.AxisAlignedRectangleSaves[i].Name + " (AxisAlignedRectangle)");
}
for (int i = 0; i < scs.CircleSaves.Count; i++)
{
listToReturn.Add(scs.CircleSaves[i].Name + " (Circle)");
}
for (int i = 0; i < scs.PolygonSaves.Count; i++)
{
listToReturn.Add(scs.PolygonSaves[i].Name + " (Polygon)");
}
for (int i = 0; i < scs.SphereSaves.Count; i++)
{
listToReturn.Add(scs.SphereSaves[i].Name + " (Sphere)");
}
break;
#endregion
#region NodeNetwork (nntx)
case "nntx":
NodeNetworkSave nns = NodeNetworkSave.FromFile(fileName);
for (int i = 0; i < nns.PositionedNodes.Count; i++)
{
listToReturn.Add(nns.PositionedNodes[i].Name + " (PositionedNode)");
}
break;
#endregion
#region EmitterList (emix)
case "emix":
EmitterSaveList esl = EmitterSaveList.FromFile(fileName);
for (int i = 0; i < esl.emitters.Count; i++)
{
listToReturn.Add(esl.emitters[i].Name + " (Emitter)");
}
break;
#endregion
#region Case AnimationChainList (achx)
case "achx":
AnimationChainListSave acls = AnimationChainListSave.FromFile(fileName);
for (int i = 0; i < acls.AnimationChains.Count; i++)
{
listToReturn.Add(acls.AnimationChains[i].Name + " (AnimationChain)");
}
break;
#endregion
#region Case SplineList (splx)
case "splx":
SplineSaveList ssl = SplineSaveList.FromFile(fileName);
for (int i = 0; i < ssl.Splines.Count; i++)
{
listToReturn.Add(ssl.Splines[i].Name + " (Spline)");
}
break;
#endregion
}
return(listToReturn);
}
public static List <string> GetFilesReferencedByAsset(string file, bool readRecursively)
{
string fileExtension = FileManager.GetExtension(file);
List <string> referencedFiles = null; // = new List<string>();
switch (fileExtension)
{
#region Scene (.scnx)
case "scnx":
SpriteEditorScene ses = SpriteEditorScene.FromFile(file);
referencedFiles = ses.GetReferencedFiles(RelativeType.Absolute);
break;
#endregion
#region Emitter List (.emix)
case "emix":
EmitterSaveList esl = EmitterSaveList.FromFile(file);
referencedFiles = esl.GetReferencedFiles(RelativeType.Absolute);
break;
#endregion
#region SpriteRig (.srgx)
case "srgx":
SpriteRigSave srs = SpriteRigSave.FromFile(file);
referencedFiles = srs.GetReferencedFiles(RelativeType.Absolute);
break;
#endregion
#region AnimationChain List
case "achx":
AnimationChainListSave acls = AnimationChainListSave.FromFile(file);
referencedFiles = acls.GetReferencedFiles(RelativeType.Absolute);
break;
#endregion
#region Bitmap Font Generator Config File (.bmfc)
case "bmfc":
referencedFiles = new List <string>();
// These are only referenced IF they actually exist
string referencedFileToAdd = FileManager.RemoveExtension(file) + ".png";
if (FileManager.FileExists(referencedFileToAdd))
{
referencedFiles.Add(referencedFileToAdd);
}
referencedFileToAdd = FileManager.RemoveExtension(file) + ".fnt";
if (FileManager.FileExists(referencedFileToAdd))
{
referencedFiles.Add(referencedFileToAdd);
}
break;
#endregion
#region X File (.x)
case "x":
referencedFiles = GetTextureReferencesInX(file);
break;
#endregion
#region WME File (.wme)
case "wme":
referencedFiles = new List <string>();
WMELoader.GetReferencedFiles(file, referencedFiles, RelativeType.Absolute);
break;
#endregion
#region Spline List (.slpx) - falls to default
case "splx":
#endregion
default:
referencedFiles = new List <string>();
break;
}
if (readRecursively)
{
for (int i = referencedFiles.Count - 1; i > -1; i--)
{
referencedFiles.AddRange(GetFilesReferencedByAsset(referencedFiles[i], true));
}
}
// Files may include "../", so let's get rid of that stuff
for (int i = 0; i < referencedFiles.Count; i++)
{
referencedFiles[i] = FileManager.Standardize(referencedFiles[i], "", false);
}
return(referencedFiles);
}
public static void GetFilesReferencedByAsset(string fileName, TopLevelOrRecursive topLevelOrRecursive, List <string> referencedFiles)
{
List <string> newReferencedFiles = new List <string>();
if (!CanFileReferenceOtherFiles(fileName))
{
return;
}
else if (!FileManager.FileExists(fileName))
{
throw new FileNotFoundException("Could not find file " + fileName, fileName);
}
else
{
string fileExtension = FileManager.GetExtension(fileName);
switch (fileExtension)
{
#region Scene (.scnx)
case "scnx":
SceneSave ses = SceneSave.FromFile(fileName);
try
{
newReferencedFiles = ses.GetReferencedFiles(RelativeType.Absolute);
}
catch (InvalidOperationException e)
{
MessageBox.Show("There is an invalid file reference in the file\n\n" +
fileName +
"\n\nGlue will skip this file. You should investigate this file in a text editor " +
"to identify the issue.\n\nAdditional error information:\n\n" + e.ToString());
}
break;
#endregion
#region Emitter List (.emix)
case "emix":
EmitterSaveList esl = EmitterSaveList.FromFile(fileName);
newReferencedFiles = esl.GetReferencedFiles(RelativeType.Absolute);
break;
#endregion
#region AnimationChain List
case "achx":
AnimationChainListSave acls = AnimationChainListSave.FromFile(fileName);
newReferencedFiles = acls.GetReferencedFiles(RelativeType.Absolute);
break;
#endregion
#region X File (.x)
case "x":
newReferencedFiles = GetTextureReferencesInX(fileName);
break;
#endregion
#region Spline List (.slpx) - falls to default
case "splx":
#endregion
#region Font File (.fnt)
case "fnt":
newReferencedFiles = GetTextureReferencesInFnt(fileName);
break;
#endregion
default:
break;
}
// We still want to construct as good of a reference structure as possible
// even if there are missing files. Therefore, we'll just keep track of errors and report them
// at the end of the method
bool didErrorOccur = false;
string errorMessage = "";
if (topLevelOrRecursive == TopLevelOrRecursive.Recursive)
{
for (int i = newReferencedFiles.Count - 1; i > -1; i--)
{
// If this file can't reference other files, no need to even do a file check or throw errors.
if (CanFileReferenceOtherFiles(newReferencedFiles[i]) == true)
{
if (File.Exists(newReferencedFiles[i]))
{
try
{
GetFilesReferencedByAsset(newReferencedFiles[i], topLevelOrRecursive, newReferencedFiles);
}
catch (Exception e)
{
didErrorOccur = true;
errorMessage += e.Message;
}
}
else
{
didErrorOccur = true;
errorMessage += "Could not find the file " + newReferencedFiles[i] +
" which is referenced in the file " + fileName + "\n";
}
}
}
}
// Files may include "../", so let's get rid of that stuff
for (int i = 0; i < newReferencedFiles.Count; i++)
{
newReferencedFiles[i] = FileManager.Standardize(newReferencedFiles[i], "", false);
}
referencedFiles.AddRange(newReferencedFiles);
if (didErrorOccur)
{
throw new Exception(errorMessage);
}
}
}
public static Sprite AddSprite(string spriteTexture, string nameToUse)
{
EditorSprite spriteCreated = new EditorSprite();
#region Create the spriteCreated depending on the type in spriteTexture
try
{
#region Is the texture null?
if (string.IsNullOrEmpty(spriteTexture))
{
spriteCreated.Texture = null;
spriteCreated.Red = GraphicalEnumerations.MaxColorComponentValue;
spriteCreated.ColorOperation = Microsoft.DirectX.Direct3D.TextureOperation.SelectArg2;
}
#endregion
#region Create the Sprite with a .achx
else if (spriteTexture.EndsWith(".ach") || spriteTexture.EndsWith(".achx") ||
spriteTexture.EndsWith(".gif"))
{
if (spriteTexture.EndsWith(".gif"))
{
AnimationChain animationChain = AnimationChain.FromGif(spriteTexture, SceneContentManager);
spriteCreated.SetAnimationChain(animationChain);
}
else
{
AnimationChainListSave listSave = AnimationChainListSave.FromFile(spriteTexture);
spriteCreated.AnimationChains = listSave.ToAnimationChainList(SceneContentManager);
}
if (spriteCreated.AnimationChains.Count != 0)
{
spriteCreated.SetAnimationChain(spriteCreated.AnimationChains[0]);
}
spriteCreated.Animate = true;
}
#endregion
#region Create the Sprite with an image
else
{
spriteCreated.Texture =
FlatRedBallServices.Load <Texture2D>(spriteTexture, SceneContentManager);
}
#endregion
}
catch (Microsoft.DirectX.Direct3D.InvalidDataException)
{
throw new Microsoft.DirectX.Direct3D.InvalidDataException();
}
#endregion
SpriteManager.AddSprite(spriteCreated);
KeepSpriteNameUnique <Sprite>(spriteCreated, nameToUse, mScene.Sprites);
spriteCreated.X = Camera.X;
spriteCreated.Y = Camera.Y;
// If the camera's in ortho mode then we're likely making a 2D game, so set the PixelSize to .5
if (SpriteManager.Camera.Orthogonal)
{
spriteCreated.PixelSize = .5f;
}
SetStoredAddToSE(spriteCreated, EditorProperties.PixelSize);
return(spriteCreated);
}