public static TimeSeriesConverter GetConverter(ConverterTypes ct)
{
switch (ct)
{
case ConverterTypes.Offset:
return new OffsetConverter() { TypeOfConverter = ct };
case ConverterTypes.LinearConverter:
return new LinearConverter() { TypeOfConverter = ct };
default:
break;
}
return null;
}
/// <summary>
/// Create a converter by syntax node.
/// </summary>
/// <param name="node">The syntax node.</param>
/// <returns>The node's converter.</returns>
public Converter CreateConverter(Node node)
{
Type nodeType = node.GetType();
if (ConverterTypes.ContainsKey(nodeType))
{
Type converterType = ConverterTypes[nodeType];
Converter converter = (Converter)converterType.GetConstructor(Type.EmptyTypes).Invoke(Type.EmptyTypes);
converter.Context = this;
return(converter);
}
return(null);
}
public static ITextConverter GetTextConverter(ConverterTypes type)
{
switch (type)
{
case ConverterTypes.TextToXML:
return(new XMLConverter());
case ConverterTypes.TextToCSV:
return(new CSVConverter());
default:
return(new XMLConverter());
}
}
public static IOperationsConverter CreateOperationConverter(ConverterTypes type)
{
switch (type)
{
case ConverterTypes.XML:
return new OperationsConverters.XMLConverter();
case ConverterTypes.MessagePack:
return new OperationsConverters.MessagePackConverter();
case ConverterTypes.Bin:
return new OperationsConverters.BinConverter();
case ConverterTypes.SOAP:
return new OperationsConverters.SOAPConverter();
case ConverterTypes.GPB:
return new OperationsConverters.GPBConverter();
case ConverterTypes.JSON:
return new OperationsConverters.JSONConverter();
default:
return null;
}
}
public static IFlowchartsConverter CreateFlowChartConverter(ConverterTypes type)
{
switch (type)
{
case ConverterTypes.XML:
return new FlowchartsConverters.XMLConverter();
case ConverterTypes.MessagePack:
return new FlowchartsConverters.MessagePackConverter();
case ConverterTypes.Bin:
return new FlowchartsConverters.BinConverter();
case ConverterTypes.SOAP:
return new FlowchartsConverters.SOAPConverter();
case ConverterTypes.GPB:
return new FlowchartsConverters.GPBConverter();
case ConverterTypes.JSON:
return new FlowchartsConverters.JSONConverter();
default:
return null;
}
}
public static TimeSeriesConverter GetConverter(ConverterTypes ct)
{
switch (ct)
{
case ConverterTypes.Offset:
return(new OffsetConverter()
{
TypeOfConverter = ct
});
case ConverterTypes.LinearConverter:
return(new LinearConverter()
{
TypeOfConverter = ct
});
default:
break;
}
return(null);
}
public void RunConverter(string pyScriptName, ConverterTypes type)
{
// should only check the textures that are being used for this converter
string scriptDict = Directory.GetCurrentDirectory() + @"\Assets\Editor\TextureConversion\Scripts";
StreamWriter sr = File.CreateText(scriptDict + @"\Temp.txt");
GetDirectroys(sr, type);
string[] files = Directory.GetFiles(scriptDict);
string pyScript = null;
for (int i = 0; i < files.Length; i++)
{
if (files[i].Contains(pyScriptName) && !files[i].Contains(".meta"))
{
pyScript = files[i];
}
}
RunCmd("\"" + pyScript + "\"");
}
public IConverterAPI getConverterAPI(ConverterTypes converterType)
{
switch (converterType)
{
case ConverterTypes.Length:
return(new LengthConverterAPI());
case ConverterTypes.Mass:
return(new MassConverterAPI());
case ConverterTypes.Speed:
return(new SpeedConverterAPI());
case ConverterTypes.Temperature:
return(new TemperatureConverterAPI());
case ConverterTypes.Volume:
return(new VolumeConverterAPI());
default:
throw new ArgumentOutOfRangeException(string.Format("ConverterAPIFactory does not support type {0}", converterType));
}
}
public void GetDirectroys(StreamWriter sr, ConverterTypes type)
{
switch (type)
{
case ConverterTypes.Roughness_To_Metallic_Smoothness:
sr.WriteLine(Directory.GetCurrentDirectory() + @"\" + AssetDatabase.GetAssetPath(Roughness));
sr.WriteLine(Directory.GetCurrentDirectory() + @"\" + AssetDatabase.GetAssetPath(Metallic));
sr.Close();
break;
case ConverterTypes.Unity_Default_To_Valve_VR_Standard:
sr.WriteLine(Directory.GetCurrentDirectory() + @"\" + AssetDatabase.GetAssetPath(Diffuse));
sr.WriteLine(Directory.GetCurrentDirectory() + @"\" + AssetDatabase.GetAssetPath(Gloss));
sr.WriteLine(Directory.GetCurrentDirectory() + @"\" + AssetDatabase.GetAssetPath(Normal));
sr.Close();
break;
case ConverterTypes.BGRA_Normal_To_RGB_Normal:
sr.WriteLine(Directory.GetCurrentDirectory() + @"\" + AssetDatabase.GetAssetPath(Normal));
sr.Close();
break;
case ConverterTypes.Invert_Yellow_Normal:
sr.WriteLine(Directory.GetCurrentDirectory() + @"\" + AssetDatabase.GetAssetPath(Normal));
sr.Close();
break;
case ConverterTypes.Invert_RGB_Texture:
sr.WriteLine(Directory.GetCurrentDirectory() + @"\" + AssetDatabase.GetAssetPath(Texture));
sr.Close();
break;
default:
break;
}
}
public static void Converters(string file, ConverterTypes converterType, bool mssON)
{
var txtOgg2FixHdr = String.Empty;
var txtWwiseConvert = String.Empty;
var txtWwise2Ogg = String.Empty;
var txtAudio2Wem = String.Empty;
//using (var fd = new OpenFileDialog())
//{
// fd.Multiselect = true;
// fd.Filter = "Wwise 2010.3.3 OGG files (*.ogg)|*.ogg";
// if (converterType == ConverterType.Revorb || converterType == ConverterType.WEM)
// fd.Filter += "|Wwise 2013 WEM files (*.wem)|*.wem";
// else if (converterType == ConverterType.Ogg2Wem)
// fd.Filter = "Vobis Ogg or Wave files (*.ogg, *.wav)|*.ogg; *.wav";
// fd.ShowDialog();
// if (!fd.FileNames.Any())
// return;
//InputAudioFiles = fd.FileNames;
Dictionary<string, string> errorFiles = new Dictionary<string, string>();
List<string> successFiles = new List<string>();
try
{
var extension = Path.GetExtension(file);
var outputFileName = Path.Combine(Path.GetDirectoryName(file), String.Format("{0}_fixed{1}", Path.GetFileNameWithoutExtension(file), ".ogg"));
switch (converterType)
{
case ConverterTypes.Ogg2Wem:
//txtAudio2Wem.Text = file;
OggFile.Convert2Wem(file, 4, 4 * 1000);
//Delete any preview_preview file created..by....?ccc
foreach (string prev_prev in Directory.GetFiles(Path.GetDirectoryName(file), "*preview_preview*", System.IO.SearchOption.AllDirectories))
{
File.Delete(prev_prev);
}
break;
}
successFiles.Add(file);
}
catch (Exception ex)
{
errorFiles.Add(file, ex.Message);
}
if (errorFiles.Count <= 0 && successFiles.Count > 0)
if (mssON) MessageBox.Show("Conversion complete!", MESSAGEBOX_CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Information);
else if (errorFiles.Count > 0 && successFiles.Count > 0)
{
StringBuilder alertMessage = new StringBuilder(
"Conversion complete with errors." + Environment.NewLine + Environment.NewLine);
alertMessage.AppendLine(
"Files converted with success:" + Environment.NewLine);
foreach (var sFile in successFiles)
alertMessage.AppendLine(String.Format("File: {0}", sFile));
alertMessage.AppendLine("Files converted with error:" + Environment.NewLine);
foreach (var eFile in errorFiles)
alertMessage.AppendLine(String.Format("File: {0}; error: {1}", eFile.Key, eFile.Value));
if (mssON) MessageBox.Show(alertMessage.ToString(), MESSAGEBOX_CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else
{
StringBuilder alertMessage = new StringBuilder(
"Conversion complete with errors." + Environment.NewLine);
alertMessage.AppendLine(
"Files converted with error: " + Environment.NewLine);
foreach (var eFile in errorFiles)
alertMessage.AppendLine(String.Format("File: {0}, error: {1}", eFile.Key, eFile.Value));
if (mssON) MessageBox.Show(alertMessage.ToString(), MESSAGEBOX_CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public static Action <Stream, Object> BuildWrite(Type t, IServiceProvider provider)
{
Log($"Building Write of {t.Name}");
ParameterExpression inputStream = Expression.Parameter(typeof(Stream), "inputStream");
ParameterExpression inputObject = Expression.Parameter(typeof(Object), "inputObject");
List <Expression> expressions = new List <Expression>();
var Fields = from field in t.GetFields()
where field.CustomAttributes.Any(attribute => attribute.AttributeType == typeof(AutoSerializeAttribute))
orderby field.GetCustomAttribute <AutoSerializeAttribute>().Order
select field;
foreach (var field in Fields)
{
var isArray = field.FieldType.IsArray;
var serializer = GetSerializer(provider, isArray ? field.FieldType.GetElementType() : field.FieldType,
out Type UsedSerializerType, out List <Type> ConverterTypes);
#if DEBUG
Log(
$"Write of {t.Name}/{field.Name} ({field.FieldType.Name})\nSerializer: {serializer.GetType().Name}");
#endif
var preSerialize = field.GetCustomAttribute <PreSerializeAttribute>();
if (preSerialize?.Writing != null)
{
Log($"PreSerialize {preSerialize.Writing}");
expressions.Add(Expression.Call(Expression.Convert(inputObject, t), t.GetMethod(preSerialize.Writing)));
}
Expression writeExpression =
// The Convert above because GetValue returns object
// Second Parameter: the value of this field of the inputObject
// this field
Expression.Call(Expression.Constant(field),
// get its value
typeof(FieldInfo).GetMethod("GetValue"),
// the input is the instance
inputObject);
writeExpression = !isArray
? ConverterTypes.Aggregate(writeExpression,
Expression.ConvertChecked)
: Expression.ConvertChecked(writeExpression,
field.FieldType);
if (isArray)
{
var noLengthAtt = field.GetCustomAttribute <NoLengthAttribute>();
var leftOverDataAttribute = field.GetCustomAttribute <LeftOverDataAttribute>();
if (leftOverDataAttribute == null && noLengthAtt == null)
{
// Write Length as Int32
expressions.Add(Expression.Call(Expression.Constant(provider.GetService(_arrayHeadNumericTypeAccessor)),
_arrayHeadNumericTypeAccessor.GetMethod("Write"), inputStream,
Expression.Property(
Expression.ConvertChecked(
Expression.Call(Expression.Constant(field), typeof(FieldInfo).GetMethod("GetValue"),
inputObject), typeof(Array)), typeof(Array).GetProperty("Length"))));
}
}
// call the write methode on him
expressions.Add(Expression.Call(Expression.Constant(serializer),
// First of all, we want to have the Write Methode on the Serializer
UsedSerializerType.GetMethod(isArray ? "WriteArray" : "Write"),
// First Parameter: the inputStream
inputStream, writeExpression));
}
var build = Expression.Lambda <Action <Stream, Object> >(
Expression.Block(expressions), inputStream, inputObject).Compile();
Log("Done Building Write");
return(build);
}
public static IBinaryConverter CreateConverter(ConverterTypes converterType)
{
return(Resolver.Activate <IBinaryConverter>(converterType));
}
public static IBinaryConverter CreateConverter(ConverterTypes converterType)
{
return Resolver.Activate<IBinaryConverter>(converterType);
}
private void OnGUI()
{
string TypeText = "Select Conversion Type";
GUILayout.Label(TypeText);
convType = (ConverterTypes)EditorGUILayout.EnumPopup(convType);
switch (convType)
{
case ConverterTypes.Roughness_To_Metallic_Smoothness:
{
GetTexture(TextureTypes.Roughness);
GetTexture(TextureTypes.Metallic);
if (GUILayout.Button("Convert"))
{
if (Roughness != null && Metallic != null)
{
#region IDK IF I WANNA DO DIS YET SO..
//string scriptDict = Directory.GetCurrentDirectory() + @"\Assets\Editor\TextureConversion\Scripts";
//StreamWriter sr = File.CreateText(scriptDict + @"\Temp.txt");
//sr.WriteLine(Directory.GetCurrentDirectory() + @"\" + AssetDatabase.GetAssetPath(Roughness));
//sr.WriteLine(Directory.GetCurrentDirectory() + @"\" + AssetDatabase.GetAssetPath(Metallic));
//sr.Close();
//string[] files = Directory.GetFiles(scriptDict);
//string pyScript = null;
//for (int i = 0; i < files.Length; i++)
//{
// if (files[i].Contains("MetallicSmoothnessConverter") && !files[i].Contains(".meta"))
// pyScript = files[i];
//}
//RunCmd("\"" + pyScript + "\"");
//UnityEngine.Debug.Log("python \"" + pyScript + "\"");
#endregion
RunConverter("MetallicSmoothnessConverter", ConverterTypes.Roughness_To_Metallic_Smoothness);
}
else
{
UnityEngine.Debug.LogError("Missing Textures!");
}
}
EditorGUILayout.HelpBox("Inverts the Roughness Map and puts it into the Metallic Map's Alpha Channel", MessageType.Info, true);
}
break;
case ConverterTypes.Unity_Default_To_Valve_VR_Standard:
{
GetTexture(TextureTypes.Diffuse);
GetTexture(TextureTypes.Gloss);
GetTexture(TextureTypes.Normal);
if (GUILayout.Button("Convert"))
{
if (Diffuse != null && Gloss != null && Normal != null)
{
//string scriptDict = Directory.GetCurrentDirectory() + @"\Assets\Editor\TextureConversion\Scripts";
//StreamWriter sr = File.CreateText(scriptDict + @"\Temp.txt");
//sr.WriteLine(Directory.GetCurrentDirectory() + @"\" + AssetDatabase.GetAssetPath(Diffuse));
//sr.WriteLine(Directory.GetCurrentDirectory() + @"\" + AssetDatabase.GetAssetPath(Gloss));
//sr.WriteLine(Directory.GetCurrentDirectory() + @"\" + AssetDatabase.GetAssetPath(Normal));
//sr.Close();
//string[] files = Directory.GetFiles(scriptDict);
//string pyScript = null;
//for (int i = 0; i < files.Length; i++)
//{
// if (files[i].Contains("UnityDefaultToValveVRStandard") && !files[i].Contains(".meta"))
// pyScript = files[i];
//}
//RunCmd("\"" + pyScript + "\"");
//UnityEngine.Debug.Log("python \"" + pyScript + "\"");
RunConverter("UnityDefaultToValveVRStandard", ConverterTypes.Unity_Default_To_Valve_VR_Standard);
}
else
{
UnityEngine.Debug.LogError("Missing Textures!");
}
}
EditorGUILayout.HelpBox("All-In-One Converter\n" +
"Seperates Metallic Map from Diffuse, Adds Gloss Map to Metallic Alpha, and fixes BGRA Normal Map"
, MessageType.Info, true);
}
break;
case ConverterTypes.BGRA_Normal_To_RGB_Normal:
{
GetTexture(TextureTypes.Normal);
if (GUILayout.Button("Convert"))
{
if (Normal != null)
{
//string scriptDict = Directory.GetCurrentDirectory() + @"\Assets\Editor\TextureConversion\Scripts";
//StreamWriter sr = File.CreateText(scriptDict + @"\Temp.txt");
//sr.WriteLine(Directory.GetCurrentDirectory() + @"\" + AssetDatabase.GetAssetPath(Normal));
//sr.Close();
//string[] files = Directory.GetFiles(scriptDict);
//string pyScript = null;
//for (int i = 0; i < files.Length; i++)
//{
// if (files[i].Contains("BGRA_Normal_To_RGBA_Normal") && !files[i].Contains(".meta"))
// pyScript = files[i];
//}
//RunCmd("\"" + pyScript + "\"");
//UnityEngine.Debug.Log("python \"" + pyScript + "\"");
RunConverter("BGRA_Normal_To_RGBA_Normal", ConverterTypes.BGRA_Normal_To_RGB_Normal);
}
else
{
UnityEngine.Debug.LogError("Missing Textures!");
}
}
EditorGUILayout.HelpBox("Converts BGRA Normal Maps\nUse if your Normal Map is red", MessageType.Info, true);
}
break;
case ConverterTypes.Invert_Yellow_Normal:
{
GetTexture(TextureTypes.Normal);
if (GUILayout.Button("Convert"))
{
if (Normal != null)
{
//string scriptDict = Directory.GetCurrentDirectory() + @"\Assets\Editor\TextureConversion\Scripts";
//StreamWriter sr = File.CreateText(scriptDict + @"\Temp.txt");
//sr.WriteLine(Directory.GetCurrentDirectory() + @"\" + AssetDatabase.GetAssetPath(Normal));
//sr.Close();
//string[] files = Directory.GetFiles(scriptDict);
//string pyScript = null;
//for (int i = 0; i < files.Length; i++)
//{
// if (files[i].Contains("InvertYellowNormal") && !files[i].Contains(".meta"))
// pyScript = files[i];
//}
//RunCmd("\"" + pyScript + "\"");
//UnityEngine.Debug.Log("python \"" + pyScript + "\"");
RunConverter("InvertYellowNormal", ConverterTypes.Invert_Yellow_Normal);
}
else
{
UnityEngine.Debug.LogError("Missing Textures!");
}
}
EditorGUILayout.HelpBox("Inverts Blue Channel on Normal Maps\nUse if your Normal Map is yellow", MessageType.Info, true);
}
break;
case ConverterTypes.Invert_RGB_Texture:
{
GetTexture(TextureTypes.Texture);
if (GUILayout.Button("Convert"))
{
if (Texture != null)
{
//string scriptDict = Directory.GetCurrentDirectory() + @"\Assets\Editor\TextureConversion\Scripts";
//StreamWriter sr = File.CreateText(scriptDict + @"\Temp.txt");
//sr.WriteLine(Directory.GetCurrentDirectory() + @"\" + AssetDatabase.GetAssetPath(Texture));
//sr.Close();
//string[] files = Directory.GetFiles(scriptDict);
//string pyScript = null;
//for (int i = 0; i < files.Length; i++)
//{
// if (files[i].Contains("InvertRGB") && !files[i].Contains(".meta"))
// pyScript = files[i];
//}
//RunCmd("\"" + pyScript + "\"");
//UnityEngine.Debug.Log("python \"" + pyScript + "\"");
RunConverter("InvertRGB", ConverterTypes.Invert_RGB_Texture);
}
else
{
UnityEngine.Debug.LogError("Missing Textures!");
}
}
EditorGUILayout.HelpBox("Inverts RGB channels. Will preserve texture Alpha", MessageType.Info, true);
}
break;
default:
break;
}
}
