internal static ICodeBlock GenerateFields(IElement saveObject)
{
ICodeBlock codeBlock = new CodeDocument(2);
foreach (ElementComponentCodeGenerator codeGenerator in CodeWriter.CodeGenerators)
{
if (codeGenerator == null)
{
throw new Exception("The CodeWriter contains a null code generator. A plugin must have added this");
}
try
{
codeGenerator.GenerateFields(codeBlock, saveObject);
}
catch (Exception e)
{
throw new Exception("Error generating fields in generator " + codeGenerator.GetType().Name +
"\n\n" + e.ToString());
}
}
PerformancePluginCodeGenerator.GenerateFields(saveObject, codeBlock);
EntitySave asEntitySave = saveObject as EntitySave;
// No need to create LayerProvidedByContainer if this inherits from another object.
if (asEntitySave != null && !saveObject.InheritsFromEntity())
{
// Add the layer that is going to get assigned in generated code
codeBlock.Line("protected FlatRedBall.Graphics.Layer LayerProvidedByContainer = null;");
}
return codeBlock;
}
internal static ICodeBlock GenerateInitialize(IElement saveObject)
{
ICodeBlock codeBlock = new CodeDocument(3);
ICodeBlock currentBlock = codeBlock;
// Start measuring performance before anything else
PerformancePluginCodeGenerator.GenerateStartTimingInitialize(saveObject, codeBlock);
PerformancePluginCodeGenerator.SaveObject = saveObject;
PerformancePluginCodeGenerator.CodeBlock = codeBlock;
PerformancePluginCodeGenerator.GenerateStart("CustomLoadStaticContent from Initialize");
// Load static content before looping through the CodeGenerators
// The reason for this is there is a ReferencedFileSaveCodeGenerator
// which needs to work with static RFS's which are instantiated here
currentBlock.Line("LoadStaticContent(ContentManagerName);");
PerformancePluginCodeGenerator.GenerateEnd();
PerformancePluginCodeGenerator.GenerateStart("General Initialize internals");
foreach (ElementComponentCodeGenerator codeGenerator in CodeGenerators)
{
codeGenerator.GenerateInitialize(codeBlock, saveObject);
}
foreach (ElementComponentCodeGenerator codeGenerator in CodeGenerators)
{
codeGenerator.GenerateInitializeLate(codeBlock, saveObject);
}
if (saveObject is ScreenSave)
{
ScreenSave asScreenSave = saveObject as ScreenSave;
codeBlock._();
if (asScreenSave.IsRequiredAtStartup)
{
string startupScreen = ProjectManager.StartUpScreen;
string qualifiedName = ProjectManager.ProjectNamespace + "." + startupScreen.Replace("\\", ".");
codeBlock.Line(string.Format("this.NextScreen = typeof({0}).FullName;", qualifiedName));
}
if (asScreenSave.UseGlobalContent)
{
// no need to do anything here because Screens are smart enough to know to not load if they
// are using global content
}
if (!string.IsNullOrEmpty(asScreenSave.NextScreen))
{
string nameToUse = ProjectManager.ProjectNamespace + "." + asScreenSave.NextScreen.Replace("\\", ".");
codeBlock.Line(string.Format("this.NextScreen = typeof({0}).FullName;", nameToUse));
}
}
codeBlock._();
PerformancePluginCodeGenerator.GenerateEnd();
#region PostInitializeCode
PerformancePluginCodeGenerator.GenerateStart("Post Initialize");
if (saveObject.InheritsFromElement() == false)
{
codeBlock.Line("PostInitialize();");
}
PerformancePluginCodeGenerator.GenerateEnd();
#endregion
PerformancePluginCodeGenerator.GenerateStart("Base.Initialize");
InheritanceCodeWriter.Self.WriteBaseInitialize(saveObject, codeBlock);
PerformancePluginCodeGenerator.GenerateEnd();
// I think we want to set this after calling base.Initialize so that the base
// has a chance to set values on derived objects
PerformancePluginCodeGenerator.GenerateStart("Reset Variables");
// Now that variables are set, we can record reset variables
NamedObjectSaveCodeGenerator.AssignResetVariables(codeBlock, saveObject);
PerformancePluginCodeGenerator.GenerateEnd();
PerformancePluginCodeGenerator.GenerateStart("AddToManagers");
#region If shouldCallAddToManagers, call AddToManagers
bool shouldCallAddToManagers = !saveObject.InheritsFromElement();
if (shouldCallAddToManagers)
{
currentBlock = currentBlock
.If("addToManagers");
if (saveObject is ScreenSave)
{
currentBlock.Line("AddToManagers();");
}
else
{
currentBlock.Line("AddToManagers(null);");
}
}
#endregion
PerformancePluginCodeGenerator.GenerateEnd();
PerformancePluginCodeGenerator.GenerateEndTimingInitialize(saveObject, codeBlock);
return codeBlock;
}
public static ICodeBlock GetMethodCallForBehavior(string behaviorName, IBehaviorContainer container)
{
ICodeBlock codeBlock = new CodeDocument();
string returnString = GetRawBehaviorMethodHeader(behaviorName);
if (returnString.StartsWith("//"))
{
codeBlock.Line(returnString);
return codeBlock;
}
else
{
returnString = returnString.Trim();
returnString = returnString.Replace("public ", "");
returnString = returnString.Replace("private ", "");
returnString = returnString.Replace("protected ", "");
returnString = returnString.Replace("internal ", "");
returnString = returnString.Replace("override ", "");
returnString = returnString.Replace("virtual ", "");
returnString = returnString.Replace("static ", "");
// The first word is going to be the return value
returnString = returnString.Substring(returnString.IndexOf(' ') + 1);
List<BehaviorRequirement> requirements =
BehaviorManager.GetBehaviorRequirementsForBehavior(behaviorName);
if (requirements.Count != 0)
{
// Let's clear out the argments and fill them with the objects that fulfill the requirements
int start = returnString.IndexOf('(') + 1;
int indexOfClose = returnString.IndexOf(')');
string argumentList = returnString.Substring(start, indexOfClose - start) ;
returnString = returnString.Replace(argumentList, "");
argumentList = "";
for (int i = 0; i < requirements.Count; i++)
{
//string requirementFulfiller =
string requirementFulfiller = container.GetFulfillerName(requirements[i]);
argumentList += requirementFulfiller;
if (i != requirements.Count - 1)
{
argumentList += ", ";
}
}
returnString = returnString.Insert(start, argumentList);
}
codeBlock.Line(returnString + ";");
return codeBlock;
}
}
public static ICodeBlock CreateClass(string namespaceName, string className, bool isPartial, List<TypedMemberBase> members,
bool isStatic, List<string> usingStatements, Dictionary<string, string> untypedMembers, ICodeBlock methodContent)
{
var codeBlock = new CodeDocument();
#region Append Using Statements
foreach(var usingStatement in usingStatements.Distinct())
{
codeBlock.Line("using " + usingStatement + ";");
}
#endregion
#region Append Namespace
codeBlock._();
ICodeBlock currentBlock = codeBlock;
currentBlock = currentBlock.Namespace(namespaceName);
#endregion
#region Append class header
currentBlock = currentBlock.Class(className, Public: true, Static: isStatic, Partial: isPartial);
#endregion
for (int i = 0; i < members.Count; i++)
{
TypedMemberBase member = members[i];
bool isPublic = member.Modifier == Modifier.Public;
bool isPrivate = member.Modifier == Modifier.Private;
bool isInternal = member.Modifier == Modifier.Internal;
string memberType = member.MemberType.ToString();
memberType = PrepareTypeToBeWritten(member, memberType);
// We used to remove whitespace here,
// but the member name may contain an assignment.
// In that case we want spaces preserved. Whatever
// calls this method is in charge of removing whitespace.
string memberName = member.MemberName;
currentBlock.Line(StringHelper.Modifiers(
Public: isPublic,
Private: isPrivate,
Internal: isInternal,
Static: isStatic,
Type: memberType,
Name: memberName) + ";");
}
foreach (KeyValuePair<string, string> kvp in untypedMembers)
{
string memberName = kvp.Key;
string type = kvp.Value;
bool isPublic = !memberName.StartsWith("m");
currentBlock.Line(StringHelper.Modifiers(Public: isPublic, Static: isStatic, Type: type, Name: memberName) + ";");
}
if (methodContent == null)
{
currentBlock.Tag("Methods");
}
else
{
currentBlock.InsertBlock(methodContent);
}
currentBlock._()._();
currentBlock.Replace(" System.Single ", " float ");
currentBlock.Replace(" System.Boolean ", " bool ");
currentBlock.Replace(" System.Int32 ", " int ");
currentBlock.Replace(" System.String ", " string ");
return codeBlock;
}
private static string GetBehaviorContents(string behaviorName)
{
ICodeBlock codeBlock = new CodeDocument();
string fileName = BehaviorFolder + behaviorName + ".cs";
if (File.Exists(fileName))
{
string behaviorContents = FileManager.FromFileText(fileName
);
codeBlock.Line(behaviorContents);
}
else
{
codeBlock.Line("// There is an invalid behavior reference to behavior " + behaviorName);
}
return codeBlock.ToString();
}
protected ICodeBlock GetDestroyForReferencedFile(IElement element, ReferencedFileSave referencedFile)
{
ICodeBlock codeBlock = new CodeDocument(3);
///////////////////////////////EARLY OUT///////////////////////
if (!referencedFile.LoadedAtRuntime || !referencedFile.DestroyOnUnload)
{
return codeBlock;
}
if (referencedFile.GetGeneratesMember() == false)
{
return codeBlock;
}
/////////////////////////////END EARLY OUT/////////////////////
AddIfConditionalSymbolIfNecesssary(codeBlock, referencedFile);
string fileName = referencedFile.Name;
AssetTypeInfo ati = referencedFile.GetAssetTypeInfo();
string variableName = referencedFile.GetInstanceName();
bool isScreenSave = element is ScreenSave;
if (referencedFile.LoadedOnlyWhenReferenced)
{
variableName = "m" + variableName;
codeBlock = codeBlock.If(variableName + " != null");
}
if (ati != null && (!referencedFile.IsSharedStatic || isScreenSave))
{
string typeName = ati.RuntimeTypeName;
string destroyMethod = ati.DestroyMethod;
string recycleMethod = ati.RecycledDestroyMethod;
if (string.IsNullOrEmpty(recycleMethod))
{
recycleMethod = destroyMethod;
}
if (!string.IsNullOrEmpty(ati.DestroyMethod))
{
if (isScreenSave && recycleMethod != destroyMethod)
{
codeBlock = codeBlock.If("this.UnloadsContentManagerWhenDestroyed && ContentManagerName != \"Global\"");
codeBlock.Line(destroyMethod.Replace("this", variableName) + ";");
if (referencedFile.LoadedOnlyWhenReferenced)
{
codeBlock = codeBlock.End().ElseIf(variableName + " != null");
}
else
{
codeBlock = codeBlock.End().Else();
}
codeBlock.Line(recycleMethod.Replace("this", variableName) + ";");
codeBlock = codeBlock.End();
}
else
{
codeBlock.Line(destroyMethod.Replace("this", variableName) + ";");
}
}
if (ati.ShouldBeDisposed && element.UseGlobalContent == false)
{
codeBlock = codeBlock.If("this.UnloadsContentManagerWhenDestroyed && ContentManagerName != \"Global\"");
codeBlock.Line(string.Format("{0}.Dispose();", variableName));
codeBlock = codeBlock.End();
}
}
if (element is ScreenSave && referencedFile.IsSharedStatic)
{
if (referencedFile.LoadedOnlyWhenReferenced)
{
variableName = "m" + referencedFile.GetInstanceName();
}
// We used to do this here, but we want to do it after all Objects have been destroyed
// because we may need to make the file one way before the destruction of the objects.
if (ati != null && ati.SupportsMakeOneWay)
{
codeBlock = codeBlock.If("this.UnloadsContentManagerWhenDestroyed && ContentManagerName != \"Global\"");
codeBlock.Line(string.Format("{0} = null;", variableName));
codeBlock = codeBlock.End().Else();
codeBlock.Line(string.Format("{0}.MakeOneWay();", variableName));
codeBlock = codeBlock.End();
}
else
{
codeBlock.Line(string.Format("{0} = null;", variableName));
}
}
if (referencedFile.LoadedOnlyWhenReferenced)
{
codeBlock = codeBlock.End();
}
AddEndIfIfNecessary(codeBlock, referencedFile);
return codeBlock;
}
public static ICodeBlock GetPostCustomActivityForReferencedFile(ReferencedFileSave referencedFile)
{
ICodeBlock codeBlock = new CodeDocument();
if (!referencedFile.LoadedAtRuntime)
{
return codeBlock;
}
AssetTypeInfo ati = referencedFile.GetAssetTypeInfo();
// January 8, 2012
// This used to not
// check LoadedOnlyWhenReferenced
// but I think it should otherwise
// this code will always load Scenes
// that are LoadedOnlyWhenReferenced by
// calling their ManageAll method - so I
// added a check for LoadedOnlyWhenReferenced.
if (ati != null && !referencedFile.IsSharedStatic && !referencedFile.LoadedOnlyWhenReferenced && ati.AfterCustomActivityMethod != null)
{
AddIfConditionalSymbolIfNecesssary(codeBlock, referencedFile);
string variableName = referencedFile.GetInstanceName();
codeBlock.Line(ati.AfterCustomActivityMethod.Replace("this", variableName) + ";");
AddEndIfIfNecessary(codeBlock, referencedFile);
return codeBlock;
}
else
{
return codeBlock;
}
}
public static ICodeBlock GetPostInitializeForReferencedFile(ReferencedFileSave referencedFile)
{
AssetTypeInfo ati = referencedFile.GetAssetTypeInfo();
ICodeBlock codeBlock = new CodeDocument();
if (ati != null && !referencedFile.IsSharedStatic)
{
string variableName = referencedFile.GetInstanceName();
if (!string.IsNullOrEmpty(ati.PostInitializeCode))
{
codeBlock.Line(ati.PostInitializeCode.Replace("this", variableName) + ";");
}
}
return codeBlock;
}
static ICodeBlock GetActivityForReferencedFile(ReferencedFileSave referencedFile, IElement element)
{
ICodeBlock codeBlock = new CodeDocument();
/////////////////////EARLY OUT/////////////////////////
if (!referencedFile.LoadedAtRuntime)
{
return codeBlock;
}
//////////////////END EARLY OUT//////////////////////
AssetTypeInfo ati = referencedFile.GetAssetTypeInfo();
// If it's an emitter, call TimedEmit:
ParticleCodeGenerator.GenerateTimedEmit(codeBlock, referencedFile, element);
if (ati != null && (!referencedFile.IsSharedStatic || element is ScreenSave )&& !referencedFile.LoadedOnlyWhenReferenced && ati.ActivityMethod != null)
{
AddIfConditionalSymbolIfNecesssary(codeBlock, referencedFile);
string variableName = referencedFile.GetInstanceName();
codeBlock.Line(ati.ActivityMethod.Replace("this", variableName) + ";");
AddEndIfIfNecessary(codeBlock, referencedFile);
return codeBlock;
}
else
{
return codeBlock;
}
}
