增加马踏飞燕以及青花瓷破碎特效

Assets/Model.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 09a17e7bce804d54d83c8782f9dab407
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Model/ma222.controller

@@ -0,0 +1,1027 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1101 &-7994479991439336086
+AnimatorStateTransition:
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_Conditions: []
+  m_DstStateMachine: {fileID: 0}
+  m_DstState: {fileID: 7731658760487074574}
+  m_Solo: 0
+  m_Mute: 0
+  m_IsExit: 0
+  serializedVersion: 3
+  m_TransitionDuration: 0
+  m_TransitionOffset: 0.014048716
+  m_ExitTime: 1.0000001
+  m_HasExitTime: 1
+  m_HasFixedDuration: 1
+  m_InterruptionSource: 0
+  m_OrderedInterruption: 1
+  m_CanTransitionToSelf: 1
+--- !u!1101 &-7503558647069790959
+AnimatorStateTransition:
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_Conditions: []
+  m_DstStateMachine: {fileID: 0}
+  m_DstState: {fileID: 7287412515168328555}
+  m_Solo: 0
+  m_Mute: 0
+  m_IsExit: 0
+  serializedVersion: 3
+  m_TransitionDuration: 0.0008981526
+  m_TransitionOffset: 0.017964052
+  m_ExitTime: 0.9979274
+  m_HasExitTime: 1
+  m_HasFixedDuration: 1
+  m_InterruptionSource: 0
+  m_OrderedInterruption: 1
+  m_CanTransitionToSelf: 1
+--- !u!1102 &-7244591779265756029
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: donghua 0
+  m_Speed: 1
+  m_CycleOffset: 0
+  m_Transitions:
+  - {fileID: 2353454580860710148}
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: -7981952544716469480, guid: 9e61581a97cfbf749ae174690343c731,
+    type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1102 &-7152189074264257905
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: pao 0
+  m_Speed: 0.8
+  m_CycleOffset: 0
+  m_Transitions:
+  - {fileID: -520004809337334844}
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 2995255283246636721, guid: 9e61581a97cfbf749ae174690343c731,
+    type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1101 &-6452371527825091772
+AnimatorStateTransition:
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_Conditions: []
+  m_DstStateMachine: {fileID: 0}
+  m_DstState: {fileID: 5098155635446421678}
+  m_Solo: 0
+  m_Mute: 0
+  m_IsExit: 0
+  serializedVersion: 3
+  m_TransitionDuration: 0
+  m_TransitionOffset: 0.021048933
+  m_ExitTime: 1
+  m_HasExitTime: 1
+  m_HasFixedDuration: 1
+  m_InterruptionSource: 0
+  m_OrderedInterruption: 1
+  m_CanTransitionToSelf: 1
+--- !u!1107 &-5976178758092552167
+AnimatorStateMachine:
+  serializedVersion: 5
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Base Layer
+  m_ChildStates:
+  - serializedVersion: 1
+    m_State: {fileID: -3989605709805445660}
+    m_Position: {x: 30, y: 220, z: 0}
+  - serializedVersion: 1
+    m_State: {fileID: 7134197725718032038}
+    m_Position: {x: 50, y: 340, z: 0}
+  - serializedVersion: 1
+    m_State: {fileID: -7152189074264257905}
+    m_Position: {x: 60, y: 420, z: 0}
+  - serializedVersion: 1
+    m_State: {fileID: 1686057868300083300}
+    m_Position: {x: 370, y: 430, z: 0}
+  - serializedVersion: 1
+    m_State: {fileID: -3717064466148710650}
+    m_Position: {x: 390, y: 510, z: 0}
+  - serializedVersion: 1
+    m_State: {fileID: 1113760392139070383}
+    m_Position: {x: 380, y: 580, z: 0}
+  - serializedVersion: 1
+    m_State: {fileID: 7731658760487074574}
+    m_Position: {x: 390, y: 660, z: 0}
+  - serializedVersion: 1
+    m_State: {fileID: 1851545991632814577}
+    m_Position: {x: 400, y: 740, z: 0}
+  - serializedVersion: 1
+    m_State: {fileID: -7244591779265756029}
+    m_Position: {x: 100, y: 920, z: 0}
+  - serializedVersion: 1
+    m_State: {fileID: 7927526774016616015}
+    m_Position: {x: 90, y: 1020, z: 0}
+  - serializedVersion: 1
+    m_State: {fileID: 5075305838487493551}
+    m_Position: {x: 780, y: 650, z: 0}
+  - serializedVersion: 1
+    m_State: {fileID: 3892657994898196661}
+    m_Position: {x: 770, y: 740, z: 0}
+  - serializedVersion: 1
+    m_State: {fileID: 7287412515168328555}
+    m_Position: {x: 760, y: 810, z: 0}
+  - serializedVersion: 1
+    m_State: {fileID: -219083811586033718}
+    m_Position: {x: 750, y: 880, z: 0}
+  - serializedVersion: 1
+    m_State: {fileID: -1343356418090546779}
+    m_Position: {x: 750, y: 980, z: 0}
+  - serializedVersion: 1
+    m_State: {fileID: 7969560249966770103}
+    m_Position: {x: 740, y: 1070, z: 0}
+  - serializedVersion: 1
+    m_State: {fileID: 5098155635446421678}
+    m_Position: {x: 440, y: 1070, z: 0}
+  - serializedVersion: 1
+    m_State: {fileID: -4647658267204495407}
+    m_Position: {x: 420, y: 990, z: 0}
+  - serializedVersion: 1
+    m_State: {fileID: 3939819862128878234}
+    m_Position: {x: 420, y: 900, z: 0}
+  m_ChildStateMachines: []
+  m_AnyStateTransitions: []
+  m_EntryTransitions: []
+  m_StateMachineTransitions: {}
+  m_StateMachineBehaviours: []
+  m_AnyStatePosition: {x: 50, y: 20, z: 0}
+  m_EntryPosition: {x: 50, y: 120, z: 0}
+  m_ExitPosition: {x: 800, y: 120, z: 0}
+  m_ParentStateMachinePosition: {x: 800, y: 20, z: 0}
+  m_DefaultState: {fileID: -3989605709805445660}
+--- !u!1101 &-5683795790671046343
+AnimatorStateTransition:
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_Conditions: []
+  m_DstStateMachine: {fileID: 0}
+  m_DstState: {fileID: 1851545991632814577}
+  m_Solo: 0
+  m_Mute: 0
+  m_IsExit: 0
+  serializedVersion: 3
+  m_TransitionDuration: 0
+  m_TransitionOffset: 0.02003678
+  m_ExitTime: 1.0000001
+  m_HasExitTime: 1
+  m_HasFixedDuration: 1
+  m_InterruptionSource: 0
+  m_OrderedInterruption: 1
+  m_CanTransitionToSelf: 1
+--- !u!1101 &-4741379183383210401
+AnimatorStateTransition:
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_Conditions: []
+  m_DstStateMachine: {fileID: 0}
+  m_DstState: {fileID: 3939819862128878234}
+  m_Solo: 0
+  m_Mute: 0
+  m_IsExit: 0
+  serializedVersion: 3
+  m_TransitionDuration: 0
+  m_TransitionOffset: 0.015318364
+  m_ExitTime: 1
+  m_HasExitTime: 1
+  m_HasFixedDuration: 1
+  m_InterruptionSource: 0
+  m_OrderedInterruption: 1
+  m_CanTransitionToSelf: 1
+--- !u!1102 &-4647658267204495407
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: pao 3 0 0 0 0 0 0 0 0 0 0
+  m_Speed: 0.8
+  m_CycleOffset: 0
+  m_Transitions:
+  - {fileID: -4741379183383210401}
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 2995255283246636721, guid: 9e61581a97cfbf749ae174690343c731,
+    type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1102 &-3989605709805445660
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: donghua
+  m_Speed: 1
+  m_CycleOffset: 0
+  m_Transitions:
+  - {fileID: 3290011484129963128}
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: -7981952544716469480, guid: 9e61581a97cfbf749ae174690343c731,
+    type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1102 &-3717064466148710650
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: pao 2
+  m_Speed: 0.8
+  m_CycleOffset: 0
+  m_Transitions:
+  - {fileID: 3226604885610724964}
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 2995255283246636721, guid: 9e61581a97cfbf749ae174690343c731,
+    type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1101 &-2474563801332861938
+AnimatorStateTransition:
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_Conditions: []
+  m_DstStateMachine: {fileID: 0}
+  m_DstState: {fileID: -4647658267204495407}
+  m_Solo: 0
+  m_Mute: 0
+  m_IsExit: 0
+  serializedVersion: 3
+  m_TransitionDuration: 0
+  m_TransitionOffset: 0.021048933
+  m_ExitTime: 1
+  m_HasExitTime: 1
+  m_HasFixedDuration: 1
+  m_InterruptionSource: 0
+  m_OrderedInterruption: 1
+  m_CanTransitionToSelf: 1
+--- !u!1102 &-1343356418090546779
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: pao 3 0 0 0 0 0 0 0
+  m_Speed: 0.8
+  m_CycleOffset: 0
+  m_Transitions:
+  - {fileID: 8987798597038341299}
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 2995255283246636721, guid: 9e61581a97cfbf749ae174690343c731,
+    type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1101 &-520004809337334844
+AnimatorStateTransition:
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_Conditions: []
+  m_DstStateMachine: {fileID: 0}
+  m_DstState: {fileID: 1686057868300083300}
+  m_Solo: 0
+  m_Mute: 0
+  m_IsExit: 0
+  serializedVersion: 3
+  m_TransitionDuration: 0
+  m_TransitionOffset: 0.008060722
+  m_ExitTime: 1.0000001
+  m_HasExitTime: 1
+  m_HasFixedDuration: 1
+  m_InterruptionSource: 0
+  m_OrderedInterruption: 1
+  m_CanTransitionToSelf: 1
+--- !u!1101 &-253305415961484227
+AnimatorStateTransition:
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_Conditions: []
+  m_DstStateMachine: {fileID: 0}
+  m_DstState: {fileID: -7152189074264257905}
+  m_Solo: 0
+  m_Mute: 0
+  m_IsExit: 0
+  serializedVersion: 3
+  m_TransitionDuration: 0
+  m_TransitionOffset: 0.02003678
+  m_ExitTime: 1.0000001
+  m_HasExitTime: 1
+  m_HasFixedDuration: 1
+  m_InterruptionSource: 0
+  m_OrderedInterruption: 1
+  m_CanTransitionToSelf: 1
+--- !u!1102 &-219083811586033718
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: pao 3 0 0 0 0 0 0
+  m_Speed: 0.8
+  m_CycleOffset: 0
+  m_Transitions:
+  - {fileID: 1930765715503899784}
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 2995255283246636721, guid: 9e61581a97cfbf749ae174690343c731,
+    type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!91 &9100000
+AnimatorController:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: ma222
+  serializedVersion: 5
+  m_AnimatorParameters: []
+  m_AnimatorLayers:
+  - serializedVersion: 5
+    m_Name: Base Layer
+    m_StateMachine: {fileID: -5976178758092552167}
+    m_Mask: {fileID: 0}
+    m_Motions: []
+    m_Behaviours: []
+    m_BlendingMode: 0
+    m_SyncedLayerIndex: -1
+    m_DefaultWeight: 0
+    m_IKPass: 0
+    m_SyncedLayerAffectsTiming: 0
+    m_Controller: {fileID: 9100000}
+--- !u!1101 &630138665073789545
+AnimatorStateTransition:
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_Conditions: []
+  m_DstStateMachine: {fileID: 0}
+  m_DstState: {fileID: 5075305838487493551}
+  m_Solo: 0
+  m_Mute: 0
+  m_IsExit: 0
+  serializedVersion: 3
+  m_TransitionDuration: 0
+  m_TransitionOffset: 0.014048716
+  m_ExitTime: 1.0000001
+  m_HasExitTime: 1
+  m_HasFixedDuration: 1
+  m_InterruptionSource: 0
+  m_OrderedInterruption: 1
+  m_CanTransitionToSelf: 1
+--- !u!1101 &894486182780273400
+AnimatorStateTransition:
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_Conditions: []
+  m_DstStateMachine: {fileID: 0}
+  m_DstState: {fileID: 3892657994898196661}
+  m_Solo: 0
+  m_Mute: 0
+  m_IsExit: 0
+  serializedVersion: 3
+  m_TransitionDuration: 0
+  m_TransitionOffset: 0.008060722
+  m_ExitTime: 1.0000001
+  m_HasExitTime: 1
+  m_HasFixedDuration: 1
+  m_InterruptionSource: 0
+  m_OrderedInterruption: 1
+  m_CanTransitionToSelf: 1
+--- !u!1102 &1113760392139070383
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: pao 3
+  m_Speed: 0.8
+  m_CycleOffset: 0
+  m_Transitions:
+  - {fileID: -7994479991439336086}
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 2995255283246636721, guid: 9e61581a97cfbf749ae174690343c731,
+    type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1101 &1116115450721455439
+AnimatorStateTransition:
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_Conditions: []
+  m_DstStateMachine: {fileID: 0}
+  m_DstState: {fileID: -7244591779265756029}
+  m_Solo: 0
+  m_Mute: 0
+  m_IsExit: 0
+  serializedVersion: 3
+  m_TransitionDuration: 0.25
+  m_TransitionOffset: 0
+  m_ExitTime: 0.423077
+  m_HasExitTime: 1
+  m_HasFixedDuration: 1
+  m_InterruptionSource: 0
+  m_OrderedInterruption: 1
+  m_CanTransitionToSelf: 1
+--- !u!1101 &1627701304546293694
+AnimatorStateTransition:
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_Conditions: []
+  m_DstStateMachine: {fileID: 0}
+  m_DstState: {fileID: -219083811586033718}
+  m_Solo: 0
+  m_Mute: 0
+  m_IsExit: 0
+  serializedVersion: 3
+  m_TransitionDuration: 0
+  m_TransitionOffset: 0.014048716
+  m_ExitTime: 1.0000001
+  m_HasExitTime: 1
+  m_HasFixedDuration: 1
+  m_InterruptionSource: 0
+  m_OrderedInterruption: 1
+  m_CanTransitionToSelf: 1
+--- !u!1102 &1686057868300083300
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: pao 1
+  m_Speed: 0.8
+  m_CycleOffset: 0
+  m_Transitions:
+  - {fileID: 4683152103039940193}
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 2995255283246636721, guid: 9e61581a97cfbf749ae174690343c731,
+    type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1102 &1851545991632814577
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: pao 3 0 0
+  m_Speed: 0.8
+  m_CycleOffset: 0
+  m_Transitions:
+  - {fileID: 630138665073789545}
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 2995255283246636721, guid: 9e61581a97cfbf749ae174690343c731,
+    type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1101 &1930765715503899784
+AnimatorStateTransition:
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_Conditions: []
+  m_DstStateMachine: {fileID: 0}
+  m_DstState: {fileID: -1343356418090546779}
+  m_Solo: 0
+  m_Mute: 0
+  m_IsExit: 0
+  serializedVersion: 3
+  m_TransitionDuration: 0
+  m_TransitionOffset: 0.015318294
+  m_ExitTime: 1
+  m_HasExitTime: 1
+  m_HasFixedDuration: 1
+  m_InterruptionSource: 0
+  m_OrderedInterruption: 1
+  m_CanTransitionToSelf: 1
+--- !u!1101 &2353454580860710148
+AnimatorStateTransition:
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_Conditions: []
+  m_DstStateMachine: {fileID: 0}
+  m_DstState: {fileID: 7927526774016616015}
+  m_Solo: 0
+  m_Mute: 0
+  m_IsExit: 0
+  serializedVersion: 3
+  m_TransitionDuration: 0.9929569
+  m_TransitionOffset: 0
+  m_ExitTime: 0.38383716
+  m_HasExitTime: 1
+  m_HasFixedDuration: 1
+  m_InterruptionSource: 0
+  m_OrderedInterruption: 1
+  m_CanTransitionToSelf: 1
+--- !u!1101 &3226604885610724964
+AnimatorStateTransition:
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_Conditions: []
+  m_DstStateMachine: {fileID: 0}
+  m_DstState: {fileID: 1113760392139070383}
+  m_Solo: 0
+  m_Mute: 0
+  m_IsExit: 0
+  serializedVersion: 3
+  m_TransitionDuration: 0
+  m_TransitionOffset: 0.008060722
+  m_ExitTime: 1.0000001
+  m_HasExitTime: 1
+  m_HasFixedDuration: 1
+  m_InterruptionSource: 0
+  m_OrderedInterruption: 1
+  m_CanTransitionToSelf: 1
+--- !u!1101 &3290011484129963128
+AnimatorStateTransition:
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_Conditions: []
+  m_DstStateMachine: {fileID: 0}
+  m_DstState: {fileID: 7134197725718032038}
+  m_Solo: 0
+  m_Mute: 0
+  m_IsExit: 0
+  serializedVersion: 3
+  m_TransitionDuration: 0
+  m_TransitionOffset: 0.025586372
+  m_ExitTime: 0.99988717
+  m_HasExitTime: 1
+  m_HasFixedDuration: 1
+  m_InterruptionSource: 0
+  m_OrderedInterruption: 1
+  m_CanTransitionToSelf: 1
+--- !u!1102 &3892657994898196661
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: pao 3 0 0 0 0
+  m_Speed: 0.8
+  m_CycleOffset: 0
+  m_Transitions:
+  - {fileID: -7503558647069790959}
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 2995255283246636721, guid: 9e61581a97cfbf749ae174690343c731,
+    type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1102 &3939819862128878234
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: pao 3 0 0 0 0 0 0 0 0 0 0 0
+  m_Speed: 0.8
+  m_CycleOffset: 0
+  m_Transitions:
+  - {fileID: 1116115450721455439}
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 2995255283246636721, guid: 9e61581a97cfbf749ae174690343c731,
+    type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1101 &4683152103039940193
+AnimatorStateTransition:
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_Conditions: []
+  m_DstStateMachine: {fileID: 0}
+  m_DstState: {fileID: -3717064466148710650}
+  m_Solo: 0
+  m_Mute: 0
+  m_IsExit: 0
+  serializedVersion: 3
+  m_TransitionDuration: 0
+  m_TransitionOffset: 0.0020727275
+  m_ExitTime: 1.0000001
+  m_HasExitTime: 1
+  m_HasFixedDuration: 1
+  m_InterruptionSource: 0
+  m_OrderedInterruption: 1
+  m_CanTransitionToSelf: 1
+--- !u!1102 &5075305838487493551
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: pao 3 0 0 0
+  m_Speed: 0.8
+  m_CycleOffset: 0
+  m_Transitions:
+  - {fileID: 894486182780273400}
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 2995255283246636721, guid: 9e61581a97cfbf749ae174690343c731,
+    type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1102 &5098155635446421678
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: pao 3 0 0 0 0 0 0 0 0 0
+  m_Speed: 0.8
+  m_CycleOffset: 0
+  m_Transitions:
+  - {fileID: -2474563801332861938}
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 2995255283246636721, guid: 9e61581a97cfbf749ae174690343c731,
+    type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1102 &7134197725718032038
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: pao
+  m_Speed: 0.8
+  m_CycleOffset: 0
+  m_Transitions:
+  - {fileID: -253305415961484227}
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 2995255283246636721, guid: 9e61581a97cfbf749ae174690343c731,
+    type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1102 &7287412515168328555
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: pao 3 0 0 0 0 0
+  m_Speed: 0.8
+  m_CycleOffset: 0
+  m_Transitions:
+  - {fileID: 1627701304546293694}
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 2995255283246636721, guid: 9e61581a97cfbf749ae174690343c731,
+    type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1102 &7731658760487074574
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: pao 3 0
+  m_Speed: 0.8
+  m_CycleOffset: 0
+  m_Transitions:
+  - {fileID: -5683795790671046343}
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 2995255283246636721, guid: 9e61581a97cfbf749ae174690343c731,
+    type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1102 &7927526774016616015
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: pose
+  m_Speed: 1
+  m_CycleOffset: 0
+  m_Transitions: []
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 1827226128182048838, guid: 9e61581a97cfbf749ae174690343c731,
+    type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1102 &7969560249966770103
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: pao 3 0 0 0 0 0 0 0 0
+  m_Speed: 0.8
+  m_CycleOffset: 0
+  m_Transitions:
+  - {fileID: -6452371527825091772}
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 2995255283246636721, guid: 9e61581a97cfbf749ae174690343c731,
+    type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1101 &8987798597038341299
+AnimatorStateTransition:
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_Conditions: []
+  m_DstStateMachine: {fileID: 0}
+  m_DstState: {fileID: 7969560249966770103}
+  m_Solo: 0
+  m_Mute: 0
+  m_IsExit: 0
+  serializedVersion: 3
+  m_TransitionDuration: 0
+  m_TransitionOffset: 0.009587654
+  m_ExitTime: 1
+  m_HasExitTime: 1
+  m_HasFixedDuration: 1
+  m_InterruptionSource: 0
+  m_OrderedInterruption: 1
+  m_CanTransitionToSelf: 1

Assets/Model/ma222.controller.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: cbe792c4c981b6b4b9028cc9d9b2729d
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 9100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Model/ma222.fbx.meta

@@ -0,0 +1,191 @@
+fileFormatVersion: 2
+guid: 9e61581a97cfbf749ae174690343c731
+ModelImporter:
+  serializedVersion: 26
+  internalIDToNameTable:
+  - first:
+      74: 1827226128182048838
+    second: pose
+  - first:
+      74: -7981952544716469480
+    second: donghua
+  - first:
+      74: 2995255283246636721
+    second: pao
+  externalObjects: {}
+  materials:
+    importMaterials: 1
+    materialName: 0
+    materialSearch: 1
+    materialLocation: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    resampleCurves: 1
+    optimizeGameObjects: 0
+    motionNodeName: 
+    rigImportErrors: 
+    rigImportWarnings: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    importAnimatedCustomProperties: 0
+    importConstraints: 0
+    animationCompression: 1
+    animationRotationError: 0.5
+    animationPositionError: 0.5
+    animationScaleError: 0.5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    extraUserProperties: []
+    clipAnimations:
+    - serializedVersion: 16
+      name: pose
+      takeName: Take 001
+      internalID: 0
+      firstFrame: 1
+      lastFrame: 1
+      wrapMode: 0
+      orientationOffsetY: 0
+      level: 0
+      cycleOffset: 0
+      loop: 0
+      hasAdditiveReferencePose: 0
+      loopTime: 0
+      loopBlend: 0
+      loopBlendOrientation: 0
+      loopBlendPositionY: 0
+      loopBlendPositionXZ: 0
+      keepOriginalOrientation: 0
+      keepOriginalPositionY: 1
+      keepOriginalPositionXZ: 0
+      heightFromFeet: 0
+      mirror: 0
+      bodyMask: 01000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000
+      curves: []
+      events: []
+      transformMask: []
+      maskType: 3
+      maskSource: {instanceID: 0}
+      additiveReferencePoseFrame: 0
+    - serializedVersion: 16
+      name: donghua
+      takeName: Take 001
+      internalID: 0
+      firstFrame: 1
+      lastFrame: 142
+      wrapMode: 0
+      orientationOffsetY: 0
+      level: 0
+      cycleOffset: 0
+      loop: 0
+      hasAdditiveReferencePose: 0
+      loopTime: 0
+      loopBlend: 0
+      loopBlendOrientation: 0
+      loopBlendPositionY: 0
+      loopBlendPositionXZ: 0
+      keepOriginalOrientation: 0
+      keepOriginalPositionY: 1
+      keepOriginalPositionXZ: 0
+      heightFromFeet: 0
+      mirror: 0
+      bodyMask: 01000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000
+      curves: []
+      events: []
+      transformMask: []
+      maskType: 3
+      maskSource: {instanceID: 0}
+      additiveReferencePoseFrame: 0
+    - serializedVersion: 16
+      name: pao
+      takeName: Take 001
+      internalID: 0
+      firstFrame: 143
+      lastFrame: 156
+      wrapMode: 0
+      orientationOffsetY: 0
+      level: 0
+      cycleOffset: 0
+      loop: 0
+      hasAdditiveReferencePose: 0
+      loopTime: 0
+      loopBlend: 0
+      loopBlendOrientation: 0
+      loopBlendPositionY: 0
+      loopBlendPositionXZ: 0
+      keepOriginalOrientation: 0
+      keepOriginalPositionY: 1
+      keepOriginalPositionXZ: 0
+      heightFromFeet: 0
+      mirror: 0
+      bodyMask: 01000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000
+      curves: []
+      events: []
+      transformMask: []
+      maskType: 3
+      maskSource: {instanceID: 0}
+      additiveReferencePoseFrame: 0
+    isReadable: 0
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 1
+    meshCompression: 0
+    addColliders: 0
+    useSRGBMaterialColor: 1
+    sortHierarchyByName: 1
+    importVisibility: 1
+    importBlendShapes: 1
+    importCameras: 1
+    importLights: 1
+    swapUVChannels: 0
+    generateSecondaryUV: 0
+    useFileUnits: 1
+    keepQuads: 0
+    weldVertices: 1
+    preserveHierarchy: 0
+    skinWeightsMode: 0
+    maxBonesPerVertex: 4
+    minBoneWeight: 0.001
+    meshOptimizationFlags: -1
+    indexFormat: 0
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVPackMargin: 4
+    useFileScale: 1
+  tangentSpace:
+    normalSmoothAngle: 60
+    normalImportMode: 0
+    tangentImportMode: 3
+    normalCalculationMode: 4
+    legacyComputeAllNormalsFromSmoothingGroupsWhenMeshHasBlendShapes: 0
+    blendShapeNormalImportMode: 1
+    normalSmoothingSource: 0
+  referencedClips: []
+  importAnimation: 1
+  copyAvatar: 0
+  humanDescription:
+    serializedVersion: 3
+    human: []
+    skeleton: []
+    armTwist: 0.5
+    foreArmTwist: 0.5
+    upperLegTwist: 0.5
+    legTwist: 0.5
+    armStretch: 0.05
+    legStretch: 0.05
+    feetSpacing: 0
+    globalScale: 1
+    rootMotionBoneName: 
+    hasTranslationDoF: 0
+    hasExtraRoot: 0
+    skeletonHasParents: 1
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  animationType: 2
+  humanoidOversampling: 1
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d3e38fae90ff1ff4a89beab0656ade4f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/(can be deleted) Example Scene.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 149a7cb3a0353b04bbb33f8fb1d68e74
+folderAsset: yes
+timeCreated: 1536038961
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/(can be deleted) Example Scene/RadialBar.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 415bde91cd1a58643a4240e299585e32
+timeCreated: 1536039006
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/(can be deleted) Example Scene/RadialBar.unity

@@ -0,0 +1,433 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!29 &1
+OcclusionCullingSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_OcclusionBakeSettings:
+    smallestOccluder: 5
+    smallestHole: 0.25
+    backfaceThreshold: 100
+  m_SceneGUID: 00000000000000000000000000000000
+  m_OcclusionCullingData: {fileID: 0}
+--- !u!104 &2
+RenderSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 8
+  m_Fog: 0
+  m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  m_FogMode: 3
+  m_FogDensity: 0.01
+  m_LinearFogStart: 0
+  m_LinearFogEnd: 300
+  m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
+  m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
+  m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
+  m_AmbientIntensity: 1
+  m_AmbientMode: 0
+  m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
+  m_SkyboxMaterial: {fileID: 10304, guid: 0000000000000000f000000000000000, type: 0}
+  m_HaloStrength: 0.5
+  m_FlareStrength: 1
+  m_FlareFadeSpeed: 3
+  m_HaloTexture: {fileID: 0}
+  m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
+  m_DefaultReflectionMode: 0
+  m_DefaultReflectionResolution: 128
+  m_ReflectionBounces: 1
+  m_ReflectionIntensity: 1
+  m_CustomReflection: {fileID: 0}
+  m_Sun: {fileID: 0}
+  m_IndirectSpecularColor: {r: 0, g: 0, b: 0, a: 1}
+--- !u!157 &3
+LightmapSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 11
+  m_GIWorkflowMode: 0
+  m_GISettings:
+    serializedVersion: 2
+    m_BounceScale: 1
+    m_IndirectOutputScale: 1
+    m_AlbedoBoost: 1
+    m_TemporalCoherenceThreshold: 1
+    m_EnvironmentLightingMode: 0
+    m_EnableBakedLightmaps: 1
+    m_EnableRealtimeLightmaps: 1
+  m_LightmapEditorSettings:
+    serializedVersion: 9
+    m_Resolution: 2
+    m_BakeResolution: 40
+    m_TextureWidth: 1024
+    m_TextureHeight: 1024
+    m_AO: 0
+    m_AOMaxDistance: 1
+    m_CompAOExponent: 0
+    m_CompAOExponentDirect: 0
+    m_Padding: 2
+    m_LightmapParameters: {fileID: 0}
+    m_LightmapsBakeMode: 1
+    m_TextureCompression: 1
+    m_FinalGather: 0
+    m_FinalGatherFiltering: 1
+    m_FinalGatherRayCount: 1024
+    m_ReflectionCompression: 2
+    m_MixedBakeMode: 1
+    m_BakeBackend: 0
+    m_PVRSampling: 1
+    m_PVRDirectSampleCount: 32
+    m_PVRSampleCount: 500
+    m_PVRBounces: 2
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
+    m_PVRFilteringMode: 1
+    m_PVRCulling: 1
+    m_PVRFilteringGaussRadiusDirect: 1
+    m_PVRFilteringGaussRadiusIndirect: 5
+    m_PVRFilteringGaussRadiusAO: 2
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
+    m_ShowResolutionOverlay: 1
+  m_LightingDataAsset: {fileID: 0}
+  m_UseShadowmask: 1
+--- !u!196 &4
+NavMeshSettings:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_BuildSettings:
+    serializedVersion: 2
+    agentTypeID: 0
+    agentRadius: 0.5
+    agentHeight: 2
+    agentSlope: 45
+    agentClimb: 0.4
+    ledgeDropHeight: 0
+    maxJumpAcrossDistance: 0
+    minRegionArea: 2
+    manualCellSize: 0
+    cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
+    accuratePlacement: 0
+    debug:
+      m_Flags: 0
+  m_NavMeshData: {fileID: 0}
+--- !u!1 &834247932
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 834247935}
+  - component: {fileID: 834247934}
+  - component: {fileID: 834247933}
+  - component: {fileID: 834247936}
+  m_Layer: 0
+  m_Name: RadialBar Point Cache Player
+  m_TagString: Untagged
+  m_Icon: {fileID: -3545028842045912814, guid: 0000000000000000d000000000000000, type: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &834247933
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 834247932}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 869b6c025d4cd344493378b931062b64, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  UseTimescale: 1
+  UpdateMode: 1
+  ActiveMesh: 0
+  MCollider: {fileID: 0}
+  ColliderMesh: {fileID: 0}
+  Clips:
+  - Idx: 0
+    Player: {fileID: 834247933}
+    AutoPlaybackType: 0
+    DurationInSeconds: 1
+    DrawMotionPath: 0
+    MotionPathIconSize: 0.1
+  - Idx: 1
+    Player: {fileID: 834247933}
+    AutoPlaybackType: 0
+    DurationInSeconds: 1
+    DrawMotionPath: 0
+    MotionPathIconSize: 0.1
+  - Idx: 2
+    Player: {fileID: 834247933}
+    AutoPlaybackType: 0
+    DurationInSeconds: 1
+    DrawMotionPath: 0
+    MotionPathIconSize: 0.1
+  - Idx: 3
+    Player: {fileID: 834247933}
+    AutoPlaybackType: 0
+    DurationInSeconds: 1
+    DrawMotionPath: 0
+    MotionPathIconSize: 0.1
+  - Idx: 4
+    Player: {fileID: 834247933}
+    AutoPlaybackType: 0
+    DurationInSeconds: 1
+    DrawMotionPath: 0
+    MotionPathIconSize: 0.1
+  - Idx: 5
+    Player: {fileID: 834247933}
+    AutoPlaybackType: 0
+    DurationInSeconds: 1
+    DrawMotionPath: 0
+    MotionPathIconSize: 0.1
+  - Idx: 6
+    Player: {fileID: 834247933}
+    AutoPlaybackType: 0
+    DurationInSeconds: 1
+    DrawMotionPath: 0
+    MotionPathIconSize: 0.1
+  - Idx: 7
+    Player: {fileID: 834247933}
+    AutoPlaybackType: 0
+    DurationInSeconds: 1
+    DrawMotionPath: 0
+    MotionPathIconSize: 0.1
+  Clip0NormalizedTime: 0.75454015
+  Clip0Weight: 1
+  Clip1NormalizedTime: 0
+  Clip1Weight: 0
+  Clip2NormalizedTime: 0
+  Clip2Weight: 0
+  Clip3NormalizedTime: 0
+  Clip3Weight: 0
+  Clip4NormalizedTime: 0
+  Clip4Weight: 0
+  Clip5NormalizedTime: 0
+  Clip5Weight: 0
+  Clip6NormalizedTime: 0
+  Clip6Weight: 0
+  Clip7NormalizedTime: 0
+  Clip7Weight: 0
+  pointCache: {fileID: 11400000, guid: 415bde91cd1a58643a4240e299585e32, type: 2}
+  smr: {fileID: 834247934}
+  Constraints: []
+  DrawMeshGizmo: 0
+--- !u!137 &834247934
+SkinnedMeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 834247932}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_Materials:
+  - {fileID: 2192310, guid: 415bde91cd1a58643a4240e299585e32, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  serializedVersion: 2
+  m_Quality: 0
+  m_UpdateWhenOffscreen: 0
+  m_SkinnedMotionVectors: 1
+  m_Mesh: {fileID: 4382032, guid: 415bde91cd1a58643a4240e299585e32, type: 2}
+  m_Bones: []
+  m_BlendShapeWeights:
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 85.471535
+  - 14.528465
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  - 0
+  m_RootBone: {fileID: 0}
+  m_AABB:
+    m_Center: {x: 0.0000076293945, y: 0.000015258789, z: 0}
+    m_Extent: {x: 60.108566, y: 60.108597, z: 13.44366}
+  m_DirtyAABB: 0
+--- !u!4 &834247935
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 834247932}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!95 &834247936
+Animator:
+  serializedVersion: 3
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 834247932}
+  m_Enabled: 1
+  m_Avatar: {fileID: 0}
+  m_Controller: {fileID: 9100000, guid: 7fd9c795af583c54fb57f9c1bfdbd4af, type: 2}
+  m_CullingMode: 0
+  m_UpdateMode: 0
+  m_ApplyRootMotion: 0
+  m_LinearVelocityBlending: 0
+  m_WarningMessage: 
+  m_HasTransformHierarchy: 1
+  m_AllowConstantClipSamplingOptimization: 1
+--- !u!1 &1205350534
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1205350536}
+  - component: {fileID: 1205350535}
+  m_Layer: 0
+  m_Name: Directional Light
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!108 &1205350535
+Light:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1205350534}
+  m_Enabled: 1
+  serializedVersion: 8
+  m_Type: 1
+  m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1}
+  m_Intensity: 1
+  m_Range: 10
+  m_SpotAngle: 30
+  m_CookieSize: 10
+  m_Shadows:
+    m_Type: 2
+    m_Resolution: -1
+    m_CustomResolution: -1
+    m_Strength: 1
+    m_Bias: 0.05
+    m_NormalBias: 0.4
+    m_NearPlane: 0.2
+  m_Cookie: {fileID: 0}
+  m_DrawHalo: 0
+  m_Flare: {fileID: 0}
+  m_RenderMode: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_Lightmapping: 4
+  m_AreaSize: {x: 1, y: 1}
+  m_BounceIntensity: 1
+  m_ColorTemperature: 6570
+  m_UseColorTemperature: 0
+  m_ShadowRadius: 0
+  m_ShadowAngle: 0
+--- !u!4 &1205350536
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1205350534}
+  m_LocalRotation: {x: 0.40821794, y: -0.23456973, z: 0.109381676, w: 0.87542605}
+  m_LocalPosition: {x: -367.2, y: 3, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1965288491
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1965288493}
+  - component: {fileID: 1965288492}
+  m_Layer: 0
+  m_Name: Move Me!
+  m_TagString: Untagged
+  m_Icon: {fileID: -3545028842045912814, guid: 0000000000000000d000000000000000, type: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &1965288492
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1965288491}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: e94ada2d297fdad48b5a5e29bd97931e, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  pcplayer: {fileID: 834247933}
+--- !u!4 &1965288493
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1965288491}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: -77.1, y: 2.2, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 2
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}

Assets/Plugins/VertexAnimationTools_30/(can be deleted) Example Scene/RadialBar.unity.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 394f3a700716f9b4581e71b964f4b2ce
+timeCreated: 1536042011
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/(can be deleted) Example Scene/RadialBarController.cs

@@ -0,0 +1,16 @@
+using UnityEngine;
+using System.Collections;
+using VertexAnimationTools_30;
+
+namespace VertexAnimationTools_Examples {
+    [ExecuteInEditMode]
+    public class RadialBarController : MonoBehaviour {
+        public PointCachePlayer pcplayer;
+
+        void Update() {
+            Vector3 lp = pcplayer.transform.worldToLocalMatrix.MultiplyPoint3x4(transform.position);
+            pcplayer.Clip0NormalizedTime = Mathf.Atan2(-lp.x, -lp.y) * Mathf.Rad2Deg / 360f + 0.5f;
+            Debug.DrawLine(pcplayer.transform.position, pcplayer.transform.localToWorldMatrix.MultiplyPoint3x4(new Vector3(lp.x, lp.y, 0) ), Color.red);
+        }
+    }
+}

Assets/Plugins/VertexAnimationTools_30/(can be deleted) Example Scene/RadialBarController.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e94ada2d297fdad48b5a5e29bd97931e
+timeCreated: 1536039399
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/Editor.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: badcbcabe3d65324895b9ea618c0be56
+folderAsset: yes
+timeCreated: 1497330591
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/Editor/InspectorsBase.cs

@@ -0,0 +1,329 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace VertexAnimationTools_30 {
+
+    public class InspectorsBase : Editor {
+        internal GUIContent[] MeshCompressionNames = new GUIContent[4] { new GUIContent("Off"), new GUIContent("Low"), new GUIContent("Medium"), new GUIContent("High") };
+        internal int[] MeshCompressionIndeces = new int[4] { 0, 1, 2, 3 };
+        internal GUIContent s_meshCompression = new GUIContent("Mesh compression", "Mesh compression settings. Comperessing meshes saves space in the built game, but more compression introduces more artifacts in vertex data");
+        internal SerializedProperty prp_meshCompression;
+
+        internal GUIContent s_clipNormalizedTime = new GUIContent("Normalized Time", "The time percentage of overall clip length. The Auto Playback Mode set how this value will be changed on Play mode. This property is animable");
+        internal GUIContent s_clipWeight = new GUIContent("Weight", "The weight of point cache clip. Used for clips blending and transitions. This property is animable");
+
+        internal GUIContent s_clipPlaybackMode = new GUIContent("Auto Playback", "Simple animators for NormalizedTime value. Works only on Play mode. Select None when updated manually, or by script, or by custom Animation ");
+        internal SerializedProperty prp_clipPlaybackMode;
+
+        internal GUIContent s_playerUpdateMode = new GUIContent("Update Order", "Event Function used for execution. Select Manually in case player updated by by code by call UpdatePlayback() method");
+        internal SerializedProperty prp_playerUpdateMode;
+
+        internal GUIContent s_normalizedTime = new GUIContent("Normalized time", "Normalized time of the animation");
+        internal SerializedProperty prp_normalizedTime;
+
+        internal GUIContent s_useTimescale = new GUIContent("Use Time Scale", "When enabled, Time.timeScale affects the speed of Auto Playback, otherwise it does not.");
+        internal SerializedProperty prp_useTimescale;
+
+        internal GUIContent s_importButton = new GUIContent("Import", "Import");
+        internal GUIContent s_importButtonRequireReimport = new GUIContent("Import", "Import (require re-import)");
+
+        internal GUIContent s_importCustomRange = new GUIContent("Import custom range", "When off, all frames will be exported, otherwise selected range only");
+        internal SerializedProperty prp_importCustomRange;
+        internal SerializedProperty prp_importFrom;
+        internal SerializedProperty prp_importTo;
+        internal SerializedProperty prp_filesSortMode;
+
+        internal GUIContent s_filesSortMode = new GUIContent("Sort mode", "Sorting mode for obj files sequence");
+        internal GUIContent s_TransitionMode = new GUIContent("Transition", "Controls copying selected frames range outside Import Custom Range into it using dissolve. Suitable to making seamless loop transition. ");
+
+        internal GUIContent s_TransitionLengthBegin = new GUIContent("Frames count", "Begin transition length. Cannot be longer than custom clip`s length");
+        internal GUIContent s_TransitionLengthEnd = new GUIContent("Frames count", "End transition length. Cannot be longer than custom clip`s length");
+
+        internal GUIContent s_DrawMotionPath = new GUIContent("Draw motion path", "Displays motion paths gizmos for vertices wich defined in Import/Generate Path/Index Step.");
+        internal GUIContent s_MotionPathIconSize = new GUIContent("Icon size", "Size of motion path icons.");
+
+        internal GUIContent s_swapYZAxis = new GUIContent("Swap YZ", "Swap Y and Z axis of coorinates. Suitable when model has Z axis aligned to up direction");
+        internal SerializedProperty prp_swapYZAxis;
+
+        internal GUIContent s_pivotOffset = new GUIContent("Pivot offset", "Offset model about its local coordinates");
+        internal SerializedProperty prp_pivotOffset;
+
+        internal GUIContent s_scaleFactor = new GUIContent("Scale", "Scale model about its local coordinates");
+        internal SerializedProperty prp_scaleFactor;
+
+        internal GUIContent s_flipNormals = new GUIContent("Flip Normals", "When On, reverse the direction of all surface normals of the mesh");
+        internal SerializedProperty prp_flipNormals;
+
+        internal SerializedProperty prp_generateMaterials;
+        internal GUIContent s_generateMaterials = new GUIContent("Generate materials", "When On, materials will be created and applied. Set Off if you planned to set materials manually in Renderer component.");
+
+        internal SerializedProperty prp_smoothingGroupImportMode;
+        internal GUIContent s_smoothingGroupImportMode = new GUIContent("Smoothing groups", "Controls how smoothing groups is applied to a mesh");
+
+        internal SerializedProperty prp_normalRecalculationMode;
+        internal GUIContent s_normalRecalculationMode = new GUIContent("Normals", "Defines how the mesh normals are calculated.");
+
+        internal SerializedProperty prp_savePortableData;
+        internal GUIContent s_savePortableData = new GUIContent("Save Portable Data", "Saves Meshes as .mesh and  Clips as .anim assets");
+
+        internal GUIContent s_brightIcons = new GUIContent("Bright icons", "Enables bright inspector icons");
+
+#if UNITY_2017_3_OR_NEWER
+        internal SerializedProperty prp_IndexFormat;
+        internal GUIContent s_IndexFormat = new GUIContent("Index format", "Format of the mesh index buffer data. Index buffer can either be 16 bit (supports up to 65535 vertices in a mesh, takes less memory and bandwidth), or 32 bit (supports up to 4 billion vertices).");
+#endif
+        internal SerializedProperty prp_OptimizeMesh;
+        internal GUIContent s_OptimizeMesh = new GUIContent("Optimize mesh", "This option might take a while but will make the geometry displayed be faster.");
+
+        static EditorResourcesHolderSO _resourceHolder;
+        public static EditorResourcesHolderSO ResourceHolder {
+            get {
+                if (_resourceHolder == null) {
+                    string[] result = UnityEditor.AssetDatabase.FindAssets("pc2unityResourcesHolder");
+
+                    if (result != null && result.Length > 0) {
+                        string path = AssetDatabase.GUIDToAssetPath(result[0]);
+                        _resourceHolder = (EditorResourcesHolderSO)AssetDatabase.LoadAssetAtPath(path, typeof(EditorResourcesHolderSO));
+                    }
+                }
+                return _resourceHolder;
+            }
+        }
+
+        internal List<Vector3[]> GizmoAxisPoints;
+
+        bool _brightIcons;
+        protected bool brightIcons {
+            get {
+                return _brightIcons;
+            }
+
+            set {
+                if (value != _brightIcons) {
+                    _brightIcons = value;
+                    EditorPrefs.SetBool("pc2unityBrightIcons", _brightIcons);
+                     
+                }
+            }
+        }
+
+        Vector3 qv(float xy, float z, int idx) {
+            int[] signMask = new int[8] { -1, -1, -1, 1, 1, 1, 1, -1 };
+            return new Vector3(xy * signMask[idx * 2], xy * signMask[idx * 2 + 1], z);
+        }
+
+        internal void OnEnableBase() {
+            _brightIcons = EditorPrefs.GetBool("pc2unityBrightIcons", false);
+            s_importButtonRequireReimport.image = IsDarkTheme ? ResourceHolder.RequireReimportDark : ResourceHolder.RequireReimportLight;
+            GizmoAxisPoints = new List<Vector3[]>();
+            GizmoAxisPoints.Add(new Vector3[3] { new Vector3(0, 0, 0), qv(1, 2, 0), qv(1, 2, 1) });
+            GizmoAxisPoints.Add(new Vector3[3] { new Vector3(0, 0, 0), qv(1, 2, 1), qv(1, 2, 2) });
+            GizmoAxisPoints.Add(new Vector3[3] { new Vector3(0, 0, 0), qv(1, 2, 2), qv(1, 2, 3) });
+            GizmoAxisPoints.Add(new Vector3[3] { new Vector3(0, 0, 0), qv(1, 2, 3), qv(1, 2, 0) });
+
+            GizmoAxisPoints.Add(new Vector3[4] { qv(1, 2, 0), qv(1, 2, 1), qv(1, 14, 1), qv(1, 14, 0) });
+            GizmoAxisPoints.Add(new Vector3[4] { qv(1, 2, 1), qv(1, 2, 2), qv(1, 14, 2), qv(1, 14, 1) });
+            GizmoAxisPoints.Add(new Vector3[4] { qv(1, 2, 2), qv(1, 2, 3), qv(1, 14, 3), qv(1, 14, 2) });
+            GizmoAxisPoints.Add(new Vector3[4] { qv(1, 2, 3), qv(1, 2, 0), qv(1, 14, 0), qv(1, 14, 3) });
+
+            GizmoAxisPoints.Add(new Vector3[4] { qv(1, 14, 0), qv(1, 14, 1), qv(2, 14, 1), qv(2, 14, 0) });
+            GizmoAxisPoints.Add(new Vector3[4] { qv(1, 14, 1), qv(1, 14, 2), qv(2, 14, 2), qv(2, 14, 1) });
+            GizmoAxisPoints.Add(new Vector3[4] { qv(1, 14, 2), qv(1, 14, 3), qv(2, 14, 3), qv(2, 14, 2) });
+            GizmoAxisPoints.Add(new Vector3[4] { qv(1, 14, 3), qv(1, 14, 0), qv(2, 14, 0), qv(2, 14, 3) });
+
+            GizmoAxisPoints.Add(new Vector3[3] { qv(0, 18, 0), qv(2, 14, 1), qv(2, 14, 0) });
+            GizmoAxisPoints.Add(new Vector3[3] { qv(0, 18, 1), qv(2, 14, 2), qv(2, 14, 1) });
+            GizmoAxisPoints.Add(new Vector3[3] { qv(0, 18, 2), qv(2, 14, 3), qv(2, 14, 2) });
+            GizmoAxisPoints.Add(new Vector3[3] { qv(0, 18, 3), qv(2, 14, 0), qv(2, 14, 3) });
+
+        }
+
+        internal string GetResentDirectory() {
+            string cachedDirectoryPath = EditorPrefs.GetString("pc2unityLastOpenedDirectory");
+            if (!System.IO.Directory.Exists(cachedDirectoryPath)) {
+                cachedDirectoryPath = EditorPrefs.GetString("pc2unityLastOpenedDirectoryParent");
+            }
+            return cachedDirectoryPath;
+        }
+
+        internal void SetResentDirectory(string filePath) {
+            EditorPrefs.SetString("pc2unityLastOpenedDirectory", new System.IO.FileInfo(filePath).Directory.FullName);
+            EditorPrefs.SetString("pc2unityLastOpenedDirectoryParent", new System.IO.FileInfo(filePath).Directory.Parent.FullName);
+        }
+
+        public void DrawHandleAxis(Color c) {
+            Handles.color = new Color(c.r, c.g, c.b, 0.25f);
+            Handles.DrawAAConvexPolygon(GizmoAxisPoints[0]);
+            Handles.DrawAAConvexPolygon(GizmoAxisPoints[1]);
+            Handles.DrawAAConvexPolygon(GizmoAxisPoints[2]);
+            Handles.DrawAAConvexPolygon(GizmoAxisPoints[3]);
+            Handles.DrawAAConvexPolygon(GizmoAxisPoints[4]);
+            Handles.DrawAAConvexPolygon(GizmoAxisPoints[5]);
+            Handles.DrawAAConvexPolygon(GizmoAxisPoints[6]);
+            Handles.DrawAAConvexPolygon(GizmoAxisPoints[7]);
+            Handles.DrawAAConvexPolygon(GizmoAxisPoints[8]);
+            Handles.DrawAAConvexPolygon(GizmoAxisPoints[9]);
+            Handles.DrawAAConvexPolygon(GizmoAxisPoints[10]);
+            Handles.DrawAAConvexPolygon(GizmoAxisPoints[11]);
+            Handles.DrawAAConvexPolygon(GizmoAxisPoints[12]);
+            Handles.DrawAAConvexPolygon(GizmoAxisPoints[13]);
+            Handles.DrawAAConvexPolygon(GizmoAxisPoints[14]);
+            Handles.DrawAAConvexPolygon(GizmoAxisPoints[15]);
+
+            Handles.color = new Color(c.r, c.g, c.b, 0.5f);
+            Handles.DrawPolyLine(GizmoAxisPoints[0]);
+            Handles.DrawPolyLine(GizmoAxisPoints[1]);
+            Handles.DrawPolyLine(GizmoAxisPoints[2]);
+            Handles.DrawPolyLine(GizmoAxisPoints[3]);
+            Handles.DrawPolyLine(GizmoAxisPoints[4]);
+            Handles.DrawPolyLine(GizmoAxisPoints[5]);
+            Handles.DrawPolyLine(GizmoAxisPoints[6]);
+            Handles.DrawPolyLine(GizmoAxisPoints[7]);
+            Handles.DrawPolyLine(GizmoAxisPoints[12]);
+            Handles.DrawPolyLine(GizmoAxisPoints[13]);
+            Handles.DrawPolyLine(GizmoAxisPoints[14]);
+            Handles.DrawPolyLine(GizmoAxisPoints[15]);
+        }
+
+        public void DrawTM(Matrix4x4 tm, float scale) {
+            Matrix4x4 original = Handles.matrix;
+            float size = HandleUtility.GetHandleSize(tm.GetColumn(3)) * scale * 0.01f;
+
+            Vector4 x = tm.GetColumn(0) * size;
+            Vector4 y = tm.GetColumn(1) * size;
+            Vector4 z = tm.GetColumn(2) * size;
+
+            tm.SetColumn(0, x);
+            tm.SetColumn(1, y);
+            tm.SetColumn(2, z);
+            Handles.matrix = tm;
+            DrawHandleAxis(Color.blue);
+
+            tm.SetColumn(0, z);
+            tm.SetColumn(1, y);
+            tm.SetColumn(2, x);
+            Handles.matrix = tm;
+            DrawHandleAxis(Color.red);
+
+            tm.SetColumn(0, x);
+            tm.SetColumn(1, z);
+            tm.SetColumn(2, y);
+            Handles.matrix = tm;
+            DrawHandleAxis(Color.green);
+            Handles.matrix = original;
+        }
+
+        public static Object AddToAsset(Object asset, Object assetToAdd) {
+            if (assetToAdd == null) {
+                Debug.LogError("Trying to add null object");
+                return null;
+            }
+
+            Object[] existing = AssetDatabase.LoadAllAssetsAtPath(AssetDatabase.GetAssetPath(asset));
+            for (int i = 0; i < existing.Length; i++) {
+                if (existing[i] == assetToAdd) {
+                    return existing[i];
+                }
+            }
+            AssetDatabase.AddObjectToAsset(assetToAdd, asset);
+            return AddToAsset(asset, assetToAdd);
+        }
+
+        internal bool IsDarkTheme {
+            get {
+                return brightIcons ||  PlayerSettings.advancedLicense;
+            }
+        }
+
+        internal GUIStyle FoldoutToggleStyle {
+            get {
+                return IsDarkTheme ? ResourceHolder.FoldoutToggleDark : ResourceHolder.FoldoutToggle;
+            }
+        }
+
+        GUIStyle quadButtonStyle;
+        internal GUIStyle QuadButtonStyle{
+            get {
+                return ResourceHolder.QuadIconButtonStyle;
+            }
+        }
+
+        GUIStyle boldLabelStyle;
+        internal GUIStyle BoldLabelStyle {
+            get {
+                if (boldLabelStyle == null) {
+                    boldLabelStyle = new GUIStyle(EditorStyles.boldLabel);
+                }
+                return boldLabelStyle;
+            }
+        }
+
+        GUIStyle labelStyle;
+        internal GUIStyle LabelStyle {
+            get {
+ 
+                if (labelStyle == null) {
+                    labelStyle = new GUIStyle(EditorStyles.label);
+                }
+                return labelStyle;
+            }
+        }
+
+        internal Texture2D AddButtonTexture {
+            get {
+                return IsDarkTheme? ResourceHolder.AddDark: ResourceHolder.AddLight;
+            }
+        }
+
+        internal Texture2D RemoveButtonTexture {
+            get {
+                return IsDarkTheme ? ResourceHolder.RemoveDark : ResourceHolder.RemoveLight;
+            }
+        }
+
+        internal Texture2D RefreshButtonTexture {
+            get {
+                return IsDarkTheme ? ResourceHolder.RefreshDark : ResourceHolder.RefreshLight;
+            }
+        }
+
+        internal Texture2D GraphBackgroundTexture {
+            get {
+                return IsDarkTheme ? ResourceHolder.Graph0101BackgroundDark : ResourceHolder.Graph0101BackgroundLight;
+            }
+        }
+
+        public static void CleanupAsset (Object asset, List<Object> usedObjects ) {
+            string existingPath = AssetDatabase.GetAssetPath(asset);
+            Object[] existing = AssetDatabase.LoadAllAssetsAtPath(existingPath);
+            List<Object> toDelete = new List<Object>();
+
+            for (int i = 0; i < existing.Length; i++) {
+                Object obj = existing[i];
+
+                if (obj == asset) {
+                    continue;
+                }
+                    
+                bool isUsed = false;
+                for (int u = 0; u < usedObjects.Count; u++) {
+                     if (usedObjects[u] == obj) {
+                           isUsed = true;
+                           break;
+                     }
+                }
+
+                 if (isUsed == false) {
+                      toDelete.Add(obj);
+                 }
+            }
+
+            for (int i = 0; i<toDelete.Count; i++) {
+                DestroyImmediate(toDelete[i], true);
+            }
+
+         }
+    }
+}

Assets/Plugins/VertexAnimationTools_30/Editor/InspectorsBase.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 47931d58c8ee1064f8227372541ecbbf
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/Editor/MeshSequenceInspector.cs

@@ -0,0 +1,115 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+using VertexAnimationTools_30;
+using UnityEditor.AnimatedValues;
+using UnityEditor.ProjectWindowCallback;
+using System.IO;
+using UnityEditorInternal;
+
+namespace VertexAnimationTools_30{
+    [InitializeOnLoad]    
+	[CustomEditor(typeof(MeshSequence))]
+	public class MeshSequenceInspector : Editor {
+		static bool ShowDetailedFramesInfo;
+		AnimBool detailedFramesInfoAB;
+        static MeshSequence dragged;
+
+        void OnEnable(){
+            detailedFramesInfoAB = new AnimBool( ShowDetailedFramesInfo, Repaint); 
+		}
+
+		public override void OnInspectorGUI(){
+
+            GUIContent polyVertHeader = new GUIContent("poly | vert", "polygons and vertcses count of obj file");
+            GUIContent trisVertsHeader = new GUIContent("tris | vert", "triangles and vertcses count of Unity Mesh");
+            GUIContent submeshHeader = new GUIContent("submeshes", "Submeshes (Material IDs) count");
+
+            MeshSequence t = target as MeshSequence;
+            GUILayout.Label("Mesh Sequence Asset", EditorStyles.boldLabel);
+
+            if (t.FramesCount <= 0) {
+                EditorGUILayout.HelpBox(" 1) Create player \n 2) Set sources in Import Tab \n 3) Press Import button", MessageType.Info);
+            } else {
+                EditorGUI.indentLevel++;
+                EditorGUILayout.LabelField(string.Format("Imported {0} frames", t.FramesCount) );
+                EditorGUILayout.LabelField(string.Format("{0}-{1} vertices", t.SequenceVerticesCount.Min, t.SequenceVerticesCount.Max));
+                EditorGUILayout.LabelField(string.Format("{0}-{1} triangles", t.SequenceTrianglesCount.Min, t.SequenceTrianglesCount.Max));
+                EditorGUILayout.LabelField(string.Format("{0}-{1} obj vertices", t.SequenceObjVerticesCount.Min, t.SequenceObjVerticesCount.Max));
+                EditorGUILayout.LabelField(string.Format("{0}-{1} obj polygons", t.SequenceObjPolygonsCount.Min, t.SequenceObjPolygonsCount.Max));
+                EditorGUILayout.LabelField(string.Format("{0}-{1} submeshes", t.SequenceSubmeshesCount.Min, t.SequenceSubmeshesCount.Max));
+                GUILayout.Space(4);
+                EditorGUILayout.LabelField(string.Format("Directory: {0}", t.PostImport.MSI.DirectoryPath));
+                EditorGUILayout.LabelField(string.Format("Sequence: {0} , {1} files", t.PostImport.MSI.SequenceName, t.PostImport.MSI.Count) );
+                EditorGUILayout.LabelField(string.Format("Imported at: {0}", t.PostImport.ImportDate));
+                EditorGUILayout.LabelField(string.Format("Asset file size: {0} MB", t.AssetFileSize.ToString("F4")));
+
+                GUILayout.Space(4); 
+
+                ShowDetailedFramesInfo = EditorGUILayout.Foldout(ShowDetailedFramesInfo, "Show detailed frames info");
+                detailedFramesInfoAB.target = ShowDetailedFramesInfo;
+                
+                if (EditorGUILayout.BeginFadeGroup(detailedFramesInfoAB.faded)) {
+                    float nameWidth = 50;
+                    for (int f = 0; f < t.FramesCount; f++) {
+                        nameWidth = Mathf.Max(nameWidth, EditorStyles.label.CalcSize(new GUIContent(t[f].Name)).x);
+                    }
+                    nameWidth += 4;
+                    GUILayout.BeginHorizontal();
+                    EditorGUILayout.LabelField("Idx",  GUILayout.Width(40));
+                    EditorGUILayout.LabelField("obj name",   GUILayout.Width(164));
+                    EditorGUILayout.LabelField(polyVertHeader,   GUILayout.Width(120));
+                    EditorGUILayout.LabelField(trisVertsHeader,   GUILayout.Width(120));
+                    EditorGUILayout.LabelField(submeshHeader, GUILayout.Width(90));
+                    GUILayout.EndHorizontal();
+                    GUILayout.Space(4);
+
+ 
+                    for (int f = 0; f < t.FramesCount; f++) {
+                        GUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField(string.Format("#{0}", f.ToString()), GUILayout.Width(50));
+                        EditorGUILayout.LabelField(t[f].Name, GUILayout.Width(150));
+                        EditorGUILayout.LabelField(string.Format("{0} | {1}", t[f].ObjPolygonsCount, t[f].ObjVerticesCount), GUILayout.Width(120));
+                        EditorGUILayout.LabelField(string.Format("{0} | {1}", t[f].MeshTrisCount, t[f].MeshVertsCount), GUILayout.Width(120));
+                        EditorGUILayout.LabelField(string.Format("      {0} ", t[f].Materials==null? 0 : t[f].Materials.Length ), GUILayout.Width(100));
+                        GUILayout.EndHorizontal();
+                    }
+                }
+                EditorGUILayout.EndFadeGroup();
+                EditorGUI.indentLevel--;
+            }
+
+            GUILayout.Space(4);
+
+            if (GUILayout.Button("Create Mesh Sequence Player")) {
+                t.SpawnMeshSequencePlayer();
+            }
+           // DrawDefaultInspector();
+        }
+    }
+
+    public class ObjSequenceFactory{
+		    [MenuItem("Assets/Create/Vertex Animation Tools/Mesh Sequence", priority = 202)]
+		    static void MenuCreateMeshSequenceAsset(){
+ 				var icon = InspectorsBase.ResourceHolder.MeshSequenceIcon;
+ 				ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, ScriptableObject.CreateInstance<DoCreateMeshSequence>(), "MeshSequence.asset", icon, null);
+		    }
+
+			internal static MeshSequence CreateMeshSequenceAtPath(string path){
+		       var data = ScriptableObject.CreateInstance<MeshSequence>();
+		       data.name = Path.GetFileName(path);
+		       AssetDatabase.CreateAsset(data, path);
+               AssetDatabase.SaveAssets();
+               AssetDatabase.Refresh();
+               return data;
+		   }
+		}
+
+	class DoCreateMeshSequence : EndNameEditAction {
+		public override void Action(int instanceId, string pathName, string resourceFile){
+			MeshSequence data = ObjSequenceFactory.CreateMeshSequenceAtPath(pathName);
+		    ProjectWindowUtil.ShowCreatedAsset(data);
+	    }
+	}
+}

Assets/Plugins/VertexAnimationTools_30/Editor/MeshSequenceInspector.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: c84ccda542fb59b42926510665058e61
+timeCreated: 1521354138
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/Editor/MeshSequencePlayerInspector.cs

@@ -0,0 +1,401 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+ 
+using System.IO;
+ 
+
+namespace VertexAnimationTools_30{
+
+	[CanEditMultipleObjects]
+	[CustomEditor(typeof(MeshSequencePlayer)  )]
+	public sealed class MeshSequencePlayerInspector : InspectorsBase {
+
+		#region PLAYBACK_PROPERTIES
+		public SerializedObject so_player;
+		GUIContent s_sequence = new GUIContent("Mesh Sequence", "Shared Mesh Sequence asset");
+		public SerializedProperty prp_sequence;
+
+		GUIContent s_framesPerSeconds = new GUIContent("Frames per second", "Auto playback speed in frames per seconds");
+		public SerializedProperty prp_framesPerSeconds;
+
+		public SerializedProperty prp_tabChoise;
+ 		#endregion
+
+		#region IMPORT_PROPERTIES
+		static bool EnableAORadiusHandle;
+ 
+
+		SerializedObject so_sequence;
+
+        GUIContent s_updateSequenceInfo;
+
+        GUIContent s_importUV = new GUIContent("Enable UV", "Determines whether or not the UV coodinates should be imported (if exist) and applied to mesh. Must be enabled if shader use textures.");
+		SerializedProperty prp_importUV;
+
+		GUIContent s_calculateNormals = new GUIContent("Calculate normals", "When on, calculates mesh normals. Must be enabled for lit shaders");
+		SerializedProperty prp_calculateNormals;
+
+		GUIContent s_calculateTangents = new GUIContent("Calculate tangents", "When on, calculates mesh tangents. Tangents is required for normal-mapped shaders");
+		SerializedProperty prp_calculateTangents;
+
+		GUIContent s_vertexColor =  new GUIContent("Vertex color settings", "Generate a per vertex colors based on mesh surface. Not requared texture maps and UV attributes. Note that vertex color displaying requare shader that utilize it. There is simple vertex color shaders at 'custom/pc2unity'");
+
+		GUIContent s_cavity = new GUIContent("Cavity", "Generate a per vertex grayscale color alpha value that displays how convex or concave the surface of an mesh is at given point. The more concave the surface is the darker the vertex will be.");
+		SerializedProperty prp_cavity;
+
+		GUIContent s_cavityAngles = new GUIContent("Angles", "Determines how minimal concavity and maximal convexity angles in degrees is used to generate cavity effect");
+		SerializedProperty prp_cavityAngleMin;
+		SerializedProperty prp_cavityAngleMax;
+
+		GUIContent s_cavityAmount = new GUIContent("Amount", "Amount of cavity effect to use. At 1.0 cavity has its greatest effect; at 0 the cavity not visible at all");
+		SerializedProperty prp_cavityAmount;
+
+		GUIContent s_cavityBlur = new GUIContent("Blur Amount", "Determine how cavity effect is blurred or how it softened");
+		SerializedProperty prp_cavityBlur;
+		GUIContent s_cavityBlurIterations = new GUIContent("Blur iterations", "Sets the number of calculations used to blur cavity. More iterations leads to cavity affects more adjacent vertices.");
+		SerializedProperty prp_cavityBlurIterations;
+
+		GUIContent s_innerVertexOcclusion = new GUIContent("Inner Vertex Occlusion", "Generate a per vertex grayscale color alpha value that displays vertices within the mesh volume.");
+		SerializedProperty prp_innerVertexOcclusion;
+
+		GUIContent s_innerVertexOcclusionAmount = new GUIContent("Amount", "Amount of inner vertex occlusion effect to use ");
+		SerializedProperty prp_innerVertexOcclusionAmount;
+
+		GUIContent s_innerVertexOcclusionBlur = new GUIContent("Blur Amount", "Determine how Inner Vertex Occlusion effect is blurred or how it softened");
+		SerializedProperty prp_innerVertexOcclusionBlur;
+
+		GUIContent s_innerVertexOcclusionBlurIterations = new GUIContent("Blur iterations", "Sets the number of calculations used to blur Inner Vertex Occlusion effect. More iterations leads to Inner Vertex Occlusion affects more adjacent vertices.");
+		SerializedProperty prp_innerVertexOcclusionBlurIterations;
+
+		GUIContent s_ambientOcclusion = new GUIContent("Ambient Occlusion", "Ambient Occlusion is an  per vertex effect for emulating the look of true global illumination by using method that calculate the extend to wich area is occluded, or prevented from receiving incoming light"); 
+		SerializedProperty prp_ambientOcclusion;
+		SerializedProperty prp_ambientOcclusionAmount;
+
+		GUIContent s_ambientOcclusionRadius = new GUIContent("Radius", "Ambient Occlusion Radius defines the maximum distance within which looking for occluding surfaces. Smaller values restrict the AO effect."); 
+		SerializedProperty prp_ambientOcclusionRadius;
+		SerializedProperty prp_ambientOcclusionBlur;
+		SerializedProperty prp_ambientOcclusionBlurIterations;
+		SerializedProperty prp_ambientOcclusionQuality;
+
+		
+		#endregion
+
+		void CollectProperties(){
+			
+			so_player = new SerializedObject(targets);	
+			prp_clipPlaybackMode = so_player.FindProperty("PlaybackMode");
+            prp_playerUpdateMode = so_player.FindProperty("UpdateMode");
+			prp_framesPerSeconds = so_player.FindProperty("FramesPerSecond");
+			prp_normalizedTime = so_player.FindProperty("NormalizedTime");
+			prp_useTimescale = so_player.FindProperty("UseTimescale");
+			prp_tabChoise = so_player.FindProperty("TabChoise");
+			prp_sequence = so_player.FindProperty("meshSequence");
+
+			MeshSequence sequence = (target as MeshSequencePlayer).meshSequence;
+			if(sequence == null){
+				return;
+			}
+
+			so_sequence = new SerializedObject( sequence );
+			SerializedProperty prp_preImport = so_sequence.FindProperty( "PreImport" );
+            prp_filesSortMode = prp_preImport.FindPropertyRelative("FilesSortMode");
+            prp_importCustomRange = prp_preImport.FindPropertyRelative("ImportCustomRange");
+			prp_importFrom = prp_preImport.FindPropertyRelative("ImportFromFrame");
+			prp_importTo = prp_preImport.FindPropertyRelative("ImportToFrame");
+
+			prp_swapYZAxis = prp_preImport.FindPropertyRelative("SwapYZAxis");
+			prp_pivotOffset = prp_preImport.FindPropertyRelative("PivotOffset");
+			prp_scaleFactor = prp_preImport.FindPropertyRelative("ScaleFactor");
+
+			prp_flipNormals = prp_preImport.FindPropertyRelative("FlipNormals");
+
+			prp_importUV = prp_preImport.FindPropertyRelative("ImportUV");
+			prp_calculateNormals =  prp_preImport.FindPropertyRelative("CalculateNormals");
+			prp_calculateTangents = prp_preImport.FindPropertyRelative("CalculateTangents");
+			  
+			prp_smoothingGroupImportMode = prp_preImport.FindPropertyRelative("SmoothingGroupImportMode");
+			prp_normalRecalculationMode = prp_preImport.FindPropertyRelative("NormalRecalculationMode");
+			prp_meshCompression = prp_preImport.FindPropertyRelative("MeshCompression");
+            prp_OptimizeMesh = prp_preImport.FindPropertyRelative("OptimizeMesh");
+#if UNITY_2017_3_OR_NEWER
+            prp_IndexFormat = prp_preImport.FindPropertyRelative("IndexFormat");
+#endif
+            prp_generateMaterials = prp_preImport.FindPropertyRelative("GenerateMaterials");
+
+            SerializedProperty prp_VColorSettings = prp_preImport.FindPropertyRelative("VColorSettings");
+			prp_cavity = prp_VColorSettings.FindPropertyRelative("Cavity");
+			prp_cavityAmount = prp_VColorSettings.FindPropertyRelative("CavityAmount");
+			prp_cavityAngleMin = prp_VColorSettings.FindPropertyRelative("CavityAngleMin");
+			prp_cavityAngleMax = prp_VColorSettings.FindPropertyRelative("CavityAngleMax");
+			prp_cavityBlur = prp_VColorSettings.FindPropertyRelative("CavityBlur");
+			prp_cavityBlurIterations = prp_VColorSettings.FindPropertyRelative("CavityBlurIterations");
+
+			prp_innerVertexOcclusion = prp_VColorSettings.FindPropertyRelative("InnerVertexOcclusion");
+			prp_innerVertexOcclusionAmount = prp_VColorSettings.FindPropertyRelative("InnerVertexOcclusionAmount");
+			prp_innerVertexOcclusionBlur = prp_VColorSettings.FindPropertyRelative("InnerVertexOcclusionBlur");
+			prp_innerVertexOcclusionBlurIterations = prp_VColorSettings.FindPropertyRelative("InnerVertexOcclusionBlurIterations");
+
+			prp_ambientOcclusion = prp_VColorSettings.FindPropertyRelative("AmbientOcclusion");
+			prp_ambientOcclusionAmount = prp_VColorSettings.FindPropertyRelative("AmbientOcclusionAmount");
+			prp_ambientOcclusionRadius = prp_VColorSettings.FindPropertyRelative("AmbientOcclusionRadius");
+			prp_ambientOcclusionBlur = prp_VColorSettings.FindPropertyRelative("AmbientOcclusionBlur");
+			prp_ambientOcclusionBlurIterations = prp_VColorSettings.FindPropertyRelative("AmbientOcclusionBlurIterations");
+			prp_ambientOcclusionQuality = prp_VColorSettings.FindPropertyRelative("quality");
+ 		}
+
+		void OnEnable(){
+            s_updateSequenceInfo = new GUIContent( RefreshButtonTexture, "Update source info");
+            OnEnableBase();
+ 			CollectProperties();
+		}
+
+ 		public override void OnInspectorGUI (){
+			EditorGUI.showMixedValue = so_player.isEditingMultipleObjects; 	
+			so_player.Update();
+			EditorGUI.BeginChangeCheck();
+			prp_sequence.objectReferenceValue = (MeshSequence)EditorGUILayout.ObjectField(s_sequence, prp_sequence.objectReferenceValue, typeof(MeshSequence), false );
+			if(EditorGUI.EndChangeCheck()){
+				so_player.ApplyModifiedProperties();
+				CollectProperties();	
+			}
+			if(prp_sequence.objectReferenceValue == null){
+				EditorGUILayout.HelpBox( "Select mesh sequence asset", MessageType.Warning);
+				return;
+			}
+			EditorGUI.showMixedValue = so_sequence.isEditingMultipleObjects; 
+			EditorGUI.BeginChangeCheck(); 
+			prp_tabChoise.intValue =  GUILayout.Toolbar(prp_tabChoise.intValue, new string[2]{"Playback", "Import"});
+			if(EditorGUI.EndChangeCheck()){
+				so_player.ApplyModifiedProperties();
+			}
+
+			
+			if(prp_tabChoise.intValue == 0){
+				DrawPlaybackInspector();
+			} else if (prp_tabChoise.intValue == 1) {
+				DrawImportInspector();
+			}  
+ 
+ 		}
+
+		void DrawPlaybackInspector (){
+            MeshSequence t = (target as MeshSequencePlayer).meshSequence;
+            if (t.FramesCount == 0) {
+                EditorGUILayout.HelpBox("No frames yet", MessageType.Warning);
+                return;
+            }
+
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(prp_playerUpdateMode, s_playerUpdateMode);
+			EditorGUILayout.Slider( prp_normalizedTime, 0, 1f, s_normalizedTime);
+			EditorGUILayout.PropertyField( prp_clipPlaybackMode, s_clipPlaybackMode );
+			if(prp_clipPlaybackMode.enumValueIndex != 3){
+				EditorGUI.indentLevel ++;
+				EditorGUILayout.PropertyField(prp_framesPerSeconds, s_framesPerSeconds);
+				EditorGUILayout.PropertyField(prp_useTimescale, s_useTimescale);
+				EditorGUI.indentLevel --;
+			}
+ 			if( EditorGUI.EndChangeCheck()){
+				so_player.ApplyModifiedProperties();
+			}
+ 		}
+
+        void UpdateSequenceInfo() {
+            MeshSequence t = (target as MeshSequencePlayer).meshSequence;
+            t.PreImport.MSI = new MeshSequenceInfo(t.PreImport.PathToObj, t.PreImport.FilesSortMode );
+            if (t.PreImport.MSI.State == MeshSequenceInfo.StateEnum.Ready) {
+                SetResentDirectory(t.PreImport.PathToObj);
+            }
+            if (t.PreImport.MSI.State == MeshSequenceInfo.StateEnum.Empty_path) {
+                t.PreImport.PathToObj = "Select obj file";
+            }
+        }
+
+		void DrawImportInspector(){
+			MeshSequence t = (target as MeshSequencePlayer).meshSequence;
+            so_sequence.Update();
+            EditorGUI.BeginChangeCheck();
+
+			 
+			GUILayout.Label(".obj sequence:");
+
+            string pathButtonName = string.IsNullOrEmpty(t.PreImport.PathToObj) ? " Select .obj file" : t.PreImport.PathToObj;
+            if (GUILayout.Button( pathButtonName )) {
+                t.PreImport.PathToObj = EditorUtility.OpenFilePanelWithFilters("Select point cache", GetResentDirectory(), new string[2] {   "OBJ", "obj" });
+                UpdateSequenceInfo();
+
+            }
+            GUILayout.BeginHorizontal();
+            if (GUILayout.Button(s_updateSequenceInfo, QuadButtonStyle)) {
+                UpdateSequenceInfo();  
+            }
+            EditorGUILayout.LabelField( t.PreImport.MSI.ShortInfo);
+            GUILayout.EndHorizontal();
+
+            EditorGUILayout.PropertyField(prp_filesSortMode, s_filesSortMode);
+
+			prp_importCustomRange.boolValue = EditorGUILayout.Toggle(s_importCustomRange, prp_importCustomRange.boolValue);
+			if(prp_importCustomRange.boolValue){
+				EditorGUI.indentLevel ++;
+				prp_importFrom.intValue = EditorGUILayout.IntField( "From", prp_importFrom.intValue ); 
+				prp_importTo.intValue = EditorGUILayout.IntField( "To", prp_importTo.intValue ); 
+				EditorGUI.indentLevel --;
+			}
+
+			prp_importUV.boolValue = EditorGUILayout.Toggle(s_importUV, prp_importUV.boolValue);
+			prp_calculateNormals.boolValue = EditorGUILayout.Toggle(s_calculateNormals, prp_calculateNormals.boolValue);
+			if(prp_calculateNormals.boolValue){
+				EditorGUI.indentLevel ++;
+				EditorGUILayout.PropertyField( prp_smoothingGroupImportMode, new GUIContent( "Smoothing groups" ) );
+				EditorGUILayout.PropertyField( prp_normalRecalculationMode, new GUIContent( "Normals") );
+				EditorGUI.indentLevel --;
+			}
+			if(prp_calculateNormals.boolValue && prp_importUV.boolValue ){
+				prp_calculateTangents.boolValue = EditorGUILayout.Toggle(s_calculateTangents, prp_calculateTangents.boolValue);
+			}
+
+			EditorGUILayout.PropertyField(prp_flipNormals, s_flipNormals );
+			EditorGUILayout.PropertyField(prp_swapYZAxis, s_swapYZAxis);
+			EditorGUILayout.PropertyField(prp_pivotOffset, s_pivotOffset);
+			EditorGUILayout.PropertyField(prp_scaleFactor, s_scaleFactor);
+			EditorGUILayout.PropertyField(prp_generateMaterials, s_generateMaterials);
+
+			EditorGUILayout.IntPopup( prp_meshCompression, MeshCompressionNames, MeshCompressionIndeces, s_meshCompression );
+            EditorGUILayout.PropertyField(prp_OptimizeMesh, s_OptimizeMesh);
+
+#if UNITY_2017_3_OR_NEWER
+            EditorGUILayout.PropertyField(prp_IndexFormat, s_IndexFormat);
+#endif
+
+            bool nbrightIcons = EditorGUILayout.Toggle(s_brightIcons, brightIcons);
+            if (nbrightIcons != brightIcons) {
+                brightIcons = nbrightIcons;
+                OnEnable();
+            }
+
+
+            EditorGUILayout.LabelField(s_vertexColor);
+			EditorGUI.indentLevel ++;
+			prp_cavity.boolValue = EditorGUILayout.Toggle(s_cavity, prp_cavity.boolValue);
+			if(prp_cavity.boolValue){
+				EditorGUI.indentLevel ++;
+				EditorGUILayout.Slider(  prp_cavityAmount, 0, 10f, s_cavityAmount );
+				float cavityMin = prp_cavityAngleMin.floatValue;
+				float cavityMax = prp_cavityAngleMax.floatValue;
+				s_cavityAngles.text = string.Format("Range [{0}-{1}]",cavityMin.ToString("F0") , cavityMax.ToString("F0"));
+				EditorGUILayout.MinMaxSlider( s_cavityAngles, ref cavityMin, ref cavityMax, 45, 135f );
+				prp_cavityAngleMin.floatValue = cavityMin;
+				prp_cavityAngleMax.floatValue = cavityMax;
+				EditorGUILayout.Slider( prp_cavityBlur, 0, 1f, s_cavityBlur );
+				EditorGUILayout.IntSlider( prp_cavityBlurIterations, 0, 8, s_cavityBlurIterations);
+				EditorGUI.indentLevel --;
+			}
+			 
+			prp_innerVertexOcclusion.boolValue = EditorGUILayout.Toggle(s_innerVertexOcclusion, prp_innerVertexOcclusion.boolValue);
+			if(prp_innerVertexOcclusion.boolValue){
+ 				EditorGUI.indentLevel ++;
+				EditorGUILayout.Slider( prp_innerVertexOcclusionAmount, 0, 5f, s_innerVertexOcclusionAmount);
+				EditorGUILayout.Slider( prp_innerVertexOcclusionBlur, 0, 5f, s_innerVertexOcclusionBlur);
+				EditorGUILayout.IntSlider( prp_innerVertexOcclusionBlurIterations, 0, 8, s_innerVertexOcclusionBlurIterations);
+				EditorGUI.indentLevel --;
+			}
+
+			prp_ambientOcclusion.boolValue = EditorGUILayout.Toggle(s_ambientOcclusion, prp_ambientOcclusion.boolValue);
+			if(prp_ambientOcclusion.boolValue){
+				EditorGUI.indentLevel ++;
+				EditorGUILayout.Slider( prp_ambientOcclusionAmount, 0, 5f, "Amount");
+				EditorGUILayout.PropertyField( prp_ambientOcclusionRadius, s_ambientOcclusionRadius );
+				bool nEnableAORadiusHandle = EditorGUILayout.Toggle( "Radius Handle", EnableAORadiusHandle   );
+				if(nEnableAORadiusHandle != EnableAORadiusHandle){
+					EnableAORadiusHandle = nEnableAORadiusHandle;
+					SceneView.RepaintAll();
+				} 
+				EditorGUILayout.Slider( prp_ambientOcclusionBlur, 0, 5f, "Blur amount");
+				EditorGUILayout.IntSlider( prp_ambientOcclusionBlurIterations, 0, 8, "Blur iterations");
+				EditorGUILayout.PropertyField( prp_ambientOcclusionQuality, new GUIContent("Quality") );
+				EditorGUI.indentLevel --;
+ 			}
+			EditorGUI.indentLevel --;
+
+			if( EditorGUI.EndChangeCheck()){
+ 				so_sequence.ApplyModifiedProperties();
+			}
+
+            if (GUILayout.Button(t.IsImportSettingsDirty? s_importButtonRequireReimport :  s_importButton)){
+				Import();
+				so_player.ApplyModifiedProperties();
+				so_sequence.ApplyModifiedProperties();
+			}
+ 	 	}
+
+ 	 	void OnSceneGUI(){
+            MeshSequencePlayer t = target as MeshSequencePlayer;
+            if (t.meshSequence != null && EnableAORadiusHandle) {
+                Tools.hidden = true;
+                Handles.color = Color.red;
+                float scale = t.transform.localScale.magnitude;
+                float nradius = Handles.RadiusHandle(Quaternion.identity, t.transform.position, t.meshSequence.PreImport.VColorSettings.AmbientOcclusionRadius * scale);
+                if (nradius != t.meshSequence.PreImport.VColorSettings.AmbientOcclusionRadius) {
+                    t.meshSequence.PreImport.VColorSettings.AmbientOcclusionRadius = nradius / scale;
+                    Repaint();
+                }
+            } else {
+                Tools.hidden = false;
+            }
+        }
+
+        void Import() {
+            MeshSequencePlayer t = target as MeshSequencePlayer;
+            MeshSequence ms = t.meshSequence;
+            foreach (TaskInfo ti in t.ImportIE(t.meshSequence)) {
+                 if (ti.Persentage < 0) {
+                     EditorUtility.ClearProgressBar();
+                     EditorUtility.DisplayDialog( string.Format( "Error importing {0}", t.name), ti.Name, "OK", "");
+                     return;
+                 }
+                 EditorUtility.DisplayProgressBar(string.Format("Importing {0} {1}%", ms.name, (ti.Persentage * 100).ToString("F0")), ti.Name, ti.Persentage);
+            }
+
+            List<Object> usedAssets = new List<Object>();
+
+            for (int f = 0; f<ms.FramesCount; f++) {
+                int vertcesCountBeforeCompression = ms[f].FrameMesh.vertexCount;
+                MeshUtility.SetMeshCompression(ms[f].FrameMesh, (ModelImporterMeshCompression)ms.PreImport.MeshCompression);
+                
+                if (ms.PreImport.OptimizeMesh) {
+                    MeshUtility.Optimize(ms[f].FrameMesh);
+                }
+                int vertcesCountAfterCompression = ms[f].FrameMesh.vertexCount;
+                //Debug.LogFormat("Before:{0} after:{1}", vertcesCountBeforeCompression, vertcesCountAfterCompression);
+                ms[f].FrameMesh = (Mesh)AddToAsset(ms, ms[f].FrameMesh);
+                usedAssets.Add( ms[f].FrameMesh );
+            }
+
+            for (int m = 0; m<ms.Materials.Count; m++) {
+                ms.Materials[m].Mat = (Material)AddToAsset(ms, ms.Materials[m].Mat);
+                usedAssets.Add(ms.Materials[m].Mat);
+            }
+
+
+            CleanupAsset(ms, usedAssets);
+            EditorUtility.SetDirty(ms);
+            AssetDatabase.SaveAssets();
+            AssetDatabase.Refresh();
+            CollectProperties(); 
+            EditorUtility.ClearProgressBar();
+            string path = AssetDatabase.GetAssetPath(ms).Remove(0,6);
+            string gPath = Application.dataPath + path;
+            FileInfo fi = new FileInfo(gPath);
+            ms.AssetFileSize = fi.Length / 1000000f;
+            EditorUtility.SetDirty(ms);
+            AssetDatabase.SaveAssets();
+            AssetDatabase.Refresh();
+            GUIUtility.ExitGUI();
+        }
+
+ 
+
+    }	
+}

Assets/Plugins/VertexAnimationTools_30/Editor/MeshSequencePlayerInspector.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 79203610a65b05d4aa2c3297f073c89f
+timeCreated: 1498025099
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/Editor/PointCacheInspector.cs

@@ -0,0 +1,90 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+using VertexAnimationTools_30;
+using UnityEditor.AnimatedValues;
+using UnityEditor.ProjectWindowCallback;
+using System.IO;
+
+namespace VertexAnimationTools_30{
+
+	[CustomEditor(typeof(PointCache))]
+	public class PointCacheInspector : Editor {
+		
+
+		public override void OnInspectorGUI(){
+            PointCache t = target as PointCache;
+            GUILayout.Label("Point Cache Asset", EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+
+            if (t.Meshes[0].mesh == null) {
+                EditorGUILayout.HelpBox(" 1) Create player \n 2) Set sources in Import Tab \n 3) Press Import button", MessageType.Info);
+
+            } else {
+
+                for (int i = 0; i < t.PostImport.UsedMeshesCount; i++) {
+                    EditorGUILayout.LabelField(string.Format("Mesh #{0} name:{1}", i, t.Meshes[i].Name));
+                    EditorGUI.indentLevel++;
+                    EditorGUILayout.LabelField(string.Format("Path {0}", t.Meshes[i].Path));
+                    EditorGUILayout.LabelField(string.Format("Mesh: {0} vertices, {1} triangles", t.Meshes[i].mesh.vertexCount, t.Meshes[i].mesh.triangles.Length / 3));
+                    EditorGUILayout.LabelField(string.Format("Source: {0}", t.Meshes[i].Info));
+                    EditorGUI.indentLevel--;
+                    GUILayout.Space(4);
+                }
+
+                GUILayout.Space(4);
+                for (int i = 0; i < t.PostImport.UsedClipsCount; i++) {
+                    EditorGUILayout.LabelField(string.Format("Clip #{0} name:{1}", i, t.Clips[i].PostImport.Name));
+                    EditorGUI.indentLevel++;
+                    EditorGUILayout.LabelField(string.Format("{0} frames {1} ", t.Clips[i].PostImport.ImportRangeLength, t.Clips[i].PostImport.IsLoop ? ", loop" : ""));
+                    EditorGUILayout.LabelField(string.Format("Path: {0}", t.Clips[i].PostImport.FilePath));
+                    string type = t.Clips[i].PostImport.FilePath.EndsWith("obj") ? "obj sequence" : ".pc2";
+                    EditorGUILayout.LabelField(string.Format("Source type: {0}", type));
+                    EditorGUILayout.LabelField(string.Format("Source frames count:{0}", t.Clips[i].PostImport.FileFramesCount));
+                    EditorGUILayout.LabelField(string.Format("Motion path count:{0}", t.Clips[i].MotionPathsCount));
+                    EditorGUI.indentLevel--;
+                    GUILayout.Space(4);
+                }
+
+
+                EditorGUILayout.LabelField(string.Format("{0} constraints", t.PostConstraints.Length));
+
+                EditorGUILayout.LabelField(string.Format("Imported at: {0}", t.ImportingDate));
+                EditorGUILayout.LabelField(string.Format("Asset file size: {0} MB", t.AssetFileSize.ToString("F4")));
+
+            }
+
+            if (GUILayout.Button("Create Point Cache Player")) {
+                Selection.activeGameObject = t.CreatePlayer();
+            }
+
+            //DrawDefaultInspector();
+         }
+        
+	}
+
+	public class PointCacheFactory{
+		[MenuItem("Assets/Create/Vertex Animation Tools/Point Cache", priority = 203)]
+		static void MenuCreatePointCache(){
+ 			var icon = InspectorsBase.ResourceHolder.PointCacheIcon;
+ 			ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, ScriptableObject.CreateInstance<DoCreatePointCacheAsset>(), "PointCache.asset", icon, null);
+		}
+
+		public static PointCache CreatePointCacheAssetAtPath(string path){
+		    var data = ScriptableObject.CreateInstance<PointCache>();
+		    data.name = Path.GetFileName(path);
+            AssetDatabase.CreateAsset(data, path);
+            AssetDatabase.SaveAssets();
+            AssetDatabase.Refresh();
+            return data;
+		}
+	}
+
+	class DoCreatePointCacheAsset : EndNameEditAction {
+		public override void Action(int instanceId, string pathName, string resourceFile){
+			PointCache data = PointCacheFactory.CreatePointCacheAssetAtPath(pathName);
+		    ProjectWindowUtil.ShowCreatedAsset(data);
+	    }
+	}
+}

Assets/Plugins/VertexAnimationTools_30/Editor/PointCacheInspector.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: fc2e397fcf05fae4eb04dbe47d97a76b
+timeCreated: 1521354138
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/Editor/PointCachePlayerInspector.cs

@@ -0,0 +1,1043 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+using System.IO;
+
+namespace VertexAnimationTools_30{
+    [CanEditMultipleObjects]
+    [CustomEditor(typeof(PointCachePlayer))]
+    public class PointCachePlayerInspector : InspectorsBase {
+
+        #region PLAYBACKCLIP
+        public class PlaybackClip {
+
+            PointCachePlayerInspector Inspector;
+            int Idx;
+
+            GUIStyle coloredIdxStyle;
+            SerializedProperty prp_AutoPlaybackTypeEnum;
+            SerializedProperty prp_NormalizedTime;
+            SerializedProperty prp_Weight;
+            SerializedProperty prp_DurationInSeconds;
+            SerializedProperty prp_DrawMotionPath;
+            SerializedProperty prp_PrpMotionPathIconSize;
+
+            public PlaybackClip(PointCachePlayerInspector inspector, int idx) {
+                Inspector = inspector;
+                Idx = idx;
+                SerializedProperty prp_clip = Inspector.so_player.FindProperty("Clips").GetArrayElementAtIndex(idx);
+ 
+                prp_AutoPlaybackTypeEnum = prp_clip.FindPropertyRelative("AutoPlaybackType");
+                prp_NormalizedTime = Inspector.so_player.FindProperty(string.Format("Clip{0}NormalizedTime", idx));
+                prp_Weight = inspector.so_player.FindProperty(string.Format("Clip{0}Weight", idx));
+                prp_DurationInSeconds = prp_clip.FindPropertyRelative("DurationInSeconds");
+
+                prp_DrawMotionPath = prp_clip.FindPropertyRelative("DrawMotionPath");
+                prp_PrpMotionPathIconSize = prp_clip.FindPropertyRelative("MotionPathIconSize");
+                coloredIdxStyle = new GUIStyle(Inspector.BoldLabelStyle);
+                coloredIdxStyle.normal.textColor = PointCachePlayer.GizmosClipColors[idx];
+            }
+
+            public void DrawClipPlaybackInspector(PointCache pointCache) {
+                PointCache.Clip pcclip = pointCache.Clips[Idx];
+                
+                string clipLabel = string.Format("{0} frames",  pcclip.PostImport.FramesCount);
+                if (pcclip.PostImport.IsLoop) {
+                    clipLabel += ", loop ";
+                } 
+ 
+                GUILayout.BeginHorizontal();
+                GUILayout.Space(16);
+                GUILayout.Label (string.Format("#{0}", Idx ), coloredIdxStyle, GUILayout.Width(20));
+                GUILayout.Label (pcclip.PostImport.Name, Inspector.BoldLabelStyle );
+
+                GUILayout.EndHorizontal();
+               
+
+                EditorGUI.indentLevel++;
+                EditorGUILayout.LabelField(clipLabel, Inspector.LabelStyle);
+                prp_NormalizedTime.floatValue = EditorGUILayout.Slider(Inspector.s_clipNormalizedTime,  prp_NormalizedTime.floatValue, 0, 1f  );
+                EditorGUILayout.Slider( prp_Weight, 0, 1f, Inspector.s_clipWeight);
+                EditorGUILayout.PropertyField(prp_AutoPlaybackTypeEnum,  Inspector.s_clipPlaybackMode);
+                if (prp_AutoPlaybackTypeEnum.enumValueIndex != 3) {
+                    EditorGUI.indentLevel++;
+                    prp_DurationInSeconds.floatValue = EditorGUILayout.FloatField("Duration", prp_DurationInSeconds.floatValue);
+                    EditorGUI.indentLevel--;
+                }
+
+                if (pointCache.Clips[Idx].MotionPathsCount > 0) {
+                    EditorGUILayout.PropertyField(prp_DrawMotionPath, Inspector.s_DrawMotionPath);
+                    if (prp_DrawMotionPath.boolValue)  {
+                        EditorGUI.indentLevel++;
+                        EditorGUILayout.PropertyField(prp_PrpMotionPathIconSize, Inspector.s_MotionPathIconSize);
+                        EditorGUI.indentLevel--;
+                    }
+                }
+
+                EditorGUI.indentLevel--;
+            }
+        }
+        #endregion
+
+        #region POINTCACHECLIP
+        public class PointCacheClip {
+            int ThisIdx;
+            PointCachePlayerInspector Inspector;
+            public SerializedProperty prp_FoldoutIsOpen;
+            public SerializedProperty prp_Name;
+            public SerializedProperty prp_FilePath;
+            public SerializedProperty prp_SwapYZAxis;
+            public SerializedProperty prp_Scale;
+            public SerializedProperty prp_ChangeFramesCount;
+            public SerializedProperty prp_CustomFramesCount;
+            public SerializedProperty prp_SubFrameInterpolation;
+            public SerializedProperty prp_EnableCustomRange;
+            public SerializedProperty prp_CustomRangeFrom;
+            public SerializedProperty prp_CustomRangeTo;
+            public SerializedProperty prp_TransitionMode;
+            public SerializedProperty prp_TransitionLength;
+            public SerializedProperty prp_IsLoop;
+            public SerializedProperty prp_EnableMotionSmoothing;
+            public SerializedProperty prp_MotionSmoothIterations;
+            public SerializedProperty prp_MotionSmoothAmountMin;
+            public SerializedProperty prp_MotionSmoothAmountMax;
+            public SerializedProperty prp_MotionSmoothEaseOffset;
+            public SerializedProperty prp_MotionSmoothEaseLength;
+            public SerializedProperty prp_GenerageMotionPaths;
+            public SerializedProperty prp_MotionPathsIndexStep;
+            public SerializedProperty prp_EnableNormalizeSpeed;
+            public SerializedProperty prp_NormalizeSpeedPersentage;
+
+            public GUIStyle coloredName;
+
+            SmoothCurveGraphTexture _smoothCurveGraph;
+            public SmoothCurveGraphTexture SmoothCurveGraph {
+                get {
+                    if (_smoothCurveGraph == null) {
+                        _smoothCurveGraph = new SmoothCurveGraphTexture(prp_MotionSmoothAmountMin.floatValue, prp_MotionSmoothAmountMax.floatValue, prp_MotionSmoothEaseOffset.floatValue, prp_MotionSmoothEaseLength.floatValue, Inspector.IsDarkTheme);
+                    }
+                    return _smoothCurveGraph;
+                }
+            }
+
+            public PointCacheClip(PointCachePlayerInspector inspector, int idx) {
+                Inspector = inspector;
+                ThisIdx = idx;
+                SerializedProperty prp_PCclip = Inspector.so_pointCache.FindProperty("Clips").GetArrayElementAtIndex(idx);
+                SerializedProperty prp_PCclipPreImport = prp_PCclip.FindPropertyRelative("PreImport");
+                prp_Name = prp_PCclipPreImport.FindPropertyRelative("Name");
+                prp_FoldoutIsOpen = prp_PCclipPreImport.FindPropertyRelative("FoldoutIsOpen");
+                prp_FilePath = prp_PCclipPreImport.FindPropertyRelative("FilePath");
+                prp_SwapYZAxis = prp_PCclipPreImport.FindPropertyRelative("SwapYZAxis");
+                prp_Scale = prp_PCclipPreImport.FindPropertyRelative("Scale");
+                prp_EnableCustomRange = prp_PCclipPreImport.FindPropertyRelative("EnableCustomRange");
+                prp_CustomRangeFrom = prp_PCclipPreImport.FindPropertyRelative("CustomRangeFrom");
+                prp_CustomRangeTo = prp_PCclipPreImport.FindPropertyRelative("CustomRangeTo");
+                prp_TransitionMode =  prp_PCclipPreImport.FindPropertyRelative("TransitionMode");
+                prp_TransitionLength =  prp_PCclipPreImport.FindPropertyRelative("TransitionLength");
+                prp_ChangeFramesCount = prp_PCclipPreImport.FindPropertyRelative("ChangeFramesCount");
+                prp_CustomFramesCount = prp_PCclipPreImport.FindPropertyRelative("CustomFramesCount");
+                prp_SubFrameInterpolation = prp_PCclipPreImport.FindPropertyRelative("SubFrameInterpolation");
+                prp_IsLoop = prp_PCclipPreImport.FindPropertyRelative("IsLoop");
+                prp_EnableMotionSmoothing = prp_PCclipPreImport.FindPropertyRelative("EnableMotionSmoothing");
+                prp_MotionSmoothIterations = prp_PCclipPreImport.FindPropertyRelative("MotionSmoothIterations");
+                prp_MotionSmoothAmountMin = prp_PCclipPreImport.FindPropertyRelative("MotionSmoothAmountMin");
+                prp_MotionSmoothAmountMax = prp_PCclipPreImport.FindPropertyRelative("MotionSmoothAmountMax");
+                prp_MotionSmoothEaseOffset = prp_PCclipPreImport.FindPropertyRelative("MotionSmoothEaseOffset");
+                prp_MotionSmoothEaseLength = prp_PCclipPreImport.FindPropertyRelative("MotionSmoothEaseLength");
+                prp_GenerageMotionPaths = prp_PCclipPreImport.FindPropertyRelative("GenerageMotionPaths");
+                prp_MotionPathsIndexStep = prp_PCclipPreImport.FindPropertyRelative("MotionPathsIndexStep");
+                prp_EnableNormalizeSpeed = prp_PCclipPreImport.FindPropertyRelative("EnableNormalizeSpeed");
+                prp_NormalizeSpeedPersentage = prp_PCclipPreImport.FindPropertyRelative("NormalizeSpeedPercentage");
+                coloredName = new GUIStyle(Inspector.BoldLabelStyle);
+                coloredName.normal.textColor = PointCachePlayer.GizmosClipColors[idx];
+            }
+
+
+            void DrawSourceButton( PointCache pointCache ) {
+                string buttonName = prp_FilePath.stringValue;
+                if (string.IsNullOrEmpty(buttonName)) {
+                    buttonName = "none";
+                }
+                EditorGUILayout.LabelField("Path to .pc2 file or .obj files sequence", Inspector.LabelStyle);
+
+                GUILayout.BeginHorizontal();
+                GUILayout.Space(16);
+                if (GUILayout.Button(buttonName)) {
+                    string dir = UnityEditor.EditorPrefs.GetString("pc2unityLastOpenedDirectory");
+                    string nselect = EditorUtility.OpenFilePanelWithFilters("Select point cache", dir, new string[4] { "PC2", "pc2", "OBJ", "obj" });
+                    if (File.Exists(nselect)) {
+                        UnityEditor.EditorPrefs.SetString("pc2unityLastOpenedDirectory", new FileInfo(nselect).Directory.FullName);
+                    }
+                    prp_FilePath.stringValue = nselect;
+                    Inspector.so_pointCache.ApplyModifiedProperties();
+                    pointCache.Clips[ThisIdx].PreImport.CheckAndUpdateInfo(pointCache.Meshes[0].VertsCount);
+
+                }
+                GUILayout.EndHorizontal();
+
+                GUILayout.BeginHorizontal();
+                GUILayout.Space(16);
+                if (GUILayout.Button(Inspector.s_RefreshPointCacheClip, Inspector.QuadButtonStyle )) {
+                    pointCache.Clips[ThisIdx].PreImport.CheckAndUpdateInfo(pointCache.Meshes[0].VertsCount);
+                }
+                 GUILayout.Label(pointCache.Clips[ThisIdx].PreImport.FileInfo, Inspector.LabelStyle );
+
+
+                GUILayout.EndHorizontal();
+                GUILayout.Space(4);
+            }
+
+
+            void DrawCustomRange( PointCache pointCache ) {
+                EditorGUILayout.PropertyField(prp_EnableCustomRange, Inspector.s_importCustomRange);
+                if (prp_EnableCustomRange.boolValue) {
+                    EditorGUI.indentLevel++;
+                    int _from = EditorGUILayout.IntField("From", prp_CustomRangeFrom.intValue);
+                    int _to = EditorGUILayout.IntField("To", prp_CustomRangeTo.intValue);
+
+                    prp_CustomRangeFrom.intValue = _from < 0 ? 0 : _from;
+                    prp_CustomRangeTo.intValue = _to<_from ? _from : _to;
+                    EditorGUI.indentLevel--;
+                }
+            }
+
+            void DrawTransition( PointCache pointCache ) {
+                prp_TransitionLength.intValue = pointCache.Clips[ThisIdx].PreImport.TransitionFramesCount;
+                EditorGUILayout.PropertyField(prp_TransitionMode, Inspector.s_TransitionMode);
+                int maxBegin = pointCache.Clips[ThisIdx].PreImport.MaxBeginTransitionLength;
+                int maxEnd = pointCache.Clips[ThisIdx].PreImport.MaxEndTransitionLength;
+
+                if (prp_TransitionMode.intValue == 1) {
+                    EditorGUI.indentLevel++;
+                    if (maxBegin > 0) {
+                        EditorGUILayout.IntSlider(prp_TransitionLength, 0, maxBegin, Inspector.s_TransitionLengthBegin);
+                    } else {
+                        EditorGUILayout.HelpBox("To build Begin transition the last frame of the Import Custom Range should be less than source clip length.", MessageType.Warning);
+                    }
+                    EditorGUI.indentLevel--;
+                }
+
+                if (prp_TransitionMode.intValue == 2) {
+                    EditorGUI.indentLevel++;
+                    if (maxEnd > 0) {
+                        EditorGUILayout.IntSlider(prp_TransitionLength, 0, maxEnd, Inspector.s_TransitionLengthEnd);
+                    } else {
+                        EditorGUILayout.HelpBox("To build End transition the first frame of the Import Custom Range should be greater than 0", MessageType.Warning);
+                    }
+                    EditorGUI.indentLevel--;
+                }
+            }
+
+
+            public void DrawInspector(PointCache pointCache) {
+                GUILayout.Space(2);
+                GUILayout.BeginHorizontal();
+                prp_FoldoutIsOpen.boolValue = EditorGUILayout.Toggle(prp_FoldoutIsOpen.boolValue, Inspector.FoldoutToggleStyle, GUILayout.Width(13));
+                EditorGUILayout.LabelField(string.Format("#{0} ", ThisIdx ), coloredName, GUILayout.Width(20));
+                EditorGUILayout.LabelField(string.Format("{0} ",   prp_Name.stringValue), Inspector.BoldLabelStyle);
+                GUILayout.EndHorizontal();
+
+                if (prp_FoldoutIsOpen.boolValue) {
+                    EditorGUI.indentLevel++;
+                    DrawSourceButton(pointCache);
+                    EditorGUILayout.PropertyField(prp_Name);
+                    EditorGUILayout.PropertyField(prp_SwapYZAxis, new GUIContent("Swap YZ"));
+                    EditorGUILayout.PropertyField(prp_Scale, new GUIContent("Scale"));
+
+                    prp_IsLoop.boolValue = EditorGUILayout.Toggle("Loop", prp_IsLoop.boolValue);
+
+                    DrawCustomRange(pointCache);
+                    DrawTransition(pointCache);
+                    EditorGUILayout.PropertyField(prp_ChangeFramesCount, Inspector.s_ChangeFramesCount);
+                    if (prp_ChangeFramesCount.boolValue) {
+                        EditorGUI.indentLevel++;
+                        EditorGUILayout.PropertyField(prp_CustomFramesCount, Inspector.s_CustomFramesCount);
+                        EditorGUILayout.PropertyField(prp_SubFrameInterpolation, Inspector.s_SubFramesInterpolationMode);
+                        EditorGUI.indentLevel--;
+                    }
+
+                    EditorGUILayout.PropertyField(prp_EnableMotionSmoothing, Inspector.s_EnableMotionSmoothing);
+                    if (prp_EnableMotionSmoothing.boolValue) {
+                        EditorGUI.indentLevel++;
+                        EditorGUILayout.PropertyField(prp_MotionSmoothIterations, Inspector.s_MotionSmoothIterations);
+                        float smoothAmountMin = prp_MotionSmoothAmountMin.floatValue;
+                        float smoothAmountMax = prp_MotionSmoothAmountMax.floatValue;
+                        EditorGUILayout.MinMaxSlider(Inspector.s_MotionSmoothAmount, ref smoothAmountMin, ref smoothAmountMax, 0, 1f);
+                        float smoothEaseOffset = prp_MotionSmoothEaseOffset.floatValue;
+                        float smoothEaseLength = prp_MotionSmoothEaseLength.floatValue;
+                        EditorGUILayout.MinMaxSlider(Inspector.s_MotionSmoothEase, ref smoothEaseOffset, ref smoothEaseLength, 0, 0.5f);
+
+                        if (smoothAmountMin != prp_MotionSmoothAmountMin.floatValue || smoothAmountMax != prp_MotionSmoothAmountMax.floatValue || smoothEaseOffset != prp_MotionSmoothEaseOffset.floatValue || smoothEaseLength != prp_MotionSmoothEaseLength.floatValue) {
+                            prp_MotionSmoothAmountMin.floatValue = Mathf.Clamp(smoothAmountMin, 0, 1f);
+                            prp_MotionSmoothAmountMax.floatValue = Mathf.Clamp(smoothAmountMax, 0, 1f);
+                            prp_MotionSmoothEaseOffset.floatValue = Mathf.Clamp(smoothEaseOffset, 0, 0.5f);
+                            prp_MotionSmoothEaseLength.floatValue = Mathf.Clamp(smoothEaseLength, 0, 0.5f);
+                            SmoothCurveGraph.RepaintTexture(smoothAmountMin, smoothAmountMax, smoothEaseOffset, smoothEaseLength);
+                        }
+
+                        EditorGUI.indentLevel--;
+                        if (Event.current.type == EventType.Repaint) {
+                            Rect lastrect = GUILayoutUtility.GetLastRect();
+                            Rect graphRect = new Rect(lastrect.center.x - 64 + 17, lastrect.yMax + 9, 100, 50);
+                            GUI.DrawTexture(graphRect, SmoothCurveGraph.GraphTexture);
+                            Rect backgroundRect = new Rect(lastrect.center.x - 64, lastrect.yMax + 4, 128, 64);
+                            GUI.DrawTexture(backgroundRect, Inspector.GraphBackgroundTexture );
+                        }
+
+                        GUILayout.Space(70);
+                    }
+
+                    EditorGUILayout.PropertyField(prp_EnableNormalizeSpeed, Inspector.s_EnableNormalizeSpeed);
+                    if (prp_EnableNormalizeSpeed.boolValue) {
+                        EditorGUI.indentLevel++;
+                        EditorGUILayout.Slider(prp_NormalizeSpeedPersentage, 0, 1, Inspector.s_NormalizeSpeedPersentage);
+                        EditorGUI.indentLevel--;
+                    }
+
+                    EditorGUILayout.PropertyField(prp_GenerageMotionPaths, Inspector.s_GenerateGizmoPaths);
+                    if (prp_GenerageMotionPaths.boolValue) {
+                        EditorGUI.indentLevel++;
+                        EditorGUILayout.PropertyField(prp_MotionPathsIndexStep, Inspector.s_MotionPathsIndexStep);
+                        EditorGUI.indentLevel--;
+                    }
+
+                    EditorGUI.indentLevel--;
+                }
+            }
+
+        }
+        #endregion
+
+        #region CONSTRAINT
+        public class Constraint {
+            int ThisIdx;
+            PointCachePlayerInspector Inspector;
+            SerializedProperty prp_Name;
+ 
+            PointCache.PreImportConstraint constraint;
+
+            public Constraint(PointCachePlayerInspector inspector, int idx, PointCache.PreImportConstraint _constraint) {
+                Inspector = inspector;
+                ThisIdx = idx;
+                constraint = _constraint;
+                SerializedProperty prp_costraint = Inspector.so_pointCache.FindProperty("PreConstraints").GetArrayElementAtIndex(idx);
+                prp_Name = prp_costraint.FindPropertyRelative("Name");
+            }
+
+            public void DrawInspector() {
+                GUILayout.Space(12);
+                GUILayout.Label( string.Format( "#{0} {1}",  ThisIdx.ToString(), prp_Name.stringValue), Inspector.BoldLabelStyle);
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(prp_Name);
+
+                GUILayout.BeginHorizontal();
+                GUILayout.Space(16);
+                if (Inspector.currentEditedConstraint == constraint) {
+                    if (GUILayout.Button("Edit mode", ResourceHolder.PressedButton)) {
+                        Inspector.currentEditedConstraint = null;
+                        SceneView.RepaintAll();
+                    }
+                } else {
+                    if (GUILayout.Button("Edit mode")) {
+                        Inspector.currentEditedConstraint = constraint;
+                        SceneView.RepaintAll();
+                    }
+                }
+                GUILayout.EndHorizontal();
+                EditorGUI.indentLevel--;
+            }
+        }
+        #endregion
+
+        #region PLAYBACKCONSTRAINT
+        public class PlaybackConstraint {
+            int ThisIdx;
+            PointCachePlayerInspector Inspector;
+            SerializedProperty prp_transform; 
+            string name;
+            GUIContent s_field;
+
+            public PlaybackConstraint(PointCachePlayerInspector inspector, int idx ) {
+                Inspector = inspector;
+                ThisIdx = idx;
+                 
+                prp_transform = Inspector.so_player.FindProperty("Constraints").GetArrayElementAtIndex(idx).FindPropertyRelative("Tr");
+                name = Inspector.so_player.FindProperty("Constraints").GetArrayElementAtIndex(idx).FindPropertyRelative("Name").stringValue;
+                //Debug.LogFormat("name: {0}", name);
+                s_field = new GUIContent(name, string.Format( "constrained transform #{0} {1}", ThisIdx, name ) );
+            }
+
+            public void DrawInspector() {
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(prp_transform, s_field);
+                EditorGUI.indentLevel--;
+            }
+
+        }
+        #endregion
+
+        #region MESH
+        public class PolygonMesh {
+            int ThisIdx;
+            PointCachePlayerInspector Inspector;
+            PointCache pc;
+            SerializedProperty prp_Path;
+            SerializedProperty prp_Name;
+
+            public PolygonMesh( PointCachePlayerInspector inspector, int idx, PointCache pc ) {
+                this.pc = pc;
+                Inspector = inspector;
+                ThisIdx = idx;
+                prp_Path = Inspector.so_pointCache.FindProperty("Meshes").GetArrayElementAtIndex(idx).FindPropertyRelative("Path");
+                prp_Name = Inspector.so_pointCache.FindProperty("Meshes").GetArrayElementAtIndex(idx).FindPropertyRelative("Name");
+            }
+
+            public void DrawInspector() {
+                GUILayout.Space(12);
+                GUIContent buttonContent = new GUIContent();
+                string labelString = ThisIdx == 0 ? string.Format("#{0} ( Main )  {1}  ", ThisIdx, prp_Name.stringValue) :  string.Format("#{0} {1}", ThisIdx, prp_Name.stringValue);
+
+                if (ThisIdx == 0) {
+                     buttonContent.tooltip = " Mesh 0 (Main) vertices count should match up with point cache source";
+                } else {
+                    buttonContent.tooltip = "Can contains arbitary vertex count";
+                }
+
+                EditorGUILayout.LabelField(labelString, Inspector.BoldLabelStyle);
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(prp_Name);
+
+
+                buttonContent.text = prp_Path.stringValue;
+                if(string.IsNullOrEmpty(buttonContent.text)){
+                    buttonContent.text = "none";
+                }
+                EditorGUILayout.LabelField("Path to mesh .obj file");
+                GUILayout.BeginHorizontal();
+                GUILayout.Space(16);
+                if (GUILayout.Button( buttonContent )){
+                	string dir =  EditorPrefs.GetString("pc2unityLastOpenedDirectory");
+                	string nselect = EditorUtility.OpenFilePanelWithFilters( "Select .obj file", dir, new string[2]{"obj","OBJ"});
+                	if(File.Exists(nselect)){
+                		EditorPrefs.SetString( "pc2unityLastOpenedDirectory",  new FileInfo(nselect).Directory.FullName);
+                	}
+                	prp_Path.stringValue = nselect;
+                    prp_Path.serializedObject.ApplyModifiedProperties();
+                    pc.Meshes[ThisIdx].CheckAndUpdateInfo();
+                }
+                GUILayout.EndHorizontal();
+
+                GUILayout.BeginHorizontal();
+                GUILayout.Space(16);
+                if (GUILayout.Button(Inspector.s_RefreshMesh, Inspector.QuadButtonStyle)) {
+                    pc.Meshes[ThisIdx].CheckAndUpdateInfo();
+                    Inspector.so_pointCache.Update();
+                }
+                GUILayout.Label(pc.Meshes[ThisIdx].Info, Inspector.LabelStyle);
+ 
+
+                GUILayout.EndHorizontal();
+                EditorGUI.indentLevel--;
+
+            }
+        }
+        #endregion
+
+        SerializedObject so_player;
+		SerializedObject so_pointCache;
+		PlaybackClip[] playbackClips;
+		PointCacheClip[] importClips;
+        Constraint[] costraints;
+        PolygonMesh[] meshed;
+        PlaybackConstraint[] playbackConstraints;
+
+		SerializedProperty prp_pointCache;
+        SerializedProperty prp_constraintHandlesSize;
+        SerializedProperty prp_drawConstraintHandlesName;
+        SerializedProperty prp_selectedTabIdx;
+        SerializedProperty prp_selectedImportTabIdx;
+
+        static GUIContent s_addMeshButton;
+        static GUIContent s_removeMeshButton;
+
+        static GUIContent s_addClipButton;
+		static GUIContent s_removeClipButton;
+
+        static GUIContent s_addConstraintButton;
+        static GUIContent s_removeConstraintButton;
+ 
+        internal SerializedProperty prp_ImportUsedClipsCount;
+        internal SerializedProperty prp_PlaybackUsedClipsCount;
+
+        internal SerializedProperty prp_PlaybackUsedMeshCount;
+        internal SerializedProperty prp_ImportUsedMeshCount;
+        internal SerializedProperty prp_activeMeshIdx;
+        internal SerializedProperty prp_drawMeshGizmo;
+
+        string[] tabNames = new string[2] { "Playback", "Import" };
+        string[] importToolbarNames = new string[3] { "Meshes", "Clips", "Constraints" };
+
+        GUIContent s_RefreshMesh ;
+		GUIContent s_RefreshPointCacheClip;
+ 
+		GUIContent s_ChangeFramesCount = new GUIContent("Change frames count","Enables custom frames count. As a result, the clip plays over a greater or lesser number of frames. Descreasing frames count reduce memory usage.");
+		GUIContent s_CustomFramesCount = new GUIContent("Frames count","The new frames count");
+		GUIContent s_SubFramesInterpolationMode = new GUIContent("Interpolation","Interpolation mode controls set how generates new frame. Linear mode uses linear interpolation, Hermite uses curve based algorthm");
+
+		GUIContent s_EnableMotionSmoothing = new GUIContent("Motion smoothing", "Enable motion smoothing with following settings. This option respects Loop option so you can use Motion Smoothing for bluring start-end transition and make clip seamless repeated");
+		GUIContent s_MotionSmoothIterations = new GUIContent("Iterations", "Increasing this value increase motion smooth");
+		GUIContent s_MotionSmoothAmount = new GUIContent("Min-Max", "Amount of smoothing over time");
+		GUIContent s_MotionSmoothEase = new GUIContent("Offset-Length", "Define amount ease start-end of the clip over time");
+
+        GUIContent s_GenerateGizmoPaths = new GUIContent("Generate Paths", "Motion paths is a position data for each vertex over clip time in object local space. Useful for debug preview of clip motion. To display generated paths, enable Draw Motion Paths in Playback tab after importing. Not forget to disable Motion Paths before final build because paths data increased asset size.");
+        GUIContent s_MotionPathsIndexStep = new GUIContent("Index step", "Defines index stride of vertices which will be used  generate motion path. 1 mean all vertices will generate own path. ");
+
+        GUIContent s_EnableNormalizeSpeed = new GUIContent("Normalize Speed", "This options makes motion speed constant with given value of blend with original speed. When Normalize Speed is 1.0, all vertices moves with constant speed. ");
+        GUIContent s_NormalizeSpeedPersentage = new GUIContent("Normalize Speed", "Blend normalized speed with original over this value");
+
+        GUIContent s_costrainGizmoSize = new GUIContent("Gizmo size", "Size of constrant gizmo on Scene View");
+        GUIContent s_drawCostrainHandlesName = new GUIContent("Draw name", "Enables name label");
+        GUIContent s_activeMesh = new GUIContent("Active mesh", "Which mesh will be displayed");
+        GUIContent s_drawMeshGizmo = new GUIContent("Draw gizmo", "Enables gizmo of active mesh");
+
+
+        bool toolsIsHiddenOnEnable;
+        PointCache.PreImportConstraint currentEditedConstraint;
+
+        void OnEnable(){
+            OnEnableBase();
+
+            toolsIsHiddenOnEnable = Tools.hidden;
+            s_addMeshButton = new GUIContent( AddButtonTexture, "Add mesh");
+            s_removeMeshButton = new GUIContent(RemoveButtonTexture, "Remove last mesh");
+
+            s_addClipButton = new GUIContent( AddButtonTexture, "Add clip" );
+			s_removeClipButton = new GUIContent( RemoveButtonTexture, "Remove last clip" );
+
+            s_addConstraintButton = new GUIContent( AddButtonTexture, "Add constraint");
+            s_removeConstraintButton = new GUIContent( RemoveButtonTexture, "Remove last constraint");
+
+            s_RefreshMesh = new GUIContent(RefreshButtonTexture, "Refresh source mesh statistic" );
+			s_RefreshPointCacheClip = new GUIContent( RefreshButtonTexture, "Refresh source info" );
+			CollectProperties();
+            currentEditedConstraint = null;
+        }
+
+        void OnDisable() {
+            Tools.hidden = toolsIsHiddenOnEnable;
+            currentEditedConstraint = null;
+        }
+
+		void CollectProperties(){
+ 			so_player = new SerializedObject(targets);
+            PointCachePlayer player = target as PointCachePlayer;
+			prp_pointCache =  so_player.FindProperty( "pointCache" );
+            prp_activeMeshIdx = so_player.FindProperty("ActiveMesh");
+            prp_drawMeshGizmo = so_player.FindProperty("DrawMeshGizmo");
+            prp_playerUpdateMode = so_player.FindProperty("UpdateMode");
+            prp_useTimescale = so_player.FindProperty("UseTimescale");
+
+            playbackClips = new PlaybackClip[8];
+			for(int i = 0; i<playbackClips.Length; i++){
+				playbackClips[i] = new PlaybackClip(this, i);
+			}
+
+            if (prp_pointCache.objectReferenceValue == null){
+ 				return;
+			}
+            PointCache pc = (target as PointCachePlayer).pointCache;
+
+            playbackConstraints = new PlaybackConstraint[player.Constraints.Length];
+            for (int i = 0; i < playbackConstraints.Length; i++) {
+                playbackConstraints[i] = new PlaybackConstraint(this, i );
+            }
+
+            so_pointCache = new SerializedObject( pc );
+ 
+            prp_constraintHandlesSize = so_pointCache.FindProperty("ConstraintHandlesSize");
+            prp_drawConstraintHandlesName = so_pointCache.FindProperty("DrawConstraintHandlesName");
+            prp_selectedTabIdx = so_pointCache.FindProperty("SelectedTabIdx");
+            prp_selectedImportTabIdx = so_pointCache.FindProperty("SelectedImportTabIdx");
+
+            SerializedProperty prp_postImport = so_pointCache.FindProperty("PostImport");
+            prp_PlaybackUsedClipsCount = prp_postImport.FindPropertyRelative("UsedClipsCount");
+            prp_PlaybackUsedMeshCount = prp_postImport.FindPropertyRelative("UsedMeshesCount");
+
+            SerializedProperty prp_preImport = so_pointCache.FindProperty("PreImport");
+ 			prp_swapYZAxis = prp_preImport.FindPropertyRelative("SwapYZAxis");
+			prp_scaleFactor = prp_preImport.FindPropertyRelative("ScaleFactor");
+			prp_flipNormals = prp_preImport.FindPropertyRelative("FlipNormals");
+			prp_smoothingGroupImportMode = prp_preImport.FindPropertyRelative("SmoothingGroupImportMode");
+			prp_normalRecalculationMode = prp_preImport.FindPropertyRelative("NormalRecalculationMode");
+			prp_meshCompression = prp_preImport.FindPropertyRelative("MeshCompression");
+            prp_OptimizeMesh = prp_preImport.FindPropertyRelative("OptimizeMesh");
+            prp_ImportUsedClipsCount = prp_preImport.FindPropertyRelative("UsedClipsCount");
+            prp_ImportUsedMeshCount = prp_preImport.FindPropertyRelative("UsedMeshesCount");
+            prp_generateMaterials = prp_preImport.FindPropertyRelative("GenerateMaterials");
+            prp_savePortableData = prp_preImport.FindPropertyRelative("SavePortableData");
+
+
+#if UNITY_2017_3_OR_NEWER
+            prp_IndexFormat = prp_preImport.FindPropertyRelative("IndexFormat");
+#endif
+
+            costraints = new Constraint[pc.PreConstraints.Count];
+            for (int i = 0; i< costraints.Length; i++) {
+                costraints[i] = new Constraint(this, i, pc.PreConstraints[i]);
+            }
+
+            importClips = new PointCacheClip[8];
+			for(int i = 0; i<importClips.Length; i++){
+				importClips[i] = new PointCacheClip(this, i);
+			}
+
+            meshed = new PolygonMesh[4];
+            for (int i = 0; i<meshed.Length; i++){
+                meshed[i] = new PolygonMesh(this, i, pc);
+                //Debug.LogFormat("lod {0}", lods[i]);
+            }
+		}
+
+		public override void OnInspectorGUI(){
+            PointCachePlayer player = target as PointCachePlayer;
+            so_player.Update();
+            EditorGUI.showMixedValue = so_player.isEditingMultipleObjects;
+
+            if (DrawPointCacheField()) {
+                so_pointCache.Update();
+                EditorGUI.BeginChangeCheck();
+                prp_selectedTabIdx.intValue = GUILayout.Toolbar(prp_selectedTabIdx.intValue, tabNames);
+
+                if (EditorGUI.EndChangeCheck()) {
+                    so_pointCache.ApplyModifiedProperties();
+                }
+
+                if (prp_selectedTabIdx.intValue == 0) {
+                    DrawPlaybackInspector(player);
+                } else if (prp_selectedTabIdx.intValue == 1) {
+                    ImportInspector(player, player.pointCache);
+                }
+            }
+ 
+        }
+
+        bool DrawPointCacheField() {
+            EditorGUI.BeginChangeCheck();
+            prp_pointCache.objectReferenceValue = EditorGUILayout.ObjectField("Point Cache", prp_pointCache.objectReferenceValue, typeof(PointCache), false);
+            if (EditorGUI.EndChangeCheck()) {
+                so_player.ApplyModifiedProperties();
+                CollectProperties();
+            }
+            if (prp_pointCache.objectReferenceValue == null) {
+                EditorGUILayout.HelpBox("Select Point Cache asset", MessageType.Warning);
+                return false;
+            }
+            return true;
+        }
+
+        public void DrawPlaybackInspector(PointCachePlayer player) {
+            so_player.Update();
+            EditorGUI.BeginChangeCheck();
+
+            EditorGUILayout.PropertyField(prp_playerUpdateMode, s_playerUpdateMode);
+            EditorGUILayout.PropertyField(prp_useTimescale, s_useTimescale);
+            EditorGUILayout.LabelField("Meshes", LabelStyle);
+
+            List<GUIContent> meshesNames = new List<GUIContent>();
+            for (int i = 0; i< player.pointCache.PostImport.UsedMeshesCount; i++) {
+                meshesNames.Add( new GUIContent( player.pointCache.Meshes[i].Name ));
+            }
+            EditorGUI.indentLevel++;
+            prp_activeMeshIdx.intValue = EditorGUILayout.Popup(s_activeMesh, prp_activeMeshIdx.intValue, meshesNames.ToArray());
+            EditorGUILayout.PropertyField(prp_drawMeshGizmo, s_drawMeshGizmo);
+            EditorGUI.indentLevel--;
+
+            EditorGUILayout.LabelField("Clips", LabelStyle);
+            EditorGUI.indentLevel++;
+            for (int i = 0; i < prp_PlaybackUsedClipsCount.intValue; i++) {
+                playbackClips[i].DrawClipPlaybackInspector(player.pointCache);
+                GUILayout.Space(6);
+            }
+            EditorGUI.indentLevel--;
+
+            if (playbackConstraints.Length > 0) {  
+                GUILayout.Label("Constraints", LabelStyle );
+                for (int i = 0; i < playbackConstraints.Length; i++) {
+                    playbackConstraints[i].DrawInspector();
+                }
+            }
+
+  
+            if (EditorGUI.EndChangeCheck()) {
+                so_player.ApplyModifiedProperties();
+            }
+
+        }
+
+        public void ImportInspector(PointCachePlayer player, PointCache pointCache) {
+            GUILayout.Space(6);
+            so_pointCache.Update();
+            EditorGUI.BeginChangeCheck();
+
+            EditorGUILayout.PropertyField(prp_savePortableData, s_savePortableData);
+            bool nBrightIcons = EditorGUILayout.Toggle(s_brightIcons, brightIcons);
+            if (nBrightIcons != brightIcons) {
+                brightIcons = nBrightIcons;
+                OnEnable();
+            }
+
+            GUILayout.Space(6);
+
+            prp_selectedImportTabIdx.intValue = GUILayout.Toolbar(prp_selectedImportTabIdx.intValue, importToolbarNames);
+            if (prp_selectedImportTabIdx.intValue == 0) {
+                DrawImportGeometryTab();
+            } else if (prp_selectedImportTabIdx.intValue == 1) {
+                DrawImportClipsTab( pointCache );
+            } else if (prp_selectedImportTabIdx.intValue == 2) {
+                DrawImportConstraintsTab( pointCache );
+            }
+
+            if (EditorGUI.EndChangeCheck()) {
+                so_pointCache.ApplyModifiedProperties();
+            }
+
+
+            GUILayout.Space(6);
+            if (GUILayout.Button(pointCache.ImportSettingsIsDirty ? s_importButtonRequireReimport : s_importButton ) ){
+				Import( );
+			}
+            GUILayout.Space(6);
+        }
+
+        void DrawImportGeometryTab() {
+            GUILayout.Space(6);
+
+            EditorGUILayout.PropertyField(prp_smoothingGroupImportMode, s_smoothingGroupImportMode );
+            EditorGUILayout.PropertyField(prp_normalRecalculationMode, s_normalRecalculationMode );
+            EditorGUILayout.PropertyField(prp_flipNormals, s_flipNormals);
+            EditorGUILayout.PropertyField(prp_swapYZAxis, s_swapYZAxis);
+            EditorGUILayout.PropertyField(prp_scaleFactor, s_scaleFactor);
+
+            prp_meshCompression.intValue = EditorGUILayout.IntPopup(s_meshCompression, prp_meshCompression.intValue, MeshCompressionNames, MeshCompressionIndeces);
+            EditorGUILayout.PropertyField(prp_OptimizeMesh, s_OptimizeMesh);
+            EditorGUILayout.PropertyField(prp_generateMaterials, s_generateMaterials);
+#if UNITY_2017_3_OR_NEWER
+            EditorGUILayout.PropertyField(prp_IndexFormat, s_IndexFormat);
+#endif
+            GUILayout.Space(8);
+            GUILayout.BeginHorizontal();
+            if (GUILayout.Button(s_addMeshButton, QuadButtonStyle, GUILayout.Width(20))) {
+                prp_ImportUsedMeshCount.intValue = Mathf.Clamp(prp_ImportUsedMeshCount.intValue + 1, 1, 4);
+            }
+            if (GUILayout.Button(s_removeMeshButton, QuadButtonStyle, GUILayout.Width(20))) {
+                prp_ImportUsedMeshCount.intValue = Mathf.Clamp(prp_ImportUsedMeshCount.intValue - 1, 1, 4);
+            }
+            GUILayout.EndHorizontal();
+            for (int i = 0; i < prp_ImportUsedMeshCount.intValue; i++) {
+                meshed[i].DrawInspector();
+            }
+        }
+
+        void DrawImportClipsTab(PointCache pointCache) {
+            GUILayout.Space(6);
+            GUILayout.BeginHorizontal();
+            if (GUILayout.Button(s_addClipButton, QuadButtonStyle)) {
+                prp_ImportUsedClipsCount.intValue = Mathf.Clamp(prp_ImportUsedClipsCount.intValue + 1, 0, 8);
+            }
+            if (GUILayout.Button(s_removeClipButton, QuadButtonStyle)) {
+                prp_ImportUsedClipsCount.intValue = Mathf.Clamp(prp_ImportUsedClipsCount.intValue - 1, 0, 8);
+            }
+            GUILayout.EndHorizontal();
+            for (int i = 0; i < prp_ImportUsedClipsCount.intValue; i++) {
+                importClips[i].DrawInspector(pointCache);
+            }
+        }
+
+        void DrawImportConstraintsTab(PointCache pointCache) {
+            GUILayout.Space(6);
+            GUILayout.BeginHorizontal();
+            if (GUILayout.Button(s_addConstraintButton, QuadButtonStyle)) {
+                PointCache.PreImportConstraint newItem = new PointCache.PreImportConstraint( string.Format("New constraint {0}", pointCache.PreConstraints.Count) );
+                pointCache.PreConstraints.Add(newItem);
+                currentEditedConstraint = newItem;
+                CollectProperties();
+            }
+            if (GUILayout.Button(s_removeConstraintButton, QuadButtonStyle)) {
+                if (pointCache.PreConstraints.Count > 0) {
+                    PointCache.PreImportConstraint toRemove = pointCache.PreConstraints[pointCache.PreConstraints.Count - 1];
+                    if (toRemove == currentEditedConstraint) {
+                        currentEditedConstraint = null;
+                    }
+                    pointCache.PreConstraints.Remove(toRemove);
+                }
+
+                CollectProperties();
+            }
+            GUILayout.EndHorizontal();
+
+            EditorGUILayout.Slider(prp_constraintHandlesSize, 0, 10, s_costrainGizmoSize);
+            prp_drawConstraintHandlesName.boolValue = EditorGUILayout.Toggle(s_drawCostrainHandlesName, prp_drawConstraintHandlesName.boolValue);
+            SceneView.RepaintAll();    
+
+            for (int i = 0; i < costraints.Length; i++) {
+                costraints[i].DrawInspector();
+            }
+        }
+
+        struct ConstraintHandleHelper {
+            public PointCache.PreImportConstraint Constraint;
+            public float dist;
+            public Matrix4x4 wtm;
+
+            public static int Comparer(ConstraintHandleHelper a, ConstraintHandleHelper b) {
+                return (int)(b.dist - a.dist);
+            }
+        }
+
+        ConstraintHandleHelper[] handlesHelpers;
+        Camera sceneViewCamera;
+ 
+        void OnSceneGUI() {
+            PointCachePlayer player = target as PointCachePlayer;
+            PointCache pointCache = player.pointCache;
+
+            if (SceneView.lastActiveSceneView.camera != null) {
+                sceneViewCamera = SceneView.lastActiveSceneView.camera;
+            }
+
+            if (pointCache == null) {
+                Tools.hidden = toolsIsHiddenOnEnable;
+                return;
+            }
+
+            if (prp_selectedTabIdx.intValue != 1 || prp_selectedImportTabIdx.intValue != 2) {
+                Tools.hidden = toolsIsHiddenOnEnable;
+                return;
+            }
+
+            DrawConstraintsGizmos(player, pointCache);
+
+            if (currentEditedConstraint != null) {
+ 
+                Tools.hidden = true;
+                Matrix4x4 wtm = player.transform.localToWorldMatrix * currentEditedConstraint.ObjSpace.Matrix;
+                Vector3 bPos = wtm.GetColumn(3);
+                Quaternion bRot = Quaternion.LookRotation((Vector3)wtm.GetColumn(2), (Vector3)wtm.GetColumn(1));
+                bool changed = false;
+
+                if (!Event.current.alt && Tools.current == Tool.Move) {
+                    Vector3 pos = Handles.PositionHandle(bPos, bRot);
+                    if (pos != bPos) {
+                        bPos = pos;
+                        changed = true;
+                    }
+                }
+
+                if (!Event.current.alt && Tools.current == Tool.Rotate) {
+                    Quaternion rot = Handles.RotationHandle(bRot, bPos);
+                    if (rot != bRot) {
+                        bRot = rot;
+                        changed = true;
+                    }
+                }
+
+                if (changed) {
+                    wtm = Matrix4x4.TRS(bPos, bRot, Vector3.one);
+                    currentEditedConstraint.ObjSpace.Matrix = player.transform.worldToLocalMatrix * wtm;
+                    pointCache.ImportSettingsIsDirtyFlag = true;
+                    Repaint();
+                }
+            } else {
+                Tools.hidden = toolsIsHiddenOnEnable;
+            }
+        }
+
+        void DrawConstraintsGizmos(PointCachePlayer player, PointCache pointCache ) {
+ 
+            if (handlesHelpers == null || handlesHelpers.Length != pointCache.PreConstraints.Count) {
+                handlesHelpers = new ConstraintHandleHelper[pointCache.PreConstraints.Count];
+            }
+
+            Matrix4x4 trltw = player.transform.localToWorldMatrix;
+            for (int i = 0; i < handlesHelpers.Length; i++) {
+                handlesHelpers[i].Constraint = pointCache.PreConstraints[i];
+                handlesHelpers[i].wtm = trltw * pointCache.PreConstraints[i].ObjSpace.Matrix;
+                handlesHelpers[i].dist = sceneViewCamera.WorldToViewportPoint(handlesHelpers[i].wtm.GetColumn(3)).z;
+            }
+
+            System.Array.Sort(handlesHelpers, ConstraintHandleHelper.Comparer);
+
+            for (int i = 0; i < handlesHelpers.Length; i++) {
+                PointCache.PreImportConstraint c = handlesHelpers[i].Constraint;
+                Matrix4x4 wtm = handlesHelpers[i].wtm;
+                Vector3 bPos = wtm.GetColumn(3);
+                if (pointCache.ConstraintHandlesSize > 1) {
+                    DrawTM(wtm, pointCache.ConstraintHandlesSize);
+                }
+                Handles.BeginGUI();
+                Vector2 labelSize = ResourceHolder.ConstraintLabel.CalcSize(new GUIContent(c.Name));
+                Vector2 guiPos = HandleUtility.WorldToGUIPoint(bPos);
+                labelSize.x += 4;
+                Vector2 labelPos = new Vector2(guiPos.x - labelSize.x / 2, guiPos.y + 2);
+                Vector2 ikonPos = new Vector2(guiPos.x - 8, guiPos.y - 8);
+                bool isEdit = c == currentEditedConstraint;
+                if (pointCache.DrawConstraintHandlesName) {
+                    GUI.Label(new Rect(labelPos, labelSize), c.Name, isEdit ? ResourceHolder.ConstraintEditLabel : ResourceHolder.ConstraintLabel);
+                }
+                GUI.DrawTexture(new Rect(ikonPos, new Vector2(16, 16)), isEdit ? ResourceHolder.ConstraintEditIcon : ResourceHolder.ConstraintIcon);
+                Handles.EndGUI();
+            }
+        }
+
+        #region IMPORT
+        public void Import(){
+			PointCachePlayer player = target as PointCachePlayer;
+            PointCache pc = player.pointCache;
+             
+            foreach (TaskInfo ti in player.ImportIE()) {
+                if (ti.Persentage < 0) {
+                    EditorUtility.ClearProgressBar();
+                    EditorUtility.DisplayDialog("Error:", ti.Name, "OK", "");
+                    return;
+                }
+                EditorUtility.DisplayProgressBar(string.Format("Import {0} {1}%", player.pointCache.name, (ti.Persentage * 100).ToString("F0")), ti.Name, ti.Persentage);
+            }
+
+            List<Object> usedAssets = new List<Object>();
+            for (int i = 0; i < pc.PreImport.UsedMeshesCount; i++) {
+                MeshUtility.SetMeshCompression(pc.Meshes[i].mesh, (ModelImporterMeshCompression)pc.PreImport.MeshCompression);
+                if (pc.PreImport.OptimizeMesh) {
+                    MeshUtility.Optimize(pc.Meshes[i].mesh);
+                }
+
+                //#if UNITY_2019_2
+                Mesh meshInstance = Instantiate(pc.Meshes[i].mesh);
+                meshInstance.name = pc.Meshes[i].mesh.name;
+                pc.Meshes[i].mesh = (Mesh)AddToAsset(pc, meshInstance);
+                //#else
+                //pc.Meshes[i].mesh = (Mesh)AddToAsset( pc,  pc.Meshes[i].mesh);
+                //#endif
+                usedAssets.Add( pc.Meshes[i].mesh );
+            }
+
+            for (int m = 0; m < pc.Materials.Count; m++) {
+                pc.Materials[m].Mat = (Material)AddToAsset(pc, pc.Materials[m].Mat);
+                if (!usedAssets.Contains(pc.Materials[m].Mat)) {
+                    usedAssets.Add(pc.Materials[m].Mat);
+                }
+            }
+
+            CleanupAsset(pc, usedAssets) ;
+            EditorUtility.SetDirty(pc);
+            AssetDatabase.SaveAssets();
+            AssetDatabase.Refresh();
+            currentEditedConstraint = null;
+            CollectProperties();
+            string pcAssetPath = Application.dataPath + AssetDatabase.GetAssetPath(pc).Remove(0, 6);
+            FileInfo fi = new FileInfo(pcAssetPath);
+            pc.AssetFileSize = fi.Length / 1000000f;
+            pc.ImportingDate = System.DateTime.Now.ToString();
+            EditorUtility.SetDirty(pc);
+            AssetDatabase.SaveAssets();
+            AssetDatabase.Refresh();
+
+            player.Init();
+
+            if (pc.PostImport.SavePortableData) {
+                string portableOutputDirectory = AssetDatabase.GetAssetPath(pc);
+                portableOutputDirectory = portableOutputDirectory.Remove(portableOutputDirectory.Length - 6 - pc.name.Length);
+                 
+                for (int i = 0; i < pc.PostImport.UsedMeshesCount; i++) {
+                    string portableMeshPath = string.Format("{0}{1} {2}.asset", portableOutputDirectory, pc.name, pc.Meshes[i].Name);
+                    Mesh m = AssetDatabase.LoadAssetAtPath<Mesh>(portableMeshPath);
+                    if (m == null) {
+                        m = Instantiate(pc.Meshes[i].mesh);
+                        AssetDatabase.CreateAsset(m, portableMeshPath);
+                    } else {
+                        pc.Meshes[i].mesh.CopyDataTo(m);
+                    }
+                }
+
+                for (int i = 0; i < pc.PostImport.UsedClipsCount; i++) {
+                    PointCache.Clip pcclip = pc.Clips[i];
+                    string portableClipPath = string.Format("{0}{1} {2}.anim", portableOutputDirectory, pc.name, pcclip.PostImport.Name);
+                    AnimationClip animClip = AssetDatabase.LoadAssetAtPath<AnimationClip>(portableClipPath);
+                    if (animClip == null) {
+                        animClip = new AnimationClip();
+                        AssetDatabase.CreateAsset(animClip, portableClipPath);
+                    }  
+                    FillAnimClip(animClip, player.smr,  pcclip.PostImport.FrameIdxOffset, pcclip.PostImport.FramesCount, player.Clips[i].DurationInSeconds, pcclip.PostImport.IsLoop );
+                }
+
+
+                AssetDatabase.SaveAssets();
+                AssetDatabase.Refresh();
+            }
+
+            EditorUtility.ClearProgressBar();
+            GUIUtility.ExitGUI();
+        }
+
+        void FillAnimClip(AnimationClip clip, SkinnedMeshRenderer smr, int firstFrame, int framesCount, float duration, bool isLoop) {
+            clip.ClearCurves();
+            if (isLoop) {
+                float step = duration /  framesCount ;
+                float tangent = 100f / step;
+ 
+                for (int i = 0; i < framesCount; i++) {
+                    string name = "blendShape." + smr.sharedMesh.GetBlendShapeName( firstFrame+i );
+
+                    Keyframe[] keys = null;
+                    if (i == 0) { // first
+                        keys = new Keyframe[4];
+                        keys[0] = new Keyframe(0, 100f, tangent, -tangent);
+                        keys[1] = new Keyframe(step, 0f, -tangent, 0);
+                        keys[2] = new Keyframe((framesCount-1)*step, 0f, 0,  tangent);
+                        keys[3] = new Keyframe(framesCount * step, 100f,  tangent, -tangent);
+                    }  else {
+                        keys = new Keyframe[3];
+                        keys[0] = new Keyframe((i - 1) * step, 0f, tangent, tangent);
+                        keys[1] = new Keyframe(i * step, 100f, tangent, -tangent);
+                        keys[2] = new Keyframe((i + 1) * step, 0f, -tangent, tangent);
+                    }
+
+
+                    AnimationCurve ac = new AnimationCurve(keys);
+                    clip.SetCurve("", typeof(SkinnedMeshRenderer), name, ac);
+                }
+            } else {
+                float step = duration / (framesCount-1);
+                float tangent = 100f / step;
+ 
+                for (int i = 0; i < framesCount; i++) {
+                    string name = "blendShape." + smr.sharedMesh.GetBlendShapeName( firstFrame+i );
+
+                    Keyframe[] keys = null;
+                    if (i == 0) { // first
+                        keys = new Keyframe[2];
+                        keys[0] = new Keyframe(0, 100f, tangent, -tangent);
+                        keys[1] = new Keyframe(step, 0f, -tangent, tangent);
+                    } else if (i == framesCount - 1) { //last
+                        keys = new Keyframe[2];
+                        keys[0] = new Keyframe((i - 1) * step, 0f, tangent, tangent);
+                        keys[1] = new Keyframe(i * step, 100f, tangent, -tangent);
+                    } else {
+                        keys = new Keyframe[3];
+                        keys[0] = new Keyframe((i - 1) * step, 0f, tangent, tangent);
+                        keys[1] = new Keyframe(i * step, 100f, tangent, -tangent);
+                        keys[2] = new Keyframe((i + 1) * step, 0f, -tangent, tangent);
+                    }
+
+
+                    AnimationCurve ac = new AnimationCurve(keys);
+                    clip.SetCurve("", typeof(SkinnedMeshRenderer), name, ac);
+                }
+            } 
+        }
+#endregion
+
+ 
+	}
+}

Assets/Plugins/VertexAnimationTools_30/Editor/PointCachePlayerInspector.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 52d838d953db1e04d8fdd8c607834cce
+timeCreated: 1524290038
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/Editor/ProjectionSamplesInspector.cs

@@ -0,0 +1,17 @@
+using UnityEngine;
+using System.Collections;
+using UnityEditor;
+
+namespace VertexAnimationTools_30 {
+    [CustomEditor(typeof(ProjectionSamples))]
+    public class ProjectionSamplesInspector : Editor {
+
+        void OnEnable() {
+            target.hideFlags = HideFlags.None;  
+        }
+
+        public override void OnInspectorGUI() {
+            EditorGUILayout.HelpBox ("This 16kb asset stores ray data  for calculating Ambient Occlusion in Vertex Animation Tools. Move this asset outside Resources before final build folder if you not plan to use the runtime importing. ", MessageType.Info);
+        }
+    }
+}

Assets/Plugins/VertexAnimationTools_30/Editor/ProjectionSamplesInspector.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: ef128b632428abe4899bb75b7e62e093
+timeCreated: 1536813445
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: b4d401277a58060469c3baa2e9c1f624
+folderAsset: yes
+timeCreated: 1519581838
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/ConstraintEditIkon.tif.meta

@@ -0,0 +1,55 @@
+fileFormatVersion: 2
+guid: eb7420c4c6d44594c800a4af5e4f6058
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    linearTexture: 1
+    correctGamma: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  cubemapConvolution: 0
+  cubemapConvolutionSteps: 7
+  cubemapConvolutionExponent: 1.5
+  seamlessCubemap: 0
+  textureFormat: -3
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: 0
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  rGBM: 0
+  compressionQuality: 50
+  allowsAlphaSplitting: 0
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaIsTransparency: 1
+  textureType: 2
+  buildTargetSettings: []
+  spriteSheet:
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/ConstraintEditLabel.tif.meta

@@ -0,0 +1,55 @@
+fileFormatVersion: 2
+guid: cb5d3aa24d6ee794da750666ae9ea163
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    linearTexture: 1
+    correctGamma: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  cubemapConvolution: 0
+  cubemapConvolutionSteps: 7
+  cubemapConvolutionExponent: 1.5
+  seamlessCubemap: 0
+  textureFormat: -3
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: 0
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  rGBM: 0
+  compressionQuality: 50
+  allowsAlphaSplitting: 0
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaIsTransparency: 1
+  textureType: 2
+  buildTargetSettings: []
+  spriteSheet:
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/ConstraintIkon.tif.meta

@@ -0,0 +1,55 @@
+fileFormatVersion: 2
+guid: 279449d51f8d85e44a98da05b1f21399
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    linearTexture: 1
+    correctGamma: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  cubemapConvolution: 0
+  cubemapConvolutionSteps: 7
+  cubemapConvolutionExponent: 1.5
+  seamlessCubemap: 0
+  textureFormat: -3
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: 0
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  rGBM: 0
+  compressionQuality: 50
+  allowsAlphaSplitting: 0
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaIsTransparency: 1
+  textureType: 2
+  buildTargetSettings: []
+  spriteSheet:
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/ConstraintLabel.tif.meta

@@ -0,0 +1,55 @@
+fileFormatVersion: 2
+guid: b00e387c52df53549a2c0178106e7b8c
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    linearTexture: 1
+    correctGamma: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  cubemapConvolution: 0
+  cubemapConvolutionSteps: 7
+  cubemapConvolutionExponent: 1.5
+  seamlessCubemap: 0
+  textureFormat: -3
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: 0
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  rGBM: 0
+  compressionQuality: 50
+  allowsAlphaSplitting: 0
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaIsTransparency: 1
+  textureType: 2
+  buildTargetSettings: []
+  spriteSheet:
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/MeshSequenceIcon.png.meta

@@ -0,0 +1,57 @@
+fileFormatVersion: 2
+guid: 628935adf2b395a4f84c49088d4363a7
+timeCreated: 1521387205
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    linearTexture: 1
+    correctGamma: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  cubemapConvolution: 0
+  cubemapConvolutionSteps: 7
+  cubemapConvolutionExponent: 1.5
+  seamlessCubemap: 0
+  textureFormat: -3
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: 0
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  rGBM: 0
+  compressionQuality: 50
+  allowsAlphaSplitting: 0
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaIsTransparency: 1
+  textureType: 2
+  buildTargetSettings: []
+  spriteSheet:
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/MeshSequencePlayerIcon.png.meta

@@ -0,0 +1,57 @@
+fileFormatVersion: 2
+guid: f9823c91b0e347e4c9caa0456f8d27bc
+timeCreated: 1521441788
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    linearTexture: 1
+    correctGamma: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  cubemapConvolution: 0
+  cubemapConvolutionSteps: 7
+  cubemapConvolutionExponent: 1.5
+  seamlessCubemap: 0
+  textureFormat: -3
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: 0
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  rGBM: 0
+  compressionQuality: 50
+  allowsAlphaSplitting: 0
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaIsTransparency: 1
+  textureType: 2
+  buildTargetSettings: []
+  spriteSheet:
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/PointCacheIcon.png.meta

@@ -0,0 +1,76 @@
+fileFormatVersion: 2
+guid: 5504b8e88c3e647468197418c793db95
+timeCreated: 1549636237
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 1
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: -3
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: 0
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/PointCachePlayerIcon.png.meta

@@ -0,0 +1,57 @@
+fileFormatVersion: 2
+guid: e1e8ec44d03a2dd40be316709f543ea0
+timeCreated: 1523959794
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    linearTexture: 1
+    correctGamma: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  cubemapConvolution: 0
+  cubemapConvolutionSteps: 7
+  cubemapConvolutionExponent: 1.5
+  seamlessCubemap: 0
+  textureFormat: -3
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: 0
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  rGBM: 0
+  compressionQuality: 50
+  allowsAlphaSplitting: 0
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaIsTransparency: 1
+  textureType: 2
+  buildTargetSettings: []
+  spriteSheet:
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/VATEditorResources_AddButton_Dark.psd.meta

@@ -0,0 +1,76 @@
+fileFormatVersion: 2
+guid: 3076fee26d90b6f4f9c88275c76d747b
+timeCreated: 1549176807
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/VATEditorResources_AddButton_Light.psd.meta

@@ -0,0 +1,76 @@
+fileFormatVersion: 2
+guid: 3596c0946e8e1ad43a80928742b7dc73
+timeCreated: 1549176807
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/VATEditorResources_FoldoutClosed_Dark.psd.meta

@@ -0,0 +1,76 @@
+fileFormatVersion: 2
+guid: 66a8f527b18b74e47b6d6bb1ee9a1f0e
+timeCreated: 1549135522
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/VATEditorResources_FoldoutClosed_Light.psd.meta

@@ -0,0 +1,76 @@
+fileFormatVersion: 2
+guid: d61e6861623948e469ecd5c2652834bd
+timeCreated: 1548781941
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/VATEditorResources_FoldoutOpened_Dark.psd.meta

@@ -0,0 +1,76 @@
+fileFormatVersion: 2
+guid: cc59ca287fe579d4e8ff523b61d1d593
+timeCreated: 1549135579
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/VATEditorResources_FoldoutOpened_Light.psd.meta

@@ -0,0 +1,76 @@
+fileFormatVersion: 2
+guid: ca2699b62da5af84bb823e3c05c35944
+timeCreated: 1548781941
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/VATEditorResources_GraphBackground_Dark.psd.meta

@@ -0,0 +1,76 @@
+fileFormatVersion: 2
+guid: 2f7e75dd73d1b0e4293967325d95d088
+timeCreated: 1549179415
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/VATEditorResources_GraphBackground_Light.psd.meta

@@ -0,0 +1,76 @@
+fileFormatVersion: 2
+guid: df0ca1be9e0e8c042b61632515abff30
+timeCreated: 1549179415
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/VATEditorResources_PointCachePlayerIcon.psd.meta

@@ -0,0 +1,76 @@
+fileFormatVersion: 2
+guid: 7d4b9540fe123c742b8ef7ada28cb14b
+timeCreated: 1549139614
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/VATEditorResources_RefreshButton_Dark.psd.meta

@@ -0,0 +1,76 @@
+fileFormatVersion: 2
+guid: 8ba7d907c0b47774ebecb08740cda7a3
+timeCreated: 1549138545
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/VATEditorResources_RefreshButton_Light.psd.meta

@@ -0,0 +1,76 @@
+fileFormatVersion: 2
+guid: bd51a79849fee0b4890483eb0d8ddd49
+timeCreated: 1549178053
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/VATEditorResources_RemoveButton_Dark.psd.meta

@@ -0,0 +1,76 @@
+fileFormatVersion: 2
+guid: b6c833141475d564aa5f068345f66417
+timeCreated: 1549176951
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/VATEditorResources_RemoveButton_Light.psd.meta

@@ -0,0 +1,76 @@
+fileFormatVersion: 2
+guid: 3b853d46d6db0464d9a368682c3dbf8a
+timeCreated: 1549176951
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/VATEditorResources_icon_RequireReimport_Dark.psd.meta

@@ -0,0 +1,76 @@
+fileFormatVersion: 2
+guid: 8d0328fc6b164de46b69e4502774ced1
+timeCreated: 1549138010
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/VATEditorResources_icon_RequireReimport_Light.psd.meta

@@ -0,0 +1,55 @@
+fileFormatVersion: 2
+guid: 0430abf6923954048993bc8fde8a6d82
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    linearTexture: 1
+    correctGamma: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  cubemapConvolution: 0
+  cubemapConvolutionSteps: 7
+  cubemapConvolutionExponent: 1.5
+  seamlessCubemap: 0
+  textureFormat: -3
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: 0
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  rGBM: 0
+  compressionQuality: 50
+  allowsAlphaSplitting: 0
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaIsTransparency: 1
+  textureType: 2
+  buildTargetSettings: []
+  spriteSheet:
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/btnpressed.png.meta

@@ -0,0 +1,55 @@
+fileFormatVersion: 2
+guid: ce1f352918f03d84c966d7fdd1b9e808
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    linearTexture: 1
+    correctGamma: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  cubemapConvolution: 0
+  cubemapConvolutionSteps: 7
+  cubemapConvolutionExponent: 1.5
+  seamlessCubemap: 0
+  textureFormat: -3
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: 0
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  rGBM: 0
+  compressionQuality: 50
+  allowsAlphaSplitting: 0
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaIsTransparency: 1
+  textureType: 2
+  buildTargetSettings: []
+  spriteSheet:
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/EditorResources/pc2unityResourcesHolder.asset.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 3957d062bdc6541488cef10c197a286f
+timeCreated: 1521395082
+licenseType: Store
+NativeFormatImporter:
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/Resources.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8eb241f459e2f9044bc2d807646a394c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/Resources/VertexAnimationToolsDefaultMaterial.mat

@@ -0,0 +1,76 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: VertexAnimationToolsDefaultMaterial
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: _EMISSION
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.44117647, g: 0.44117647, b: 0.44117647, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/Plugins/VertexAnimationTools_30/Resources/VertexAnimationToolsDefaultMaterial.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4dd02413901fda442965f9741211045a
+timeCreated: 1534655791
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/Resources/VertexAnimationTools_ProjectionSamples.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b4d5b078a8b95b2499cf19cb5bdef666
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/Scripts.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: c8f046120c4028943afc821c64d1bec8
+folderAsset: yes
+timeCreated: 1497330591
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/Scripts/Common.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 69d337b89a07d7645b5a54c4cccb8bdc
+folderAsset: yes
+timeCreated: 1548846846
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/Scripts/Common/BindingHelper.cs

@@ -0,0 +1,229 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace VertexAnimationTools_30 {
+
+    public class BindingHelper {
+
+        struct Edge {
+            public int A;
+            public int B;
+
+            Vector3 pA;
+            Vector3 pB;
+            Vector3 ab;
+            float length;
+            float length2;
+
+            public Edge(int idxa, int idxb ) {
+                A = idxa;
+                B = idxb;
+                pA = Vector3.zero;
+                pB = Vector3.zero;
+                ab = Vector3.zero;
+                length = 0;
+                length2 = 0;
+            }
+
+            public void SetVertices(Vector3[] verts) {
+                pA = verts[A];
+                pB = verts[B];
+                ab = pB - pA;
+                length = ab.magnitude;
+                length2 = length * length;
+            }
+
+            public override int GetHashCode() {
+                unchecked {
+                    int min = A;
+                    int max = B;
+                    if (A > B) {
+                        min = B;
+                        max = A;
+                    }
+                    return (min.ToString() + max.ToString()).GetHashCode();
+                }
+            }
+
+            public override bool Equals(object obj) {
+                Edge other = (Edge)obj;
+                return other.GetHashCode() == this.GetHashCode();
+            }
+
+            public float GetDistance(Vector3 point, ref float lv) {
+                Vector3 ap = point - pA;
+                float u = Vector3.Dot(ap, ab) / length2;
+                Vector3 nearestPoint = Vector3.zero;
+                if (u < 0) {
+                    lv = 0;
+                    nearestPoint = pA;
+                } else if (u > 1) {
+                    lv = 1f;
+                    nearestPoint = pB;
+                } else {
+                    lv = u;
+                    nearestPoint = pA + ab * u;
+                }
+                return Vector3.Distance(nearestPoint, point);
+            }
+
+        }
+
+        public MeshCollider mc;
+        public MeshCollider imc;
+        public int[] tris;
+        public Matrix4x4 ltw;
+        public Vector3[] dirs;
+        Vector3[] vertices;
+        Vector3[] normals;
+        Vector3[] tangents;
+        HashSet<Edge> edges;
+        Edge[] edgesArr ;
+
+        public BindingHelper(Mesh snapshot, Transform tr) {
+            System.Diagnostics.Stopwatch sw = System.Diagnostics.Stopwatch.StartNew();
+            ltw = tr.transform.localToWorldMatrix;
+
+            Mesh colliderMesh = snapshot;
+
+            GameObject go = new GameObject();
+            go.hideFlags = HideFlags.HideAndDontSave;
+            go.transform.position = tr.position;
+            go.transform.rotation = tr.rotation;
+            go.transform.localScale = tr.localScale;
+            mc = go.AddComponent<MeshCollider>();
+            mc.sharedMesh = colliderMesh;
+            go.AddComponent<MeshFilter>().sharedMesh = colliderMesh;
+            go.AddComponent<MeshRenderer>();
+            tris = colliderMesh.triangles;
+
+            Mesh icolliderMesh = Object.Instantiate(colliderMesh);
+            GameObject igo = new GameObject();
+            igo.hideFlags = HideFlags.HideAndDontSave;
+            igo.transform.position = tr.position;
+            igo.transform.rotation = tr.rotation;
+            igo.transform.localScale = tr.localScale;
+            imc = igo.AddComponent<MeshCollider>();
+
+            int[] itris = icolliderMesh.triangles;
+
+            edges = new HashSet<Edge>();
+
+            for (int r = 0; r < tris.Length; r += 3) {
+                int t0 = itris[r + 2];
+                int t1 = itris[r + 1];
+                int t2 = itris[r];
+                itris[r] = t0;
+                itris[r + 1] = t1;
+                itris[r + 2] = t2;
+
+                Edge e0 = new Edge(t0, t1);
+                Edge e1 = new Edge(t1, t2);
+                Edge e2 = new Edge(t2, t0);
+
+                if (!edges.Contains(e0)) {
+                    edges.Add(e0);
+                }
+
+                if (!edges.Contains(e1)) {
+                    edges.Add(e1);
+                }
+
+                if (!edges.Contains(e2)) {
+                    edges.Add(e2);
+                }
+
+            }
+            icolliderMesh.triangles = itris;
+            imc.sharedMesh = icolliderMesh;
+            
+            edgesArr = new Edge[edges.Count];
+            edges.CopyTo(edgesArr);
+            ProjectionSamples ps = ProjectionSamples.Get;
+            dirs = ps.SphereSamples[4].Dirs;
+            sw.Stop();
+
+        }
+
+        public void SetVertices(Vector3[] _vertices, Vector3[] _normals, Vector3[] _tangents) {
+            vertices = Extension.Copy(_vertices);
+            normals = Extension.Copy(_normals);
+            tangents = Extension.Copy(_tangents);
+        }
+
+        public Matrix4x4 GetTrisTM(int idxa, int idxb, int idxc, Vector3 bary) {
+            Vector3 a = vertices[idxa];
+            Vector3 b = vertices[idxb];
+            Vector3 c = vertices[idxc];
+            Vector3 na = normals[idxa];
+            Vector3 nb = normals[idxb];
+            Vector3 nc = normals[idxc];
+            Vector3 ta = tangents[idxa];
+            Vector3 tb = tangents[idxb];
+            Vector3 tc = tangents[idxc];
+            Vector3 trisCenter = a * bary.x + b * bary.y + c * bary.z;
+            Vector3 averageUp = na * bary.x + nb * bary.y + nc * bary.z;
+            Vector3 xDir = ta * bary.x + tb * bary.y + tc * bary.z;
+            Vector3 zDir = Vector3.Cross(xDir, averageUp);
+            Matrix4x4 res = Matrix4x4.identity;
+            res.SetColumn(0, (Vector4)xDir);
+            res.SetColumn(1, (Vector4)averageUp);
+            res.SetColumn(2, (Vector4)zDir);
+            res.SetColumn(3, trisCenter);
+            res[15] = 1;
+            return res;
+        }
+
+
+        public void Bind(PFU objSpacePFU, ref BindInfo bi) {
+            float minDist = float.MaxValue;
+            RaycastHit rh = new RaycastHit();
+            Vector3 constraintPos = ltw.MultiplyPoint3x4(objSpacePFU.P);
+            float lv = -1;
+            for (int e = 0; e < edgesArr.Length; e++) {
+                edgesArr[e].SetVertices(vertices);
+                float d = edgesArr[e].GetDistance(objSpacePFU.P, ref lv);
+                if (d < minDist) {
+                    bi.VidxA = edgesArr[e].A;
+                    bi.VidxB = edgesArr[e].B;
+                    bi.VidxC = edgesArr[e].B;
+                    minDist = d;
+                    bi.Bary = new Vector3(1f - lv, lv, 0);
+                }
+            }
+
+            for (int i = 0; i < dirs.Length; i++) {
+                Ray r = new Ray(constraintPos, dirs[i]);
+                if (imc.Raycast(r, out rh, float.MaxValue)) {
+                    //Debug.LogFormat("to edge {0} dist:{1}", e, d);
+                    if (rh.distance < minDist) {
+                        bi.VidxA = tris[rh.triangleIndex * 3 + 2];
+                        bi.VidxB = tris[rh.triangleIndex * 3 + 1];
+                        bi.VidxC = tris[rh.triangleIndex * 3];
+                        minDist = rh.distance;
+                        bi.Bary = rh.barycentricCoordinate;
+                    }
+                }
+
+                if (mc.Raycast(r, out rh, float.MaxValue)) {
+                    if (rh.distance < minDist) {
+                        bi.VidxA = tris[rh.triangleIndex * 3];
+                        bi.VidxB = tris[rh.triangleIndex * 3 + 1];
+                        bi.VidxC = tris[rh.triangleIndex * 3 + 2];
+                        minDist = rh.distance;
+                        bi.Bary = rh.barycentricCoordinate;
+                    }
+                }
+            }
+            bi.TrisSpace = objSpacePFU * GetTrisTM(bi.VidxA, bi.VidxB, bi.VidxC, bi.Bary).inverse;
+        }
+
+        public void Delete() {
+            Object.DestroyImmediate(mc.gameObject);
+            Object.DestroyImmediate(imc.gameObject);
+        }
+
+
+    }
+}

Assets/Plugins/VertexAnimationTools_30/Scripts/Common/BindingHelper.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: ed524c34e2c916e439161f529e152497
+timeCreated: 1529731511
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/Scripts/Common/EditorResourcesHolderSO.cs

@@ -0,0 +1,48 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+
+namespace VertexAnimationTools_30 {
+    #if UNITY_5_5_OR_NEWER
+    [PreferBinarySerialization]
+    #endif
+    public class EditorResourcesHolderSO : ScriptableObject {
+ 
+        public Texture2D RemoveLight;
+        public Texture2D RemoveDark;
+
+        public Texture2D AddLight;
+        public Texture2D AddDark;
+
+
+        public Texture2D RefreshLight;
+        public Texture2D RefreshDark;
+
+        public Texture2D Graph0101BackgroundLight;
+        public Texture2D Graph0101BackgroundDark;
+
+        public GUIStyle QuadIconButtonStyle;
+        public GUIStyle TLabel;
+
+        public GUIStyle ConstraintLabel;
+        public Texture2D ConstraintIcon;
+
+        public GUIStyle ConstraintEditLabel;
+        public Texture2D ConstraintEditIcon;
+        public Texture2D MeshSequenceIcon;
+        public Texture2D PointCacheIcon;
+
+
+        public Texture2D RequireReimportLight;
+        public Texture2D RequireReimportDark;
+
+
+        public GUIStyle PressedButton;
+ 
+
+        public GUIStyle FoldoutToggle;
+        public GUIStyle FoldoutToggleDark;
+
+    }
+}

Assets/Plugins/VertexAnimationTools_30/Scripts/Common/EditorResourcesHolderSO.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 20354498d6d720948907404d93f7af50
+timeCreated: 1521394586
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/Scripts/Common/Extension.cs

@@ -0,0 +1,438 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+ 
+using System.IO;
+ 
+
+namespace VertexAnimationTools_30{
+
+    public enum InterpolateModeEnum {
+        Linear,
+        Hermite
+    }
+
+    public enum TransitionModeEnum {
+        None,
+        Begin,
+        End
+    }
+
+    public enum PlayerUpdateMode {
+        Update,
+        LateUpdate,
+        Manually
+    }
+
+    public enum AutoPlaybackTypeEnum {
+        Repeat,
+        PingPong,
+        Once,
+        None
+    }
+
+    [System.Serializable]
+    public class MaterialInfo {
+        public Material Mat;
+        public bool Used;
+        public string Name;
+
+        public MaterialInfo(string name, Material mat) {
+            Mat = mat;
+            Name = name;
+        }
+    }
+
+    public struct TaskInfo {
+        public string Name;
+        public float Persentage;
+
+        public TaskInfo(string name, float persentage) {
+            Name = name;
+            Persentage = persentage;
+        }
+    }
+
+    public class NormalizedSpline {
+        public Vector3[] Vertices;
+        public float[] Distances;
+        public float Length;
+
+        public NormalizedSpline(Vector3[] vertices ) {
+            Vertices = new Vector3[vertices.Length];
+            vertices.CopyTo(Vertices, 0);
+            Distances = new float[Vertices.Length];
+            Length = 0;
+            for (int v = 1; v<Vertices.Length; v++) {
+                Length += Vector3.Distance(Vertices[v], Vertices[v - 1]);
+                Distances[v] = Length;
+            }
+ 
+        }
+
+        public Vector3 GetPoint(float persentage) {
+            float targetDist = persentage * Length;
+            if (targetDist <= 0) {
+                return Vertices[0];
+            }
+
+            if (targetDist >= Length) {
+                return Vertices[Vertices.Length - 1];
+            }
+
+            for (int v = 1; v<Distances.Length; v++) {
+                float a = Distances[v-1];
+                float b = Distances[v];
+
+                if (a <= targetDist && b > targetDist) {
+                    float lv =  (targetDist - a)/(b-a);
+                    return Vector3.LerpUnclamped(Vertices[v - 1], Vertices[v], lv);
+                }
+            }
+            return Vertices[0];
+        }
+    }
+
+    public class SinAnimator {
+        public float Speed;
+        public float MinValue;
+        public float MaxValue;
+
+        float timer;
+        float targetTime;
+        float valueFrom;
+        float valueTo;
+
+        public float Result;
+
+
+        public SinAnimator(float minValue, float maxValue, float speed ) {
+            Speed = speed;
+            MinValue = minValue;
+            MaxValue = maxValue;
+            valueTo = Random.Range(MinValue, MaxValue);
+            Reset();
+        }
+
+        public SinAnimator(float minValue, float maxValue, float speed, float value) {
+            Speed = speed;
+            MinValue = minValue;
+            MaxValue = maxValue;
+            valueTo = Random.Range(MinValue, MaxValue);
+            Result = value;
+            valueFrom = value;
+            valueTo = Random.Range(MinValue, MaxValue);
+            targetTime = Mathf.Abs(valueTo - valueFrom) / Speed;
+        }
+
+        void Reset() {
+            float prevSign = Mathf.Sign(valueTo-valueFrom);
+            valueFrom = valueTo;
+            if (prevSign > 0) {
+                valueTo = Random.Range(MinValue, Mathf.Lerp(Result, MinValue, 0.5f));
+            } else {
+                valueTo = Random.Range(MaxValue, Mathf.Lerp(Result, MaxValue, 0.5f));
+            }
+ 
+            targetTime = Mathf.Abs(valueTo - valueFrom) / Speed;
+        }
+
+        public void Update() {
+            if (timer > targetTime) {
+                timer = 0;
+                Reset();
+            }
+
+            float t = timer / targetTime;
+            t = Extension.LinearToSin(t);
+            Result = Mathf.LerpUnclamped(valueFrom, valueTo, t);
+            timer += Time.deltaTime;
+        }
+    }
+
+    public struct BindInfo {
+        public int VidxA;
+        public int VidxB;
+        public int VidxC;
+        public Vector3 Bary;
+        public PFU TrisSpace;
+
+        public BindInfo(int vidxa, int vidxb, int vidxc, Vector3 bary, PFU tspace   ) {
+            VidxA = vidxa;
+            VidxB = vidxb;
+            VidxC = vidxc;
+            Bary = bary;
+            TrisSpace = tspace;
+        }
+    }
+
+    [System.Serializable]
+    public struct PFU {
+        public Vector3 P;
+        public Vector3 F;
+        public Vector3 U;
+
+        public PFU(Matrix4x4 tm) {
+            P = tm.GetColumn(3);
+            F = tm.GetColumn(2);
+            U = tm.GetColumn(1);
+        }
+
+        public static PFU operator - ( PFU a, PFU b ) {
+            a.P -= b.P;
+            a.F -= b.F;
+            a.U -= b.U;
+            return a;
+        }
+
+        public static PFU operator + (PFU a, PFU b) {
+            a.P += b.P;
+            a.F += b.F;
+            a.U += b.U;
+            return a;
+        }
+
+        public static PFU operator * (PFU a, float t) {
+            a.P *= t;
+            a.F *= t;
+            a.U *= t;
+            return a;
+        }
+
+        public static PFU operator * (PFU a, Matrix4x4 matrix) {
+            a.P = matrix.MultiplyPoint3x4( a.P ) ;
+            a.F = matrix.MultiplyVector( a.F ) ;
+            a.U = matrix.MultiplyVector( a.U );
+            return a;
+        }
+
+        public Matrix4x4 Matrix {
+            get {
+                return Matrix4x4.TRS(P, Quaternion.LookRotation(F, U), Vector3.one);
+            }
+
+            set {
+                P = value.GetColumn(3);
+                F = value.GetColumn(2);
+                U = value.GetColumn(1);
+            }
+        } 
+    }
+
+    [System.Serializable]
+    public struct NumbersRange {
+        public int Min;
+        public int Max;
+
+        public NumbersRange(bool isWhole) {
+            Max = isWhole?0:int.MinValue;
+            Min = int.MaxValue;
+        }
+
+        public void Set(int number) {
+            Min = Mathf.Min(Min, number);
+            Max = Mathf.Max(Max, number);
+        }
+    } 
+
+    [System.Serializable]
+    public class ConstraintClip {
+        public PFU[] Frames;
+
+        public ConstraintClip(int framesCount) {
+            Frames = new PFU[framesCount];
+        }
+
+        public ConstraintClip GetCopy() {
+            ConstraintClip r = new ConstraintClip(Frames.Length);
+            for (int i = 0; i<r.Frames.Length; i++) {
+                r.Frames[i] = Frames[i];
+            }
+            return r;
+        }
+    }
+
+    public class TasksStack {
+
+        public class Task {
+
+            public string Name;
+            public float Iterations;
+            public float NormalizedFrom;
+            public float NormalizedTo;
+            public float Weight = 1;
+
+            public Task(string name ) {
+                Name = name;
+            }
+
+            public TaskInfo GetInfo( int iteration ) {
+                float persentage = (float)iteration / (float)Iterations;
+                float totalPersentage = Mathf.Lerp(NormalizedFrom, NormalizedTo, persentage);
+                return new TaskInfo(string.Format("{0} {1}%", Name, (persentage * 100).ToString("F0")), totalPersentage);
+            }
+
+            public TaskInfo GetInfo(float localPersentage ) {
+                float totalPersentage = Mathf.Lerp(NormalizedFrom, NormalizedTo, localPersentage);
+                return new TaskInfo(string.Format("{0} {1}%", Name, (localPersentage * 100).ToString("F0")), totalPersentage);
+            }
+        }
+
+        public string Name;
+        List<Task> items = new List<Task>();
+        Dictionary<string, Task> itemsDict = new Dictionary<string, Task>();
+        public int CurrentIdx = 0;
+
+        public Task this[string name] {
+            get {
+                return itemsDict[name];
+            }
+        }
+
+        public Task this[int idx] {
+            get {
+                return items[idx];
+            }
+        }
+
+        public TasksStack(string name) {
+            Name = name;
+            itemsDict = new Dictionary<string, Task>();
+        }
+
+        public void Add( string name, float iterations ) {
+            Task existing = null;
+            if (itemsDict.TryGetValue(name, out existing) == false) {
+                Task t = new Task( name );
+                t.Iterations = iterations;
+                itemsDict.Add(name, t);
+                items.Add(t);
+            }
+        }
+
+        public void Add(string name, float iterations, float weight) {
+            Task existing = null;
+            if (itemsDict.TryGetValue(name, out existing) == false) {
+                Task t = new Task(name);
+                t.Iterations = iterations;
+                t.Weight = weight;
+                itemsDict.Add(name, t);
+                items.Add(t);
+            }
+        }
+
+        public void Normalize() {
+            float summ = 0;
+
+            for (int i = 0; i<items.Count; i++) {
+                items[i].NormalizedFrom = summ;
+                summ += items[i].Weight;
+                items[i].NormalizedTo = summ;
+            }
+
+            for (int i = 0; i < items.Count; i++) {
+                items[i].NormalizedFrom /= summ;
+                items[i].NormalizedTo /= summ;
+            }
+        }
+
+  
+        public TaskInfo Done {
+            get {
+                return new TaskInfo(string.Format("{0} is done", Name), 1f);
+            }
+        }
+
+        public void PrintDebugInfo() {
+            for (int i = 0; i<items.Count; i++) {
+                Debug.LogFormat("{0} name: [{1}]  {2}% ", i, items[i].Name,  ((items[i].NormalizedTo - items[i].NormalizedFrom)*100f).ToString("F2") );
+                //Debug.LogFormat("{0} name: [{1}] from:{2} to:{3} weight:{4}",  i, items[i].Name, items[i].NormalizedFrom, items[i].NormalizedTo, items[i].Weight);
+            }
+        }
+    }
+
+    public static class Extension  {
+
+        public static float LinearToSin(float t) {
+            return 1f - (Mathf.Sin((t * 3.141592f) + 1.5708f) * 0.49999f + 0.5f);
+        }
+
+		public static float InverseLerpUnclamped( float a, float b, float value){
+ 			float result;
+			if (a != b) {
+				result = (value - a) / (b - a) ;
+			}
+			else {
+				result = 0;
+			}
+			return result;
+ 		}
+
+		public static float SmoothLoopCurve(float t, float minAmount, float maxAmount, float easeOffset, float easeLength){
+			t = Mathf.Clamp01(t);
+			if(t>=0.5f){
+				if( Mathf.Approximately(easeOffset, easeLength )){
+					return t<(1f-easeOffset)? minAmount : maxAmount;
+				} 
+				t = 0.5f+ Mathf.InverseLerp(1f - easeLength, 1f - easeOffset, t)*0.5f;
+			} else   {
+				if( Mathf.Approximately(easeOffset, easeLength )){
+					return t>( easeOffset)? minAmount : maxAmount;
+				} 
+				t = Mathf.InverseLerp(easeOffset, easeLength, t) * 0.5f;
+			} 
+			float result = Mathf.Sin( (t*6.28318f)+1.5708f )*0.49999f+0.5f;	
+			return Mathf.LerpUnclamped( minAmount, maxAmount, result );
+		}
+
+	 	public static void SpawnMesh(Mesh m, string name){
+	 		GameObject go = new GameObject(  name );
+	 		go.AddComponent<MeshFilter>().mesh = GameObject.Instantiate(m) as Mesh;
+            go.AddComponent<MeshRenderer>().sharedMaterial = new Material(Shader.Find("Standard"));
+ 
+	 	}
+
+        public static Material GetRandomMaterial( string name ) {
+ 
+            Material mat = new Material( (Material)Resources.Load("VertexAnimationToolsDefaultMaterial"));
+            mat.SetColor("_Color", Color.Lerp(Color.red, Color.Lerp(Color.green, Color.blue, Random.value), Random.value));
+            mat.name = name;
+ 
+            return mat;
+        }
+ 
+        public static Vector3[] Copy(Vector3[] source) {
+            Vector3[] result = new Vector3[source.Length];
+            System.Array.Copy(source, result, source.Length);
+            return result;
+        }
+
+        public static Vector3[] Delta(Vector3[] a, Vector3[] b) {
+            Vector3[] result = new Vector3[a.Length];
+            for (int i = 0; i < a.Length; i++) {
+                result[i] = b[i] - a[i];
+            }
+            return result;
+        }
+
+        public static void CopyDataTo(this Mesh m, Mesh other) {
+            other.Clear();
+            other.ClearBlendShapes();
+            other.vertices = m.vertices;
+            other.normals = m.normals;
+            other.tangents = m.tangents;
+            other.uv = m.uv;
+            other.triangles = m.triangles;
+            for (int i = 0; i<m.blendShapeCount; i++) {
+                Vector3[] bsPos = new Vector3[m.vertexCount];
+                Vector3[] bsNorms = new Vector3[m.vertexCount];
+                Vector3[] bsTangents = new Vector3[m.vertexCount];
+                m.GetBlendShapeFrameVertices(i, 0, bsPos, bsNorms, bsTangents);
+                string shapeName = m.GetBlendShapeName(i);
+                other.AddBlendShapeFrame(shapeName, 100, bsPos, bsNorms, bsTangents);
+            }
+        }
+
+    }
+ 
+}

Assets/Plugins/VertexAnimationTools_30/Scripts/Common/Extension.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 936601b300b4171418eaa8eb0fa844b5
+timeCreated: 1516884073
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/Scripts/Common/FramesArray.cs

@@ -0,0 +1,174 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System.IO;
+
+namespace VertexAnimationTools_30 {
+
+    public class FramesArray {
+
+        List<Vector3[]> frames = new List<Vector3[]>();
+       
+        public bool IsLoop;
+        public InterpolateModeEnum Interpolation;
+
+        public float step {
+            get {
+                return 1f / ((float)Count - (IsLoop ? 0 : 1)); 
+            }
+        }
+
+        float b1 = 0.166667f;
+        float b2 = 0.666667f;
+        float b3 = 0.166667f;
+ 
+        public FramesArray(  bool isLoop, InterpolateModeEnum interpolationMode) {
+            IsLoop = isLoop;
+            Interpolation = interpolationMode;
+            
+        }
+
+        public FramesArray( int framesCount, int verticesCount,  bool isLoop, InterpolateModeEnum interpolationMode) {
+            for (int i = 0; i<framesCount; i++) {
+                frames.Add(new Vector3[verticesCount]);
+            }
+            IsLoop = isLoop;
+            Interpolation = interpolationMode;
+         }
+
+        public void AddFrame(Vector3[] vertices) {
+            frames.Add(vertices);
+         }
+
+        public int Count {
+            get {
+                return frames.Count;
+            }
+        }
+
+        public FramesArray(FramesArray source) {
+            frames = new List<Vector3[]>(source.frames);
+            IsLoop = source.IsLoop;
+            Interpolation = source.Interpolation;
+ 
+        }
+
+        public Vector3 this[int frame, int vertex] {
+            get {
+                if (IsLoop) {
+                    frame = (int)Mathf.Repeat(frame, Count);
+                    return frames[frame][vertex];
+                } else {
+                    if (frame < 0) {
+                        Vector3 f0 = frames[0][vertex];
+                        Vector3 f1 = frames[1][vertex];
+                        Vector3 delta = f1 - f0;
+                        return f0 - delta;
+                    }
+                    if (frame >= Count) {
+                        Vector3 l0 = frames[Count - 1][vertex];
+                        Vector3 l1 = frames[Count - 2][vertex];
+                        Vector3 delta = l0 - l1;
+                        return l0 + delta;
+                    }
+ 
+                    return frames[frame][vertex];
+                }
+            }
+
+            set {
+                if (IsLoop) {
+                    frame = frame % Count;
+                } else {
+                    frame = Mathf.Clamp(frame, 0, Count);
+                }
+                frames[frame][vertex] = value;
+            }
+        }
+
+        public Vector3 this[float persentage, int vertex] {
+            get {
+                int a = Mathf.FloorToInt(persentage / step);
+                int b = a + 1;
+                float lv = (persentage - (a * step)) / step;
+
+                if (Interpolation == InterpolateModeEnum.Linear) {
+                    return Vector3.Lerp(this[a, vertex], this[b, vertex], lv);
+                } else {
+                    return HermitePoint(this[a - 1, vertex], this[a, vertex], this[b, vertex], this[b + 1, vertex], lv);
+                }
+            }
+        }
+
+        public Vector3[] this[int vertex] {
+            get {
+                Vector3[] result = new Vector3[Count];
+                for (int i = 0; i < result.Length; i++) {
+                    result[i] = this[i, vertex];
+                }
+                return result;
+            }
+
+            set {
+                for (int f = 0; f < value.Length; f++) {
+                    this[f, vertex] = value[f];
+                }
+            }
+
+        }
+
+        public int VerticesCount {
+            get {
+                return frames[0].Length;
+            }
+        }
+
+        Vector3 HermitePoint(Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3, float s) {
+            return new Vector3(hermiteInterplation(p0.x, p1.x, p2.x, p3.x, s), hermiteInterplation(p0.y, p1.y, p2.y, p3.y, s), hermiteInterplation(p0.z, p1.z, p2.z, p3.z, s));
+        }
+
+        float hermiteInterplation(float y0, float y1, float y2, float y3, float s) {
+            float mu2 = s * s;
+            float mu3 = mu2 * s;
+            float m0, m1;
+            float a0, a1, a2, a3;
+            m0 = (y1 - y0) / 2;
+            m0 += (y2 - y1) / 2;
+            m1 = (y2 - y1) / 2;
+            m1 += (y3 - y2) / 2;
+            a0 = 2 * mu3 - 3 * mu2 + 1;
+            a1 = mu3 - 2 * mu2 + s;
+            a2 = mu3 - mu2;
+            a3 = -2 * mu3 + 3 * mu2;
+            return (a0 * y1 + a1 * m0 + a2 * m1 + a3 * y2);
+        }
+
+        public IEnumerable<TaskInfo> SmoothIE(int iterations, float smoothMin, float smoothMax, float easeOffset, float easeLength) {
+            FramesArray smoothed = new FramesArray(this);
+            FramesArray temp = new FramesArray(this);
+ 
+            for (int i = 0; i < iterations; i++) {
+                for (int v = 0; v < smoothed.VerticesCount; v++) {
+                    for (int f = 0; f < smoothed.Count; f++) {
+                        smoothed[f, v] = BPoint(temp[f - 1, v], temp[f, v], temp[f + 1, v], temp[f + 2, v]);
+                    }
+                }
+                temp = new FramesArray(smoothed);
+                yield return new TaskInfo("Smoothing", i / (float)iterations);
+            }
+
+            for (int v = 0; v < smoothed.VerticesCount; v++) {
+                for (int f = 0; f < Count; f++) {
+                    float pers = (float)f / (float)(Count - 1);
+                    float lv = Extension.SmoothLoopCurve(pers, smoothMin, smoothMax, easeOffset, easeLength);
+                    this[f, v] = Vector3.LerpUnclamped(this[f, v], smoothed[f, v], lv);
+                }
+            }
+            yield return new TaskInfo("Smoothing", 1f);
+        }
+
+        Vector3 BPoint(Vector3 P1, Vector3 P2, Vector3 P3, Vector3 P4) {
+             return new Vector3(b1 * P1.x + b2 * P2.x + b3 * P3.x, b1 * P1.y + b2 * P2.y + b3 * P3.y, b1 * P1.z + b2 * P2.z + b3 * P3.z);
+        }
+    }
+}

Assets/Plugins/VertexAnimationTools_30/Scripts/Common/FramesArray.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 64459174141a2ee489370d84edaec840
+timeCreated: 1548847057
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/Scripts/Common/MeshSequenceInfo.cs

@@ -0,0 +1,146 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System.IO;
+
+
+namespace VertexAnimationTools_30 {
+
+    [System.Serializable]
+    public struct MeshSequenceInfo   {
+
+        public enum StateEnum {
+            Empty_path,
+            File_not_found,
+            Ready
+        }
+
+        public enum SortModeEnum {
+            ByDate,
+            ByNumber
+        }
+
+        [System.Serializable]
+        public struct ObjFileInfo {
+            public string FileName;
+            public int Hash;
+            public int ParsedNumber;
+            public FileInfo fi;
+        }
+
+        public StateEnum State;
+        public ObjFileInfo[] infos;
+        public string SequenceName;
+        public string DirectoryPath;
+        //public string Date;
+        SortModeEnum SortMode ;
+
+        public MeshSequenceInfo( string pathToAnyObj, SortModeEnum sortMode) {
+            SortMode = sortMode;
+            State = StateEnum.Empty_path;
+            SequenceName = "";
+            DirectoryPath = "";
+            infos = new ObjFileInfo[0];
+           // Date = System.DateTime.Now.ToString();
+
+            if (string.IsNullOrEmpty(pathToAnyObj)) {
+                return;
+            }
+
+            if (!File.Exists(pathToAnyObj)) {
+                State = StateEnum.File_not_found;
+                return;
+            }
+
+            DirectoryInfo di = (new FileInfo(pathToAnyObj)).Directory;
+            FileInfo[] fis = di.GetFiles("*.obj");
+            DirectoryPath = di.FullName;
+            infos = new ObjFileInfo[fis.Length];
+             
+            for (int i = 0; i < infos.Length; i++) {
+                infos[i] = new ObjFileInfo();
+                infos[i].fi = fis[i];
+                infos[i].FileName = Path.GetFileNameWithoutExtension(fis[i].FullName);
+                infos[i].ParsedNumber = GetNumberFromName(infos[i].FileName, ref infos[i].Hash);
+            }
+
+            if (SortMode == SortModeEnum.ByDate) {
+                System.Array.Sort(infos, InfosDateComparer);
+            } else {
+                System.Array.Sort(infos, InfosNumberComparer);
+            }
+            SequenceName = string.Format("[{0}-{1}]", infos[0].FileName, infos[infos.Length-1].FileName );
+             
+            State = StateEnum.Ready;
+           
+        }
+
+        public string ShortInfo {
+            get {
+                if (State != StateEnum.Ready) {
+                    return State.ToString().Replace('_',' ');
+                } else {
+                    return string.Format("{0} {1} frames", SequenceName, Count.ToString());
+                }
+            }
+        }
+
+        public int Count {
+            get {
+                if (infos == null) {
+                    return 0;
+                } else {
+                    return infos.Length;
+                }
+            }
+        }
+
+        public ObjFileInfo this[int index] {
+            get {
+                return infos[index];
+            }
+        }
+
+        int InfosNumberComparer(ObjFileInfo a, ObjFileInfo b) {
+            if (a.ParsedNumber == b.ParsedNumber) {
+                return a.Hash - b.Hash;
+            } else {
+                return   a.ParsedNumber - b.ParsedNumber;
+            }
+        }
+
+        int InfosDateComparer(ObjFileInfo a, ObjFileInfo b) {
+            int result;
+            if (a.fi.LastWriteTime == b.fi.LastWriteTime) {
+                result = 0;
+            } else if (a.fi.LastWriteTime < b.fi.LastWriteTime) {
+                result = -1;
+            } else {
+                result = 1;
+            }
+
+            return result;
+        }
+
+        int GetNumberFromName(string str, ref int prefixHash) {
+            char[] nameChars = str.ToCharArray();
+			int splitIdx = nameChars.Length;
+            for (int i = nameChars.Length - 1; i >= 0; i--) {
+				if (!char.IsDigit (nameChars [i])) {
+					break;
+				} else {
+					splitIdx = i;
+				}
+            }
+
+			string digitsPart = str.Substring( splitIdx );
+			string prefixPart = str.Substring(0, splitIdx);
+            prefixHash = prefixPart.GetHashCode();
+            int index = 0;
+            int.TryParse(digitsPart, out index);
+            return index;
+        }
+
+ 
+    }
+}

Assets/Plugins/VertexAnimationTools_30/Scripts/Common/MeshSequenceInfo.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f2a37cb99aebc5a4fadf719478be8cfa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/Scripts/Common/ObjData.cs

@@ -0,0 +1,1706 @@
+ using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System.Text.RegularExpressions; 
+
+namespace VertexAnimationTools_30{
+
+	public partial class ObjData {
+
+        #region UMESHVERTICES
+        public class UMeshVertex {
+            public int ThisIdx;
+            public PositionVertex Position;
+            public NormalVertex Normal;
+            public MapVertex UV;
+            public BindInfo Bi;
+
+            public override bool Equals(object obj) {
+                UMeshVertex other = (UMeshVertex)obj;
+                return Position == other.Position && Normal == other.Normal && UV == other.UV;
+            }
+
+            public override int GetHashCode() {
+                if (UV == null) {
+                    return Position.GetHashCode() + Normal.GetHashCode();
+                } else {
+                    return Position.GetHashCode() + Normal.GetHashCode() + UV.GetHashCode();
+                }
+            }
+
+            public void Bind (BindingHelper bh) {
+                PFU result = new PFU();
+                result.P = Position.Value;
+                result.F = Normal.Value;
+                result.U = UV.Tangent;
+                bh.Bind(result, ref Bi);
+            }
+
+ 
+        }
+
+
+        public class UMeshVerticesList {
+            Dictionary<UMeshVertex, int> itemsDict = new Dictionary<UMeshVertex, int>();
+            List<UMeshVertex> items = new List<UMeshVertex>();
+
+            public int Count {
+                get {
+                    return items.Count;
+                }
+            }
+
+            public UMeshVertex this[int idx] {
+                get {
+                    return items[idx];
+                }
+            }
+
+            public UMeshVertex this[PositionVertex position, MapVertex mapVertex, NormalVertex normalVertex] {
+                get {
+                    UMeshVertex newItem = new UMeshVertex();
+                    int idx = items.Count;
+                    newItem.ThisIdx = items.Count;
+                    newItem.Position = position;
+                    newItem.Normal = normalVertex;
+                    newItem.UV = mapVertex;
+
+                    int findedIdx = -1;
+                    if (itemsDict.TryGetValue(newItem, out findedIdx)) {
+                        return items[findedIdx];
+                    } else {
+                        itemsDict.Add(newItem, idx);
+                        items.Add(newItem);
+                        return newItem;
+                    }
+                }
+            }
+
+
+        }
+
+        #endregion
+
+        #region NORMALS
+        public class NormalVertex {
+ 
+            public Vector3 Value;
+            public float AO;
+            public bool IsInnerAO;
+            public int SmoothingGroup;
+            public PositionVertex Position;
+            HashSet<AdjacentPolygon> AdjacentPolygons = new HashSet<AdjacentPolygon>();
+            public AdjacentPolygon[] aAdjacentPolygons;
+            public List<NormalVertex> AdjacentNormals = new List<NormalVertex>();
+            public float Cavity;
+            public float AdjacentMult;
+
+
+            public NormalVertex(int smoothingGroup, PositionVertex posVert) {
+                Value = Vector3.zero;
+                SmoothingGroup = smoothingGroup;
+                Position = posVert;
+            }
+
+            public void Link ( Polygon p ) {
+                AdjacentPolygon ap = new AdjacentPolygon(p);
+                AdjacentPolygons.Add(ap);
+            }
+
+
+            public void OnPostBuild() {
+                aAdjacentPolygons = new AdjacentPolygon[AdjacentPolygons.Count];
+                AdjacentPolygons.CopyTo(aAdjacentPolygons);
+                for (int a = 0; a < aAdjacentPolygons.Length; a++) {
+                    AdjacentNormals.Add(aAdjacentPolygons[a].polygon.GetNextNormal(this));
+                }
+                AdjacentMult = 1f / (float)AdjacentNormals.Count;
+            }
+
+            public void CalcAdjacentAreaMults() {
+                float areaSumm = 0;
+
+                for (int a = 0; a < aAdjacentPolygons.Length; a++) {
+                    areaSumm += aAdjacentPolygons[a].polygon.Area;
+                }
+
+                for (int a = 0; a < aAdjacentPolygons.Length; a++) {
+                    aAdjacentPolygons[a].AreaMult = aAdjacentPolygons[a].polygon.Area / areaSumm;
+                }
+
+            }
+
+            public void CalcNormal() {
+                Value = Vector3.zero;
+                for (int a = 0; a < aAdjacentPolygons.Length; a++) {
+                    Value += aAdjacentPolygons[a].polygon.Normal;
+                }
+                //Value.Normalize();
+                float num = Vector3.Magnitude(Value);
+                if (num > 1E-05) {
+                    
+                    Value /= num;
+                } else {
+                    //Debug.Log("Zero norm");
+                    for (int e = 0; e < AdjacentNormals.Count; e++) {
+                        Value += (Position.Value - AdjacentNormals[e].Position.Value);
+                    }
+                    Value.Normalize();
+                }
+            }
+
+            public override bool Equals(object obj) {
+                NormalVertex other = (NormalVertex)obj;
+                if (other == null) {
+                    return false;
+                }
+                return SmoothingGroup == other.SmoothingGroup && Position == other.Position;
+            }
+
+            public override int GetHashCode() {
+                return Position.GetHashCode() ^ SmoothingGroup;
+            }
+
+            public void PrintInfo() {
+                float checkAreaSumm = 0;
+                foreach (AdjacentPolygon p in AdjacentPolygons) {
+                    checkAreaSumm += p.AreaMult;
+                }
+                Debug.LogFormat("Normal Vertex adjacent polygons count {0}, checkAreaSumm:{1}", AdjacentPolygons.Count, checkAreaSumm);
+            }
+        }
+
+        [System.Serializable]
+        public class NormalsList {
+            List<NormalVertex> items = new List<NormalVertex>();
+            Dictionary<NormalVertex, int> itemsDict = new Dictionary<NormalVertex, int>();
+
+
+            public NormalVertex this[PositionVertex posVertex, int sg] {
+                get {
+                    NormalVertex newNormal = new NormalVertex(sg, posVertex);
+                    int findedIdx = -1;
+
+                    if (itemsDict.TryGetValue(newNormal, out findedIdx)) {
+                        return items[findedIdx];
+                    }
+
+                    itemsDict.Add(newNormal, items.Count);
+                    items.Add(newNormal);
+                    return newNormal;
+                }
+            }
+
+            public int Count {
+                get {
+                    return items.Count;
+                }
+            }
+
+            public NormalVertex this[int idx] {
+                get {
+                    return items[idx];
+                }
+            }
+
+        }
+
+        #endregion
+
+        #region MAPVERTEX
+        public class MapVertex {
+            public UMeshVertex UMV;
+            public Vector2 Value;
+
+            HashSet<Polygon> AdjacentPolygons = new HashSet<Polygon>();
+            Polygon[] aAdjacentPolygons;
+
+
+            public Vector3 Tangent;
+            public float TangentW;
+
+            public MapVertex(Vector2 uv) {
+                Value = uv;
+            }
+
+            public void Link(Polygon p, UMeshVertex umv) {
+                AdjacentPolygons.Add(p);
+                UMV = umv;
+            }
+
+            public void OnPostBuild() {
+                aAdjacentPolygons = new Polygon[AdjacentPolygons.Count];
+                AdjacentPolygons.CopyTo(aAdjacentPolygons);
+            }
+
+            public void PrintInfo() {
+                Debug.LogFormat("   AdjacentPolygons.count{0} ", AdjacentPolygons.Count);
+            }
+
+            public void CalcTangent() {
+                //Debug.LogFormat("CalcTangent() aAdjacentPolygons.Length{0} ParentNormal not null :{1}", aAdjacentPolygons.Length, ParentNormal!=null);
+                Vector3 rTangent = Vector3.zero;
+                for (int i = 0; i < aAdjacentPolygons.Length; i++) {
+                    rTangent += aAdjacentPolygons[i].Tangent;
+                }
+
+
+                Tangent = Vector3.Cross(Vector3.Cross(UMV.Normal.Value, rTangent), UMV.Normal.Value);
+                Tangent.Normalize();
+            }
+        }
+
+        public class MapVerticesList {
+            List<MapVertex> objmvs = new List<MapVertex>();
+            Dictionary<PositionVertex, MapVertex> forgedMvs = new Dictionary<PositionVertex, MapVertex>();
+
+            public void AddObjMV(Vector2 uv) {
+                objmvs.Add(new MapVertex(uv));
+            }
+
+            public MapVertex this[PositionVertex pv, int objMvIdx] {
+                get {
+   
+                    if (objMvIdx >= 0) {
+                        return objmvs[objMvIdx];
+                    }
+ 
+                    MapVertex mv = null;
+                    if (forgedMvs.TryGetValue(pv, out mv)) {
+                        return mv;
+                    }
+                    mv = new MapVertex(pv.BindPos);
+                    forgedMvs.Add(pv, mv);
+                    return mv;
+                }
+            }
+
+            public IEnumerable<MapVertex> AllMapVerts() {
+                for (int i = 0; i<objmvs.Count; i++) {
+                    yield return objmvs[i];
+                }
+                foreach (KeyValuePair<PositionVertex, MapVertex> mv in forgedMvs) {
+                    yield return mv.Value;
+                }
+            }
+
+            public void PrintInfo(bool detailed ) {
+                string result = string.Format("objmvs: {0} forgedMvs:{1}", objmvs.Count, forgedMvs.Count);
+                Debug.Log(result);
+                if (detailed) {
+                    foreach (MapVertex mv in AllMapVerts()) {
+                        Debug.LogFormat("mv:{0}", mv.Value);
+                    }
+
+                }
+            }
+
+            public int Count {
+                get {
+                    return objmvs.Count + forgedMvs.Count;
+                }
+            }
+        }
+        #endregion
+
+        #region FACE
+        public class Face {
+            public int Idx;
+            public UMeshVertex Va;
+            public UMeshVertex Vb;
+            public UMeshVertex Vc;
+            public Polygon ParentPolygon;
+            public float TangentT;
+            public float TangentW;
+            public float Sign;
+            public Vector3 Normal;
+            public Vector3 Tangent;
+            public Vector3 Center;
+            public float Area;
+            bool isParallel;
+            public float tv;
+
+            public Face(int idx, UMeshVertex va, UMeshVertex vb, UMeshVertex vc, Polygon p) {
+                Idx = idx;
+                ParentPolygon = p;
+                Va = va;
+                Vb = vb;
+                Vc = vc;
+                Vector2 _0 = Va.UV.Value;
+                Vector2 _1 = Vb.UV.Value;
+                Vector2 _2 = Vc.UV.Value;
+                 Vector2 ab = _1 - _0;
+                 Vector2 ac = _2 - _0;
+
+
+
+                TangentW = -Mathf.Sign(Vector2.Dot(ac, new Vector2(ab.y, -ab.x)));
+                if (Mathf.Approximately(_1.y, _2.y)) {
+                    isParallel = true;
+                    Sign = Mathf.Sign(_2.x - _1.x);
+                } else {
+                    isParallel = false;
+                    tv = (_0.y - _1.y) / (_2.y - _1.y);
+                    float _x = Mathf.LerpUnclamped(_1.x, _2.x, tv);
+                    Sign = _0.x < _x ? 1 : -1;
+                }
+
+    //            
+				//if(Mathf.Approximately(uvB.y, uvC.y)){
+				//	TangentT = -Mathf.Abs(uvB.x - uvC.x) * 1000f;
+				//	 Sign = Mathf.Sign(uvB.x - uvC.x);
+ 			//	} else {
+				//	TangentT = Extension.InverseLerpUnclamped(uvB.y, uvC.y, uvA.y);
+				//	Sign = ((uvB.y > uvC.y) ? -1 : 1) * TangentW;
+				//}
+                
+            }
+
+            public void Update() {
+                Normal = GetNormal();
+                Tangent = GetTangent();
+                Center = GetCenter();
+                Area = GetArea();
+            }
+
+
+
+            //public void UpdateTangents(Vector3[] mvertices) {
+            //    Vector3 _0 = mvertices[face.v0];
+            //    Vector3 _1 = mvertices[face.v1];
+            //    Vector3 _2 = mvertices[face.v2];
+            //    if (isParallel) {
+            //        tangent = ((_2 - _1) * sign);
+            //    } else {
+            //        Vector3 pointOn12 = Vector3.LerpUnclamped(_1, _2, tv);
+            //        tangent = (pointOn12 - _0) * sign;
+            //    }
+            //}
+
+            Vector3 GetTangent() {
+                Vector3 _0 = Va.Position.Value;
+                Vector3 _1 = Vb.Position.Value;
+                Vector3 _2 = Vc.Position.Value;
+ 
+                if (isParallel) {
+                    return ((_2 - _1) * Sign);
+                } else {
+                    Vector3 pointOn12 = Vector3.LerpUnclamped(_1, _2, tv);
+                    return (pointOn12 - _0) * Sign;
+                }
+
+            }
+
+            //Vector3 GetTangent() {
+            //    Vector3 a = Va.Position.Value;
+            //    Vector3 b = Vb.Position.Value;
+            //    Vector3 c = Vc.Position.Value;
+            //    return (((b + (c - b) * TangentT) - a) * Sign).normalized;
+
+
+            //}
+
+            Vector3 GetNormal() {
+                Vector3 ab = (Vb.Position.Value - Va.Position.Value);
+                Vector3 ac = (Vc.Position.Value - Va.Position.Value);
+                return Vector3.Cross(ab*100, ac*100).normalized;
+            }
+
+            float GetArea() {
+                return Vector3.Cross( (Va.Position.Value - Vb.Position.Value)*100, (Va.Position.Value - Vc.Position.Value)*100).magnitude * 0.005f;
+            }
+
+            Vector3 GetCenter() {
+                return Va.Position.Value / 3f + Vb.Position.Value / 3f + Vc.Position.Value / 3f;
+            }
+
+            public Matrix4x4 TM {
+                get {
+                    float div = 1f / 3f;
+                    Vector3 a = Va.Position.Value;
+                    Vector3 b = Vb.Position.Value;
+                    Vector3 c = Vc.Position.Value;
+                    Vector3 na = Va.Normal.Value;
+                    Vector3 nb = Vb.Normal.Value;
+                    Vector3 nc = Vc.Normal.Value;
+                    Vector3 trisCenter = (a + b + c) * div;
+                    Vector3 averageUp = (na + nb + nc) * div;
+                    Vector3 xDir = a - trisCenter;
+                    Vector3 zDir = b - trisCenter;
+                    Matrix4x4 res = Matrix4x4.identity;
+                    res.SetColumn(0, (Vector4)xDir);
+                    res.SetColumn(1, (Vector4)averageUp);
+                    res.SetColumn(2, (Vector4)zDir);
+                    res.SetColumn(3, trisCenter);
+                    res[15] = 1;
+                    return res;
+                }
+            }
+        }
+        #endregion
+
+        #region POSITIONVERTEX
+        public class PositionVertex {
+
+       
+            public Vector3 BindPos;
+            public Vector3 Value;
+
+
+            public HashSet<AdjacentPolygon> AdjacentPolygons = new HashSet<AdjacentPolygon>();
+            //public List<Polygon> AdjacentPolygons = new List<Polygon>();
+            //public List<float> AdjacentAreaMults;
+
+            public bool IsInner;
+            public float InnerAO;
+
+            public PositionVertex(Vector3 pos) {
+                Value = pos;
+                BindPos = pos;
+            }
+
+            public void Link(Polygon poly ) {
+                AdjacentPolygons.Add(new AdjacentPolygon(poly));
+            }
+
+            public void CalcAdjacentAreaMults() {
+                float areaSumm = 0;
+                foreach (AdjacentPolygon ap in AdjacentPolygons) {
+                    areaSumm += ap.polygon.Area;
+                }
+                foreach (AdjacentPolygon ap in AdjacentPolygons) {
+                    ap.AreaMult = ap.polygon.Area / areaSumm;
+                }
+            }
+
+        }
+        #endregion
+        
+        #region POLYGON
+        public class Polygon {
+            public int SmoothingGroup;
+            public Vector3 Normal;
+            public Vector3 Tangent;
+            public Vector3 Center;
+            public float Area;
+            public List<UMeshVertex> corners = new List<UMeshVertex>();
+            public float AO;
+            public float InnerAO;
+            public float Cavity;
+            public float FacesMult;
+            public float CornersMult;
+
+            public List<Face> Faces = new List<Face>();
+
+            public Polygon(int sg) {
+                SmoothingGroup = sg;
+            }
+
+            public void BuildTriangles(List<Face> allFaces, List<int> submeshTrisList, bool flipNormals) {
+                if (flipNormals) {
+                    if (corners.Count > 4) {
+                        Vector3[] cornerPosition = new Vector3[corners.Count];
+                        for (int c = 0; c < corners.Count; c++) {
+                            cornerPosition[c] = corners[c].Position.Value;
+                        }
+                        PolygonTriangulator pt = new PolygonTriangulator(cornerPosition);
+                        int trisCount = pt.trianglesIndeces.Count / 3;
+                        for (int t = 0; t < trisCount; t++) {
+                            UMeshVertex c0 = corners[pt.trianglesIndeces[t * 3 + 2]];
+                            UMeshVertex c1 = corners[pt.trianglesIndeces[t * 3 + 1]];
+                            UMeshVertex c2 = corners[pt.trianglesIndeces[t * 3]];
+                            submeshTrisList.Add(c0.ThisIdx);
+                            submeshTrisList.Add(c1.ThisIdx);
+                            submeshTrisList.Add(c2.ThisIdx);
+                            Face face = new Face(allFaces.Count, c0, c1, c2, this);
+                            allFaces.Add(face);
+                            Faces.Add(face);
+                        }
+                    } else {
+                        for (int c = 1; c < corners.Count - 1; c++) {
+                            submeshTrisList.Add(corners[c + 1].ThisIdx);
+                            submeshTrisList.Add(corners[c].ThisIdx);
+                            submeshTrisList.Add(corners[0].ThisIdx);
+                            Face face = new Face(allFaces.Count, corners[c + 1], corners[c], corners[0], this);
+                            allFaces.Add(face);
+                            Faces.Add(face);
+                        }
+                    }
+                } else {
+                    if (corners.Count > 4) {
+                        Vector3[] cornerPosition = new Vector3[corners.Count];
+                        for (int c = 0; c < corners.Count; c++) {
+                            cornerPosition[c] = corners[c].Position.Value;
+                        }
+                        PolygonTriangulator pt = new PolygonTriangulator(cornerPosition);
+                        int trisCount = pt.trianglesIndeces.Count / 3;
+                        for (int t = 0; t < trisCount; t++) {
+                            UMeshVertex c0 = corners[pt.trianglesIndeces[t * 3]];
+                            UMeshVertex c1 = corners[pt.trianglesIndeces[t * 3 + 1]];
+                            UMeshVertex c2 = corners[pt.trianglesIndeces[t * 3 + 2]];
+                            submeshTrisList.Add(c0.ThisIdx);
+                            submeshTrisList.Add(c1.ThisIdx);
+                            submeshTrisList.Add(c2.ThisIdx);
+                            Face face = new Face(allFaces.Count, c0, c1, c2, this);
+                            allFaces.Add(face);
+                            Faces.Add(face);
+                        }
+                    } else {
+                        for (int c = 1; c < corners.Count - 1; c++) {
+                            submeshTrisList.Add(corners[0].ThisIdx);
+                            submeshTrisList.Add(corners[c].ThisIdx);
+                            submeshTrisList.Add(corners[c + 1].ThisIdx);
+                            Face face = new Face(allFaces.Count, corners[0], corners[c], corners[c + 1], this);
+                            allFaces.Add(face);
+                            Faces.Add(face);
+                        }
+                    }
+                }
+                FacesMult = 1f / (float)Faces.Count;
+                CornersMult = 1f / (float)corners.Count;
+
+                float tangentW = 0;
+                for (int f = 0; f < Faces.Count; f++) {
+                    tangentW += Faces[f].TangentW;
+                }
+                tangentW = tangentW >= 0 ? 1f : -1f;
+
+                for (int c = 0; c < corners.Count; c++) {
+                    corners[c].UV.TangentW = tangentW;
+                }
+
+            }
+
+            public void Update(NormalsRecalculationModeEnum normalMode) {
+                for (int f = 0; f < Faces.Count; f++) {
+                    Faces[f].Update();
+                }
+
+                Tangent = Vector3.zero;
+                Normal = Vector3.zero;
+                Center = Vector3.zero;
+                Area = 0;
+
+                if (normalMode == NormalsRecalculationModeEnum.Default) {
+                    for (int f = 0; f < Faces.Count; f++) {
+                        Face face = Faces[f];
+                        Tangent += face.Tangent;
+                        Normal += face.Normal;
+                        Area += face.Area;
+                        Center += face.Center * FacesMult;
+                    }
+                } else {
+                    for (int f = 0; f < Faces.Count; f++) {
+                        Face face = Faces[f];
+                        Tangent += face.Tangent * face.Area;
+                        Normal += face.Normal * face.Area;
+                        Area += face.Area;
+                        Center += face.Center * FacesMult;
+                    }
+                }
+ 
+            }
+
+            public NormalVertex GetNextNormal(NormalVertex nv) {
+                int nvIdx = -1;
+                for (int c = 0; c < corners.Count; c++) {
+                    if (corners[c].Normal == nv) {
+                        nvIdx = c;
+                        break;
+                    }
+                }
+                return corners[(nvIdx + 1) % corners.Count].Normal;
+            }
+
+            public Matrix4x4 TM {
+                get {
+                    return Matrix4x4.TRS(Center, Quaternion.LookRotation(Normal, corners[0].Position.Value - Center), Vector3.one);
+                }
+
+            }
+
+            public bool ContainsTris(int trisIdx) {
+                for (int t = 0; t < Faces.Count; t++) {
+                    if (Faces[t].Idx == trisIdx) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        }
+
+        public class AdjacentPolygon {
+            public Polygon polygon;
+            public float AreaMult;
+
+            public AdjacentPolygon(Polygon p) {
+                polygon = p;
+                AreaMult = 0;
+            }
+
+            public override bool Equals(object obj) {
+                return ((AdjacentPolygon)obj).polygon == this.polygon;
+            }
+
+            public override int GetHashCode() {
+                return this.polygon.GetHashCode();
+            }
+        }
+
+        #endregion
+
+        #region SUBMESHES 
+        public class SubMesh {
+            public string MaterialName;
+            public List<int> TrisIndeces = new List<int>();
+            public List<Polygon> Polygons = new List<Polygon>();
+
+            public SubMesh(string materialName) {
+                MaterialName = materialName;
+            }
+
+            public void AddPolygon(Polygon p) {
+                Polygons.Add(p);
+            }
+        }
+
+        public class SubMeshesList {
+            List<SubMesh> items = new List<SubMesh>();
+            public SubMesh Current = new SubMesh("Default submesh");
+
+            public void SetCurrent(string materialName) {
+                for (int s = 0; s < items.Count; s++) {
+                    if (items[s].MaterialName == materialName) {
+                        Current = items[s];
+                        return;
+                    }
+                }
+                SubMesh newItem = new SubMesh(materialName);
+                items.Add(newItem);
+                Current = newItem;
+            }
+
+            public int Count {
+                get {
+                    if (items.Count == 0) {
+                        return 1;
+                    } else {
+                        return items.Count;
+                    }
+                }
+            }
+
+            public SubMesh this[int idx] {
+                get {
+                    if (items.Count == 0) {
+                        return Current;
+                    } else {
+                        return items[idx];
+                    }
+                }
+            }
+
+            public void RemoveUnused() {
+                List<SubMesh> unused = new List<SubMesh>();
+                for (int s = items.Count - 1; s >= 0; s--) {
+                    if (items[s].Polygons.Count == 0) {
+                        unused.Add(items[s]);
+                    }
+                }
+
+                for (int i = 0; i < unused.Count; i++) {
+                    items.Remove(unused[i]);
+                }
+            }
+
+
+            public string[] GetNames() {
+                string[] result = new string[items.Count];
+                for (int i = 0; i < items.Count; i++) {
+                    result[i] = items[i].MaterialName;
+                }
+                return result;
+            }
+
+            public List<Polygon> GetAllPolygons() {
+                List<Polygon> result = new List<Polygon>();
+                for (int i = 0; i<Count; i++) {
+                    result.AddRange(this[i].Polygons);
+                }
+
+                return result;
+            }
+        }
+        #endregion
+
+        #region POLYGONTRIANGULATOR
+        public class PolygonTriangulator {
+
+            public class Corner {
+                public int SourceIdx;
+                public Vector3 WorldPoint;
+                public Vector2 PolygonSpacePoint;
+                public float Angle;
+                public bool Used;
+
+                public Corner(Vector3 worldPoint, int idx) {
+                    WorldPoint = worldPoint;
+                    SourceIdx = idx;
+                }
+            }
+            List<Corner> corners;
+            public List<int> trianglesIndeces;
+            Corner minAngleCorner = null;
+
+            public PolygonTriangulator(Vector3[] cornerPositions) {
+                corners = new List<Corner>();
+                for (int i = 0; i < cornerPositions.Length; i++) {
+                    corners.Add(new Corner(cornerPositions[i], i));
+                }
+
+                Vector3 PolyCenter = Vector3.zero;
+                float mult = 1f / (float)corners.Count;
+                for (int i = 0; i < corners.Count; i++) {
+                    PolyCenter += corners[i].WorldPoint * mult;
+                }
+
+                Vector3 PolyNormal = Vector3.zero;
+
+                for (int i = 0; i < corners.Count; i++) {
+                    int nexti = (i + 1) % (corners.Count - 1);
+                    Vector3 dirI = corners[i].WorldPoint - PolyCenter;
+                    Vector3 nextI = corners[nexti].WorldPoint - PolyCenter;
+                    PolyNormal += Vector3.Cross(dirI, nextI);
+                }
+                PolyNormal.Normalize();
+                Vector3 PolyUp = (corners[0].WorldPoint - PolyCenter).normalized;
+
+                Matrix4x4 PolygonTM = Matrix4x4.TRS(PolyCenter, Quaternion.LookRotation(PolyNormal, PolyUp), Vector3.one);
+                    
+ 
+                Matrix4x4 polygonTMInverted = PolygonTM.inverse;
+                for (int c = 0; c < corners.Count; c++) {
+                    corners[c].PolygonSpacePoint = polygonTMInverted.MultiplyPoint3x4(corners[c].WorldPoint);
+                }
+                trianglesIndeces = new List<int>();
+
+
+                int trisCount = corners.Count - 2;
+                for (int c = 0; c < trisCount; c++) {
+                    UpdateAngles();
+                    int i = corners.IndexOf(minAngleCorner);
+                    int previ = i - 1;
+                    if (previ < 0) {
+                        previ = corners.Count - 1;
+                    }
+
+                    int nexti = i + 1;
+                    if (nexti >= corners.Count) {
+                        nexti = 0;
+                    }
+                    trianglesIndeces.Add(corners[i].SourceIdx);
+                    trianglesIndeces.Add(corners[nexti].SourceIdx);
+                    trianglesIndeces.Add(corners[previ].SourceIdx);
+
+                    if (minAngleCorner != null) {
+                        corners.Remove(minAngleCorner);
+                    }
+                }
+
+            }
+
+            void UpdateAngles() {
+                float minAngle = float.MaxValue;
+                for (int i = 0; i < corners.Count; i++) {
+                    int previ = i - 1;
+                    if (previ < 0) {
+                        previ = corners.Count - 1;
+                    }
+
+                    int nexti = i + 1;
+                    if (nexti >= corners.Count) {
+                        nexti = 0;
+                    }
+
+                    Vector2 prevDir = corners[i].PolygonSpacePoint - corners[previ].PolygonSpacePoint;
+                    float prevAngle = Mathf.Atan2(prevDir.y, prevDir.x);
+
+                    Vector2 nextDir = corners[nexti].PolygonSpacePoint - corners[i].PolygonSpacePoint;
+                    float nextAngle = Mathf.Atan2(nextDir.y, nextDir.x);
+
+                    corners[i].Angle = 180 - Mathf.DeltaAngle(prevAngle * Mathf.Rad2Deg, nextAngle * Mathf.Rad2Deg);
+
+                    if (corners[i].Angle < minAngle) {
+                        if (IsTriangleAllow(previ, i, nexti)) {
+                            minAngleCorner = corners[i];
+                            minAngle = corners[i].Angle;
+                        }
+                    }
+                }
+            }
+
+            bool IsTriangleAllow(int idxa, int idxb, int idxc) {
+                Triangle2d tris = new Triangle2d(corners[idxa].PolygonSpacePoint, corners[idxb].PolygonSpacePoint, corners[idxc].PolygonSpacePoint);
+                Vector3 bary = new Vector3();
+                for (int c = 0; c < corners.Count; c++) {
+                    if (c == idxa || c == idxb || c == idxc) {
+                        continue;
+                    }
+                    if (tris.PointTest(corners[c].PolygonSpacePoint, ref bary)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+
+
+        }
+
+        #endregion
+
+        #region TRIANGLE2D
+        public struct Triangle2d {
+            public Vector2 a;
+            public Vector2 b;
+            public Vector2 c;
+            Vector2 v0;
+            Vector2 v1;
+            float dot00;
+            float dot01;
+            float dot11;
+            float invDenom;
+
+            public Triangle2d(Vector2 _a, Vector2 _b, Vector2 _c) {
+                a = _a;
+                b = _b;
+                c = _c;
+                v0 = c - a;
+                v1 = b - a;
+                dot00 = Vector2.Dot(v0, v0);
+                dot01 = Vector2.Dot(v0, v1);
+                dot11 = Vector2.Dot(v1, v1);
+                invDenom = 1f / (dot00 * dot11 - dot01 * dot01);
+            }
+
+            public bool PointTest(Vector2 p, ref Vector3 bary) {
+                Vector2 v2 = p - a;
+                float dot02 = Vector2.Dot(v0, v2);
+                float dot12 = Vector2.Dot(v1, v2);
+                bary.z = (dot11 * dot02 - dot01 * dot12) * invDenom; // u
+                bary.y = (dot00 * dot12 - dot01 * dot02) * invDenom; // v
+                bary.x = 1f - (bary.z + bary.y);
+                return (bary.z >= 0) && (bary.y >= 0) && (bary.z + bary.y < 1f);
+            }
+        }
+        #endregion
+
+        public enum SmoothingGroupImportModeEnum {
+            FromObjFile,
+            FlatShading,
+            SmoothAll
+        }
+
+        public enum NormalsRecalculationModeEnum {
+            Default,
+            Weighted,
+        }
+
+        public enum ObjLineIdEnum{
+			v,
+			vt,
+			f,
+			s,
+			s_off,
+			usemtl,
+			other
+		}
+
+        public string Name;
+		public bool FlipNormals; 
+
+		public bool CalculateNormals;
+		public bool ImportUV;
+		public bool CalculateTangents;
+
+ 		public SmoothingGroupImportModeEnum SmoothingGroupsMode;
+ 		public NormalsRecalculationModeEnum NormalsRecalculationMode;
+
+		public Vector3[] UM_vertices;
+		Vector2[] UM_uv;
+		public Vector3[] UM_normals;
+		public Vector3[] UM_v3tangents;
+        public Color[] UM_colors;
+        public Vector4[] UM_v4tangents;
+		public Bounds UM_Bounds;
+		public Vector3[] VerticesToSet;
+		public List<Face> AllFaces = new List<Face>();
+		public SubMeshesList SubMeshes;	
+		public List<PositionVertex> Vertices = new List<PositionVertex>();
+		public NormalsList Normals = new NormalsList();
+        public MapVerticesList mapVertices = new MapVerticesList();
+
+        Vector3[] bindVerts ;
+        Vector3[] bindNormals;
+        Vector3[] bindTangents;
+
+#if UNITY_2017_3_OR_NEWER
+        public UnityEngine.Rendering.IndexFormat IndexFormat = UnityEngine.Rendering.IndexFormat.UInt16; 
+#endif
+
+        public UMeshVerticesList UnityVertices = new UMeshVerticesList();
+		public List <Polygon> AllPolygons = new List<Polygon>();
+ 
+		Mesh refMesh;
+		string[] subString;
+ 
+		System.IO.TextReader objFile;
+		int currentSmoothingGroup = 0;
+	 	bool offSGMode = false;
+	 	int offSGcounter = 1;
+		char[] spaceSeparator = @" ".ToCharArray();
+ 	 	float objFileLength;
+
+        public System.Diagnostics.Stopwatch BuildSW;
+        public System.Diagnostics.Stopwatch ApplySW;
+        FaceLineParser fplp = new FaceLineParser();
+
+        public ObjData(string path){
+			System.IO.FileInfo fi = new System.IO.FileInfo(path);
+			if(!fi.Exists){
+				Debug.LogErrorFormat("obj file {0} not found", path);
+			}
+			Name = fi.Name;
+ 
+ 			objFile = System.IO.File.OpenText(path);
+            BuildSW = new System.Diagnostics.Stopwatch();
+            ApplySW = new System.Diagnostics.Stopwatch();
+        }
+
+        public void Build() {
+            BuildSW.Reset();
+            BuildSW.Start();
+            refMesh = new Mesh();
+
+            #if UNITY_2017_3_OR_NEWER
+            refMesh.indexFormat = IndexFormat;
+            #endif
+
+            SubMeshes = new SubMeshesList();
+       
+            while (true) {
+                string str = objFile.ReadLine();
+                if (str == null) {
+#if UNITY_WSA
+                    objFile.Dispose();
+#else
+
+                    objFile.Close();
+#endif
+
+                    break;
+                }
+
+                ObjLineIdEnum lineId = GetObjLineId(str);
+                if (lineId == ObjLineIdEnum.vt) {
+                    subString = str.Split(spaceSeparator, System.StringSplitOptions.RemoveEmptyEntries);
+                    Vector2 uv = new Vector2(ToFloat(subString[1]), ToFloat(subString[2]));
+                    mapVertices.AddObjMV (uv) ;
+                } else if (lineId == ObjLineIdEnum.v) {
+                    subString = str.Split(spaceSeparator, System.StringSplitOptions.RemoveEmptyEntries);
+                    Vector3 defaultPos = new Vector3(ToFloat(subString[1]), ToFloat(subString[2]), ToFloat(subString[3]));
+                    Vertices.Add(new PositionVertex(defaultPos));
+                } else if (lineId == ObjLineIdEnum.usemtl) {
+                    SubMeshes.SetCurrent(str.Remove(0, 7));
+                } else if (lineId == ObjLineIdEnum.s_off) {
+                    offSGMode = true;
+                } else if (lineId == ObjLineIdEnum.s) {
+                    offSGMode = false;
+                    currentSmoothingGroup = ToInt(str.Remove(0, 2));
+                } else if (lineId == ObjLineIdEnum.f) {
+                    int sg = currentSmoothingGroup;
+                    if (SmoothingGroupsMode == SmoothingGroupImportModeEnum.SmoothAll) {
+                        sg = 0;
+                    } else if (SmoothingGroupsMode == SmoothingGroupImportModeEnum.FlatShading || offSGMode) {
+                        sg = -offSGcounter;
+                        offSGcounter++;
+                    }
+                    fplp.Parse(str);
+
+                    Polygon poly = new Polygon(sg);
+ 
+                    for (int c = 0; c < fplp.corners.Count; c++) {
+                        PositionVertex pv = Vertices[fplp.corners[c].VertIdx];
+                        MapVertex mv = mapVertices[pv, fplp.corners[c].UvIdx];
+                        NormalVertex nv = Normals[pv, sg];
+                        UMeshVertex umv = UnityVertices[pv, mv, nv];
+
+                        pv.Link(poly);
+                        mv.Link(poly, umv);
+                        nv.Link( poly );
+                        poly.corners.Add(umv);
+                    }
+                    SubMeshes.Current.AddPolygon(poly);
+                }
+            }
+
+
+            AllPolygons = SubMeshes.GetAllPolygons();
+
+            foreach (MapVertex mv in mapVertices.AllMapVerts() ) {
+                mv.OnPostBuild();
+            }
+
+            for (int n = 0; n < Normals.Count; n++) {
+                Normals[n].OnPostBuild();
+            }
+ 
+
+            UM_vertices = new Vector3[UnityVertices.Count];
+			UM_normals = new Vector3[UnityVertices.Count];
+			UM_v3tangents = new Vector3[UnityVertices.Count];
+			UM_v4tangents = new Vector4[UnityVertices.Count];
+			 
+			VerticesToSet = new Vector3[Vertices.Count];
+			for(int v = 0; v<Vertices.Count; v++){
+				VerticesToSet[v] = Vertices[v].BindPos;
+			}
+
+ 
+            refMesh.vertices = UM_vertices;
+
+            SubMeshes.RemoveUnused();
+			refMesh.subMeshCount = SubMeshes.Count;
+			for(int s = 0; s<SubMeshes.Count; s++){
+				for(int p = 0; p<SubMeshes[s].Polygons.Count; p++){
+					SubMeshes[s].Polygons[p].BuildTriangles( AllFaces, SubMeshes[s].TrisIndeces, FlipNormals  );
+				}
+				refMesh.SetTriangles(SubMeshes[s].TrisIndeces.ToArray(), s);
+				 
+			}
+
+			if(ImportUV){
+				UM_uv = new Vector2[UnityVertices.Count];
+				for(int v = 0; v<UnityVertices.Count; v++){
+					UM_uv[v] = UnityVertices[v].UV.Value;
+				}
+				refMesh.uv = UM_uv;
+
+				if(CalculateNormals){
+					if(CalculateTangents){
+						for(int v = 0; v<UM_v4tangents.Length; v++){
+							UM_v4tangents[v] = new Vector4(0,0,0, UnityVertices[v].UV.TangentW);
+						}
+					}
+				}
+			}
+
+            BuildSW.Stop();
+		}
+
+
+        public IEnumerable<TaskInfo> BindIE( BindingHelper bh ) {
+            string tiname = string.Format("Binding {0}", Name);
+            for (int i = 0; i < UnityVertices.Count; i++) {
+                UnityVertices[i].Bind(bh);
+                yield return new TaskInfo(tiname, i/(float)UnityVertices.Count);
+            }
+            yield return new TaskInfo(tiname, 1f);
+        }
+
+        public void BindToBh(BindingHelper bh) {
+            for (int i = 0; i < UnityVertices.Count; i++) {
+                UnityVertices[i].Bind(bh);
+            }
+        }
+
+        public void ApplyBinded(BindingHelper bh) {
+            //Debug.LogFormat("Apply binded od vertices count:{0} bh:{1} UnityVertices.Count:{2}", Vertices.Count, bh, UnityVertices.Count);
+            for (int i = 0; i<UnityVertices.Count; i++) {
+                PFU current = UnityVertices[i].Bi.TrisSpace * bh.GetTrisTM(UnityVertices[i].Bi.VidxA, UnityVertices[i].Bi.VidxB, UnityVertices[i].Bi.VidxC, UnityVertices[i].Bi.Bary);
+                UM_vertices[i] = current.P;
+                UM_normals[i] = current.F;
+                UM_v3tangents[i] = current.U;
+            }
+        }
+
+		public void Apply( bool SwapYZ, float Scale ){
+            ApplySW.Reset();
+            ApplySW.Start();
+ 			for(int v = 0; v<VerticesToSet.Length; v++){
+				Vector3 vert = VerticesToSet[v];
+                if (SwapYZ) {
+                    vert.Set(vert.x, vert.z, vert.y);
+                }
+                vert *= Scale;
+                 if (v == 0){
+					UM_Bounds = new Bounds(vert, Vector3.zero);
+				} else {
+					UM_Bounds.Encapsulate( vert );
+				}
+				Vertices[v].Value = vert;
+			}
+ 
+
+			for(int v = 0; v<UnityVertices.Count; v++){
+				UM_vertices[v] = UnityVertices[v].Position.Value;
+			}
+ 
+
+			if(CalculateNormals){
+  
+				for(int p = 0; p<AllPolygons.Count; p++){
+					AllPolygons[p].Update(  NormalsRecalculationMode );
+			 	}
+
+				for( int n = 0; n<Normals.Count; n++ ){
+					Normals[n].CalcNormal();
+				}
+
+				for(int v = 0; v<UnityVertices.Count; v++){
+					UM_normals[v] = UnityVertices[v].Normal.Value;
+				}
+			}
+
+            if (ImportUV && CalculateNormals && CalculateTangents) {
+                for (int v = 0; v < UnityVertices.Count; v++) {
+                    UnityVertices[v].UV.CalcTangent();
+                    Vector3 tan = UnityVertices[v].UV.Tangent;
+                    UM_v3tangents[v] = tan;
+                    UM_v4tangents[v].x = tan.x;
+                    UM_v4tangents[v].y = tan.y;
+                    UM_v4tangents[v].z = tan.z;
+                }
+ 
+            }
+
+            refMesh.vertices = UM_vertices;
+            refMesh.normals = UM_normals;
+            refMesh.bounds = UM_Bounds;
+            refMesh.tangents = UM_v4tangents;
+            ApplySW.Stop();
+        }
+
+        public static bool GetObjInfo(string pathToObj, ref string name, ref int vertCount, ref int polygonsCount, ref int submeshesCount ){
+            name = System.IO.Path.GetFileNameWithoutExtension(pathToObj);
+            System.IO.TextReader objFile = System.IO.File.OpenText(pathToObj);
+			List<string> submeshesNames = new List<string>();
+
+ 			while (true){
+				string str = objFile.ReadLine();
+				if(str == null) break;
+				ObjLineIdEnum id = GetObjLineId(str);
+				if(id == ObjLineIdEnum.v ){
+					vertCount ++;
+				} else if( id == ObjLineIdEnum.f ){
+ 					polygonsCount ++;	
+				} else if( id == ObjLineIdEnum.usemtl ){
+					string submeshName = str.Remove(0,7);
+					if(!submeshesNames.Contains(submeshName)){
+						submeshesNames.Add(submeshName);
+					}
+				}
+			}
+
+
+#if UNITY_WSA
+                    objFile.Dispose();
+#else
+
+            objFile.Close();
+#endif
+            submeshesCount = submeshesNames.Count;
+			return polygonsCount>0 && vertCount>0; 
+		}
+
+        public static bool GetObjInfo(string pathToObj, ref int vertCount) {
+            System.IO.TextReader objFile = System.IO.File.OpenText(pathToObj);
+            while (true) {
+                string str = objFile.ReadLine();
+                if (str == null) break;
+                ObjLineIdEnum id = GetObjLineId(str);
+                if (id == ObjLineIdEnum.v) {
+                    vertCount++;
+                }
+            }
+
+#if UNITY_WSA
+                    objFile.Dispose();
+#else
+
+            objFile.Close();
+#endif
+            return vertCount > 0;
+        }
+
+        public void SetBindPoseFrameVertices() {
+            bindVerts = Extension.Copy( UM_vertices );
+            bindNormals = Extension.Copy( UM_normals );
+            bindTangents = Extension.Copy( UM_v3tangents );
+        }
+
+        public static Vector3[] GetVerticesFromObj(string path , bool swapAxis, float scale) {
+            List<Vector3> verticesList = new List<Vector3>();
+            System.IO.TextReader objFile = System.IO.File.OpenText(path);
+            char[] spaceSeparator = @" ".ToCharArray();
+            string[] subString;
+            while (true) {
+                string str = objFile.ReadLine();
+                if (str == null) break;
+                ObjLineIdEnum id = GetObjLineId(str);
+                if (id == ObjLineIdEnum.v) {
+                    subString = str.Split(spaceSeparator, System.StringSplitOptions.RemoveEmptyEntries);
+                    Vector3 defaultPos = new Vector3(ToFloat(subString[1]), ToFloat(subString[2]), ToFloat(subString[3]));
+                    if (swapAxis) {
+                        defaultPos.Set(defaultPos.x, defaultPos.z, defaultPos.y);
+                    }
+                    defaultPos = defaultPos * scale;
+                    verticesList.Add(defaultPos);
+                }
+            }
+#if UNITY_WSA
+                    objFile.Dispose();
+#else
+
+            objFile.Close();
+#endif
+            return verticesList.ToArray();
+        }
+
+        public Vector3[] GetPosDeltas() {
+            return Extension.Delta(bindVerts, UM_vertices);
+        }
+
+        public Vector3[] GetNormsDeltas() {
+            return Extension.Delta(bindNormals, UM_normals);
+        }
+
+        public Vector3[] GetTansDeltas() {
+            return Extension.Delta(bindTangents, UM_v3tangents);
+        }
+
+
+        public static ObjLineIdEnum GetObjLineId (string str){
+			char[] chars = str.ToCharArray();
+			if(chars.Length<2){
+				return ObjLineIdEnum.other;
+			}
+			if(chars[0]=='v' && chars[1] == ' '){
+				return ObjLineIdEnum.v;
+			}
+			if(chars[0]=='v' && chars[1] == 't'){
+				return ObjLineIdEnum.vt;
+			}
+			if(chars[0]=='f' && chars[1] == ' '){
+				return ObjLineIdEnum.f;
+			}
+			if(chars[0]=='s' && chars[1] == ' '){
+				return ObjLineIdEnum.s;
+			}
+			//usemtl
+			if(chars[0]=='u' && chars[1]=='s' && chars[2]=='e' && chars[3]=='m' && chars[4]=='t' && chars[5]=='l'  ){
+				return ObjLineIdEnum.usemtl;
+			}
+			if(chars[0]=='s' && chars[1]==' ' && chars[2]=='o' && chars[3]=='f' && chars[4]=='f'){
+				return ObjLineIdEnum.s_off;
+			}
+
+			return ObjLineIdEnum.other;
+		}
+
+        static float ToFloat(string s) {
+             return float.Parse(s, System.Globalization.CultureInfo.InvariantCulture );
+        }
+
+        int ToInt(string s) {
+            int result = 0;
+            int.TryParse(s, out result);
+            return result;
+        }
+
+        public class FaceLineParser {
+            public class Corner {
+                public int VertIdx = -1;
+                public int UvIdx = -1;
+                public int NormalIdx = -1;
+
+                public List<char>[] chars = { new List<char>(), new List<char>(), new List<char>(), };
+                public int ci;
+
+                public void Parse() {
+                    if (chars[0].Count > 0) {
+                        int.TryParse(new string(chars[0].ToArray()), out VertIdx);
+                        VertIdx--;
+                    }
+
+                    if (chars[1].Count > 0) {
+                        int.TryParse(new string(chars[1].ToArray()), out UvIdx);
+                        UvIdx--;
+                    }
+
+                    if (chars[2].Count > 0) {
+                        int.TryParse(new string(chars[2].ToArray()), out NormalIdx);
+                        NormalIdx--;
+                    }
+                }
+
+            }
+ 
+
+            public List<Corner> corners = new List<Corner>();
+
+            public void Parse(string str) {
+                corners.Clear();
+                char[] ca = str.ToCharArray();
+
+                Corner current = null;
+
+                for (int i = 2; i<ca.Length; i++) {
+					char c = ca[i];
+					if (char.IsDigit(c)) {
+						if (current == null) {
+							current = new Corner();
+						}
+						current.chars[current.ci].Add(c);
+					} 
+
+                    if (ca[i] == '/') {
+                        current.ci++;
+                        continue;
+                    }
+
+                    if (ca[i] == ' ') {
+                        if (current != null) {
+                            corners.Add(current);
+                            current = null;
+                        }
+                        continue;
+                    }
+
+                }
+				if (current != null) {
+					corners.Add(current);
+				}
+
+                for (int c = 0; c<corners.Count; c++) {
+                    corners[c].Parse();
+                }
+            }
+
+            public void PrintDebug() {
+                string result = string.Format("corners count {0} ", corners.Count);
+                for (int i = 0; i<corners.Count; i++) {
+                    result += string.Format( " {0}/{1}/{2} ", corners[i].VertIdx, corners[i].UvIdx, corners[i].NormalIdx );
+                }
+                Debug.Log(result);
+            }
+
+        }
+ 
+        public bool CalcVertexColor( VertexColorsSettings settings ) {
+            ProjectionSamples ps = Resources.Load<ProjectionSamples>("VertexAnimationTools_ProjectionSamples");
+            bool innerOcclusionEnabled = settings.InnerVertexOcclusion && settings.InnerVertexOcclusionAmount > 0;
+            bool ambientOcclusionEnabled = settings.AmbientOcclusion && settings.AmbientOcclusionAmount > 0;
+            bool cavityEnabled = settings.Cavity && settings.CavityAmount > 0;
+
+
+            if (!innerOcclusionEnabled && !ambientOcclusionEnabled && !cavityEnabled) {
+                return false;
+            }
+
+            Vector3[] sphereDirs = ps.SphereSamples[0].Dirs;
+            Vector3[] domeDirs = ps.DomeSamples[(int)settings.quality].Dirs;
+
+            RaycastHit hit = new RaycastHit();
+            RaycastHit ihit = new RaycastHit();
+            Matrix4x4 objTM = settings.go.transform.localToWorldMatrix;
+
+            if (!CalculateNormals) {
+                for (int p = 0; p < AllPolygons.Count; p++) {
+                    AllPolygons[p].Update(NormalsRecalculationMode);
+                }
+
+                for (int n = 0; n < Normals.Count; n++) {
+                    Normals[n].CalcNormal();
+                }
+            }
+
+            for (int n = 0; n < Normals.Count; n++) {
+                Normals[n].CalcAdjacentAreaMults();
+            }
+
+            for (int v = 0; v < Vertices.Count; v++) {
+                Vertices[v].CalcAdjacentAreaMults();
+            }
+
+
+#region CAVITY
+            if (cavityEnabled) {
+                for (int n = 0; n < Normals.Count; n++) {
+                    ObjData.NormalVertex norm = Normals[n];
+                    norm.Cavity = 0;
+
+                    for (int a = 0; a < norm.AdjacentNormals.Count; a++) {
+                        Vector3 toanv = (norm.AdjacentNormals[a].Position.Value - norm.Position.Value).normalized;
+                        float angle = Mathf.InverseLerp(settings.CavityAngleMax, settings.CavityAngleMin, Vector3.Angle(toanv, norm.Value));
+                        norm.Cavity += angle * norm.AdjacentMult;
+                    }
+                }
+                for (int i = 0; i < settings.CavityBlurIterations; i++) {
+                    for (int p = 0; p < AllPolygons.Count; p++) {
+                        ObjData.Polygon poly = AllPolygons[p];
+                        poly.Cavity = 0;
+                        for (int c = 0; c < poly.corners.Count; c++) {
+                            poly.Cavity += poly.corners[c].Normal.Cavity * poly.CornersMult;
+                        }
+                    }
+
+                    for (int n = 0; n < Normals.Count; n++) {
+                        ObjData.NormalVertex norm = Normals[n];
+                        float polyCurvature = 0;
+                        int counter = 0;
+                        for (int a = 0; a < norm.aAdjacentPolygons.Length; a++) {
+                            ObjData.AdjacentPolygon p = norm.aAdjacentPolygons[a];
+                            polyCurvature += p.polygon.Cavity * p.AreaMult;
+                            counter++;
+                        }
+
+                        norm.Cavity = Mathf.Lerp(norm.Cavity, polyCurvature, settings.CavityBlur);
+                    }
+                }
+            }
+#endregion
+
+            if (ambientOcclusionEnabled || innerOcclusionEnabled) {
+
+#region CREATECOLLIDERS
+                GameObject mcGO = new GameObject("mcGO");
+                mcGO.transform.position = settings.go.transform.position;
+                mcGO.transform.rotation = settings.go.transform.rotation;
+                mcGO.transform.localScale = settings.go.transform.localScale;
+                MeshCollider mc = mcGO.AddComponent<MeshCollider>();
+                mc.sharedMesh = refMesh;
+
+                GameObject imcGO = new GameObject("imcGO");
+                imcGO.transform.position = settings.go.transform.position;
+                imcGO.transform.rotation = settings.go.transform.rotation;
+                imcGO.transform.localScale = settings.go.transform.localScale;
+                MeshCollider imc = imcGO.AddComponent<MeshCollider>();
+
+                //INVERT MC
+                Mesh inverted = Object.Instantiate(refMesh) as Mesh;
+                int[] tris = inverted.triangles;
+                for (int t = 0; t < tris.Length; t += 3) {
+                    int t0 = tris[t + 2];
+                    int t1 = tris[t + 1];
+                    int t2 = tris[t];
+                    tris[t] = t0;
+                    tris[t + 1] = t1;
+                    tris[t + 2] = t2;
+                }
+
+                inverted.triangles = tris;
+                imc.sharedMesh = inverted;
+#endregion
+
+#region INNERVERTEX
+                if (innerOcclusionEnabled) {
+                    for (int v = 0; v < Vertices.Count; v++) {
+                        ObjData.PositionVertex vert = Vertices[v];
+
+                        Vector3 normal = Vector3.zero;
+
+                        foreach (ObjData.AdjacentPolygon ap in vert.AdjacentPolygons) {
+                            normal += ap.polygon.Normal.normalized * ap.AreaMult;
+                        }
+
+ 
+                        Vector3 vertWP = objTM.MultiplyPoint3x4(vert.Value + normal * 0.01f);
+
+                        int innerHitCount = 0;
+                        int outerHitCount = 0;
+                        vert.InnerAO = 0;
+                        for (int s = 0; s < sphereDirs.Length; s++) {
+                            Ray sampleRay = new Ray(vertWP, sphereDirs[s]);
+                            float dist = float.MaxValue;
+                            float idist = float.MaxValue;
+                            if (mc.Raycast(sampleRay, out hit, float.MaxValue)) {
+                                dist = hit.distance;
+                            }
+                            if (imc.Raycast(sampleRay, out ihit, float.MaxValue)) {
+                                idist = ihit.distance;
+                            }
+
+
+                            if (idist < dist) {
+                                innerHitCount++;
+                            } else {
+                                outerHitCount++;
+                            }
+                            if (innerHitCount >= outerHitCount) {
+                                vert.IsInner = true;
+                                vert.InnerAO = 1;
+                            }
+
+                        }
+                    }
+
+                    for (int i = 0; i < settings.InnerVertexOcclusionBlurIterations; i++) {
+                        for (int p = 0; p < AllPolygons.Count; p++) {
+                            ObjData.Polygon poly = AllPolygons[p];
+                            poly.InnerAO = 0;
+                            for (int c = 0; c < poly.corners.Count; c++) {
+                                poly.InnerAO += poly.corners[c].Position.InnerAO * poly.CornersMult;
+                            }
+                        }
+
+                        for (int n = 0; n < Vertices.Count; n++) {
+                            ObjData.PositionVertex vert = Vertices[n];
+                            float ainnerAO = 0;
+                            foreach (ObjData.AdjacentPolygon ap in vert.AdjacentPolygons) {
+                                ainnerAO += ap.polygon.InnerAO * ap.AreaMult;
+                            }
+                            vert.InnerAO = Mathf.Lerp(vert.InnerAO, ainnerAO, settings.InnerVertexOcclusionBlur);
+                        }
+                    }
+                }
+#endregion
+
+#region AmbientOcclusion
+                if (ambientOcclusionEnabled) {
+                    float samplesMult = 1f / (float)domeDirs.Length;
+                    for (int p = 0; p < AllPolygons.Count; p++) {
+                        ObjData.Polygon poly = AllPolygons[p];
+                        poly.AO = 0;
+                        Matrix4x4 ptm = objTM * poly.TM;
+                        for (int i = 0; i < domeDirs.Length; i++) {
+                            Vector3 dir = ptm.MultiplyVector(domeDirs[i]);
+                            Ray sampleRay = new Ray((Vector3)ptm.GetColumn(3), dir);
+                            if (mc.Raycast(sampleRay, out hit, settings.AmbientOcclusionRadius)) {
+                                poly.AO += Mathf.InverseLerp(settings.AmbientOcclusionRadius, 0, hit.distance) * samplesMult;
+                            }
+
+                        }
+                    }
+
+                    for (int n = 0; n < Normals.Count; n++) {
+                        ObjData.NormalVertex norm = Normals[n];
+                        for (int a = 0; a < norm.aAdjacentPolygons.Length; a++) {
+                            norm.AO += norm.aAdjacentPolygons[a].polygon.AO * norm.aAdjacentPolygons[a].AreaMult;
+                        }
+                    }
+
+                    for (int i = 0; i < settings.AmbientOcclusionBlurIterations; i++) {
+                        for (int p = 0; p < AllPolygons.Count; p++) {
+                            ObjData.Polygon poly = AllPolygons[p];
+                            poly.AO = 0;
+                            for (int c = 0; c < poly.corners.Count; c++) {
+                                poly.AO += poly.corners[c].Normal.AO * poly.CornersMult;
+                            }
+
+                        }
+
+                        for (int n = 0; n < Normals.Count; n++) {
+                            ObjData.NormalVertex norm = Normals[n];
+                            float nao = 0;
+
+                            for (int a = 0; a < norm.aAdjacentPolygons.Length; a++) {
+                                nao += norm.aAdjacentPolygons[a].polygon.AO * norm.aAdjacentPolygons[a].AreaMult;
+                            }
+
+                            norm.AO = Mathf.LerpUnclamped(norm.AO, nao, settings.AmbientOcclusionBlur);
+                        }
+                    }
+                }
+#endregion
+
+                Object.DestroyImmediate(mcGO);
+                Object.DestroyImmediate(imcGO);
+
+            }
+
+            UM_colors = new Color[UnityVertices.Count];
+            for (int v = 0; v < UnityVertices.Count; v++) {
+                UM_colors[v].a = 1f - (UnityVertices[v].Normal.Cavity * settings.CavityAmount);
+                UM_colors[v].a -= (UnityVertices[v].Position.InnerAO * settings.InnerVertexOcclusionAmount);
+                UM_colors[v].a -= (UnityVertices[v].Normal.AO * settings.AmbientOcclusionAmount);
+            }
+            return true;
+         }
+
+        [System.Serializable]
+        public struct VertexColorsSettings {
+            public GameObject go;
+            public ProjectionQualityEnum quality;
+           
+            public bool Cavity;
+            public float CavityAmount;
+            public float CavityAngleMin;
+            public float CavityAngleMax;
+            public float CavityBlur;
+            public int CavityBlurIterations;
+
+            public bool InnerVertexOcclusion;
+            public float InnerVertexOcclusionAmount;
+            public float InnerVertexOcclusionBlur;
+            public int InnerVertexOcclusionBlurIterations;
+
+            public bool AmbientOcclusion;
+            public float AmbientOcclusionAmount;
+            public float AmbientOcclusionRadius;
+            public float AmbientOcclusionBlur;
+            public int AmbientOcclusionBlurIterations;
+
+
+            public bool AnyEnabled {
+                get {
+                    return InnerVertexOcclusion || Cavity || AmbientOcclusion;
+                }
+            }
+
+            public VertexColorsSettings(bool enableAO) {
+                go = null;
+                Cavity = false;
+                CavityAmount = 1;
+                CavityAngleMin = 70f;
+                CavityAngleMax = 90f;
+                CavityBlur = 1f;
+                CavityBlurIterations = 1;
+                InnerVertexOcclusion = false;
+                InnerVertexOcclusionAmount = 0.75f;
+                InnerVertexOcclusionBlur = 1;
+                InnerVertexOcclusionBlurIterations = 1;
+                AmbientOcclusion = enableAO;
+                AmbientOcclusionAmount = 1;
+                AmbientOcclusionRadius = 1;
+                AmbientOcclusionBlur = 1;
+                AmbientOcclusionBlurIterations = 1;
+                quality = ProjectionQualityEnum.Medium;
+            }
+
+        }
+
+        public Mesh Snapshot {
+            get {
+                return Object.Instantiate(refMesh) as Mesh;
+            }
+        }
+
+        public void CopyTo(Mesh m) {
+            m.Clear();
+#if UNITY_2017_3_OR_NEWER
+            m.indexFormat = IndexFormat;
+#endif
+            m.vertices = UM_vertices;
+            m.subMeshCount = refMesh.subMeshCount;
+            for (int i = 0; i<refMesh.subMeshCount; i++) {
+                m.SetTriangles(refMesh.GetTriangles(i), i );
+            }
+            m.bounds = refMesh.bounds;
+            m.colors = refMesh.colors;
+            m.uv = refMesh.uv;
+            m.normals = UM_normals;
+            m.tangents = UM_v4tangents;
+            //Debug.LogFormat("od copy indexformat:{0} buildsw:{1} applysw:{2}", m.indexFormat, BuildSW.ElapsedMilliseconds, ApplySW.ElapsedMilliseconds);
+        }    
+    }
+}

Assets/Plugins/VertexAnimationTools_30/Scripts/Common/ObjData.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 985a76634afaf4c4cb248839aab022c9
+timeCreated: 1521625718
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/Scripts/Common/PointCacheData.cs

@@ -0,0 +1,273 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System.IO;
+
+namespace VertexAnimationTools_30 {
+
+	public class PointCacheData {
+		public string Name;
+	 	public FramesArray Frames;
+        public PointCache.Clip clip;
+        PointCache.Clip.ImportSettings cis;
+        public PointCache pointCache;
+        public int geometryVerticesCount;
+        public bool IsMeshSequence;
+        TasksStack tstack;
+
+        public PointCacheData(PointCache.Clip _clip, PointCache _pointCache, int _geometryVerticesCount) {
+            clip = _clip;
+            cis = clip.PreImport;
+            pointCache = _pointCache;
+            geometryVerticesCount = _geometryVerticesCount;
+            IsMeshSequence = Path.GetExtension(cis.FilePath) == ".obj";
+        
+            tstack = new TasksStack(string.Format("Build clip {0} data", cis.Name));
+            if (IsMeshSequence) {
+                MeshSequenceInfo msi = new MeshSequenceInfo(cis.FilePath, MeshSequenceInfo.SortModeEnum.ByNumber);
+                tstack.Add("Read .obj sequence", msi.infos.Length + cis.TransitionFramesCount, 3f );
+            } else {
+                tstack.Add("Read .pc2 file",  cis.ImportRangeLength + cis.TransitionFramesCount);
+            }
+ 
+
+
+            if (cis.ChangeFramesCount) {
+                tstack.Add("Change frames count",  cis.ClampedCustomFramesCount);
+            }
+
+
+
+            if (cis.EnableMotionSmoothing) {
+                tstack.Add("Motion smoothing", geometryVerticesCount);
+            }
+
+            if (cis.EnableNormalizeSpeed) {
+                tstack.Add("Normalize speed", geometryVerticesCount);
+            }
+
+            if (cis.GenerageMotionPaths) {
+                tstack.Add("Generage Motion Paths", geometryVerticesCount);
+            }
+
+            tstack.Normalize();
+        }
+
+ 
+
+        Vector3[] ReadFrame(BinaryReader br, int vertsCount ) {
+            Vector3[] vertices = new Vector3[vertsCount];
+            for (int v = 0; v < vertsCount; v++) {
+                Vector3 pos = new Vector3();
+                pos.x = br.ReadSingle();
+                pos.y = br.ReadSingle();
+                pos.z = br.ReadSingle();
+                if (cis.SwapYZAxis) {
+                    pos.Set(pos.x, pos.z, pos.y);
+                }
+                pos = pos * cis.Scale;
+                vertices[v] = pos;
+            }
+            return vertices;
+        }
+
+        public IEnumerable<TaskInfo> Build (){
+            Frames = new FramesArray(cis.IsLoop, cis.SubFrameInterpolation);
+            FramesArray TransitionFrames = new FramesArray(false, InterpolateModeEnum.Linear);
+
+            int readFramesCounter = 0;
+            if (IsMeshSequence) {
+                MeshSequenceInfo msi = new MeshSequenceInfo( cis.FilePath, MeshSequenceInfo.SortModeEnum.ByNumber );
+
+                for (int f = cis.EndTransitionFrom; f<cis.EndTransitionTo; f++) {
+                    Vector3[] objVertices = ObjData.GetVerticesFromObj(msi.infos[f].fi.FullName, cis.SwapYZAxis, cis.Scale);
+                    TransitionFrames.AddFrame(objVertices);
+                    readFramesCounter++;
+                    yield return tstack["Read .obj sequence"].GetInfo(readFramesCounter);
+                }
+ 
+                for (int f = cis.ImportRangeFrom; f < cis.ImportRangeTo; f++ ) {
+                    Vector3[] objVertices = ObjData.GetVerticesFromObj( msi.infos[f].fi.FullName, cis.SwapYZAxis, cis.Scale);
+                    if (objVertices.Length != geometryVerticesCount) {
+                        yield return new TaskInfo(string.Format("Error: frame {0} vertex count mismatch", msi.infos[f].fi.FullName), -1);
+                    }
+                    Frames.AddFrame(objVertices);
+                    readFramesCounter++;
+                    yield return tstack["Read .obj sequence"].GetInfo(readFramesCounter);
+                }
+
+                for (int f = cis.BeginTransitionFrom; f < cis.BeginTransitionTo; f++) {
+                    Vector3[] objVertices = ObjData.GetVerticesFromObj(msi.infos[f].fi.FullName, cis.SwapYZAxis, cis.Scale);
+                    TransitionFrames.AddFrame(objVertices);
+                    readFramesCounter++;
+                    yield return tstack["Read .obj sequence"].GetInfo(readFramesCounter);
+                }
+            } else {
+                Name = (new FileInfo(cis.FilePath)).Name;
+                FileStream fs = new FileStream(cis.FilePath, FileMode.Open);
+                BinaryReader binReader = new BinaryReader(fs);
+                binReader.ReadChars(12); //signature
+                binReader.ReadInt32(); //file version
+                int VerticesCount = binReader.ReadInt32();
+                binReader.ReadSingle(); // start frame
+                binReader.ReadSingle(); //sample rate
+                binReader.ReadInt32(); // int sourceFramesCount;
+
+ 
+
+                for (int f = 0; f < cis.EndTransitionFrom; f++) {
+                    for (int v = 0; v < VerticesCount; v++) {
+                        binReader.ReadSingle();
+                        binReader.ReadSingle();
+                        binReader.ReadSingle();
+                    }
+
+ 
+                }
+
+                // end transition
+                for (int f = cis.EndTransitionFrom; f < cis.EndTransitionTo; f++) {
+                    TransitionFrames.AddFrame( ReadFrame(binReader, geometryVerticesCount));
+                    readFramesCounter++;
+                    yield return tstack["Read .pc2 file"].GetInfo(readFramesCounter);
+                }
+
+                // frames
+                for (int f = cis.ImportRangeFrom; f < cis.ImportRangeTo; f++) {
+                    Frames.AddFrame(ReadFrame(binReader, geometryVerticesCount));
+                    readFramesCounter++;
+                    yield return tstack["Read .pc2 file"].GetInfo(readFramesCounter);
+                }
+
+
+                // begin transition
+                for (int f = cis.BeginTransitionFrom; f < cis.BeginTransitionTo; f++) {
+                    TransitionFrames.AddFrame(ReadFrame(binReader, geometryVerticesCount));
+                    readFramesCounter++;
+                    yield return tstack["Read .pc2 file"].GetInfo(readFramesCounter);
+                }
+
+
+#if UNITY_WSA
+                binReader.Dispose();
+                fs.Dispose();
+
+#else
+                binReader.Close();
+                fs.Close();
+#endif
+
+
+
+
+            }
+
+            if (cis.TransitionMode == TransitionModeEnum.Begin ) {
+                for (int f = 0; f < TransitionFrames.Count; f++) {
+                    float flv =    f / (float)TransitionFrames.Count  ;
+                    flv = Extension.LinearToSin(flv);
+                    for (int v = 0; v < geometryVerticesCount; v++) {
+                        Vector3 sVert = Vector3.LerpUnclamped(TransitionFrames[f, v], Frames[f, v], flv);
+                        Frames[f, v] = sVert;
+                    }
+                }
+            }
+
+            if (cis.TransitionMode == TransitionModeEnum.End) {
+                for (int f = 0; f < TransitionFrames.Count; f++) {
+                    float flv = f / (float)TransitionFrames.Count;
+                    flv =  Extension.LinearToSin(flv);
+                    int frameIdx = Frames.Count - f-1;
+                    int transitionIdx = TransitionFrames.Count - f-1;
+                    for (int v = 0; v < geometryVerticesCount; v++) {
+                        Vector3 sVert = Vector3.LerpUnclamped(  TransitionFrames[transitionIdx, v], Frames[frameIdx, v],  flv);
+                        Frames[frameIdx, v] = sVert;
+                    }
+                }
+            }
+
+            if (cis.ChangeFramesCount){
+ 
+                FramesArray retimedFrames = new FramesArray(cis.ClampedCustomFramesCount, Frames.VerticesCount, cis.IsLoop, cis.SubFrameInterpolation);
+				float step = cis.IsLoop ? 1f/(float)cis.CustomFramesCount : 1f/(cis.ClampedCustomFramesCount - 1);
+ 				for(int f = 0; f<retimedFrames.Count; f++){
+					float persentage = f*step;
+					for (int v = 0; v < Frames.VerticesCount; v++) {
+						retimedFrames[f,v] = Frames[ persentage, v ];
+					}
+                    yield return tstack["Change frames count"].GetInfo(f); 
+				}
+				Frames = retimedFrames;
+			}
+
+            if (cis.EnableMotionSmoothing){
+                foreach (TaskInfo ti in Frames.SmoothIE(cis.MotionSmoothIterations, cis.MotionSmoothAmountMin, cis.MotionSmoothAmountMax, cis.MotionSmoothEaseOffset, cis.MotionSmoothEaseLength)) {
+                    yield return tstack["Motion smoothing"].GetInfo(ti.Persentage) ;
+                }
+            }
+
+            if (cis.EnableNormalizeSpeed) {
+                for (int v = 0; v < Frames.VerticesCount; v++) {
+                    Vector3[] modified = Frames[v];
+                    if (cis.IsLoop) {
+                        Vector3[] modifiedLooped = new Vector3[modified.Length + 1];
+                        modified.CopyTo(modifiedLooped, 0);
+                        modifiedLooped[modifiedLooped.Length-1] = modifiedLooped[0];
+                        modified = modifiedLooped;
+                    }
+                    
+                    NormalizedSpline ns = new NormalizedSpline(modified);
+                    float stepMult = 1f / (modified.Length - 1);
+                    for (int f = 0; f < modified.Length; f++) {
+                        modified[f] = Vector3.LerpUnclamped(modified[f], ns.GetPoint(f * stepMult), cis.NormalizeSpeedPercentage);
+                    }
+                    Frames[v] = modified;
+                    yield return tstack["Normalize speed"].GetInfo(v);
+                }
+            }
+
+            clip.MotionPathVertices = null;
+ 
+            clip.MotionPathsCount = 0;
+
+            if (cis.GenerageMotionPaths) {
+                List<Vector3> mPathVertList = new List<Vector3>();
+                cis.MotionPathsIndexStep = Mathf.Clamp(cis.MotionPathsIndexStep, 1, 1000);
+                for (int v = 0; v< Frames.VerticesCount; v+= cis.MotionPathsIndexStep) {
+                    for (int f = 0; f < Frames.Count; f++) {
+                        mPathVertList.Add(Frames[f, v]);
+                    }
+                    clip.MotionPathsCount++;
+                    yield return tstack["Generage Motion Paths"].GetInfo(v);
+                }
+                clip.MotionPathVertices = mPathVertList.ToArray();
+ 
+            }
+            yield return new TaskInfo("done", 1f); 
+        }
+
+		public Vector3[] GetFrameVertices(int frameIdx ){
+			Vector3[] result = new Vector3[Frames.VerticesCount];
+			for(int v = 0; v<result.Length; v++){
+				result[v] = Frames [frameIdx, v];	
+			}
+ 			return result;
+		}
+
+		public void SetFrame(int frameIdx, Vector3[] arr){
+			for(int v = 0; v<Frames.VerticesCount; v++){
+				Frames[frameIdx, v] = arr[v];	
+			}
+		}
+
+		public void EncapsulateToBounds(ref Bounds b){
+			for(int f = 0; f<Frames.Count; f++){
+				for(int v = 0; v<Frames.VerticesCount; v++){
+					b.Encapsulate(Frames[f,v]);
+				}
+		 		
+		 	}
+		}
+
+	}
+}

Assets/Plugins/VertexAnimationTools_30/Scripts/Common/PointCacheData.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 7703043973561c8418f0000ed13bae7b
+timeCreated: 1498194296
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/VertexAnimationTools_30/Scripts/Common/ProjectionSamples.cs

@@ -0,0 +1,39 @@
+using UnityEngine;
+
+namespace VertexAnimationTools_30 {
+
+    public enum ProjectionQualityEnum {
+        Draft = 0,
+        Low = 1,
+        Medium = 2,
+        High = 3,
+        Ultra = 4
+    }
+
+    #if UNITY_5_5_OR_NEWER
+    [PreferBinarySerialization]
+    #endif
+    public class ProjectionSamples : ScriptableObject {
+        [System.Serializable]
+        public class Samples {
+            [HideInInspector]
+            public string Name;
+            [HideInInspector]
+            public Vector3[] Dirs;
+        }
+
+ 
+        public Samples[] SphereSamples;
+        [HideInInspector]
+        public Samples[] DomeSamples;
+
+ 
+
+        public static ProjectionSamples Get {
+            get {
+                ProjectionSamples ps = Resources.Load<ProjectionSamples>("VertexAnimationTools_ProjectionSamples");
+                return ps;
+            }
+        }
+    }
+}

Assets/Plugins/VertexAnimationTools_30/Scripts/Common/ProjectionSamples.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 826b850b3432bee45acebe6da8d64bdb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: