private static void CheckChangedAssets()
{
var changedAssetsCopy = default(string[]);
lock (changedAssets)
{
if (changedAssets.Count > 0)
{
changedAssetsCopy = changedAssets.ToArray();
changedAssets.Clear();
}
}
if (changedAssetsCopy == null)
{
return;
}
//if (Settings.Current.Verbose)
// Debug.Log("Watched paths: " + string.Join(", ", templatePathByWatchedPaths.Keys.ToArray()));
var triggeredTemplatePaths = new HashSet <string>();
foreach (var changedAsset in changedAssetsCopy)
{
if (!File.Exists(changedAsset))
{
continue;
}
//if (Settings.Current.Verbose)
// Debug.Log("Changed Asset: " + changedAsset);
foreach (var watchedPath in templatePathByWatchedPaths.Keys)
{
if (changedAsset.StartsWith(watchedPath, StringComparison.Ordinal))
{
foreach (var templatePath in templatePathByWatchedPaths[watchedPath])
{
triggeredTemplatePaths.Add(templatePath);
}
}
}
}
foreach (var templatePath in triggeredTemplatePaths)
{
if (Settings.Current.Verbose)
{
Debug.Log(string.Format("Asset modification is triggered T4 template's generator at '{0}'.", templatePath));
}
var settings = TemplateSettings.Load(templatePath);
UnityTemplateGenerator.RunForTemplateWithDelay(templatePath, TimeSpan.FromMilliseconds(settings.TriggerDelay));
}
}
private static void T4TransformAllAssets()
{
foreach (var templatePath in TemplateSettings.ListTemplatesInProject())
{
var assetName = Path.GetFileName(templatePath);
Debug.Log(string.Format("Running transformation for '{0}' asset...", assetName));
var result = UnityTemplateGenerator.RunForTemplate(templatePath);
Debug.Log(string.Format("Transformation for '{0}' asset is completed. Result: {1}", assetName, result));
}
AssetChangesTrigger.DoDelayedAssetRefresh();
}
private static void Initialize()
{
EditorApplication.update -= InitializeCallback;
System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(typeof(TemplateInspector).TypeHandle);
foreach (var templatePath in TemplateSettings.ListTemplatesInProject())
{
var settings = TemplateSettings.Load(templatePath);
if ((settings.Trigger & (int)TemplateSettings.Triggers.CodeCompilation) == 0)
{
continue;
}
if (Settings.Current.Verbose)
{
Debug.Log(string.Format("Code compilation in project is triggered T4 template's generator at '{0}'.", templatePath));
}
UnityTemplateGenerator.RunForTemplateWithDelay(templatePath, TimeSpan.FromMilliseconds(settings.TriggerDelay));
}
}
/// <summary>
/// Run T4 template transformation with at <paramref name="templatePath"/> with additional settings.
/// </summary>
/// <param name="templatePath">Path to T4 template.</param>
/// <param name="outputPath">Output path. It will override <see cref="TemplateSettings.OutputPath"/> from <paramref name="settings"/> parameter.</param>
/// <param name="settings">Settings override for this run.</param>
/// <param name="parameters">Additional template parameters. They could be retrieved with following code. <code>this.Host.ResolveParameterValue("-", "-", "someKey");</code>.</param>
/// <param name="assemblyReferences">Additional assemblies to load during transformation. Could be assembly name or full path to assembly.</param>
/// <param name="assemblyReferencesLookupPaths">Additional assembly lookup paths. Used during referenced assemblies resolution.</param>
/// <param name="includeLookupPaths">Additional lookup path for <#=include#> directives.</param>
/// <returns>Result of transformation.</returns>
public static TransformationResult RunForTemplate
(
string templatePath,
string outputPath,
TemplateSettings settings = null,
Dictionary <string, string> parameters = null,
List <string> assemblyReferences = null,
List <string> assemblyReferencesLookupPaths = null,
List <string> includeLookupPaths = null
)
{
if (templatePath == null)
{
throw new ArgumentNullException("templatePath");
}
templatePath = PathUtils.MakeProjectRelative(templatePath);
settings = settings ?? TemplateSettings.Load(templatePath);
var generator = new UnityTemplateGenerator();
var templateName = Path.GetFileNameWithoutExtension(templatePath);
var templateDir = Path.GetDirectoryName(templatePath) ?? "Assets";
var templateNamespace = string.Join(".", templateDir.Split(new char[] { '\\', '/' }, StringSplitOptions.RemoveEmptyEntries));
var generatorOutputDir = Path.Combine("Temp", "T4");
var outputFile = Path.Combine(generatorOutputDir, Path.GetFileNameWithoutExtension(templatePath) + "_" + Guid.NewGuid().ToString().Replace("-", "") + ".txt");
var generatorOutputFile = Path.ChangeExtension(outputFile, ".gen.cs");
var language = default(string);
var references = default(string[]);
if (Directory.Exists(generatorOutputDir) == false)
{
Directory.CreateDirectory(generatorOutputDir);
}
if (Settings.Current.Verbose)
{
Debug.Log(string.Format("Pre-process T4 template '{0}'. Output directory: '{1}'.", templatePath, generatorOutputDir));
}
if (generator.PreprocessTemplate(templatePath, templateName, templateNamespace, generatorOutputFile, Encoding.UTF8, out language, out references) == false)
{
Debug.LogWarning(string.Format("Failed to pre-process template '{0}'.", templatePath));
foreach (var error in generator.Errors)
{
var log = (Action <object>)Debug.LogError;
log.BeginInvoke(error, null, null);
}
FocusConsoleWindow();
return(TransformationResult.TemplateCompilationError);
}
if (Settings.Current.Verbose)
{
Debug.Log(string.Format("Pre-process T4 template '{0}' is complete successfully. Language: '{1}', References: '{2}', Reference location paths: {3}, Include paths: {4}, Output file: '{5}'.",
templatePath, language, string.Join(", ", references ?? new string[0]),
string.Join(", ", generator.ReferencePaths.ToArray()), string.Join(", ", generator.IncludePaths.ToArray()), generatorOutputFile));
}
if (assemblyReferences != null)
{
generator.Refs.AddRange(assemblyReferences);
}
if (assemblyReferencesLookupPaths != null)
{
generator.ReferencePaths.AddRange(assemblyReferencesLookupPaths);
}
if (includeLookupPaths != null)
{
generator.IncludePaths.AddRange(includeLookupPaths);
}
if (parameters != null)
{
foreach (var kv in parameters)
{
generator.AddParameter("-", "-", kv.Key, kv.Value);
generator.AddParameter(null, null, kv.Key, kv.Value);
}
}
if (Settings.Current.Verbose)
{
Debug.Log(string.Format("Process T4 template '{0}'. Output File: '{1}'.", templatePath, outputFile));
}
if (generator.ProcessTemplate(templatePath, ref outputFile) == false)
{
Debug.LogWarning(string.Format("Failed to process template '{0}'.", templatePath));
foreach (CompilerError error in generator.Errors)
{
var log = (Action <object>)Debug.LogError;
log.BeginInvoke(error, null, null);
}
FocusConsoleWindow();
return(TransformationResult.TemplateProcessingError);
}
if (Settings.Current.Verbose)
{
Debug.Log(string.Format("Process T4 template '{0}' is complete successfully. Output file: '{1}'.", templatePath, outputFile));
}
var sourceFile = default(string);
switch ((TemplateSettings.OutputTypes)settings.OutputType)
{
case TemplateSettings.OutputTypes.Text:
sourceFile = outputFile;
break;
case TemplateSettings.OutputTypes.TextGenerator:
sourceFile = generatorOutputFile;
break;
default:
Debug.LogWarning("Invalid 'OutputType' is specified in template's settings.");
return(TransformationResult.UnknownOutputType);
}
var targetFile = outputPath ?? settings.OutputPath;
if (targetFile == null)
{
targetFile = Path.GetFullPath(Path.ChangeExtension(templatePath, Path.GetExtension(sourceFile)));
}
else
{
targetFile = Path.GetFullPath(targetFile);
}
if (File.Exists(targetFile) && PathUtils.ComputeMd5Hash(targetFile) == PathUtils.ComputeMd5Hash(sourceFile))
{
if (Settings.Current.Verbose)
{
Debug.Log(string.Format("Generated file is same as existing at location '{0}'.", targetFile));
}
return(TransformationResult.NoChanges);
}
var targetDir = Path.GetDirectoryName(targetFile);
if (targetDir != null && Directory.Exists(targetDir) == false)
{
Directory.CreateDirectory(targetDir);
}
File.Copy(sourceFile, targetFile, overwrite: true);
File.Delete(outputFile);
File.Delete(generatorOutputFile);
return(TransformationResult.Success);
}