public UTinyProject CreateProject(UTinyId id, string name)
{
var project = new UTinyProject(this, m_VersionStorage)
{
Id = id,
Name = name,
};
m_VersionStorage.MarkAsChanged(project);
Register(project);
return(project);
}
private static bool UsesAdSupport(UTinyProject project)
{
var registry = project.Registry;
var module = project.Module.Dereference(registry);
foreach (var m in module.EnumerateDependencies())
{
if (m.Namespace == "ut.AdSupport")
{
return(true);
}
}
return(false);
}
/// <summary>
/// Sets up or migrates the initial state of the project
/// * Includes required modules
/// * Perfrorms any migration
/// </summary>
/// <param name="registry"></param>
/// <param name="project"></param>
private static void SetupProject(IRegistry registry, UTinyProject project)
{
var module = project.Module.Dereference(registry);
// Make sure there's a dependency on the core modules
module.AddExplicitModuleDependency((UTinyModule.Reference)registry.FindByName <UTinyModule>("UTiny.Core"));
module.AddExplicitModuleDependency((UTinyModule.Reference)registry.FindByName <UTinyModule>("UTiny.Math"));
module.AddExplicitModuleDependency((UTinyModule.Reference)registry.FindByName <UTinyModule>("UTiny.Core2D"));
if (project.Configuration.Equals(UTinyEntity.Reference.None))
{
var configurationEntity = registry.CreateEntity(UTinyId.New(), "Configuration");
project.Configuration = (UTinyEntity.Reference)configurationEntity;
}
}
public static void SendBuildEvent(UTinyProject project, UTinyBuildResults buildResults, TimeSpan duration)
{
if (project?.Settings == null || buildResults == null)
{
return;
}
var buildReportRoot = buildResults.BuildReport.Root;
var buildReportRuntime = buildReportRoot.GetChild(UTinyBuildReport.RuntimeNode);
var buildReportAssets = buildReportRoot.GetChild(UTinyBuildReport.AssetsNode);
var buildReportCode = buildReportRoot.GetChild(UTinyBuildReport.CodeNode);
var e = new BuildEvent()
{
package = TinyPackageUtility.Package,
context = ContextInfo.Default,
project = ProjectInfo.Create(project),
duration = duration.Ticks,
total_bytes = buildReportRoot?.Item.CompressedSize ?? 0,
runtime_bytes = buildReportRuntime?.Item.CompressedSize ?? 0,
assets_bytes = buildReportAssets?.Item.CompressedSize ?? 0,
code_bytes = buildReportCode?.Item.CompressedSize ?? 0,
total_raw_bytes = buildReportRoot?.Item.Size ?? 0,
runtime_raw_bytes = buildReportRuntime?.Item.Size ?? 0,
assets_raw_bytes = buildReportAssets?.Item.Size ?? 0,
code_raw_bytes = buildReportCode?.Item.Size ?? 0,
heap_size = project.Settings.MemorySize,
opt_auto_resize = project.Settings.CanvasAutoResize,
opt_ws_client = project.Settings.IncludeWSClient,
opt_webp_decompressor = project.Settings.IncludeWebPDecompressor,
opt_ecma5 = project.Settings.RunBabel,
opt_single_file_output = project.Settings.SingleFileHtml,
opt_embed_assets = project.Settings.EmbedAssets,
default_texture_format = project.Settings.DefaultTextureSettings.FormatType.ToString()
};
Send(EventName.tinyEditorBuild, e);
}
private void AddRegistryObjectDependency(UTinyProject project)
{
if (null == project)
{
return;
}
var path = UTinyPersistence.GetLocation(project);
// Core or sample module/project don't need to be packaged, they will be included from the manifest.
if (ShouldPackage(path))
{
AddFileElements(path, false);
}
foreach (var module in project.Module.Dereference(project.Registry).EnumerateDependencies())
{
AddRegistryObjectDependency(module);
}
}
private void HandleProjectLoaded(UTinyProject project)
{
if (null == project)
{
Repaint();
return;
}
EntityGroupManager.OnEntityGroupLoaded += AddToTrees;
EntityGroupManager.OnEntityGroupUnloaded += RemoveFromTrees;
EntityGroupManager.OnEntityGroupsReordered += ReorderTrees;
m_TreeView = new HierarchyTree(EditorContext, m_TreeState);
foreach (var entityGroup in LoadedEntityGroups)
{
AddToTrees(entityGroup);
}
Undo.OnUndoPerformed += () => HandleDataModelChange(ChangeSource.DataModel, null);
Undo.OnRedoPerformed += () => HandleDataModelChange(ChangeSource.DataModel, null);
}
public static ProjectInfo Create(UTinyProject project)
{
var result = new ProjectInfo();
if (project == null)
{
return(result);
}
var main = project.Module.Dereference(project.Registry);
if (main == null)
{
return(result);
}
var deps = main.EnumerateDependencies().Select(d => d.Name);
result.modules = deps.ToArray();
return(result);
}
/// <summary>
/// Generates the platform-agnostic IDL file from the given UTinyProject.
/// </summary>
public static void GenerateIDL(UTinyProject project, FileInfo destination)
{
var writer = new UTinyCodeWriter
{
CodeStyle = CodeStyle.CSharp
};
writer.Line("using UTiny;");
writer.Line("using UTiny.Shared;");
var mainModule = project.Module.Dereference(project.Registry);
foreach (var dep in mainModule.EnumerateDependencies())
{
if (dep.Equals(mainModule))
{
continue;
}
if (dep.Name == "UTiny.Core") // Hack: The Core module does not actually generate a Core namespace, but Core namespace is the UTiny/ut namespace.
{
continue;
}
if (dep.IsRuntimeIncluded)
{
writer.Line($"using {dep.Name};"); // Core namespaces are of form "UTiny.Core2D".
}
else
{
writer.Line($"using {dep.Namespace.Replace("UTiny.", "ut.")};"); // Runtime generated namespaces are of form "ut.tween".
}
}
project.Visit(new GenerateIDLVisitor {
Writer = writer
});
File.WriteAllText(destination.FullName, writer.ToString(), Encoding.UTF8);
}
private static void HandleProjectUnloaded(UTinyProject project)
{
EntityGroupManager.OnWillUnloadEntityGroup -= HandleEntityGroupWillUnload;
EntityGroupManager.OnEntityGroupUnloaded -= HandleEntityGroupUnloaded;
}
public static IList <UTinyExportInfo> Export(UTinyProject project, DirectoryInfo assetsFolder)
{
var module = project.Module.Dereference(project.Registry);
return(AssetIterator.EnumerateAssets(module).Select(asset => Export(project, assetsFolder.FullName, asset)).ToList());
}
public static string GetAssetName(UTinyProject project, Object @object)
{
return(GetAssetName(project.Module.Dereference(project.Registry), @object));
}
private static void CreateEntityForAsset(IRegistry registry, UTinyProject project, UTinyEntityGroup entityGroup, UTinyAssetInfo asset)
{
var @object = asset.Object;
UTinyEntity entity = null;
if (@object is Texture2D)
{
var texture = @object as Texture2D;
var path = AssetDatabase.GetAssetPath(texture);
var importer = (TextureImporter)AssetImporter.GetAtPath(path);
entity = registry.CreateEntity(UTinyId.New(), $"{GetAssetEntityPath(typeof(Texture2D))}{asset.Name}");
var image2d = entity.AddComponent(registry.GetImage2DType());
image2d.Refresh();
image2d["imageFile"] = $"ut-asset:{asset.Name}";
var settings = UTinyUtility.GetAssetExportSettings(project, @object) as UTinyTextureSettings;
if (settings != null && settings.FormatType == TextureFormatType.JPG && UTinyAssetExporter.TextureExporter.ReallyHasAlpha(texture))
{
image2d["maskFile"] = $"ut-asset:{asset.Name}_a";
}
image2d["disableSmoothing"] = importer.filterMode == FilterMode.Point;
var sprite = AssetDatabase.LoadAllAssetsAtPath(path).OfType <Sprite>().FirstOrDefault();
// @NOTE The `importer.spritePixelsPerUnit` is currently NOT used in the editor...
// We ALWAYS draw sprites at 1 pixel to world unit in the editor.
// When we switch to using SpriteRenderer as our editor drawer we can just pass `sprite.pixelsPerUnit` directly here.
var pixelsToWorldUnits = sprite ? sprite.pixelsPerUnit : 1;
image2d["pixelsToWorldUnits"] = 1.0f / pixelsToWorldUnits;
}
else if (@object is Sprite)
{
var sprite = (Sprite)@object;
entity = registry.CreateEntity(UTinyId.New(), $"{GetAssetEntityPath(typeof(Sprite))}{asset.Name}");
var sprite2d = entity.AddComponent(registry.GetSprite2DType());
sprite2d.Refresh();
sprite2d["image"] = sprite.texture;
var region = sprite2d["imageRegion"] as UTinyObject;
if (null != region)
{
region["x"] = sprite.rect.x / sprite.texture.width;
region["y"] = sprite.rect.y / sprite.texture.height;
region["width"] = sprite.rect.width / sprite.texture.width;
region["height"] = sprite.rect.height / sprite.texture.height;
}
var pivot = sprite2d["pivot"] as UTinyObject;
if (null != pivot)
{
pivot["x"] = sprite.pivot.x / sprite.rect.width;
pivot["y"] = sprite.pivot.y / sprite.rect.height;
}
}
else if (@object is AudioClip)
{
entity = registry.CreateEntity(UTinyId.New(), $"{GetAssetEntityPath(typeof(AudioClip))}{asset.Name}");
var audioClip = entity.AddComponent(registry.GetAudioClipType());
audioClip.Refresh();
audioClip["file"] = $"ut-asset:{asset.Name}";
}
else if (@object is Font)
{
entity = registry.CreateEntity(UTinyId.New(), $"{GetAssetEntityPath(typeof(Font))}{asset.Name}");
var fontAsset = entity.AddComponent(registry.GetFontType());
fontAsset.Refresh();
fontAsset["file"] = $"ut-asset:{asset.Name}";
}
if (null != entity)
{
entityGroup.AddEntityReference((UTinyEntity.Reference)entity);
}
foreach (var child in asset.Children)
{
CreateEntityForAsset(registry, project, entityGroup, child);
}
}
private void HandleProjectClosed(UTinyProject project)
{
m_TreeView.ClearScenes();
Repaint();
}
private void OnSaveProject(UTinyProject project)
{
SetDirtyAll();
}
public static string GetBuildDirectory(UTinyProject project, UTinyPlatform platform, UTinyBuildConfiguration configuration)
{
return(Path.Combine("UTinyExport", project.Name, platform.ToString(), configuration.ToString()));
}
public static bool IncludesModule(UTinyProject project, string moduleName)
{
return(project.Module.Dereference(project.Registry).EnumerateDependencies().WithName(moduleName).Any());
}
public static void WriteEntityGroupSetupFunction(UTinyCodeWriter writer, UTinyProject project, UTinyEntityGroup entityGroup, bool writeEntityGroupComponent = true, bool writeEntityLayer = true)
{
var entityIndex = 0;
var entityIndexMap = new Dictionary <UTinyEntity.Reference, int>();
using (writer.Scope("function(w)"))
{
entityIndexMap.Clear();
foreach (var reference in entityGroup.Entities)
{
var entity = reference.Dereference(entityGroup.Registry);
++entityIndex;
entityIndexMap[reference] = entityIndex;
writer.Line($"var e{entityIndex} = w.create({EscapeJsString(entity.Name)});");
}
if (writeEntityGroupComponent)
{
foreach (var reference in entityGroup.Entities)
{
var index = entityIndexMap[reference];
writer.Line($"e{index}.addComponent(this.Component);");
}
}
if (writeEntityLayer)
{
foreach (var reference in entityGroup.Entities)
{
var index = entityIndexMap[reference];
var entity = reference.Dereference(entityGroup.Registry);
writer.Line($"e{index}.addComponent({GetFullyQualifiedLayerName(LayerMask.LayerToName(entity.Layer))});");
}
}
var context = new VisitorContext
{
Project = project,
Module = project.Module.Dereference(project.Registry),
Registry = project.Registry,
Writer = writer,
EntityIndexMap = entityIndexMap
};
entityIndex = 0;
foreach (var reference in entityGroup.Entities)
{
var entity = reference.Dereference(entityGroup.Registry);
++entityIndex;
foreach (var component in entity.Components)
{
var type = component.Type.Dereference(component.Registry);
if (null == type)
{
Debug.LogError($"{UTinyConstants.ApplicationName}: Missing component type, ComponentType=[{component.Type.Name}] Entity=[{entity.Name}] Group=[{entityGroup.Name}]");
continue;
}
var index = ++context.ComponentIndex;
writer.Line($"var c{index} = e{entityIndex}.addComponent({UTinyBuildPipeline.GetJsTypeName(type)});");
component.Properties.Visit(new ComponentVisitor
{
VisitorContext = context,
Path = $"c{index}",
Entity = $"e{entityIndex}"
});
}
}
writer.WriteIndent();
writer.WriteRaw("return [");
for (var i = 0; i < entityIndex; i++)
{
writer.WriteRaw(i != 0 ? $", e{i + 1}" : $"e{i + 1}");
}
writer.WriteRaw("];\n");
}
writer.Line().Line();
}
