Update material library serialize clone... to decorators

Tools/Gulp/config.json

@@ -186,6 +186,7 @@
       "../../src/tools/hdr/babylon.tools.cubemaptosphericalpolynomial.js",
       "../../src/tools/hdr/babylon.tools.panoramatocubemap.js",
       "../../src/tools/hdr/babylon.tools.hdr.js",
+      "../../src/tools/hdr/babylon.tools.pmremgenerator.js",
       "../../src/materials/textures/babylon.hdrcubetexture.js"
     ]
   }

dist/preview release/babylon.d.ts

@@ -1703,247 +1703,6 @@ declare module BABYLON {
 }
 
 declare module BABYLON {
-    class Collider {
-        radius: Vector3;
-        retry: number;
-        velocity: Vector3;
-        basePoint: Vector3;
-        epsilon: number;
-        collisionFound: boolean;
-        velocityWorldLength: number;
-        basePointWorld: Vector3;
-        velocityWorld: Vector3;
-        normalizedVelocity: Vector3;
-        initialVelocity: Vector3;
-        initialPosition: Vector3;
-        nearestDistance: number;
-        intersectionPoint: Vector3;
-        collidedMesh: AbstractMesh;
-        private _collisionPoint;
-        private _planeIntersectionPoint;
-        private _tempVector;
-        private _tempVector2;
-        private _tempVector3;
-        private _tempVector4;
-        private _edge;
-        private _baseToVertex;
-        private _destinationPoint;
-        private _slidePlaneNormal;
-        private _displacementVector;
-        _initialize(source: Vector3, dir: Vector3, e: number): void;
-        _checkPointInTriangle(point: Vector3, pa: Vector3, pb: Vector3, pc: Vector3, n: Vector3): boolean;
-        _canDoCollision(sphereCenter: Vector3, sphereRadius: number, vecMin: Vector3, vecMax: Vector3): boolean;
-        _testTriangle(faceIndex: number, trianglePlaneArray: Array<Plane>, p1: Vector3, p2: Vector3, p3: Vector3, hasMaterial: boolean): void;
-        _collide(trianglePlaneArray: Array<Plane>, pts: Vector3[], indices: number[] | Int32Array, indexStart: number, indexEnd: number, decal: number, hasMaterial: boolean): void;
-        _getResponse(pos: Vector3, vel: Vector3): void;
-    }
-}
-
-declare module BABYLON {
-    var CollisionWorker: string;
-    interface ICollisionCoordinator {
-        getNewPosition(position: Vector3, velocity: Vector3, collider: Collider, maximumRetry: number, excludedMesh: AbstractMesh, onNewPosition: (collisionIndex: number, newPosition: Vector3, collidedMesh?: AbstractMesh) => void, collisionIndex: number): void;
-        init(scene: Scene): void;
-        destroy(): void;
-        onMeshAdded(mesh: AbstractMesh): any;
-        onMeshUpdated(mesh: AbstractMesh): any;
-        onMeshRemoved(mesh: AbstractMesh): any;
-        onGeometryAdded(geometry: Geometry): any;
-        onGeometryUpdated(geometry: Geometry): any;
-        onGeometryDeleted(geometry: Geometry): any;
-    }
-    interface SerializedMesh {
-        id: string;
-        name: string;
-        uniqueId: number;
-        geometryId: string;
-        sphereCenter: Array<number>;
-        sphereRadius: number;
-        boxMinimum: Array<number>;
-        boxMaximum: Array<number>;
-        worldMatrixFromCache: any;
-        subMeshes: Array<SerializedSubMesh>;
-        checkCollisions: boolean;
-    }
-    interface SerializedSubMesh {
-        position: number;
-        verticesStart: number;
-        verticesCount: number;
-        indexStart: number;
-        indexCount: number;
-        hasMaterial: boolean;
-        sphereCenter: Array<number>;
-        sphereRadius: number;
-        boxMinimum: Array<number>;
-        boxMaximum: Array<number>;
-    }
-    interface SerializedGeometry {
-        id: string;
-        positions: Float32Array;
-        indices: Int32Array;
-        normals: Float32Array;
-    }
-    interface BabylonMessage {
-        taskType: WorkerTaskType;
-        payload: InitPayload | CollidePayload | UpdatePayload;
-    }
-    interface SerializedColliderToWorker {
-        position: Array<number>;
-        velocity: Array<number>;
-        radius: Array<number>;
-    }
-    enum WorkerTaskType {
-        INIT = 0,
-        UPDATE = 1,
-        COLLIDE = 2,
-    }
-    interface WorkerReply {
-        error: WorkerReplyType;
-        taskType: WorkerTaskType;
-        payload?: any;
-    }
-    interface CollisionReplyPayload {
-        newPosition: Array<number>;
-        collisionId: number;
-        collidedMeshUniqueId: number;
-    }
-    interface InitPayload {
-    }
-    interface CollidePayload {
-        collisionId: number;
-        collider: SerializedColliderToWorker;
-        maximumRetry: number;
-        excludedMeshUniqueId?: number;
-    }
-    interface UpdatePayload {
-        updatedMeshes: {
-            [n: number]: SerializedMesh;
-        };
-        updatedGeometries: {
-            [s: string]: SerializedGeometry;
-        };
-        removedMeshes: Array<number>;
-        removedGeometries: Array<string>;
-    }
-    enum WorkerReplyType {
-        SUCCESS = 0,
-        UNKNOWN_ERROR = 1,
-    }
-    class CollisionCoordinatorWorker implements ICollisionCoordinator {
-        private _scene;
-        private _scaledPosition;
-        private _scaledVelocity;
-        private _collisionsCallbackArray;
-        private _init;
-        private _runningUpdated;
-        private _runningCollisionTask;
-        private _worker;
-        private _addUpdateMeshesList;
-        private _addUpdateGeometriesList;
-        private _toRemoveMeshesArray;
-        private _toRemoveGeometryArray;
-        constructor();
-        static SerializeMesh: (mesh: AbstractMesh) => SerializedMesh;
-        static SerializeGeometry: (geometry: Geometry) => SerializedGeometry;
-        getNewPosition(position: Vector3, velocity: Vector3, collider: Collider, maximumRetry: number, excludedMesh: AbstractMesh, onNewPosition: (collisionIndex: number, newPosition: Vector3, collidedMesh?: AbstractMesh) => void, collisionIndex: number): void;
-        init(scene: Scene): void;
-        destroy(): void;
-        onMeshAdded(mesh: AbstractMesh): void;
-        onMeshUpdated: (mesh: AbstractMesh) => void;
-        onMeshRemoved(mesh: AbstractMesh): void;
-        onGeometryAdded(geometry: Geometry): void;
-        onGeometryUpdated: (geometry: Geometry) => void;
-        onGeometryDeleted(geometry: Geometry): void;
-        private _afterRender;
-        private _onMessageFromWorker;
-    }
-    class CollisionCoordinatorLegacy implements ICollisionCoordinator {
-        private _scene;
-        private _scaledPosition;
-        private _scaledVelocity;
-        private _finalPosition;
-        getNewPosition(position: Vector3, velocity: Vector3, collider: Collider, maximumRetry: number, excludedMesh: AbstractMesh, onNewPosition: (collisionIndex: number, newPosition: Vector3, collidedMesh?: AbstractMesh) => void, collisionIndex: number): void;
-        init(scene: Scene): void;
-        destroy(): void;
-        onMeshAdded(mesh: AbstractMesh): void;
-        onMeshUpdated(mesh: AbstractMesh): void;
-        onMeshRemoved(mesh: AbstractMesh): void;
-        onGeometryAdded(geometry: Geometry): void;
-        onGeometryUpdated(geometry: Geometry): void;
-        onGeometryDeleted(geometry: Geometry): void;
-        private _collideWithWorld(position, velocity, collider, maximumRetry, finalPosition, excludedMesh?);
-    }
-}
-
-declare module BABYLON {
-    var WorkerIncluded: boolean;
-    class CollisionCache {
-        private _meshes;
-        private _geometries;
-        getMeshes(): {
-            [n: number]: SerializedMesh;
-        };
-        getGeometries(): {
-            [s: number]: SerializedGeometry;
-        };
-        getMesh(id: any): SerializedMesh;
-        addMesh(mesh: SerializedMesh): void;
-        removeMesh(uniqueId: number): void;
-        getGeometry(id: string): SerializedGeometry;
-        addGeometry(geometry: SerializedGeometry): void;
-        removeGeometry(id: string): void;
-    }
-    class CollideWorker {
-        collider: Collider;
-        private _collisionCache;
-        private finalPosition;
-        private collisionsScalingMatrix;
-        private collisionTranformationMatrix;
-        constructor(collider: Collider, _collisionCache: CollisionCache, finalPosition: Vector3);
-        collideWithWorld(position: Vector3, velocity: Vector3, maximumRetry: number, excludedMeshUniqueId?: number): void;
-        private checkCollision(mesh);
-        private processCollisionsForSubMeshes(transformMatrix, mesh);
-        private collideForSubMesh(subMesh, transformMatrix, meshGeometry);
-        private checkSubmeshCollision(subMesh);
-    }
-    interface ICollisionDetector {
-        onInit(payload: InitPayload): void;
-        onUpdate(payload: UpdatePayload): void;
-        onCollision(payload: CollidePayload): void;
-    }
-    class CollisionDetectorTransferable implements ICollisionDetector {
-        private _collisionCache;
-        onInit(payload: InitPayload): void;
-        onUpdate(payload: UpdatePayload): void;
-        onCollision(payload: CollidePayload): void;
-    }
-}
-
-declare module BABYLON {
-    class IntersectionInfo {
-        bu: number;
-        bv: number;
-        distance: number;
-        faceId: number;
-        subMeshId: number;
-        constructor(bu: number, bv: number, distance: number);
-    }
-    class PickingInfo {
-        hit: boolean;
-        distance: number;
-        pickedPoint: Vector3;
-        pickedMesh: AbstractMesh;
-        bu: number;
-        bv: number;
-        faceId: number;
-        subMeshId: number;
-        pickedSprite: Sprite;
-        getNormal(useWorldCoordinates?: boolean, useVerticesNormals?: boolean): Vector3;
-        getTextureCoordinates(): Vector2;
-    }
-}
-
-declare module BABYLON {
     class ArcRotateCamera extends TargetCamera {
         alpha: number;
         beta: number;
@@ -2352,59 +2111,243 @@ declare module BABYLON {
 }
 
 declare module BABYLON {
-    class DebugLayer {
+    class Collider {
+        radius: Vector3;
+        retry: number;
+        velocity: Vector3;
+        basePoint: Vector3;
+        epsilon: number;
+        collisionFound: boolean;
+        velocityWorldLength: number;
+        basePointWorld: Vector3;
+        velocityWorld: Vector3;
+        normalizedVelocity: Vector3;
+        initialVelocity: Vector3;
+        initialPosition: Vector3;
+        nearestDistance: number;
+        intersectionPoint: Vector3;
+        collidedMesh: AbstractMesh;
+        private _collisionPoint;
+        private _planeIntersectionPoint;
+        private _tempVector;
+        private _tempVector2;
+        private _tempVector3;
+        private _tempVector4;
+        private _edge;
+        private _baseToVertex;
+        private _destinationPoint;
+        private _slidePlaneNormal;
+        private _displacementVector;
+        _initialize(source: Vector3, dir: Vector3, e: number): void;
+        _checkPointInTriangle(point: Vector3, pa: Vector3, pb: Vector3, pc: Vector3, n: Vector3): boolean;
+        _canDoCollision(sphereCenter: Vector3, sphereRadius: number, vecMin: Vector3, vecMax: Vector3): boolean;
+        _testTriangle(faceIndex: number, trianglePlaneArray: Array<Plane>, p1: Vector3, p2: Vector3, p3: Vector3, hasMaterial: boolean): void;
+        _collide(trianglePlaneArray: Array<Plane>, pts: Vector3[], indices: number[] | Int32Array, indexStart: number, indexEnd: number, decal: number, hasMaterial: boolean): void;
+        _getResponse(pos: Vector3, vel: Vector3): void;
+    }
+}
+
+declare module BABYLON {
+    var CollisionWorker: string;
+    interface ICollisionCoordinator {
+        getNewPosition(position: Vector3, velocity: Vector3, collider: Collider, maximumRetry: number, excludedMesh: AbstractMesh, onNewPosition: (collisionIndex: number, newPosition: Vector3, collidedMesh?: AbstractMesh) => void, collisionIndex: number): void;
+        init(scene: Scene): void;
+        destroy(): void;
+        onMeshAdded(mesh: AbstractMesh): any;
+        onMeshUpdated(mesh: AbstractMesh): any;
+        onMeshRemoved(mesh: AbstractMesh): any;
+        onGeometryAdded(geometry: Geometry): any;
+        onGeometryUpdated(geometry: Geometry): any;
+        onGeometryDeleted(geometry: Geometry): any;
+    }
+    interface SerializedMesh {
+        id: string;
+        name: string;
+        uniqueId: number;
+        geometryId: string;
+        sphereCenter: Array<number>;
+        sphereRadius: number;
+        boxMinimum: Array<number>;
+        boxMaximum: Array<number>;
+        worldMatrixFromCache: any;
+        subMeshes: Array<SerializedSubMesh>;
+        checkCollisions: boolean;
+    }
+    interface SerializedSubMesh {
+        position: number;
+        verticesStart: number;
+        verticesCount: number;
+        indexStart: number;
+        indexCount: number;
+        hasMaterial: boolean;
+        sphereCenter: Array<number>;
+        sphereRadius: number;
+        boxMinimum: Array<number>;
+        boxMaximum: Array<number>;
+    }
+    interface SerializedGeometry {
+        id: string;
+        positions: Float32Array;
+        indices: Int32Array;
+        normals: Float32Array;
+    }
+    interface BabylonMessage {
+        taskType: WorkerTaskType;
+        payload: InitPayload | CollidePayload | UpdatePayload;
+    }
+    interface SerializedColliderToWorker {
+        position: Array<number>;
+        velocity: Array<number>;
+        radius: Array<number>;
+    }
+    enum WorkerTaskType {
+        INIT = 0,
+        UPDATE = 1,
+        COLLIDE = 2,
+    }
+    interface WorkerReply {
+        error: WorkerReplyType;
+        taskType: WorkerTaskType;
+        payload?: any;
+    }
+    interface CollisionReplyPayload {
+        newPosition: Array<number>;
+        collisionId: number;
+        collidedMeshUniqueId: number;
+    }
+    interface InitPayload {
+    }
+    interface CollidePayload {
+        collisionId: number;
+        collider: SerializedColliderToWorker;
+        maximumRetry: number;
+        excludedMeshUniqueId?: number;
+    }
+    interface UpdatePayload {
+        updatedMeshes: {
+            [n: number]: SerializedMesh;
+        };
+        updatedGeometries: {
+            [s: string]: SerializedGeometry;
+        };
+        removedMeshes: Array<number>;
+        removedGeometries: Array<string>;
+    }
+    enum WorkerReplyType {
+        SUCCESS = 0,
+        UNKNOWN_ERROR = 1,
+    }
+    class CollisionCoordinatorWorker implements ICollisionCoordinator {
         private _scene;
-        private _camera;
-        private _transformationMatrix;
-        private _enabled;
-        private _labelsEnabled;
-        private _displayStatistics;
-        private _displayTree;
-        private _displayLogs;
-        private _globalDiv;
-        private _statsDiv;
-        private _statsSubsetDiv;
-        private _optionsDiv;
-        private _optionsSubsetDiv;
-        private _logDiv;
-        private _logSubsetDiv;
-        private _treeDiv;
-        private _treeSubsetDiv;
-        private _drawingCanvas;
-        private _drawingContext;
-        private _rootElement;
-        _syncPositions: () => void;
-        private _syncData;
-        private _syncUI;
-        private _onCanvasClick;
-        private _clickPosition;
-        private _ratio;
-        private _identityMatrix;
-        private _showUI;
-        private _needToRefreshMeshesTree;
-        shouldDisplayLabel: (node: Node) => boolean;
-        shouldDisplayAxis: (mesh: Mesh) => boolean;
-        axisRatio: number;
-        accentColor: string;
-        customStatsFunction: () => string;
-        constructor(scene: Scene);
-        private _refreshMeshesTreeContent();
-        private _renderSingleAxis(zero, unit, unitText, label, color);
-        private _renderAxis(projectedPosition, mesh, globalViewport);
-        private _renderLabel(text, projectedPosition, labelOffset, onClick, getFillStyle);
-        private _isClickInsideRect(x, y, width, height);
-        isVisible(): boolean;
-        hide(): void;
-        show(showUI?: boolean, camera?: Camera, rootElement?: HTMLElement): void;
-        private _clearLabels();
-        private _generateheader(root, text);
-        private _generateTexBox(root, title, color);
-        private _generateAdvancedCheckBox(root, leftTitle, rightTitle, initialState, task, tag?);
-        private _generateCheckBox(root, title, initialState, task, tag?);
-        private _generateButton(root, title, task, tag?);
-        private _generateRadio(root, title, name, initialState, task, tag?);
-        private _generateDOMelements();
-        private _displayStats();
+        private _scaledPosition;
+        private _scaledVelocity;
+        private _collisionsCallbackArray;
+        private _init;
+        private _runningUpdated;
+        private _runningCollisionTask;
+        private _worker;
+        private _addUpdateMeshesList;
+        private _addUpdateGeometriesList;
+        private _toRemoveMeshesArray;
+        private _toRemoveGeometryArray;
+        constructor();
+        static SerializeMesh: (mesh: AbstractMesh) => SerializedMesh;
+        static SerializeGeometry: (geometry: Geometry) => SerializedGeometry;
+        getNewPosition(position: Vector3, velocity: Vector3, collider: Collider, maximumRetry: number, excludedMesh: AbstractMesh, onNewPosition: (collisionIndex: number, newPosition: Vector3, collidedMesh?: AbstractMesh) => void, collisionIndex: number): void;
+        init(scene: Scene): void;
+        destroy(): void;
+        onMeshAdded(mesh: AbstractMesh): void;
+        onMeshUpdated: (mesh: AbstractMesh) => void;
+        onMeshRemoved(mesh: AbstractMesh): void;
+        onGeometryAdded(geometry: Geometry): void;
+        onGeometryUpdated: (geometry: Geometry) => void;
+        onGeometryDeleted(geometry: Geometry): void;
+        private _afterRender;
+        private _onMessageFromWorker;
+    }
+    class CollisionCoordinatorLegacy implements ICollisionCoordinator {
+        private _scene;
+        private _scaledPosition;
+        private _scaledVelocity;
+        private _finalPosition;
+        getNewPosition(position: Vector3, velocity: Vector3, collider: Collider, maximumRetry: number, excludedMesh: AbstractMesh, onNewPosition: (collisionIndex: number, newPosition: Vector3, collidedMesh?: AbstractMesh) => void, collisionIndex: number): void;
+        init(scene: Scene): void;
+        destroy(): void;
+        onMeshAdded(mesh: AbstractMesh): void;
+        onMeshUpdated(mesh: AbstractMesh): void;
+        onMeshRemoved(mesh: AbstractMesh): void;
+        onGeometryAdded(geometry: Geometry): void;
+        onGeometryUpdated(geometry: Geometry): void;
+        onGeometryDeleted(geometry: Geometry): void;
+        private _collideWithWorld(position, velocity, collider, maximumRetry, finalPosition, excludedMesh?);
+    }
+}
+
+declare module BABYLON {
+    var WorkerIncluded: boolean;
+    class CollisionCache {
+        private _meshes;
+        private _geometries;
+        getMeshes(): {
+            [n: number]: SerializedMesh;
+        };
+        getGeometries(): {
+            [s: number]: SerializedGeometry;
+        };
+        getMesh(id: any): SerializedMesh;
+        addMesh(mesh: SerializedMesh): void;
+        removeMesh(uniqueId: number): void;
+        getGeometry(id: string): SerializedGeometry;
+        addGeometry(geometry: SerializedGeometry): void;
+        removeGeometry(id: string): void;
+    }
+    class CollideWorker {
+        collider: Collider;
+        private _collisionCache;
+        private finalPosition;
+        private collisionsScalingMatrix;
+        private collisionTranformationMatrix;
+        constructor(collider: Collider, _collisionCache: CollisionCache, finalPosition: Vector3);
+        collideWithWorld(position: Vector3, velocity: Vector3, maximumRetry: number, excludedMeshUniqueId?: number): void;
+        private checkCollision(mesh);
+        private processCollisionsForSubMeshes(transformMatrix, mesh);
+        private collideForSubMesh(subMesh, transformMatrix, meshGeometry);
+        private checkSubmeshCollision(subMesh);
+    }
+    interface ICollisionDetector {
+        onInit(payload: InitPayload): void;
+        onUpdate(payload: UpdatePayload): void;
+        onCollision(payload: CollidePayload): void;
+    }
+    class CollisionDetectorTransferable implements ICollisionDetector {
+        private _collisionCache;
+        onInit(payload: InitPayload): void;
+        onUpdate(payload: UpdatePayload): void;
+        onCollision(payload: CollidePayload): void;
+    }
+}
+
+declare module BABYLON {
+    class IntersectionInfo {
+        bu: number;
+        bv: number;
+        distance: number;
+        faceId: number;
+        subMeshId: number;
+        constructor(bu: number, bv: number, distance: number);
+    }
+    class PickingInfo {
+        hit: boolean;
+        distance: number;
+        pickedPoint: Vector3;
+        pickedMesh: AbstractMesh;
+        bu: number;
+        bv: number;
+        faceId: number;
+        subMeshId: number;
+        pickedSprite: Sprite;
+        getNormal(useWorldCoordinates?: boolean, useVerticesNormals?: boolean): Vector3;
+        getTextureCoordinates(): Vector2;
     }
 }
 
@@ -2472,6 +2415,63 @@ declare module BABYLON {
 }
 
 declare module BABYLON {
+    class DebugLayer {
+        private _scene;
+        private _camera;
+        private _transformationMatrix;
+        private _enabled;
+        private _labelsEnabled;
+        private _displayStatistics;
+        private _displayTree;
+        private _displayLogs;
+        private _globalDiv;
+        private _statsDiv;
+        private _statsSubsetDiv;
+        private _optionsDiv;
+        private _optionsSubsetDiv;
+        private _logDiv;
+        private _logSubsetDiv;
+        private _treeDiv;
+        private _treeSubsetDiv;
+        private _drawingCanvas;
+        private _drawingContext;
+        private _rootElement;
+        _syncPositions: () => void;
+        private _syncData;
+        private _syncUI;
+        private _onCanvasClick;
+        private _clickPosition;
+        private _ratio;
+        private _identityMatrix;
+        private _showUI;
+        private _needToRefreshMeshesTree;
+        shouldDisplayLabel: (node: Node) => boolean;
+        shouldDisplayAxis: (mesh: Mesh) => boolean;
+        axisRatio: number;
+        accentColor: string;
+        customStatsFunction: () => string;
+        constructor(scene: Scene);
+        private _refreshMeshesTreeContent();
+        private _renderSingleAxis(zero, unit, unitText, label, color);
+        private _renderAxis(projectedPosition, mesh, globalViewport);
+        private _renderLabel(text, projectedPosition, labelOffset, onClick, getFillStyle);
+        private _isClickInsideRect(x, y, width, height);
+        isVisible(): boolean;
+        hide(): void;
+        show(showUI?: boolean, camera?: Camera, rootElement?: HTMLElement): void;
+        private _clearLabels();
+        private _generateheader(root, text);
+        private _generateTexBox(root, title, color);
+        private _generateAdvancedCheckBox(root, leftTitle, rightTitle, initialState, task, tag?);
+        private _generateCheckBox(root, title, initialState, task, tag?);
+        private _generateButton(root, title, task, tag?);
+        private _generateRadio(root, title, name, initialState, task, tag?);
+        private _generateDOMelements();
+        private _displayStats();
+    }
+}
+
+declare module BABYLON {
     class Layer {
         name: string;
         texture: Texture;
@@ -3565,66 +3565,6 @@ declare module BABYLON {
 }
 
 declare module BABYLON {
-    interface IPhysicsEnginePlugin {
-        name: string;
-        initialize(iterations?: number): any;
-        setGravity(gravity: Vector3): void;
-        getGravity(): Vector3;
-        runOneStep(delta: number): void;
-        registerMesh(mesh: AbstractMesh, impostor: number, options: PhysicsBodyCreationOptions): any;
-        registerMeshesAsCompound(parts: PhysicsCompoundBodyPart[], options: PhysicsBodyCreationOptions): any;
-        unregisterMesh(mesh: AbstractMesh): any;
-        applyImpulse(mesh: AbstractMesh, force: Vector3, contactPoint: Vector3): void;
-        createLink(mesh1: AbstractMesh, mesh2: AbstractMesh, pivot1: Vector3, pivot2: Vector3, options?: any): boolean;
-        dispose(): void;
-        isSupported(): boolean;
-        updateBodyPosition(mesh: AbstractMesh): void;
-        getWorldObject(): any;
-        getPhysicsBodyOfMesh(mesh: AbstractMesh): any;
-    }
-    interface PhysicsBodyCreationOptions {
-        mass: number;
-        friction: number;
-        restitution: number;
-    }
-    interface PhysicsCompoundBodyPart {
-        mesh: Mesh;
-        impostor: number;
-    }
-    class PhysicsEngine {
-        gravity: Vector3;
-        private _currentPlugin;
-        constructor(plugin?: IPhysicsEnginePlugin);
-        _initialize(gravity?: Vector3): void;
-        _runOneStep(delta: number): void;
-        _setGravity(gravity: Vector3): void;
-        _getGravity(): Vector3;
-        _registerMesh(mesh: AbstractMesh, impostor: number, options: PhysicsBodyCreationOptions): any;
-        _registerMeshesAsCompound(parts: PhysicsCompoundBodyPart[], options: PhysicsBodyCreationOptions): any;
-        _unregisterMesh(mesh: AbstractMesh): void;
-        _applyImpulse(mesh: AbstractMesh, force: Vector3, contactPoint: Vector3): void;
-        _createLink(mesh1: AbstractMesh, mesh2: AbstractMesh, pivot1: Vector3, pivot2: Vector3, options?: any): boolean;
-        _updateBodyPosition(mesh: AbstractMesh): void;
-        dispose(): void;
-        isSupported(): boolean;
-        getPhysicsBodyOfMesh(mesh: AbstractMesh): any;
-        getPhysicsPluginName(): string;
-        getWorldObject(): any;
-        static NoImpostor: number;
-        static SphereImpostor: number;
-        static BoxImpostor: number;
-        static PlaneImpostor: number;
-        static MeshImpostor: number;
-        static CapsuleImpostor: number;
-        static ConeImpostor: number;
-        static CylinderImpostor: number;
-        static ConvexHullImpostor: number;
-        static HeightmapImpostor: number;
-        static Epsilon: number;
-    }
-}
-
-declare module BABYLON {
     class AbstractMesh extends Node implements IDisposable {
         private static _BILLBOARDMODE_NONE;
         private static _BILLBOARDMODE_X;
@@ -5378,23 +5318,62 @@ declare module BABYLON {
 }
 
 declare module BABYLON {
-    class ReflectionProbe {
+    interface IPhysicsEnginePlugin {
         name: string;
-        private _scene;
-        private _renderTargetTexture;
-        private _projectionMatrix;
-        private _viewMatrix;
-        private _target;
-        private _add;
-        private _attachedMesh;
-        position: Vector3;
-        constructor(name: string, size: number, scene: Scene, generateMipMaps?: boolean);
-        refreshRate: number;
-        getScene(): Scene;
-        cubeTexture: RenderTargetTexture;
-        renderList: AbstractMesh[];
-        attachToMesh(mesh: AbstractMesh): void;
+        initialize(iterations?: number): any;
+        setGravity(gravity: Vector3): void;
+        getGravity(): Vector3;
+        runOneStep(delta: number): void;
+        registerMesh(mesh: AbstractMesh, impostor: number, options: PhysicsBodyCreationOptions): any;
+        registerMeshesAsCompound(parts: PhysicsCompoundBodyPart[], options: PhysicsBodyCreationOptions): any;
+        unregisterMesh(mesh: AbstractMesh): any;
+        applyImpulse(mesh: AbstractMesh, force: Vector3, contactPoint: Vector3): void;
+        createLink(mesh1: AbstractMesh, mesh2: AbstractMesh, pivot1: Vector3, pivot2: Vector3, options?: any): boolean;
+        dispose(): void;
+        isSupported(): boolean;
+        updateBodyPosition(mesh: AbstractMesh): void;
+        getWorldObject(): any;
+        getPhysicsBodyOfMesh(mesh: AbstractMesh): any;
+    }
+    interface PhysicsBodyCreationOptions {
+        mass: number;
+        friction: number;
+        restitution: number;
+    }
+    interface PhysicsCompoundBodyPart {
+        mesh: Mesh;
+        impostor: number;
+    }
+    class PhysicsEngine {
+        gravity: Vector3;
+        private _currentPlugin;
+        constructor(plugin?: IPhysicsEnginePlugin);
+        _initialize(gravity?: Vector3): void;
+        _runOneStep(delta: number): void;
+        _setGravity(gravity: Vector3): void;
+        _getGravity(): Vector3;
+        _registerMesh(mesh: AbstractMesh, impostor: number, options: PhysicsBodyCreationOptions): any;
+        _registerMeshesAsCompound(parts: PhysicsCompoundBodyPart[], options: PhysicsBodyCreationOptions): any;
+        _unregisterMesh(mesh: AbstractMesh): void;
+        _applyImpulse(mesh: AbstractMesh, force: Vector3, contactPoint: Vector3): void;
+        _createLink(mesh1: AbstractMesh, mesh2: AbstractMesh, pivot1: Vector3, pivot2: Vector3, options?: any): boolean;
+        _updateBodyPosition(mesh: AbstractMesh): void;
         dispose(): void;
+        isSupported(): boolean;
+        getPhysicsBodyOfMesh(mesh: AbstractMesh): any;
+        getPhysicsPluginName(): string;
+        getWorldObject(): any;
+        static NoImpostor: number;
+        static SphereImpostor: number;
+        static BoxImpostor: number;
+        static PlaneImpostor: number;
+        static MeshImpostor: number;
+        static CapsuleImpostor: number;
+        static ConeImpostor: number;
+        static CylinderImpostor: number;
+        static ConvexHullImpostor: number;
+        static HeightmapImpostor: number;
+        static Epsilon: number;
     }
 }
 
@@ -5968,6 +5947,27 @@ declare module BABYLON {
 }
 
 declare module BABYLON {
+    class ReflectionProbe {
+        name: string;
+        private _scene;
+        private _renderTargetTexture;
+        private _projectionMatrix;
+        private _viewMatrix;
+        private _target;
+        private _add;
+        private _attachedMesh;
+        position: Vector3;
+        constructor(name: string, size: number, scene: Scene, generateMipMaps?: boolean);
+        refreshRate: number;
+        getScene(): Scene;
+        cubeTexture: RenderTargetTexture;
+        renderList: AbstractMesh[];
+        attachToMesh(mesh: AbstractMesh): void;
+        dispose(): void;
+    }
+}
+
+declare module BABYLON {
     class BoundingBoxRenderer {
         frontColor: Color3;
         backColor: Color3;
@@ -6269,6 +6269,7 @@ declare module BABYLON {
     function serializeAsTexture(sourceName?: string): (target: any, propertyKey: string | symbol) => void;
     function serializeAsColor3(sourceName?: string): (target: any, propertyKey: string | symbol) => void;
     function serializeAsFresnelParameters(sourceName?: string): (target: any, propertyKey: string | symbol) => void;
+    function serializeAsVector2(sourceName?: string): (target: any, propertyKey: string | symbol) => void;
     function serializeAsVector3(sourceName?: string): (target: any, propertyKey: string | symbol) => void;
     function serializeAsMeshReference(sourceName?: string): (target: any, propertyKey: string | symbol) => void;
     class SerializationHelper {
@@ -7446,6 +7447,11 @@ declare module BABYLON.Internals {
     }
 }
 
+declare module BABYLON.Internals {
+    class PMREMGenerator {
+    }
+}
+
 declare module BABYLON {
     class CustomProceduralTexture extends ProceduralTexture {
         private _animate;

materialsLibrary/dist/babylon.furMaterial.js

@@ -1,5 +1,13 @@
 /// <reference path="../../../dist/preview release/babylon.d.ts"/>
 
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc);
+    switch (arguments.length) {
+        case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);
+        case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
+        case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
+    }
+};
 var BABYLON;
 (function (BABYLON) {
     var maxSimultaneousLights = 4;
@@ -467,67 +475,17 @@ var BABYLON;
             _super.prototype.dispose.call(this, forceDisposeEffect);
         };
         FurMaterial.prototype.clone = function (name) {
-            var newMaterial = new FurMaterial(name, this.getScene());
-            // Base material
-            this.copyTo(newMaterial);
-            // Fur material
-            if (this.diffuseTexture && this.diffuseTexture.clone) {
-                newMaterial.diffuseTexture = this.diffuseTexture.clone();
-            }
-            if (this.heightTexture && this.heightTexture.clone) {
-                newMaterial.heightTexture = this.heightTexture.clone();
-            }
-            if (this.diffuseColor && this.diffuseColor.clone) {
-                newMaterial.diffuseColor = this.diffuseColor.clone();
-            }
-            return newMaterial;
+            var _this = this;
+            return BABYLON.SerializationHelper.Clone(function () { return new FurMaterial(name, _this.getScene()); }, this);
         };
         FurMaterial.prototype.serialize = function () {
-            var serializationObject = _super.prototype.serialize.call(this);
+            var serializationObject = BABYLON.SerializationHelper.Serialize(this);
             serializationObject.customType = "BABYLON.FurMaterial";
-            serializationObject.diffuseColor = this.diffuseColor.asArray();
-            serializationObject.disableLighting = this.disableLighting;
-            serializationObject.furLength = this.furLength;
-            serializationObject.furAngle = this.furAngle;
-            serializationObject.furColor = this.furColor.asArray();
-            serializationObject.furGravity = this.furGravity.asArray();
-            serializationObject.furSpacing = this.furSpacing;
-            serializationObject.furSpeed = this.furSpeed;
-            serializationObject.furDensity = this.furDensity;
-            if (this.diffuseTexture) {
-                serializationObject.diffuseTexture = this.diffuseTexture.serialize();
-            }
-            if (this.heightTexture) {
-                serializationObject.heightTexture = this.heightTexture.serialize();
-            }
             return serializationObject;
         };
+        // Statics
         FurMaterial.Parse = function (source, scene, rootUrl) {
-            var material = new FurMaterial(source.name, scene);
-            material.diffuseColor = BABYLON.Color3.FromArray(source.diffuseColor);
-            material.furLength = source.furLength;
-            material.furAngle = source.furAngle;
-            material.furColor = BABYLON.Color3.FromArray(source.furColor);
-            material.furGravity = BABYLON.Vector3.FromArray(source.furGravity);
-            material.furSpacing = source.furSpacing;
-            material.furSpeed = source.furSpeed;
-            material.furDensity = source.furDensity;
-            material.disableLighting = source.disableLighting;
-            material.alpha = source.alpha;
-            material.id = source.id;
-            BABYLON.Tags.AddTagsTo(material, source.tags);
-            material.backFaceCulling = source.backFaceCulling;
-            material.wireframe = source.wireframe;
-            if (source.diffuseTexture) {
-                material.diffuseTexture = BABYLON.Texture.Parse(source.diffuseTexture, scene, rootUrl);
-            }
-            if (source.heightTexture) {
-                material.heightTexture = BABYLON.Texture.Parse(source.heightTexture, scene, rootUrl);
-            }
-            if (source.checkReadyOnlyOnce) {
-                material.checkReadyOnlyOnce = source.checkReadyOnlyOnce;
-            }
-            return material;
+            return BABYLON.SerializationHelper.Parse(function () { return new FurMaterial(source.name, scene); }, source, scene, rootUrl);
         };
         FurMaterial.GenerateTexture = function (name, scene) {
             // Generate fur textures
@@ -573,6 +531,43 @@ var BABYLON;
             }
             return meshes;
         };
+        __decorate([
+            BABYLON.serialize()
+        ], FurMaterial.prototype, "furLength");
+        __decorate([
+            BABYLON.serialize()
+        ], FurMaterial.prototype, "furAngle");
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], FurMaterial.prototype, "furColor");
+        __decorate([
+            BABYLON.serialize()
+        ], FurMaterial.prototype, "furOffset");
+        __decorate([
+            BABYLON.serialize()
+        ], FurMaterial.prototype, "furSpacing");
+        __decorate([
+            BABYLON.serializeAsVector3()
+        ], FurMaterial.prototype, "furGravity");
+        __decorate([
+            BABYLON.serialize()
+        ], FurMaterial.prototype, "furSpeed");
+        __decorate([
+            BABYLON.serialize()
+        ], FurMaterial.prototype, "furDensity");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], FurMaterial.prototype, "furTexture");
+        __decorate([
+            BABYLON.serialize()
+        ], FurMaterial.prototype, "disableLighting");
+        __decorate([
+            BABYLON.serialize()
+        ], FurMaterial.prototype, "highLevelFur");
+        Object.defineProperty(FurMaterial.prototype, "furTime",
+            __decorate([
+                BABYLON.serialize()
+            ], FurMaterial.prototype, "furTime", Object.getOwnPropertyDescriptor(FurMaterial.prototype, "furTime")));
         return FurMaterial;
     })(BABYLON.Material);
     BABYLON.FurMaterial = FurMaterial;

materialsLibrary/dist/babylon.gradientMaterial.js

@@ -1,5 +1,13 @@
 /// <reference path="../../../dist/preview release/babylon.d.ts"/>
 
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc);
+    switch (arguments.length) {
+        case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);
+        case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
+        case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
+    }
+};
 var BABYLON;
 (function (BABYLON) {
     var maxSimultaneousLights = 4;
@@ -266,40 +274,39 @@ var BABYLON;
             _super.prototype.dispose.call(this, forceDisposeEffect);
         };
         GradientMaterial.prototype.clone = function (name) {
-            var newMaterial = new GradientMaterial(name, this.getScene());
-            // Base material
-            this.copyTo(newMaterial);
-            // Gradient material
-            newMaterial.topColor = this.topColor.clone();
-            newMaterial.bottomColor = this.bottomColor.clone();
-            newMaterial.offset = this.offset;
-            return newMaterial;
+            var _this = this;
+            return BABYLON.SerializationHelper.Clone(function () { return new GradientMaterial(name, _this.getScene()); }, this);
         };
         GradientMaterial.prototype.serialize = function () {
-            var serializationObject = _super.prototype.serialize.call(this);
+            var serializationObject = BABYLON.SerializationHelper.Serialize(this);
             serializationObject.customType = "BABYLON.GradientMaterial";
-            serializationObject.topColor = this.topColor.asArray();
-            serializationObject.bottomColor = this.bottomColor.asArray();
-            serializationObject.offset = this.offset;
-            serializationObject.disableLighting = this.disableLighting;
             return serializationObject;
         };
+        // Statics
         GradientMaterial.Parse = function (source, scene, rootUrl) {
-            var material = new GradientMaterial(source.name, scene);
-            material.topColor = BABYLON.Color3.FromArray(source.topColor);
-            material.bottomColor = BABYLON.Color3.FromArray(source.bottomColor);
-            material.offset = source.offset;
-            material.disableLighting = source.disableLighting;
-            material.alpha = source.alpha;
-            material.id = source.id;
-            BABYLON.Tags.AddTagsTo(material, source.tags);
-            material.backFaceCulling = source.backFaceCulling;
-            material.wireframe = source.wireframe;
-            if (source.checkReadyOnlyOnce) {
-                material.checkReadyOnlyOnce = source.checkReadyOnlyOnce;
-            }
-            return material;
+            return BABYLON.SerializationHelper.Parse(function () { return new GradientMaterial(source.name, scene); }, source, scene, rootUrl);
         };
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], GradientMaterial.prototype, "topColor");
+        __decorate([
+            BABYLON.serialize()
+        ], GradientMaterial.prototype, "topColorAlpha");
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], GradientMaterial.prototype, "bottomColor");
+        __decorate([
+            BABYLON.serialize()
+        ], GradientMaterial.prototype, "bottomColorAlpha");
+        __decorate([
+            BABYLON.serialize()
+        ], GradientMaterial.prototype, "offset");
+        __decorate([
+            BABYLON.serialize()
+        ], GradientMaterial.prototype, "smoothness");
+        __decorate([
+            BABYLON.serialize()
+        ], GradientMaterial.prototype, "disableLighting");
         return GradientMaterial;
     })(BABYLON.Material);
     BABYLON.GradientMaterial = GradientMaterial;

materialsLibrary/dist/babylon.lavaMaterial.js

@@ -1,5 +1,13 @@
 /// <reference path="../../../dist/preview release/babylon.d.ts"/>
 
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc);
+    switch (arguments.length) {
+        case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);
+        case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
+        case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
+    }
+};
 var BABYLON;
 (function (BABYLON) {
     var maxSimultaneousLights = 4;
@@ -302,63 +310,45 @@ var BABYLON;
             _super.prototype.dispose.call(this, forceDisposeEffect);
         };
         LavaMaterial.prototype.clone = function (name) {
-            var newMaterial = new LavaMaterial(name, this.getScene());
-            // Base material
-            this.copyTo(newMaterial);
-            // Lava material
-            if (this.diffuseTexture && this.diffuseTexture.clone) {
-                newMaterial.diffuseTexture = this.diffuseTexture.clone();
-            }
-            if (this.noiseTexture && this.noiseTexture.clone) {
-                newMaterial.noiseTexture = this.noiseTexture.clone();
-            }
-            if (this.fogColor && this.fogColor.clone) {
-                newMaterial.fogColor = this.fogColor.clone();
-            }
-            return newMaterial;
+            var _this = this;
+            return BABYLON.SerializationHelper.Clone(function () { return new LavaMaterial(name, _this.getScene()); }, this);
         };
         LavaMaterial.prototype.serialize = function () {
-            var serializationObject = _super.prototype.serialize.call(this);
+            var serializationObject = BABYLON.SerializationHelper.Serialize(this);
             serializationObject.customType = "BABYLON.LavaMaterial";
-            serializationObject.diffuseColor = this.diffuseColor.asArray();
-            serializationObject.fogColor = this.fogColor.asArray();
-            serializationObject.speed = this.speed;
-            serializationObject.movingSpeed = this.movingSpeed;
-            serializationObject.lowFrequencySpeed = this.lowFrequencySpeed;
-            serializationObject.fogDensity = this.fogDensity;
-            serializationObject.checkReadyOnlyOnce = this.checkReadyOnlyOnce;
-            if (this.diffuseTexture) {
-                serializationObject.diffuseTexture = this.diffuseTexture.serialize();
-            }
-            if (this.noiseTexture) {
-                serializationObject.noiseTexture = this.noiseTexture.serialize();
-            }
             return serializationObject;
         };
+        // Statics
         LavaMaterial.Parse = function (source, scene, rootUrl) {
-            var material = new LavaMaterial(source.name, scene);
-            material.diffuseColor = BABYLON.Color3.FromArray(source.diffuseColor);
-            material.speed = source.speed;
-            material.fogColor = BABYLON.Color3.FromArray(source.fogColor);
-            material.movingSpeed = source.movingSpeed;
-            material.lowFrequencySpeed = source.lowFrequencySpeed;
-            material.fogDensity = source.lowFrequencySpeed;
-            material.alpha = source.alpha;
-            material.id = source.id;
-            BABYLON.Tags.AddTagsTo(material, source.tags);
-            material.backFaceCulling = source.backFaceCulling;
-            material.wireframe = source.wireframe;
-            if (source.diffuseTexture) {
-                material.diffuseTexture = BABYLON.Texture.Parse(source.diffuseTexture, scene, rootUrl);
-            }
-            if (source.noiseTexture) {
-                material.noiseTexture = BABYLON.Texture.Parse(source.noiseTexture, scene, rootUrl);
-            }
-            if (source.checkReadyOnlyOnce) {
-                material.checkReadyOnlyOnce = source.checkReadyOnlyOnce;
-            }
-            return material;
+            return BABYLON.SerializationHelper.Parse(function () { return new LavaMaterial(source.name, scene); }, source, scene, rootUrl);
         };
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], LavaMaterial.prototype, "diffuseTexture");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], LavaMaterial.prototype, "noiseTexture");
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], LavaMaterial.prototype, "fogColor");
+        __decorate([
+            BABYLON.serialize()
+        ], LavaMaterial.prototype, "speed");
+        __decorate([
+            BABYLON.serialize()
+        ], LavaMaterial.prototype, "movingSpeed");
+        __decorate([
+            BABYLON.serialize()
+        ], LavaMaterial.prototype, "lowFrequencySpeed");
+        __decorate([
+            BABYLON.serialize()
+        ], LavaMaterial.prototype, "fogDensity");
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], LavaMaterial.prototype, "diffuseColor");
+        __decorate([
+            BABYLON.serialize()
+        ], LavaMaterial.prototype, "disableLighting");
         return LavaMaterial;
     })(BABYLON.Material);
     BABYLON.LavaMaterial = LavaMaterial;

materialsLibrary/dist/babylon.normalMaterial.js

@@ -1,5 +1,13 @@
 /// <reference path="../../../dist/preview release/babylon.d.ts"/>
 
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc);
+    switch (arguments.length) {
+        case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);
+        case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
+        case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
+    }
+};
 var BABYLON;
 (function (BABYLON) {
     var NormalMaterialDefines = (function (_super) {
@@ -277,43 +285,27 @@ var BABYLON;
             _super.prototype.dispose.call(this, forceDisposeEffect);
         };
         NormalMaterial.prototype.clone = function (name) {
-            var newMaterial = new NormalMaterial(name, this.getScene());
-            // Base material
-            this.copyTo(newMaterial);
-            // Normal material
-            if (this.diffuseTexture && this.diffuseTexture.clone) {
-                newMaterial.diffuseTexture = this.diffuseTexture.clone();
-            }
-            newMaterial.diffuseColor = this.diffuseColor.clone();
-            return newMaterial;
+            var _this = this;
+            return BABYLON.SerializationHelper.Clone(function () { return new NormalMaterial(name, _this.getScene()); }, this);
         };
         NormalMaterial.prototype.serialize = function () {
-            var serializationObject = _super.prototype.serialize.call(this);
+            var serializationObject = BABYLON.SerializationHelper.Serialize(this);
             serializationObject.customType = "BABYLON.NormalMaterial";
-            serializationObject.diffuseColor = this.diffuseColor.asArray();
-            serializationObject.disableLighting = this.disableLighting;
-            if (this.diffuseTexture) {
-                serializationObject.diffuseTexture = this.diffuseTexture.serialize();
-            }
             return serializationObject;
         };
+        // Statics
         NormalMaterial.Parse = function (source, scene, rootUrl) {
-            var material = new NormalMaterial(source.name, scene);
-            material.diffuseColor = BABYLON.Color3.FromArray(source.diffuseColor);
-            material.disableLighting = source.disableLighting;
-            material.alpha = source.alpha;
-            material.id = source.id;
-            BABYLON.Tags.AddTagsTo(material, source.tags);
-            material.backFaceCulling = source.backFaceCulling;
-            material.wireframe = source.wireframe;
-            if (source.diffuseTexture) {
-                material.diffuseTexture = BABYLON.Texture.Parse(source.diffuseTexture, scene, rootUrl);
-            }
-            if (source.checkReadyOnlyOnce) {
-                material.checkReadyOnlyOnce = source.checkReadyOnlyOnce;
-            }
-            return material;
+            return BABYLON.SerializationHelper.Parse(function () { return new NormalMaterial(source.name, scene); }, source, scene, rootUrl);
         };
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], NormalMaterial.prototype, "diffuseTexture");
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], NormalMaterial.prototype, "diffuseColor");
+        __decorate([
+            BABYLON.serialize()
+        ], NormalMaterial.prototype, "disableLighting");
         return NormalMaterial;
     })(BABYLON.Material);
     BABYLON.NormalMaterial = NormalMaterial;

materialsLibrary/dist/babylon.pbrMaterial.js

@@ -1,5 +1,13 @@
 /// <reference path="../../../dist/preview release/babylon.d.ts"/>
 
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc);
+    switch (arguments.length) {
+        case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);
+        case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
+        case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
+    }
+};
 var BABYLON;
 (function (BABYLON) {
     var maxSimultaneousLights = 4;
@@ -844,243 +852,183 @@ var BABYLON;
             _super.prototype.dispose.call(this, forceDisposeEffect);
         };
         PBRMaterial.prototype.clone = function (name) {
-            var newPBRMaterial = new PBRMaterial(name, this.getScene());
-            // Base material
-            this.copyTo(newPBRMaterial);
-            newPBRMaterial.directIntensity = this.directIntensity;
-            newPBRMaterial.emissiveIntensity = this.emissiveIntensity;
-            newPBRMaterial.environmentIntensity = this.environmentIntensity;
-            newPBRMaterial.specularIntensity = this.specularIntensity;
-            newPBRMaterial.cameraExposure = this.cameraExposure;
-            newPBRMaterial.cameraContrast = this.cameraContrast;
-            newPBRMaterial.overloadedShadowIntensity = this.overloadedShadowIntensity;
-            newPBRMaterial.overloadedShadeIntensity = this.overloadedShadeIntensity;
-            newPBRMaterial.overloadedAmbientIntensity = this.overloadedAmbientIntensity;
-            newPBRMaterial.overloadedAlbedoIntensity = this.overloadedAlbedoIntensity;
-            newPBRMaterial.overloadedReflectivityIntensity = this.overloadedReflectivityIntensity;
-            newPBRMaterial.overloadedEmissiveIntensity = this.overloadedEmissiveIntensity;
-            newPBRMaterial.overloadedAmbient = this.overloadedAmbient;
-            newPBRMaterial.overloadedAlbedo = this.overloadedAlbedo;
-            newPBRMaterial.overloadedReflectivity = this.overloadedReflectivity;
-            newPBRMaterial.overloadedEmissive = this.overloadedEmissive;
-            newPBRMaterial.overloadedReflection = this.overloadedReflection;
-            newPBRMaterial.overloadedMicroSurface = this.overloadedMicroSurface;
-            newPBRMaterial.overloadedMicroSurfaceIntensity = this.overloadedMicroSurfaceIntensity;
-            newPBRMaterial.overloadedReflectionIntensity = this.overloadedReflectionIntensity;
-            newPBRMaterial.disableBumpMap = this.disableBumpMap;
-            // Standard material
-            if (this.albedoTexture && this.albedoTexture.clone) {
-                newPBRMaterial.albedoTexture = this.albedoTexture.clone();
-            }
-            if (this.ambientTexture && this.ambientTexture.clone) {
-                newPBRMaterial.ambientTexture = this.ambientTexture.clone();
-            }
-            if (this.opacityTexture && this.opacityTexture.clone) {
-                newPBRMaterial.opacityTexture = this.opacityTexture.clone();
-            }
-            if (this.reflectionTexture && this.reflectionTexture.clone) {
-                newPBRMaterial.reflectionTexture = this.reflectionTexture.clone();
-            }
-            if (this.emissiveTexture && this.emissiveTexture.clone) {
-                newPBRMaterial.emissiveTexture = this.emissiveTexture.clone();
-            }
-            if (this.reflectivityTexture && this.reflectivityTexture.clone) {
-                newPBRMaterial.reflectivityTexture = this.reflectivityTexture.clone();
-            }
-            if (this.bumpTexture && this.bumpTexture.clone) {
-                newPBRMaterial.bumpTexture = this.bumpTexture.clone();
-            }
-            if (this.lightmapTexture && this.lightmapTexture.clone) {
-                newPBRMaterial.lightmapTexture = this.lightmapTexture.clone();
-                newPBRMaterial.useLightmapAsShadowmap = this.useLightmapAsShadowmap;
-            }
-            if (this.refractionTexture && this.refractionTexture.clone) {
-                newPBRMaterial.refractionTexture = this.refractionTexture.clone();
-                newPBRMaterial.linkRefractionWithTransparency = this.linkRefractionWithTransparency;
-            }
-            newPBRMaterial.ambientColor = this.ambientColor.clone();
-            newPBRMaterial.albedoColor = this.albedoColor.clone();
-            newPBRMaterial.reflectivityColor = this.reflectivityColor.clone();
-            newPBRMaterial.reflectionColor = this.reflectionColor.clone();
-            newPBRMaterial.microSurface = this.microSurface;
-            newPBRMaterial.emissiveColor = this.emissiveColor.clone();
-            newPBRMaterial.useAlphaFromAlbedoTexture = this.useAlphaFromAlbedoTexture;
-            newPBRMaterial.useEmissiveAsIllumination = this.useEmissiveAsIllumination;
-            newPBRMaterial.useMicroSurfaceFromReflectivityMapAlpha = this.useMicroSurfaceFromReflectivityMapAlpha;
-            newPBRMaterial.useAutoMicroSurfaceFromReflectivityMap = this.useAutoMicroSurfaceFromReflectivityMap;
-            newPBRMaterial.useScalarInLinearSpace = this.useScalarInLinearSpace;
-            newPBRMaterial.useSpecularOverAlpha = this.useSpecularOverAlpha;
-            newPBRMaterial.indexOfRefraction = this.indexOfRefraction;
-            newPBRMaterial.invertRefractionY = this.invertRefractionY;
-            newPBRMaterial.usePhysicalLightFalloff = this.usePhysicalLightFalloff;
-            newPBRMaterial.useRadianceOverAlpha = this.useRadianceOverAlpha;
-            newPBRMaterial.emissiveFresnelParameters = this.emissiveFresnelParameters.clone();
-            newPBRMaterial.opacityFresnelParameters = this.opacityFresnelParameters.clone();
-            return newPBRMaterial;
+            var _this = this;
+            return BABYLON.SerializationHelper.Clone(function () { return new PBRMaterial(name, _this.getScene()); }, this);
         };
         PBRMaterial.prototype.serialize = function () {
-            var serializationObject = _super.prototype.serialize.call(this);
+            var serializationObject = BABYLON.SerializationHelper.Serialize(this);
             serializationObject.customType = "BABYLON.PBRMaterial";
-            serializationObject.directIntensity = this.directIntensity;
-            serializationObject.emissiveIntensity = this.emissiveIntensity;
-            serializationObject.environmentIntensity = this.environmentIntensity;
-            serializationObject.specularIntensity = this.specularIntensity;
-            serializationObject.cameraExposure = this.cameraExposure;
-            serializationObject.cameraContrast = this.cameraContrast;
-            serializationObject.overloadedShadowIntensity = this.overloadedShadowIntensity;
-            serializationObject.overloadedShadeIntensity = this.overloadedShadeIntensity;
-            serializationObject.overloadedAmbientIntensity = this.overloadedAmbientIntensity;
-            serializationObject.overloadedAlbedoIntensity = this.overloadedAlbedoIntensity;
-            serializationObject.overloadedReflectivityIntensity = this.overloadedReflectivityIntensity;
-            serializationObject.overloadedEmissiveIntensity = this.overloadedEmissiveIntensity;
-            serializationObject.overloadedAmbient = this.overloadedAmbient.asArray();
-            serializationObject.overloadedAlbedo = this.overloadedAlbedo.asArray();
-            serializationObject.overloadedReflectivity = this.overloadedReflectivity.asArray();
-            serializationObject.overloadedEmissive = this.overloadedEmissive.asArray();
-            serializationObject.overloadedReflection = this.overloadedReflection.asArray();
-            serializationObject.overloadedMicroSurface = this.overloadedMicroSurface;
-            serializationObject.overloadedMicroSurfaceIntensity = this.overloadedMicroSurfaceIntensity;
-            serializationObject.overloadedReflectionIntensity = this.overloadedReflectionIntensity;
-            serializationObject.disableBumpMap = this.disableBumpMap;
-            // Standard material
-            if (this.albedoTexture) {
-                serializationObject.albedoTexture = this.albedoTexture.serialize();
-            }
-            if (this.ambientTexture) {
-                serializationObject.ambientTexture = this.ambientTexture.serialize();
-            }
-            if (this.opacityTexture) {
-                serializationObject.opacityTexture = this.opacityTexture.serialize();
-            }
-            if (this.reflectionTexture) {
-                serializationObject.reflectionTexture = this.reflectionTexture.serialize();
-            }
-            if (this.emissiveTexture) {
-                serializationObject.emissiveTexture = this.emissiveTexture.serialize();
-            }
-            if (this.reflectivityTexture) {
-                serializationObject.reflectivityTexture = this.reflectivityTexture.serialize();
-            }
-            if (this.bumpTexture) {
-                serializationObject.bumpTexture = this.bumpTexture.serialize();
-            }
-            if (this.lightmapTexture) {
-                serializationObject.lightmapTexture = this.lightmapTexture.serialize();
-                serializationObject.useLightmapAsShadowmap = this.useLightmapAsShadowmap;
-            }
-            if (this.refractionTexture) {
-                serializationObject.refractionTexture = this.refractionTexture;
-                serializationObject.linkRefractionWithTransparency = this.linkRefractionWithTransparency;
-            }
-            serializationObject.ambientColor = this.ambientColor.asArray();
-            serializationObject.albedoColor = this.albedoColor.asArray();
-            serializationObject.reflectivityColor = this.reflectivityColor.asArray();
-            serializationObject.reflectionColor = this.reflectionColor.asArray();
-            serializationObject.microSurface = this.microSurface;
-            serializationObject.emissiveColor = this.emissiveColor.asArray();
-            serializationObject.useAlphaFromAlbedoTexture = this.useAlphaFromAlbedoTexture;
-            serializationObject.useEmissiveAsIllumination = this.useEmissiveAsIllumination;
-            serializationObject.useMicroSurfaceFromReflectivityMapAlpha = this.useMicroSurfaceFromReflectivityMapAlpha;
-            serializationObject.useAutoMicroSurfaceFromReflectivityMap = this.useAutoMicroSurfaceFromReflectivityMap;
-            serializationObject.useScalarInLinear = this.useScalarInLinearSpace;
-            serializationObject.useSpecularOverAlpha = this.useSpecularOverAlpha;
-            serializationObject.indexOfRefraction = this.indexOfRefraction;
-            serializationObject.invertRefractionY = this.invertRefractionY;
-            serializationObject.usePhysicalLightFalloff = this.usePhysicalLightFalloff;
-            serializationObject.useRadianceOverAlpha = this.useRadianceOverAlpha;
-            serializationObject.emissiveFresnelParameters = this.emissiveFresnelParameters.serialize();
-            serializationObject.opacityFresnelParameters = this.opacityFresnelParameters.serialize();
             return serializationObject;
         };
+        // Statics
         PBRMaterial.Parse = function (source, scene, rootUrl) {
-            var material = new PBRMaterial(source.name, scene);
-            material.alpha = source.alpha;
-            material.id = source.id;
-            if (source.disableDepthWrite) {
-                material.disableDepthWrite = source.disableDepthWrite;
-            }
-            if (source.checkReadyOnlyOnce) {
-                material.checkReadyOnlyOnce = source.checkReadyOnlyOnce;
-            }
-            BABYLON.Tags.AddTagsTo(material, source.tags);
-            material.backFaceCulling = source.backFaceCulling;
-            material.wireframe = source.wireframe;
-            material.directIntensity = source.directIntensity;
-            material.emissiveIntensity = source.emissiveIntensity;
-            material.environmentIntensity = source.environmentIntensity;
-            material.specularIntensity = source.specularIntensity;
-            material.cameraExposure = source.cameraExposure;
-            material.cameraContrast = source.cameraContrast;
-            material.overloadedShadowIntensity = source.overloadedShadowIntensity;
-            material.overloadedShadeIntensity = source.overloadedShadeIntensity;
-            material.overloadedAmbientIntensity = source.overloadedAmbientIntensity;
-            material.overloadedAlbedoIntensity = source.overloadedAlbedoIntensity;
-            material.overloadedReflectivityIntensity = source.overloadedReflectivityIntensity;
-            material.overloadedEmissiveIntensity = source.overloadedEmissiveIntensity;
-            material.overloadedAmbient = BABYLON.Color3.FromArray(source.overloadedAmbient);
-            material.overloadedAlbedo = BABYLON.Color3.FromArray(source.overloadedAlbedo);
-            material.overloadedReflectivity = BABYLON.Color3.FromArray(source.overloadedReflectivity);
-            material.overloadedEmissive = BABYLON.Color3.FromArray(source.overloadedEmissive);
-            material.overloadedReflection = BABYLON.Color3.FromArray(source.overloadedReflection);
-            material.overloadedMicroSurface = source.overloadedMicroSurface;
-            material.overloadedMicroSurfaceIntensity = source.overloadedMicroSurfaceIntensity;
-            material.overloadedReflectionIntensity = source.overloadedReflectionIntensity;
-            material.disableBumpMap = source.disableBumpMap;
-            // Standard material
-            if (source.albedoTexture) {
-                material.albedoTexture = BABYLON.Texture.Parse(source.albedoTexture, scene, rootUrl);
-            }
-            if (source.ambientTexture) {
-                material.ambientTexture = BABYLON.Texture.Parse(source.ambientTexture, scene, rootUrl);
-            }
-            if (source.opacityTexture) {
-                material.opacityTexture = BABYLON.Texture.Parse(source.opacityTexture, scene, rootUrl);
-            }
-            if (source.reflectionTexture) {
-                material.reflectionTexture = BABYLON.Texture.Parse(source.reflectionTexture, scene, rootUrl);
-            }
-            if (source.emissiveTexture) {
-                material.emissiveTexture = BABYLON.Texture.Parse(source.emissiveTexture, scene, rootUrl);
-            }
-            if (source.reflectivityTexture) {
-                material.reflectivityTexture = BABYLON.Texture.Parse(source.reflectivityTexture, scene, rootUrl);
-            }
-            if (source.bumpTexture) {
-                material.bumpTexture = BABYLON.Texture.Parse(source.bumpTexture, scene, rootUrl);
-            }
-            if (source.lightmapTexture) {
-                material.lightmapTexture = BABYLON.Texture.Parse(source.lightmapTexture, scene, rootUrl);
-                material.useLightmapAsShadowmap = source.useLightmapAsShadowmap;
-            }
-            if (source.refractionTexture) {
-                material.refractionTexture = BABYLON.Texture.Parse(source.refractionTexture, scene, rootUrl);
-                material.linkRefractionWithTransparency = source.linkRefractionWithTransparency;
-            }
-            material.ambientColor = BABYLON.Color3.FromArray(source.ambient);
-            material.albedoColor = BABYLON.Color3.FromArray(source.albedo);
-            material.reflectivityColor = BABYLON.Color3.FromArray(source.reflectivity);
-            material.reflectionColor = BABYLON.Color3.FromArray(source.reflectionColor);
-            material.microSurface = source.microSurface;
-            material.emissiveColor = BABYLON.Color3.FromArray(source.emissive);
-            material.useAlphaFromAlbedoTexture = source.useAlphaFromAlbedoTexture;
-            material.useEmissiveAsIllumination = source.useEmissiveAsIllumination;
-            material.useMicroSurfaceFromReflectivityMapAlpha = source.useMicroSurfaceFromReflectivityMapAlpha;
-            material.useAutoMicroSurfaceFromReflectivityMap = source.useAutoMicroSurfaceFromReflectivityMap;
-            material.useScalarInLinearSpace = source.useScalarInLinear;
-            material.useSpecularOverAlpha = source.useSpecularOverAlpha;
-            material.indexOfRefraction = source.indexOfRefraction;
-            material.invertRefractionY = source.invertRefractionY;
-            material.usePhysicalLightFalloff = source.usePhysicalLightFalloff;
-            material.useRadianceOverAlpha = source.useRadianceOverAlpha;
-            material.emissiveFresnelParameters = BABYLON.FresnelParameters.Parse(source.emissiveFresnelParameters);
-            material.opacityFresnelParameters = BABYLON.FresnelParameters.Parse(source.opacityFresnelParameters);
-            return material;
+            return BABYLON.SerializationHelper.Parse(function () { return new PBRMaterial(source.name, scene); }, source, scene, rootUrl);
         };
         PBRMaterial._scaledAlbedo = new BABYLON.Color3();
         PBRMaterial._scaledReflectivity = new BABYLON.Color3();
         PBRMaterial._scaledEmissive = new BABYLON.Color3();
         PBRMaterial._scaledReflection = new BABYLON.Color3();
         PBRMaterial._lightRadiuses = [1, 1, 1, 1];
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "directIntensity");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "emissiveIntensity");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "environmentIntensity");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "specularIntensity");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "overloadedShadowIntensity");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "overloadedShadeIntensity");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "cameraExposure");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "cameraContrast");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "overloadedAmbientIntensity");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "overloadedAlbedoIntensity");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "overloadedReflectivityIntensity");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "overloadedEmissiveIntensity");
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], PBRMaterial.prototype, "overloadedAmbient");
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], PBRMaterial.prototype, "overloadedAlbedo");
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], PBRMaterial.prototype, "overloadedReflectivity");
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], PBRMaterial.prototype, "overloadedEmissive");
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], PBRMaterial.prototype, "overloadedReflection");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "overloadedMicroSurface");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "overloadedMicroSurfaceIntensity");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "overloadedReflectionIntensity");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "disableBumpMap");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], PBRMaterial.prototype, "albedoTexture");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], PBRMaterial.prototype, "ambientTexture");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], PBRMaterial.prototype, "opacityTexture");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], PBRMaterial.prototype, "reflectionTexture");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], PBRMaterial.prototype, "emissiveTexture");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], PBRMaterial.prototype, "reflectivityTexture");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], PBRMaterial.prototype, "bumpTexture");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], PBRMaterial.prototype, "lightmapTexture");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], PBRMaterial.prototype, "refractionTexture");
+        __decorate([
+            BABYLON.serializeAsColor3("ambient")
+        ], PBRMaterial.prototype, "ambientColor");
+        __decorate([
+            BABYLON.serializeAsColor3("albedo")
+        ], PBRMaterial.prototype, "albedoColor");
+        __decorate([
+            BABYLON.serializeAsColor3("reflectivity")
+        ], PBRMaterial.prototype, "reflectivityColor");
+        __decorate([
+            BABYLON.serializeAsColor3("reflection")
+        ], PBRMaterial.prototype, "reflectionColor");
+        __decorate([
+            BABYLON.serializeAsColor3("emissivie")
+        ], PBRMaterial.prototype, "emissiveColor");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "microSurface");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "indexOfRefraction");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "invertRefractionY");
+        __decorate([
+            BABYLON.serializeAsFresnelParameters()
+        ], PBRMaterial.prototype, "opacityFresnelParameters");
+        __decorate([
+            BABYLON.serializeAsFresnelParameters()
+        ], PBRMaterial.prototype, "emissiveFresnelParameters");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "linkRefractionWithTransparency");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "linkEmissiveWithAlbedo");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "useLightmapAsShadowmap");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "useEmissiveAsIllumination");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "useAlphaFromAlbedoTexture");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "useSpecularOverAlpha");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "useMicroSurfaceFromReflectivityMapAlpha");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "useAutoMicroSurfaceFromReflectivityMap");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "useScalarInLinearSpace");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "usePhysicalLightFalloff");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "useRadianceOverAlpha");
+        __decorate([
+            BABYLON.serialize()
+        ], PBRMaterial.prototype, "disableLighting");
+        Object.defineProperty(PBRMaterial.prototype, "useLogarithmicDepth",
+            __decorate([
+                BABYLON.serialize()
+            ], PBRMaterial.prototype, "useLogarithmicDepth", Object.getOwnPropertyDescriptor(PBRMaterial.prototype, "useLogarithmicDepth")));
         return PBRMaterial;
     })(BABYLON.Material);
     BABYLON.PBRMaterial = PBRMaterial;

materialsLibrary/dist/babylon.simpleMaterial.js

@@ -290,31 +290,13 @@ var BABYLON;
             return BABYLON.SerializationHelper.Clone(function () { return new SimpleMaterial(name, _this.getScene()); }, this);
         };
         SimpleMaterial.prototype.serialize = function () {
-            var serializationObject = _super.prototype.serialize.call(this);
+            var serializationObject = BABYLON.SerializationHelper.Serialize(this);
             serializationObject.customType = "BABYLON.SimpleMaterial";
-            serializationObject.diffuseColor = this.diffuseColor.asArray();
-            serializationObject.disableLighting = this.disableLighting;
-            if (this.diffuseTexture) {
-                serializationObject.diffuseTexture = this.diffuseTexture.serialize();
-            }
             return serializationObject;
         };
+        // Statics
         SimpleMaterial.Parse = function (source, scene, rootUrl) {
-            var material = new SimpleMaterial(source.name, scene);
-            material.diffuseColor = BABYLON.Color3.FromArray(source.diffuseColor);
-            material.disableLighting = source.disableLighting;
-            material.alpha = source.alpha;
-            material.id = source.id;
-            BABYLON.Tags.AddTagsTo(material, source.tags);
-            material.backFaceCulling = source.backFaceCulling;
-            material.wireframe = source.wireframe;
-            if (source.diffuseTexture) {
-                material.diffuseTexture = BABYLON.Texture.Parse(source.diffuseTexture, scene, rootUrl);
-            }
-            if (source.checkReadyOnlyOnce) {
-                material.checkReadyOnlyOnce = source.checkReadyOnlyOnce;
-            }
-            return material;
+            return BABYLON.SerializationHelper.Parse(function () { return new SimpleMaterial(source.name, scene); }, source, scene, rootUrl);
         };
         __decorate([
             BABYLON.serializeAsTexture()
@@ -322,6 +304,9 @@ var BABYLON;
         __decorate([
             BABYLON.serializeAsColor3("diffuseColor")
         ], SimpleMaterial.prototype, "diffuseColor");
+        __decorate([
+            BABYLON.serialize()
+        ], SimpleMaterial.prototype, "disableLighting");
         return SimpleMaterial;
     })(BABYLON.Material);
     BABYLON.SimpleMaterial = SimpleMaterial;

materialsLibrary/dist/babylon.skyMaterial.js

@@ -182,37 +182,13 @@ var BABYLON;
             return BABYLON.SerializationHelper.Clone(function () { return new SkyMaterial(name, _this.getScene()); }, this);
         };
         SkyMaterial.prototype.serialize = function () {
-            var serializationObject = _super.prototype.serialize.call(this);
+            var serializationObject = BABYLON.SerializationHelper.Serialize(this);
             serializationObject.customType = "BABYLON.SkyMaterial";
-            serializationObject.luminance = this.luminance;
-            serializationObject.turbidity = this.turbidity;
-            serializationObject.rayleigh = this.rayleigh;
-            serializationObject.mieCoefficient = this.mieCoefficient;
-            serializationObject.mieDirectionalG = this.mieDirectionalG;
-            serializationObject.distance = this.distance;
-            serializationObject.inclination = this.inclination;
-            serializationObject.azimuth = this.azimuth;
             return serializationObject;
         };
+        // Statics
         SkyMaterial.Parse = function (source, scene, rootUrl) {
-            var material = new SkyMaterial(source.name, scene);
-            material.alpha = source.alpha;
-            material.id = source.id;
-            BABYLON.Tags.AddTagsTo(material, source.tags);
-            material.backFaceCulling = source.backFaceCulling;
-            material.wireframe = source.wireframe;
-            if (source.checkReadyOnlyOnce) {
-                material.checkReadyOnlyOnce = source.checkReadyOnlyOnce;
-            }
-            material.luminance = source.luminance;
-            material.turbidity = source.turbidity;
-            material.rayleigh = source.rayleigh;
-            material.mieCoefficient = source.mieCoefficient;
-            material.mieDirectionalG = source.mieDirectionalG;
-            material.distance = source.distance;
-            material.inclination = source.inclination;
-            material.azimuth = source.azimuth;
-            return material;
+            return BABYLON.SerializationHelper.Parse(function () { return new SkyMaterial(source.name, scene); }, source, scene, rootUrl);
         };
         __decorate([
             BABYLON.serialize()
@@ -231,6 +207,9 @@ var BABYLON;
         ], SkyMaterial.prototype, "mieDirectionalG");
         __decorate([
             BABYLON.serialize()
+        ], SkyMaterial.prototype, "distance");
+        __decorate([
+            BABYLON.serialize()
         ], SkyMaterial.prototype, "inclination");
         __decorate([
             BABYLON.serialize()

materialsLibrary/dist/babylon.terrainMaterial.js

@@ -1,5 +1,13 @@
 /// <reference path="../../../dist/preview release/babylon.d.ts"/>
 
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc);
+    switch (arguments.length) {
+        case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);
+        case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
+        case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
+    }
+};
 var BABYLON;
 (function (BABYLON) {
     var maxSimultaneousLights = 4;
@@ -460,80 +468,51 @@ var BABYLON;
             _super.prototype.dispose.call(this, forceDisposeEffect);
         };
         TerrainMaterial.prototype.clone = function (name) {
-            var newMaterial = new TerrainMaterial(name, this.getScene());
-            // Base material
-            this.copyTo(newMaterial);
-            // Simple material
-            if (this.mixTexture && this.mixTexture.clone) {
-                newMaterial.mixTexture = this.mixTexture.clone();
-            }
-            newMaterial.diffuseColor = this.diffuseColor.clone();
-            return newMaterial;
+            var _this = this;
+            return BABYLON.SerializationHelper.Clone(function () { return new TerrainMaterial(name, _this.getScene()); }, this);
         };
         TerrainMaterial.prototype.serialize = function () {
-            var serializationObject = _super.prototype.serialize.call(this);
+            var serializationObject = BABYLON.SerializationHelper.Serialize(this);
             serializationObject.customType = "BABYLON.TerrainMaterial";
-            serializationObject.diffuseColor = this.diffuseColor.asArray();
-            serializationObject.specularColor = this.specularColor.asArray();
-            serializationObject.specularPower = this.specularPower;
-            serializationObject.disableLighting = this.disableLighting;
-            if (this.diffuseTexture1) {
-                serializationObject.diffuseTexture1 = this.diffuseTexture1.serialize();
-            }
-            if (this.diffuseTexture2) {
-                serializationObject.diffuseTexture2 = this.diffuseTexture2.serialize();
-            }
-            if (this.diffuseTexture3) {
-                serializationObject.diffuseTexture3 = this.diffuseTexture3.serialize();
-            }
-            if (this.bumpTexture1) {
-                serializationObject.bumpTexture1 = this.bumpTexture1.serialize();
-            }
-            if (this.bumpTexture2) {
-                serializationObject.bumpTexture2 = this.bumpTexture2.serialize();
-            }
-            if (this.bumpTexture3) {
-                serializationObject.bumpTexture3 = this.bumpTexture3.serialize();
-            }
-            if (this.mixTexture) {
-                serializationObject.mixTexture = this.mixTexture.serialize();
-            }
             return serializationObject;
         };
+        // Statics
         TerrainMaterial.Parse = function (source, scene, rootUrl) {
-            var material = new TerrainMaterial(source.name, scene);
-            material.diffuseColor = BABYLON.Color3.FromArray(source.diffuseColor);
-            material.specularColor = BABYLON.Color3.FromArray(source.specularColor);
-            material.specularPower = source.specularPower;
-            material.disableLighting = source.disableLighting;
-            material.alpha = source.alpha;
-            material.id = source.id;
-            BABYLON.Tags.AddTagsTo(material, source.tags);
-            material.backFaceCulling = source.backFaceCulling;
-            material.wireframe = source.wireframe;
-            if (source.diffuseTexture1) {
-                material.diffuseTexture1 = BABYLON.Texture.Parse(source.diffuseTexture1, scene, rootUrl);
-            }
-            if (source.diffuseTexture2) {
-                material.diffuseTexture2 = BABYLON.Texture.Parse(source.diffuseTexture2, scene, rootUrl);
-            }
-            if (source.diffuseTexture3) {
-                material.diffuseTexture3 = BABYLON.Texture.Parse(source.diffuseTexture3, scene, rootUrl);
-            }
-            if (source.bumpTexture1) {
-                material.bumpTexture1 = BABYLON.Texture.Parse(source.bumpTexture1, scene, rootUrl);
-            }
-            if (source.bumpTexture2) {
-                material.bumpTexture2 = BABYLON.Texture.Parse(source.bumpTexture2, scene, rootUrl);
-            }
-            if (source.bumpTexture3) {
-                material.bumpTexture3 = BABYLON.Texture.Parse(source.bumpTexture3, scene, rootUrl);
-            }
-            if (source.mixTexture) {
-                material.mixTexture = BABYLON.Texture.Parse(source.mixTexture, scene, rootUrl);
-            }
-            return material;
+            return BABYLON.SerializationHelper.Parse(function () { return new TerrainMaterial(source.name, scene); }, source, scene, rootUrl);
         };
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], TerrainMaterial.prototype, "mixTexture");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], TerrainMaterial.prototype, "diffuseTexture1");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], TerrainMaterial.prototype, "diffuseTexture2");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], TerrainMaterial.prototype, "diffuseTexture3");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], TerrainMaterial.prototype, "bumpTexture1");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], TerrainMaterial.prototype, "bumpTexture2");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], TerrainMaterial.prototype, "bumpTexture3");
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], TerrainMaterial.prototype, "diffuseColor");
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], TerrainMaterial.prototype, "specularColor");
+        __decorate([
+            BABYLON.serialize()
+        ], TerrainMaterial.prototype, "specularPower");
+        __decorate([
+            BABYLON.serialize()
+        ], TerrainMaterial.prototype, "disableLighting");
         return TerrainMaterial;
     })(BABYLON.Material);
     BABYLON.TerrainMaterial = TerrainMaterial;

materialsLibrary/dist/babylon.triPlanarMaterial.js

@@ -1,5 +1,13 @@
 /// <reference path="../../../dist/preview release/babylon.d.ts"/>
 
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc);
+    switch (arguments.length) {
+        case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);
+        case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
+        case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
+    }
+};
 var BABYLON;
 (function (BABYLON) {
     var maxSimultaneousLights = 4;
@@ -450,56 +458,54 @@ var BABYLON;
             _super.prototype.dispose.call(this, forceDisposeEffect);
         };
         TriPlanarMaterial.prototype.clone = function (name) {
-            var newMaterial = new TriPlanarMaterial(name, this.getScene());
-            // Base material
-            this.copyTo(newMaterial);
-            // Simple material
-            if (this.mixTexture && this.mixTexture.clone) {
-                newMaterial.mixTexture = this.mixTexture.clone();
-            }
-            newMaterial.diffuseColor = this.diffuseColor.clone();
-            return newMaterial;
+            var _this = this;
+            return BABYLON.SerializationHelper.Clone(function () { return new TriPlanarMaterial(name, _this.getScene()); }, this);
         };
         TriPlanarMaterial.prototype.serialize = function () {
-            var serializationObject = _super.prototype.serialize.call(this);
-            serializationObject.customType = "BABYLON.TerrainMaterial";
-            serializationObject.diffuseColor = this.diffuseColor.asArray();
-            serializationObject.specularColor = this.specularColor.asArray();
-            serializationObject.specularPower = this.specularPower;
-            serializationObject.disableLighting = this.disableLighting;
-            if (this.diffuseTextureX) {
-                serializationObject.diffuseTextureX = this.diffuseTextureX.serialize();
-            }
-            if (this.diffuseTextureY) {
-                serializationObject.diffuseTextureY = this.diffuseTextureY.serialize();
-            }
-            if (this.diffuseTextureZ) {
-                serializationObject.diffuseTextureZ = this.diffuseTextureZ.serialize();
-            }
+            var serializationObject = BABYLON.SerializationHelper.Serialize(this);
+            serializationObject.customType = "BABYLON.TriPlanarMaterial";
             return serializationObject;
         };
+        // Statics
         TriPlanarMaterial.Parse = function (source, scene, rootUrl) {
-            var material = new TriPlanarMaterial(source.name, scene);
-            material.diffuseColor = BABYLON.Color3.FromArray(source.diffuseColor);
-            material.specularColor = BABYLON.Color3.FromArray(source.specularColor);
-            material.specularPower = source.specularPower;
-            material.disableLighting = source.disableLighting;
-            material.alpha = source.alpha;
-            material.id = source.id;
-            BABYLON.Tags.AddTagsTo(material, source.tags);
-            material.backFaceCulling = source.backFaceCulling;
-            material.wireframe = source.wireframe;
-            if (source.diffuseTextureX) {
-                material.diffuseTextureX = BABYLON.Texture.Parse(source.diffuseTextureX, scene, rootUrl);
-            }
-            if (source.diffuseTextureY) {
-                material.diffuseTextureY = BABYLON.Texture.Parse(source.diffuseTextureY, scene, rootUrl);
-            }
-            if (source.diffuseTextureZ) {
-                material.diffuseTextureZ = BABYLON.Texture.Parse(source.diffuseTextureZ, scene, rootUrl);
-            }
-            return material;
+            return BABYLON.SerializationHelper.Parse(function () { return new TriPlanarMaterial(source.name, scene); }, source, scene, rootUrl);
         };
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], TriPlanarMaterial.prototype, "mixTexture");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], TriPlanarMaterial.prototype, "diffuseTextureX");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], TriPlanarMaterial.prototype, "diffuseTextureY");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], TriPlanarMaterial.prototype, "diffuseTextureZ");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], TriPlanarMaterial.prototype, "normalTextureX");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], TriPlanarMaterial.prototype, "normalTextureY");
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], TriPlanarMaterial.prototype, "normalTextureZ");
+        __decorate([
+            BABYLON.serialize()
+        ], TriPlanarMaterial.prototype, "tileSize");
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], TriPlanarMaterial.prototype, "diffuseColor");
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], TriPlanarMaterial.prototype, "specularColor");
+        __decorate([
+            BABYLON.serialize()
+        ], TriPlanarMaterial.prototype, "specularPower");
+        __decorate([
+            BABYLON.serialize()
+        ], TriPlanarMaterial.prototype, "disableLighting");
         return TriPlanarMaterial;
     })(BABYLON.Material);
     BABYLON.TriPlanarMaterial = TriPlanarMaterial;

materialsLibrary/dist/babylon.waterMaterial.js

@@ -1,6 +1,14 @@
 /// <reference path="../../../dist/preview release/babylon.d.ts"/>
 /// <reference path="../simple/babylon.simpleMaterial.ts"/>
 
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc);
+    switch (arguments.length) {
+        case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);
+        case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
+        case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
+    }
+};
 var BABYLON;
 (function (BABYLON) {
     var maxSimultaneousLights = 4;
@@ -600,68 +608,61 @@ var BABYLON;
             _super.prototype.dispose.call(this, forceDisposeEffect);
         };
         WaterMaterial.prototype.clone = function (name) {
-            var newMaterial = new WaterMaterial(name, this.getScene());
-            // Base material
-            this.copyTo(newMaterial);
-            // water material
-            if (this.bumpTexture && this.bumpTexture.clone) {
-                newMaterial.bumpTexture = this.bumpTexture.clone();
-            }
-            newMaterial.diffuseColor = this.diffuseColor.clone();
-            return newMaterial;
+            var _this = this;
+            return BABYLON.SerializationHelper.Clone(function () { return new WaterMaterial(name, _this.getScene()); }, this);
         };
         WaterMaterial.prototype.serialize = function () {
-            var serializationObject = _super.prototype.serialize.call(this);
+            var serializationObject = BABYLON.SerializationHelper.Serialize(this);
             serializationObject.customType = "BABYLON.WaterMaterial";
-            serializationObject.diffuseColor = this.diffuseColor.asArray();
-            serializationObject.specularColor = this.specularColor.asArray();
-            serializationObject.specularPower = this.specularPower;
-            serializationObject.disableLighting = this.disableLighting;
-            serializationObject.windForce = this.windForce;
-            serializationObject.windDirection = this.windDirection.asArray();
-            serializationObject.waveHeight = this.waveHeight;
-            serializationObject.bumpHeight = this.bumpHeight;
-            serializationObject.waterColor = this.waterColor.asArray();
-            serializationObject.colorBlendFactor = this.colorBlendFactor;
-            serializationObject.waveLength = this.waveLength;
-            serializationObject.renderTargetSize = this.renderTargetSize.asArray();
-            if (this.bumpTexture) {
-                serializationObject.bumpTexture = this.bumpTexture.serialize();
-            }
             return serializationObject;
         };
+        // Statics
         WaterMaterial.Parse = function (source, scene, rootUrl) {
-            var renderTargetSize = source.renderTargetSize ? BABYLON.Vector2.FromArray(source.renderTargetSize) : null;
-            var material = new WaterMaterial(source.name, scene, renderTargetSize);
-            material.diffuseColor = BABYLON.Color3.FromArray(source.diffuseColor);
-            material.specularColor = BABYLON.Color3.FromArray(source.specularColor);
-            material.specularPower = source.specularPower;
-            material.disableLighting = source.disableLighting;
-            material.windForce = source.windForce;
-            material.windDirection = BABYLON.Vector2.FromArray(source.windDirection);
-            material.waveHeight = source.waveHeight;
-            material.bumpHeight = source.bumpHeight;
-            material.waterColor = BABYLON.Color3.FromArray(source.waterColor);
-            material.colorBlendFactor = source.colorBlendFactor;
-            material.waveLength = source.waveLength;
-            material.renderTargetSize = BABYLON.Vector2.FromArray(source.renderTargetSize);
-            material.alpha = source.alpha;
-            material.id = source.id;
-            BABYLON.Tags.AddTagsTo(material, source.tags);
-            material.backFaceCulling = source.backFaceCulling;
-            material.wireframe = source.wireframe;
-            if (source.bumpTexture) {
-                material.bumpTexture = BABYLON.Texture.Parse(source.bumpTexture, scene, rootUrl);
-            }
-            if (source.checkReadyOnlyOnce) {
-                material.checkReadyOnlyOnce = source.checkReadyOnlyOnce;
-            }
-            return material;
+            return BABYLON.SerializationHelper.Parse(function () { return new WaterMaterial(source.name, scene); }, source, scene, rootUrl);
         };
         WaterMaterial.CreateDefaultMesh = function (name, scene) {
             var mesh = BABYLON.Mesh.CreateGround(name, 512, 512, 32, scene, false);
             return mesh;
         };
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], WaterMaterial.prototype, "bumpTexture");
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], WaterMaterial.prototype, "diffuseColor");
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], WaterMaterial.prototype, "specularColor");
+        __decorate([
+            BABYLON.serialize()
+        ], WaterMaterial.prototype, "specularPower");
+        __decorate([
+            BABYLON.serialize()
+        ], WaterMaterial.prototype, "disableLighting");
+        __decorate([
+            BABYLON.serialize()
+        ], WaterMaterial.prototype, "windForce");
+        __decorate([
+            BABYLON.serializeAsVector2()
+        ], WaterMaterial.prototype, "windDirection");
+        __decorate([
+            BABYLON.serialize()
+        ], WaterMaterial.prototype, "waveHeight");
+        __decorate([
+            BABYLON.serialize()
+        ], WaterMaterial.prototype, "bumpHeight");
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], WaterMaterial.prototype, "waterColor");
+        __decorate([
+            BABYLON.serialize()
+        ], WaterMaterial.prototype, "colorBlendFactor");
+        __decorate([
+            BABYLON.serialize()
+        ], WaterMaterial.prototype, "waveLength");
+        __decorate([
+            BABYLON.serialize()
+        ], WaterMaterial.prototype, "waveSpeed");
         return WaterMaterial;
     })(BABYLON.Material);
     BABYLON.WaterMaterial = WaterMaterial;

materialsLibrary/materials/fur/babylon.furMaterial.ts

@@ -61,22 +61,42 @@ module BABYLON {
     }
 
     export class FurMaterial extends Material {
+        
         public diffuseTexture: BaseTexture;
         public heightTexture: BaseTexture;
         public diffuseColor = new Color3(1, 1, 1);
         
+        @serialize()
         public furLength: number = 1;
+        
+        @serialize()
         public furAngle: number = 0;
+        
+        @serializeAsColor3()
         public furColor = new Color3(0.44,0.21,0.02);
         
+        @serialize()
         public furOffset: number = 0.0;
+        
+        @serialize()
         public furSpacing: number = 12;
+        
+        @serializeAsVector3()
         public furGravity = new Vector3(0, 0, 0);
+        
+        @serialize()
         public furSpeed: number = 100;
+        
+        @serialize()
         public furDensity: number = 20;
+        
+        @serializeAsTexture()
         public furTexture: DynamicTexture;
         
+        @serialize()
         public disableLighting = false;
+        
+        @serialize()
         public highLevelFur: boolean = true;
 
         private _worldViewProjectionMatrix = Matrix.Zero();
@@ -94,6 +114,7 @@ module BABYLON {
             this._cachedDefines.BonesPerMesh = -1;
         }
         
+        @serialize()
         public get furTime() {
             return this._furTime;
         }
@@ -561,87 +582,20 @@ module BABYLON {
 
             super.dispose(forceDisposeEffect);
         }
-
+        
         public clone(name: string): FurMaterial {
-            var newMaterial = new FurMaterial(name, this.getScene());
-
-            // Base material
-            this.copyTo(newMaterial);
-
-            // Fur material
-            if (this.diffuseTexture && this.diffuseTexture.clone) {
-                newMaterial.diffuseTexture = this.diffuseTexture.clone();
-            }
-            if (this.heightTexture && this.heightTexture.clone) {
-                newMaterial.heightTexture = this.heightTexture.clone();
-            }
-            if (this.diffuseColor && this.diffuseColor.clone) {
-                newMaterial.diffuseColor = this.diffuseColor.clone();
-            }
-            
-            return newMaterial;
+            return SerializationHelper.Clone(() => new FurMaterial(name, this.getScene()), this);
         }
-        
-        public serialize(): any {		
-            var serializationObject = super.serialize();
-            serializationObject.customType      = "BABYLON.FurMaterial";
-            serializationObject.diffuseColor    = this.diffuseColor.asArray();
-            serializationObject.disableLighting = this.disableLighting;
-            
-            serializationObject.furLength = this.furLength;
-            serializationObject.furAngle  = this.furAngle;
-            serializationObject.furColor  = this.furColor.asArray();
-            
-            serializationObject.furGravity = this.furGravity.asArray();
-            serializationObject.furSpacing = this.furSpacing;
-            serializationObject.furSpeed   = this.furSpeed;
-            serializationObject.furDensity = this.furDensity;
-            
-            if (this.diffuseTexture) {
-                serializationObject.diffuseTexture = this.diffuseTexture.serialize();
-            }
-            
-            if (this.heightTexture) {
-                serializationObject.heightTexture = this.heightTexture.serialize();
-            }
 
+        public serialize(): any {
+            var serializationObject = SerializationHelper.Serialize(this);
+            serializationObject.customType = "BABYLON.FurMaterial";
             return serializationObject;
         }
 
+        // Statics
         public static Parse(source: any, scene: Scene, rootUrl: string): FurMaterial {
-            var material = new FurMaterial(source.name, scene);
-            
-            material.diffuseColor       = Color3.FromArray(source.diffuseColor);
-            material.furLength          = source.furLength;
-            material.furAngle           = source.furAngle;
-            material.furColor           = Color3.FromArray(source.furColor);
-            material.furGravity         = Vector3.FromArray(source.furGravity);
-            material.furSpacing         = source.furSpacing;
-            material.furSpeed           = source.furSpeed;
-            material.furDensity         = source.furDensity;
-            material.disableLighting    = source.disableLighting;
-
-            material.alpha              = source.alpha;
-
-            material.id                 = source.id;
-
-            Tags.AddTagsTo(material, source.tags);
-            material.backFaceCulling = source.backFaceCulling;
-            material.wireframe = source.wireframe;
-
-            if (source.diffuseTexture) {
-                material.diffuseTexture = Texture.Parse(source.diffuseTexture, scene, rootUrl);
-            }
-            
-            if (source.heightTexture) {
-                material.heightTexture = Texture.Parse(source.heightTexture, scene, rootUrl);
-            }
-
-            if (source.checkReadyOnlyOnce) {
-                material.checkReadyOnlyOnce = source.checkReadyOnlyOnce;
-            }
-
-            return material;
+            return SerializationHelper.Parse(() => new FurMaterial(source.name, scene), source, scene, rootUrl);
         }
         
         public static GenerateTexture(name: string, scene: Scene): DynamicTexture {

materialsLibrary/materials/gradient/babylon.gradientMaterial.ts

@@ -60,17 +60,27 @@ module BABYLON {
     export class GradientMaterial extends Material {
 
         // The gradient top color, red by default
+        @serializeAsColor3()
         public topColor = new Color3(1, 0, 0);
+        
+        @serialize()
         public topColorAlpha = 1.0;
 
         // The gradient top color, blue by default
+        @serializeAsColor3()
         public bottomColor = new Color3(0, 0, 1);
+        
+        @serialize()
         public bottomColorAlpha = 1.0;
 
         // Gradient offset
+        @serialize()
         public offset = 0;
+        
+        @serialize()
         public smoothness = 1.0;
 
+        @serialize()
         public disableLighting = false;
 
         private _worldViewProjectionMatrix = Matrix.Zero();
@@ -335,50 +345,18 @@ module BABYLON {
         }
 
         public clone(name: string): GradientMaterial {
-            var newMaterial = new GradientMaterial(name, this.getScene());
-
-            // Base material
-            this.copyTo(newMaterial);
-
-            // Gradient material
-            newMaterial.topColor = this.topColor.clone();
-            newMaterial.bottomColor = this.bottomColor.clone();
-            newMaterial.offset = this.offset;
-            return newMaterial;
+            return SerializationHelper.Clone(() => new GradientMaterial(name, this.getScene()), this);
         }
-        
-        public serialize(): any {		
-            var serializationObject = super.serialize();
-            serializationObject.customType      = "BABYLON.GradientMaterial";
-            serializationObject.topColor        = this.topColor.asArray();
-            serializationObject.bottomColor     = this.bottomColor.asArray();
-            serializationObject.offset          = this.offset;
-            serializationObject.disableLighting = this.disableLighting;
 
+        public serialize(): any {
+            var serializationObject = SerializationHelper.Serialize(this);
+            serializationObject.customType = "BABYLON.GradientMaterial";
             return serializationObject;
         }
 
+        // Statics
         public static Parse(source: any, scene: Scene, rootUrl: string): GradientMaterial {
-            var material = new GradientMaterial(source.name, scene);
-
-            material.topColor               = Color3.FromArray(source.topColor);
-            material.bottomColor            = Color3.FromArray(source.bottomColor);
-            material.offset                 = source.offset;
-            material.disableLighting        = source.disableLighting;
-
-            material.alpha          = source.alpha;
-
-            material.id             = source.id;
-
-            Tags.AddTagsTo(material, source.tags);
-            material.backFaceCulling = source.backFaceCulling;
-            material.wireframe = source.wireframe;
-
-            if (source.checkReadyOnlyOnce) {
-                material.checkReadyOnlyOnce = source.checkReadyOnlyOnce;
-            }
-
-            return material;
+            return SerializationHelper.Parse(() => new GradientMaterial(source.name, scene), source, scene, rootUrl);
         }
     }
 } 

materialsLibrary/materials/lava/babylon.lavaMaterial.ts

@@ -58,17 +58,33 @@ module BABYLON {
     }
 
     export class LavaMaterial extends Material {
+        @serializeAsTexture()
         public diffuseTexture: BaseTexture;
+        
+        @serializeAsTexture()
         public noiseTexture: BaseTexture;
+        
+        @serializeAsColor3()
         public fogColor: Color3;
+        
+        @serialize()
         public speed : number = 1;
+        
+        @serialize()
         public movingSpeed : number = 1;
+        
+        @serialize()
         public lowFrequencySpeed : number = 1;
+        
+        @serialize()
         public fogDensity : number = 0.15;
 
         private _lastTime : number = 0;
 
+        @serializeAsColor3()
         public diffuseColor = new Color3(1, 1, 1);
+        
+        @serialize()
         public disableLighting = false;
 
         private _worldViewProjectionMatrix = Matrix.Zero();
@@ -378,78 +394,18 @@ module BABYLON {
         }
 
         public clone(name: string): LavaMaterial {
-            var newMaterial = new LavaMaterial(name, this.getScene());
-
-            // Base material
-            this.copyTo(newMaterial);
-
-            // Lava material
-            if (this.diffuseTexture && this.diffuseTexture.clone) {
-                newMaterial.diffuseTexture = this.diffuseTexture.clone();
-            }
-            if (this.noiseTexture && this.noiseTexture.clone) {
-                newMaterial.noiseTexture = this.noiseTexture.clone();
-            }
-            if (this.fogColor && this.fogColor.clone) {
-                newMaterial.fogColor = this.fogColor.clone();
-            }
-
-            return newMaterial;
+            return SerializationHelper.Clone(() => new LavaMaterial(name, this.getScene()), this);
         }
 
-
         public serialize(): any {
-            var serializationObject = super.serialize();
-            serializationObject.customType      = "BABYLON.LavaMaterial";
-            serializationObject.diffuseColor    = this.diffuseColor.asArray();
-            serializationObject.fogColor        = this.fogColor.asArray();
-            serializationObject.speed           = this.speed;
-            serializationObject.movingSpeed     = this.movingSpeed;
-            serializationObject.lowFrequencySpeed = this.lowFrequencySpeed;
-            serializationObject.fogDensity      = this.fogDensity;
-            serializationObject.checkReadyOnlyOnce = this.checkReadyOnlyOnce;
-
-            if (this.diffuseTexture) {
-                serializationObject.diffuseTexture = this.diffuseTexture.serialize();
-            }
-            if (this.noiseTexture) {
-                serializationObject.noiseTexture = this.noiseTexture.serialize();
-            }
-
+            var serializationObject = SerializationHelper.Serialize(this);
+            serializationObject.customType = "BABYLON.LavaMaterial";
             return serializationObject;
         }
 
+        // Statics
         public static Parse(source: any, scene: Scene, rootUrl: string): LavaMaterial {
-            var material = new LavaMaterial(source.name, scene);
-
-            material.diffuseColor   = Color3.FromArray(source.diffuseColor);
-            material.speed          = source.speed;
-            material.fogColor       = Color3.FromArray(source.fogColor);
-            material.movingSpeed    = source.movingSpeed;
-            material.lowFrequencySpeed = source.lowFrequencySpeed;
-            material.fogDensity     =  source.lowFrequencySpeed;
-
-            material.alpha          = source.alpha;
-
-            material.id             = source.id;
-
-            Tags.AddTagsTo(material, source.tags);
-            material.backFaceCulling = source.backFaceCulling;
-            material.wireframe = source.wireframe;
-
-            if (source.diffuseTexture) {
-                material.diffuseTexture = Texture.Parse(source.diffuseTexture, scene, rootUrl);
-            }
-
-            if (source.noiseTexture) {
-                material.noiseTexture = Texture.Parse(source.noiseTexture, scene, rootUrl);
-            }
-
-            if (source.checkReadyOnlyOnce) {
-                material.checkReadyOnlyOnce = source.checkReadyOnlyOnce;
-            }
-
-            return material;
+            return SerializationHelper.Parse(() => new LavaMaterial(source.name, scene), source, scene, rootUrl);
         }
     }
 } 

materialsLibrary/materials/normal/babylon.normalMaterial.ts

@@ -56,9 +56,13 @@ module BABYLON {
     }
 
     export class NormalMaterial extends Material {
+        @serializeAsTexture()
         public diffuseTexture: BaseTexture;
 
+        @serializeAsColor3()
         public diffuseColor = new Color3(1, 1, 1);
+        
+        @serialize()
         public disableLighting = false;
 
         private _worldViewProjectionMatrix = Matrix.Zero();
@@ -341,56 +345,18 @@ module BABYLON {
         }
 
         public clone(name: string): NormalMaterial {
-            var newMaterial = new NormalMaterial(name, this.getScene());
-
-            // Base material
-            this.copyTo(newMaterial);
-
-            // Normal material
-            if (this.diffuseTexture && this.diffuseTexture.clone) {
-                newMaterial.diffuseTexture = this.diffuseTexture.clone();
-            }
-
-            newMaterial.diffuseColor = this.diffuseColor.clone();
-            return newMaterial;
+            return SerializationHelper.Clone(() => new NormalMaterial(name, this.getScene()), this);
         }
-        
-        public serialize(): any {		
-            var serializationObject = super.serialize();
-            serializationObject.customType      = "BABYLON.NormalMaterial";
-            serializationObject.diffuseColor    = this.diffuseColor.asArray();
-            serializationObject.disableLighting = this.disableLighting;
-            
-            if (this.diffuseTexture) {
-                serializationObject.diffuseTexture = this.diffuseTexture.serialize();
-            }
 
+        public serialize(): any {
+            var serializationObject = SerializationHelper.Serialize(this);
+            serializationObject.customType = "BABYLON.NormalMaterial";
             return serializationObject;
         }
 
+        // Statics
         public static Parse(source: any, scene: Scene, rootUrl: string): NormalMaterial {
-            var material = new NormalMaterial(source.name, scene);
-
-            material.diffuseColor       = Color3.FromArray(source.diffuseColor);
-            material.disableLighting    = source.disableLighting;
-
-            material.alpha          = source.alpha;
-
-            material.id             = source.id;
-
-            Tags.AddTagsTo(material, source.tags);
-            material.backFaceCulling = source.backFaceCulling;
-            material.wireframe = source.wireframe;
-
-            if (source.diffuseTexture) {
-                material.diffuseTexture = Texture.Parse(source.diffuseTexture, scene, rootUrl);
-            }
-
-            if (source.checkReadyOnlyOnce) {
-                material.checkReadyOnlyOnce = source.checkReadyOnlyOnce;
-            }
-
-            return material;
+            return SerializationHelper.Parse(() => new NormalMaterial(source.name, scene), source, scene, rootUrl);
         }
     }
 } 

materialsLibrary/materials/pbr/babylon.pbrMaterial.ts

@@ -100,79 +100,174 @@ module BABYLON {
 
     export class PBRMaterial extends BABYLON.Material {
 
+        @serialize()
         public directIntensity: number = 1.0;
+        
+        @serialize()
         public emissiveIntensity: number = 1.0;
+        
+        @serialize()
         public environmentIntensity: number = 1.0;
+        
+        @serialize()
         public specularIntensity: number = 1.0;
 
         private _lightingInfos: Vector4 = new Vector4(this.directIntensity, this.emissiveIntensity, this.environmentIntensity, this.specularIntensity);
 
+        @serialize()
         public overloadedShadowIntensity: number = 1.0;
+        
+        @serialize()
         public overloadedShadeIntensity: number = 1.0;
+        
         private _overloadedShadowInfos: Vector4 = new Vector4(this.overloadedShadowIntensity, this.overloadedShadeIntensity, 0.0, 0.0);
 
+        @serialize()
         public cameraExposure: number = 1.0;
+        
+        @serialize()
         public cameraContrast: number = 1.0;
+        
         private _cameraInfos: Vector4 = new Vector4(1.0, 1.0, 0.0, 0.0);
 
         private _microsurfaceTextureLods: Vector2 = new Vector2(0.0, 0.0);
 
+        @serialize()
         public overloadedAmbientIntensity: number = 0.0;
+        
+        @serialize()
         public overloadedAlbedoIntensity: number = 0.0;
+        
+        @serialize()
         public overloadedReflectivityIntensity: number = 0.0;
+        
+        @serialize()
         public overloadedEmissiveIntensity: number = 0.0;
+        
         private _overloadedIntensity: Vector4 = new Vector4(this.overloadedAmbientIntensity, this.overloadedAlbedoIntensity, this.overloadedReflectivityIntensity, this.overloadedEmissiveIntensity);
 
+        @serializeAsColor3()
         public overloadedAmbient: Color3 = BABYLON.Color3.White();
+        
+        @serializeAsColor3()
         public overloadedAlbedo: Color3 = BABYLON.Color3.White();
+        
+        @serializeAsColor3()
         public overloadedReflectivity: Color3 = BABYLON.Color3.White();
+        
+        @serializeAsColor3()
         public overloadedEmissive: Color3 = BABYLON.Color3.White();
+        
+        @serializeAsColor3()
         public overloadedReflection: Color3 = BABYLON.Color3.White();
 
+        @serialize()
         public overloadedMicroSurface: number = 0.0;
+        
+        @serialize()
         public overloadedMicroSurfaceIntensity: number = 0.0;
+        
+        @serialize()
         public overloadedReflectionIntensity: number = 0.0;
+        
         private _overloadedMicroSurface: Vector3 = new Vector3(this.overloadedMicroSurface, this.overloadedMicroSurfaceIntensity, this.overloadedReflectionIntensity);
 
+        @serialize()
         public disableBumpMap: boolean = false;
 
+        @serializeAsTexture()
         public albedoTexture: BaseTexture;
+        
+        @serializeAsTexture()
         public ambientTexture: BaseTexture;
+        
+        @serializeAsTexture()
         public opacityTexture: BaseTexture;
+        
+        @serializeAsTexture()
         public reflectionTexture: BaseTexture;
+        
+        @serializeAsTexture()
         public emissiveTexture: BaseTexture;
+        
+        @serializeAsTexture()
         public reflectivityTexture: BaseTexture;
+        
+        @serializeAsTexture()
         public bumpTexture: BaseTexture;
+        
+        @serializeAsTexture()
         public lightmapTexture: BaseTexture;
+        
+        @serializeAsTexture()
         public refractionTexture: BaseTexture;
 
+        @serializeAsColor3("ambient")
         public ambientColor = new Color3(0, 0, 0);
+        
+        @serializeAsColor3("albedo")
         public albedoColor = new Color3(1, 1, 1);
+        
+        @serializeAsColor3("reflectivity")
         public reflectivityColor = new Color3(1, 1, 1);
+        
+        @serializeAsColor3("reflection")
         public reflectionColor = new Color3(0.5, 0.5, 0.5);
+        
+        @serializeAsColor3("emissivie")
         public emissiveColor = new Color3(0, 0, 0);
+        
+        @serialize()
         public microSurface = 0.5;
+        
+        @serialize()
         public indexOfRefraction = 0.66;
+        
+        @serialize()
         public invertRefractionY = false;
-
+        
+        @serializeAsFresnelParameters()
         public opacityFresnelParameters: FresnelParameters;
+        
+        @serializeAsFresnelParameters()
         public emissiveFresnelParameters: FresnelParameters;
 
+        @serialize()
         public linkRefractionWithTransparency = false;
+        
+        @serialize()
         public linkEmissiveWithAlbedo = false;
         
+        @serialize()
         public useLightmapAsShadowmap = false;
+        
+        @serialize()
         public useEmissiveAsIllumination = false;
+        
+        @serialize()
         public useAlphaFromAlbedoTexture = false;
+        
+        @serialize()
         public useSpecularOverAlpha = true;
+        
+        @serialize()
         public useMicroSurfaceFromReflectivityMapAlpha = false;
+        
+        @serialize()
         public useAutoMicroSurfaceFromReflectivityMap = false;
+        
+        @serialize()
         public useScalarInLinearSpace = false;
+        
+        @serialize()
         public usePhysicalLightFalloff = true;
+        
+        @serialize()
         public useRadianceOverAlpha = true;
         
+        @serialize()
         public disableLighting = false;
-
+        
         private _renderTargets = new SmartArray<RenderTargetTexture>(16);
         private _worldViewProjectionMatrix = Matrix.Zero();
         private _globalAmbientColor = new Color3(0, 0, 0);
@@ -204,6 +299,7 @@ module BABYLON {
             }
         }
 
+        @serialize()
         public get useLogarithmicDepth(): boolean {
             return this._useLogarithmicDepth;
         }
@@ -1064,277 +1160,20 @@ module BABYLON {
 
             super.dispose(forceDisposeEffect);
         }
-
+        
         public clone(name: string): PBRMaterial {
-            var newPBRMaterial = new PBRMaterial(name, this.getScene());
-
-            // Base material
-            this.copyTo(newPBRMaterial);
-
-            newPBRMaterial.directIntensity = this.directIntensity;
-            newPBRMaterial.emissiveIntensity = this.emissiveIntensity;
-            newPBRMaterial.environmentIntensity = this.environmentIntensity;
-            newPBRMaterial.specularIntensity = this.specularIntensity;
-
-            newPBRMaterial.cameraExposure = this.cameraExposure;
-            newPBRMaterial.cameraContrast = this.cameraContrast;
-
-            newPBRMaterial.overloadedShadowIntensity = this.overloadedShadowIntensity;
-            newPBRMaterial.overloadedShadeIntensity = this.overloadedShadeIntensity;
-
-            newPBRMaterial.overloadedAmbientIntensity = this.overloadedAmbientIntensity;
-            newPBRMaterial.overloadedAlbedoIntensity = this.overloadedAlbedoIntensity;
-            newPBRMaterial.overloadedReflectivityIntensity = this.overloadedReflectivityIntensity;
-            newPBRMaterial.overloadedEmissiveIntensity = this.overloadedEmissiveIntensity;
-            newPBRMaterial.overloadedAmbient = this.overloadedAmbient;
-            newPBRMaterial.overloadedAlbedo = this.overloadedAlbedo;
-            newPBRMaterial.overloadedReflectivity = this.overloadedReflectivity;
-            newPBRMaterial.overloadedEmissive = this.overloadedEmissive;
-            newPBRMaterial.overloadedReflection = this.overloadedReflection;
-
-            newPBRMaterial.overloadedMicroSurface = this.overloadedMicroSurface;
-            newPBRMaterial.overloadedMicroSurfaceIntensity = this.overloadedMicroSurfaceIntensity;
-            newPBRMaterial.overloadedReflectionIntensity = this.overloadedReflectionIntensity;
-
-            newPBRMaterial.disableBumpMap = this.disableBumpMap;
-
-            // Standard material
-            if (this.albedoTexture && this.albedoTexture.clone) {
-                newPBRMaterial.albedoTexture = this.albedoTexture.clone();
-            }
-            if (this.ambientTexture && this.ambientTexture.clone) {
-                newPBRMaterial.ambientTexture = this.ambientTexture.clone();
-            }
-            if (this.opacityTexture && this.opacityTexture.clone) {
-                newPBRMaterial.opacityTexture = this.opacityTexture.clone();
-            }
-            if (this.reflectionTexture && this.reflectionTexture.clone) {
-                newPBRMaterial.reflectionTexture = this.reflectionTexture.clone();
-            }
-            if (this.emissiveTexture && this.emissiveTexture.clone) {
-                newPBRMaterial.emissiveTexture = this.emissiveTexture.clone();
-            }
-            if (this.reflectivityTexture && this.reflectivityTexture.clone) {
-                newPBRMaterial.reflectivityTexture = this.reflectivityTexture.clone();
-            }
-            if (this.bumpTexture && this.bumpTexture.clone) {
-                newPBRMaterial.bumpTexture = this.bumpTexture.clone();
-            }
-            if (this.lightmapTexture && this.lightmapTexture.clone) {
-                newPBRMaterial.lightmapTexture = this.lightmapTexture.clone();
-                newPBRMaterial.useLightmapAsShadowmap = this.useLightmapAsShadowmap;
-            }
-            if (this.refractionTexture && this.refractionTexture.clone) {
-                newPBRMaterial.refractionTexture = this.refractionTexture.clone();
-                newPBRMaterial.linkRefractionWithTransparency = this.linkRefractionWithTransparency;
-            }
-
-            newPBRMaterial.ambientColor = this.ambientColor.clone();
-            newPBRMaterial.albedoColor = this.albedoColor.clone();
-            newPBRMaterial.reflectivityColor = this.reflectivityColor.clone();
-            newPBRMaterial.reflectionColor = this.reflectionColor.clone();
-            newPBRMaterial.microSurface = this.microSurface;
-            newPBRMaterial.emissiveColor = this.emissiveColor.clone();
-            newPBRMaterial.useAlphaFromAlbedoTexture = this.useAlphaFromAlbedoTexture;
-            newPBRMaterial.useEmissiveAsIllumination = this.useEmissiveAsIllumination;
-            newPBRMaterial.useMicroSurfaceFromReflectivityMapAlpha = this.useMicroSurfaceFromReflectivityMapAlpha;
-            newPBRMaterial.useAutoMicroSurfaceFromReflectivityMap = this.useAutoMicroSurfaceFromReflectivityMap;
-            newPBRMaterial.useScalarInLinearSpace = this.useScalarInLinearSpace;
-            newPBRMaterial.useSpecularOverAlpha = this.useSpecularOverAlpha;
-            newPBRMaterial.indexOfRefraction = this.indexOfRefraction;
-            newPBRMaterial.invertRefractionY = this.invertRefractionY;
-            newPBRMaterial.usePhysicalLightFalloff = this.usePhysicalLightFalloff;
-            newPBRMaterial.useRadianceOverAlpha = this.useRadianceOverAlpha;
-
-            newPBRMaterial.emissiveFresnelParameters = this.emissiveFresnelParameters.clone();
-            newPBRMaterial.opacityFresnelParameters = this.opacityFresnelParameters.clone();
-
-            return newPBRMaterial;
+            return SerializationHelper.Clone(() => new PBRMaterial(name, this.getScene()), this);
         }
 
         public serialize(): any {
-            var serializationObject = super.serialize();
-
-            serializationObject.customType = "BABYLON.PBRMaterial";
-
-            serializationObject.directIntensity = this.directIntensity;
-            serializationObject.emissiveIntensity = this.emissiveIntensity;
-            serializationObject.environmentIntensity = this.environmentIntensity;
-            serializationObject.specularIntensity = this.specularIntensity;
-
-            serializationObject.cameraExposure = this.cameraExposure;
-            serializationObject.cameraContrast = this.cameraContrast;
-
-            serializationObject.overloadedShadowIntensity = this.overloadedShadowIntensity;
-            serializationObject.overloadedShadeIntensity = this.overloadedShadeIntensity;
-
-            serializationObject.overloadedAmbientIntensity = this.overloadedAmbientIntensity;
-            serializationObject.overloadedAlbedoIntensity = this.overloadedAlbedoIntensity;
-            serializationObject.overloadedReflectivityIntensity = this.overloadedReflectivityIntensity;
-            serializationObject.overloadedEmissiveIntensity = this.overloadedEmissiveIntensity;
-            serializationObject.overloadedAmbient = this.overloadedAmbient.asArray();
-            serializationObject.overloadedAlbedo = this.overloadedAlbedo.asArray();
-            serializationObject.overloadedReflectivity = this.overloadedReflectivity.asArray();
-            serializationObject.overloadedEmissive = this.overloadedEmissive.asArray();
-            serializationObject.overloadedReflection = this.overloadedReflection.asArray();
-
-            serializationObject.overloadedMicroSurface = this.overloadedMicroSurface;
-            serializationObject.overloadedMicroSurfaceIntensity = this.overloadedMicroSurfaceIntensity;
-            serializationObject.overloadedReflectionIntensity = this.overloadedReflectionIntensity;
-
-            serializationObject.disableBumpMap = this.disableBumpMap;
-
-            // Standard material
-            if (this.albedoTexture) {
-                serializationObject.albedoTexture = this.albedoTexture.serialize();
-            }
-            if (this.ambientTexture) {
-                serializationObject.ambientTexture = this.ambientTexture.serialize();
-            }
-            if (this.opacityTexture) {
-                serializationObject.opacityTexture = this.opacityTexture.serialize();
-            }
-            if (this.reflectionTexture) {
-                serializationObject.reflectionTexture = this.reflectionTexture.serialize();
-            }
-            if (this.emissiveTexture) {
-                serializationObject.emissiveTexture = this.emissiveTexture.serialize();
-            }
-            if (this.reflectivityTexture) {
-                serializationObject.reflectivityTexture = this.reflectivityTexture.serialize();
-            }
-            if (this.bumpTexture) {
-                serializationObject.bumpTexture = this.bumpTexture.serialize();
-            }
-            if (this.lightmapTexture) {
-                serializationObject.lightmapTexture = this.lightmapTexture.serialize();
-                serializationObject.useLightmapAsShadowmap = this.useLightmapAsShadowmap;
-            }
-            if (this.refractionTexture) {
-                serializationObject.refractionTexture = this.refractionTexture;
-                serializationObject.linkRefractionWithTransparency = this.linkRefractionWithTransparency;
-            }
-
-            serializationObject.ambientColor = this.ambientColor.asArray();
-            serializationObject.albedoColor = this.albedoColor.asArray();
-            serializationObject.reflectivityColor = this.reflectivityColor.asArray();
-            serializationObject.reflectionColor = this.reflectionColor.asArray();
-            serializationObject.microSurface = this.microSurface;
-            serializationObject.emissiveColor = this.emissiveColor.asArray();
-            serializationObject.useAlphaFromAlbedoTexture = this.useAlphaFromAlbedoTexture;
-            serializationObject.useEmissiveAsIllumination = this.useEmissiveAsIllumination;
-            serializationObject.useMicroSurfaceFromReflectivityMapAlpha = this.useMicroSurfaceFromReflectivityMapAlpha;
-            serializationObject.useAutoMicroSurfaceFromReflectivityMap = this.useAutoMicroSurfaceFromReflectivityMap;
-            serializationObject.useScalarInLinear = this.useScalarInLinearSpace;
-            serializationObject.useSpecularOverAlpha = this.useSpecularOverAlpha;
-            serializationObject.indexOfRefraction = this.indexOfRefraction;
-            serializationObject.invertRefractionY = this.invertRefractionY;
-            serializationObject.usePhysicalLightFalloff = this.usePhysicalLightFalloff;
-            serializationObject.useRadianceOverAlpha = this.useRadianceOverAlpha;
-
-            serializationObject.emissiveFresnelParameters = this.emissiveFresnelParameters.serialize();
-            serializationObject.opacityFresnelParameters = this.opacityFresnelParameters.serialize();
-
+            var serializationObject = SerializationHelper.Serialize(this);
+            serializationObject.customType      = "BABYLON.PBRMaterial";
             return serializationObject;
         }
 
+        // Statics
         public static Parse(source: any, scene: Scene, rootUrl: string): PBRMaterial {
-            var material = new PBRMaterial(source.name, scene);
-
-            material.alpha = source.alpha;
-            material.id = source.id;
-
-            if (source.disableDepthWrite) {
-                material.disableDepthWrite = source.disableDepthWrite;
-            }
-
-            if (source.checkReadyOnlyOnce) {
-                material.checkReadyOnlyOnce = source.checkReadyOnlyOnce;
-            }
-
-            Tags.AddTagsTo(material, source.tags);
-            material.backFaceCulling = source.backFaceCulling;
-            material.wireframe = source.wireframe;
-
-            material.directIntensity = source.directIntensity;
-            material.emissiveIntensity = source.emissiveIntensity;
-            material.environmentIntensity = source.environmentIntensity;
-            material.specularIntensity = source.specularIntensity;
-
-            material.cameraExposure = source.cameraExposure;
-            material.cameraContrast = source.cameraContrast;
-
-            material.overloadedShadowIntensity = source.overloadedShadowIntensity;
-            material.overloadedShadeIntensity = source.overloadedShadeIntensity;
-
-            material.overloadedAmbientIntensity = source.overloadedAmbientIntensity;
-            material.overloadedAlbedoIntensity = source.overloadedAlbedoIntensity;
-            material.overloadedReflectivityIntensity = source.overloadedReflectivityIntensity;
-            material.overloadedEmissiveIntensity = source.overloadedEmissiveIntensity;
-            material.overloadedAmbient = Color3.FromArray(source.overloadedAmbient);
-            material.overloadedAlbedo = Color3.FromArray(source.overloadedAlbedo);
-            material.overloadedReflectivity = Color3.FromArray(source.overloadedReflectivity);
-            material.overloadedEmissive = Color3.FromArray(source.overloadedEmissive);
-            material.overloadedReflection = Color3.FromArray(source.overloadedReflection);
-
-            material.overloadedMicroSurface = source.overloadedMicroSurface;
-            material.overloadedMicroSurfaceIntensity = source.overloadedMicroSurfaceIntensity;
-            material.overloadedReflectionIntensity = source.overloadedReflectionIntensity;
-
-            material.disableBumpMap = source.disableBumpMap;
-
-            // Standard material
-            if (source.albedoTexture) {
-                material.albedoTexture = Texture.Parse(source.albedoTexture, scene, rootUrl);
-            }
-            if (source.ambientTexture) {
-                material.ambientTexture = Texture.Parse(source.ambientTexture, scene, rootUrl);
-            }
-            if (source.opacityTexture) {
-                material.opacityTexture = Texture.Parse(source.opacityTexture, scene, rootUrl);
-            }
-            if (source.reflectionTexture) {
-                material.reflectionTexture = Texture.Parse(source.reflectionTexture, scene, rootUrl);
-            }
-            if (source.emissiveTexture) {
-                material.emissiveTexture = Texture.Parse(source.emissiveTexture, scene, rootUrl);
-            }
-            if (source.reflectivityTexture) {
-                material.reflectivityTexture = Texture.Parse(source.reflectivityTexture, scene, rootUrl);
-            }
-            if (source.bumpTexture) {
-                material.bumpTexture = Texture.Parse(source.bumpTexture, scene, rootUrl);
-            }
-            if (source.lightmapTexture) {
-                material.lightmapTexture = Texture.Parse(source.lightmapTexture, scene, rootUrl);
-                material.useLightmapAsShadowmap = source.useLightmapAsShadowmap;
-            }
-            if (source.refractionTexture) {
-                material.refractionTexture = Texture.Parse(source.refractionTexture, scene, rootUrl);
-                material.linkRefractionWithTransparency = source.linkRefractionWithTransparency;
-            }
-
-            material.ambientColor = Color3.FromArray(source.ambient);
-            material.albedoColor = Color3.FromArray(source.albedo);
-            material.reflectivityColor = Color3.FromArray(source.reflectivity);
-            material.reflectionColor = Color3.FromArray(source.reflectionColor);
-            material.microSurface = source.microSurface;
-            material.emissiveColor = Color3.FromArray(source.emissive);
-            material.useAlphaFromAlbedoTexture = source.useAlphaFromAlbedoTexture;
-            material.useEmissiveAsIllumination = source.useEmissiveAsIllumination;
-            material.useMicroSurfaceFromReflectivityMapAlpha = source.useMicroSurfaceFromReflectivityMapAlpha;
-            material.useAutoMicroSurfaceFromReflectivityMap = source.useAutoMicroSurfaceFromReflectivityMap;
-            material.useScalarInLinearSpace = source.useScalarInLinear;
-            material.useSpecularOverAlpha = source.useSpecularOverAlpha;
-            material.indexOfRefraction = source.indexOfRefraction;
-            material.invertRefractionY = source.invertRefractionY;
-            material.usePhysicalLightFalloff = source.usePhysicalLightFalloff;
-            material.useRadianceOverAlpha = source.useRadianceOverAlpha;
-
-            material.emissiveFresnelParameters = FresnelParameters.Parse(source.emissiveFresnelParameters);
-            material.opacityFresnelParameters = FresnelParameters.Parse(source.opacityFresnelParameters);
-
-            return material;
+            return SerializationHelper.Parse(() => new PBRMaterial(source.name, scene), source, scene, rootUrl);
         }
     }
 }

materialsLibrary/materials/simple/babylon.simpleMaterial.ts

@@ -63,6 +63,8 @@ module BABYLON {
 
         @serializeAsColor3("diffuseColor")
         public diffuseColor = new Color3(1, 1, 1);
+        
+        @serialize()
         public disableLighting = false;
 
         private _worldViewProjectionMatrix = Matrix.Zero();
@@ -349,42 +351,15 @@ module BABYLON {
             return SerializationHelper.Clone<SimpleMaterial>(() => new SimpleMaterial(name, this.getScene()), this);
         }
         
-        public serialize(): any {		
-            var serializationObject = super.serialize();
-            serializationObject.customType      = "BABYLON.SimpleMaterial";
-            serializationObject.diffuseColor    = this.diffuseColor.asArray();
-            serializationObject.disableLighting = this.disableLighting;
-            
-            if (this.diffuseTexture) {
-                serializationObject.diffuseTexture = this.diffuseTexture.serialize();
-            }
-
+        public serialize(): any {
+            var serializationObject = SerializationHelper.Serialize(this);
+            serializationObject.customType = "BABYLON.SimpleMaterial";
             return serializationObject;
         }
 
+        // Statics
         public static Parse(source: any, scene: Scene, rootUrl: string): SimpleMaterial {
-            var material = new SimpleMaterial(source.name, scene);
-
-            material.diffuseColor       = Color3.FromArray(source.diffuseColor);
-            material.disableLighting    = source.disableLighting;
-
-            material.alpha          = source.alpha;
-
-            material.id             = source.id;
-
-            Tags.AddTagsTo(material, source.tags);
-            material.backFaceCulling = source.backFaceCulling;
-            material.wireframe = source.wireframe;
-
-            if (source.diffuseTexture) {
-                material.diffuseTexture = Texture.Parse(source.diffuseTexture, scene, rootUrl);
-            }
-
-            if (source.checkReadyOnlyOnce) {
-                material.checkReadyOnlyOnce = source.checkReadyOnlyOnce;
-            }
-
-            return material;
+            return SerializationHelper.Parse(() => new SimpleMaterial(source.name, scene), source, scene, rootUrl);
         }
     }
 } 

materialsLibrary/materials/sky/babylon.skyMaterial.ts

@@ -31,6 +31,7 @@ module BABYLON {
         @serialize()
         public mieDirectionalG: number = 0.8;
         
+        @serialize()
         public distance: number = 500;
         
         @serialize()
@@ -235,48 +236,16 @@ module BABYLON {
         public clone(name: string): SkyMaterial {
             return SerializationHelper.Clone<SkyMaterial>(() => new SkyMaterial(name, this.getScene()), this);
         }
-		
-		public serialize(): any {
-		
-            var serializationObject = super.serialize();
-            serializationObject.customType = "BABYLON.SkyMaterial";
-            
-            serializationObject.luminance = this.luminance;
-            serializationObject.turbidity = this.turbidity;
-            serializationObject.rayleigh = this.rayleigh;
-            serializationObject.mieCoefficient = this.mieCoefficient;
-            serializationObject.mieDirectionalG = this.mieDirectionalG;
-            serializationObject.distance = this.distance;
-            serializationObject.inclination = this.inclination;
-            serializationObject.azimuth = this.azimuth;
-
+        
+        public serialize(): any {
+            var serializationObject = SerializationHelper.Serialize(this);
+            serializationObject.customType  = "BABYLON.SkyMaterial";
             return serializationObject;
         }
 
+        // Statics
         public static Parse(source: any, scene: Scene, rootUrl: string): SkyMaterial {
-            var material = new SkyMaterial(source.name, scene);
-
-            material.alpha = source.alpha;
-            material.id = source.id;
-            
-            Tags.AddTagsTo(material, source.tags);
-            material.backFaceCulling = source.backFaceCulling;
-            material.wireframe = source.wireframe;
-
-            if (source.checkReadyOnlyOnce) {
-                material.checkReadyOnlyOnce = source.checkReadyOnlyOnce;
-            }
-            
-            material.luminance = source.luminance;
-            material.turbidity = source.turbidity;
-            material.rayleigh = source.rayleigh;
-            material.mieCoefficient = source.mieCoefficient;
-            material.mieDirectionalG = source.mieDirectionalG;
-            material.distance = source.distance;
-            material.inclination = source.inclination;
-            material.azimuth = source.azimuth;
-
-            return material;
+            return SerializationHelper.Parse(() => new SkyMaterial(source.name, scene), source, scene, rootUrl);
         }
     }
 } 

materialsLibrary/materials/terrain/babylon.terrainMaterial.ts

@@ -61,19 +61,37 @@ module BABYLON {
     }
 
     export class TerrainMaterial extends Material {
+        @serializeAsTexture()
         public mixTexture: BaseTexture;
         
+        @serializeAsTexture()
         public diffuseTexture1: Texture;
+        
+        @serializeAsTexture()
         public diffuseTexture2: Texture;
+        
+        @serializeAsTexture()
         public diffuseTexture3: Texture;
         
+        @serializeAsTexture()
         public bumpTexture1: Texture;
+        
+        @serializeAsTexture()
         public bumpTexture2: Texture;
+        
+        @serializeAsTexture()
         public bumpTexture3: Texture;
         
+        @serializeAsColor3()
         public diffuseColor = new Color3(1, 1, 1);
+        
+        @serializeAsColor3()
         public specularColor = new Color3(0, 0, 0);
+        
+        @serialize()
         public specularPower = 64;
+        
+        @serialize()
         public disableLighting = false;
 
         private _worldViewProjectionMatrix = Matrix.Zero();
@@ -557,107 +575,20 @@ module BABYLON {
 
             super.dispose(forceDisposeEffect);
         }
-
+        
         public clone(name: string): TerrainMaterial {
-            var newMaterial = new TerrainMaterial(name, this.getScene());
-
-            // Base material
-            this.copyTo(newMaterial);
-
-            // Simple material
-            if (this.mixTexture && this.mixTexture.clone) {
-                newMaterial.mixTexture = this.mixTexture.clone();
-            }
-
-            newMaterial.diffuseColor = this.diffuseColor.clone();
-            return newMaterial;
+            return SerializationHelper.Clone(() => new TerrainMaterial(name, this.getScene()), this);
         }
-		
-		public serialize(): any {
-		
-            var serializationObject = super.serialize();
-            serializationObject.customType      = "BABYLON.TerrainMaterial";
-            serializationObject.diffuseColor    = this.diffuseColor.asArray();
-			serializationObject.specularColor   = this.specularColor.asArray();
-            serializationObject.specularPower   = this.specularPower;
-            serializationObject.disableLighting = this.disableLighting;
-
-            if (this.diffuseTexture1) {
-                serializationObject.diffuseTexture1 = this.diffuseTexture1.serialize();
-            }
-			
-			if (this.diffuseTexture2) {
-                serializationObject.diffuseTexture2 = this.diffuseTexture2.serialize();
-            }
-			
-			if (this.diffuseTexture3) {
-                serializationObject.diffuseTexture3 = this.diffuseTexture3.serialize();
-            }
-			
-			if (this.bumpTexture1) {
-                serializationObject.bumpTexture1 = this.bumpTexture1.serialize();
-            }
-			
-			if (this.bumpTexture2) {
-                serializationObject.bumpTexture2 = this.bumpTexture2.serialize();
-            }
-			
-			if (this.bumpTexture3) {
-                serializationObject.bumpTexture3 = this.bumpTexture3.serialize();
-            }
-            
-			if (this.mixTexture) {
-                serializationObject.mixTexture = this.mixTexture.serialize();
-            }
 
+        public serialize(): any {
+            var serializationObject = SerializationHelper.Serialize(this);
+            serializationObject.customType = "BABYLON.TerrainMaterial";
             return serializationObject;
         }
 
+        // Statics
         public static Parse(source: any, scene: Scene, rootUrl: string): TerrainMaterial {
-            var material = new TerrainMaterial(source.name, scene);
-
-            material.diffuseColor   = Color3.FromArray(source.diffuseColor);
-			material.specularColor   = Color3.FromArray(source.specularColor);
-            material.specularPower          = source.specularPower;
-            material.disableLighting    = source.disableLighting;
-
-            material.alpha          = source.alpha;
-
-            material.id             = source.id;
-
-            Tags.AddTagsTo(material, source.tags);
-            material.backFaceCulling = source.backFaceCulling;
-            material.wireframe = source.wireframe;
-
-            if (source.diffuseTexture1) {
-                material.diffuseTexture1 = <Texture>Texture.Parse(source.diffuseTexture1, scene, rootUrl);
-            }
-			
-			if (source.diffuseTexture2) {
-                material.diffuseTexture2 = <Texture>Texture.Parse(source.diffuseTexture2, scene, rootUrl);
-            }
-
-			if (source.diffuseTexture3) {
-                material.diffuseTexture3 = <Texture>Texture.Parse(source.diffuseTexture3, scene, rootUrl);
-            }
-			
-			if (source.bumpTexture1) {
-                material.bumpTexture1 = <Texture>Texture.Parse(source.bumpTexture1, scene, rootUrl);
-            }
-			
-			if (source.bumpTexture2) {
-                material.bumpTexture2 = <Texture> Texture.Parse(source.bumpTexture2, scene, rootUrl);
-            }
-			
-			if (source.bumpTexture3) {
-                material.bumpTexture3 = <Texture> Texture.Parse(source.bumpTexture3, scene, rootUrl);
-            }
-
-            if (source.mixTexture) {
-                material.mixTexture = Texture.Parse(source.mixTexture, scene, rootUrl);
-            }
-
-            return material;
+            return SerializationHelper.Parse(() => new TerrainMaterial(source.name, scene), source, scene, rootUrl);
         }
     }
 } 

materialsLibrary/materials/triPlanar/babylon.triPlanarMaterial.ts

@@ -65,21 +65,40 @@ module BABYLON {
     }
 
     export class TriPlanarMaterial extends Material {
+        @serializeAsTexture()
         public mixTexture: BaseTexture;
         
+        @serializeAsTexture()
         public diffuseTextureX: Texture;
+        
+        @serializeAsTexture()
         public diffuseTextureY: Texture;
+        
+        @serializeAsTexture()
         public diffuseTextureZ: Texture;
         
+        @serializeAsTexture()
         public normalTextureX: Texture;
+        
+        @serializeAsTexture()
         public normalTextureY: Texture;
+        
+        @serializeAsTexture()
         public normalTextureZ: Texture;
         
+        @serialize()
         public tileSize: number = 1;
         
+        @serializeAsColor3()
         public diffuseColor = new Color3(1, 1, 1);
+        
+        @serializeAsColor3()
         public specularColor = new Color3(0.2, 0.2, 0.2);
+        
+        @serialize()
         public specularPower = 64;
+        
+        @serialize()
         public disableLighting = false;
 
         private _worldViewProjectionMatrix = Matrix.Zero();
@@ -547,75 +566,20 @@ module BABYLON {
 
             super.dispose(forceDisposeEffect);
         }
-
+        
         public clone(name: string): TriPlanarMaterial {
-            var newMaterial = new TriPlanarMaterial(name, this.getScene());
-
-            // Base material
-            this.copyTo(newMaterial);
-
-            // Simple material
-            if (this.mixTexture && this.mixTexture.clone) {
-                newMaterial.mixTexture = this.mixTexture.clone();
-            }
-
-            newMaterial.diffuseColor = this.diffuseColor.clone();
-            return newMaterial;
+            return SerializationHelper.Clone(() => new TriPlanarMaterial(name, this.getScene()), this);
         }
-		
-		public serialize(): any {
-		
-            var serializationObject = super.serialize();
-            serializationObject.customType      = "BABYLON.TerrainMaterial";
-            serializationObject.diffuseColor    = this.diffuseColor.asArray();
-			serializationObject.specularColor   = this.specularColor.asArray();
-            serializationObject.specularPower   = this.specularPower;
-            serializationObject.disableLighting = this.disableLighting;
-
-            if (this.diffuseTextureX) {
-                serializationObject.diffuseTextureX = this.diffuseTextureX.serialize();
-            }
-			
-			if (this.diffuseTextureY) {
-                serializationObject.diffuseTextureY = this.diffuseTextureY.serialize();
-            }
-			
-			if (this.diffuseTextureZ) {
-                serializationObject.diffuseTextureZ = this.diffuseTextureZ.serialize();
-            }
 
+        public serialize(): any {
+            var serializationObject = SerializationHelper.Serialize(this);
+            serializationObject.customType = "BABYLON.TriPlanarMaterial";
             return serializationObject;
         }
 
+        // Statics
         public static Parse(source: any, scene: Scene, rootUrl: string): TriPlanarMaterial {
-            var material = new TriPlanarMaterial(source.name, scene);
-
-            material.diffuseColor   = Color3.FromArray(source.diffuseColor);
-			material.specularColor   = Color3.FromArray(source.specularColor);
-            material.specularPower          = source.specularPower;
-            material.disableLighting    = source.disableLighting;
-
-            material.alpha          = source.alpha;
-
-            material.id             = source.id;
-
-            Tags.AddTagsTo(material, source.tags);
-            material.backFaceCulling = source.backFaceCulling;
-            material.wireframe = source.wireframe;
-
-            if (source.diffuseTextureX) {
-                material.diffuseTextureX = <Texture>Texture.Parse(source.diffuseTextureX, scene, rootUrl);
-            }
-			
-			if (source.diffuseTextureY) {
-                material.diffuseTextureY = <Texture>Texture.Parse(source.diffuseTextureY, scene, rootUrl);
-            }
-
-			if (source.diffuseTextureZ) {
-                material.diffuseTextureZ = <Texture>Texture.Parse(source.diffuseTextureZ, scene, rootUrl);
-            }
-
-            return material;
+            return SerializationHelper.Parse(() => new TriPlanarMaterial(source.name, scene), source, scene, rootUrl);
         }
     }
 } 

materialsLibrary/materials/pbr/tsconfig.json

@@ -1,5 +1,6 @@
 {
     "compilerOptions": {
+        "experimentalDecorators": true,
         "module": "commonjs", 
         "target": "es5"
     }

materialsLibrary/materials/water/babylon.waterMaterial.ts

@@ -65,44 +65,61 @@ module BABYLON {
 		/*
 		* Public members
 		*/
+        @serializeAsTexture()
         public bumpTexture: BaseTexture;
+        
+        @serializeAsColor3()
         public diffuseColor = new Color3(1, 1, 1);
+        
+        @serializeAsColor3()
         public specularColor = new Color3(0, 0, 0);
+        
+        @serialize()
         public specularPower = 64;
+        
+        @serialize()
         public disableLighting = false;
         
         /**
         * @param {number}: Represents the wind force
         */
+        @serialize()
 		public windForce: number = 6;
         /**
         * @param {Vector2}: The direction of the wind in the plane (X, Z)
         */
+        @serializeAsVector2()
 		public windDirection: Vector2 = new Vector2(0, 1);
         /**
         * @param {number}: Wave height, represents the height of the waves
         */
+        @serialize()
 		public waveHeight: number = 0.4;
         /**
         * @param {number}: Bump height, represents the bump height related to the bump map
         */
+        @serialize()
 		public bumpHeight: number = 0.4;
         /**
         * @param {number}: The water color blended with the reflection and refraction samplers
         */
+        @serializeAsColor3()
 		public waterColor: Color3 = new Color3(0.1, 0.1, 0.6);
         /**
         * @param {number}: The blend factor related to the water color
         */
+        @serialize()
 		public colorBlendFactor: number = 0.2;
         /**
         * @param {number}: Represents the maximum length of a wave
         */
+        @serialize()
 		public waveLength: number = 0.1;
         
         /**
         * @param {number}: Defines the waves speed
         */
+        @serialize()
         public waveSpeed: number = 1.0;
 		
 		/*
@@ -717,81 +734,18 @@ module BABYLON {
         }
 
         public clone(name: string): WaterMaterial {
-            var newMaterial = new WaterMaterial(name, this.getScene());
-
-            // Base material
-            this.copyTo(newMaterial);
-
-            // water material
-            if (this.bumpTexture && this.bumpTexture.clone) {
-                newMaterial.bumpTexture = this.bumpTexture.clone();
-            }
-
-            newMaterial.diffuseColor = this.diffuseColor.clone();
-            return newMaterial;
+            return SerializationHelper.Clone(() => new WaterMaterial(name, this.getScene()), this);
         }
-        
-		public serialize(): any {
-		        		
-            var serializationObject = super.serialize();
-			
-             serializationObject.customType         = "BABYLON.WaterMaterial";
-            serializationObject.diffuseColor    	= this.diffuseColor.asArray();
-			serializationObject.specularColor   	= this.specularColor.asArray();
-            serializationObject.specularPower   	= this.specularPower;
-            serializationObject.disableLighting 	= this.disableLighting;
-            serializationObject.windForce     		= this.windForce;
-            serializationObject.windDirection 		= this.windDirection.asArray();
-            serializationObject.waveHeight      	= this.waveHeight;
-            serializationObject.bumpHeight 			= this.bumpHeight;
-			serializationObject.waterColor 			= this.waterColor.asArray();
-			serializationObject.colorBlendFactor	= this.colorBlendFactor;
-			serializationObject.waveLength 			= this.waveLength;
-			serializationObject.renderTargetSize	= this.renderTargetSize.asArray();
-			
-            if (this.bumpTexture) {
-                serializationObject.bumpTexture 	= this.bumpTexture.serialize();
-            }
 
+        public serialize(): any {
+            var serializationObject = SerializationHelper.Serialize(this);
+            serializationObject.customType = "BABYLON.WaterMaterial";
             return serializationObject;
         }
 
+        // Statics
         public static Parse(source: any, scene: Scene, rootUrl: string): WaterMaterial {
-		
-			var renderTargetSize = source.renderTargetSize ? Vector2.FromArray(source.renderTargetSize) : null;
-		
-            var material = new WaterMaterial(source.name, scene, renderTargetSize);
-
-            material.diffuseColor    	= Color3.FromArray(source.diffuseColor);
-			material.specularColor   	= Color3.FromArray(source.specularColor);
-            material.specularPower   	= source.specularPower;
-            material.disableLighting 	= source.disableLighting;
-            material.windForce     		= source.windForce;
-            material.windDirection 		= Vector2.FromArray(source.windDirection);
-            material.waveHeight      	= source.waveHeight;
-            material.bumpHeight 		= source.bumpHeight;
-			material.waterColor 		= Color3.FromArray(source.waterColor);
-			material.colorBlendFactor	= source.colorBlendFactor;
-			material.waveLength 		= source.waveLength;
-			material.renderTargetSize	= Vector2.FromArray(source.renderTargetSize);
-
-            material.alpha          = source.alpha;
-
-            material.id             = source.id;
-
-            Tags.AddTagsTo(material, source.tags);
-            material.backFaceCulling = source.backFaceCulling;
-            material.wireframe = source.wireframe;
-
-            if (source.bumpTexture) {
-                material.bumpTexture = Texture.Parse(source.bumpTexture, scene, rootUrl);
-            }
-
-            if (source.checkReadyOnlyOnce) {
-                material.checkReadyOnlyOnce = source.checkReadyOnlyOnce;
-            }
-
-            return material;
+            return SerializationHelper.Parse(() => new WaterMaterial(source.name, scene), source, scene, rootUrl);
         }
 		
 		public static CreateDefaultMesh(name: string, scene: Scene): Mesh {

src/Tools/HDR/babylon.tools.pmremgenerator.js

@@ -0,0 +1,12 @@
+var BABYLON;
+(function (BABYLON) {
+    var Internals;
+    (function (Internals) {
+        var PMREMGenerator = (function () {
+            function PMREMGenerator() {
+            }
+            return PMREMGenerator;
+        })();
+        Internals.PMREMGenerator = PMREMGenerator;
+    })(Internals = BABYLON.Internals || (BABYLON.Internals = {}));
+})(BABYLON || (BABYLON = {}));

src/Tools/HDR/babylon.tools.pmremgenerator.ts

@@ -0,0 +1,5 @@
+module BABYLON.Internals {
+    export class PMREMGenerator {
+
+    }
+} 

src/Tools/babylon.decorators.js

@@ -24,12 +24,16 @@ var BABYLON;
         return generateSerializableMember(3, sourceName); // fresnel parameters member
     }
     BABYLON.serializeAsFresnelParameters = serializeAsFresnelParameters;
+    function serializeAsVector2(sourceName) {
+        return generateSerializableMember(4, sourceName); // vector2 member
+    }
+    BABYLON.serializeAsVector2 = serializeAsVector2;
     function serializeAsVector3(sourceName) {
-        return generateSerializableMember(4, sourceName); // vector3 member
+        return generateSerializableMember(5, sourceName); // vector3 member
     }
     BABYLON.serializeAsVector3 = serializeAsVector3;
     function serializeAsMeshReference(sourceName) {
-        return generateSerializableMember(5, sourceName); // mesh reference member
+        return generateSerializableMember(6, sourceName); // mesh reference member
     }
     BABYLON.serializeAsMeshReference = serializeAsMeshReference;
     var SerializationHelper = (function () {
@@ -65,6 +69,9 @@ var BABYLON;
                             serializationObject[targetPropertyName] = sourceProperty.asArray();
                             break;
                         case 5:
+                            serializationObject[targetPropertyName] = sourceProperty.asArray();
+                            break;
+                        case 6:
                             serializationObject[targetPropertyName] = sourceProperty.id;
                             break;
                     }
@@ -96,9 +103,12 @@ var BABYLON;
                             destination[property] = BABYLON.FresnelParameters.Parse(sourceProperty);
                             break;
                         case 4:
-                            destination[property] = BABYLON.Vector3.FromArray(sourceProperty);
+                            destination[property] = BABYLON.Vector2.FromArray(sourceProperty);
                             break;
                         case 5:
+                            destination[property] = BABYLON.Vector3.FromArray(sourceProperty);
+                            break;
+                        case 6:
                             destination[property] = scene.getLastMeshByID(sourceProperty);
                             break;
                     }
@@ -118,13 +128,14 @@ var BABYLON;
                 if (sourceProperty !== undefined && sourceProperty !== null) {
                     switch (propertyType) {
                         case 0: // Value
-                        case 5:
+                        case 6:
                             destination[property] = sourceProperty;
                             break;
                         case 1: // Texture
                         case 2: // Color3
                         case 3: // FresnelParameters
-                        case 4:
+                        case 4: // Vector2
+                        case 5:
                             destination[property] = sourceProperty.clone();
                             break;
                     }

src/Tools/babylon.decorators.ts

@@ -24,13 +24,17 @@
     export function serializeAsFresnelParameters(sourceName?: string) {
         return generateSerializableMember(3, sourceName); // fresnel parameters member
     }
+    
+    export function serializeAsVector2(sourceName?: string) {
+        return generateSerializableMember(4, sourceName); // vector2 member
+    }
 
     export function serializeAsVector3(sourceName?: string) {
-        return generateSerializableMember(4, sourceName); // vector3 member
+        return generateSerializableMember(5, sourceName); // vector3 member
     }
 
     export function serializeAsMeshReference(sourceName?: string) {
-        return generateSerializableMember(5, sourceName); // mesh reference member
+        return generateSerializableMember(6, sourceName); // mesh reference member
     }
 
     export class SerializationHelper {
@@ -64,10 +68,13 @@
                         case 3:     // FresnelParameters
                             serializationObject[targetPropertyName] = sourceProperty.serialize();
                             break;
-                        case 4:     // Vector3
+                        case 4:     // Vector2
+                            serializationObject[targetPropertyName] = sourceProperty.asArray();
+                            break;
+                        case 5:     // Vector3
                             serializationObject[targetPropertyName] = sourceProperty.asArray();
                             break;
-                        case 5:     // Mesh reference
+                        case 6:     // Mesh reference
                             serializationObject[targetPropertyName] = sourceProperty.id;
                             break;
                     }
@@ -103,10 +110,13 @@
                         case 3:     // FresnelParameters
                             destination[property] = FresnelParameters.Parse(sourceProperty);
                             break;
-                        case 4:     // Vector3
+                        case 4:     // Vector2
+                            destination[property] = Vector2.FromArray(sourceProperty);
+                            break;
+                        case 5:     // Vector3
                             destination[property] = Vector3.FromArray(sourceProperty);
                             break;
-                        case 5:     // Mesh reference
+                        case 6:     // Mesh reference
                             destination[property] = scene.getLastMeshByID(sourceProperty);
                             break;
                     }
@@ -131,13 +141,14 @@
                 if (sourceProperty !== undefined && sourceProperty !== null) {
                     switch (propertyType) {
                         case 0:     // Value
-                        case 5:     // Mesh reference
+                        case 6:     // Mesh reference
                             destination[property] = sourceProperty;
                             break;
                         case 1:     // Texture
                         case 2:     // Color3
                         case 3:     // FresnelParameters
-                        case 4:     // Vector3
+                        case 4:     // Vector2
+                        case 5:     // Vector3
                             destination[property] = sourceProperty.clone();
                             break;
                     }

src/tsconfig.json

@@ -1,5 +1,6 @@
 {
     "compilerOptions": {
+        "experimentalDecorators": true,
         "module": "commonjs", 
         "target": "es5"
     }