static void Postfix(MaterialImporter __instance, ref Material __result, int i, glTFMaterial x, bool hasVertexColor)
{
__result.SetFloat("_DoubleSided", x.doubleSided ? 0 : 2);
__result.SetFloat("_Cutout", x.alphaCutoff);
if (x.pbrMetallicRoughness != null)
{
if (x.pbrMetallicRoughness.baseColorFactor != null && x.pbrMetallicRoughness.baseColorFactor.Length == 3)
{
float[] baseColorFactor2 = x.pbrMetallicRoughness.baseColorFactor;
__result.SetColor("_MainColor", new Color(baseColorFactor2[0], baseColorFactor2[1], baseColorFactor2[2]).gamma);
}
else if (x.pbrMetallicRoughness.baseColorFactor != null && x.pbrMetallicRoughness.baseColorFactor.Length == 4)
{
float[] baseColorFactor2 = x.pbrMetallicRoughness.baseColorFactor;
__result.SetColor("_MainColor", new Color(baseColorFactor2[0], baseColorFactor2[1], baseColorFactor2[2], baseColorFactor2[3]).gamma);
}
__result.SetFloat("_RefMetallic", x.pbrMetallicRoughness.metallicFactor);
}
if (x.normalTexture != null && x.normalTexture.index != -1)
{
__result.SetFloat("_N_F_NM", 1.0f);
var func = __instance.GetRefField <MaterialImporter, Func <int, TextureItem> >("GetTextureFunc");
TextureItem textureItem4 = func(x.normalTexture.index);
if (textureItem4 != null)
{
string text2 = "_NormalMap";
__result.SetTexture(text2, textureItem4.ConvertTexture(text2, 1f));
__result.SetFloat("_NormalMapIntensity", x.normalTexture.scale);
}
SetTextureOffsetAndScale(__result, x.normalTexture, "_NormalMap");
}
}
public void ImportTest()
{
MaterialImporter target = new MaterialImporter(); // TODO: Initialize to an appropriate value
XmlNode xmlRoot = null; // TODO: Initialize to an appropriate value
ColladaModel model = null; // TODO: Initialize to an appropriate value
target.Import(xmlRoot, model);
Assert.Inconclusive("A method that does not return a value cannot be verified.");
}
public void ImportTest()
{
MaterialImporter target = new MaterialImporter(); // TODO: Initialize to an appropriate value
XmlNode xmlRoot = null; // TODO: Initialize to an appropriate value
ColladaModel model = null; // TODO: Initialize to an appropriate value
target.Import(xmlRoot, model);
Assert.Inconclusive("A method that does not return a value cannot be verified.");
}
private void ImportMaterials(Dictionary <string, PbrMaterial> materials)
{
// import materials
var materialImporter = new MaterialImporter(
materials.Values.ToArray(),
_assetHandler
);
materialImporter.ImportMaterials();
}
private List <ImportedKMATInfo> ImportKMATs(PackageInfo packageInfo)
{
var materialImporter = new MaterialImporter(packageInfo, ModelBinDir);
var materials = packageInfo.GetMaterials();
Log.Debug($"Importing {string.Join( ", ", materials )}");
var importedKMATs = ImportKMATs(materials, materialImporter).ToList();
return(importedKMATs);
}
public async Task <IHttpActionResult> Post()
{
// Check if the request contains multipart/form-data.
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var provider = new MultipartFormDataStreamProvider(Folder);
string filePath = null;
try
{
// Read the form data.
await Request.Content.ReadAsMultipartAsync(provider);
var fileData = provider.FileData[0];
filePath = Path.Combine(Folder, fileData.LocalFileName);
MaterialImportResults results = null;
using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
var importer = new MaterialImporter(manager);
results = await importer.ImportFromStream(stream);
stream.Close();
}
//foreach (var question in results.CreatedQuestions)
// await Logger.AddInformation(" \"{0}\" был добавлен в результате импорта.", .Name);
//foreach (var question in results.UpdatedQuestions)
// await Logger.AddInformation(" \"{0}\" был обновлен в результате импорта.", .Name);
return(Ok(new
{
CreatedMaterials = results.CreatedMaterials.Count,
UpdatedMaterials = results.UpdatedMaterials.Count,
Errors = results.Errors,
}));
}
catch (Exception e)
{
return(InternalServerError(e));
}
finally
{
if (!String.IsNullOrWhiteSpace(filePath) && File.Exists(filePath))
{
File.Delete(filePath);
}
}
}
private void Save(object sender, RoutedEventArgs e)
{
if (string.IsNullOrEmpty(asset.Name) ||
string.IsNullOrEmpty(asset.Description))
{
MessageBox.Show("Name/Description can't be empty!");
return;
}
foreach (var texture in asset.Textures)
{
if (texture.Source == null && !texture.IsProcedural)
{
MessageBox.Show("Must specify texture source, its currently blank");
return;
}
}
var materialPath = Path.Combine(Properties.Settings.Default.ImportedAssetsPath, "Materials");
var outputName = Path.Combine(materialPath, Path.ChangeExtension(asset.Name, "mat"));
if (!Directory.Exists(materialPath))
{
Directory.CreateDirectory(materialPath);
}
asset.ImportedFilename = Path.GetFullPath(outputName);
if (!InEditMode)
{
if (File.Exists(asset.ImportedFilename))
{
MessageBox.Show("An imported material with the same name already exists, stopping");
return;
}
}
MaterialImporter.Import(asset);
this.DialogResult = true;
this.Close();
}
private string ImportModel(Material material, MaterialImporter materialImporter)
{
try {
Log.Info($"Importing model {materialImporter}");
var vtFileName = material.VtPath.Split('\\').Last();
var productModelName = Path.GetFileNameWithoutExtension(vtFileName);
var modelFile = materialImporter.CreateModelFile(productModelName);
Log.Info($"Created {modelFile}");
materialImporter.ImportKMAT(modelFile, productModelName);
Log.Info($"Imported KMAT {modelFile}");
var pmxFile = materialImporter.CreatePMX(modelFile);
Log.Info($"Created PMX {pmxFile}");
return(pmxFile);
}
catch (ImportException importException) {
Log.Error(importException.Message);
Log.Warn($"Skipping Material {material.MaterialNbr}, there was an error during import (see logs)");
return(null);
}
}
static void Postfix(MaterialImporter __instance, ref Material __result, int i, glTFMaterial x, bool hasVertexColor)
{
__result.SetFloat("_DoubleSided", x.doubleSided ? 0 : 2);
__result.SetFloat("_Cutout", x.alphaCutoff);
if (x.pbrMetallicRoughness != null)
{
if (x.pbrMetallicRoughness.baseColorFactor != null && x.pbrMetallicRoughness.baseColorFactor.Length == 3)
{
float[] baseColorFactor2 = x.pbrMetallicRoughness.baseColorFactor;
var max = baseColorFactor2.Max();
var rate = Mathf.Min(0.688f / max, 1.0f);
__result.SetColor("_MainColor", new Color(baseColorFactor2[0] * rate, baseColorFactor2[1] * rate, baseColorFactor2[2] * rate));
}
else if (x.pbrMetallicRoughness.baseColorFactor != null && x.pbrMetallicRoughness.baseColorFactor.Length == 4)
{
float[] baseColorFactor2 = x.pbrMetallicRoughness.baseColorFactor;
var facotrs = new float[] { baseColorFactor2[0], baseColorFactor2[1], baseColorFactor2[2] };
var max = facotrs.Max();
var rate = Mathf.Min(0.688f / max, 1.0f);
__result.SetColor("_MainColor", new Color(baseColorFactor2[0] * rate, baseColorFactor2[1] * rate, baseColorFactor2[2] * rate, baseColorFactor2[3]));
}
}
}
public static bool UpdateAsset(Object asset,
out string error, out string successMessage)
{
error = "";
successMessage = "";
if (asset is MeshAsset)
{
MeshAsset mesh = asset as MeshAsset;
var result = ImportMesh.import(mesh.SourceFilename, mesh.ImportedFilename);
if (string.IsNullOrEmpty(result))
{
successMessage = "Successfully updated mesh: " + mesh.Name;
mesh.LastUpdated = DateTime.Now;
AssetMetadata.createMeshMetadata(mesh);
return(true);
}
}
else if (asset is TextureAsset)
{
TextureAsset texture = asset as TextureAsset;
var result = ImportTexture.import(texture.Format, texture.ChannelMappings, texture.ImportedFilename);
if (string.IsNullOrEmpty(result))
{
successMessage = "Successfully updated texture: " + texture.Name;
texture.LastUpdated = DateTime.Now;
AssetMetadata.createTextureMetadata(texture);
return(true);
}
else
{
error = "ERROR: Updating texture: " + texture.Name + " failed!" + Environment.NewLine + result;
}
}
else if (asset is ShaderAsset)
{
ShaderAsset shader = asset as ShaderAsset;
var result = ImportShader.import(shader.SourceFilename, shader.ImportedFilename);
if (string.IsNullOrEmpty(result))
{
successMessage = "Successfully updated shader: " + shader.Name;
shader.LastUpdated = DateTime.Now;
AssetMetadata.createShaderMetadata(shader);
return(true);
}
else
{
error = "ERROR: Updating shader: " + shader.Name + " failed!" + Environment.NewLine + result;
}
}
else if (asset is MaterialAsset)
{
MaterialAsset material = asset as MaterialAsset;
var result = MaterialImporter.Import(material);
if (result)
{
successMessage = "Successfully updated material: " + material.Name;
material.LastUpdated = DateTime.Now;
AssetMetadata.createMaterialMetadata(material);
return(true);
}
else
{
error = "ERROR: Updating material: " + material.Name + " failed!" + Environment.NewLine;
}
}
else if (asset is StateGroupAsset)
{
var stateGroup = asset as StateGroupAsset;
var result = StateGroupImporter.Import(stateGroup);
if (result)
{
successMessage = "Successfully updated state group: " + stateGroup.Name;
stateGroup.LastUpdated = DateTime.Now;
AssetMetadata.createStateGroupMetadata(stateGroup);
return(true);
}
else
{
error = "ERROR: Updating state group: " + stateGroup.Name + " failed!" + Environment.NewLine + result;
}
}
return(false);
}
private IEnumerable <ImportedKMATInfo> ImportKMATs(List <Material> materials, MaterialImporter materialImporter)
{
foreach (var material in materials)
{
string pmxFile = null;
try {
pmxFile = ImportModel(material, materialImporter);
}
catch (ImportException importException) {
Log.Error(importException.Message);
Log.Warn($"Skipping Material {material.MaterialNbr}, there was an error during import (see logs)");
}
if (pmxFile != null)
{
yield return(new ImportedKMATInfo(pmxFile, material.MaterialNbr));
}
}
}
