public Texture2D UpdateTexture()
{
var color = this.value;
var path = Theme.storagePath.GetAssetPath() + "Palettes/@Generated/";
if (!File.Exists(path))
{
File.Create(path);
}
var imagePath = path + "Color" + this.name + ".png";
var image = default(Texture2D);
Worker.MainThread(() => {
image = File.GetAsset <Texture2D>(imagePath);
if (image.IsNull())
{
image = new Texture2D(1, 1, TextureFormat.RGBA32, false);
image.SaveAs(imagePath);
ProxyEditor.ImportAsset(imagePath);
return;
}
image.SetPixel(0, 0, color);
image.Apply();
});
return(image);
}
public static Type Create <Type>(string path, bool createPath = true) where Type : ScriptableObject
{
if (path.IsNull())
{
return(default(Type));
}
var name = path.GetPathTerm();
var useName = typeof(Type).Name == "ScriptableObject";
var folder = Application.dataPath + Singleton.storagePath;
path = folder.GetAssetPath() + path;
if (createPath)
{
File.Create(folder);
}
ProxyEditor.ImportAsset(folder.GetAssetPath());
try{
ScriptableObject instance = useName ? ScriptableObject.CreateInstance(name) : ScriptableObject.CreateInstance <Type>();
ProxyEditor.CreateAsset(instance, path);
ProxyEditor.RefreshAssets();
return(instance.As <Type>());
}
catch { Log.Warning("[Utility] No scriptableObject exists named -- " + name + ".asset"); }
return(null);
}
public void Export(string path = null)
{
var theme = Theme.active;
var savePath = path ?? Theme.storagePath + "Fontsets";
var saveName = theme.fontset.name + "-Variant";
path = path.IsEmpty() ? ProxyEditor.SaveFilePanel("Save Theme [Fonts]", savePath.GetAssetPath(), saveName, "unityfontset") : path;
if (path.Length > 0)
{
var file = File.Create(path);
file.Write(this.Serialize());
ProxyEditor.ImportAsset(path.GetAssetPath());
EditorPref.Set <string>("Zios.Theme.Fontset" + Theme.suffix, path.GetFileName());
Theme.Reset();
}
}
public void ApplyTexture(string path, Texture2D texture)
{
var empty = false;
Worker.MainThread(() => empty = texture.IsNull());
if (empty)
{
return;
}
var name = path.GetPathTerm().TrimLeft("#");
var ignoreAlpha = name.StartsWith("A-");
var isSplat = name.StartsWith("!");
var parts = name.TrimLeft("!", "A-").Split("-");
if (isSplat && parts.Length < 2)
{
Log.Warning("[ThemePalette] : Improperly formed splat texture -- " + path.GetPathTerm());
return;
}
var colorA = isSplat ? this.ParseColor(parts[0]) : Color.clear;
var colorB = isSplat ? this.ParseColor(parts[1]) : Color.clear;
var colorC = isSplat ? this.ParseColor(parts[2]) : Color.clear;
if (isSplat)
{
parts = parts.Skip(3).ToArray();
}
name = parts.Join("-");
bool changes = false;
Texture2D originalImage = null;
var originalPath = path.GetDirectory().GetDirectory() + "/" + name;
var pixels = new Color[0];
Action method = () => {
originalImage = File.GetAsset <Texture2D>(originalPath, false);
if (originalImage.IsNull() && !originalPath.ContainsAny("Themes", "@Themes"))
{
originalImage = File.GetAsset <Texture2D>(name, false);
}
pixels = texture.GetPixels();
if (originalImage.IsNull() || pixels.Length != originalImage.GetPixels().Length)
{
Log.Show("[TexturePalette] : Generating source for index/splat -- " + originalPath.GetPathTerm());
texture.SaveAs(originalPath);
var assetPath = originalPath.GetAssetPath();
ProxyEditor.ImportAsset(assetPath);
var importer = TextureImporter.GetAtPath(assetPath).As <TextureImporter>();
ColorImportSettings.Apply(importer);
importer.SaveAndReimport();
originalImage = File.GetAsset <Texture2D>(originalPath, false);
}
originalPath = originalImage.GetAssetPath();
if (Theme.debug && originalImage.format != TextureFormat.RGBA32)
{
Log.Show("[ThemePalette] Original image is not an RGBA32 texture -- " + originalPath);
}
};
Worker.MainThread(method);
if (Theme.debug && pixels.Length > 65536)
{
Log.Warning("[ThemePalette] Dynamic image has over 65K pixels. Performance can be affected -- " + name);
}
var swapKeys = this.swap.Keys.ToArray();
var originalPixels = pixels.Copy();
for (int index = 0; index < pixels.Length; ++index)
{
var pixel = pixels[index];
if (isSplat)
{
var emptyRed = pixel.r == 0 || colorA.a == 0;
var emptyGreen = pixel.g == 0 || colorB.a == 0;
var emptyBlue = pixel.b == 0 || colorC.a == 0;
var colorAStart = emptyGreen && emptyBlue?colorA.SetAlpha(0) : Color.clear;
var colorBStart = emptyRed && emptyBlue?colorB.SetAlpha(0) : Color.clear;
var colorCStart = emptyRed && emptyGreen?colorC.SetAlpha(0) : Color.clear;
var splatA = colorAStart.Lerp(colorA, pixel.r);
var splatB = colorBStart.Lerp(colorB, pixel.g);
var splatC = colorCStart.Lerp(colorC, pixel.b);
var pixelColor = splatA + splatB + splatC;
pixelColor.a *= pixel.a;
if (originalPixels[index] != pixelColor)
{
originalPixels[index] = pixelColor;
changes = true;
}
continue;
}
for (int swapIndex = 0; swapIndex < swapKeys.Length; ++swapIndex)
{
var swapColor = swapKeys[swapIndex];
if (pixel.Matches(swapColor, false))
{
var color = this.swap[swapColor].value;
color.a = ignoreAlpha ? pixel.a : color.a * pixel.a;
if (originalPixels[index] != color)
{
originalPixels[index] = color;
changes = true;
}
}
}
}
if (changes)
{
method = () => {
originalImage.SetPixels(originalPixels);
originalImage.Apply();
};
Worker.MainThread(method);
}
}