diff options
Diffstat (limited to 'Assets/ThirdParty/MaterializeFX/Scripts')
17 files changed, 712 insertions, 0 deletions
diff --git a/Assets/ThirdParty/MaterializeFX/Scripts/MfxController.cs b/Assets/ThirdParty/MaterializeFX/Scripts/MfxController.cs new file mode 100644 index 00000000..35aaa3e7 --- /dev/null +++ b/Assets/ThirdParty/MaterializeFX/Scripts/MfxController.cs @@ -0,0 +1,87 @@ +using UnityEngine;
+
+namespace Assets.MaterializeFX.Scripts
+{
+ internal sealed class MfxController : MonoBehaviour
+ {
+ private const string MfxMaskOffsetProperty = "_MaskOffset";
+ private const string MfxMaskPositionProperty = "_MaskWorldPosition";
+
+ public AnimationCurve MaskOffsetCurve = AnimationCurve.Linear(0f, 0f, 1f, 1f);
+ public float ScaleTimeFactor = 1;
+ public float ScaleOffsetFactor = 1;
+ public bool ModifyChildren = true;
+ public GameObject TargetObject;
+
+ public bool ByDistance;
+ public GameObject DistanceBasedObject;
+
+ public bool ReplaceMaterial;
+ public bool ReplaceMaterialMode; //Runtime, Editor
+ public Material MfxMaterial;
+
+ private float _startTime;
+ private bool _isEnabled;
+ private MfxObjectMaterialUpdater _mfxObjectMaterialUpdater;
+ private Transform _targetTransform;
+
+ public GameObject Target
+ {
+ get
+ {
+ return TargetObject != null ? TargetObject : gameObject;
+ }
+ }
+
+ public void ReplaceMaterials()
+ {
+ _mfxObjectMaterialUpdater.Replace(MfxMaterial);
+ }
+
+ public void RevertMaterials()
+ {
+ _mfxObjectMaterialUpdater.Revert();
+ }
+
+ private void Start()
+ {
+ _mfxObjectMaterialUpdater = new MfxObjectMaterialUpdater(Target, ModifyChildren, ReplaceMaterial, MfxMaterial);
+
+ _targetTransform = Target.transform;
+ _startTime = Time.time;
+ }
+
+ private void Update()
+ {
+ if (!_isEnabled || _targetTransform == null)
+ return;
+
+ if (ByDistance)
+ {
+ if (DistanceBasedObject == null)
+ {
+ Debug.LogError("By distance property was set, but object was not set");
+ return;
+ }
+
+ _mfxObjectMaterialUpdater.SetVector(MfxMaskPositionProperty, DistanceBasedObject.transform.position);
+
+ return;
+ }
+
+ var time = Time.time - _startTime;
+ var maskOffset = MaskOffsetCurve.Evaluate(time / ScaleTimeFactor) * ScaleOffsetFactor;
+ _mfxObjectMaterialUpdater.SetFloat(MfxMaskOffsetProperty, maskOffset);
+ }
+
+ private void OnEnable()
+ {
+ _isEnabled = true;
+ }
+
+ private void OnDisable()
+ {
+ _isEnabled = false;
+ }
+ }
+}
\ No newline at end of file diff --git a/Assets/ThirdParty/MaterializeFX/Scripts/MfxController.cs.meta b/Assets/ThirdParty/MaterializeFX/Scripts/MfxController.cs.meta new file mode 100644 index 00000000..745714e7 --- /dev/null +++ b/Assets/ThirdParty/MaterializeFX/Scripts/MfxController.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 9fb57af500d52f243b8c0a90cc3a00e1 +timeCreated: 1518888167 +licenseType: Store +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/ThirdParty/MaterializeFX/Scripts/MfxControllerEditor.cs b/Assets/ThirdParty/MaterializeFX/Scripts/MfxControllerEditor.cs new file mode 100644 index 00000000..50ad9e50 --- /dev/null +++ b/Assets/ThirdParty/MaterializeFX/Scripts/MfxControllerEditor.cs @@ -0,0 +1,139 @@ +using System.Globalization;
+using UnityEditor;
+using UnityEngine;
+
+namespace Assets.MaterializeFX.Scripts
+{
+ [CustomEditor(typeof(MfxController))]
+ internal sealed class MfxControllerEditor : Editor
+ {
+ private GameObject _targetObject;
+ private bool _modifyChildren;
+
+ private AnimationCurve _maskOffsetCurve;
+ private string _scaleTimeFactor;
+ private string _scalePositionFactor;
+
+ private bool _byDistance;
+ private GameObject _distanceBasedObject;
+
+ private bool _replaceMaterial;
+ private bool _replaceMaterialMode;
+ private Material _mfxMaterial;
+
+ public override void OnInspectorGUI()
+ {
+ var mfxController = (MfxController)target;
+
+ _targetObject = mfxController.TargetObject;
+ _modifyChildren = mfxController.ModifyChildren;
+
+ _maskOffsetCurve = mfxController.MaskOffsetCurve;
+ _scaleTimeFactor = mfxController.ScaleTimeFactor.ToString(CultureInfo.InvariantCulture);
+ _scalePositionFactor = mfxController.ScaleOffsetFactor.ToString(CultureInfo.InvariantCulture);
+
+ _byDistance = mfxController.ByDistance;
+ _distanceBasedObject = mfxController.DistanceBasedObject;
+
+ _replaceMaterial = mfxController.ReplaceMaterial;
+ _replaceMaterialMode = mfxController.ReplaceMaterialMode;
+ _mfxMaterial = mfxController.MfxMaterial;
+
+ EditorGUILayout.Separator();
+
+ // Modify children
+ EditorGUILayout.Separator();
+ _modifyChildren = EditorGUILayout.Toggle(MfxEditorLocalization.ModifyChildrenLabel, _modifyChildren);
+ mfxController.ModifyChildren = _modifyChildren;
+
+ // Target object
+ _targetObject = (GameObject)EditorGUILayout.ObjectField(MfxEditorLocalization.TargetObjectLabel, _targetObject, typeof(GameObject), true);
+ mfxController.TargetObject = _targetObject;
+
+ EditorGUILayout.Separator();
+ EditorGUILayout.LabelField(MfxEditorLocalization.DistanceParamsLabel, EditorStyles.boldLabel);
+
+ // ReplaceMaterials depending on the distance
+ _byDistance = EditorGUILayout.Toggle(MfxEditorLocalization.ByDistanceLabel, _byDistance);
+ mfxController.ByDistance = _byDistance;
+
+ // Object To Calculate Distance
+ if (_byDistance)
+ {
+ _distanceBasedObject = (GameObject)EditorGUILayout.ObjectField(MfxEditorLocalization.DistanceBasedObjectLabel, _distanceBasedObject, typeof(GameObject), true);
+ mfxController.DistanceBasedObject = _distanceBasedObject;
+ }
+
+ if (!_byDistance)
+ {
+ // Direction type
+ EditorGUILayout.Separator();
+ EditorGUILayout.LabelField(MfxEditorLocalization.MfxParamsLabel, EditorStyles.boldLabel);
+
+ _maskOffsetCurve = EditorGUILayout.CurveField(MfxEditorLocalization.MaskOffsetCurve, _maskOffsetCurve);
+ mfxController.MaskOffsetCurve = _maskOffsetCurve;
+
+ _scaleTimeFactor = EditorGUILayout.TextField(MfxEditorLocalization.ScaleTimeLabel, _scaleTimeFactor);
+ _scalePositionFactor = EditorGUILayout.TextField(MfxEditorLocalization.ScalePositionLabel, _scalePositionFactor);
+ mfxController.ScaleTimeFactor = float.Parse(_scaleTimeFactor);
+ mfxController.ScaleOffsetFactor = float.Parse(_scalePositionFactor);
+ }
+
+ EditorGUILayout.Separator();
+ EditorGUILayout.LabelField(MfxEditorLocalization.ReplaceMaterialParamsLabel, EditorStyles.boldLabel);
+
+ _replaceMaterial = EditorGUILayout.Toggle(MfxEditorLocalization.ReplaceMaterialLabel, _replaceMaterial);
+
+ mfxController.ReplaceMaterial = _replaceMaterial;
+
+ if (_replaceMaterial)
+ {
+ _mfxMaterial = (Material)EditorGUILayout.ObjectField(MfxEditorLocalization.MaterialLabel, _mfxMaterial, typeof(Material), true);
+ mfxController.MfxMaterial = _mfxMaterial;
+ }
+
+ if (_replaceMaterial)
+ {
+ _replaceMaterialMode = EditorGUILayout.Toggle(MfxEditorLocalization.ReplaceMaterialInEditorLabel, _replaceMaterialMode);
+ mfxController.ReplaceMaterialMode = _replaceMaterialMode;
+
+ if (_replaceMaterial && _replaceMaterialMode)
+ {
+ if (GUILayout.Button(MfxEditorLocalization.ReplaceMaterialButton))
+ {
+ if (_mfxMaterial == null)
+ Debug.LogWarning("template mfx materials is not selected");
+ else
+ {
+ var targetObject = mfxController.Target;
+
+ MfxMaterialUtil.ReplaceRenderersMaterials(_mfxMaterial, targetObject, true);
+ }
+ }
+ }
+ }
+
+ EditorUtility.SetDirty(target);
+ }
+
+ private static class MfxEditorLocalization
+ {
+ public const string TargetObjectLabel = "Target Object";
+ public const string ModifyChildrenLabel = "Modify Children";
+ public const string DistanceParamsLabel = "Distance Params";
+ public const string ByDistanceLabel = "Depending on the distance";
+ public const string DistanceBasedObjectLabel = "Object to calcualte distance";
+
+ public const string MfxParamsLabel = "Mfx Params";
+ public const string MaskOffsetCurve = "Mask Offset Curve";
+ public const string ScaleTimeLabel = "Scale Time Factor";
+ public const string ScalePositionLabel = "Scale Offset Factor";
+
+ public const string ReplaceMaterialParamsLabel = "Replace Material Params";
+ public const string ReplaceMaterialLabel = "Replace Material";
+ public const string ReplaceMaterialInEditorLabel = "Replace in Editor";
+ public const string ReplaceMaterialButton = "Copy & Replace";
+ public const string MaterialLabel = "Mfx Material Template";
+ }
+ }
+}
\ No newline at end of file diff --git a/Assets/ThirdParty/MaterializeFX/Scripts/MfxControllerEditor.cs.meta b/Assets/ThirdParty/MaterializeFX/Scripts/MfxControllerEditor.cs.meta new file mode 100644 index 00000000..b1197458 --- /dev/null +++ b/Assets/ThirdParty/MaterializeFX/Scripts/MfxControllerEditor.cs.meta @@ -0,0 +1,3 @@ +fileFormatVersion: 2
+guid: b2796124494d46169208aa448ca66158
+timeCreated: 1520486780
\ No newline at end of file diff --git a/Assets/ThirdParty/MaterializeFX/Scripts/MfxMaterialUtil.cs b/Assets/ThirdParty/MaterializeFX/Scripts/MfxMaterialUtil.cs new file mode 100644 index 00000000..f8957a4a --- /dev/null +++ b/Assets/ThirdParty/MaterializeFX/Scripts/MfxMaterialUtil.cs @@ -0,0 +1,170 @@ +using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace Assets.MaterializeFX.Scripts
+{
+ internal static class MfxMaterialUtil
+ {
+ private const string MfxShaderName = "QFX/MFX/Uber/Standart";
+
+ private const string Color2PropName = "_Color2";
+ private const string MainTex2PropName = "_MainTex2";
+ private const string BumpMap2PropName = "_BumpMap2";
+ private const string EmissionColor2PropName = "_EmissionColor2";
+ private const string EmissionMap2PropName = "_EmissionMap2";
+ private const string EmissionMap2ScrollPropName = "_EmissionMap2_Scroll";
+ private const string EmissionSize2PropName = "_EmissionSize2";
+ private const string EdgeColorPropName = "_EdgeColor";
+ private const string EdgeSizePropName = "_EdgeSize";
+ private const string EdgeStrengthPropName = "_EdgeStrength";
+ private const string EdgeRampMap1PropName = "_EdgeRampMap1";
+ private const string EdgeRampMap1ScrollPropName = "_EdgeRampMap1_Scroll";
+ private const string DissolveMap1PropName = "_DissolveMap1";
+ private const string DissolveMap1ScrollPropName = "_DissolveMap1_Scroll";
+ private const string MaskPropName = "_Mask";
+ private const string CutoffAxisPropName = "_CutoffAxis";
+ private const string MaskOffsetPropName = "_MaskOffset";
+ private const string MaskPositionPropName = "_MaskPosition";
+ private const string DissolveSizePropName = "_DissolveSize";
+ private const string DissolveEdgeColorPropName = "_DissolveEdgeColor";
+ private const string DissolveEdgeSizePropName = "_DissolveEdgeSize";
+
+ public static void CopyMfxProperties(Material mfxTemplateMaterial, Material emptyMfxMaterial)
+ {
+ CopyPropertyToMaterial<Color>(mfxTemplateMaterial, emptyMfxMaterial, Color2PropName, Color2PropName);
+ CopyPropertyToMaterial<Texture>(mfxTemplateMaterial, emptyMfxMaterial, MainTex2PropName, MainTex2PropName);
+ CopyPropertyToMaterial<Texture>(mfxTemplateMaterial, emptyMfxMaterial, BumpMap2PropName, BumpMap2PropName);
+ CopyPropertyToMaterial<Color>(mfxTemplateMaterial, emptyMfxMaterial, EmissionColor2PropName, EmissionColor2PropName);
+ CopyPropertyToMaterial<Texture>(mfxTemplateMaterial, emptyMfxMaterial, EmissionMap2PropName, EmissionMap2PropName);
+ CopyPropertyToMaterial<Vector4>(mfxTemplateMaterial, emptyMfxMaterial, EmissionMap2ScrollPropName, EmissionMap2ScrollPropName);
+ CopyPropertyToMaterial<float>(mfxTemplateMaterial, emptyMfxMaterial, EmissionSize2PropName, EmissionSize2PropName);
+ CopyPropertyToMaterial<Color>(mfxTemplateMaterial, emptyMfxMaterial, EdgeColorPropName, EdgeColorPropName);
+ CopyPropertyToMaterial<float>(mfxTemplateMaterial, emptyMfxMaterial, EdgeSizePropName, EdgeSizePropName);
+ CopyPropertyToMaterial<float>(mfxTemplateMaterial, emptyMfxMaterial, EdgeStrengthPropName, EdgeStrengthPropName);
+ CopyPropertyToMaterial<Texture>(mfxTemplateMaterial, emptyMfxMaterial, EdgeRampMap1PropName, EdgeRampMap1PropName);
+ CopyPropertyToMaterial<Vector4>(mfxTemplateMaterial, emptyMfxMaterial, EdgeRampMap1ScrollPropName, EdgeRampMap1ScrollPropName);
+ CopyPropertyToMaterial<Texture>(mfxTemplateMaterial, emptyMfxMaterial, DissolveMap1PropName, DissolveMap1PropName);
+ CopyPropertyToMaterial<Vector4>(mfxTemplateMaterial, emptyMfxMaterial, DissolveMap1ScrollPropName, DissolveMap1ScrollPropName);
+ CopyPropertyToMaterial<int>(mfxTemplateMaterial, emptyMfxMaterial, MaskPropName, MaskPropName);
+ CopyPropertyToMaterial<int>(mfxTemplateMaterial, emptyMfxMaterial, CutoffAxisPropName, CutoffAxisPropName);
+ CopyPropertyToMaterial<float>(mfxTemplateMaterial, emptyMfxMaterial, MaskOffsetPropName, MaskOffsetPropName);
+ CopyPropertyToMaterial<Vector4>(mfxTemplateMaterial, emptyMfxMaterial, MaskPositionPropName, MaskPositionPropName);
+ CopyPropertyToMaterial<float>(mfxTemplateMaterial, emptyMfxMaterial, DissolveSizePropName, DissolveSizePropName);
+ CopyPropertyToMaterial<float>(mfxTemplateMaterial, emptyMfxMaterial, DissolveSizePropName, DissolveSizePropName);
+ CopyPropertyToMaterial<Color>(mfxTemplateMaterial, emptyMfxMaterial, DissolveEdgeColorPropName, DissolveEdgeColorPropName);
+ CopyPropertyToMaterial<float>(mfxTemplateMaterial, emptyMfxMaterial, DissolveEdgeSizePropName, DissolveEdgeSizePropName);
+
+ emptyMfxMaterial.renderQueue = mfxTemplateMaterial.renderQueue;
+ emptyMfxMaterial.shaderKeywords = mfxTemplateMaterial.shaderKeywords;
+ emptyMfxMaterial.SetOverrideTag("RenderType", mfxTemplateMaterial.GetTag("RenderType", false));
+ emptyMfxMaterial.SetOverrideTag("Queue", mfxTemplateMaterial.GetTag("Queue", false));
+ emptyMfxMaterial.SetOverrideTag("IsEmissive", mfxTemplateMaterial.GetTag("IsEmissive", false));
+ emptyMfxMaterial.SetOverrideTag("PerformanceChecks", mfxTemplateMaterial.GetTag("PerformanceChecks", false));
+ emptyMfxMaterial.SetOverrideTag("DisableBatching", mfxTemplateMaterial.GetTag("DisableBatching", false));
+ }
+
+ public static void ReplaceRenderersMaterials(Material mfxMaterial, GameObject targetObject, bool editorMode)
+ {
+ var renderers = targetObject.GetComponentsInChildren<Renderer>();
+
+ foreach (var targetRenderer in renderers)
+ {
+ var targetRendererMaterials = targetRenderer.sharedMaterials;
+ var newMaterials = ReplaceMaterialsToMfx(mfxMaterial, targetRendererMaterials, editorMode);
+ targetRenderer.sharedMaterials = newMaterials.ToArray();
+ }
+ }
+
+ public static List<Material> ReplaceMaterialsToMfx(Material mfxMaterial, Material[] targetRendererMaterials, bool editorMode)
+ {
+ var newMaterials = new List<Material>();
+
+ foreach (var targetRendererMaterial in targetRendererMaterials)
+ {
+ if (targetRendererMaterial == null)
+ continue;
+
+ string newAssetPath = string.Empty;
+
+ if (editorMode)
+ {
+ var materialPath = AssetDatabase.GetAssetPath(targetRendererMaterial);
+
+ var extensionIdx = materialPath.LastIndexOf("/", StringComparison.Ordinal);
+ if (extensionIdx <= 0)
+ {
+ Debug.LogError("the path is incorrect");
+ continue;
+ }
+
+ var pathWithoutExtension = materialPath.Substring(0, extensionIdx);
+
+ newAssetPath = pathWithoutExtension + "/" + targetRendererMaterial.name + "_MFX.mat";
+
+ var assetType = AssetDatabase.GetMainAssetTypeAtPath(newAssetPath);
+ if (assetType != null)
+ {
+ var existingMaterial = AssetDatabase.LoadAssetAtPath<Material>(newAssetPath);
+ newMaterials.Add(existingMaterial);
+ continue;
+ }
+ }
+
+ var newMaterial = new Material(targetRendererMaterial)
+ {
+ shader = Shader.Find(MfxShaderName)
+ };
+
+ CopyMfxProperties(mfxMaterial, newMaterial);
+
+ newMaterials.Add(newMaterial);
+
+ if (editorMode)
+ {
+ AssetDatabase.CreateAsset(newMaterial, newAssetPath);
+ }
+ }
+
+ return newMaterials;
+ }
+
+ private static void CopyPropertyToMaterial<T>(Material fromMaterial, Material toMaterial, string fromProperty, string toProperty)
+ {
+ if (!fromMaterial.HasProperty(fromProperty) || !toMaterial.HasProperty(toProperty))
+ return;
+
+ var tType = typeof(T);
+
+ if (tType == typeof(Texture))
+ {
+ var tex = fromMaterial.GetTexture(fromProperty);
+ toMaterial.SetTexture(toProperty, tex);
+
+ var texScale = fromMaterial.GetTextureScale(fromProperty);
+ toMaterial.SetTextureScale(toProperty, texScale);
+ }
+ else if (tType == typeof(Color))
+ {
+ var col = fromMaterial.GetColor(fromProperty);
+ toMaterial.SetColor(toProperty, col);
+ }
+ else if (tType == typeof(float))
+ {
+ var f = fromMaterial.GetFloat(fromProperty);
+ toMaterial.SetFloat(toProperty, f);
+ }
+ else if (tType == typeof(int))
+ {
+ var f = fromMaterial.GetInt(fromProperty);
+ toMaterial.SetInt(toProperty, f);
+ }
+ else if (tType == typeof(Vector4))
+ {
+ var f = fromMaterial.GetVector(fromProperty);
+ toMaterial.SetVector(toProperty, f);
+ }
+ }
+ }
+}
diff --git a/Assets/ThirdParty/MaterializeFX/Scripts/MfxMaterialUtil.cs.meta b/Assets/ThirdParty/MaterializeFX/Scripts/MfxMaterialUtil.cs.meta new file mode 100644 index 00000000..2f0f7080 --- /dev/null +++ b/Assets/ThirdParty/MaterializeFX/Scripts/MfxMaterialUtil.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 45c2244b3e8522e4f891813072da63a1 +timeCreated: 1523301762 +licenseType: Store +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/ThirdParty/MaterializeFX/Scripts/MfxObjectMaterialUpdater.cs b/Assets/ThirdParty/MaterializeFX/Scripts/MfxObjectMaterialUpdater.cs new file mode 100644 index 00000000..c828afd4 --- /dev/null +++ b/Assets/ThirdParty/MaterializeFX/Scripts/MfxObjectMaterialUpdater.cs @@ -0,0 +1,79 @@ +using System.Collections.Generic;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+namespace Assets.MaterializeFX.Scripts
+{
+ internal sealed class MfxObjectMaterialUpdater
+ {
+ private readonly Renderer[] _renderers;
+ private readonly Dictionary<Renderer, Material[]> _rendererToOriginalMaterialsMap = new Dictionary<Renderer, Material[]>();
+ private readonly List<Material> _mfxMaterials = new List<Material>();
+
+ public MfxObjectMaterialUpdater(GameObject targetObject, bool modifyChildren, bool replaceMaterials, Material mfxMaterialTemplate)
+ {
+ _renderers = modifyChildren ? targetObject.GetComponentsInChildren<Renderer>() : targetObject.GetComponents<Renderer>();
+
+ if (!replaceMaterials)
+ {
+ foreach (var renderer in _renderers)
+ foreach (var material in renderer.sharedMaterials)
+ _mfxMaterials.Add(material);
+ return;
+ }
+
+ Replace(mfxMaterialTemplate);
+ }
+
+ public void SetFloat(string propertyName, float value)
+ {
+ foreach (var mfxMaterial in _mfxMaterials)
+ mfxMaterial.SetFloat(propertyName, value);
+ }
+
+ public void SetInt(string propertyName, int value)
+ {
+ foreach (var mfxMaterial in _mfxMaterials)
+ mfxMaterial.SetInt(propertyName, value);
+ }
+
+ public void SetVector(string propertyName, Vector3 value)
+ {
+ foreach (var mfxMaterial in _mfxMaterials)
+ mfxMaterial.SetVector(propertyName, value);
+ }
+
+ public void Replace(Material mfxMaterialTemplate)
+ {
+ _rendererToOriginalMaterialsMap.Clear();
+ _mfxMaterials.Clear();
+
+ foreach (var renderer in _renderers)
+ {
+ var rendererSharedMaterials = renderer.sharedMaterials;
+
+ _rendererToOriginalMaterialsMap[renderer] = rendererSharedMaterials;
+ var newMaterials = MfxMaterialUtil.ReplaceMaterialsToMfx(mfxMaterialTemplate, rendererSharedMaterials, false);
+ renderer.sharedMaterials = newMaterials.ToArray();
+ _mfxMaterials.AddRange(newMaterials);
+ }
+ }
+
+ public void Revert()
+ {
+ // ReSharper disable once ForCanBeConvertedToForeach
+ for (int i = 0; i < _renderers.Length; i++)
+ {
+ if (_rendererToOriginalMaterialsMap.ContainsKey(_renderers[i]))
+ _renderers[i].materials = _rendererToOriginalMaterialsMap[_renderers[i]];
+ }
+
+ _rendererToOriginalMaterialsMap.Clear();
+
+ foreach (var mfxMaterial in _mfxMaterials)
+ Object.DestroyImmediate(mfxMaterial);
+
+ _mfxMaterials.Clear();
+ }
+ }
+}
\ No newline at end of file diff --git a/Assets/ThirdParty/MaterializeFX/Scripts/MfxObjectMaterialUpdater.cs.meta b/Assets/ThirdParty/MaterializeFX/Scripts/MfxObjectMaterialUpdater.cs.meta new file mode 100644 index 00000000..e01fe665 --- /dev/null +++ b/Assets/ThirdParty/MaterializeFX/Scripts/MfxObjectMaterialUpdater.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 4dada6828534dcd4eae04266e7675c62 +timeCreated: 1518888167 +licenseType: Store +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/ThirdParty/MaterializeFX/Scripts/MfxShaderType.cs b/Assets/ThirdParty/MaterializeFX/Scripts/MfxShaderType.cs new file mode 100644 index 00000000..20eabb4b --- /dev/null +++ b/Assets/ThirdParty/MaterializeFX/Scripts/MfxShaderType.cs @@ -0,0 +1,7 @@ +namespace Assets.MaterializeFX.Scripts
+{
+ internal enum MfxShaderType
+ {
+ UberStandart,
+ }
+}
\ No newline at end of file diff --git a/Assets/ThirdParty/MaterializeFX/Scripts/MfxShaderType.cs.meta b/Assets/ThirdParty/MaterializeFX/Scripts/MfxShaderType.cs.meta new file mode 100644 index 00000000..e9ae3a4f --- /dev/null +++ b/Assets/ThirdParty/MaterializeFX/Scripts/MfxShaderType.cs.meta @@ -0,0 +1,3 @@ +fileFormatVersion: 2
+guid: 2cd6f05b8ade472d8e654c7b85d695d9
+timeCreated: 1520486397
\ No newline at end of file diff --git a/Assets/ThirdParty/MaterializeFX/Scripts/Utils.meta b/Assets/ThirdParty/MaterializeFX/Scripts/Utils.meta new file mode 100644 index 00000000..55b23d62 --- /dev/null +++ b/Assets/ThirdParty/MaterializeFX/Scripts/Utils.meta @@ -0,0 +1,10 @@ +fileFormatVersion: 2 +guid: f31456c0e62f6634fa658ee1b35578ae +folderAsset: yes +timeCreated: 1519067135 +licenseType: Store +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/ThirdParty/MaterializeFX/Scripts/Utils/DemoInputConrtoller.cs b/Assets/ThirdParty/MaterializeFX/Scripts/Utils/DemoInputConrtoller.cs new file mode 100644 index 00000000..f5b2c26f --- /dev/null +++ b/Assets/ThirdParty/MaterializeFX/Scripts/Utils/DemoInputConrtoller.cs @@ -0,0 +1,37 @@ +using UnityEngine;
+
+namespace Assets.MaterializeFX.Scripts.Utils
+{
+ internal sealed class DemoInputConrtoller : MonoBehaviour
+ {
+ private const string SpaceButton = "space";
+ private const string LightButton = "f";
+ private DemoPrefabController _demoPrefabController;
+
+ public Light Light;
+
+ public void EnableLigh()
+ {
+ Light.enabled = true;
+ }
+
+ public void DisableLight()
+ {
+ Light.enabled = false;
+ }
+
+ private void Start()
+ {
+ _demoPrefabController = GetComponent<DemoPrefabController>();
+ }
+
+ private void Update()
+ {
+ if (Input.GetKeyDown(SpaceButton))
+ _demoPrefabController.Next();
+
+ if (Input.GetKeyDown(LightButton))
+ Light.enabled = !Light.enabled;
+ }
+ }
+}
\ No newline at end of file diff --git a/Assets/ThirdParty/MaterializeFX/Scripts/Utils/DemoInputConrtoller.cs.meta b/Assets/ThirdParty/MaterializeFX/Scripts/Utils/DemoInputConrtoller.cs.meta new file mode 100644 index 00000000..73ac01ca --- /dev/null +++ b/Assets/ThirdParty/MaterializeFX/Scripts/Utils/DemoInputConrtoller.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 6a769f5ec192b024985c56e36956f614 +timeCreated: 1504459121 +licenseType: Store +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/ThirdParty/MaterializeFX/Scripts/Utils/DemoPrefabController.cs b/Assets/ThirdParty/MaterializeFX/Scripts/Utils/DemoPrefabController.cs new file mode 100644 index 00000000..d1c108bb --- /dev/null +++ b/Assets/ThirdParty/MaterializeFX/Scripts/Utils/DemoPrefabController.cs @@ -0,0 +1,41 @@ +using UnityEngine;
+
+namespace Assets.MaterializeFX.Scripts.Utils
+{
+ internal sealed class DemoPrefabController : MonoBehaviour
+ {
+ public int StartNum;
+ public GameObject[] Prefabs;
+
+ private GameObject _currentInstance;
+ private int _currentPrefabNum;
+
+ public void Next()
+ {
+ if (Prefabs.Length == 0)
+ return;
+
+ _currentPrefabNum++;
+ if (_currentPrefabNum >= Prefabs.Length)
+ _currentPrefabNum = 0;
+
+ ChangePrefab(_currentPrefabNum);
+ }
+
+ private void Start()
+ {
+ _currentPrefabNum = StartNum;
+
+ ChangePrefab(_currentPrefabNum);
+ }
+
+ private void ChangePrefab(int num)
+ {
+ if (_currentInstance != null)
+ Destroy(_currentInstance);
+ var newPrefab = Prefabs[num];
+ _currentInstance = Instantiate(newPrefab, newPrefab.transform.position, newPrefab.transform.transform.rotation);
+ _currentInstance.SetActive(true);
+ }
+ }
+}
\ No newline at end of file diff --git a/Assets/ThirdParty/MaterializeFX/Scripts/Utils/DemoPrefabController.cs.meta b/Assets/ThirdParty/MaterializeFX/Scripts/Utils/DemoPrefabController.cs.meta new file mode 100644 index 00000000..5f29197f --- /dev/null +++ b/Assets/ThirdParty/MaterializeFX/Scripts/Utils/DemoPrefabController.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: b1a784e5c50cf8d4791732b4911f7e65 +timeCreated: 1504459134 +licenseType: Store +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/ThirdParty/MaterializeFX/Scripts/Utils/MouseOrbitController.cs b/Assets/ThirdParty/MaterializeFX/Scripts/Utils/MouseOrbitController.cs new file mode 100644 index 00000000..e2f91048 --- /dev/null +++ b/Assets/ThirdParty/MaterializeFX/Scripts/Utils/MouseOrbitController.cs @@ -0,0 +1,58 @@ +using UnityEngine;
+
+namespace Assets.MaterializeFX.Scripts.Utils
+{
+ internal sealed class MouseOrbitController : MonoBehaviour
+ {
+ public Transform Target;
+ public float Distance = 5.0f;
+ public float XSpeed = 120.0f;
+ public float YSpeed = 120.0f;
+
+ public float YMinLimit = 20f;
+ public float YMaxLimit = 80f;
+
+ public float DistanceMin = .5f;
+ public float DistanceMax = 15f;
+
+ private float _x;
+ private float _y;
+
+ private void Start()
+ {
+ var angles = transform.eulerAngles;
+ _x = angles.y;
+ _y = angles.x;
+ }
+
+ private void LateUpdate()
+ {
+ if (!Input.GetMouseButton(0))
+ return;
+
+ _x += Input.GetAxis("Mouse X") * XSpeed * Distance * 0.02f;
+ _y -= Input.GetAxis("Mouse Y") * YSpeed * 0.02f;
+
+ _y = ClampAngle(_y, YMinLimit, YMaxLimit);
+
+ var rotation = Quaternion.Euler(_y, _x, 0);
+
+ Distance -= Input.GetAxis("Mouse ScrollWheel") * 5;
+
+ var negDistance = new Vector3(0.0f, 0.0f, -Distance);
+ var position = rotation * negDistance + Target.position;
+
+ transform.rotation = rotation;
+ transform.position = position;
+ }
+
+ private static float ClampAngle(float angle, float min, float max)
+ {
+ if (angle < -360F)
+ angle += 360F;
+ if (angle > 360F)
+ angle -= 360F;
+ return Mathf.Clamp(angle, min, max);
+ }
+ }
+}
diff --git a/Assets/ThirdParty/MaterializeFX/Scripts/Utils/MouseOrbitController.cs.meta b/Assets/ThirdParty/MaterializeFX/Scripts/Utils/MouseOrbitController.cs.meta new file mode 100644 index 00000000..b6ac3ab0 --- /dev/null +++ b/Assets/ThirdParty/MaterializeFX/Scripts/Utils/MouseOrbitController.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 04f1caafe23156a438ca1d322d70a4ac +timeCreated: 1516131563 +licenseType: Store +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: |