private void ConvertUnityLightToBabylon(Light light, float progress)
{
if (!light.isActiveAndEnabled || light.alreadyLightmapped)
{
return;
}
ExporterWindow.ReportProgress(progress, "Exporting light: " + light.name);
BabylonLight babylonLight = new BabylonLight
{
name = light.name,
id = GetID(light.gameObject),
parentId = GetParentID(light.transform)
};
switch (light.type)
{
case LightType.Spot:
babylonLight.type = 2;
break;
case LightType.Directional:
babylonLight.type = 1;
break;
case LightType.Point:
babylonLight.type = 0;
babylonLight.range = light.range;
break;
case LightType.Area:
// TODO
break;
}
babylonLight.position = light.transform.localPosition.ToFloat();
var direction = new Vector3(0, 0, 1);
var transformedDirection = light.transform.TransformDirection(direction);
babylonLight.direction = transformedDirection.ToFloat();
babylonLight.diffuse = light.color.ToFloat();
babylonLight.intensity = light.intensity;
babylonLight.angle = light.spotAngle * (float)Math.PI / 180;
babylonLight.exponent = 1.0f;
babylonScene.LightsList.Add(babylonLight);
// Animations
ExportAnimations(light.transform, babylonLight);
// Shadows
if (exportationOptions.ExportShadows)
{
if ((light.type == LightType.Directional || light.type == LightType.Spot) && light.shadows != LightShadows.None)
{
GenerateShadowsGenerator(light);
}
}
}
public void Prepare(bool generateDefaultLight = true, bool generateDefaultCamera = true)
{
meshes = MeshesList.ToArray();
sounds = SoundsList.ToArray();
materials = MaterialsList.ToArray();
multiMaterials = MultiMaterialsList.ToArray();
shadowGenerators = ShadowGeneratorsList.ToArray();
skeletons = SkeletonsList.ToArray();
if (MorphTargetManagersList.Count > 0)
{
morphTargetManagers = MorphTargetManagersList.ToArray();
}
if (CamerasList.Count == 0 && generateDefaultCamera)
{
var camera = new BabylonCamera {
name = "Default camera", id = Guid.NewGuid().ToString()
};
// Default camera init gives infinit values
// Indeed, float.MaxValue - float.MinValue always leads to infinity
var distanceVector = MaxVector - MinVector;
var midPoint = MinVector + distanceVector / 2;
camera.target = midPoint.ToArray();
camera.position = (midPoint + distanceVector).ToArray();
var distance = distanceVector.Length();
camera.speed = distance / 50.0f;
camera.maxZ = distance * 4f;
camera.minZ = distance < 100.0f ? 0.1f : 1.0f;
CamerasList.Add(camera);
}
if (LightsList.Count == 0 && generateDefaultLight)
{
var light = new BabylonLight
{
name = "Default light",
id = Guid.NewGuid().ToString(),
type = 3,
groundColor = new float[] { 0, 0, 0 },
direction = new[] { 0, 1.0f, 0 },
intensity = 1
};
LightsList.Add(light);
}
cameras = (CamerasList.Count > 0) ? CamerasList.ToArray() : null;
lights = (LightsList.Count > 0) ? LightsList.ToArray() : null;
if (activeCameraID == null && CamerasList.Count > 0)
{
activeCameraID = CamerasList[0].id;
}
}
public void Prepare(bool generateDefaultLight = true)
{
meshes = MeshesList.ToArray();
materials = MaterialsList.ToArray();
multiMaterials = MultiMaterialsList.ToArray();
shadowGenerators = ShadowGeneratorsList.ToArray();
skeletons = SkeletonsList.ToArray();
if (CamerasList.Count == 0)
{
var camera = new BabylonCamera {
name = "Default camera", id = Guid.NewGuid().ToString()
};
var distanceVector = MaxVector - MinVector;
var midPoint = MinVector + distanceVector / 2;
camera.target = midPoint.ToArray();
camera.position = (midPoint + distanceVector).ToArray();
var distance = distanceVector.Length();
camera.speed = distance / 50.0f;
camera.maxZ = distance * 4f;
camera.minZ = distance < 100.0f ? 0.1f : 1.0f;
CamerasList.Add(camera);
}
if (LightsList.Count == 0 && generateDefaultLight)
{
var light = new BabylonLight {
name = "Default light", id = Guid.NewGuid().ToString()
};
var midPoint = MinVector + (MaxVector - MinVector) / 2;
light.type = 0;
light.position = (midPoint + (MaxVector - MinVector)).ToArray();
light.diffuse = new Vector3(1, 1, 1).ToArray();
light.specular = new Vector3(1, 1, 1).ToArray();
LightsList.Add(light);
}
cameras = CamerasList.ToArray();
lights = LightsList.ToArray();
if (activeCameraID == null)
{
activeCameraID = CamerasList[0].id;
}
}
void ExportDefaultLight(BabylonScene babylonScene)
{
var babylonLight = new BabylonLight();
babylonLight.name = "Default light";
babylonLight.id = Guid.NewGuid().ToString();
babylonLight.type = 3;
babylonLight.groundColor = new float[] { 0, 0, 0 };
babylonLight.direction = new[] { 0, 1.0f, 0 };
babylonLight.intensity = 1;
babylonLight.diffuse = new[] { 1.0f, 1.0f, 1.0f };
babylonLight.specular = new[] { 1.0f, 1.0f, 1.0f };
babylonScene.LightsList.Add(babylonLight);
}
public void Prepare(bool generateDefaultLight = true)
{
meshes = MeshesList.ToArray();
sounds = SoundsList.ToArray();
materials = MaterialsList.ToArray();
multiMaterials = MultiMaterialsList.ToArray();
shadowGenerators = ShadowGeneratorsList.ToArray();
skeletons = SkeletonsList.ToArray();
if (CamerasList.Count == 0)
{
var camera = new BabylonCamera { name = "Default camera", id = Guid.NewGuid().ToString() };
var distanceVector = MaxVector - MinVector;
var midPoint = MinVector + distanceVector / 2;
camera.target = midPoint.ToArray();
camera.position = (midPoint + distanceVector).ToArray();
var distance = distanceVector.Length();
camera.speed = distance / 50.0f;
camera.maxZ = distance * 4f;
camera.minZ = distance < 100.0f ? 0.1f : 1.0f;
CamerasList.Add(camera);
}
if (LightsList.Count == 0 && generateDefaultLight)
{
var light = new BabylonLight
{
name = "Default light",
id = Guid.NewGuid().ToString(),
type = 3,
groundColor = new float[] {0, 0, 0},
direction = new[] {0, 1.0f, 0},
intensity = 1
};
LightsList.Add(light);
}
cameras = CamerasList.ToArray();
lights = LightsList.ToArray();
if (activeCameraID == null)
{
activeCameraID = CamerasList[0].id;
}
}
private void ExportLight(IIGameScene scene, IIGameNode lightNode, BabylonScene babylonScene)
{
if (lightNode.MaxNode.GetBoolProperty("babylonjs_noexport"))
{
return;
}
var gameLight = lightNode.IGameObject.AsGameLight();
var initialized = gameLight.InitializeData;
var babylonLight = new BabylonLight();
RaiseMessage(lightNode.Name, 1);
babylonLight.name = lightNode.Name;
babylonLight.id = lightNode.MaxNode.GetGuid().ToString();
if (lightNode.NodeParent != null)
{
babylonLight.parentId = GetParentID(lightNode.NodeParent, babylonScene, scene);
}
// Type
var maxLight = (lightNode.MaxNode.ObjectRef as ILightObject);
var lightState = Loader.Global.LightState.Create();
maxLight.EvalLightState(0, Tools.Forever, lightState);
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 };
break;
}
// Shadows
if (maxLight.ShadowMethod == 1)
{
if (lightState.Type == LightType.DirectLgt || lightState.Type == LightType.SpotLgt)
{
ExportShadowGenerator(lightNode.MaxNode, babylonScene);
}
else
{
RaiseWarning("Shadows maps are only supported for directional and spot lights", 2);
}
}
// Position
var wm = lightNode.GetObjectTM(0);
if (lightNode.NodeParent != null)
{
var parentWorld = lightNode.NodeParent.GetObjectTM(0);
wm.MultiplyBy(parentWorld.Inverse);
}
var position = wm.Translation;
babylonLight.position = new[] { position.X, position.Y, position.Z };
// Direction
var target = gameLight.LightTarget;
if (target != null)
{
var targetWm = target.GetObjectTM(0);
var targetPosition = targetWm.Translation;
var direction = targetPosition.Subtract(position).Normalize;
babylonLight.direction = new[] { direction.X, direction.Y, direction.Z };
}
else
{
var vDir = Loader.Global.Point3.Create(0, -1, 0);
vDir = wm.ExtractMatrix3().VectorTransform(vDir).Normalize;
babylonLight.direction = new[] { vDir.X, vDir.Y, vDir.Z };
}
var maxScene = Loader.Core.RootNode;
// Exclusion
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>();
ExportVector3Animation("position", animations, key =>
{
var mat = lightNode.GetObjectTM(key);
if (lightNode.NodeParent != null)
{
var parentWorld = lightNode.NodeParent.GetObjectTM(key);
mat.MultiplyBy(parentWorld.Inverse);
}
var pos = mat.Translation;
return new[] { pos.X, pos.Y, pos.Z };
});
ExportVector3Animation("direction", animations, key =>
{
var wmLight = lightNode.GetObjectTM(key);
if (lightNode.NodeParent != null)
{
var parentWorld = lightNode.NodeParent.GetObjectTM(key);
wmLight.MultiplyBy(parentWorld.Inverse);
}
var positionLight = wmLight.Translation;
var lightTarget = gameLight.LightTarget;
if (lightTarget != null)
{
var targetWm = lightTarget.GetObjectTM(key);
var targetPosition = targetWm.Translation;
var direction = targetPosition.Subtract(positionLight).Normalize;
return new[] { direction.X, direction.Y, direction.Z };
}
else
{
var vDir = Loader.Global.Point3.Create(0, -1, 0);
vDir = wmLight.ExtractMatrix3().VectorTransform(vDir).Normalize;
return new[] { vDir.X, vDir.Y, vDir.Z };
}
});
ExportFloatAnimation("intensity", animations, key => new[] { maxLight.GetIntensity(key, Tools.Forever) });
babylonLight.animations = animations.ToArray();
if (lightNode.MaxNode.GetBoolProperty("babylonjs_autoanimate"))
{
babylonLight.autoAnimate = true;
babylonLight.autoAnimateFrom = (int)lightNode.MaxNode.GetFloatProperty("babylonjs_autoanimate_from");
babylonLight.autoAnimateTo = (int)lightNode.MaxNode.GetFloatProperty("babylonjs_autoanimate_to");
babylonLight.autoAnimateLoop = lightNode.MaxNode.GetBoolProperty("babylonjs_autoanimateloop");
}
babylonScene.LightsList.Add(babylonLight);
}
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);
}
public void ConvertFromUnity()
{
ExporterWindow.ReportProgress(0, "Starting exportation process...");
gameObjects = Object.FindObjectsOfType(typeof(GameObject)) as GameObject[];
if (gameObjects.Length == 0)
{
ExporterWindow.ShowMessage("No gameobject! - Please add at least a gameobject to export");
return;
}
// Create scene metadata
SceneBuilder.Metadata = new SceneMetaData();
// Parse all scene game objects
var index = 0;
var itemsCount = gameObjects.Length;
var particleSystems = new List<BabylonExport.Entities.BabylonParticleSystem>();
var lensFlareSystems = new List<UnityFlareSystem>();
ExporterWindow.ReportProgress(0, "Exporting game objects from scene...");
babylonScene.physicsEngine = (exportationOptions.DefaultPhysicsEngine == 1) ? "oimo" : "cannon";
try
{
bool foundController = false;
foreach (var gameObject in gameObjects)
{
var progress = ((float)index / itemsCount);
index++;
// Unity metadata
var metaData = new UnityMetaData();
metaData.objectId = GetID(gameObject);
metaData.objectName = gameObject.name;
metaData.tagName = gameObject.tag;
metaData.layerIndex = gameObject.layer;
metaData.layerName = LayerMask.LayerToName(gameObject.layer);
// Export hooking
var exportObject = gameObject;
var exportOptions = exportationOptions;
BabylonScene sceneBuilder = babylonScene;
if (SceneController != null)
{
SceneController.OnExportGameObject(ref exportOptions, ref exportObject, ref metaData, ref sceneBuilder, OutputPath);
}
// Components tags
string componentTags = String.Empty;
if (!String.IsNullOrEmpty(gameObject.tag) && !gameObject.tag.Equals("Untagged", StringComparison.OrdinalIgnoreCase))
{
componentTags = gameObject.tag;
}
// Navigation area
metaData.areaIndex = -1;
bool navigationStatic = GameObjectUtility.AreStaticEditorFlagsSet(gameObject, StaticEditorFlags.NavigationStatic);
if (navigationStatic)
{
metaData.areaIndex = GameObjectUtility.GetNavMeshArea(gameObject);
}
// Navigation agent
metaData.navAgent = null;
var navigationAgent = gameObject.GetComponent<NavMeshAgent>();
if (navigationAgent != null)
{
componentTags += " [NAVAGENT]";
Dictionary<string, object> agentInfo = new Dictionary<string, object>();
agentInfo.Add("name", navigationAgent.name);
agentInfo.Add("radius", navigationAgent.radius);
agentInfo.Add("height", navigationAgent.height);
agentInfo.Add("speed", navigationAgent.speed);
agentInfo.Add("acceleration", navigationAgent.acceleration);
agentInfo.Add("angularSpeed", navigationAgent.angularSpeed);
agentInfo.Add("areaMask", navigationAgent.areaMask);
agentInfo.Add("autoBraking", navigationAgent.autoBraking);
agentInfo.Add("autoTraverseOffMeshLink", navigationAgent.autoTraverseOffMeshLink);
agentInfo.Add("avoidancePriority", navigationAgent.avoidancePriority);
agentInfo.Add("baseOffset", navigationAgent.baseOffset);
agentInfo.Add("obstacleAvoidanceType", navigationAgent.obstacleAvoidanceType.ToString());
agentInfo.Add("stoppingDistance", navigationAgent.stoppingDistance);
metaData.navAgent = agentInfo;
}
// Navigation link
metaData.meshLink = null;
var navigationLink = gameObject.GetComponent<OffMeshLink>();
if (navigationLink != null)
{
componentTags += " [MESHLINK]";
Dictionary<string, object> linkInfo = new Dictionary<string, object>();
linkInfo.Add("name", navigationLink.name);
linkInfo.Add("activated", navigationLink.activated);
linkInfo.Add("area", navigationLink.area);
linkInfo.Add("autoUpdatePositions", navigationLink.autoUpdatePositions);
linkInfo.Add("biDirectional", navigationLink.biDirectional);
linkInfo.Add("costOverride", navigationLink.costOverride);
linkInfo.Add("occupied", navigationLink.occupied);
linkInfo.Add("start", GetTransformPropertyValue(navigationLink.startTransform));
linkInfo.Add("end", GetTransformPropertyValue(navigationLink.endTransform));
metaData.meshLink = linkInfo;
}
// Navigation obstacle
metaData.meshObstacle = null;
var navigationObstacle = gameObject.GetComponent<NavMeshObstacle>();
if (navigationObstacle != null)
{
componentTags += " [MESHOBSTACLE]";
Dictionary<string, object> obstacleInfo = new Dictionary<string, object>();
obstacleInfo.Add("name", navigationObstacle.name);
obstacleInfo.Add("carving", navigationObstacle.carving);
obstacleInfo.Add("carveOnlyStationary", navigationObstacle.carveOnlyStationary);
obstacleInfo.Add("carvingMoveThreshold", navigationObstacle.carvingMoveThreshold);
obstacleInfo.Add("carvingTimeToStationary", navigationObstacle.carvingTimeToStationary);
obstacleInfo.Add("shape", navigationObstacle.shape.ToString());
obstacleInfo.Add("radius", navigationObstacle.radius);
obstacleInfo.Add("center", navigationObstacle.center.ToFloat());
obstacleInfo.Add("size", navigationObstacle.size.ToFloat());
metaData.meshObstacle = obstacleInfo;
}
// Tags component
var tagsComponent = gameObject.GetComponent<BabylonTagsComponent>();
if (tagsComponent != null)
{
if (!String.IsNullOrEmpty(tagsComponent.babylonTags))
{
componentTags += (" " + tagsComponent.babylonTags);
}
}
// Script components
var gameComponents = gameObject.GetComponents<BabylonScriptComponent>();
if (gameComponents != null)
{
var components = new List<object>();
foreach (var gameComponent in gameComponents)
{
Type componentType = gameComponent.GetType();
string componentName = componentType.FullName;
var component = new UnityScriptComponent();
MonoScript componentScript = MonoScript.FromMonoBehaviour(gameComponent);
component.order = MonoImporter.GetExecutionOrder(componentScript);
component.name = componentName;
component.klass = gameComponent.babylonClass;
component.update = (gameComponent.updateOption == BabylonTickOptions.EnableTick);
component.controller = (gameComponent is BabylonSceneController);
if (component.controller == true)
{
component.order = -1;
if (foundController == false)
{
foundController = true;
componentTags += " [CONTROLLER]";
object userInterface = null;
BabylonSceneController scx = (gameComponent as BabylonSceneController);
EmbeddedAsset guiAsset = scx.sceneOptions.graphicUserInterface;
if (guiAsset != null && scx.sceneOptions.userInterfaceMode != BabylonGuiMode.None)
{
userInterface = GetEmbeddedAssetPropertyValue(guiAsset);
}
SceneBuilder.Metadata.properties.Add("autoDraw", scx.sceneOptions.autoDrawInterface);
SceneBuilder.Metadata.properties.Add("interfaceMode", scx.sceneOptions.userInterfaceMode.ToString());
SceneBuilder.Metadata.properties.Add("userInterface", userInterface);
SceneBuilder.Metadata.properties.Add("controllerPresent", true);
SceneBuilder.Metadata.properties.Add("controllerObjectId", metaData.objectId);
}
else
{
Debug.LogError("Duplicate scene controller detected: " + component.name);
}
}
FieldInfo[] componentFields = componentType.GetFields();
if (componentFields != null)
{
foreach (var componentField in componentFields)
{
var componentAttribute = (BabylonPropertyAttribute)Attribute.GetCustomAttribute(componentField, typeof(BabylonPropertyAttribute));
if (componentAttribute != null && componentField.Name != "babylonClass")
{
component.properties.Add(componentField.Name, GetComponentPropertyValue(componentField, gameComponent));
}
}
}
gameComponent.OnExportProperties(ref exportOptions, ref exportObject, ref component.properties, OutputPath);
components.Add(component);
}
if (components.Count > 0)
{
metaData.components = components;
}
}
// Format tags
if (!String.IsNullOrEmpty(componentTags))
{
componentTags = componentTags.Trim();
}
// Audio sources
var audioComponents = gameObject.GetComponents<BabylonAudioSource>();
if (audioComponents != null)
{
foreach (var item in audioComponents)
{
if (item != null && item.exportAudio && item.sound != null)
{
string soundPath = AssetDatabase.GetAssetPath(item.sound);
if (!String.IsNullOrEmpty(soundPath))
{
string soundName = Path.GetFileName(soundPath).Replace(" ", "");
string outputFile = Path.Combine(OutputPath, soundName);
if (File.Exists(soundPath))
{
File.Copy(soundPath, outputFile, true);
var sound = new BabylonSound();
sound.name = soundName;
sound.volume = item.options.volume;
sound.playbackRate = item.options.playbackRate;
sound.autoplay = item.options.autoplay;
sound.loop = item.options.loop;
sound.soundTrackId = item.options.soundTrackId;
sound.spatialSound = item.options.spatialSound;
sound.position = item.options.position.ToFloat();
sound.refDistance = item.options.refDistance;
sound.rolloffFactor = item.options.rolloffFactor;
sound.maxDistance = item.options.maxDistance;
sound.distanceModel = item.options.distanceModel;
sound.panningModel = item.options.panningModel;
sound.isDirectional = item.options.isDirectional;
sound.coneInnerAngle = item.options.coneInnerAngle;
sound.coneOuterAngle = item.options.coneOuterAngle;
sound.coneOuterGain = item.options.coneOuterGain;
sound.localDirectionToMesh = item.options.directionToMesh.ToFloat();
babylonScene.SoundsList.Add(sound);
}
else
{
Debug.LogError("Fail to locate audio file: " + soundPath);
}
}
else
{
Debug.LogError("Null audio clip path for: " + item.sound.name);
}
}
}
}
// Terrain meshes
var terrainMesh = gameObject.GetComponent<Terrain>();
if (terrainMesh != null)
{
ConvertUnityTerrainToBabylon(terrainMesh, gameObject, progress, ref metaData, ref particleSystems, ref lensFlareSystems, ref componentTags);
continue;
}
// Collision meshes
BabylonMesh collisionMesh = null;
var collider = gameObject.GetComponent<Collider>();
if (collider != null)
{
if (collider.enabled)
{
int segments = 12;
BabylonColliderDetail detail = (BabylonColliderDetail)exportationOptions.DefaultColliderDetail;
var collisionData = new UnityMetaData();
collisionData.objectId = Guid.NewGuid().ToString();
collisionData.objectName = gameObject.name + "_Metadata";
if (collider is MeshCollider)
{
var meshCollider = collider as MeshCollider;
collisionMesh = new BabylonMesh();
collisionMesh.tags = "[MESHCOLLIDER]";
// Generate Mesh Collider Geometry
if(!meshCollider.sharedMesh)
{
UnityEngine.Debug.LogWarning(meshCollider.gameObject+" has a Mesh Collider component without a mesh");
}
else
{
Tools.GenerateBabylonMeshData(meshCollider.sharedMesh, collisionMesh);
}
collisionMesh.position = Vector3.zero.ToFloat();
collisionMesh.rotation = Vector3.zero.ToFloat();
float factorX = 1f, factorY = 1f, factorZ = 1f;
if (meshCollider.inflateMesh && meshCollider.skinWidth > 0f)
{
Vector3 localScale = gameObject.transform.localScale;
factorX += (meshCollider.skinWidth / localScale.x);
factorY += (meshCollider.skinWidth / localScale.y);
factorZ += (meshCollider.skinWidth / localScale.z);
}
collisionMesh.scaling = new Vector3(factorX, factorY, factorZ).ToFloat();
// Export Mesh Collider Metadata
collisionData.tagName = "MeshCollider";
collisionData.properties.Add("type", "Mesh");
collisionData.properties.Add("convex", meshCollider.convex);
collisionData.properties.Add("inflateMesh", meshCollider.inflateMesh);
collisionData.properties.Add("skinWidth", meshCollider.skinWidth);
}
else if (collider is CapsuleCollider)
{
var capsuleCollider = collider as CapsuleCollider;
collisionMesh = new BabylonMesh();
collisionMesh.tags = "[CAPSULECOLLIDER]";
switch (detail)
{
case BabylonColliderDetail.FullResolution:
segments = 48;
break;
case BabylonColliderDetail.HighResolution:
segments = 32;
break;
case BabylonColliderDetail.MediumResolution:
segments = 24;
break;
case BabylonColliderDetail.LowResolution:
segments = 12;
break;
case BabylonColliderDetail.VeryLowResolution:
segments = 8;
break;
case BabylonColliderDetail.MinimumResolution:
segments = 6;
break;
default:
segments = 12;
break;
}
// Generate Capsule Collider Geometry
Mesh capsuleMesh = Tools.CreateCapsuleMesh(capsuleCollider.height, capsuleCollider.radius, segments);
Tools.GenerateBabylonMeshData(capsuleMesh, collisionMesh);
collisionMesh.position = new float[3];
collisionMesh.position[0] = capsuleCollider.center.x;
collisionMesh.position[1] = capsuleCollider.center.y;
collisionMesh.position[2] = capsuleCollider.center.z;
collisionMesh.rotation = new float[3];
collisionMesh.rotation[0] = (capsuleCollider.direction == 2) ? 90f * (float)Math.PI / 180f : 0f;
collisionMesh.rotation[1] = 0f;
collisionMesh.rotation[2] = (capsuleCollider.direction == 0) ? 90f * (float)Math.PI / 180f : 0f;
collisionMesh.scaling = new Vector3(1, 1, 1).ToFloat();
// Export Capsule Collider Metadata
collisionData.tagName = "CapsuleCollider";
collisionData.properties.Add("type", "Capsule");
collisionData.properties.Add("center", capsuleCollider.center.ToFloat());
collisionData.properties.Add("radius", capsuleCollider.radius);
collisionData.properties.Add("height", capsuleCollider.height);
collisionData.properties.Add("direction", capsuleCollider.direction);
}
else if (collider is SphereCollider)
{
var sphereCollider = collider as SphereCollider;
collisionMesh = new BabylonMesh();
collisionMesh.tags = "[SPHERECOLLIDER]";
switch (detail)
{
case BabylonColliderDetail.FullResolution:
segments = 48;
break;
case BabylonColliderDetail.HighResolution:
segments = 32;
break;
case BabylonColliderDetail.MediumResolution:
segments = 24;
break;
case BabylonColliderDetail.LowResolution:
segments = 12;
break;
case BabylonColliderDetail.VeryLowResolution:
segments = 8;
break;
case BabylonColliderDetail.MinimumResolution:
segments = 6;
break;
default:
segments = 12;
break;
}
// Generate Sphere Collider Geometry
Mesh sphereMesh = Tools.CreateSphereMesh(sphereCollider.radius, segments);
Tools.GenerateBabylonMeshData(sphereMesh, collisionMesh);
collisionMesh.position = new float[3];
collisionMesh.position[0] = sphereCollider.center.x;
collisionMesh.position[1] = sphereCollider.center.y;
collisionMesh.position[2] = sphereCollider.center.z;
collisionMesh.rotation = Vector3.zero.ToFloat();
collisionMesh.scaling = new Vector3(1f, 1f, 1f).ToFloat();
// Export Sphere Collider Metadata
collisionData.tagName = "SphereCollider";
collisionData.properties.Add("type", "Sphere");
collisionData.properties.Add("center", sphereCollider.center.ToFloat());
collisionData.properties.Add("radius", sphereCollider.radius);
}
else if (collider is WheelCollider)
{
var wheelCollider = collider as WheelCollider;
collisionMesh = new BabylonMesh();
collisionMesh.tags = "[WHEELCOLLIDER]";
switch (detail)
{
case BabylonColliderDetail.FullResolution:
segments = 128;
break;
case BabylonColliderDetail.HighResolution:
segments = 64;
break;
case BabylonColliderDetail.MediumResolution:
segments = 48;
break;
case BabylonColliderDetail.LowResolution:
segments = 32;
break;
case BabylonColliderDetail.VeryLowResolution:
segments = 24;
break;
case BabylonColliderDetail.MinimumResolution:
segments = 16;
break;
default:
segments = 32;
break;
}
// Generate Wheel Collider Geometry
Mesh wheelMesh = Tools.CreateWheelMesh(wheelCollider.suspensionDistance, wheelCollider.radius, segments);
Tools.GenerateBabylonMeshData(wheelMesh, collisionMesh);
collisionMesh.position = new float[3];
collisionMesh.position[0] = wheelCollider.center.x;
collisionMesh.position[1] = wheelCollider.center.y;
collisionMesh.position[2] = wheelCollider.center.z;
collisionMesh.rotation = new float[3];
collisionMesh.rotation[0] = 0f;
collisionMesh.rotation[1] = 0f;
collisionMesh.rotation[2] = 90f * (float)Math.PI / 180;
collisionMesh.scaling = new Vector3(1f, 1f, 1f).ToFloat();
// Export Wheel Collider Metadata
collisionData.tagName = "WheelCollider";
collisionData.properties.Add("type", "Wheel");
collisionData.properties.Add("center", wheelCollider.center.ToFloat());
collisionData.properties.Add("radius", wheelCollider.radius);
}
else if (collider is BoxCollider)
{
var boxCollider = collider as BoxCollider;
collisionMesh = new BabylonMesh();
collisionMesh.tags = "[BOXCOLLIDER]";
// Generate Box Collider Geometry
Mesh boxMesh = Tools.CreateBoxMesh(boxCollider.size.x, boxCollider.size.y, boxCollider.size.z);
Tools.GenerateBabylonMeshData(boxMesh, collisionMesh);
collisionMesh.position = new float[3];
collisionMesh.position[0] = boxCollider.center.x;
collisionMesh.position[1] = boxCollider.center.y;
collisionMesh.position[2] = boxCollider.center.z;
collisionMesh.rotation = Vector3.zero.ToFloat();
collisionMesh.scaling = new Vector3(1f, 1f, 1f).ToFloat();
// Export Box Collider Metadata
collisionData.tagName = "BoxCollider";
collisionData.properties.Add("type", "Box");
collisionData.properties.Add("center", boxCollider.center.ToFloat());
collisionData.properties.Add("size", boxCollider.size.ToFloat());
}
if (collisionMesh != null)
{
collisionMesh.id = Guid.NewGuid().ToString();
collisionMesh.name = gameObject.name + "_Collider";
// Default Check Collisions False
collisionMesh.checkCollisions = false;
collisionMesh.isVisible = false;
collisionData.properties.Add("parrentId", metaData.objectId);
collisionData.properties.Add("transform", GetTransformPropertyValue(gameObject.transform));
collisionMesh.metadata = collisionData;
babylonScene.MeshesList.Add(collisionMesh);
SceneBuilder.Metadata.properties["hasCollisionMeshes"] = true;
}
}
}
// Static meshes
var meshFilter = gameObject.GetComponent<MeshFilter>();
if (meshFilter != null)
{
ConvertUnityMeshToBabylon(meshFilter.sharedMesh, meshFilter.transform, gameObject, progress, ref metaData, ref particleSystems, ref lensFlareSystems, ref componentTags, collisionMesh, collider);
continue;
}
// Skinned meshes
var skinnedMesh = gameObject.GetComponent<SkinnedMeshRenderer>();
if (skinnedMesh != null)
{
var babylonMesh = ConvertUnityMeshToBabylon(skinnedMesh.sharedMesh, skinnedMesh.transform, gameObject, progress, ref metaData, ref particleSystems, ref lensFlareSystems, ref componentTags, collisionMesh, collider);
var skeleton = ConvertUnitySkeletonToBabylon(skinnedMesh.bones, skinnedMesh.sharedMesh.bindposes, skinnedMesh.transform, gameObject, progress);
babylonMesh.skeletonId = skeleton.id;
ExportSkeletonAnimation(skinnedMesh, babylonMesh, skeleton);
continue;
}
// Scene lights
var light = gameObject.GetComponent<Light>();
if (light != null)
{
ConvertUnityLightToBabylon(light, gameObject, progress, ref metaData, ref particleSystems, ref lensFlareSystems, ref componentTags);
continue;
}
// Scene cameras
var camera = gameObject.GetComponent<Camera>();
if (camera != null)
{
ConvertUnityCameraToBabylon(camera, gameObject, progress, ref metaData, ref particleSystems, ref lensFlareSystems, ref componentTags);
if (SceneController != null && SceneController.skyboxOptions.exportSkybox)
{
ConvertUnitySkyboxToBabylon(camera, progress);
}
continue;
}
// Empty objects
ConvertUnityEmptyObjectToBabylon(gameObject, ref metaData, ref particleSystems, ref lensFlareSystems, ref componentTags, collisionMesh, collider);
}
// Materials
foreach (var mat in materialsDictionary)
{
babylonScene.MaterialsList.Add(mat.Value);
}
foreach (var multiMat in multiMatDictionary)
{
babylonScene.MultiMaterialsList.Add(multiMat.Value);
}
// Collisions
if (exportationOptions.ExportCollisions)
{
babylonScene.workerCollisions = exportationOptions.WorkerCollisions;
if (SceneController != null) {
babylonScene.gravity = SceneController.sceneOptions.defaultGravity.ToFloat();
}
}
// Babylon Physics
if (exportationOptions.ExportPhysics)
{
babylonScene.physicsEnabled = true;
if (SceneController != null) {
babylonScene.physicsGravity = SceneController.sceneOptions.defaultGravity.ToFloat();
}
}
// Scene Controller
if (SceneController != null)
{
Color ambientColor = SceneController.sceneOptions.ambientColor;
float ambientLevel = SceneController.lightingOptions.lightLevel;
Color ambientSpecular = SceneController.lightingOptions.specularColor;
babylonScene.autoClear = SceneController.sceneOptions.autoClear;
int fogmode = 0;
if (RenderSettings.fog)
{
switch (RenderSettings.fogMode)
{
case FogMode.Exponential:
fogmode = 1;
break;
case FogMode.ExponentialSquared:
fogmode = 2;
break;
case FogMode.Linear:
fogmode = 3;
break;
}
}
babylonScene.fogMode = fogmode;
babylonScene.fogDensity = RenderSettings.fogDensity;
babylonScene.fogColor = RenderSettings.fogColor.ToFloat();
babylonScene.fogStart = RenderSettings.fogStartDistance;
babylonScene.fogEnd = RenderSettings.fogEndDistance;
if (exportationOptions.DefaultLightmapMode != (int)BabylonLightmapMode.FullLightBaking && SceneController.lightingOptions.lightMode == BabylonAmbientLighting.UnityAmbientLighting)
{
var ambientLight = new BabylonLight
{
name = "Ambient Light",
id = Guid.NewGuid().ToString(),
parentId = null,
metadata = null,
position = null,
exponent = 1.0f,
angle = 0.0f,
type = 3
};
var ambientDirection = new Vector3(0.0f, 1.0f, 0.0f);
Color ambientDiffuse = (RenderSettings.ambientMode == UnityEngine.Rendering.AmbientMode.Skybox) ? RenderSettings.ambientSkyColor : RenderSettings.ambientLight;
ambientLight.intensity = RenderSettings.ambientIntensity * ambientLevel;
ambientLight.direction = ambientDirection.ToFloat(); ;
ambientLight.diffuse = ambientDiffuse.ToFloat();
ambientLight.specular = ambientSpecular.ToFloat();
ambientLight.groundColor = RenderSettings.ambientGroundColor.ToFloat();
babylonScene.ambientColor = ambientColor.ToFloat();
babylonScene.LightsList.Add(ambientLight);
ExporterWindow.ReportProgress(0, "Exporting ambient light intensity at: " + ambientLight.intensity.ToString());
}
if (SceneController.sceneOptions.navigationMesh == BabylonNavigationMesh.EnableNavigation)
{
ExporterWindow.ReportProgress(0, "Parsing scene navigation mesh...");
NavMeshTriangulation triangulatedNavMesh = NavMesh.CalculateTriangulation();
if (triangulatedNavMesh.vertices != null && triangulatedNavMesh.vertices.Length > 0 && triangulatedNavMesh.indices != null && triangulatedNavMesh.indices.Length > 0)
{
int vertexCount = triangulatedNavMesh.vertices.Length;
if (vertexCount <= SceneBuilder.MAX_VERTEX_COUNT)
{
ExporterWindow.ReportProgress(0, "Generating navigation mesh vertices: " + vertexCount.ToString());
var navData = new UnityMetaData();
navData.type = "NavMesh";
navData.objectId = Guid.NewGuid().ToString();
navData.objectName = "Navigation_Mesh";
var areaTable = new List<object>();
string[] areaNavigation = GameObjectUtility.GetNavMeshAreaNames();
foreach (string areaName in areaNavigation)
{
var bag = new Dictionary<string, object>();
int areaIndex = NavMesh.GetAreaFromName(areaName);
float areaCost = NavMesh.GetAreaCost(areaIndex);
bag.Add("index", areaIndex);
bag.Add("area", areaName);
bag.Add("cost", areaCost);
areaTable.Add(bag);
}
navData.properties.Add("table", areaTable);
navData.properties.Add("areas", triangulatedNavMesh.areas);
Mesh mesh = new Mesh();
mesh.name = "sceneNavigationMesh";
mesh.vertices = triangulatedNavMesh.vertices;
mesh.triangles = triangulatedNavMesh.indices;
mesh.RecalculateNormals();
BabylonMesh babylonMesh = new BabylonMesh();
babylonMesh.tags = "[NAVMESH]";
babylonMesh.metadata = navData;
babylonMesh.name = mesh.name;
babylonMesh.id = Guid.NewGuid().ToString();
babylonMesh.parentId = null;
babylonMesh.position = Vector3.zero.ToFloat();
babylonMesh.rotation = Vector3.zero.ToFloat();
babylonMesh.scaling = new Vector3(1, 1, 1).ToFloat();
babylonMesh.isVisible = false;
babylonMesh.visibility = 0.75f;
babylonMesh.checkCollisions = false;
Tools.GenerateBabylonMeshData(mesh, babylonMesh);
babylonScene.MeshesList.Add(babylonMesh);
SceneBuilder.Metadata.properties["hasNavigationMesh"] = true;
}
else
{
UnityEngine.Debug.LogError("Navigation mesh exceeds max (65000) vertex limit: " + vertexCount.ToString());
}
}
}
if (SceneController.sceneOptions.particleSystems)
{
if (particleSystems != null && particleSystems.Count > 0)
{
babylonScene.particleSystems = particleSystems.ToArray();
}
}
if (SceneController.sceneOptions.lensFlareSystems)
{
if (lensFlareSystems != null && lensFlareSystems.Count > 0)
{
var lfs_buffer = new List<BabylonLensFlareSystem>();
foreach (var ulfs in lensFlareSystems)
{
var lfs = new BabylonLensFlareSystem();
lfs.borderLimit = ulfs.borderLimit;
lfs.emitterId = ulfs.emitterId;
var lfx = new List<BabylonLensFlare>();
foreach (var ulf in ulfs.lensFlares)
{
var lf = new BabylonLensFlare();
lf.textureName = ulf.textureName;
lf.position = ulf.position;
lf.color = ulf.color;
lf.size = ulf.size;
lfx.Add(lf);
}
lfs.flares = lfx.ToArray();
lfs_buffer.Add(lfs);
}
babylonScene.lensFlareSystems = lfs_buffer.ToArray();
}
}
}
}
catch (Exception ex)
{
Debug.LogException(ex);
}
finally
{
babylonScene.metadata = SceneBuilder.Metadata;
}
}
public void Prepare(bool generateDefaultLight = true)
{
meshes = MeshesList.ToArray();
materials = MaterialsList.ToArray();
multiMaterials = MultiMaterialsList.ToArray();
shadowGenerators = ShadowGeneratorsList.ToArray();
skeletons = SkeletonsList.ToArray();
if (CamerasList.Count == 0)
{
var camera = new BabylonCamera {name = "Default camera", id = Guid.NewGuid().ToString()};
var distanceVector = MaxVector - MinVector;
var midPoint = MinVector +distanceVector / 2;
camera.target = midPoint.ToArray();
camera.position = (midPoint + distanceVector).ToArray();
var distance = distanceVector.Length();
camera.speed = distance/ 50.0f;
camera.maxZ = distance * 4f;
camera.minZ = distance < 100.0f ? 0.1f : 1.0f;
CamerasList.Add(camera);
}
if (LightsList.Count == 0 && generateDefaultLight)
{
var light = new BabylonLight {name = "Default light", id = Guid.NewGuid().ToString()};
var midPoint = MinVector + (MaxVector - MinVector) / 2;
light.type = 0;
light.position = (midPoint + (MaxVector - MinVector)).ToArray();
light.diffuse = new Vector3(1, 1, 1).ToArray();
light.specular = new Vector3(1, 1, 1).ToArray();
LightsList.Add(light);
}
cameras = CamerasList.ToArray();
lights = LightsList.ToArray();
if (activeCameraID == null)
{
activeCameraID = CamerasList[0].id;
}
}
private void ConvertUnityLightToBabylon(Light light, GameObject gameObject, float progress, ref UnityMetaData metaData, ref List<BabylonExport.Entities.BabylonParticleSystem> particleSystems, ref List<UnityFlareSystem> lensFlares, ref string componentTags)
{
// No Inactive Or Baking Lights
if (light.isActiveAndEnabled == false || light.type == LightType.Area || light.lightmappingMode == LightmappingMode.Baked) return;
ExporterWindow.ReportProgress(progress, "Exporting light: " + light.name);
BabylonLight babylonLight = new BabylonLight
{
name = light.name,
id = GetID(light.gameObject),
parentId = GetParentID(light.transform)
};
metaData.type = "Light";
babylonLight.tags = componentTags;
switch (light.type)
{
case LightType.Point:
babylonLight.type = 0;
babylonLight.range = light.range;
break;
case LightType.Directional:
babylonLight.type = 1;
break;
case LightType.Spot:
babylonLight.type = 2;
break;
}
babylonLight.position = light.transform.localPosition.ToFloat();
var direction = new Vector3(0, 0, 1);
var transformedDirection = light.transform.TransformDirection(direction);
transformedDirection[0] += exportationOptions.LightRotationOffset.X;
transformedDirection[1] += exportationOptions.LightRotationOffset.Y;
transformedDirection[2] += exportationOptions.LightRotationOffset.Z;
babylonLight.direction = transformedDirection.ToFloat();
babylonLight.diffuse = light.color.ToFloat();
babylonLight.intensity = light.intensity * exportationOptions.LightIntensityFactor;
babylonLight.angle = light.spotAngle * (float)Math.PI / 180;
babylonLight.exponent = 1.0f;
babylonLight.metadata = metaData;
babylonScene.LightsList.Add(babylonLight);
// Animations
ExportAnimations(light.transform, babylonLight);
// Lens Flares
ParseLensFlares(gameObject, babylonLight.id, ref lensFlares);
// Particles Systems
ParseParticleSystems(gameObject, babylonLight.id, ref particleSystems);
// Shadow Maps
if (exportationOptions.ExportShadows)
{
if ((light.type == LightType.Directional || light.type == LightType.Spot) && light.shadows != LightShadows.None)
{
GenerateShadowsGenerator(light, progress);
}
}
}