private IIGameMaterial GetBakedMaterialFromShellMaterial(IIGameMaterial materialNode)
{
if (isShellMaterial(materialNode))
{
// Shell Material Parameters
// Original Material not exported => only for the offline rendering in 3DS Max
// Baked Material => used for the export
IMtl bakedMtl = materialNode.IPropertyContainer.GetProperty(1).MaxParamBlock2.GetMtl(3, 0, 0);
if (bakedMtl != null)
{
Guid guid = bakedMtl.GetGuid();
for (int indexSubMaterial = 0; indexSubMaterial < materialNode.SubMaterialCount; indexSubMaterial++)
{
IIGameMaterial subMaterialNode = materialNode.GetSubMaterial(indexSubMaterial);
if (guid.Equals(subMaterialNode.MaxMaterial.GetGuid()))
{
return(subMaterialNode);
}
}
}
}
return(null);
}
public void AddMaterial(IMtl material)
{
if (material == null)
{
return;
}
if (!FlightSimMaterialUtilities.IsFlightSimMaterial(material))
{
return;
}
Guid matGuid = material.GetGuid();
ListViewItem item = FillMaterialItem(material, matGuid);
if (item != null)
{
previousMaterialMap.Add(matGuid, item);
}
}
public void RemoveMaterialFromSelection(IMtl material)
{
if (material == null)
{
return;
}
if (!FlightSimMaterialUtilities.IsFlightSimMaterial(material))
{
return;
}
Guid matGuid = material.GetGuid();
ListViewItem itemToRemove;
if (previousMaterialMap.TryGetValue(matGuid, out itemToRemove))
{
itemToRemove.BackColor = Color.Red;
currentMaterialMap.Remove(matGuid);
}
}
public void AddMaterialFromSelection(IMtl material)
{
if (material == null)
{
return;
}
if (!MaterialUtilities.IsMaterialAssignedInScene(material))
{
return;
}
if (!FlightSimMaterialUtilities.IsFlightSimMaterial(material))
{
return;
}
Guid matGuid = material.GetGuid();
ListViewItem item = FillMaterialItem(material, matGuid);
if (item != null)
{
currentMaterialMap.Add(matGuid, item);
item.BackColor = Color.Green;
}
}
private void ExportMaterial(IMtl materialNode, BabylonScene babylonScene)
{
var name = materialNode.Name;
var id = materialNode.GetGuid().ToString();
RaiseMessage(name, 1);
if (materialNode.NumSubMtls > 0)
{
var babylonMultimaterial = new BabylonMultiMaterial();
babylonMultimaterial.name = name;
babylonMultimaterial.id = id;
var guids = new List<string>();
for (var index = 0; index < materialNode.NumSubMtls; index++)
{
var subMat = materialNode.GetSubMtl(index);
if (subMat != null)
{
guids.Add(subMat.GetGuid().ToString());
if (!referencedMaterials.Contains(subMat))
{
referencedMaterials.Add(subMat);
ExportMaterial(subMat, babylonScene);
}
}
else
{
guids.Add(Guid.Empty.ToString());
}
}
babylonMultimaterial.materials = guids.ToArray();
babylonScene.MultiMaterialsList.Add(babylonMultimaterial);
return;
}
var babylonMaterial = new BabylonMaterial();
babylonMaterial.name = name;
babylonMaterial.id = id;
babylonMaterial.ambient = materialNode.GetAmbient(0, false).ToArray();
babylonMaterial.diffuse = materialNode.GetDiffuse(0, false).ToArray();
babylonMaterial.specular = materialNode.GetSpecular(0, false).Scale(materialNode.GetShinStr(0, false));
babylonMaterial.specularPower = materialNode.GetShininess(0, false) * 256;
babylonMaterial.emissive = materialNode.GetSelfIllumColorOn(0, false) ? materialNode.GetSelfIllumColor(0, false).ToArray() : materialNode.GetDiffuse(0, false).Scale(materialNode.GetSelfIllum(0, false));
babylonMaterial.alpha = 1.0f - materialNode.GetXParency(0, false);
var stdMat = materialNode.GetParamBlock(0).Owner as IStdMat2;
if (stdMat != null)
{
babylonMaterial.backFaceCulling = !stdMat.TwoSided;
babylonMaterial.wireframe = stdMat.Wire;
// Textures
babylonMaterial.ambientTexture = ExportTexture(stdMat, 0, babylonScene); // Ambient
babylonMaterial.diffuseTexture = ExportTexture(stdMat, 1, babylonScene); // Diffuse
babylonMaterial.specularTexture = ExportTexture(stdMat, 2, babylonScene); // Specular
babylonMaterial.emissiveTexture = ExportTexture(stdMat, 5, babylonScene); // Emissive
babylonMaterial.opacityTexture = ExportTexture(stdMat, 6, babylonScene, false, true); // Opacity
babylonMaterial.bumpTexture = ExportTexture(stdMat, 8, babylonScene); // Bump
babylonMaterial.reflectionTexture = ExportTexture(stdMat, 9, babylonScene, true); // Reflection
// Constraints
if (babylonMaterial.diffuseTexture != null)
{
babylonMaterial.diffuse = new [] { 1.0f, 1.0f, 1.0f };
}
if (babylonMaterial.emissiveTexture != null)
{
babylonMaterial.emissive = new float[]{0, 0, 0};
}
if (babylonMaterial.opacityTexture != null && babylonMaterial.diffuseTexture != null &&
babylonMaterial.diffuseTexture.name == babylonMaterial.opacityTexture.name &&
babylonMaterial.diffuseTexture.hasAlpha && !babylonMaterial.opacityTexture.getAlphaFromRGB)
{
// This is a alpha testing purpose
babylonMaterial.opacityTexture = null;
babylonMaterial.diffuseTexture.hasAlpha = true;
RaiseWarning("Opacity texture was removed because alpha from diffuse texture can be use instead", 2);
RaiseWarning("If you do not want this behavior, just set Alpha Source = None on your diffuse texture", 2);
}
}
babylonScene.MaterialsList.Add(babylonMaterial);
}
private void ExportMaterial(IMtl materialNode, BabylonScene babylonScene)
{
var name = materialNode.Name;
var id = materialNode.GetGuid().ToString();
RaiseMessage(name, 1);
if (materialNode.NumSubMtls > 0)
{
var babylonMultimaterial = new BabylonMultiMaterial {
name = name, id = id
};
var guids = new List <string>();
for (var index = 0; index < materialNode.NumSubMtls; index++)
{
var subMat = materialNode.GetSubMtl(index);
if (subMat != null)
{
guids.Add(subMat.GetGuid().ToString());
if (!referencedMaterials.Contains(subMat))
{
referencedMaterials.Add(subMat);
ExportMaterial(subMat, babylonScene);
}
}
else
{
guids.Add(Guid.Empty.ToString());
}
}
babylonMultimaterial.materials = guids.ToArray();
babylonScene.MultiMaterialsList.Add(babylonMultimaterial);
return;
}
var babylonMaterial = new BabylonMaterial
{
name = name,
id = id,
ambient = materialNode.GetAmbient(0, false).ToArray(),
diffuse = materialNode.GetDiffuse(0, false).ToArray(),
specular = materialNode.GetSpecular(0, false).Scale(materialNode.GetShinStr(0, false)),
specularPower = materialNode.GetShininess(0, false) * 256,
emissive =
materialNode.GetSelfIllumColorOn(0, false)
? materialNode.GetSelfIllumColor(0, false).ToArray()
: materialNode.GetDiffuse(0, false).Scale(materialNode.GetSelfIllum(0, false)),
alpha = 1.0f - materialNode.GetXParency(0, false)
};
var stdMat = materialNode.GetParamBlock(0).Owner as IStdMat2;
if (stdMat != null)
{
babylonMaterial.backFaceCulling = !stdMat.TwoSided;
babylonMaterial.wireframe = stdMat.Wire;
// Textures
BabylonFresnelParameters fresnelParameters;
babylonMaterial.ambientTexture = ExportTexture(stdMat, 0, out fresnelParameters, babylonScene); // Ambient
babylonMaterial.diffuseTexture = ExportTexture(stdMat, 1, out fresnelParameters, babylonScene); // Diffuse
if (fresnelParameters != null)
{
babylonMaterial.diffuseFresnelParameters = fresnelParameters;
}
babylonMaterial.specularTexture = ExportTexture(stdMat, 2, out fresnelParameters, babylonScene); // Specular
babylonMaterial.emissiveTexture = ExportTexture(stdMat, 5, out fresnelParameters, babylonScene); // Emissive
if (fresnelParameters != null)
{
babylonMaterial.emissiveFresnelParameters = fresnelParameters;
if (babylonMaterial.emissive[0] == 0 &&
babylonMaterial.emissive[1] == 0 &&
babylonMaterial.emissive[2] == 0)
{
babylonMaterial.emissive = new float[] { 1, 1, 1 };
}
}
babylonMaterial.opacityTexture = ExportTexture(stdMat, 6, out fresnelParameters, babylonScene, false, true); // Opacity
if (fresnelParameters != null)
{
babylonMaterial.opacityFresnelParameters = fresnelParameters;
}
babylonMaterial.bumpTexture = ExportTexture(stdMat, 8, out fresnelParameters, babylonScene); // Bump
babylonMaterial.reflectionTexture = ExportTexture(stdMat, 9, out fresnelParameters, babylonScene, true); // Reflection
if (fresnelParameters != null)
{
if (babylonMaterial.reflectionTexture == null)
{
RaiseWarning("Fallout cannot be used with reflection channel without a texture", 2);
}
else
{
babylonMaterial.reflectionFresnelParameters = fresnelParameters;
}
}
// Constraints
if (babylonMaterial.diffuseTexture != null)
{
babylonMaterial.diffuse = new [] { 1.0f, 1.0f, 1.0f };
}
if (babylonMaterial.emissiveTexture != null)
{
babylonMaterial.emissive = new float[] { 0, 0, 0 };
}
if (babylonMaterial.opacityTexture != null && babylonMaterial.diffuseTexture != null &&
babylonMaterial.diffuseTexture.name == babylonMaterial.opacityTexture.name &&
babylonMaterial.diffuseTexture.hasAlpha && !babylonMaterial.opacityTexture.getAlphaFromRGB)
{
// This is a alpha testing purpose
babylonMaterial.opacityTexture = null;
babylonMaterial.diffuseTexture.hasAlpha = true;
RaiseWarning("Opacity texture was removed because alpha from diffuse texture can be use instead", 2);
RaiseWarning("If you do not want this behavior, just set Alpha Source = None on your diffuse texture", 2);
}
}
babylonScene.MaterialsList.Add(babylonMaterial);
}
public void LoadFromJson(string jsonContent, bool merge = false)
{
List <string> animationPropertyNameList = Loader.Core.RootNode.GetStringArrayProperty(s_AnimationListPropertyName).ToList();
if (!merge)
{
animationPropertyNameList = new List <string>();
Clear();
}
List <AnimationGroup> animationGroupsData = JsonConvert.DeserializeObject <List <AnimationGroup> >(jsonContent);
List <Guid> nodeGuids = new List <Guid>();
List <Guid> materialsGuids = new List <Guid>();
foreach (AnimationGroup animData in animationGroupsData)
{
nodeGuids.Clear();
if (animData.AnimationGroupNodes != null)
{
string missingNodes = "";
string movedNodes = "";
foreach (AnimationGroupNode nodeData in animData.AnimationGroupNodes)
{
//check here if something changed between export\import
// a node handle is reassigned the moment the node is created
// it is no possible to have consistency at 100% sure between two file
// we need to prevent artists
IINode node = Loader.Core.GetINodeByName(nodeData.Name);
if (node == null)
{
//node is missing
missingNodes += nodeData.Name + "\n";
continue;
}
if (node.ParentNode.Name != nodeData.ParentName)
{
//node has been moved in hierarchy
movedNodes += node.Name + "\n";
continue;
}
nodeGuids.Add(node.GetGuid());
}
if (!string.IsNullOrEmpty(movedNodes))
{
//skip restoration of evaluated animation group
nodeGuids = new List <Guid>();
MessageBox.Show(string.Format("{0} has been moved in hierarchy,{1} import skipped", movedNodes, animData.Name));
}
if (!string.IsNullOrEmpty(missingNodes))
{
//skip restoration of evaluated animation group
nodeGuids = new List <Guid>();
MessageBox.Show(string.Format("{0} does not exist,{1} import skipped", missingNodes, animData.Name));
}
}
if (animData.AnimationGroupMaterials != null)
{
string missingMaterials = "";
foreach (AnimationGroupMaterial matData in animData.AnimationGroupMaterials)
{
//check here if something changed between export\import
// a material handle is reassigned the moment the node is created
// it is no possible to have consistency at 100% sure between two file
// we need to prevent artists
IMtl mtl = Tools.GetIMtlByGuid(matData.Guid);
if (mtl == null)
{
//material is missing
missingMaterials += matData.Name + "\n";
continue;
}
materialsGuids.Add(mtl.GetGuid());
}
if (!string.IsNullOrEmpty(missingMaterials))
{
//skip restoration of evaluated animation group
materialsGuids = new List <Guid>();
MessageBox.Show(string.Format("{0} does not exist,{1} import skipped", missingMaterials, animData.Name));
}
}
animData.NodeGuids = nodeGuids;
animData.MaterialGuids = materialsGuids;
string nodes = string.Join(AnimationGroup.s_PropertySeparator.ToString(), animData.NodeGuids);
string materials = string.Join(AnimationGroup.s_PropertySeparator.ToString(), animData.MaterialGuids);
string guids = string.Join(AnimationGroup.s_GUIDTypeSeparator.ToString(), nodes, materials);
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendFormat(AnimationGroup.s_PropertyFormat, animData.Name, animData.TicksStart, animData.TicksEnd, guids);
Loader.Core.RootNode.SetStringProperty(animData.SerializedId.ToString(), stringBuilder.ToString());
string id = animData.SerializedId.ToString();
if (merge)
{
//if json are merged check if the same animgroup is already in list
//and skip in that case
if (!animationPropertyNameList.Contains(id))
{
animationPropertyNameList.Add(animData.SerializedId.ToString());
}
}
else
{
animationPropertyNameList.Add(animData.SerializedId.ToString());
}
}
Loader.Core.RootNode.SetStringArrayProperty(s_AnimationListPropertyName, animationPropertyNameList);
LoadFromData(Loader.Core.RootNode);
}
private IList <BabylonAnimationGroup> ExportAnimationGroups(BabylonScene babylonScene)
{
IList <BabylonAnimationGroup> animationGroups = new List <BabylonAnimationGroup>();
// Retrieve and parse animation group data
AnimationGroupList animationList = AnimationGroupList.InitAnimationGroups(logger);
foreach (AnimationGroup animGroup in animationList)
{
logger?.RaiseMessage("Exporter.animationGroups | " + animGroup.Name, 1);
BabylonAnimationGroup animationGroup = new BabylonAnimationGroup
{
name = animGroup.Name,
from = animGroup.FrameStart,
to = animGroup.FrameEnd,
keepNonAnimated = animGroup.KeepNonAnimated,
targetedAnimations = new List <BabylonTargetedAnimation>()
};
// add animations of each nodes contained in the animGroup
foreach (Guid guid in animGroup.NodeGuids)
{
IINode maxNode = Tools.GetINodeByGuid(guid);
// node could have been deleted, silently ignore it
if (maxNode == null)
{
continue;
}
if (exportParameters.exportAsSubmodel && !maxNode.Selected)
{
continue;
}
// Helpers can be exported as dummies and as bones
string nodeId = maxNode.GetGuid().ToString();
string boneId = isGltfExported?maxNode.GetGuid().ToString(): maxNode.GetGuid().ToString() + "-bone"; // the suffix "-bone" is added in babylon export format to assure the uniqueness of IDs
// Node
BabylonNode node = null;
babylonScene.NodeMap.TryGetValue(nodeId, out node);
if (node != null)
{
if (node.animations != null && node.animations.Length != 0)
{
IList <BabylonAnimation> animations = GetSubAnimations(node, animationGroup.from, animationGroup.to);
if (!animGroup.KeepStaticAnimation)
{
RemoveStaticAnimations(ref animations);
}
foreach (BabylonAnimation animation in animations)
{
BabylonTargetedAnimation targetedAnimation = new BabylonTargetedAnimation
{
animation = animation,
targetId = nodeId
};
animationGroup.targetedAnimations.Add(targetedAnimation);
}
}
}
// bone
BabylonBone bone = null;
int index = 0;
while (index < babylonScene.SkeletonsList.Count && bone == null)
{
BabylonSkeleton skel = babylonScene.SkeletonsList[index];
bone = skel.bones.FirstOrDefault(b => b.id == boneId);
index++;
}
if (bone != null)
{
if (bone.animation != null)
{
IList <BabylonAnimation> animations = GetSubAnimations(bone, animationGroup.from, animationGroup.to);
foreach (BabylonAnimation animation in animations)
{
BabylonTargetedAnimation targetedAnimation = new BabylonTargetedAnimation
{
animation = animation,
targetId = boneId
};
animationGroup.targetedAnimations.Add(targetedAnimation);
}
}
}
}
// add animations of each nodes contained in the animGroup
foreach (Guid guid in animGroup.MaterialGuids)
{
IMtl maxMtl = Tools.GetIMtlByGuid(guid);
// mat could have been deleted, silently ignore it
if (maxMtl == null)
{
continue;
}
string matId = maxMtl.GetGuid().ToString();
// Material
BabylonMaterial material = null;
material = babylonScene.MaterialsList.FirstOrDefault(x => x.id == matId);
if (material != null)
{
if (material.animations != null && material.animations.Length != 0)
{
IList <BabylonAnimation> animations = GetSubAnimations(material, animationGroup.from, animationGroup.to);
foreach (BabylonAnimation animation in animations)
{
BabylonTargetedAnimation targetedAnimation = new BabylonTargetedAnimation
{
animation = animation,
targetId = matId
};
animationGroup.targetedAnimations.Add(targetedAnimation);
}
}
}
}
if (animationGroup.targetedAnimations.Count > 0)
{
animationGroups.Add(animationGroup);
}
}
return(animationGroups);
}