private AssetTypeInfo CreateAtiForRawTmx() { AssetTypeInfo toReturn = CreateAtiForLayeredTilemapScnx(); toReturn.VariableDefinitions.Add(new VariableDefinition { Name = "X", Type = "float", DefaultValue = "0", Category = "Position" }); toReturn.VariableDefinitions.Add(new VariableDefinition { Name = "Y", Type = "float", DefaultValue = "0", Category = "Position" }); toReturn.VariableDefinitions.Add(new VariableDefinition { Name = "Z", Type = "float", DefaultValue = "0", Category = "Position" }); toReturn.FriendlyName = "LayeredTileMap (.tmx)"; toReturn.QualifiedSaveTypeName = ""; toReturn.Extension = "tmx"; toReturn.CustomLoadMethod = "{THIS} = FlatRedBall.TileGraphics.LayeredTileMap.FromTiledMapSave(\"{FILE_NAME}\", {CONTENT_MANAGER_NAME});"; return(toReturn); }
private AssetTypeInfo CreateAtiForLayeredTilemapScnx() { AssetTypeInfo toReturn = new AssetTypeInfo(); toReturn.FriendlyName = "LayeredTileMap (.scnx)"; toReturn.QualifiedRuntimeTypeName = new PlatformSpecificType(); toReturn.QualifiedRuntimeTypeName.QualifiedType = "FlatRedBall.TileGraphics.LayeredTileMap"; toReturn.QualifiedSaveTypeName = "FlatRedBall.Content.SpriteEditorScene"; toReturn.Extension = "scnx"; toReturn.AddToManagersMethod = new List <string>(); toReturn.AddToManagersMethod.Add("this.AddToManagers()"); toReturn.LayeredAddToManagersMethod.Add("this.AddToManagers(mLayer)"); toReturn.CustomLoadMethod = "{THIS} = FlatRedBall.TileGraphics.LayeredTileMap.FromScene(\"{FILE_NAME}\", {CONTENT_MANAGER_NAME});"; toReturn.DestroyMethod = "this.Destroy()"; toReturn.ShouldBeDisposed = false; toReturn.ShouldAttach = true; // I believe this means it will call Clone() toReturn.CanBeCloned = true; toReturn.MustBeAddedToContentPipeline = false; toReturn.HasCursorIsOn = false; toReturn.HasVisibleProperty = false; toReturn.CanIgnorePausing = false; toReturn.CanBeObject = true; // We don't want this to show up as a file type - it's the same thing as a .scnx, and should only be used // from a TMX. toReturn.HideFromNewFileWindow = true; return(toReturn); }
private AssetTypeInfo CreateAtiForTileShapeCollection() { AssetTypeInfo toReturn = new AssetTypeInfo(); toReturn.FriendlyName = "TileShapeCollection"; toReturn.QualifiedRuntimeTypeName = new PlatformSpecificType(); toReturn.QualifiedRuntimeTypeName.QualifiedType = "FlatRedBall.TileCollisions.TileShapeCollection"; toReturn.QualifiedSaveTypeName = null; toReturn.Extension = null; toReturn.AddToManagersMethod = new List <string>(); toReturn.CustomLoadMethod = null; toReturn.DestroyMethod = "this.Visible = false"; toReturn.ShouldBeDisposed = false; toReturn.ShouldAttach = false; toReturn.MustBeAddedToContentPipeline = false; toReturn.CanBeCloned = false; toReturn.HasCursorIsOn = false; toReturn.CanIgnorePausing = false; toReturn.CanBeObject = true; toReturn.HasVisibleProperty = true; toReturn.FindByNameSyntax = $"Collisions.First(item => item.Name == \"OBJECTNAME\");"; toReturn.GetObjectFromFileFunc = GetObjectFromFileFunc; toReturn.VariableDefinitions.Add(new VariableDefinition() { Name = "Visible", DefaultValue = "false", Type = "bool" }); toReturn.ConstructorFunc = GenerateConstructionFunc; return(toReturn); }
private void OptionsComboBox_SelectedIndexChanged(object sender, EventArgs e) { if (mOptionsComboBox.SelectedItem != null && mOptionsComboBox.SelectedItem is AssetTypeInfo) { AssetTypeInfo ati = mOptionsComboBox.SelectedItem as AssetTypeInfo; string fileType = GetObjectTypeFromAti(ati); foreach (var option in mFileTypeOptions) { if (option.ObjectType.Contains(fileType)) { mDynamicUiHelper.Show(option.UiId); } else { mDynamicUiHelper.Hide(option.UiId); } } if (mIsNameDefault) { // We want to make sure we don't // suggest a name that is already // being used. //textBox1.Text = fileType + "File"; textBox1.Text = StringFunctions.MakeStringUnique(fileType + "File", mNamesAlreadyUsed, 2); while (ObjectFinder.Self.GetReferencedFileSaveFromFile(textBox1.Text + "." + ResultAssetTypeInfo.Extension) != null) { textBox1.Text = FlatRedBall.Utilities.StringFunctions.IncrementNumberAtEnd(textBox1.Text); } } } }
private static string GetCreatedFileTarget(AssetTypeInfo assetTypeInfo, string directory, string name) { string createdFile = ""; if (!directory.EndsWith("\\") && !directory.EndsWith("/")) { directory = directory + "/"; } if (FileManager.IsRelative(directory)) { createdFile = FileManager.RelativeDirectory + directory + name + "." + assetTypeInfo.Extension; if (ObjectFinder.Self.GlueProject != null) { // I think we should always use the content directory whether we have a content project or not: createdFile = ProjectManager.ContentDirectory + directory + name + "." + assetTypeInfo.Extension; } } else { createdFile = directory + name + "." + assetTypeInfo.Extension; } return(createdFile); }
private void AddRenderTargetAti() { AssetTypeInfo renderTargetAti = new AssetTypeInfo(); // todo: need to make an explicit InstantiateOnAddToManagers bool for ATI, set to true for layers and this, instead of relying on "this = " in the AddToManagers call renderTargetAti.CanBeObject = true; renderTargetAti.QualifiedRuntimeTypeName = new PlatformSpecificType { QualifiedType = "Microsoft.Xna.Framework.Graphics.RenderTarget2D" }; renderTargetAti.FriendlyName = "RenderTarget"; renderTargetAti.AddToManagersFunc = GetAddToManagersCodeForRenderTarget; renderTargetAti.ConstructorFunc = GetConstructorFunc; renderTargetAti.VariableDefinitions.Add(new VariableDefinition { Name = "Width", Type = "int", UsesCustomCodeGeneration = true }); renderTargetAti.VariableDefinitions.Add(new VariableDefinition { Name = "Height", Type = "int", UsesCustomCodeGeneration = true }); // Seems like currently Glue doesn't differentiate between remove from managers and destroy...may need to investigate this if it becomes a problem. renderTargetAti.DestroyMethod = "this.Dispose()"; AvailableAssetTypes.Self.AddAssetType(renderTargetAti); }
private void AddAssetTypeIfNotPresent(AssetTypeInfo ati) { if (AvailableAssetTypes.Self.AllAssetTypes.Any(item => item.FriendlyName == ati.FriendlyName) == false) { AvailableAssetTypes.Self.AddAssetType(ati); } }
private void CreateAndAddTpsAti() { AssetTypeInfo gumProjectAti = new AssetTypeInfo(); gumProjectAti.FriendlyName = "TexturePacker Sprite Sheet (.tps)"; //gumProjectAti.QualifiedSaveTypeName = "Gum.Data.ProjectSave"; gumProjectAti.Extension = "tps"; //gumProjectAti.CustomLoadMethod = "FlatRedBall.Gum.GumIdb.StaticInitialize(\"{FILE_NAME}\"); " + // "FlatRedBall.Gum.GumIdb.RegisterTypes(); " + // "FlatRedBall.Gui.GuiManager.BringsClickedWindowsToFront = false;"; gumProjectAti.SupportsMakeOneWay = false; gumProjectAti.ShouldAttach = false; gumProjectAti.MustBeAddedToContentPipeline = false; gumProjectAti.CanBeCloned = false; gumProjectAti.HasCursorIsOn = false; gumProjectAti.HasVisibleProperty = false; gumProjectAti.CanIgnorePausing = false; // don't let users add this: gumProjectAti.HideFromNewFileWindow = true; gumProjectAti.CanBeObject = false; AddIfNotPresent(gumProjectAti); }
private bool IsIInstructable(AssetTypeInfo assetTypeInfo) { return(assetTypeInfo?.RuntimeTypeName == "Sprite" || assetTypeInfo?.RuntimeTypeName == "Text" || assetTypeInfo?.RuntimeTypeName == "PositionedObject" ); }
/// <summary> /// Returns whether the calling Entity inherits from another Entity that implements IVisible. /// Whether the calling Entity itself implements IVisible doesn't matter. /// </summary> /// <param name="instance">The calling Entity</param> /// <returns>Whether the implementation is found in a base Entity.</returns> public static bool GetInheritsFromIVisible(this EntitySave instance) { if (string.IsNullOrEmpty(instance.BaseEntity)) { return(false); } else { if (instance.InheritsFromFrbType()) { AssetTypeInfo ati = AvailableAssetTypes.Self.GetAssetTypeFromRuntimeType(instance.BaseEntity, instance); if (ati != null) { return(ati.HasVisibleProperty); } } else { EntitySave entitySave = ObjectFinder.Self.GetEntitySave(instance.BaseEntity); return(entitySave != null && (entitySave.ImplementsIVisible || entitySave.GetInheritsFromIVisible())); } } return(false); }
private static void SetAtiValue(AssetTypeInfo ati, string variableName, string value) { var orthogonal = ati.VariableDefinitions.FirstOrDefault(item => item.Name == variableName); if (orthogonal != null) { orthogonal.DefaultValue = value; } }
private void CreateNoCodeGenerationAtiFor(string extension) { AssetTypeInfo ati = new AssetTypeInfo(); ati.Extension = extension; ati.FriendlyName = extension + " (" + extension + ")"; AvailableAssetTypes.Self.AddAssetType(ati); }
private void BtnAddNewFileClick(object sender, System.EventArgs e) { if (!ProjectTypeIsValid()) { return; } var nfw = new CustomizableNewFileWindow(); foreach (var ati in AvailableAssetTypes.Self.AllAssetTypes) { if (!string.IsNullOrEmpty(ati.Extension) && !string.IsNullOrEmpty(ati.QualifiedSaveTypeName)) { nfw.AddOption(ati); } // special case .txt if (ati.Extension == "txt") { nfw.AddOption(ati); } } // Also add CSV files //nfw.AddOption(new AssetTypeInfo("csv", "", null, "Spreadsheet (.csv)", "", "")); nfw.AddOption(AvailableAssetTypes.Self.AllAssetTypes.First(item => item.FriendlyName == "Spreadsheet (.csv)")); var dialogResult = nfw.ShowDialog(); if (dialogResult == true) { AssetTypeInfo resultAssetTypeInfo = nfw.ResultAssetTypeInfo; bool make2D = nfw.GetOptionFor(resultAssetTypeInfo) == "2D"; string name = nfw.ResultName; string createdFile = PluginManager.CreateNewFile(resultAssetTypeInfo, make2D, FileManager.GetDirectoryKeepRelative(Rfs.Name), name); //var createdFile = resultAssetTypeInfo.CreateNewFile(FileManager.GetDirectoryKeepRelative(Rfs.Name) + name, "", make2D); createdFile = ProjectManager.MakeRelativeContent(createdFile); var psf = new ProjectSpecificFile { ProjectName = cboProjectType.Text, FilePath = createdFile }; Value.Add(psf); Rfs.ProjectSpecificFiles = Value; GlueCommands.Self.ProjectCommands.UpdateFileMembershipInProject(Rfs); ProjectManager.SaveProjects(); GlueCommands.Self.RefreshCommands.RefreshPropertyGrid(); RefreshList(); } }
public static AssetTypeInfo GetAssetTypeInfo(this NamedObjectSave instance) { if (instance == null) { throw new ArgumentNullException(nameof(instance)); } if (string.IsNullOrEmpty(instance.ClassType)) { return(null); } // If this NOS uses an EntireFile, then we should ask the file for its AssetTypeInfo, // as there may be multiple file types that produce the same class type. // For example AssetTypeInfo returnAti = null; if (instance.IsEntireFile) { var container = instance.GetContainer(); var rfs = container?.GetReferencedFileSave(instance.SourceFile); if (rfs != null) { var candidateAti = rfs.GetAssetTypeInfo(); // The user may use a file, but may change the runtime type through the // SourceName property, so we need to make sure they match: if (candidateAti != null && candidateAti.RuntimeTypeName == instance.ClassType) { returnAti = candidateAti; } } } if (returnAti == null) { returnAti = AvailableAssetTypes.Self.GetAssetTypeFromRuntimeType(instance.ClassType, instance, isObject: true); } if (instance.ClassType.StartsWith("PositionedObjectList<")) { return(null); } else { // Vic says: I don't think this should throw an exception anymore //if (returnAti == null) //{ // throw new InvalidOperationException("You probably need to add the class type " + this.ClassType + // " to the ContentTypes.csv"); //} return(returnAti); } }
public ReferencedFileSave ShowAddNewFileDialog() { ReferencedFileSave rfs = null; NewFileWindow nfw = CreateNewFileWindow(); if (nfw.ShowDialog(MainGlueWindow.Self) == DialogResult.OK) { string name = nfw.ResultName; AssetTypeInfo resultAssetTypeInfo = nfw.ResultAssetTypeInfo; string errorMessage; string directory = null; IElement element = EditorLogic.CurrentElement; if (EditorLogic.CurrentTreeNode.IsDirectoryNode()) { directory = EditorLogic.CurrentTreeNode.GetRelativePath().Replace("/", "\\"); } var option = nfw.GetOptionFor(resultAssetTypeInfo); rfs = GlueProjectSaveExtensionMethods.AddReferencedFileSave( element, directory, name, resultAssetTypeInfo, option, out errorMessage); if (!string.IsNullOrEmpty(errorMessage)) { MessageBox.Show(errorMessage); } else if (rfs != null) { var createdFile = ProjectManager.MakeAbsolute(rfs.GetRelativePath()); if (createdFile.EndsWith(".csv")) { string location = ProjectManager.MakeAbsolute(createdFile); CsvCodeGenerator.GenerateAndSaveDataClass(rfs, AvailableDelimiters.Comma); } ElementViewWindow.UpdateChangedElements(); ElementViewWindow.SelectedNode = GlueState.Self.Find.ReferencedFileSaveTreeNode(rfs); PluginManager.ReactToNewFile(rfs); GluxCommands.Self.SaveGlux(); } } return(rfs); }
private AssetTypeInfo CreateAtiForLayeredTilemapTilb() { AssetTypeInfo toReturn = CreateAtiForLayeredTilemapScnx(); toReturn.FriendlyName = "LayeredTileMap (.tilb)"; toReturn.QualifiedSaveTypeName = ""; toReturn.Extension = "tilb"; toReturn.CustomLoadMethod = "{THIS} = FlatRedBall.TileGraphics.LayeredTileMap.FromReducedTileMapInfo(\"{FILE_NAME}\", {CONTENT_MANAGER_NAME});"; return(toReturn); }
private AssetTypeInfo CreateArticyDraftXmlAti() { var toReturn = new AssetTypeInfo(); toReturn.FriendlyName = "Articy:Draft XML File"; toReturn.QualifiedRuntimeTypeName = new PlatformSpecificType(); toReturn.QualifiedRuntimeTypeName.QualifiedType = "ArticyDraft.GameDialogue"; // todo continue here maybe return(toReturn); }
public void AddIfNotPresent(AssetTypeInfo ati) { var alreadyAdded = AvailableAssetTypes.Self.AllAssetTypes .Any(item => item.FriendlyName == ati.FriendlyName && item.QualifiedRuntimeTypeName.QualifiedType == ati.QualifiedRuntimeTypeName.QualifiedType); if (alreadyAdded == false) { AvailableAssetTypes.Self.AddAssetType(ati); } }
public List <string> GetInheritanceList(IElement element, EntitySave entitySave, out EntitySave rootEntitySave) { var inheritsFromEntity = !string.IsNullOrEmpty(element.BaseElement) && element.BaseElement != "<NONE>" && !element.InheritsFromFrbType(); rootEntitySave = null; if (inheritsFromEntity) { rootEntitySave = entitySave.GetRootBaseEntitySave(); inheritsFromEntity = inheritsFromEntity && entitySave.GetRootBaseEntitySave() != null; } List <string> inheritanceList = new List <string>(); if (inheritsFromEntity) { inheritanceList.Add( ProjectManager.ProjectNamespace + "." + entitySave.BaseEntity.Replace("\\", ".")); } else if (entitySave.InheritsFromFrbType()) { AssetTypeInfo ati = AvailableAssetTypes.Self.GetAssetTypeFromRuntimeType(entitySave.BaseEntity); if (ati != null) { inheritanceList.Add(ati.QualifiedRuntimeTypeName.QualifiedType); } else { inheritanceList.Add(entitySave.BaseEntity); } } else { inheritanceList.Add("FlatRedBall.PositionedObject"); } inheritanceList.Add("FlatRedBall.Graphics.IDestroyable"); foreach (ElementComponentCodeGenerator eccg in CodeWriter.CodeGenerators) { eccg.AddInheritedTypesToList(inheritanceList, element); } StringFunctions.RemoveDuplicates(inheritanceList); return(inheritanceList); }
bool IsRfsOfType(ReferencedFileSave rfs, Type type) { AssetTypeInfo ati = rfs.GetAssetTypeInfo(); if (ati != null) { return(ati.QualifiedRuntimeTypeName.QualifiedType == type.FullName); } else { return(false); } }
bool IsRfsOfUnqualifiedRuntimeType(ReferencedFileSave rfs, string unqualifiedRuntimeType) { AssetTypeInfo ati = rfs.GetAssetTypeInfo(); if (ati != null) { return(ati.RuntimeTypeName == unqualifiedRuntimeType); } else { return(false); } }
private AssetTypeInfo GetAtiFor(ElementSave element) { AssetTypeInfo newAti = FlatRedBall.IO.FileManager.CloneObject <AssetTypeInfo>(GraphicalUiElementAti); newAti.QualifiedRuntimeTypeName = new PlatformSpecificType() { QualifiedType = GueDerivingClassCodeGenerator.GetQualifiedRuntimeTypeFor(element) }; if (element is ComponentSave) { newAti.Extension = GumProjectSave.ComponentExtension; newAti.CustomLoadMethod = ComponentAti.CustomLoadMethod + " as " + GueDerivingClassCodeGenerator.GetQualifiedRuntimeTypeFor(element); } string unqualifiedName = element.Name + "Runtime"; newAti.FriendlyName = unqualifiedName; newAti.FindByNameSyntax = "GetGraphicalUiElementByName(\"OBJECTNAME\") as " + newAti.QualifiedRuntimeTypeName.QualifiedType; if (newAti.ExtraVariablesPattern.EndsWith(";") == false) { newAti.ExtraVariablesPattern += ";"; } newAti.ExtraVariablesPattern = ""; // 9/24/2014 // Jesse was getting // the plugin to crash // on this line of code // with a NullReferenceException. // I'm going to wrap this in if-s to be sure it's safe. if (element != null && element.DefaultState != null && element.DefaultState.Variables != null) { foreach (var variable in element.DefaultState.Variables.Where(item => !string.IsNullOrEmpty(item.ExposedAsName) || string.IsNullOrEmpty(item.SourceObject))) { var variableDefinition = new VariableDefinition(); variableDefinition.Category = variable.Category; variableDefinition.DefaultValue = variable.Value?.ToString(); variableDefinition.Name = variable.ExposedAsName ?? variable.Name; variableDefinition.Type = variable.Type; newAti.VariableDefinitions.Add(variableDefinition); } } return(newAti); }
public static void UpdateShownVariables(DataUiGrid grid, NamedObjectSave instance, IElement container) { grid.Categories.Clear(); List <MemberCategory> categories = new List <MemberCategory>(); var defaultCategory = new MemberCategory("Variables"); defaultCategory.FontSize = 14; categories.Add(defaultCategory); AssetTypeInfo ati = instance.GetAssetTypeInfo(); // not sure if this is needed: if (instance.TypedMembers.Count == 0) { instance.UpdateCustomProperties(); } CreateCategoriesAndVariables(instance, container, categories, ati); if (ati != null) { SortCategoriesAndMembers(ref categories, ati); } if (defaultCategory.Members.Count == 0) { categories.Remove(defaultCategory); } else if (categories.Count != 1) { defaultCategory.Name = "Other Variables"; } if (categories.Count != 0) { // "Name" should be the very first property: var nameCategory = CreateNameInstanceMember(instance); categories.Insert(0, nameCategory); } SetAlternatingColors(grid, categories); foreach (var category in categories) { grid.Categories.Add(category); } grid.Refresh(); }
public List <AssetTypeInfo> GetAtisForDerivedGues() { List <AssetTypeInfo> assetTypeInfos = new List <AssetTypeInfo>(); foreach (var element in AppState.Self.AllLoadedElements) { if (GueDerivingClassCodeGenerator.Self.ShouldGenerateRuntimeFor(element)) { AssetTypeInfo newAti = GetAtiFor(element); assetTypeInfos.Add(newAti); } } return(assetTypeInfos); }
public static AssetTypeInfo GetAssetTypeInfoForProjectSpecificFile(this ReferencedFileSave instance, ProjectSpecificFile psf) { string extension = FileManager.GetExtension(psf.FilePath); AssetTypeInfo thisAssetTypeInfo = instance.GetAssetTypeInfo(); foreach (AssetTypeInfo assetTypeInfo in AvailableAssetTypes.Self.AllAssetTypes) { if (assetTypeInfo.Extension == extension && assetTypeInfo.RuntimeTypeName == thisAssetTypeInfo.RuntimeTypeName) { return(assetTypeInfo); } } return(null); }
private void CreateAndAddTexturePackerSpriteSheetAti() { TextureAtlasAti = new AssetTypeInfo(); TextureAtlasAti.FriendlyName = "Texture Atlas"; // We don't want this as part of the VS project, since it's not loaded at runtime. TextureAtlasAti.Extension = "atlas"; TextureAtlasAti.QualifiedRuntimeTypeName.QualifiedType = "FlatRedBall.Graphics.Texture.Atlas"; TextureAtlasAti.CustomLoadMethod = "{THIS} = FlatRedBall.Graphics.Texture.AtlasLoader.Load(\"{FILE_NAME}\", {CONTENT_MANAGER_NAME});"; TextureAtlasAti.CustomBuildToolName = "*.tps->TexturePacker.exe-> *.atlas"; AddIfNotPresent(TextureAtlasAti); AvailableAssetTypes.Self.AddAssetType(TextureAtlasAti); }
public string GetObjectTypeFromAti(AssetTypeInfo ati) { if (ati == null) { return(null); } else { string fileType = ati.FriendlyName; if (fileType.Contains("(")) { fileType = fileType.Substring(0, fileType.IndexOf('(')); } fileType = fileType.Replace(" ", ""); return(fileType); } }
private bool CreateNewFile(AssetTypeInfo assetTypeInfo, object extraData, string directory, string name, out string resultingName) { resultingName = null; if (assetTypeInfo != null) { string createdFile = GetCreatedFileTarget(assetTypeInfo, directory, name); SaveNewFileAtLocation(assetTypeInfo, createdFile); bool make2D = (bool)extraData; AssetTypeInfoExtensionMethodsGlue.CreateCompanionSettingsFile(createdFile, make2D); resultingName = createdFile; return(true); } return(false); }
/// <summary> /// Returns whether the calling Entity inherits from another class that implements ICollidable. /// Whether the calling Entity itself implements ICollidable doesn't matter. /// </summary> /// <param name="instance">The calling Entity</param> /// <returns>Whether the implementation is found in a base Entity.</returns> public static bool GetHasImplementsCollidableProperty(this EntitySave instance) { if (string.IsNullOrEmpty(instance.BaseEntity)) { return(true); } else { if (instance.InheritsFromFrbType()) { AssetTypeInfo ati = AvailableAssetTypes.Self.GetAssetTypeFromRuntimeType(instance.BaseEntity, instance); if (ati != null) { return(!ati.ImplementsICollidable); } } return(true); } }
public AssetTypeInfo CreateAtiForTileShapeCollection() { AssetTypeInfo toReturn = new AssetTypeInfo(); toReturn.FriendlyName = "TileShapeCollection"; toReturn.QualifiedRuntimeTypeName = new PlatformSpecificType(); toReturn.QualifiedRuntimeTypeName.QualifiedType = "FlatRedBall.TileCollisions.TileShapeCollection"; toReturn.QualifiedSaveTypeName = null; toReturn.Extension = null; toReturn.AddToManagersMethod = new List <string>(); toReturn.CustomLoadMethod = null; toReturn.DestroyMethod = "this.Visible = false"; toReturn.ShouldBeDisposed = false; toReturn.ShouldAttach = false; toReturn.MustBeAddedToContentPipeline = false; toReturn.CanBeCloned = false; toReturn.HasCursorIsOn = false; toReturn.CanIgnorePausing = false; toReturn.CanBeObject = true; toReturn.HasVisibleProperty = true; return(toReturn); }
public bool CreateNewFile(AssetTypeInfo assetTypeInfo, object extraData, string directory, string name, out string resultingName) { resultingName = null; if (assetTypeInfo != null) { string createdFile = GetCreatedFileTarget(assetTypeInfo, directory, name); SaveNewFileAtLocation(assetTypeInfo, createdFile); bool make2D = (bool)extraData; AssetTypeInfoExtensionMethodsGlue.CreateCompanionSettingsFile(createdFile, make2D); resultingName = createdFile; return true; } return false; }
public string GetObjectTypeFromAti(AssetTypeInfo ati) { if (ati == null) { return null; } else { string fileType = ati.FriendlyName; if (fileType.Contains("(")) { fileType = fileType.Substring(0, fileType.IndexOf('(')); } fileType = fileType.Replace(" ", ""); return fileType; } }
private static void InstantiateObjectInSwitchStatement(NamedObjectSave namedObject, ICodeBlock codeBlock, List<string[]> referencedFilesAlreadyUsingFullFile, AssetTypeInfo ati, string objectName, ReferencedFileSave rfs, List<StateSave> stateSaves, IElement saveObject, string defaultContainer, string overridingName) { var switchBlock = codeBlock.Switch("LoadingState"); for (int i = 0; i < stateSaves.Count; i++) { StateSave stateSave = stateSaves[i]; string name = ""; // I don't think we're going to use these anymore //NamedObjectPropertyOverride objectOverride = stateSave.GetNamedObjectOverride(objectName); //name = FileManager.RemovePath(FileManager.RemoveExtension(objectOverride.SourceFile)); InstantiateObjectUsingFile(namedObject, switchBlock.Case("VariableState." + stateSave.Name), referencedFilesAlreadyUsingFullFile, ati, objectName, rfs, saveObject, name, overridingName); } InstantiateObjectUsingFile(namedObject, switchBlock.Case("VariableState.Uninitialized:"), referencedFilesAlreadyUsingFullFile, ati, objectName, rfs, saveObject, defaultContainer, overridingName); }
public static void GetLoadCallForAtiFile(ReferencedFileSave rfs, AssetTypeInfo ati, string variableName, string contentManagerString, string fileNameToLoad, ICodeBlock codeBlock) { string formattableLine = null; if (!string.IsNullOrEmpty(ati.CustomLoadMethod)) { formattableLine = ati.CustomLoadMethod; // Replace the expressive variable names with ints: formattableLine = formattableLine.Replace("{THIS}", "{0}"); formattableLine = formattableLine.Replace("{TYPE}", "{1}"); formattableLine = formattableLine.Replace("{FILE_NAME}", "{2}"); formattableLine = formattableLine.Replace("{CONTENT_MANAGER_NAME}", "{3}"); // If the user didn't end the line with a semicolon, let's do it ourselves if (!formattableLine.EndsWith(";")) { formattableLine = formattableLine + ";"; } } else { formattableLine = "{0} = FlatRedBall.FlatRedBallServices.Load<{1}>(@\"{2}\", {3});"; } bool shouldAddExtensionOnNonXnaPlatforms = FileManager.GetExtension(fileNameToLoad) != FileManager.GetExtension(rfs.Name) && FileManager.GetExtension(rfs.Name) == "png"; if(shouldAddExtensionOnNonXnaPlatforms) { codeBlock.Line("#if IOS || ANDROID || WINDOWS_8"); string withExtension = fileNameToLoad + ".png"; codeBlock.Line( string.Format(formattableLine, variableName, ati.QualifiedRuntimeTypeName.QualifiedType, withExtension, contentManagerString)); codeBlock.Line("#else"); } codeBlock.Line( string.Format(formattableLine, variableName, ati.QualifiedRuntimeTypeName.QualifiedType, fileNameToLoad, contentManagerString)); if (shouldAddExtensionOnNonXnaPlatforms) { codeBlock.Line("#endif"); } }
private static void SortMembers(List<MemberCategory> categories, AssetTypeInfo ati) { foreach(var category in categories) { string categoryName = category.Name; var variableDefinitions = ati.VariableDefinitions .Where(item => item.Category == categoryName) .Select(item=>item.Name) .ToList(); var sorted = category.Members .OrderBy(item => { var castedItem = item as DataGridItem; var index = variableDefinitions.IndexOf(castedItem.UnmodifiedVariableName); if(index == -1) { return int.MaxValue; } else { return index; } }) .ToList(); category.Members.Clear(); foreach(var item in sorted) { category.Members.Add(item); } } }
private static string GetCreatedFileTarget(AssetTypeInfo assetTypeInfo, string directory, string name) { string createdFile = ""; if (!directory.EndsWith("\\") && !directory.EndsWith("/")) { directory = directory + "/"; } if (FileManager.IsRelative(directory)) { createdFile = FileManager.RelativeDirectory + directory + name + "." + assetTypeInfo.Extension; if (ObjectFinder.Self.GlueProject != null) { // I think we should always use the content directory whether we have a content project or not: createdFile = ProjectManager.ContentDirectory + directory + name + "." + assetTypeInfo.Extension; } } else { createdFile = directory + name + "." + assetTypeInfo.Extension; } return createdFile; }
private static List<MemberCategory> SortCategories(List<MemberCategory> categories, AssetTypeInfo ati) { var orderedCategoryNames = ati.VariableDefinitions.Select(item => item.Category).Distinct().ToList(); categories = categories.OrderBy(item => { int index = orderedCategoryNames.IndexOf(item.Name); if (index == -1) { return int.MaxValue; } else { return index; } }).ToList(); return categories; }
private static void GenerateInitializationForAssetTypeInfoRfs(ReferencedFileSave referencedFile, ICodeBlock codeBlock, bool loadsUsingGlobalContentManager, string variableName, string fileName, AssetTypeInfo ati, ProjectBase project) { string typeName = ati.RuntimeTypeName; var vsProject = project as VisualStudioProject; var isContentPipeline = (vsProject == null || vsProject.AllowContentCompile) && (ati.MustBeAddedToContentPipeline || referencedFile.UseContentPipeline); if (isContentPipeline) { fileName = FileManager.RemoveExtension(fileName); } bool isSharedStatic = referencedFile.IsSharedStatic; string referencedFileName = referencedFile.Name; bool containedByGlobalContentFiles = GlobalContentFilesDictionary.ContainsKey(referencedFileName); var referencedFileContainerType = referencedFile.GetContainerType(); if (isSharedStatic && containedByGlobalContentFiles && loadsUsingGlobalContentManager && referencedFileContainerType != ContainerType.None) { string globalRfsVariable = GlobalContentFilesDictionary[referencedFile.Name].GetInstanceName(); codeBlock.Line(string.Format("{0} = GlobalContent.{1};", variableName, globalRfsVariable)); } else { ContentLoadWriter.GetLoadCallsForRfs( referencedFile, fileName, ati, variableName, codeBlock, loadsUsingGlobalContentManager && referencedFile.IsSharedStatic, isContentPipeline); } }
private static string WriteMethodForClone(NamedObjectSave namedObject, ICodeBlock codeBlock, List<string[]> referencedFilesAlreadyUsingFullFile, AssetTypeInfo nosAti, string objectName, ReferencedFileSave rfs, IElement container, string containerName, string overridingName) { int lastParen = namedObject.SourceName.LastIndexOf(" ("); string nameOfSourceInContainer = namedObject.SourceName.Substring(0, lastParen); // This could have a quote in the name. If so we want to escape it since this will be put in code: nameOfSourceInContainer = nameOfSourceInContainer.Replace("\"", "\\\""); string cloneString = ".Clone()"; string namedObjectToPullFrom = null; foreach (string[] stringPair in referencedFilesAlreadyUsingFullFile) { if (rfs != null && stringPair[0] == rfs.Name && !namedObject.SourceName.StartsWith("Entire File (")) { namedObjectToPullFrom = stringPair[1]; break; } } // September 30, 2012 // Now all files - whether // they are part of an Entity // or part of a Screen, are static. // This means that the rfs.IsSharedStatic // check will usually fail. However, Screens // will still add to managers even for static // object, so we want to make sure that we don't // clone an object already added to managers, so we // need the last check to see if the container is a ScreenSave. if (nosAti == null || !nosAti.CanBeCloned || namedObjectToPullFrom != null || (rfs != null && rfs.IsSharedStatic == false) || container is ScreenSave) { cloneString = ""; } if (nosAti != null && !string.IsNullOrEmpty(nosAti.CustomCloneMethod)) { cloneString = nosAti.CustomCloneMethod; } AssetTypeInfo rfsAti = null; if (rfs != null) { rfsAti = rfs.GetAssetTypeInfo(); } bool usesFullConversion = false; if (rfsAti != null && rfsAti.Conversion.Count != 0) { var foundConversion = rfsAti.Conversion.FirstOrDefault(item => item.ToType == namedObject.InstanceType); if (foundConversion != null) { cloneString = foundConversion.ConversionPattern.Replace("{NEW}", objectName); cloneString = cloneString.Replace("{THIS}", rfs.GetInstanceName()); usesFullConversion = true; } } if (namedObjectToPullFrom != null) { containerName = namedObjectToPullFrom; } if (!string.IsNullOrEmpty(overridingName)) { containerName = overridingName; } string listMemberName = ContentParser.GetMemberNameForList(FileManager.GetExtension(namedObject.SourceFile), namedObject.InstanceType); if (!string.IsNullOrEmpty(listMemberName)) { listMemberName += "."; } if (nameOfSourceInContainer == "Entire File" && string.IsNullOrEmpty(listMemberName)) { if (usesFullConversion) { codeBlock.Line(cloneString + ";"); } else if (cloneString.Contains("{THIS}")) { string entireString = cloneString.Replace("{THIS}", objectName); entireString = entireString.Replace("{SOURCE_FILE}", containerName); codeBlock.Line(entireString); } else { codeBlock.Line(string.Format("{0} = {1}{2};", objectName, containerName, cloneString)); } } else { string findByNameLine = ""; if (nosAti != null) { findByNameLine = nosAti.FindByNameSyntax; if (string.IsNullOrEmpty(findByNameLine)) { string message = "The object " + namedObject.ToString() + " is part of a file. To be properly generated " + "the AssetTypeInfo (or CSV value) for " + nosAti.ToString() + " must contain a FindByNameSyntax property"; throw new Exception(message); } } findByNameLine = findByNameLine.Replace("OBJECTNAME", nameOfSourceInContainer); string possibleDot = "."; if (findByNameLine.StartsWith("[")) { possibleDot = ""; } //if (namedObject.AddToManagers) { // Not sure why we don't clone on a non add to manager. This post right here suggests we should // and I tend to believe Scott so...I'm following his advice: // http://www.flatredball.com/frb/forum/viewtopic.php?f=26&t=4741 codeBlock.Line(string.Format("{0} = {1}{2}{3}{4}{5};", objectName, containerName, possibleDot, listMemberName, findByNameLine, cloneString)); } //else //{ // stringBuilder.AppendLine( // string.Format("\t\t\t{0} = {1}{2}{3}{4};", // objectName, // containerName, // possibleDot, // listMemberName, // findByNameLine)); //} } return containerName; }
public ReferencedFileSave CreateReferencedFileSaveForExistingFile(IElement containerForFile, string directoryInsideContainer, string absoluteFileName, PromptHandleEnum unknownTypeHandle, AssetTypeInfo ati, out string creationReport, out string errorMessage) { creationReport = ""; errorMessage = null; ReferencedFileSave referencedFileSaveToReturn = null; string whyItIsntValid; // Let's see if there is already an Entity with the same name string fileWithoutPath = FileManager.RemovePath(FileManager.RemoveExtension(absoluteFileName)); bool isValid = NameVerifier.IsReferencedFileNameValid(fileWithoutPath, ati, referencedFileSaveToReturn, containerForFile, out whyItIsntValid); if (!isValid) { errorMessage = "Invalid file name:\n" + fileWithoutPath + "\n" + whyItIsntValid; } else { Zipper.UnzipAndModifyFileIfZip(ref absoluteFileName); string extension = FileManager.GetExtension(absoluteFileName); bool isValidExtensionOrIsConfirmedByUser; bool isUnknownType; CheckAndWarnAboutUnknownFileTypes(unknownTypeHandle, extension, out isValidExtensionOrIsConfirmedByUser, out isUnknownType); if (isValidExtensionOrIsConfirmedByUser) { string directoryThatFileShouldBeRelativeTo = GetFullPathContentDirectory(containerForFile, directoryInsideContainer); string projectDirectory = projectDirectory = FileManager.GetDirectory(ProjectManager.ContentProject.FullFileName); string fileToAdd = GetNameOfFileRelativeToProject(absoluteFileName, directoryThatFileShouldBeRelativeTo, projectDirectory); BuildToolAssociation bta = null; if (ati != null && !string.IsNullOrEmpty(ati.CustomBuildToolName)) { bta = BuildToolAssociationManager.Self.GetBuilderToolAssociationByName(ati.CustomBuildToolName); } if (containerForFile != null) { referencedFileSaveToReturn = containerForFile.AddReferencedFile(fileToAdd, ati, bta); } else { bool useFullPathAsName = false; // todo - support built files here referencedFileSaveToReturn = AddReferencedFileToGlobalContent(fileToAdd, useFullPathAsName); } // This will be null if there was an error above in creating this file if (referencedFileSaveToReturn != null) { if (containerForFile != null) containerForFile.HasChanged = true; if (fileToAdd.EndsWith(".csv")) { string fileToAddAbsolute = ProjectManager.MakeAbsolute(fileToAdd); CsvCodeGenerator.GenerateAndSaveDataClass(referencedFileSaveToReturn, referencedFileSaveToReturn.CsvDelimiter); } if (isUnknownType) { referencedFileSaveToReturn.LoadedAtRuntime = false; } ProjectManager.UpdateFileMembershipInProject(referencedFileSaveToReturn); PluginManager.ReactToNewFile(referencedFileSaveToReturn); GluxCommands.Self.SaveGlux(); ProjectManager.SaveProjects(); UnreferencedFilesManager.Self.RefreshUnreferencedFiles(false); string error; referencedFileSaveToReturn.RefreshSourceFileCache(false, out error); if (!string.IsNullOrEmpty(error)) { ErrorReporter.ReportError(referencedFileSaveToReturn.Name, error, false); } } } } return referencedFileSaveToReturn; }
private static void InstantiateObjectUsingFile(NamedObjectSave namedObject, ICodeBlock codeBlock, List<string[]> referencedFilesAlreadyUsingFullFile, AssetTypeInfo nosAti, string objectName, ReferencedFileSave rfs, IElement container, string containerName, string overridingName) { #region If the user hasn't picked an object inside the file, it's either a SpriteRig or we should return "" if (string.IsNullOrEmpty(namedObject.SourceName) || namedObject.SourceName == "<NONE>") { if (FileManager.GetExtension(namedObject.SourceFile) == "srgx") { codeBlock.Line(objectName + " = " + containerName + ";"); } } #endregion #region else, the user has picked a file else { containerName = WriteMethodForClone(namedObject, codeBlock, referencedFilesAlreadyUsingFullFile, nosAti, objectName, rfs, container, containerName, overridingName); } #endregion }
private static void CreateCategoriesAndVariables(NamedObjectSave instance, IElement container, List<MemberCategory> categories, AssetTypeInfo ati) { for (int i = 0; i < instance.TypedMembers.Count; i++) { TypedMemberBase typedMember = instance.TypedMembers[i]; InstanceMember instanceMember = CreateInstanceMember(instance, container, typedMember, ati); var categoryToAddTo = GetOrCreateCategoryToAddTo(categories, ati, typedMember); if (instanceMember != null) { categoryToAddTo.Members.Add(instanceMember); } } bool shouldAddSourceNameVariable = instance.SourceType == SourceType.File && !string.IsNullOrEmpty(instance.SourceFile); if(shouldAddSourceNameVariable) { AddSourceNameVariable(instance, categories); } }
private static string DecideOnLineToAdd(NamedObjectSave namedObject, AssetTypeInfo ati, bool layered) { int index = 0; if (ati.AddToManagersMethod.Count > 1 && namedObject.SourceType == SourceType.FlatRedBallType && (namedObject.SourceClassType == "Sprite" || namedObject.SourceClassType == "SpriteFrame") && namedObject.IsZBuffered) { index = 1; } if (layered) { return ati.LayeredAddToManagersMethod[index]; } else { return ati.AddToManagersMethod[index]; } }
private static ICodeBlock ApplyResetVariables(NamedObjectSave namedObject, ICodeBlock codeBlock, AssetTypeInfo ati) { // Also reset variables before attachment. // May 15, 2011: This should happen before // setting the custom variables. // May 16, 2011: CustomVariables which are // exposed variables are now set before AddToManagers // is even called. Therefore, doing this before doesn't matter // anymore. Moved back down to its old position. for (int i = 0; i < namedObject.VariablesToReset.Count; i++) { string variableToReset = namedObject.VariablesToReset[i]; string relativeVersion = InstructionManager.GetRelativeForAbsolute(namedObject.VariablesToReset[i]); if ((namedObject.SourceType == SourceType.Entity || ati.ShouldAttach) && !string.IsNullOrEmpty(relativeVersion)) { codeBlock = codeBlock.If(namedObject.InstanceName + ".Parent == null"); } codeBlock.Line(namedObject.InstanceName + "." + namedObject.VariablesToReset[i] + " = " + namedObject.InstanceName + namedObject.VariablesToReset[i].Replace(".", "") + "Reset" + ";"); if ((namedObject.SourceType == SourceType.Entity || ati.ShouldAttach) && !string.IsNullOrEmpty(relativeVersion)) { codeBlock = codeBlock.End().Else(); codeBlock.Line(namedObject.InstanceName + "." + relativeVersion + " = " + namedObject.InstanceName + namedObject.VariablesToReset[i].Replace(".", "") + "Reset" + ";"); codeBlock = codeBlock.End(); } } return codeBlock; }
private void SaveNewFileAtLocation(AssetTypeInfo assetTypeInfo, string createdFile) { string availableFile; if (assetTypeInfo.Extension == "csv") { string contents = "\"Name (string, required)\",Health (float)" + Environment.NewLine + "Monster,100"; FileManager.SaveText(contents, createdFile); } else if (assetTypeInfo.Extension == "txt") { const string contents = "Glue is such a great tool!"; FileManager.SaveText(contents, createdFile); } // If the save type isn't null, then it's a type that is understood by the Glue, so we can // instantiate and save off the instance // Why don't we try a template first? else if (TryGetTemplateFileForAti(assetTypeInfo, out availableFile)) { CreateNewFileFromAvailableFileTemplate(createdFile, availableFile); } else if (assetTypeInfo.SaveType != null) { object saveInstance = Activator.CreateInstance(assetTypeInfo.SaveType); FileManager.XmlSerialize(assetTypeInfo.SaveType, saveInstance, createdFile); } // Unknown type, so save an empty file. else { FileManager.SaveText(null, createdFile); } }
public static bool IsReferencedFileNameValid(string name, AssetTypeInfo ati, ReferencedFileSave rfs, IElement container, out string whyItIsntValid) { whyItIsntValid = ""; CheckForCommonImproperNames(name, ref whyItIsntValid); // CheckForExistingEntity checks if the name is already used, but we can be more specific if it's part of this entity if(container != null) { string unqualifiedContainerName = FileManager.RemovePath(container.Name); if(unqualifiedContainerName.ToLowerInvariant() == FileManager.RemovePath(FileManager.RemoveExtension(name))) { string containerType = "Entity"; if(container is ScreenSave) { containerType = "Screen"; } else if(container is EntitySave) { containerType = "Entity"; } else { containerType = "Container"; } whyItIsntValid = "The " + containerType + " that you are adding the file to has the same name as the file. This is not allowed in Glue. Please rename the file"; } } if (string.IsNullOrEmpty(whyItIsntValid)) { CheckForExistingEntity(name, ref whyItIsntValid); } if (string.IsNullOrEmpty(whyItIsntValid)) { CheckForRfsWithMatchingFileName(container, name, rfs, ref whyItIsntValid); } if (string.IsNullOrEmpty(whyItIsntValid)) { if (ati != null && ati.Extension == "csv") { // Let's see if there is already a spreadsheet by this name and if so, let's warn the user // But we only want a spreadsheet that isn't using a created class: var existing = ObjectFinder.Self.GetAllReferencedFiles().Where(item => // Is the item a CSV... item.IsCsvOrTreatedAsCsv && // And is the item different than the rfs we're checking item != rfs && // And do the names match? FileManager.RemovePath(FileManager.RemoveExtension(item.Name)) == name && // And does it not use a custom class? ObjectFinder.Self.GlueProject.CustomClasses.Any(customClass => customClass.CsvFilesUsingThis.Contains(item.Name)) == false) .ToList(); if (existing.Count != 0) { whyItIsntValid = "There is already a CSV file using the name " + name + ": " + existing[0].ToString(); } } } bool returnValue = string.IsNullOrEmpty(whyItIsntValid); return returnValue; }
private bool TryGetTemplateFileForAti(AssetTypeInfo assetTypeInfo, out string availableFile) { availableFile = GetNewFileTemplateForExtension(GetAvailableFilesForNewFile(), assetTypeInfo.Extension); return availableFile != null; }
public static ReferencedFileSave AddReferencedFileSave(IElement element, string directoryPath, string fileName, AssetTypeInfo resultAssetTypeInfo, string option, out string errorMessage) { char invalidCharacter; ReferencedFileSave rfs = null; errorMessage = null; #region Get directory string directoryRelativeToContent = ""; if (!String.IsNullOrEmpty(directoryPath)) { //string directory = directoryTreeNode.GetRelativePath().Replace("/", "\\"); directoryRelativeToContent = directoryPath; } else if (element != null) { //string directory = elementToAddTo.GetRelativePath().Replace("/", "\\"); directoryRelativeToContent = element.Name.Replace(@"/", @"\") + "\\"; } else { directoryRelativeToContent = "GlobalContent/"; } #endregion bool userCancelled = false; #region If there is some reason why the file name won't, then work show a message box string whyIsntValid; if (!NameVerifier.IsReferencedFileNameValid(fileName, resultAssetTypeInfo, rfs, element, out whyIsntValid)) { errorMessage = "Invalid file name:\n" + fileName + "\n" + whyIsntValid; } else if (resultAssetTypeInfo == null) { errorMessage = "You must select a valid type for your new file."; } else if (ObjectFinder.Self.GetReferencedFileSaveFromFile(directoryRelativeToContent + fileName + "." + resultAssetTypeInfo.Extension) != null) { errorMessage = "There is already a file named\n\n" + directoryRelativeToContent + fileName + "." + resultAssetTypeInfo.Extension; } // TODO: This currently checks for an exact match, but we should prevent different files (like a .emix and .scnx) from having the same name else if (EditorLogic.CurrentElement != null && EditorLogic.CurrentElement.GetReferencedFileSaveRecursively(directoryRelativeToContent + fileName + "." + resultAssetTypeInfo.Extension) != null) { errorMessage = "There is already a file named " + fileName; } // need to check global content for duplicates. This is not implemented yet. #endregion #region Else, create the file else { string createdFile = PluginManager.CreateNewFile(resultAssetTypeInfo, option == "2D", directoryRelativeToContent, fileName); // let's just re-route this // to the code that adds existing // files now that we have a file and // that's exactly what we're doing. rfs = RightClickHelper.AddSingleFile(createdFile, ref userCancelled, option); if (rfs == null && !userCancelled) { throw new NullReferenceException("The RFS shouldn't be null"); } } #endregion return rfs; }
/// <summary> /// Determines if a variable should be ignored by the variable plugin. /// </summary> /// <param name="typedMember">The typed member - represents the variable which may be ignored.</param> /// <param name="instance">The NamedObjectSave owning the variable.</param> /// <param name="ati">The Asset Typ Info for the NamedObjectSave.</param> /// <returns>Whether to skip the variable.</returns> private static bool GetIfShouldBeSkipped(TypedMemberBase typedMember, NamedObjectSave instance, AssetTypeInfo ati) { var name = typedMember.MemberName; if (ati != null) { if (ati.IsPositionedObject) { if (name.EndsWith("Velocity") || name.EndsWith("Acceleration") || name.StartsWith("Relative") || name == "ParentBone" || name == "KeepTrackOfReal" || name == "Drag" ) { return true; } } if (ati.QualifiedRuntimeTypeName.QualifiedType == "FlatRedBall.Math.Geometry.AxisAlignedRectangle") { return name == "ScaleX" || name == "ScaleY" || name == "Top" || name == "Bottom" || name == "Left" || name == "Right"; } if (ati.QualifiedRuntimeTypeName.QualifiedType == "FlatRedBall.Graphics.Text") { return name == "AlphaRate" || name == "RedRate" || name == "GreenRate" || name == "BlueRate" || name == "ScaleVelocity" || name == "SpacingVelocity" || name == "ScaleXVelocity" || name == "ScaleYVelocity" || // These used to be the standard way to size text, but now we just // use "TextureScale" name == "Scale" || name == "Spacing" || name == "NewLineDistance" ; } if (ati.QualifiedRuntimeTypeName.QualifiedType == "FlatRedBall.Camera") { return name == "AspectRatio" || name == "DestinationRectangle" || name == "CameraModelCullMode"; } if (ati.QualifiedRuntimeTypeName.QualifiedType == "FlatRedBall.Math.Geometry.Polygon") { return name == "RotationX" || name == "RotationY" || name == "Points"; } if (ati.QualifiedRuntimeTypeName.QualifiedType == "FlatRedBall.Graphics.Layer") { return name == "LayerCameraSettings"; } if (ati.QualifiedRuntimeTypeName.QualifiedType == "FlatRedBall.Sprite") { return name == "AlphaRate" || name == "RedRate" || name == "GreenRate" || name == "BlueRate" || name == "RelativeTop" || name == "RelativeBottom" || name == "RelativeLeft" || name == "RelativeRight" || name == "TimeCreated" || name == "TimeIntoAnimation" || name == "ScaleX" || name == "ScaleY" || name == "CurrentChainIndex" || name == "Top" || name == "Bottom" || name == "Left" || name == "Right" || name == "PixelSize" || name == "LeftTextureCoordinate" || name == "RightTextureCoordinate" || name == "BottomTextureCoordinate" || name == "TopTextureCoordinate" || name == "ScaleXVelocity" || name == "ScaleYVelocity" || name == "TextureFilter" ; } } return false; }
private static void WriteLoadedOnlyWhenReferencedPropertyBody(ReferencedFileSave referencedFile, string containerName, IElement element, string contentManagerName, AssetTypeInfo ati, string variableName, string lastContentManagerVariableName, ICodeBlock getBlock) { string referencedFileName = GetFileToLoadForRfs(referencedFile, ati); string mThenVariableName = "m" + variableName; ICodeBlock ifBlock = null; if (element == null) { ifBlock = getBlock.If(mThenVariableName + " == null"); } else { string contentManagerToCompareAgainst; if (element is ScreenSave) { contentManagerToCompareAgainst = "\"" + FileManager.RemovePath(element.Name) + "\""; } else { contentManagerToCompareAgainst = "ContentManagerName"; } string conditionContents = mThenVariableName + " == null || " + lastContentManagerVariableName + " != " + contentManagerToCompareAgainst; bool isDisposable = referencedFile.RuntimeType == "Texture2D" || referencedFile.RuntimeType == "Microsoft.Xna.Framework.Graphics.Texture2D"; if (isDisposable) { conditionContents += " || " + mThenVariableName + ".IsDisposed"; } ifBlock = getBlock.If(conditionContents); ifBlock.Line(lastContentManagerVariableName + " = " + contentManagerToCompareAgainst + ";"); } if (containerName != ContentLoadWriter.GlobalContentContainerName) { GenerateExceptionForPostInitializeLoads(getBlock); } PerformancePluginCodeGenerator.CodeBlock = ifBlock; PerformancePluginCodeGenerator.SaveObject = element; PerformancePluginCodeGenerator.GenerateStart(" Get " + variableName); if (ati != null && !referencedFile.IsCsvOrTreatedAsCsv) { GetLoadCallForAtiFile(referencedFile, ati, mThenVariableName, contentManagerName, ProjectBase.AccessContentDirectory + referencedFileName, ifBlock); } else if (referencedFile.IsCsvOrTreatedAsCsv) { GenerateCsvDeserializationCode(referencedFile, ifBlock, mThenVariableName, referencedFileName, LoadType.CompleteLoad); } if (element != null && element is EntitySave) { AppendAddUnloadMethod(ifBlock, containerName); } PerformancePluginCodeGenerator.GenerateEnd(); getBlock.Line("return " + mThenVariableName + ";"); }
private static string GetFileToLoadForRfs(ReferencedFileSave referencedFile, AssetTypeInfo ati) { string referencedFileName = referencedFile.Name; if ((ati != null && ati.MustBeAddedToContentPipeline) || referencedFile.UseContentPipeline) { referencedFileName = FileManager.RemoveExtension(referencedFileName); } if (ProjectManager.ContentProject != null) { referencedFileName = ProjectManager.ContentProject.ContainedFilePrefix + referencedFileName; } referencedFileName = referencedFileName.ToLower(); return referencedFileName; }
private static void AppendPropertyForReferencedFileSave(ICodeBlock codeBlock, ReferencedFileSave referencedFile, string containerName, IElement element, string contentManagerName, AssetTypeInfo ati, string variableName, string typeName) { codeBlock.Line(StringHelper.Modifiers(Static: referencedFile.IsSharedStatic, Type: typeName, Name: "m" + variableName) + ";"); // No need to use // ManualResetEvents // if the ReferencedFileSave // is LoadedOnlyWhenReferenced. bool shouldBlockThreads = containerName == ContentLoadWriter.GlobalContentContainerName && !referencedFile.LoadedOnlyWhenReferenced; if (shouldBlockThreads) { codeBlock.Line("#if !REQUIRES_PRIMARY_THREAD_LOADING"); codeBlock.Line("//Blocks the thread on request of " + variableName + " until it has been loaded"); codeBlock.Line("static ManualResetEvent m" + variableName + "Mre = new ManualResetEvent(false);"); codeBlock.Line("// Used to lock getter and setter so that " + variableName + " can be set on any thread even if its load is in progrss"); codeBlock.Line("static object m" + variableName + "_Lock = new object();"); codeBlock.Line("#endif"); } string lastContentManagerVariableName = "mLastContentManagerFor" + variableName; if (referencedFile.LoadedAtRuntime && element != null) { codeBlock.Line("static string " + lastContentManagerVariableName + ";"); } // Silverlight and Windows Phone only allow reflection on public methods // Since it's common practice to use reflection to reference LoadedOnlyWhenReferenced // properties, we need to make them public. var propBlock = codeBlock.Property(variableName, Public: true, Static: referencedFile.IsSharedStatic, Type: typeName); var getBlock = propBlock.Get(); if (referencedFile.LoadedOnlyWhenReferenced) { WriteLoadedOnlyWhenReferencedPropertyBody(referencedFile, containerName, element, contentManagerName, ati, variableName, lastContentManagerVariableName, getBlock); } else if (containerName == ContentLoadWriter.GlobalContentContainerName) { #region Write the getter getBlock.Line("#if !REQUIRES_PRIMARY_THREAD_LOADING"); if (shouldBlockThreads) { getBlock = getBlock.Lock("m" + variableName + "_Lock"); } //Perform a WaitOne on the event with a timeout value of zero. // It will return true if the event is not set, or false if the timeout occurs. // In other words, false -> event is set, true -> event is not set. getBlock.Line("bool isBlocking = !m" + variableName + "Mre.WaitOne(0);"); { var ifBlock = getBlock.If("isBlocking"); // This is our way of telling the GlobalContentManager to hurry up - we're waiting // on some content! ifBlock.Line("RequestContentLoad(\"" + referencedFile.Name + "\");"); #region If RecordLockRecord - write the code for recording the load order so that it can be optimized if (ProjectManager.GlueProjectSave.GlobalContentSettingsSave.RecordLockContention) { ifBlock.Line("LockRecord.Add(\"\\n" + variableName + "\");"); } #endregion } getBlock.Line("m" + variableName + "Mre.WaitOne();"); getBlock.Line("return m" + variableName + ";"); if (shouldBlockThreads) { getBlock = getBlock.End(); } getBlock.Line("#else"); WriteLoadedOnlyWhenReferencedPropertyBody(referencedFile, containerName, element, contentManagerName, ati, variableName, lastContentManagerVariableName, getBlock); getBlock.Line("#endif"); #endregion #region Write the setter var setBlock = propBlock.Set(); setBlock.Line("#if !REQUIRES_PRIMARY_THREAD_LOADING"); if (shouldBlockThreads) { setBlock = setBlock.Lock("m" + variableName + "_Lock"); } WriteAssignmentAndMreSet(variableName, setBlock); if (shouldBlockThreads) { setBlock = setBlock.End(); } setBlock.Line("#else"); setBlock.Line("m" + variableName + " = value;"); setBlock.Line("#endif"); #endregion } else { string fieldName = "m" + variableName; getBlock.Line("#if REQUIRES_PRIMARY_THREAD_LOADING"); var ifBlock = getBlock.If("fieldName == null && FlatRedBall.FlatRedBallServices.IsThreadPrimary()"); ifBlock.Line("FlatRedBall.FlatRedBallServices.GetContentManagerByName(ContentManager).ProcessTexturesWaitingToBeLoaded();"); getBlock.Line("#endif"); getBlock.Line("return " + fieldName + ";"); } }
private static InstanceMember CreateInstanceMember(NamedObjectSave instance, IElement container, TypedMemberBase typedMember, AssetTypeInfo ati) { bool shouldBeSkipped = GetIfShouldBeSkipped(typedMember, instance, ati); DataGridItem instanceMember = null; if (!shouldBeSkipped) { var typeConverter = PluginManager.GetTypeConverter( container, instance, typedMember); bool isObjectInFile = typeConverter is IObjectsInFileConverter; var memberType = typedMember.MemberType; VariableDefinition variableDefinition = null; if (ati != null) { variableDefinition = ati.VariableDefinitions.FirstOrDefault(item => item.Name == typedMember.MemberName); } if(isObjectInFile) { var fileInstanceMember = new FileInstanceMember(); instanceMember = fileInstanceMember; fileInstanceMember.View += () => { var rfs = (typeConverter as IObjectsInFileConverter).ReferencedFileSave; if (rfs != null) { var value = fileInstanceMember.Value as string; GlueCommands.Self.SelectCommands.Select( rfs, value); } }; instanceMember.PreferredDisplayer = typeof(FileReferenceComboBox); } else { instanceMember = new DataGridItem(); } instanceMember.FirstGridLength = new System.Windows.GridLength(140); instanceMember.UnmodifiedVariableName = typedMember.MemberName; string displayName = StringFunctions.InsertSpacesInCamelCaseString(typedMember.MemberName); instanceMember.DisplayName = displayName; instanceMember.TypeConverter = typeConverter; instanceMember.CustomRefreshOptions += () => { if (typeConverter != null) { instanceMember.CustomOptions.Clear(); var values = typeConverter.GetStandardValues(); foreach (var value in values) { instanceMember.CustomOptions.Add(value); } } }; instanceMember.CustomGetTypeEvent += (throwaway) => memberType; instanceMember.IsDefault = instance.GetInstructionFromMember(typedMember.MemberName) == null; instanceMember.CustomGetEvent += (throwaway) => { var instruction = instance.GetInstructionFromMember(typedMember.MemberName); if (instruction == null) { if (variableDefinition != null) { var toReturn = variableDefinition.DefaultValue; if (memberType == typeof(bool)) { bool boolToReturn = false; bool.TryParse(variableDefinition.DefaultValue, out boolToReturn); return boolToReturn; } else { return toReturn; } } else { return null; } } else { return instruction.Value; } }; instanceMember.CustomSetEvent += (owner, value) => { NamedObjectVariableChangeLogic.ReactToValueSet(instance, typedMember, value, instanceMember, memberType); }; instanceMember.IsDefaultSet += (owner, args) => { MakeDefault(instance, typedMember.MemberName); }; instanceMember.SetValueError += (newValue) => { if (newValue is string && string.IsNullOrEmpty(newValue as string)) { MakeDefault(instance, typedMember.MemberName); } }; } return instanceMember; }
public string GetOptionFor(AssetTypeInfo ati) { string type = GetObjectTypeFromAti(ati); return GetOptionFor(type); }
private static MemberCategory GetOrCreateCategoryToAddTo(List<MemberCategory> categories, AssetTypeInfo ati, TypedMemberBase typedMember) { // By defaut make the last category get used (this is "Variables") var categoryToAddTo = categories.Last(); // If there is an AssetTypeInfo... if (ati != null) { // ... see if there is avariable definition for this variable... var foundVariableDefinition = ati.VariableDefinitions.FirstOrDefault(item => item.Name == typedMember.MemberName); if (foundVariableDefinition != null) { //... if so, see the category that it's a part of... string categoryName = foundVariableDefinition.Category; if (!string.IsNullOrEmpty(categoryName)) { //... if a category is defined, see if we have a MemberCategory that we've created for it... categoryToAddTo = categories.FirstOrDefault(item => item.Name == categoryName); if (categoryToAddTo == null) { //... if not, make one, and insert it before the last: categoryToAddTo = new MemberCategory(categoryName); categoryToAddTo.FontSize = 14; categories.Insert(categories.Count - 1, categoryToAddTo); } } } } return categoryToAddTo; }
public static ICodeBlock GetLoadCallsForRfs(ReferencedFileSave referencedFile, string fileName, AssetTypeInfo ati, string variableName, ICodeBlock codeBlock, bool useGlobalContent, bool isContentPipeline) { var currentBlock = codeBlock; if (referencedFile.IsCsvOrTreatedAsCsv == false) { string modifiedFileName = fileName.ToLower(); string contentManagerString = GetContentManagerString(referencedFile); string fileNameToLoad = ProjectBase.AccessContentDirectory + modifiedFileName; // If the file isn't part of the content pipeline we have // to manually unload it if (!useGlobalContent && !isContentPipeline) { currentBlock = currentBlock .If(string.Format("!FlatRedBall.FlatRedBallServices.IsLoaded<{2}>(@\"{0}\", {1})", ProjectBase.AccessContentDirectory + modifiedFileName, contentManagerString, ati.QualifiedRuntimeTypeName.QualifiedType)); if (referencedFile.GetContainerType() == ContainerType.Entity) { currentBlock.Line("registerUnload = true;"); } currentBlock = currentBlock.End(); } ReferencedFileSaveCodeGenerator.GetLoadCallForAtiFile(referencedFile, ati, variableName, contentManagerString, fileNameToLoad, codeBlock); } return currentBlock; }
public static ReferencedFileSave AddReferencedFile(this IElement instance, string fileName, AssetTypeInfo ati, EditorObjects.SaveClasses.BuildToolAssociation bta = null) { var referencedFileSave = new ReferencedFileSave(); if (ati != null) { referencedFileSave.RuntimeType = ati.QualifiedRuntimeTypeName.QualifiedType; } referencedFileSave.IsSharedStatic = true; referencedFileSave.SetNameNoCall(fileName); #if GLUE if (ati != null && !string.IsNullOrEmpty(ati.CustomBuildToolName) && bta != null) { referencedFileSave.BuildTool = ati.CustomBuildToolName; referencedFileSave.SourceFile = referencedFileSave.Name; string newName = FileManager.RemoveExtension(referencedFileSave.Name); newName += "." + bta.DestinationFileType; referencedFileSave.SetNameNoCall(newName); } #endif instance.ReferencedFiles.Add(referencedFileSave); referencedFileSave.IsSharedStatic = true; return referencedFileSave; }
internal static string CreateNewFile(AssetTypeInfo assetTypeInfo, object extraData, string directory, string name) { string createdFile = null; bool created = false; foreach (PluginManager pluginManager in mInstances) { if (created) { break; } foreach (INewFile plugin in pluginManager.NewFilePlugins) { PluginContainer container = pluginManager.mPluginContainers[plugin]; if (container.IsEnabled) { var exit = false; INewFile plugin1 = plugin; PluginCommand(() => { if (plugin1.CreateNewFile(assetTypeInfo, extraData, directory, name, out createdFile)) { created = true; exit = true; } }, container, "Failed in CreateNewFile"); if (exit) break; } } // Execute the new style plugins if (!created) { var plugins = pluginManager.ImportedPlugins.Where(x => x.CreateNewFileHandler != null); foreach (var plugin in plugins) { var container = pluginManager.mPluginContainers[plugin]; if (container.IsEnabled) { PluginBase plugin1 = plugin; bool exit = false; PluginCommand(() => { if (plugin1.CreateNewFileHandler(assetTypeInfo, extraData, directory, name, out createdFile)) { created = true; exit = true; } }, container, "Failed in CreateNewFile"); if (exit) break; } } } } return createdFile; }
private static void WriteCopyToAbsoluteInInitializeCode(NamedObjectSave namedObject, ICodeBlock codeBlock, List<string[]> referencedFilesAlreadyUsingFullFile, AssetTypeInfo ati, string objectName, ReferencedFileSave rfs) { if ((ati != null && ati.ShouldAttach) || namedObject.SourceType == SourceType.Entity && !string.IsNullOrEmpty(namedObject.SourceClassType) ) { bool isEntireFile = namedObject.SourceName != null && namedObject.SourceName.StartsWith("Entire File ("); string copyRelativeToAbsolute; if (namedObject.InstanceType == "Scene" || namedObject.InstanceType == "ShapeCollection" ) { copyRelativeToAbsolute = ".CopyAbsoluteToRelative(false)"; } else { copyRelativeToAbsolute = ".CopyAbsoluteToRelative()"; } string namedObjectToPullFrom = null; if (rfs != null) { foreach (string[] stringPair in referencedFilesAlreadyUsingFullFile) { if (stringPair[0] == rfs.Name && !isEntireFile) { namedObjectToPullFrom = stringPair[1]; break; } } } if (string.IsNullOrEmpty(namedObjectToPullFrom)) { codeBlock.Line(string.Format("{0}{1};", objectName, copyRelativeToAbsolute)); } } }