Unity3D exporter: added support for lightmaps and export&run

Exporters/Unity 5/Unity3D2Babylon/ExportationOptions.cs

@@ -1,23 +1,25 @@
-using System;
-using UnityEngine;
-
-namespace Unity3D2Babylon
-{
-    public class ExportationOptions
-    {
-        public string DefaultFolder { get; set; }
-        public float ReflectionDefaultLevel { get; set; }
-        public bool ExportCollisions { get; set; }
-        public SerializableVector3 CameraEllipsoid { get; set; }
-        public SerializableVector3 Gravity { get; set; }
-
-        public ExportationOptions()
-        {
-            DefaultFolder = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
-            ReflectionDefaultLevel = 0.3f;
-            ExportCollisions = false;
-            CameraEllipsoid = new Vector3(0.5f, 1.0f, 0.5f);
-            Gravity = new Vector3(0, -0.9f, 0);
-        }
-    }
-}
+using System;
+using UnityEngine;
+
+namespace Unity3D2Babylon
+{
+    public class ExportationOptions
+    {
+        public string DefaultFolder { get; set; }
+        public float ReflectionDefaultLevel { get; set; }
+        public bool ExportCollisions { get; set; }
+        public bool ExportPhysics { get; set; }
+        public SerializableVector3 CameraEllipsoid { get; set; }
+        public SerializableVector3 Gravity { get; set; }
+
+        public ExportationOptions()
+        {
+            DefaultFolder = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
+            ReflectionDefaultLevel = 0.3f;
+            ExportCollisions = false;
+            ExportPhysics = false;
+            CameraEllipsoid = new Vector3(0.5f, 1.0f, 0.5f);
+            Gravity = new Vector3(0, -0.9f, 0);
+        }
+    }
+}

Exporters/Unity 5/Unity3D2Babylon/ExporterWindow.cs

@@ -1,137 +1,158 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using JsonFx;
-using UnityEditor;
-using UnityEngine;
-using JsonFx.Json;
-
-namespace Unity3D2Babylon
-{
-    public class ExporterWindow : EditorWindow
-    {
-        private static readonly List<string> logs = new List<string>();
-        Vector2 scrollPos;
-
-        ExportationOptions exportationOptions;
-
-        public static void ReportProgress(float value, string message = "")
-        {
-            EditorUtility.DisplayProgressBar("Babylon.js", message, value);
-
-            if (!string.IsNullOrEmpty(message))
-            {
-                logs.Add(message);
-            }
-        }
-
-        public static void ShowMessage(string message, string title = "Babylon.js")
-        {
-            EditorUtility.DisplayDialog(title, message, "OK");
-        }
-
-        [MenuItem("BabylonJS/Export to .babylon")]
-        public static void Init()
-        {
-            var window = (ExporterWindow)GetWindow(typeof(ExporterWindow));
-            window.Initialize();
-        }
-
-        void Initialize()
-        {
-            titleContent.text = "Babylon.js";
-        }
-
-        void OnGUI()
-        {
-            if (exportationOptions == null)
-            {
-                exportationOptions = new ExportationOptions();
-
-                if (File.Exists("Unity3D2Babylon.ini"))
-                {
-                    var readText = File.ReadAllText("Unity3D2Babylon.ini");
-                    var jsReader = new JsonReader();
-                    exportationOptions = jsReader.Read<ExportationOptions>(readText);
-                }
-            }
-
-            GUILayout.Label("Exportation options", EditorStyles.boldLabel);
-            exportationOptions.ReflectionDefaultLevel = EditorGUILayout.Slider("Reflection default level", exportationOptions.ReflectionDefaultLevel, 0, 1.0f);
-
-            GUILayout.Label("Collisions options", EditorStyles.boldLabel);
-            exportationOptions.ExportCollisions = EditorGUILayout.Toggle("Collisions", exportationOptions.ExportCollisions);
-            exportationOptions.CameraEllipsoid = EditorGUILayout.Vector3Field("Camera's Ellipsoid:", exportationOptions.CameraEllipsoid);
-            exportationOptions.Gravity = EditorGUILayout.Vector3Field("Gravity:", exportationOptions.Gravity);
-
-            EditorGUILayout.Space();
-            EditorGUILayout.Space();
-
-            if (GUILayout.Button("Export"))
-            {
-                Export();
-            }
-
-            EditorGUILayout.Space();
-
-            scrollPos = EditorGUILayout.BeginScrollView(scrollPos);
-
-            foreach (var log in logs)
-            {
-                var bold = log.StartsWith("*");
-
-                GUILayout.Label(bold ? log.Remove(0, 1) : log, bold ? (EditorStyles.boldLabel) : EditorStyles.label);
-            }
-            EditorGUILayout.EndScrollView();
-
-            Repaint();
-        }
-
-        public void Export()
-        {
-            try
-            {
-                int pos = EditorApplication.currentScene.LastIndexOf("/", StringComparison.Ordinal);
-                string sceneName = EditorApplication.currentScene.Substring(pos + 1);
-
-                exportationOptions.DefaultFolder = EditorUtility.SaveFolderPanel("Please select a folder", exportationOptions.DefaultFolder, "");
-
-                if (string.IsNullOrEmpty(exportationOptions.DefaultFolder))
-                {
-                    return;
-                }
-
-                Stopwatch watch = new Stopwatch();
-
-                watch.Start();
-
-                var jsWriter = new JsonWriter();                
-                File.WriteAllText("Unity3D2Babylon.ini", jsWriter.Write(exportationOptions));
-                logs.Clear();
-
-                ReportProgress(0);
-
-                var sceneBuilder = new SceneBuilder(exportationOptions.DefaultFolder, sceneName, exportationOptions);
-
-                sceneBuilder.ConvertFromUnity();
-
-                ReportProgress(1, "Generating output file");
-                sceneBuilder.WriteToBabylonFile();
-
-                watch.Stop();
-                ReportProgress(1, string.Format("Exportation done in {0:0.00}s", watch.Elapsed.TotalSeconds));
-                EditorUtility.ClearProgressBar();
-
-                sceneBuilder.GenerateStatus(logs);
-
-                ShowMessage("Exportation done");
-            }
-            catch (Exception ex)
-            {
-                EditorUtility.ClearProgressBar();
-                ShowMessage("A problem occurred: " + ex.Message + ex.StackTrace, "Error");
-            }
-        }
-    }
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using JsonFx;
+using UnityEditor;
+using UnityEngine;
+using JsonFx.Json;
+
+namespace Unity3D2Babylon
+{
+    public class ExporterWindow : EditorWindow
+    {
+        private static readonly List<string> logs = new List<string>();
+        Vector2 scrollPos;
+
+        ExportationOptions exportationOptions;
+
+        public static void ReportProgress(float value, string message = "")
+        {
+            EditorUtility.DisplayProgressBar("Babylon.js", message, value);
+
+            if (!string.IsNullOrEmpty(message))
+            {
+                logs.Add(message);
+            }
+        }
+
+        public static void ShowMessage(string message, string title = "Babylon.js")
+        {
+            EditorUtility.DisplayDialog(title, message, "OK");
+        }
+
+        [MenuItem("BabylonJS/Export to .babylon")]
+        public static void Init()
+        {
+            var window = (ExporterWindow)GetWindow(typeof(ExporterWindow));
+            window.Initialize();
+        }
+
+        void Initialize()
+        {
+            title = "Babylon.js";
+        }
+
+        void OnGUI()
+        {
+            if (exportationOptions == null)
+            {
+                exportationOptions = new ExportationOptions();
+
+                if (File.Exists("Unity3D2Babylon.ini"))
+                {
+                    var readText = File.ReadAllText("Unity3D2Babylon.ini");
+                    var jsReader = new JsonReader();
+                    exportationOptions = jsReader.Read<ExportationOptions>(readText);
+                }
+            }
+
+            GUILayout.Label("Exportation options", EditorStyles.boldLabel);
+            exportationOptions.ReflectionDefaultLevel = EditorGUILayout.Slider("Reflection default level", exportationOptions.ReflectionDefaultLevel, 0, 1.0f);
+
+            EditorGUILayout.Space();
+            GUILayout.Label("Collisions options", EditorStyles.boldLabel);
+            exportationOptions.ExportCollisions = EditorGUILayout.Toggle("Collisions", exportationOptions.ExportCollisions);
+            exportationOptions.CameraEllipsoid = EditorGUILayout.Vector3Field("Camera's Ellipsoid:", exportationOptions.CameraEllipsoid);
+            exportationOptions.Gravity = EditorGUILayout.Vector3Field("Gravity:", exportationOptions.Gravity);
+
+            EditorGUILayout.Space();
+            GUILayout.Label("Physics options", EditorStyles.boldLabel);
+            exportationOptions.ExportPhysics = EditorGUILayout.Toggle("Physics", exportationOptions.ExportPhysics);
+
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+
+            if (GUILayout.Button("Export"))
+            {
+                Export(false);
+            }
+
+            if (WebServer.IsSupported)
+            {
+                if (GUILayout.Button("Export & Run"))
+                {
+                    Export(true);
+                }
+            }
+
+            EditorGUILayout.Space();
+
+            scrollPos = EditorGUILayout.BeginScrollView(scrollPos);
+
+            foreach (var log in logs)
+            {
+                var bold = log.StartsWith("*");
+
+                GUILayout.Label(bold ? log.Remove(0, 1) : log, bold ? (EditorStyles.boldLabel) : EditorStyles.label);
+            }
+            EditorGUILayout.EndScrollView();
+
+            Repaint();
+        }
+
+        public void Export(bool run)
+        {
+            try
+            {
+                int pos = EditorApplication.currentScene.LastIndexOf("/", StringComparison.Ordinal);
+                string sceneName = EditorApplication.currentScene.Substring(pos + 1);
+
+                exportationOptions.DefaultFolder = EditorUtility.SaveFolderPanel("Please select a folder", exportationOptions.DefaultFolder, "");
+
+                if (string.IsNullOrEmpty(exportationOptions.DefaultFolder))
+                {
+                    return;
+                }
+
+                Stopwatch watch = new Stopwatch();
+
+                watch.Start();
+
+                var jsWriter = new JsonWriter();                
+                File.WriteAllText("Unity3D2Babylon.ini", jsWriter.Write(exportationOptions));
+                logs.Clear();
+
+                ReportProgress(0);
+
+                var sceneBuilder = new SceneBuilder(exportationOptions.DefaultFolder, sceneName, exportationOptions);
+
+                sceneBuilder.ConvertFromUnity();
+
+                ReportProgress(1, "Generating output file");
+                var outputFile = sceneBuilder.WriteToBabylonFile();
+
+                watch.Stop();
+                ReportProgress(1, string.Format("Exportation done in {0:0.00}s", watch.Elapsed.TotalSeconds));
+                EditorUtility.ClearProgressBar();
+
+                sceneBuilder.GenerateStatus(logs);
+
+                ShowMessage("Exportation done");
+
+                if (run)
+                {
+                    WebServer.SceneFolder = Path.GetDirectoryName(outputFile);
+                    WebServer.SceneFilename = Path.GetFileName(outputFile);
+
+                    Process.Start("http://localhost:" + WebServer.Port);
+                }
+            }
+            catch (Exception ex)
+            {
+                EditorUtility.ClearProgressBar();
+                ShowMessage("A problem occurred: " + ex.Message + ex.StackTrace, "Error");
+            }
+        }
+    }
 }

Exporters/Unity 5/Unity3D2Babylon/SceneBuilder.Animations.cs

@@ -1,143 +1,143 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using BabylonExport.Entities;
-using UnityEditor;
-using UnityEditor.Animations;
-using UnityEngine;
-
-namespace Unity3D2Babylon
-{
-    partial class SceneBuilder
-    {
-        private static void ExportAnimations(Transform transform, BabylonIAnimatable animatable)
-        {
-            var animator = transform.gameObject.GetComponent<Animator>();
-            if (animator != null)
-            {
-                AnimatorController ac = animator.runtimeAnimatorController as AnimatorController;
-                if (ac == null)
-                {
-                    return;
-                }
-                var layer = ac.layers[0];
-                if (layer == null)
-                {
-                    return;
-                }
-                AnimatorStateMachine sm = layer.stateMachine;
-                if (sm.states.Length > 0)
-                {
-                    var state = sm.states[0].state; // We only support the first one
-                    AnimationClip clip = state.motion as AnimationClip;
-                    if (clip != null)
-                    {
-                        ExportAnimationClip(clip, true, animatable);
-                    }
-                }
-            }
-            else
-            {
-                var animation = transform.gameObject.GetComponent<Animation>();
-                if (animation != null && animation.clip != null)
-                {
-                    ExportAnimationClip(animation.clip, animation.playAutomatically, animatable);
-                }
-            }
-        }
-
-        private static bool IsRotationQuaternionAnimated(BabylonIAnimatable animatable)
-        {
-            if (animatable.animations == null)
-            {
-                return false;
-            }
-
-            return animatable.animations.Any(animation => animation.property.Contains("rotationQuaternion"));
-        }
-
-        private static void ExportAnimationClip(AnimationClip clip, bool autoPlay, BabylonIAnimatable animatable)
-        {
-            var curveBindings = AnimationUtility.GetCurveBindings(clip);
-
-            var animations = new List<BabylonAnimation>();
-
-            var maxFrame = 0;
-
-            foreach (var binding in curveBindings)
-            {
-                var curve = AnimationUtility.GetEditorCurve(clip, binding);
-                string property;
-
-                switch (binding.propertyName)
-                {
-                    case "m_LocalPosition.x":
-                        property = "position.x";
-                        break;
-                    case "m_LocalPosition.y":
-                        property = "position.y";
-                        break;
-                    case "m_LocalPosition.z":
-                        property = "position.z";
-                        break;
-
-                    case "m_LocalRotation.x":
-                        property = "rotationQuaternion.x";
-                        break;
-                    case "m_LocalRotation.y":
-                        property = "rotationQuaternion.y";
-                        break;
-                    case "m_LocalRotation.z":
-                        property = "rotationQuaternion.z";
-                        break;
-                    case "m_LocalRotation.w":
-                        property = "rotationQuaternion.w";
-                        break;
-
-                    case "m_LocalScale.x":
-                        property = "scaling.x";
-                        break;
-                    case "m_LocalScale.y":
-                        property = "scaling.y";
-                        break;
-                    case "m_LocalScale.z":
-                        property = "scaling.z";
-                        break;
-                    default:
-                        continue;
-                }
-
-                var babylonAnimation = new BabylonAnimation
-                {
-                    dataType = (int)BabylonAnimation.DataType.Float,
-                    name = property + " animation",
-                    keys = curve.keys.Select(keyFrame => new BabylonAnimationKey
-                    {
-                        frame = (int)(keyFrame.time * clip.frameRate),
-                        values = new[] { keyFrame.value }
-                    }).ToArray(),
-                    framePerSecond = (int)clip.frameRate,
-                    loopBehavior = (int)BabylonAnimation.LoopBehavior.Cycle,
-                    property = property
-                };
-
-                maxFrame = Math.Max(babylonAnimation.keys.Last().frame, maxFrame);
-
-                animations.Add(babylonAnimation);
-            }
-
-            if (animations.Count > 0)
-            {
-                animatable.animations = animations.ToArray();
-                if (autoPlay)
-                {
-                    animatable.autoAnimate = true;
-                    animatable.autoAnimateFrom = 0;
-                    animatable.autoAnimateTo = maxFrame;
-                    animatable.autoAnimateLoop = clip.isLooping;
-                }
-            }
-        }
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using BabylonExport.Entities;
+using UnityEditor;
+using UnityEditor.Animations;
+using UnityEngine;
+
+namespace Unity3D2Babylon
+{
+    partial class SceneBuilder
+    {
+        private static void ExportAnimations(Transform transform, BabylonIAnimatable animatable)
+        {
+            var animator = transform.gameObject.GetComponent<Animator>();
+            if (animator != null)
+            {
+                AnimatorController ac = animator.runtimeAnimatorController as AnimatorController;
+                if (ac == null)
+                {
+                    return;
+                }
+                var layer = ac.layers[0];
+                if (layer == null)
+                {
+                    return;
+                }
+                AnimatorStateMachine sm = layer.stateMachine;
+                if (sm.states.Length > 0)
+                {
+                    var state = sm.states[0].state; // We only support the first one
+                    AnimationClip clip = state.motion as AnimationClip;
+                    if (clip != null)
+                    {
+                        ExportAnimationClip(clip, true, animatable);
+                    }
+                }
+            }
+            else
+            {
+                var animation = transform.gameObject.GetComponent<Animation>();
+                if (animation != null && animation.clip != null)
+                {
+                    ExportAnimationClip(animation.clip, animation.playAutomatically, animatable);
+                }
+            }
+        }
+
+        private static bool IsRotationQuaternionAnimated(BabylonIAnimatable animatable)
+        {
+            if (animatable.animations == null)
+            {
+                return false;
+            }
+
+            return animatable.animations.Any(animation => animation.property.Contains("rotationQuaternion"));
+        }
+
+        private static void ExportAnimationClip(AnimationClip clip, bool autoPlay, BabylonIAnimatable animatable)
+        {
+            var curveBindings = AnimationUtility.GetCurveBindings(clip);
+
+            var animations = new List<BabylonAnimation>();
+
+            var maxFrame = 0;
+
+            foreach (var binding in curveBindings)
+            {
+                var curve = AnimationUtility.GetEditorCurve(clip, binding);
+                string property;
+
+                switch (binding.propertyName)
+                {
+                    case "m_LocalPosition.x":
+                        property = "position.x";
+                        break;
+                    case "m_LocalPosition.y":
+                        property = "position.y";
+                        break;
+                    case "m_LocalPosition.z":
+                        property = "position.z";
+                        break;
+
+                    case "m_LocalRotation.x":
+                        property = "rotationQuaternion.x";
+                        break;
+                    case "m_LocalRotation.y":
+                        property = "rotationQuaternion.y";
+                        break;
+                    case "m_LocalRotation.z":
+                        property = "rotationQuaternion.z";
+                        break;
+                    case "m_LocalRotation.w":
+                        property = "rotationQuaternion.w";
+                        break;
+
+                    case "m_LocalScale.x":
+                        property = "scaling.x";
+                        break;
+                    case "m_LocalScale.y":
+                        property = "scaling.y";
+                        break;
+                    case "m_LocalScale.z":
+                        property = "scaling.z";
+                        break;
+                    default:
+                        continue;
+                }
+
+                var babylonAnimation = new BabylonAnimation
+                {
+                    dataType = (int)BabylonAnimation.DataType.Float,
+                    name = property + " animation",
+                    keys = curve.keys.Select(keyFrame => new BabylonAnimationKey
+                    {
+                        frame = (int)(keyFrame.time * clip.frameRate),
+                        values = new[] { keyFrame.value }
+                    }).ToArray(),
+                    framePerSecond = (int)clip.frameRate,
+                    loopBehavior = (int)BabylonAnimation.LoopBehavior.Cycle,
+                    property = property
+                };
+
+                maxFrame = Math.Max(babylonAnimation.keys.Last().frame, maxFrame);
+
+                animations.Add(babylonAnimation);
+            }
+
+            if (animations.Count > 0)
+            {
+                animatable.animations = animations.ToArray();
+                if (autoPlay)
+                {
+                    animatable.autoAnimate = true;
+                    animatable.autoAnimateFrom = 0;
+                    animatable.autoAnimateTo = maxFrame;
+                    animatable.autoAnimateLoop = clip.isLooping;
+                }
+            }
+        }
+    }
+}

Exporters/Unity 5/Unity3D2Babylon/SceneBuilder.Cameras.cs

@@ -1,48 +1,48 @@
-using System;
-using BabylonExport.Entities;
-using UnityEngine;
-
-namespace Unity3D2Babylon
-{
-    partial class SceneBuilder
-    {
-        private void ConvertUnityCameraToBabylon(Camera camera, float progress)
-        {
-            ExporterWindow.ReportProgress(progress, "Exporting camera: " + camera.name);
-
-            BabylonCamera babylonCamera = new BabylonCamera
-            {
-                name = camera.name,
-                id = GetID(camera.gameObject),
-                fov = camera.fieldOfView*(float) Math.PI/180,
-                minZ = camera.nearClipPlane,
-                maxZ = camera.farClipPlane,
-                parentId = GetParentID(camera.transform),
-                position = camera.transform.localPosition.ToFloat()
-            };
-
-            var target = new Vector3(0, 0, 1);
-            var transformedTarget = camera.transform.TransformDirection(target);
-            babylonCamera.target = (camera.transform.position + transformedTarget).ToFloat();
-
-            babylonScene.CamerasList.Add(babylonCamera);
-
-            if (Camera.main == camera)
-            {
-                babylonScene.activeCameraID = babylonCamera.id;
-                babylonScene.clearColor = camera.backgroundColor.ToFloat();
-            }
-
-            // Animations
-            ExportAnimations(camera.transform, babylonCamera);
-
-            // Collisions
-            if (exportationOptions.ExportCollisions)
-            {
-                babylonCamera.checkCollisions = true;
-                babylonCamera.applyGravity = true;
-                babylonCamera.ellipsoid = exportationOptions.CameraEllipsoid.ToFloat();
-            }
-        }
-    }
-}
+using System;
+using BabylonExport.Entities;
+using UnityEngine;
+
+namespace Unity3D2Babylon
+{
+    partial class SceneBuilder
+    {
+        private void ConvertUnityCameraToBabylon(Camera camera, float progress)
+        {
+            ExporterWindow.ReportProgress(progress, "Exporting camera: " + camera.name);
+
+            BabylonCamera babylonCamera = new BabylonCamera
+            {
+                name = camera.name,
+                id = GetID(camera.gameObject),
+                fov = camera.fieldOfView*(float) Math.PI/180,
+                minZ = camera.nearClipPlane,
+                maxZ = camera.farClipPlane,
+                parentId = GetParentID(camera.transform),
+                position = camera.transform.localPosition.ToFloat()
+            };
+
+            var target = new Vector3(0, 0, 1);
+            var transformedTarget = camera.transform.TransformDirection(target);
+            babylonCamera.target = (camera.transform.position + transformedTarget).ToFloat();
+
+            babylonScene.CamerasList.Add(babylonCamera);
+
+            if (Camera.main == camera)
+            {
+                babylonScene.activeCameraID = babylonCamera.id;
+                babylonScene.clearColor = camera.backgroundColor.ToFloat();
+            }
+
+            // Animations
+            ExportAnimations(camera.transform, babylonCamera);
+
+            // Collisions
+            if (exportationOptions.ExportCollisions)
+            {
+                babylonCamera.checkCollisions = true;
+                babylonCamera.applyGravity = true;
+                babylonCamera.ellipsoid = exportationOptions.CameraEllipsoid.ToFloat();
+            }
+        }
+    }
+}

Exporters/Unity 5/Unity3D2Babylon/SceneBuilder.Lights.cs

@@ -1,97 +1,97 @@
-using System;
-using System.Collections.Generic;
-using BabylonExport.Entities;
-using UnityEngine;
-using UnityEngine.Rendering;
-
-namespace Unity3D2Babylon
-{
-    partial class SceneBuilder
-    {
-        private void GenerateShadowsGenerator(Light light)
-        {
-            var generator = new BabylonShadowGenerator
-            {
-                lightId = GetID(light.gameObject),
-                usePoissonSampling = light.shadows == LightShadows.Soft,
-                mapSize = 256 + 256 * QualitySettings.GetQualityLevel(),
-                bias = light.shadowBias / 10.0f
-            };
-
-            var renderList = new List<string>();
-            foreach (var gameObject in gameObjects)
-            {
-                var meshFilter = gameObject.GetComponent<MeshFilter>();
-                var renderer = gameObject.GetComponent<Renderer>();
-                if (meshFilter != null && renderer.shadowCastingMode != ShadowCastingMode.Off)
-                {
-                    renderList.Add(GetID(gameObject));
-                    continue;
-                }
-
-                var skinnedMesh = gameObject.GetComponent<SkinnedMeshRenderer>();
-                if (skinnedMesh != null && renderer.shadowCastingMode != ShadowCastingMode.Off)
-                {
-                    renderList.Add(GetID(gameObject));
-                }
-            }
-
-            generator.renderList = renderList.ToArray();
-
-            babylonScene.ShadowGeneratorsList.Add(generator);
-        }
-
-        private void ConvertUnityLightToBabylon(Light light, float progress)
-        {
-            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 ((light.type == LightType.Directional || light.type == LightType.Spot) && light.shadows != LightShadows.None)
-            {
-                GenerateShadowsGenerator(light);
-            }
-        }
-    }
-}
+using System;
+using System.Collections.Generic;
+using BabylonExport.Entities;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace Unity3D2Babylon
+{
+    partial class SceneBuilder
+    {
+        private void GenerateShadowsGenerator(Light light)
+        {
+            var generator = new BabylonShadowGenerator
+            {
+                lightId = GetID(light.gameObject),
+                usePoissonSampling = light.shadows == LightShadows.Soft,
+                mapSize = 256 + 256 * QualitySettings.GetQualityLevel(),
+                bias = light.shadowBias / 10.0f
+            };
+
+            var renderList = new List<string>();
+            foreach (var gameObject in gameObjects)
+            {
+                var meshFilter = gameObject.GetComponent<MeshFilter>();
+                var renderer = gameObject.GetComponent<Renderer>();
+                if (meshFilter != null && renderer != null && renderer.shadowCastingMode != ShadowCastingMode.Off)
+                {
+                    renderList.Add(GetID(gameObject));
+                    continue;
+                }
+
+                var skinnedMesh = gameObject.GetComponent<SkinnedMeshRenderer>();
+                if (skinnedMesh != null && renderer != null && renderer.shadowCastingMode != ShadowCastingMode.Off)
+                {
+                    renderList.Add(GetID(gameObject));
+                }
+            }
+
+            generator.renderList = renderList.ToArray();
+
+            babylonScene.ShadowGeneratorsList.Add(generator);
+        }
+
+        private void ConvertUnityLightToBabylon(Light light, float progress)
+        {
+            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 ((light.type == LightType.Directional || light.type == LightType.Spot) && light.shadows != LightShadows.None)
+            {
+                GenerateShadowsGenerator(light);
+            }
+        }
+    }
+}

Exporters/Unity 5/Unity3D2Babylon/SceneBuilder.Materials.cs

@@ -1,284 +1,307 @@
-using System;
-using System.IO;
-using BabylonExport.Entities;
-using UnityEditor;
-using UnityEngine;
-
-namespace Unity3D2Babylon
-{
-    partial class SceneBuilder
-    {
-        private void CopyTextureCube(string texturePath, Cubemap cubemap, BabylonTexture babylonTexture)
-        {
-            if (!babylonScene.AddTextureCube(texturePath))
-            {
-                return;
-            }
-
-            try
-            {
-                foreach (CubemapFace face in Enum.GetValues(typeof(CubemapFace)))
-                {
-                    var faceTexturePath = Path.Combine(babylonScene.OutputPath, Path.GetFileNameWithoutExtension(texturePath));
-
-                    switch (face)
-                    {
-                        case CubemapFace.PositiveX:
-                            faceTexturePath += "_px.jpg";
-                            break;
-                        case CubemapFace.NegativeX:
-                            faceTexturePath += "_nx.jpg";
-                            break;
-                        case CubemapFace.PositiveY:
-                            faceTexturePath += "_py.jpg";
-                            break;
-                        case CubemapFace.NegativeY:
-                            faceTexturePath += "_ny.jpg";
-                            break;
-                        case CubemapFace.PositiveZ:
-                            faceTexturePath += "_pz.jpg";
-                            break;
-                        case CubemapFace.NegativeZ:
-                            faceTexturePath += "_nz.jpg";
-                            break;
-                    }
-
-                    var tempTexture = new Texture2D(cubemap.width, cubemap.height, cubemap.format, false);
-
-                    tempTexture.SetPixels(cubemap.GetPixels(face));
-                    tempTexture.Apply();
-
-                    File.WriteAllBytes(faceTexturePath, tempTexture.EncodeToJPG());
-                }
-
-            }
-            catch (Exception ex)
-            {
-                Debug.LogException(ex);
-            }
-
-            var textureName = Path.GetFileNameWithoutExtension(texturePath);
-            babylonTexture.name = textureName;
-            babylonTexture.isCube = true;
-            babylonTexture.level = exportationOptions.ReflectionDefaultLevel;
-            babylonTexture.coordinatesMode = 3;
-        }
-
-        private void CopyTexture(string texturePath, Texture2D texture2D, BabylonTexture babylonTexture)
-        {
-            bool needToDelete = false;
-            var useJPG = !texture2D.alphaIsTransparency;
-
-            // Convert unsupported file extensions
-            if (texturePath.EndsWith(".psd") || texturePath.EndsWith(".tif") || texturePath.EndsWith(".exr"))
-            {
-                try
-                {
-                    // Change texture import settings to be able to read texture data
-                    var textureImporter = AssetImporter.GetAtPath(texturePath) as TextureImporter;
-                    var previousIsReadable = textureImporter.isReadable;
-                    var previousNormalMap = textureImporter.normalmap;
-                    var previousLightmap = textureImporter.lightmap;
-                    var previousConvertToNormalmap = textureImporter.convertToNormalmap;
-                    var previousTextureType = textureImporter.textureType;
-                    var previousGrayscaleToAlpha = textureImporter.grayscaleToAlpha;
-                    textureImporter.textureType = TextureImporterType.Advanced;
-                    textureImporter.isReadable = true;
-                    textureImporter.lightmap = false;
-                    textureImporter.normalmap = false;
-                    textureImporter.convertToNormalmap = false;
-                    textureImporter.grayscaleToAlpha = false;
-
-                    AssetDatabase.ImportAsset(texturePath);
-
-                    texturePath = Path.Combine(Path.GetTempPath(), Path.GetFileName(texturePath));
-                    var extension = useJPG ? ".jpg" : ".png";
-                    texturePath = texturePath.Replace(".psd", extension).Replace(".tif", extension).Replace(".exr", extension);
-
-                    var tempTexture = new Texture2D(texture2D.width, texture2D.height, TextureFormat.ARGB32, false);
-
-                    tempTexture.SetPixels32(texture2D.GetPixels32());
-                    tempTexture.Apply();
-
-                    File.WriteAllBytes(texturePath, useJPG ? tempTexture.EncodeToJPG() : tempTexture.EncodeToPNG());
-
-                    needToDelete = true;
-
-                    // Restore
-                    textureImporter.isReadable = previousIsReadable;
-                    textureImporter.normalmap = previousNormalMap;
-                    textureImporter.lightmap = previousLightmap;
-                    textureImporter.convertToNormalmap = previousConvertToNormalmap;
-                    textureImporter.textureType = previousTextureType;
-                    textureImporter.grayscaleToAlpha = previousGrayscaleToAlpha;
-                   
-                    AssetDatabase.ImportAsset(texturePath, ImportAssetOptions.ForceUpdate);
-                }
-                catch (Exception ex)
-                {
-                    Debug.LogException(ex);
-                }
-            }
-
-            var textureName = Path.GetFileName(texturePath);
-            babylonTexture.name = textureName;
-            babylonScene.AddTexture(texturePath);
-
-            if (needToDelete)
-            {
-                File.Delete(texturePath);
-            }
-        }
-
-        private BabylonMaterial DumpMaterial(Material material, Renderer renderer)
-        {
-            if (!materialsDictionary.ContainsKey(material.name))
-            {
-                var bMat = new BabylonMaterial
-                {
-                    name = material.name,
-                    id = Guid.NewGuid().ToString(),
-                    diffuse = new float[4],
-                    specular = new float[4]
-                };
-
-                bMat.diffuse[0] = 1.0f;
-                bMat.diffuse[1] = 1.0f;
-                bMat.diffuse[2] = 1.0f;
-                bMat.diffuse[3] = 1.0f;
-
-                if (material.HasProperty("_Color"))
-                {
-                    bMat.diffuse = material.color.ToFloat();
-                }
-
-                if (material.HasProperty("_SpecColor"))
-                {
-                    var specColor = material.GetColor("_SpecColor");
-                    bMat.specular = specColor.ToFloat();
-                }
-
-                if (material.HasProperty("_Shininess"))
-                {
-                    var specShininess = material.GetFloat("_Shininess");
-                    bMat.specularPower = specShininess * 128;
-                }
-
-                if (material.HasProperty("_Emission"))
-                {
-                    var emissiveColor = material.GetColor("_Emission");
-                    bMat.emissive = emissiveColor.ToFloat();
-                }
-
-                if (material.mainTexture)
-                {
-                    var mainTexturePath = AssetDatabase.GetAssetPath(material.mainTexture);
-                    bMat.diffuseTexture = new BabylonTexture
-                    {
-                        uScale = material.mainTextureScale.x,
-                        vScale = material.mainTextureScale.y,
-                        uOffset = material.mainTextureOffset.x,
-                        vOffset = material.mainTextureOffset.y
-                    };
-
-                    var mainTexture2D = material.mainTexture as Texture2D;
-
-                    CopyTexture(mainTexturePath, mainTexture2D, bMat.diffuseTexture);
-
-                    var alphaCuttOff = 0f;
-
-                    if (material.HasProperty("_Cutoff"))
-                    {
-                        alphaCuttOff = material.GetFloat("_Cutoff");
-                    }
-
-                    if ((mainTexture2D && mainTexture2D.alphaIsTransparency) || alphaCuttOff > 0)
-                    {
-                        bMat.diffuseTexture.hasAlpha = true;
-                        bMat.backFaceCulling = false;
-                    }
-
-                    bMat.diffuse[0] = 1.0f;
-                    bMat.diffuse[1] = 1.0f;
-                    bMat.diffuse[2] = 1.0f;
-                    bMat.diffuse[3] = 1.0f;
-                }
-
-                bMat.bumpTexture = DumpTextureFromMaterial(material, "_BumpMap");
-                bMat.emissiveTexture = DumpTextureFromMaterial(material, "_Illum");
-                bMat.ambientTexture = DumpTextureFromMaterial(material, "_LightMap");
-                bMat.reflectionTexture = DumpTextureFromMaterial(material, "_Cube");
-
-                //if (bMat.ambientTexture == null && renderer.lightmapIndex >= 0 && renderer.lightmapIndex != 255 && LightmapSettings.lightmaps.Length > renderer.lightmapIndex)
-                //{
-                //    var lightmap = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapFar;
-                //    bMat.ambientTexture = DumpTexture(lightmap);
-                //    bMat.ambientTexture.coordinatesIndex = 1;
-
-                //    bMat.ambientTexture.uScale = renderer.lightmapTilingOffset.x;
-                //    bMat.ambientTexture.vScale = renderer.lightmapTilingOffset.y;
-
-                //    bMat.ambientTexture.uOffset = renderer.lightmapTilingOffset.z;
-                //    bMat.ambientTexture.vOffset = renderer.lightmapTilingOffset.w;
-                //}
-
-                materialsDictionary.Add(bMat.name, bMat);
-                return bMat;
-            }
-
-            return materialsDictionary[material.name];
-        }
-
-        private BabylonTexture DumpTextureFromMaterial(Material material, string name)
-        {
-            if (!material.HasProperty(name))
-            {
-                return null;
-            }
-
-            var texture = material.GetTexture(name);
-            return DumpTexture(texture, material, name);
-        }
-
-        private BabylonTexture DumpTexture(Texture texture, Material material = null, string name = "")
-        {
-            if (texture == null)
-            {
-                return null;
-            }
-            var texturePath = AssetDatabase.GetAssetPath(texture);
-            var textureName = Path.GetFileName(texturePath);
-            var babylonTexture = new BabylonTexture { name = textureName };
-
-            if (material != null)
-            {
-                var textureScale = material.GetTextureScale(name);
-                babylonTexture.uScale = textureScale.x;
-                babylonTexture.vScale = textureScale.y;
-
-                var textureOffset = material.GetTextureOffset(name);
-                babylonTexture.uOffset = textureOffset.x;
-                babylonTexture.vOffset = textureOffset.y;
-            }
-
-            var texture2D = texture as Texture2D;
-
-            if (texture2D)
-            {
-                babylonTexture.hasAlpha = texture2D.alphaIsTransparency;
-
-                CopyTexture(texturePath, texture2D, babylonTexture);
-            }
-            else
-            {
-                var cubemap = texture as Cubemap;
-                if (cubemap != null)
-                {
-                    CopyTextureCube(texturePath, cubemap, babylonTexture);
-                }
-            }
-
-            return babylonTexture;
-        }
-    }
-}
+using System;
+using System.IO;
+using BabylonExport.Entities;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity3D2Babylon
+{
+    partial class SceneBuilder
+    {
+        private void CopyTextureCube(string texturePath, Cubemap cubemap, BabylonTexture babylonTexture)
+        {
+            if (!babylonScene.AddTextureCube(texturePath))
+            {
+                return;
+            }
+
+            try
+            {
+                foreach (CubemapFace face in Enum.GetValues(typeof(CubemapFace)))
+                {
+                    var faceTexturePath = Path.Combine(babylonScene.OutputPath, Path.GetFileNameWithoutExtension(texturePath));
+
+                    switch (face)
+                    {
+                        case CubemapFace.PositiveX:
+                            faceTexturePath += "_px.jpg";
+                            break;
+                        case CubemapFace.NegativeX:
+                            faceTexturePath += "_nx.jpg";
+                            break;
+                        case CubemapFace.PositiveY:
+                            faceTexturePath += "_py.jpg";
+                            break;
+                        case CubemapFace.NegativeY:
+                            faceTexturePath += "_ny.jpg";
+                            break;
+                        case CubemapFace.PositiveZ:
+                            faceTexturePath += "_pz.jpg";
+                            break;
+                        case CubemapFace.NegativeZ:
+                            faceTexturePath += "_nz.jpg";
+                            break;
+                    }
+
+                    var tempTexture = new Texture2D(cubemap.width, cubemap.height, cubemap.format, false);
+
+                    tempTexture.SetPixels(cubemap.GetPixels(face));
+                    tempTexture.Apply();
+
+                    File.WriteAllBytes(faceTexturePath, tempTexture.EncodeToJPG());
+                }
+
+            }
+            catch (Exception ex)
+            {
+                Debug.LogException(ex);
+            }
+
+            var textureName = Path.GetFileNameWithoutExtension(texturePath);
+            babylonTexture.name = textureName;
+            babylonTexture.isCube = true;
+            babylonTexture.level = exportationOptions.ReflectionDefaultLevel;
+            babylonTexture.coordinatesMode = 3;
+        }
+
+        private void CopyTexture(string texturePath, Texture2D texture2D, BabylonTexture babylonTexture, bool isLightmap = false)
+        {
+            bool needToDelete = false;
+            var useJPG = !texture2D.alphaIsTransparency;
+
+            // Convert unsupported file extensions
+            if (texturePath.EndsWith(".psd") || texturePath.EndsWith(".tif") || texturePath.EndsWith(".exr"))
+            {
+                try
+                {
+                    // Change texture import settings to be able to read texture data
+                    var textureImporter = AssetImporter.GetAtPath(texturePath) as TextureImporter;
+                    var previousIsReadable = textureImporter.isReadable;
+                    var previousNormalMap = textureImporter.normalmap;
+                    var previousLightmap = textureImporter.lightmap;
+                    var previousConvertToNormalmap = textureImporter.convertToNormalmap;
+                    var previousTextureType = textureImporter.textureType;
+                    var previousGrayscaleToAlpha = textureImporter.grayscaleToAlpha;
+
+                    textureImporter.textureType = TextureImporterType.Advanced;
+                    textureImporter.isReadable = true;
+                    textureImporter.lightmap = false;
+                    textureImporter.normalmap = false;
+                    textureImporter.convertToNormalmap = false;
+                    textureImporter.grayscaleToAlpha = false;
+
+                    AssetDatabase.ImportAsset(texturePath);
+
+                    texturePath = Path.Combine(Path.GetTempPath(), Path.GetFileName(texturePath));
+                    var extension = useJPG ? ".jpg" : ".png";
+                    texturePath = texturePath.Replace(".psd", extension).Replace(".tif", extension).Replace(".exr", extension);
+
+                    var tempTexture = new Texture2D(texture2D.width, texture2D.height, TextureFormat.ARGB32, false);
+
+                    if (isLightmap)
+                    {
+                        Color[] pixels = texture2D.GetPixels(0, 0, texture2D.width, texture2D.height);
+                        for (int index = 0; index < pixels.Length; index++)
+                        {
+                            pixels[index].r = pixels[index].r * pixels[index].a * 5;
+                            pixels[index].g = pixels[index].g * pixels[index].a * 5;
+                            pixels[index].b = pixels[index].b * pixels[index].a * 5;
+                        }
+                        tempTexture.SetPixels(pixels);
+                    }
+                    else {
+                        tempTexture.SetPixels32(texture2D.GetPixels32());
+                    }
+                    tempTexture.Apply();
+
+                    File.WriteAllBytes(texturePath, useJPG ? tempTexture.EncodeToJPG() : tempTexture.EncodeToPNG());
+
+                    needToDelete = true;
+
+                    // Restore
+                    textureImporter.isReadable = previousIsReadable;
+                    textureImporter.normalmap = previousNormalMap;
+                    textureImporter.lightmap = previousLightmap;
+                    textureImporter.convertToNormalmap = previousConvertToNormalmap;
+                    textureImporter.textureType = previousTextureType;
+                    textureImporter.grayscaleToAlpha = previousGrayscaleToAlpha;
+                   
+                    AssetDatabase.ImportAsset(texturePath, ImportAssetOptions.ForceUpdate);
+                }
+                catch (Exception ex)
+                {
+                    Debug.LogException(ex);
+                }
+            }
+
+            var textureName = Path.GetFileName(texturePath);
+            babylonTexture.name = textureName;
+            babylonScene.AddTexture(texturePath);
+
+            if (needToDelete)
+            {
+                File.Delete(texturePath);
+            }
+        }
+
+        private BabylonMaterial DumpMaterial(Material material, Renderer renderer)
+        {
+            var materialNotSupported = false; 
+
+            if (!materialsDictionary.ContainsKey(material.name))
+            {
+                var bMat = new BabylonMaterial
+                {
+                    name = material.name,
+                    id = Guid.NewGuid().ToString(),
+                    diffuse = new float[4],
+                    specular = new float[4]
+                };
+
+                bMat.diffuse[0] = 1.0f;
+                bMat.diffuse[1] = 1.0f;
+                bMat.diffuse[2] = 1.0f;
+                bMat.diffuse[3] = 1.0f;
+
+                if (material.HasProperty("_Color"))
+                {
+                    bMat.diffuse = material.color.ToFloat();
+                }
+
+                if (material.HasProperty("_SpecColor"))
+                {
+                    var specColor = material.GetColor("_SpecColor");
+                    bMat.specular = specColor.ToFloat();
+                }
+
+                if (material.HasProperty("_Shininess"))
+                {
+                    var specShininess = material.GetFloat("_Shininess");
+                    bMat.specularPower = specShininess * 128;
+                }
+
+                if (material.HasProperty("_Emission"))
+                {
+                    var emissiveColor = material.GetColor("_Emission");
+                    bMat.emissive = emissiveColor.ToFloat();
+                }
+
+                if (material.mainTexture && material.mainTexture.GetType().FullName == "UnityEngine.ProceduralTexture")
+                {
+                    materialNotSupported = true;
+                    Debug.LogWarning("ProceduralTexture: " + material.mainTexture.name + " not supported by Babylon.js");
+                }
+
+                if (material.mainTexture && !(materialNotSupported))
+                {
+                    var mainTexturePath = AssetDatabase.GetAssetPath(material.mainTexture);
+                    bMat.diffuseTexture = new BabylonTexture
+                    {
+                        uScale = material.mainTextureScale.x,
+                        vScale = material.mainTextureScale.y,
+                        uOffset = material.mainTextureOffset.x,
+                        vOffset = material.mainTextureOffset.y
+                    };
+
+                    var mainTexture2D = material.mainTexture as Texture2D;
+
+                    CopyTexture(mainTexturePath, mainTexture2D, bMat.diffuseTexture);
+
+                    var alphaCuttOff = 0f;
+
+                    if (material.HasProperty("_Cutoff"))
+                    {
+                        alphaCuttOff = material.GetFloat("_Cutoff");
+                    }
+
+                    if ((mainTexture2D && mainTexture2D.alphaIsTransparency) || alphaCuttOff > 0)
+                    {
+                        bMat.diffuseTexture.hasAlpha = true;
+                        bMat.backFaceCulling = false;
+                    }
+
+                    bMat.diffuse[0] = 1.0f;
+                    bMat.diffuse[1] = 1.0f;
+                    bMat.diffuse[2] = 1.0f;
+                    bMat.diffuse[3] = 1.0f;
+                }
+
+                bMat.bumpTexture = DumpTextureFromMaterial(material, "_BumpMap");
+                bMat.emissiveTexture = DumpTextureFromMaterial(material, "_Illum");
+                bMat.ambientTexture = DumpTextureFromMaterial(material, "_LightMap");
+                bMat.reflectionTexture = DumpTextureFromMaterial(material, "_Cube");
+
+                if (bMat.ambientTexture == null && renderer.lightmapIndex >= 0 && renderer.lightmapIndex != 255 && LightmapSettings.lightmaps.Length > renderer.lightmapIndex)
+                {
+                    var lightmap = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapFar;
+                    bMat.lightmapTexture = DumpTexture(lightmap, isLightmap: true);
+                    bMat.lightmapTexture.coordinatesIndex = 1;
+                    bMat.useLightmapAsShadowmap = true;
+
+                    bMat.lightmapTexture.uScale = renderer.lightmapScaleOffset.x;
+                    bMat.lightmapTexture.vScale = renderer.lightmapScaleOffset.y;
+
+                    bMat.lightmapTexture.uOffset = renderer.lightmapScaleOffset.z;
+                    bMat.lightmapTexture.vOffset = renderer.lightmapScaleOffset.w;
+                }
+
+                materialsDictionary.Add(bMat.name, bMat);
+                return bMat;
+            }
+
+            return materialsDictionary[material.name];
+        }
+
+        private BabylonTexture DumpTextureFromMaterial(Material material, string name)
+        {
+            if (!material.HasProperty(name))
+            {
+                return null;
+            }
+
+            var texture = material.GetTexture(name);
+            return DumpTexture(texture, material, name);
+        }
+
+        private BabylonTexture DumpTexture(Texture texture, Material material = null, string name = "", bool isLightmap = false)
+        {
+            if (texture == null)
+            {
+                return null;
+            }
+            var texturePath = AssetDatabase.GetAssetPath(texture);
+            var textureName = Path.GetFileName(texturePath);
+            var babylonTexture = new BabylonTexture { name = textureName };
+
+            if (material != null)
+            {
+                var textureScale = material.GetTextureScale(name);
+                babylonTexture.uScale = textureScale.x;
+                babylonTexture.vScale = textureScale.y;
+
+                var textureOffset = material.GetTextureOffset(name);
+                babylonTexture.uOffset = textureOffset.x;
+                babylonTexture.vOffset = textureOffset.y;
+            }
+
+            var texture2D = texture as Texture2D;
+
+            if (texture2D)
+            {
+                babylonTexture.hasAlpha = texture2D.alphaIsTransparency;
+
+                CopyTexture(texturePath, texture2D, babylonTexture, isLightmap);
+            }
+            else
+            {
+                var cubemap = texture as Cubemap;
+                if (cubemap != null)
+                {
+                    CopyTextureCube(texturePath, cubemap, babylonTexture);
+                }
+            }
+
+            return babylonTexture;
+        }
+    }
+}

Exporters/Unity 5/Unity3D2Babylon/SceneBuilder.Meshes.cs

@@ -1,291 +1,264 @@
-using System;
-using BabylonExport.Entities;
-using UnityEngine;
-
-namespace Unity3D2Babylon
-{
-    partial class SceneBuilder
-    {
-        private BabylonAbstractMesh ConvertUnityMeshToInstance(GameObject gameObject)
-        {
-            BabylonAbstractMesh babylonMesh = new BabylonAbstractMesh();
-
-            Transform transform = gameObject.transform;
-            babylonMesh.name = gameObject.name;
-            babylonMesh.position = new float[3];
-            babylonMesh.position[0] = transform.position.x;
-            babylonMesh.position[1] = transform.position.y;
-            babylonMesh.position[2] = transform.position.z;
-
-            babylonMesh.rotation = new float[3];
-            babylonMesh.rotation[0] = transform.rotation.eulerAngles.x * (float)Math.PI / 180;
-            babylonMesh.rotation[1] = transform.rotation.eulerAngles.y * (float)Math.PI / 180;
-            babylonMesh.rotation[2] = transform.rotation.eulerAngles.z * (float)Math.PI / 180;
-
-            babylonMesh.scaling = new float[3];
-            babylonMesh.scaling[0] = transform.localScale.x;
-            babylonMesh.scaling[1] = transform.localScale.y;
-            babylonMesh.scaling[2] = transform.localScale.z;
-            return babylonMesh;
-        }
-
-        private void ConvertTransform(BabylonMesh babylonMesh, Transform transform, GameObject gameObject, BabylonAbstractMesh[] instances = null)
-        {
-            Action SetTransformFromGameobject = () =>
-            {
-                babylonMesh.position = transform.localPosition.ToFloat();
-
-                babylonMesh.rotation = new float[3];
-                babylonMesh.rotation[0] = transform.localRotation.eulerAngles.x * (float)Math.PI / 180;
-                babylonMesh.rotation[1] = transform.localRotation.eulerAngles.y * (float)Math.PI / 180;
-                babylonMesh.rotation[2] = transform.localRotation.eulerAngles.z * (float)Math.PI / 180;
-
-                babylonMesh.scaling = transform.localScale.ToFloat();
-            };
-
-            Action SetTransformFromFirstInstance = () =>
-            {
-                BabylonAbstractMesh first = instances[0];
-
-                babylonMesh.position = new float[3];
-                babylonMesh.position[0] = first.position[0];
-                babylonMesh.position[1] = first.position[1];
-                babylonMesh.position[2] = first.position[2];
-
-                babylonMesh.rotation = new float[3];
-                babylonMesh.rotation[0] = first.rotation[0];
-                babylonMesh.rotation[1] = first.rotation[1];
-                babylonMesh.rotation[2] = first.rotation[2];
-
-                babylonMesh.scaling = new float[3];
-                babylonMesh.scaling[0] = first.scaling[0];
-                babylonMesh.scaling[1] = first.scaling[1];
-                babylonMesh.scaling[2] = first.scaling[2];
-            };
-
-            //Check if this is a prefab
-            if (instances != null)
-            {
-                /*
-                    Unity3D prefabs don't have transforms (position, rotation, scale) because they are just a template and are not drawn on screen          
-                    but Babylon.js meshes must have a transform because they are drawn on the screen
-                    so what we do is take the first instance
-                    copy its transform (position, rotation, scale) into the prefab mesh
-                    then remove that first instance
-                */
-
-                babylonMesh.instances = new BabylonAbstractMesh[instances.Length - 1];
-
-                //Effectively remove first instance from list of all instances
-                for (int i = 0; i < instances.Length - 1; i++)
-                {
-                    babylonMesh.instances[i] = instances[i + 1];
-                }
-
-                //If this is the root object then copy values directly from first instance
-                if (GetParentID(transform) == null)
-                {
-                    SetTransformFromFirstInstance();
-                }
-                else
-                {
-                    GameObject parent = gameObject.transform.parent.gameObject;
-                    if ((parent.GetComponent<Light>() == null) && (parent.GetComponent<Camera>() == null))
-                    {
-                        SetTransformFromGameobject();
-                    } else
-                    {
-                        SetTransformFromFirstInstance();
-                    }
-                }
-            }
-            else
-            {
-                SetTransformFromGameobject();
-            }
-        }
-
-        private void ConvertUnityEmptyObjectToBabylon(GameObject gameObject, BabylonAbstractMesh[] instances = null)
-        {
-            BabylonMesh babylonMesh = new BabylonMesh { name = gameObject.name, id = GetID(gameObject) };
-
-            var transform = gameObject.transform;
-
-            babylonMesh.parentId = GetParentID(transform);
-            ConvertTransform(babylonMesh, transform, gameObject, instances);
-
-            babylonScene.MeshesList.Add(babylonMesh);
-
-            // Animations
-            ExportAnimations(transform, babylonMesh);
-
-            if (IsRotationQuaternionAnimated(babylonMesh))
-            {
-                babylonMesh.rotationQuaternion = transform.localRotation.ToFloat();
-            }
-        }
-
-        private void ConvertUnityMeshToBabylon(Mesh mesh, Transform transform, GameObject gameObject, float progress, BabylonAbstractMesh[] instances = null)
-        {
-            BabylonMesh babylonMesh = new BabylonMesh();
-            var renderer = gameObject.GetComponent<Renderer>();
-
-            ExporterWindow.ReportProgress(progress, "Exporting mesh: " + gameObject.name);
-
-            babylonMesh.name = gameObject.name;
-            babylonMesh.id = GetID(transform.gameObject);
-            babylonMesh.receiveShadows = renderer.receiveShadows;
-
-            babylonMesh.parentId = GetParentID(transform);
-            ConvertTransform(babylonMesh, transform, gameObject, instances);
-
-            babylonMesh.positions = new float[mesh.vertexCount * 3];
-
-            for (int i = 0; i < mesh.vertices.Length; i++)
-            {
-                babylonMesh.positions[i * 3] = mesh.vertices[i].x;
-                babylonMesh.positions[(i * 3) + 1] = mesh.vertices[i].y;
-                babylonMesh.positions[(i * 3) + 2] = mesh.vertices[i].z;
-
-                // Computing world extends
-                var worldPosition = transform.TransformPoint(mesh.vertices[i]);
-
-                if (worldPosition.x > babylonScene.MaxVector.X)
-                {
-                    babylonScene.MaxVector.X = worldPosition.x;
-                }
-                if (worldPosition.y > babylonScene.MaxVector.Y)
-                {
-                    babylonScene.MaxVector.Y = worldPosition.y;
-                }
-                if (worldPosition.z > babylonScene.MaxVector.Z)
-                {
-                    babylonScene.MaxVector.Z = worldPosition.z;
-                }
-
-                if (worldPosition.x < babylonScene.MinVector.X)
-                {
-                    babylonScene.MinVector.X = worldPosition.x;
-                }
-                if (worldPosition.y < babylonScene.MinVector.Y)
-                {
-                    babylonScene.MinVector.Y = worldPosition.y;
-                }
-                if (worldPosition.z < babylonScene.MinVector.Z)
-                {
-                    babylonScene.MinVector.Z = worldPosition.z;
-                }
-            }
-
-            babylonMesh.normals = new float[mesh.vertexCount * 3];
-
-            for (int i = 0; i < mesh.normals.Length; i++)
-            {
-                babylonMesh.normals[i * 3] = mesh.normals[i].x;
-                babylonMesh.normals[(i * 3) + 1] = mesh.normals[i].y;
-                babylonMesh.normals[(i * 3) + 2] = mesh.normals[i].z;
-            }
-
-            babylonMesh.uvs = new float[mesh.vertexCount * 2];
-
-            for (int i = 0; i < mesh.uv.Length; i++)
-            {
-                babylonMesh.uvs[i * 2] = mesh.uv[i].x;
-                babylonMesh.uvs[(i * 2) + 1] = mesh.uv[i].y;
-            }
-
-            if (mesh.uv2 != null)
-            {
-                babylonMesh.uvs2 = new float[mesh.vertexCount * 2];
-
-                for (int i = 0; i < mesh.uv2.Length; i++)
-                {
-                    babylonMesh.uvs2[i * 2] = mesh.uv2[i].x;
-                    babylonMesh.uvs2[(i * 2) + 1] = mesh.uv2[i].y;
-                }
-            }
-
-            babylonMesh.indices = new int[mesh.triangles.Length];
-
-            for (int i = 0; i < mesh.triangles.Length; i += 3)
-            {
-                babylonMesh.indices[i] = mesh.triangles[i + 2];
-                babylonMesh.indices[i + 1] = mesh.triangles[i + 1];
-                babylonMesh.indices[i + 2] = mesh.triangles[i];
-            }
-
-            if (mesh.subMeshCount > 1) // Multimaterials
-            {
-                BabylonMultiMaterial bMultiMat;
-                if (!multiMatDictionary.ContainsKey(renderer.sharedMaterial.name))
-                {
-                    bMultiMat = new BabylonMultiMaterial
-                    {
-                        materials = new string[mesh.subMeshCount],
-                        id = Guid.NewGuid().ToString(),
-                        name = renderer.sharedMaterial.name
-                    };
-
-                    for (int i = 0; i < renderer.sharedMaterials.Length; i++)
-                    {
-                        var bMat = DumpMaterial(renderer.sharedMaterials[i], renderer);
-                        bMultiMat.materials[i] = bMat.id;
-                    }
-                    if (mesh.subMeshCount > 1)
-                    {
-                        multiMatDictionary.Add(bMultiMat.name, bMultiMat);
-                    }
-                }
-                else
-                {
-                    bMultiMat = multiMatDictionary[renderer.sharedMaterial.name];
-                }
-
-                babylonMesh.materialId = bMultiMat.id;
-                babylonMesh.subMeshes = new BabylonSubMesh[mesh.subMeshCount];
-
-                var offset = 0;
-                for (int materialIndex = 0; materialIndex < mesh.subMeshCount; materialIndex++)
-                {
-                    var unityTriangles = mesh.GetTriangles(materialIndex);
-
-                    babylonMesh.subMeshes[materialIndex] = new BabylonSubMesh
-                    {
-                        verticesStart = 0,
-                        verticesCount = mesh.vertexCount,
-                        materialIndex = materialIndex,
-                        indexStart = offset,
-                        indexCount = unityTriangles.Length
-                    };
-
-                    offset += unityTriangles.Length;
-                }
-            }
-            else
-            {
-                babylonMesh.materialId = DumpMaterial(renderer.sharedMaterial, renderer).id;
-            }
-
-            babylonScene.MeshesList.Add(babylonMesh);
-
-            // Animations
-            ExportAnimations(transform, babylonMesh);
-
-            if (IsRotationQuaternionAnimated(babylonMesh))
-            {
-                babylonMesh.rotationQuaternion = transform.localRotation.ToFloat();
-            }
-
-            // Collisions
-            if (exportationOptions.ExportCollisions)
-            {
-                var collider = gameObject.GetComponent<Collider>();
-
-                if (collider != null)
-                {
-                    babylonMesh.checkCollisions = true;
-                }
-            }
-        }
-    }
-}
+using System;
+using BabylonExport.Entities;
+using UnityEngine;
+
+namespace Unity3D2Babylon
+{
+    partial class SceneBuilder
+    {
+        private void ConvertUnityEmptyObjectToBabylon(GameObject gameObject)
+        {
+            BabylonMesh babylonMesh = new BabylonMesh { name = gameObject.name, id = GetID(gameObject) };
+
+            var transform = gameObject.transform;
+
+            babylonMesh.parentId = GetParentID(transform);
+
+            babylonMesh.position = transform.localPosition.ToFloat();
+
+            babylonMesh.rotation = new float[3];
+            babylonMesh.rotation[0] = transform.localRotation.eulerAngles.x * (float)Math.PI / 180;
+            babylonMesh.rotation[1] = transform.localRotation.eulerAngles.y * (float)Math.PI / 180;
+            babylonMesh.rotation[2] = transform.localRotation.eulerAngles.z * (float)Math.PI / 180;
+
+            babylonMesh.scaling = transform.localScale.ToFloat();
+
+            babylonScene.MeshesList.Add(babylonMesh);
+
+            // Animations
+            ExportAnimations(transform, babylonMesh);
+
+            if (IsRotationQuaternionAnimated(babylonMesh))
+            {
+                babylonMesh.rotationQuaternion = transform.localRotation.ToFloat();
+            }
+        }
+
+        private void ConvertUnityMeshToBabylon(Mesh mesh, Transform transform, GameObject gameObject, float progress)
+        {
+            BabylonMesh babylonMesh = new BabylonMesh();
+            var renderer = gameObject.GetComponent<Renderer>();
+
+            ExporterWindow.ReportProgress(progress, "Exporting mesh: " + gameObject.name);
+
+            babylonMesh.name = gameObject.name;
+            babylonMesh.id = GetID(transform.gameObject);
+
+            if (renderer != null)
+            {
+                babylonMesh.receiveShadows = renderer.receiveShadows;
+            }
+
+            babylonMesh.parentId = GetParentID(transform);
+
+            babylonMesh.position = transform.localPosition.ToFloat();
+
+            babylonMesh.rotation = new float[3];
+            babylonMesh.rotation[0] = transform.localRotation.eulerAngles.x * (float)Math.PI / 180;
+            babylonMesh.rotation[1] = transform.localRotation.eulerAngles.y * (float)Math.PI / 180;
+            babylonMesh.rotation[2] = transform.localRotation.eulerAngles.z * (float)Math.PI / 180;
+
+            babylonMesh.scaling = transform.localScale.ToFloat();
+
+            babylonMesh.positions = new float[mesh.vertexCount * 3];
+
+            for (int i = 0; i < mesh.vertices.Length; i++)
+            {
+                babylonMesh.positions[i * 3] = mesh.vertices[i].x;
+                babylonMesh.positions[(i * 3) + 1] = mesh.vertices[i].y;
+                babylonMesh.positions[(i * 3) + 2] = mesh.vertices[i].z;
+
+                // Computing world extends
+                var worldPosition = transform.TransformPoint(mesh.vertices[i]);
+
+                if (worldPosition.x > babylonScene.MaxVector.X)
+                {
+                    babylonScene.MaxVector.X = worldPosition.x;
+                }
+                if (worldPosition.y > babylonScene.MaxVector.Y)
+                {
+                    babylonScene.MaxVector.Y = worldPosition.y;
+                }
+                if (worldPosition.z > babylonScene.MaxVector.Z)
+                {
+                    babylonScene.MaxVector.Z = worldPosition.z;
+                }
+
+                if (worldPosition.x < babylonScene.MinVector.X)
+                {
+                    babylonScene.MinVector.X = worldPosition.x;
+                }
+                if (worldPosition.y < babylonScene.MinVector.Y)
+                {
+                    babylonScene.MinVector.Y = worldPosition.y;
+                }
+                if (worldPosition.z < babylonScene.MinVector.Z)
+                {
+                    babylonScene.MinVector.Z = worldPosition.z;
+                }
+            }
+
+            babylonMesh.normals = new float[mesh.vertexCount * 3];
+
+            for (int i = 0; i < mesh.normals.Length; i++)
+            {
+                babylonMesh.normals[i * 3] = mesh.normals[i].x;
+                babylonMesh.normals[(i * 3) + 1] = mesh.normals[i].y;
+                babylonMesh.normals[(i * 3) + 2] = mesh.normals[i].z;
+            }
+
+            babylonMesh.uvs = new float[mesh.vertexCount * 2];
+
+            for (int i = 0; i < mesh.uv.Length; i++)
+            {
+                babylonMesh.uvs[i * 2] = mesh.uv[i].x;
+                babylonMesh.uvs[(i * 2) + 1] = mesh.uv[i].y;
+            }
+
+            babylonMesh.uvs2 = new float[mesh.vertexCount * 2];
+
+            if (mesh.uv2 != null && mesh.uv2.Length > 0)
+            {
+                for (int i = 0; i < mesh.uv2.Length; i++)
+                {
+                    babylonMesh.uvs2[i * 2] = mesh.uv2[i].x;
+                    babylonMesh.uvs2[(i * 2) + 1] = mesh.uv2[i].y;
+                }
+            }
+            else
+            {
+                for (int i = 0; i < mesh.uv.Length; i++)
+                {
+                    babylonMesh.uvs2[i * 2] = mesh.uv[i].x;
+                    babylonMesh.uvs2[(i * 2) + 1] = mesh.uv[i].y;
+                }
+            }
+
+            babylonMesh.indices = new int[mesh.triangles.Length];
+
+            for (int i = 0; i < mesh.triangles.Length; i += 3)
+            {
+                babylonMesh.indices[i] = mesh.triangles[i + 2];
+                babylonMesh.indices[i + 1] = mesh.triangles[i + 1];
+                babylonMesh.indices[i + 2] = mesh.triangles[i];
+            }
+
+            if (renderer != null)
+            {
+                if (mesh.subMeshCount > 1) // Multimaterials
+                {
+                    BabylonMultiMaterial bMultiMat;
+                    if (!multiMatDictionary.ContainsKey(renderer.sharedMaterial.name))
+                    {
+                        bMultiMat = new BabylonMultiMaterial
+                        {
+                            materials = new string[mesh.subMeshCount],
+                            id = Guid.NewGuid().ToString(),
+                            name = renderer.sharedMaterial.name
+                        };
+
+                        for (int i = 0; i < renderer.sharedMaterials.Length; i++)
+                        {
+                            var bMat = DumpMaterial(renderer.sharedMaterials[i], renderer);
+                            bMultiMat.materials[i] = bMat.id;
+                        }
+                        if (mesh.subMeshCount > 1)
+                        {
+                            multiMatDictionary.Add(bMultiMat.name, bMultiMat);
+                        }
+                    }
+                    else
+                    {
+                        bMultiMat = multiMatDictionary[renderer.sharedMaterial.name];
+                    }
+
+                    babylonMesh.materialId = bMultiMat.id;
+                    babylonMesh.subMeshes = new BabylonSubMesh[mesh.subMeshCount];
+
+                    var offset = 0;
+                    for (int materialIndex = 0; materialIndex < mesh.subMeshCount; materialIndex++)
+                    {
+                        var unityTriangles = mesh.GetTriangles(materialIndex);
+
+                        babylonMesh.subMeshes[materialIndex] = new BabylonSubMesh
+                        {
+                            verticesStart = 0,
+                            verticesCount = mesh.vertexCount,
+                            materialIndex = materialIndex,
+                            indexStart = offset,
+                            indexCount = unityTriangles.Length
+                        };
+
+                        offset += unityTriangles.Length;
+                    }
+                }
+                else
+                {
+                    babylonMesh.materialId = DumpMaterial(renderer.sharedMaterial, renderer).id;
+                }
+            }
+
+            babylonScene.MeshesList.Add(babylonMesh);
+
+            // Animations
+            ExportAnimations(transform, babylonMesh);
+
+            if (IsRotationQuaternionAnimated(babylonMesh))
+            {
+                babylonMesh.rotationQuaternion = transform.localRotation.ToFloat();
+            }
+
+            // Collisions
+            if (exportationOptions.ExportCollisions)
+            {
+                var collider = gameObject.GetComponent<Collider>();
+
+                if (collider != null)
+                {
+                    babylonMesh.checkCollisions = true;
+                }
+            }
+
+            // Physics
+            if (exportationOptions.ExportPhysics)
+            {
+                DumpPhysics(gameObject, babylonMesh);
+            }
+        }
+
+        void DumpPhysics(GameObject gameObject, BabylonMesh babylonMesh)
+        {
+            var impostor = gameObject.GetComponent<Collider>();
+
+            if (impostor == null)
+            {
+                return;
+            }
+
+            babylonScene.physicsEnabled = true;
+            babylonScene.physicsGravity = Physics.gravity.ToFloat();
+
+            if (impostor is SphereCollider)
+            {
+                babylonMesh.physicsImpostor = 1;
+            }
+            else if (impostor is BoxCollider)
+            {
+                babylonMesh.physicsImpostor = 2;
+            }
+            else if (impostor is MeshCollider)
+            {
+                babylonMesh.physicsImpostor = 4;
+            }
+
+            var rigidBody = gameObject.GetComponent<Rigidbody>();
+
+            if (rigidBody == null)
+            {
+                return;
+            }
+
+            babylonMesh.physicsMass = rigidBody.mass;
+        }
+    }
+}

Exporters/Unity 5/Unity3D2Babylon/SceneBuilder.cs

@@ -1,229 +1,171 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using BabylonExport.Entities;
-using JsonFx.Json;
-using UnityEngine;
-using Object = UnityEngine.Object;
-using JsonFx.Serialization;
-using JsonFx.Serialization.Resolvers;
-using UnityEditor;
-
-namespace Unity3D2Babylon
-{
-    public partial class SceneBuilder
-    {
-        public string OutputPath { get; private set; }
-        public string SceneName { get; private set; }
-
-        readonly Dictionary<string, BabylonMaterial> materialsDictionary;
-        readonly Dictionary<string, BabylonMultiMaterial> multiMatDictionary;
-
-        readonly Dictionary<int, string> uniqueGuids;
-
-        readonly BabylonScene babylonScene;
-        GameObject[] gameObjects;
-
-        readonly ExportationOptions exportationOptions;
-
-        public SceneBuilder(string outputPath, string sceneName, ExportationOptions exportationOptions)
-        {
-            OutputPath = outputPath;
-            SceneName = string.IsNullOrEmpty(sceneName) ? "scene" : sceneName;
-
-            materialsDictionary = new Dictionary<string, BabylonMaterial>();
-            multiMatDictionary = new Dictionary<string, BabylonMultiMaterial>();
-            uniqueGuids = new Dictionary<int, string>();
-
-            babylonScene = new BabylonScene(OutputPath);
-
-            this.exportationOptions = exportationOptions;
-        }
-
-        public void WriteToBabylonFile()
-        {
-            babylonScene.Prepare();
-
-            var outputFile = Path.Combine(OutputPath, SceneName + ".babylon");
-
-            var jsWriter = new JsonWriter(new DataWriterSettings(new DataContractResolverStrategy()));
-            string babylonJSformat = jsWriter.Write(babylonScene);
-            using (var sw = new StreamWriter(outputFile))
-            {
-                sw.Write(babylonJSformat);
-                sw.Close();
-            }
-        }
-
-        public void GenerateStatus(List<string> logs)
-        {
-            var initialLog = new List<string>
-            {
-                "*Exportation Status:",
-                babylonScene.meshes.Length + " mesh(es)",
-                babylonScene.lights.Length + " light(s)",
-                babylonScene.cameras.Length + " camera(s)",
-                babylonScene.materials.Length + " material(s)",
-                babylonScene.multiMaterials.Length + " multi-material(s)",
-                "",
-                "*Log:"
-            };
-
-            logs.InsertRange(0, initialLog);
-        }
-
-        string GetParentID(Transform transform)
-        {
-            if (transform.parent == null)
-            {
-                return null;
-            }
-
-            return GetID(transform.parent.gameObject);
-        }
-
-        string GetID(GameObject gameObject)
-        {
-            var key = gameObject.GetInstanceID();
-
-            if (!uniqueGuids.ContainsKey(key))
-            {
-                uniqueGuids[key] = Guid.NewGuid().ToString();
-            }
-
-            return uniqueGuids[key];
-        }
-
-        public void ConvertFromUnity()
-        {
-            ExporterWindow.ReportProgress(0, "Starting Babylon.js 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;
-            }
-
-            var itemsCount = gameObjects.Length;
-
-            var index = 0;
-
-            //Dictionary to store prefabs and their instances
-            Dictionary<GameObject, List<BabylonAbstractMesh>> dicPrefabs = new Dictionary<GameObject, List<BabylonAbstractMesh>>();
-
-            foreach (var gameObject in gameObjects)
-            {
-                var progress = ((float)index / itemsCount);
-                index++;
-
-                /* 
-                    The order of processing is important here.
-                    We will only check if this is a mesh prefab if it is not a light or camera
-                */
-
-                // Light
-                var light = gameObject.GetComponent<Light>();
-                if (light != null)
-                {
-                    ConvertUnityLightToBabylon(light, progress);
-                    continue;
-                }
-
-                // Camera
-                var camera = gameObject.GetComponent<Camera>();
-                if (camera != null)
-                {
-                    ConvertUnityCameraToBabylon(camera, progress);
-                    continue;
-                }
-
-                // Check if this is a prefab instance
-                GameObject gobjPrefab = (GameObject)PrefabUtility.GetPrefabParent(gameObject);
-                if (gobjPrefab != null)
-                {
-                    //Add prefab to dictionary if it doesn't already exist
-                    if (!dicPrefabs.ContainsKey(gobjPrefab))
-                    {
-                        dicPrefabs[gobjPrefab] = new List<BabylonAbstractMesh>();
-                    }
-
-                    List<BabylonAbstractMesh> lstInstances = dicPrefabs[gobjPrefab];
-                    BabylonAbstractMesh instance = ConvertUnityMeshToInstance(gameObject);
-                    lstInstances.Add(instance);
-                    continue;
-                }
-
-                // Static meshes
-                var meshFilter = gameObject.GetComponent<MeshFilter>();
-                if (meshFilter != null)
-                {                    
-                    ConvertUnityMeshToBabylon(meshFilter.sharedMesh, meshFilter.transform, gameObject, progress);
-                    continue;
-                }
-
-                // Skinned meshes
-                var skinnedMesh = gameObject.GetComponent<SkinnedMeshRenderer>();
-                if (skinnedMesh != null)
-                {
-                    ConvertUnityMeshToBabylon(skinnedMesh.sharedMesh, skinnedMesh.transform, gameObject, progress);
-                    continue;
-                }
-
-                // Empty
-                ConvertUnityEmptyObjectToBabylon(gameObject);
-            }
-
-            index = 0;
-            itemsCount = dicPrefabs.Count;
-
-            //Convert prefabs
-            foreach (KeyValuePair<GameObject, List<BabylonAbstractMesh>> pair in dicPrefabs)
-            {
-                var progress = ((float)index / itemsCount);
-                index++;
-
-                List<BabylonAbstractMesh> lstValue = pair.Value;
-                GameObject prefab = pair.Key;
-                BabylonAbstractMesh[] lstInstance = lstValue.ToArray();
-
-                // Static meshes
-                var meshFilter = prefab.GetComponent<MeshFilter>();
-                if (meshFilter != null)
-                {
-                    ConvertUnityMeshToBabylon(meshFilter.sharedMesh, meshFilter.transform, prefab, progress, lstInstance);
-                    continue;
-                }
-
-                // Skinned meshes
-                var skinnedMesh = prefab.GetComponent<SkinnedMeshRenderer>();
-                if (skinnedMesh != null)
-                {
-                    ConvertUnityMeshToBabylon(skinnedMesh.sharedMesh, skinnedMesh.transform, prefab, progress, lstInstance);
-                    continue;
-                }
-
-                // Empty
-                ConvertUnityEmptyObjectToBabylon(prefab, lstInstance);
-            }
-
-            // 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.gravity = exportationOptions.Gravity.ToFloat();
-            }
-        }     
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.IO;
+using BabylonExport.Entities;
+using JsonFx.Json;
+using UnityEngine;
+using Object = UnityEngine.Object;
+using JsonFx.Serialization;
+using JsonFx.Serialization.Resolvers;
+
+namespace Unity3D2Babylon
+{
+    public partial class SceneBuilder
+    {
+        public string OutputPath { get; private set; }
+        public string SceneName { get; private set; }
+
+        readonly Dictionary<string, BabylonMaterial> materialsDictionary;
+        readonly Dictionary<string, BabylonMultiMaterial> multiMatDictionary;
+
+        readonly Dictionary<int, string> uniqueGuids;
+
+        readonly BabylonScene babylonScene;
+        GameObject[] gameObjects;
+
+        readonly ExportationOptions exportationOptions;
+
+        public SceneBuilder(string outputPath, string sceneName, ExportationOptions exportationOptions)
+        {
+            OutputPath = outputPath;
+            SceneName = string.IsNullOrEmpty(sceneName) ? "scene" : sceneName;
+
+            materialsDictionary = new Dictionary<string, BabylonMaterial>();
+            multiMatDictionary = new Dictionary<string, BabylonMultiMaterial>();
+            uniqueGuids = new Dictionary<int, string>();
+
+            babylonScene = new BabylonScene(OutputPath);
+
+            this.exportationOptions = exportationOptions;
+        }
+
+        public string WriteToBabylonFile()
+        {
+            babylonScene.Prepare();
+
+            var outputFile = Path.Combine(OutputPath, SceneName + ".babylon");
+
+            var jsWriter = new JsonWriter(new DataWriterSettings(new DataContractResolverStrategy()));
+            string babylonJSformat = jsWriter.Write(babylonScene);
+            using (var sw = new StreamWriter(outputFile))
+            {
+                sw.Write(babylonJSformat);
+                sw.Close();
+            }
+
+            return outputFile;
+        }
+
+        public void GenerateStatus(List<string> logs)
+        {
+            var initialLog = new List<string>
+            {
+                "*Exportation Status:",
+                babylonScene.meshes.Length + " mesh(es)",
+                babylonScene.lights.Length + " light(s)",
+                babylonScene.cameras.Length + " camera(s)",
+                babylonScene.materials.Length + " material(s)",
+                babylonScene.multiMaterials.Length + " multi-material(s)",
+                "",
+                "*Log:"
+            };
+
+            logs.InsertRange(0, initialLog);
+        }
+
+        string GetParentID(Transform transform)
+        {
+            if (transform.parent == null)
+            {
+                return null;
+            }
+
+            return GetID(transform.parent.gameObject);
+        }
+
+        string GetID(GameObject gameObject)
+        {
+            var key = gameObject.GetInstanceID();
+
+            if (!uniqueGuids.ContainsKey(key))
+            {
+                uniqueGuids[key] = Guid.NewGuid().ToString();
+            }
+
+            return uniqueGuids[key];
+        }
+
+        public void ConvertFromUnity()
+        {
+            ExporterWindow.ReportProgress(0, "Starting Babylon.js 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;
+            }
+
+            var itemsCount = gameObjects.Length;
+
+            var index = 0;
+            foreach (var gameObject in gameObjects)
+            {
+                var progress = ((float)index / itemsCount);
+                index++;
+                // Static meshes
+                var meshFilter = gameObject.GetComponent<MeshFilter>();
+                if (meshFilter != null)
+                {                    
+                    ConvertUnityMeshToBabylon(meshFilter.sharedMesh, meshFilter.transform, gameObject, progress);
+                    continue;
+                }
+
+                // Skinned meshes
+                var skinnedMesh = gameObject.GetComponent<SkinnedMeshRenderer>();
+                if (skinnedMesh != null)
+                {
+                    ConvertUnityMeshToBabylon(skinnedMesh.sharedMesh, skinnedMesh.transform, gameObject, progress);
+                    continue;
+                }
+
+                // Light
+                var light = gameObject.GetComponent<Light>();
+                if (light != null)
+                {
+                    ConvertUnityLightToBabylon(light, progress);
+                    continue;
+                }
+
+                // Camera
+                var camera = gameObject.GetComponent<Camera>();
+                if (camera != null)
+                {
+                    ConvertUnityCameraToBabylon(camera, progress);
+                    continue;
+                }
+
+                // Empty
+                ConvertUnityEmptyObjectToBabylon(gameObject);
+            }
+
+            // 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.gravity = exportationOptions.Gravity.ToFloat();
+            }
+        }     
+    }
+}

Exporters/Unity 5/Unity3D2Babylon/SerializableVector3.cs

@@ -1,25 +1,25 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using UnityEngine;
-
-namespace Unity3D2Babylon
-{
-    public class SerializableVector3
-    {
-        public float X { get; set; }
-        public float Y { get; set; }
-        public float Z { get; set; }
-
-        public static implicit operator Vector3(SerializableVector3 source)
-        {
-            return new Vector3(source.X, source.Y, source.Z);
-        }
-
-        public static implicit operator SerializableVector3(Vector3 source)
-        {
-            return new SerializableVector3 { X = source.x, Y = source.y, Z = source.z };
-        }
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+
+namespace Unity3D2Babylon
+{
+    public class SerializableVector3
+    {
+        public float X { get; set; }
+        public float Y { get; set; }
+        public float Z { get; set; }
+
+        public static implicit operator Vector3(SerializableVector3 source)
+        {
+            return new Vector3(source.X, source.Y, source.Z);
+        }
+
+        public static implicit operator SerializableVector3(Vector3 source)
+        {
+            return new SerializableVector3 { X = source.x, Y = source.y, Z = source.z };
+        }
+    }
+}

Exporters/Unity 5/Unity3D2Babylon/Tools.cs

@@ -1,53 +1,53 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using UnityEngine;
-
-namespace Unity3D2Babylon
-{
-    public static class Tools
-    {
-        public static float[] ToFloat(this Color color)
-        {
-            var result = new float[4];
-            result[0] = color.r;
-            result[1] = color.g;
-            result[2] = color.b;
-            result[3] = color.a;
-
-            return result;
-        }
-
-        public static float[] ToFloat(this Vector3 vector3)
-        {
-            var result = new float[3];
-            result[0] = vector3.x;
-            result[1] = vector3.y;
-            result[2] = vector3.z;
-
-            return result;
-        }
-
-        public static float[] ToFloat(this SerializableVector3 vector3)
-        {
-            var result = new float[3];
-            result[0] = vector3.X;
-            result[1] = vector3.Y;
-            result[2] = vector3.Z;
-
-            return result;
-        }
-
-        public static float[] ToFloat(this Quaternion quaternion)
-        {
-            var result = new float[4];
-            result[0] = quaternion.x;
-            result[1] = quaternion.y;
-            result[2] = quaternion.z;
-            result[3] = quaternion.w;
-
-            return result;
-        }
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+
+namespace Unity3D2Babylon
+{
+    public static class Tools
+    {
+        public static float[] ToFloat(this Color color)
+        {
+            var result = new float[4];
+            result[0] = color.r;
+            result[1] = color.g;
+            result[2] = color.b;
+            result[3] = color.a;
+
+            return result;
+        }
+
+        public static float[] ToFloat(this Vector3 vector3)
+        {
+            var result = new float[3];
+            result[0] = vector3.x;
+            result[1] = vector3.y;
+            result[2] = vector3.z;
+
+            return result;
+        }
+
+        public static float[] ToFloat(this SerializableVector3 vector3)
+        {
+            var result = new float[3];
+            result[0] = vector3.X;
+            result[1] = vector3.Y;
+            result[2] = vector3.Z;
+
+            return result;
+        }
+
+        public static float[] ToFloat(this Quaternion quaternion)
+        {
+            var result = new float[4];
+            result[0] = quaternion.x;
+            result[1] = quaternion.y;
+            result[2] = quaternion.z;
+            result[3] = quaternion.w;
+
+            return result;
+        }
+    }
+}

Exporters/Unity 5/Unity3D2Babylon/WebServer.cs

@@ -0,0 +1,180 @@
+using System;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Threading;
+using UnityEngine;
+
+namespace Unity3D2Babylon
+{
+    public static class WebServer
+    {
+        private static readonly HttpListener listener;
+
+        const string HtmlResponseText = @"
+<!doctype html>
+<html>
+
+<head>
+    <title>Babylon.js</title>
+    <script type='text/javascript' src='http://www.babylonjs.com/oimo.js'></script>
+    <script type='text/javascript' src='http://www.babylonjs.com/cannon.js'></script>
+    <script type='text/javascript' src='http://www.babylonjs.com/babylon.js'></script>
+    <style type='text/css'>
+        html, body, div, canvas {
+            width: 100%;
+            height: 100%;
+            padding: 0;
+            margin: 0;
+            overflow: hidden;
+        }
+
+        #debugLayerButton {
+            position: absolute;
+            border: white solid 1px;
+            background: rgba(128, 128, 128, 0.3);
+            color: white;
+            left: 50%;
+            width: 100px;
+            margin-left:-50px;
+            bottom: 10px;
+        }
+    </style>
+</head>
+
+<body>
+    <canvas id='canvas'></canvas>
+    <button id='debugLayerButton'>Debug layer</button>
+    <script type='text/javascript'>
+        var canvas = document.getElementById('canvas');
+        var engine = new BABYLON.Engine(canvas, true);
+       
+        BABYLON.SceneLoader.Load('', '###SCENE###', engine, function (newScene) {
+            newScene.activeCamera.attachControl(canvas);
+
+            engine.runRenderLoop(function() {
+                newScene.render();
+            });
+
+            window.addEventListener('resize', function () {
+                engine.resize();
+            });
+
+            document.getElementById('debugLayerButton').addEventListener('click', function () {
+                if (newScene.debugLayer.isVisible()) {
+                    newScene.debugLayer.hide();
+                } else {
+                    newScene.debugLayer.show();
+                }
+            });
+        });
+    </script>
+</body>
+</html>";
+
+        public const int Port = 45478;
+
+        public static bool IsSupported { get; private set; }
+
+        static WebServer()
+        {
+            try
+            {
+                listener = new HttpListener();
+
+                if (!HttpListener.IsSupported)
+                {
+                    IsSupported = false;
+                    return;
+                }
+
+                listener.Prefixes.Add("http://localhost:" + Port + "/");
+                listener.Start();
+
+                ThreadPool.QueueUserWorkItem(Listen);
+
+                IsSupported = true;
+            }
+            catch
+            {
+                IsSupported = false;
+            }
+        }
+
+        public static string SceneFilename { get; set; }
+        public static string SceneFolder { get; set; }
+        static System.Random r = new System.Random();
+        static void Listen(object state)
+        {
+            try
+            {
+                while (listener.IsListening)
+                {
+                    var context = listener.GetContext();
+                    var request = context.Request;
+                    var url = request.Url;
+
+                    context.Response.AddHeader("Cache-Control", "no-cache");
+                    if (string.IsNullOrEmpty(url.LocalPath) || url.LocalPath == "/")
+                    {
+
+                        var responseText = HtmlResponseText.Replace("###SCENE###", SceneFilename+"?once="+r.Next());
+                        WriteResponse(context, responseText);
+                    }
+                    else
+                    {
+                        try
+                        {
+                            var path = Path.Combine(SceneFolder, WWW.UnEscapeURL(url.PathAndQuery.Substring(1)));
+                            var questionMarkIndex = path.IndexOf("?");
+                            if (questionMarkIndex != -1)
+                            {
+                                path = path.Substring(0, questionMarkIndex);
+                            }
+                            var hashIndex = path.IndexOf("#");
+                            if (hashIndex != -1)
+                            {
+                                path = path.Substring(0, hashIndex);
+                            }
+                            var buffer = File.ReadAllBytes(path);
+                            WriteResponse(context, buffer);
+                        }
+                        catch
+                        {
+                            context.Response.StatusCode = 404;
+                            context.Response.Close();
+                        }
+                    }
+
+                }
+            }
+            catch
+            {
+            }
+        }
+
+        static void WriteResponse(HttpListenerContext context, string s)
+        {
+            WriteResponse(context.Response, s);
+        }
+
+        static void WriteResponse(HttpListenerContext context, byte[] buffer)
+        {
+            WriteResponse(context.Response, buffer);
+        }
+
+        static void WriteResponse(HttpListenerResponse response, string s)
+        {
+            byte[] buffer = Encoding.UTF8.GetBytes(s);
+            WriteResponse(response, buffer);
+        }
+
+        static void WriteResponse(HttpListenerResponse response, byte[] buffer)
+        {
+            response.ContentLength64 = buffer.Length;
+            Stream output = response.OutputStream;
+            output.Write(buffer, 0, buffer.Length);
+            output.Close();
+        }
+    }
+}

dist/preview release/what's new.md

@@ -11,6 +11,8 @@
     - Added Camera Inputs Manager to manage camera inputs (mouse, touch, keyboard, gamepad, ...) in a composable way, without relying on class inheritance [gleborgne](https://github.com/gleborgne)
     - Introduced new observable system to handle events ([nockawa](https://github.com/nockawa), [deltakosh](https://github.com/deltakosh))
     - Added a new VR camera : VRDeviceOrientationArcRotateCamera [temechon](https://github.com/Temechon)
+    - Unity3D exporter: Added support for lightmaps ([davrous](https://github.com/davrous), [deltakosh](https://github.com/deltakosh))
+    - Unity3D exporter: Added support for export and run (local webserver) ([davrous](https://github.com/davrous), [deltakosh](https://github.com/deltakosh))
   - **Updates**
     - Added skeleton.getBoneIndexByName(boneName: string) [dad72](https://github.com/dad72)
     - Added node._children to track children hierarchy ([deltakosh](https://github.com/deltakosh))