public static bool PrepareCheckBox(CheckBox checkBox, IINode node, string propertyName, int defaultState = 0)
{
var state = node.GetBoolProperty(propertyName, defaultState);
if (checkBox.CheckState == CheckState.Indeterminate)
{
checkBox.CheckState = state ? CheckState.Checked : CheckState.Unchecked;
}
else
{
if (checkBox.ThreeState)
{
if (!state && checkBox.CheckState == CheckState.Checked ||
state && checkBox.CheckState == CheckState.Unchecked)
{
checkBox.CheckState = CheckState.Indeterminate;
return(true);
}
}
else
{
checkBox.CheckState = state ? CheckState.Checked : CheckState.Unchecked;
return(true);
}
}
return(false);
}
private BabylonShadowGenerator ExportShadowGenerator(IINode lightNode, BabylonScene babylonScene)
{
var maxLight = (lightNode.ObjectRef as ILightObject);
var babylonShadowGenerator = new BabylonShadowGenerator();
RaiseMessage("Exporting shadow map", 2);
babylonShadowGenerator.lightId = lightNode.GetGuid().ToString();
babylonShadowGenerator.mapSize = maxLight.GetMapSize(0, Tools.Forever);
babylonShadowGenerator.bias = lightNode.GetFloatProperty("babylonjs_shadows_bias", 0.00005f);
babylonShadowGenerator.forceBackFacesOnly = lightNode.GetBoolProperty("babylonjs_forcebackfaces");
var shadowsType = lightNode.GetStringProperty("babylonjs_shadows_type", "Blurred Variance");
switch (shadowsType)
{
case "Hard shadows":
break;
case "Poisson Sampling":
babylonShadowGenerator.usePoissonSampling = true;
break;
case "Variance":
babylonShadowGenerator.useVarianceShadowMap = true;
break;
case"Blurred Variance":
babylonShadowGenerator.useBlurVarianceShadowMap = true;
babylonShadowGenerator.blurScale = lightNode.GetFloatProperty("babylonjs_shadows_blurScale", 2);
babylonShadowGenerator.blurBoxOffset = lightNode.GetFloatProperty("babylonjs_shadows_blurBoxOffset", 1);
break;
}
var list = new List<string>();
var inclusion = maxLight.ExclList.TestFlag(1); //NT_INCLUDE
var checkExclusionList = maxLight.ExclList.TestFlag(4); //NT_AFFECT_SHADOWCAST
foreach (var meshNode in Loader.Core.RootNode.NodesListBySuperClass(SClass_ID.Geomobject))
{
#if MAX2017
if (meshNode.CastShadows)
#else
if (meshNode.CastShadows == 1)
#endif
{
var inList = maxLight.ExclList.FindNode(meshNode) != -1;
if (!checkExclusionList || (inList && inclusion) || (!inList && !inclusion))
{
list.Add(meshNode.GetGuid().ToString());
}
}
}
babylonShadowGenerator.renderList = list.ToArray();
babylonScene.ShadowGeneratorsList.Add(babylonShadowGenerator);
return babylonShadowGenerator;
}
private BabylonShadowGenerator ExportShadowGenerator(IINode lightNode, BabylonScene babylonScene)
{
var maxLight = (lightNode.ObjectRef as ILightObject);
var babylonShadowGenerator = new BabylonShadowGenerator();
RaiseMessage("Exporting shadow map", 2);
babylonShadowGenerator.lightId = lightNode.GetGuid().ToString();
babylonShadowGenerator.mapSize = maxLight.GetMapSize(0, Tools.Forever);
babylonShadowGenerator.bias = lightNode.GetFloatProperty("babylonjs_shadows_bias", 0.00005f);
babylonShadowGenerator.forceBackFacesOnly = lightNode.GetBoolProperty("babylonjs_forcebackfaces");
var shadowsType = lightNode.GetStringProperty("babylonjs_shadows_type", "Blurred Variance");
switch (shadowsType)
{
case "Hard shadows":
break;
case "Poisson Sampling":
babylonShadowGenerator.usePoissonSampling = true;
break;
case "Variance":
babylonShadowGenerator.useVarianceShadowMap = true;
break;
case "Blurred Variance":
babylonShadowGenerator.useBlurVarianceShadowMap = true;
babylonShadowGenerator.blurScale = lightNode.GetFloatProperty("babylonjs_shadows_blurScale", 2);
babylonShadowGenerator.blurBoxOffset = lightNode.GetFloatProperty("babylonjs_shadows_blurBoxOffset", 1);
break;
}
var list = new List <string>();
var inclusion = maxLight.ExclList.TestFlag(1); //NT_INCLUDE
var checkExclusionList = maxLight.ExclList.TestFlag(4); //NT_AFFECT_SHADOWCAST
foreach (var meshNode in Loader.Core.RootNode.NodesListBySuperClass(SClass_ID.Geomobject))
{
if (meshNode.CastShadows == 1)
{
var inList = maxLight.ExclList.FindNode(meshNode) != -1;
if (!checkExclusionList || (inList && inclusion) || (!inList && !inclusion))
{
list.Add(meshNode.GetGuid().ToString());
}
}
}
babylonShadowGenerator.renderList = list.ToArray();
babylonScene.ShadowGeneratorsList.Add(babylonShadowGenerator);
return(babylonShadowGenerator);
}
public static bool IsBabylonContainerHelper(this IINode node)
{
//to keep retrocompatibility
if (node.Name == "BabylonAnimationHelper")
{
node.Name = $"BabylonContainerHelper_{Random.Next(0, 99999)}";
node.SetUserPropBool("babylonjs_ContainerHelper", true);
}
return(node.GetBoolProperty("babylonjs_ContainerHelper", 0));
}
private void ExportCamera(IINode cameraNode, BabylonScene babylonScene)
{
if (cameraNode.GetBoolProperty("babylonjs_noexport"))
{
return;
}
var maxCamera = (cameraNode.ObjectRef as ICameraObject);
var babylonCamera = new BabylonCamera();
RaiseMessage(cameraNode.Name, 1);
babylonCamera.name = cameraNode.Name;
babylonCamera.id = cameraNode.GetGuid().ToString();
if (cameraNode.HasParent())
{
babylonCamera.parentId = cameraNode.ParentNode.GetGuid().ToString();
}
babylonCamera.fov = Tools.ConvertFov(maxCamera.GetFOV(0, Tools.Forever));
babylonCamera.minZ = maxCamera.GetEnvRange(0, 0, Tools.Forever);
babylonCamera.maxZ = maxCamera.GetEnvRange(0, 1, Tools.Forever);
if (babylonCamera.minZ == 0.0f)
{
babylonCamera.minZ = 0.1f;
}
// Control
babylonCamera.speed = cameraNode.GetFloatProperty("babylonjs_speed", 1.0f);
babylonCamera.inertia = cameraNode.GetFloatProperty("babylonjs_inertia", 0.9f);
// Collisions
babylonCamera.checkCollisions = cameraNode.GetBoolProperty("babylonjs_checkcollisions");
babylonCamera.applyGravity = cameraNode.GetBoolProperty("babylonjs_applygravity");
babylonCamera.ellipsoid = cameraNode.GetVector3Property("babylonjs_ellipsoid");
// Position
var wm = cameraNode.GetWorldMatrix(0, cameraNode.HasParent());
var position = wm.Trans;
babylonCamera.position = position.ToArraySwitched();
// Target
var target = cameraNode.Target;
if (target != null)
{
babylonCamera.lockedTargetId = target.GetGuid().ToString();
}
else
{
var dir = wm.GetRow(2).MultiplyBy(-1);
babylonCamera.target = position.Add(dir).ToArraySwitched();
}
// Animations
var animations = new List<BabylonAnimation>();
if (!ExportVector3Controller(cameraNode.TMController.PositionController, "position", animations))
{
ExportVector3Animation("position", animations, key =>
{
var worldMatrix = cameraNode.GetWorldMatrix(key, cameraNode.HasParent());
return worldMatrix.Trans.ToArraySwitched();
});
}
ExportFloatAnimation("fov", animations, key => new[] {Tools.ConvertFov(maxCamera.GetFOV(key, Tools.Forever))});
babylonCamera.animations = animations.ToArray();
if (cameraNode.GetBoolProperty("babylonjs_autoanimate"))
{
babylonCamera.autoAnimate = true;
babylonCamera.autoAnimateFrom = (int)cameraNode.GetFloatProperty("babylonjs_autoanimate_from");
babylonCamera.autoAnimateTo = (int)cameraNode.GetFloatProperty("babylonjs_autoanimate_to");
babylonCamera.autoAnimateLoop = cameraNode.GetBoolProperty("babylonjs_autoanimateloop");
}
babylonScene.CamerasList.Add(babylonCamera);
}
public static bool PrepareCheckBox(CheckBox checkBox, IINode node, string propertyName, int defaultState = 0)
{
var state = node.GetBoolProperty(propertyName, defaultState);
if (checkBox.CheckState == CheckState.Indeterminate)
{
checkBox.CheckState = state ? CheckState.Checked : CheckState.Unchecked;
}
else
{
if (checkBox.ThreeState)
{
if (!state && checkBox.CheckState == CheckState.Checked ||
state && checkBox.CheckState == CheckState.Unchecked)
{
checkBox.CheckState = CheckState.Indeterminate;
return true;
}
}
else
{
checkBox.CheckState = state ? CheckState.Checked : CheckState.Unchecked;
return true;
}
}
return false;
}
public static bool IsMarkedAsObjectToBakeAnimation(this IINode node)
{
return(node.GetBoolProperty("babylonjs_BakeAnimation", 0));
}
public static bool IsMarkedAsNotFlattenable(this IINode node)
{
return(node.GetBoolProperty("babylonjs_DoNotFlatten"));
}
public static bool IsBabylonAnimationHelper(this IINode node)
{
return(node.GetBoolProperty("babylonjs_AnimationHelper", 0));
}
private void ExportLight(IINode lightNode, BabylonScene babylonScene)
{
if (lightNode.GetBoolProperty("babylonjs_noexport"))
{
return;
}
var maxLight = (lightNode.ObjectRef as ILightObject);
var babylonLight = new BabylonLight();
RaiseMessage(lightNode.Name, 1);
babylonLight.name = lightNode.Name;
babylonLight.id = lightNode.GetGuid().ToString();
// Type
var lightState = Loader.Global.LightState.Create();
maxLight.EvalLightState(0, Tools.Forever, lightState);
var directionScale = -1;
switch (lightState.Type)
{
case LightType.OmniLgt:
babylonLight.type = 0;
break;
case LightType.SpotLgt:
babylonLight.type = 2;
babylonLight.angle = (float)(maxLight.GetFallsize(0, Tools.Forever) * Math.PI / 180.0f);
babylonLight.exponent = 1;
break;
case LightType.DirectLgt:
babylonLight.type = 1;
break;
case LightType.AmbientLgt:
babylonLight.type = 3;
babylonLight.groundColor = new float[] { 0, 0, 0 };
directionScale = 1;
break;
}
// Shadows
if (maxLight.ShadowMethod == 1)
{
if (lightState.Type == LightType.DirectLgt)
{
ExportShadowGenerator(lightNode, babylonScene);
}
else
{
RaiseWarning("Shadows maps are only supported for directional lights", 2);
}
}
// Position
var wm = lightNode.GetWorldMatrix(0, false);
var position = wm.Trans;
babylonLight.position = position.ToArraySwitched();
// Direction
var target = lightNode.Target;
if (target != null)
{
var targetWm = target.GetObjTMBeforeWSM(0, Tools.Forever);
var targetPosition = targetWm.Trans;
var direction = targetPosition.Subtract(position);
babylonLight.direction = direction.ToArraySwitched();
}
else
{
var dir = wm.GetRow(2).MultiplyBy(directionScale);
babylonLight.direction = dir.ToArraySwitched();
}
// Exclusion
var maxScene = Loader.Core.RootNode;
var inclusion = maxLight.ExclList.TestFlag(1); //NT_INCLUDE
var checkExclusionList = maxLight.ExclList.TestFlag(2); //NT_AFFECT_ILLUM
if (checkExclusionList)
{
var excllist = new List<string>();
var incllist = new List<string>();
foreach (var meshNode in maxScene.NodesListBySuperClass(SClass_ID.Geomobject))
{
if (meshNode.CastShadows == 1)
{
var inList = maxLight.ExclList.FindNode(meshNode) != -1;
if (inList)
{
if (inclusion)
{
incllist.Add(meshNode.GetGuid().ToString());
}
else
{
excllist.Add(meshNode.GetGuid().ToString());
}
}
}
}
babylonLight.includedOnlyMeshesIds = incllist.ToArray();
babylonLight.excludedMeshesIds = excllist.ToArray();
}
// Other fields
babylonLight.intensity = maxLight.GetIntensity(0, Tools.Forever);
babylonLight.diffuse = lightState.AffectDiffuse ? maxLight.GetRGBColor(0, Tools.Forever).ToArray() : new float[] { 0, 0, 0 };
babylonLight.specular = lightState.AffectDiffuse ? maxLight.GetRGBColor(0, Tools.Forever).ToArray() : new float[] { 0, 0, 0 };
if (maxLight.UseAtten)
{
babylonLight.range = maxLight.GetAtten(0, 1, Tools.Forever);
}
// Animations
var animations = new List<BabylonAnimation>();
if (!ExportVector3Controller(lightNode.TMController.PositionController, "position", animations))
{
ExportVector3Animation("position", animations, key =>
{
var worldMatrix = lightNode.GetWorldMatrix(key, lightNode.HasParent());
return worldMatrix.Trans.ToArraySwitched();
});
}
ExportVector3Animation("direction", animations, key =>
{
var targetNode = lightNode.Target;
if (targetNode != null)
{
var targetWm = target.GetObjTMBeforeWSM(0, Tools.Forever);
var targetPosition = targetWm.Trans;
var direction = targetPosition.Subtract(position);
return direction.ToArraySwitched();
}
var dir = wm.GetRow(2).MultiplyBy(directionScale);
return dir.ToArraySwitched();
});
ExportFloatAnimation("intensity", animations, key => new[] { maxLight.GetIntensity(key, Tools.Forever) });
babylonLight.animations = animations.ToArray();
if (lightNode.GetBoolProperty("babylonjs_autoanimate"))
{
babylonLight.autoAnimate = true;
babylonLight.autoAnimateFrom = (int)lightNode.GetFloatProperty("babylonjs_autoanimate_from");
babylonLight.autoAnimateTo = (int)lightNode.GetFloatProperty("babylonjs_autoanimate_to");
babylonLight.autoAnimateLoop = lightNode.GetBoolProperty("babylonjs_autoanimateloop");
}
babylonScene.LightsList.Add(babylonLight);
}
private void ExportCamera(IINode cameraNode, BabylonScene babylonScene)
{
if (cameraNode.GetBoolProperty("babylonjs_noexport"))
{
return;
}
var maxCamera = (cameraNode.ObjectRef as ICameraObject);
var babylonCamera = new BabylonCamera();
RaiseMessage(cameraNode.Name, 1);
babylonCamera.name = cameraNode.Name;
babylonCamera.id = cameraNode.GetGuid().ToString();
if (cameraNode.HasParent())
{
babylonCamera.parentId = cameraNode.ParentNode.GetGuid().ToString();
}
babylonCamera.fov = Tools.ConvertFov(maxCamera.GetFOV(0, Tools.Forever));
babylonCamera.minZ = maxCamera.GetEnvRange(0, 0, Tools.Forever);
babylonCamera.maxZ = maxCamera.GetEnvRange(0, 1, Tools.Forever);
if (babylonCamera.minZ == 0.0f)
{
babylonCamera.minZ = 0.1f;
}
// Control
babylonCamera.speed = cameraNode.GetFloatProperty("babylonjs_speed", 1.0f);
babylonCamera.inertia = cameraNode.GetFloatProperty("babylonjs_inertia", 0.9f);
// Collisions
babylonCamera.checkCollisions = cameraNode.GetBoolProperty("babylonjs_checkcollisions");
babylonCamera.applyGravity = cameraNode.GetBoolProperty("babylonjs_applygravity");
babylonCamera.ellipsoid = cameraNode.GetVector3Property("babylonjs_ellipsoid");
// Position
var wm = cameraNode.GetWorldMatrix(0, cameraNode.HasParent());
var position = wm.Trans;
babylonCamera.position = position.ToArraySwitched();
// Target
var target = cameraNode.Target;
if (target != null)
{
babylonCamera.lockedTargetId = target.GetGuid().ToString();
}
else
{
var dir = wm.GetRow(2).MultiplyBy(-1);
babylonCamera.target = position.Add(dir).ToArraySwitched();
}
// Animations
var animations = new List <BabylonAnimation>();
if (!ExportVector3Controller(cameraNode.TMController.PositionController, "position", animations))
{
ExportVector3Animation("position", animations, key =>
{
var worldMatrix = cameraNode.GetWorldMatrix(key, cameraNode.HasParent());
return(worldMatrix.Trans.ToArraySwitched());
});
}
ExportFloatAnimation("fov", animations, key => new[] { Tools.ConvertFov(maxCamera.GetFOV(key, Tools.Forever)) });
babylonCamera.animations = animations.ToArray();
if (cameraNode.GetBoolProperty("babylonjs_autoanimate"))
{
babylonCamera.autoAnimate = true;
babylonCamera.autoAnimateFrom = (int)cameraNode.GetFloatProperty("babylonjs_autoanimate_from");
babylonCamera.autoAnimateTo = (int)cameraNode.GetFloatProperty("babylonjs_autoanimate_to");
babylonCamera.autoAnimateLoop = cameraNode.GetBoolProperty("babylonjs_autoanimateloop");
}
babylonScene.CamerasList.Add(babylonCamera);
}
private void ExportMesh(IINode meshNode, BabylonScene babylonScene)
{
if (meshNode.GetBoolProperty("babylonjs_noexport"))
{
return;
}
if (!ExportHiddenObjects && meshNode.IsHidden(NodeHideFlags.None, false))
{
return;
}
var babylonMesh = new BabylonMesh();
int vx1, vx2, vx3;
babylonMesh.name = meshNode.Name;
babylonMesh.id = meshNode.GetGuid().ToString();
if (meshNode.HasParent())
{
babylonMesh.parentId = meshNode.ParentNode.GetGuid().ToString();
}
// Misc.
babylonMesh.isVisible = meshNode.Renderable == 1;
babylonMesh.pickable = meshNode.GetBoolProperty("babylonjs_checkpickable");
babylonMesh.receiveShadows = meshNode.RcvShadows == 1;
babylonMesh.showBoundingBox = meshNode.GetBoolProperty("babylonjs_showboundingbox");
babylonMesh.showSubMeshesBoundingBox = meshNode.GetBoolProperty("babylonjs_showsubmeshesboundingbox");
// Collisions
babylonMesh.checkCollisions = meshNode.GetBoolProperty("babylonjs_checkcollisions");
// Skin
var skin = GetSkinModifier(meshNode);
if (skin != null)
{
babylonMesh.skeletonId = skins.IndexOf(skin);
bonesCount = skin.NumBones;
}
// Position / rotation / scaling
var wm = meshNode.GetWorldMatrix(0, meshNode.HasParent());
babylonMesh.position = wm.Trans.ToArraySwitched();
var parts = Loader.Global.AffineParts.Create();
Loader.Global.DecompAffine(wm, parts);
if (exportQuaternionsInsteadOfEulers)
{
babylonMesh.rotationQuaternion = parts.Q.ToArray();
}
else
{
var rotate = new float[3];
IntPtr xPtr = Marshal.AllocHGlobal(sizeof(float));
IntPtr yPtr = Marshal.AllocHGlobal(sizeof(float));
IntPtr zPtr = Marshal.AllocHGlobal(sizeof(float));
parts.Q.GetEuler(xPtr, yPtr, zPtr);
Marshal.Copy(xPtr, rotate, 0, 1);
Marshal.Copy(yPtr, rotate, 1, 1);
Marshal.Copy(zPtr, rotate, 2, 1);
var temp = rotate[1];
rotate[0] = -rotate[0] * parts.F;
rotate[1] = -rotate[2] * parts.F;
rotate[2] = -temp * parts.F;
babylonMesh.rotation = rotate;
}
babylonMesh.scaling = parts.K.ToArraySwitched();
if (wm.Parity)
{
vx1 = 2;
vx2 = 1;
vx3 = 0;
}
else
{
vx1 = 0;
vx2 = 1;
vx3 = 2;
}
// Pivot
var pivotMatrix = Tools.Identity;
pivotMatrix.PreTranslate(meshNode.ObjOffsetPos);
Loader.Global.PreRotateMatrix(pivotMatrix, meshNode.ObjOffsetRot);
Loader.Global.ApplyScaling(pivotMatrix, meshNode.ObjOffsetScale);
babylonMesh.pivotMatrix = pivotMatrix.ToArray();
// Mesh
var objectState = meshNode.EvalWorldState(0, false);
var triObject = objectState.Obj.GetMesh();
var mesh = triObject != null ? triObject.Mesh : null;
RaiseMessage(meshNode.Name, 1);
if (mesh != null)
{
mesh.BuildNormals();
if (mesh.NumFaces < 1)
{
RaiseError(string.Format("Mesh {0} has no face", babylonMesh.name), 2);
}
if (mesh.NumVerts < 3)
{
RaiseError(string.Format("Mesh {0} has not enough vertices", babylonMesh.name), 2);
}
if (mesh.NumVerts >= 65536)
{
RaiseError(string.Format("Mesh {0} has too many vertices (more than 65535)", babylonMesh.name), 2);
}
// Material
var mtl = meshNode.Mtl;
var multiMatsCount = 1;
if (mtl != null)
{
babylonMesh.materialId = mtl.GetGuid().ToString();
if (!referencedMaterials.Contains(mtl))
{
referencedMaterials.Add(mtl);
}
multiMatsCount = Math.Max(mtl.NumSubMtls, 1);
}
babylonMesh.visibility = meshNode.GetVisibility(0, Tools.Forever);
var vertices = new List<GlobalVertex>();
var indices = new List<int>();
var matIDs = new List<int>();
var hasUV = mesh.NumTVerts > 0;
var hasUV2 = mesh.GetNumMapVerts(2) > 0;
var optimizeVertices = meshNode.GetBoolProperty("babylonjs_optimizevertices");
// Skin
IISkinContextData skinContext = null;
if (skin != null)
{
skinContext = skin.GetContextInterface(meshNode);
}
// Compute normals
VNormal[] vnorms = Tools.ComputeNormals(mesh, optimizeVertices);
List<GlobalVertex>[] verticesAlreadyExported = null;
if (optimizeVertices)
{
verticesAlreadyExported = new List<GlobalVertex>[mesh.NumVerts];
}
for (var face = 0; face < mesh.NumFaces; face++)
{
indices.Add(CreateGlobalVertex(mesh, face, vx1, vertices, hasUV, hasUV2, vnorms, verticesAlreadyExported, skinContext));
indices.Add(CreateGlobalVertex(mesh, face, vx2, vertices, hasUV, hasUV2, vnorms, verticesAlreadyExported, skinContext));
indices.Add(CreateGlobalVertex(mesh, face, vx3, vertices, hasUV, hasUV2, vnorms, verticesAlreadyExported, skinContext));
matIDs.Add(mesh.Faces[face].MatID % multiMatsCount);
CheckCancelled();
}
if (vertices.Count >= 65536)
{
RaiseError(string.Format("Mesh {0} has too many vertices: {1} (limit is 65535)", babylonMesh.name, vertices.Count), 2);
if (!optimizeVertices)
{
RaiseError("You can try to optimize your object using [Try to optimize vertices] option", 2);
}
}
RaiseMessage(string.Format("{0} vertices, {1} faces", vertices.Count, indices.Count / 3), 2);
// Buffers
babylonMesh.positions = vertices.SelectMany(v => v.Position.ToArraySwitched()).ToArray();
babylonMesh.normals = vertices.SelectMany(v => v.Normal.ToArraySwitched()).ToArray();
if (hasUV)
{
babylonMesh.uvs = vertices.SelectMany(v => v.UV.ToArray()).ToArray();
}
if (hasUV2)
{
babylonMesh.uvs2 = vertices.SelectMany(v => v.UV2.ToArray()).ToArray();
}
if (skin != null)
{
babylonMesh.matricesWeights = vertices.SelectMany(v => v.Weights.ToArray()).ToArray();
babylonMesh.matricesIndices = vertices.Select(v => v.BonesIndices).ToArray();
}
// Submeshes
var sortedIndices = new List<int>();
var subMeshes = new List<BabylonSubMesh>();
var indexStart = 0;
for (var index = 0; index < multiMatsCount; index++)
{
var subMesh = new BabylonSubMesh();
var indexCount = 0;
var minVertexIndex = int.MaxValue;
var maxVertexIndex = int.MinValue;
subMesh.indexStart = indexStart;
subMesh.materialIndex = index;
for (var face = 0; face < matIDs.Count; face++)
{
if (matIDs[face] == index)
{
var a = indices[3 * face];
var b = indices[3 * face + 1];
var c = indices[3 * face + 2];
sortedIndices.Add(a);
sortedIndices.Add(b);
sortedIndices.Add(c);
indexCount += 3;
if (a < minVertexIndex)
{
minVertexIndex = a;
}
if (b < minVertexIndex)
{
minVertexIndex = b;
}
if (c < minVertexIndex)
{
minVertexIndex = c;
}
if (a > maxVertexIndex)
{
maxVertexIndex = a;
}
if (b > maxVertexIndex)
{
maxVertexIndex = b;
}
if (c > maxVertexIndex)
{
maxVertexIndex = c;
}
}
}
if (indexCount != 0)
{
subMesh.indexCount = indexCount;
subMesh.verticesStart = minVertexIndex;
subMesh.verticesCount = maxVertexIndex - minVertexIndex + 1;
indexStart += indexCount;
subMeshes.Add(subMesh);
}
CheckCancelled();
}
babylonMesh.subMeshes = subMeshes.ToArray();
// Buffers - Indices
babylonMesh.indices = sortedIndices.ToArray();
triObject.Dispose();
}
// Animations
var animations = new List<BabylonAnimation>();
if (!ExportVector3Controller(meshNode.TMController.PositionController, "position", animations))
{
ExportVector3Animation("position", animations, key =>
{
var worldMatrix = meshNode.GetWorldMatrix(key, meshNode.HasParent());
return worldMatrix.Trans.ToArraySwitched();
});
}
if (!ExportQuaternionController(meshNode.TMController.RotationController, "rotationQuaternion", animations))
{
ExportQuaternionAnimation("rotationQuaternion", animations, key =>
{
var worldMatrix = meshNode.GetWorldMatrix(key, meshNode.HasParent());
var affineParts = Loader.Global.AffineParts.Create();
Loader.Global.DecompAffine(worldMatrix, affineParts);
return affineParts.Q.ToArray();
});
}
if (!ExportVector3Controller(meshNode.TMController.ScaleController, "scaling", animations))
{
ExportVector3Animation("scaling", animations, key =>
{
var worldMatrix = meshNode.GetWorldMatrix(key, meshNode.HasParent());
var affineParts = Loader.Global.AffineParts.Create();
Loader.Global.DecompAffine(worldMatrix, affineParts);
return affineParts.K.ToArraySwitched();
});
}
if (!ExportFloatController(meshNode.VisController, "visibility", animations))
{
ExportFloatAnimation("visibility", animations, key => new[] { meshNode.GetVisibility(key, Tools.Forever) });
}
babylonMesh.animations = animations.ToArray();
if (meshNode.GetBoolProperty("babylonjs_autoanimate", 1))
{
babylonMesh.autoAnimate = true;
babylonMesh.autoAnimateFrom = (int)meshNode.GetFloatProperty("babylonjs_autoanimate_from");
babylonMesh.autoAnimateTo = (int)meshNode.GetFloatProperty("babylonjs_autoanimate_to", 100);
babylonMesh.autoAnimateLoop = meshNode.GetBoolProperty("babylonjs_autoanimateloop", 1);
}
babylonScene.MeshesList.Add(babylonMesh);
}
private void ExportLight(IINode lightNode, BabylonScene babylonScene)
{
if (lightNode.GetBoolProperty("babylonjs_noexport"))
{
return;
}
var maxLight = (lightNode.ObjectRef as ILightObject);
var babylonLight = new BabylonLight();
RaiseMessage(lightNode.Name, 1);
babylonLight.name = lightNode.Name;
babylonLight.id = lightNode.GetGuid().ToString();
// Type
var lightState = Loader.Global.LightState.Create();
maxLight.EvalLightState(0, Tools.Forever, lightState);
var directionScale = -1;
switch (lightState.Type)
{
case LightType.OmniLgt:
babylonLight.type = 0;
break;
case LightType.SpotLgt:
babylonLight.type = 2;
babylonLight.angle = (float)(maxLight.GetFallsize(0, Tools.Forever) * Math.PI / 180.0f);
babylonLight.exponent = 1;
break;
case LightType.DirectLgt:
babylonLight.type = 1;
break;
case LightType.AmbientLgt:
babylonLight.type = 3;
babylonLight.groundColor = new float[] { 0, 0, 0 };
directionScale = 1;
break;
}
// Shadows
if (maxLight.ShadowMethod == 1)
{
if (lightState.Type == LightType.DirectLgt)
{
ExportShadowGenerator(lightNode, babylonScene);
}
else
{
RaiseWarning("Shadows maps are only supported for directional lights", 2);
}
}
// Position
var wm = lightNode.GetWorldMatrix(0, false);
var position = wm.Trans;
babylonLight.position = position.ToArraySwitched();
// Direction
var target = lightNode.Target;
if (target != null)
{
var targetWm = target.GetObjTMBeforeWSM(0, Tools.Forever);
var targetPosition = targetWm.Trans;
var direction = targetPosition.Subtract(position);
babylonLight.direction = direction.ToArraySwitched();
}
else
{
var dir = wm.GetRow(2).MultiplyBy(directionScale);
babylonLight.direction = dir.ToArraySwitched();
}
// Exclusion
var maxScene = Loader.Core.RootNode;
var inclusion = maxLight.ExclList.TestFlag(1); //NT_INCLUDE
var checkExclusionList = maxLight.ExclList.TestFlag(2); //NT_AFFECT_ILLUM
if (checkExclusionList)
{
var excllist = new List <string>();
var incllist = new List <string>();
foreach (var meshNode in maxScene.NodesListBySuperClass(SClass_ID.Geomobject))
{
if (meshNode.CastShadows == 1)
{
var inList = maxLight.ExclList.FindNode(meshNode) != -1;
if (inList)
{
if (inclusion)
{
incllist.Add(meshNode.GetGuid().ToString());
}
else
{
excllist.Add(meshNode.GetGuid().ToString());
}
}
}
}
babylonLight.includedOnlyMeshesIds = incllist.ToArray();
babylonLight.excludedMeshesIds = excllist.ToArray();
}
// Other fields
babylonLight.intensity = maxLight.GetIntensity(0, Tools.Forever);
babylonLight.diffuse = lightState.AffectDiffuse ? maxLight.GetRGBColor(0, Tools.Forever).ToArray() : new float[] { 0, 0, 0 };
babylonLight.specular = lightState.AffectDiffuse ? maxLight.GetRGBColor(0, Tools.Forever).ToArray() : new float[] { 0, 0, 0 };
if (maxLight.UseAtten)
{
babylonLight.range = maxLight.GetAtten(0, 1, Tools.Forever);
}
// Animations
var animations = new List <BabylonAnimation>();
if (!ExportVector3Controller(lightNode.TMController.PositionController, "position", animations))
{
ExportVector3Animation("position", animations, key =>
{
var worldMatrix = lightNode.GetWorldMatrix(key, lightNode.HasParent());
return(worldMatrix.Trans.ToArraySwitched());
});
}
ExportVector3Animation("direction", animations, key =>
{
var targetNode = lightNode.Target;
if (targetNode != null)
{
var targetWm = target.GetObjTMBeforeWSM(0, Tools.Forever);
var targetPosition = targetWm.Trans;
var direction = targetPosition.Subtract(position);
return(direction.ToArraySwitched());
}
var dir = wm.GetRow(2).MultiplyBy(directionScale);
return(dir.ToArraySwitched());
});
ExportFloatAnimation("intensity", animations, key => new[] { maxLight.GetIntensity(key, Tools.Forever) });
babylonLight.animations = animations.ToArray();
if (lightNode.GetBoolProperty("babylonjs_autoanimate"))
{
babylonLight.autoAnimate = true;
babylonLight.autoAnimateFrom = (int)lightNode.GetFloatProperty("babylonjs_autoanimate_from");
babylonLight.autoAnimateTo = (int)lightNode.GetFloatProperty("babylonjs_autoanimate_to");
babylonLight.autoAnimateLoop = lightNode.GetBoolProperty("babylonjs_autoanimateloop");
}
babylonScene.LightsList.Add(babylonLight);
}
private void ExportMesh(IINode meshNode, BabylonScene babylonScene)
{
if (meshNode.IsInstance())
{
return;
}
if (meshNode.GetBoolProperty("babylonjs_noexport"))
{
return;
}
if (!ExportHiddenObjects && meshNode.IsHidden(NodeHideFlags.None, false))
{
return;
}
var babylonMesh = new BabylonMesh();
int vx1, vx2, vx3;
babylonMesh.name = meshNode.Name;
babylonMesh.id = meshNode.GetGuid().ToString();
if (meshNode.HasParent())
{
babylonMesh.parentId = meshNode.ParentNode.GetGuid().ToString();
}
// Misc.
babylonMesh.isVisible = meshNode.Renderable == 1;
babylonMesh.pickable = meshNode.GetBoolProperty("babylonjs_checkpickable");
babylonMesh.receiveShadows = meshNode.RcvShadows == 1;
babylonMesh.showBoundingBox = meshNode.GetBoolProperty("babylonjs_showboundingbox");
babylonMesh.showSubMeshesBoundingBox = meshNode.GetBoolProperty("babylonjs_showsubmeshesboundingbox");
// Collisions
babylonMesh.checkCollisions = meshNode.GetBoolProperty("babylonjs_checkcollisions");
// Skin
var skin = GetSkinModifier(meshNode);
if (skin != null)
{
babylonMesh.skeletonId = skins.IndexOf(skin);
bonesCount = skin.NumBones;
}
// Position / rotation / scaling
var wm = Tools.ExtractCoordinates(meshNode, babylonMesh, exportQuaternionsInsteadOfEulers);
if (wm.Parity)
{
vx1 = 2;
vx2 = 1;
vx3 = 0;
}
else
{
vx1 = 0;
vx2 = 1;
vx3 = 2;
}
// Pivot
var pivotMatrix = Tools.Identity;
pivotMatrix.PreTranslate(meshNode.ObjOffsetPos);
Loader.Global.PreRotateMatrix(pivotMatrix, meshNode.ObjOffsetRot);
Loader.Global.ApplyScaling(pivotMatrix, meshNode.ObjOffsetScale);
babylonMesh.pivotMatrix = pivotMatrix.ToArray();
// Mesh
var objectState = meshNode.EvalWorldState(0, false);
var triObject = objectState.Obj.GetMesh();
var mesh = triObject != null ? triObject.Mesh : null;
RaiseMessage(meshNode.Name, 1);
if (mesh != null)
{
mesh.BuildNormals();
if (mesh.NumFaces < 1)
{
RaiseError(string.Format("Mesh {0} has no face", babylonMesh.name), 2);
}
if (mesh.NumVerts < 3)
{
RaiseError(string.Format("Mesh {0} has not enough vertices", babylonMesh.name), 2);
}
if (mesh.NumVerts >= 65536)
{
RaiseError(string.Format("Mesh {0} has too many vertices (more than 65535)", babylonMesh.name), 2);
}
// Material
var mtl = meshNode.Mtl;
var multiMatsCount = 1;
if (mtl != null)
{
babylonMesh.materialId = mtl.GetGuid().ToString();
if (!referencedMaterials.Contains(mtl))
{
referencedMaterials.Add(mtl);
}
multiMatsCount = Math.Max(mtl.NumSubMtls, 1);
}
babylonMesh.visibility = meshNode.GetVisibility(0, Tools.Forever);
var vertices = new List <GlobalVertex>();
var indices = new List <int>();
var matIDs = new List <int>();
var hasUV = mesh.NumTVerts > 0;
var hasUV2 = mesh.GetNumMapVerts(2) > 0;
var optimizeVertices = meshNode.GetBoolProperty("babylonjs_optimizevertices");
// Skin
IISkinContextData skinContext = null;
if (skin != null)
{
skinContext = skin.GetContextInterface(meshNode);
}
// Compute normals
VNormal[] vnorms = Tools.ComputeNormals(mesh, optimizeVertices);
List <GlobalVertex>[] verticesAlreadyExported = null;
if (optimizeVertices)
{
verticesAlreadyExported = new List <GlobalVertex> [mesh.NumVerts];
}
for (var face = 0; face < mesh.NumFaces; face++)
{
indices.Add(CreateGlobalVertex(mesh, face, vx1, vertices, hasUV, hasUV2, vnorms, verticesAlreadyExported, skinContext));
indices.Add(CreateGlobalVertex(mesh, face, vx2, vertices, hasUV, hasUV2, vnorms, verticesAlreadyExported, skinContext));
indices.Add(CreateGlobalVertex(mesh, face, vx3, vertices, hasUV, hasUV2, vnorms, verticesAlreadyExported, skinContext));
matIDs.Add(mesh.Faces[face].MatID % multiMatsCount);
CheckCancelled();
}
if (vertices.Count >= 65536)
{
RaiseError(string.Format("Mesh {0} has too many vertices: {1} (limit is 65535)", babylonMesh.name, vertices.Count), 2);
if (!optimizeVertices)
{
RaiseError("You can try to optimize your object using [Try to optimize vertices] option", 2);
}
}
RaiseMessage(string.Format("{0} vertices, {1} faces", vertices.Count, indices.Count / 3), 2);
// Buffers
babylonMesh.positions = vertices.SelectMany(v => v.Position.ToArraySwitched()).ToArray();
babylonMesh.normals = vertices.SelectMany(v => v.Normal.ToArraySwitched()).ToArray();
if (hasUV)
{
babylonMesh.uvs = vertices.SelectMany(v => v.UV.ToArray()).ToArray();
}
if (hasUV2)
{
babylonMesh.uvs2 = vertices.SelectMany(v => v.UV2.ToArray()).ToArray();
}
if (skin != null)
{
babylonMesh.matricesWeights = vertices.SelectMany(v => v.Weights.ToArray()).ToArray();
babylonMesh.matricesIndices = vertices.Select(v => v.BonesIndices).ToArray();
}
// Submeshes
var sortedIndices = new List <int>();
var subMeshes = new List <BabylonSubMesh>();
var indexStart = 0;
for (var index = 0; index < multiMatsCount; index++)
{
var subMesh = new BabylonSubMesh();
var indexCount = 0;
var minVertexIndex = int.MaxValue;
var maxVertexIndex = int.MinValue;
subMesh.indexStart = indexStart;
subMesh.materialIndex = index;
for (var face = 0; face < matIDs.Count; face++)
{
if (matIDs[face] == index)
{
var a = indices[3 * face];
var b = indices[3 * face + 1];
var c = indices[3 * face + 2];
sortedIndices.Add(a);
sortedIndices.Add(b);
sortedIndices.Add(c);
indexCount += 3;
if (a < minVertexIndex)
{
minVertexIndex = a;
}
if (b < minVertexIndex)
{
minVertexIndex = b;
}
if (c < minVertexIndex)
{
minVertexIndex = c;
}
if (a > maxVertexIndex)
{
maxVertexIndex = a;
}
if (b > maxVertexIndex)
{
maxVertexIndex = b;
}
if (c > maxVertexIndex)
{
maxVertexIndex = c;
}
}
}
if (indexCount != 0)
{
subMesh.indexCount = indexCount;
subMesh.verticesStart = minVertexIndex;
subMesh.verticesCount = maxVertexIndex - minVertexIndex + 1;
indexStart += indexCount;
subMeshes.Add(subMesh);
}
CheckCancelled();
}
babylonMesh.subMeshes = subMeshes.ToArray();
// Buffers - Indices
babylonMesh.indices = sortedIndices.ToArray();
triObject.Dispose();
}
// Instances
var tabs = Loader.Global.NodeTab.Create();
Loader.Global.IInstanceMgr.InstanceMgr.GetInstances(meshNode, tabs);
var instances = new List <BabylonAbstractMesh>();
for (var index = 0; index < tabs.Count; index++)
{
var indexer = new IntPtr(index);
var tab = tabs[indexer];
Marshal.FreeHGlobal(indexer);
if (meshNode.GetGuid() == tab.GetGuid())
{
continue;
}
tab.MarkAsInstance();
var instance = new BabylonAbstractMesh {
name = tab.Name
};
Tools.ExtractCoordinates(tab, instance, exportQuaternionsInsteadOfEulers);
var instanceAnimations = new List <BabylonAnimation>();
GenerateCoordinatesAnimations(tab, instanceAnimations);
instance.animations = instanceAnimations.ToArray();
instances.Add(instance);
}
babylonMesh.instances = instances.ToArray();
// Animations
var animations = new List <BabylonAnimation>();
GenerateCoordinatesAnimations(meshNode, animations);
if (!ExportFloatController(meshNode.VisController, "visibility", animations))
{
ExportFloatAnimation("visibility", animations, key => new[] { meshNode.GetVisibility(key, Tools.Forever) });
}
babylonMesh.animations = animations.ToArray();
if (meshNode.GetBoolProperty("babylonjs_autoanimate", 1))
{
babylonMesh.autoAnimate = true;
babylonMesh.autoAnimateFrom = (int)meshNode.GetFloatProperty("babylonjs_autoanimate_from");
babylonMesh.autoAnimateTo = (int)meshNode.GetFloatProperty("babylonjs_autoanimate_to", 100);
babylonMesh.autoAnimateLoop = meshNode.GetBoolProperty("babylonjs_autoanimateloop", 1);
}
babylonScene.MeshesList.Add(babylonMesh);
}