// #define POLYBRUSH_DEBUG

using UnityEngine;
using System.Collections.Generic;
using System.Linq;
using UnityEngine.Polybrush;

namespace UnityEditor.Polybrush
{
    /// <summary>
    /// Vertex texture painter brush mode.
    /// Similar to BrushModePaint, except it packs blend information into both the color32 and UV3/4 channels.
    /// </summary>
    internal class BrushModeTexture : BrushModeMesh
    {
        static class Styles
        {
            internal static readonly GUIContent[] k_ModeIcons = new GUIContent[]
            {
                new GUIContent("Brush", "Brush" ),
                new GUIContent("Fill", "Fill" ),
                new GUIContent("Flood", "Flood" )
            };

            internal static readonly string[] k_MeshChannel =
            {
                "Color",
                "Tangent",
                "UV1",
                "UV2",
                "UV3",
                "UV4"
            };

            internal static MeshChannel ToMeshChannel(int value)
            {
                switch (value)
                {
                    case 0:
                        return MeshChannel.Color;
                    case 1:
                        return MeshChannel.Tangent;
                    case 2:
                        return MeshChannel.UV0;
                    case 3:
                        return MeshChannel.UV2;
                    case 4:
                        return MeshChannel.UV3;
                    case 5:
                        return MeshChannel.UV4;
                }
                return MeshChannel.Null;
            }

            internal static int ToInt(MeshChannel channel)
            {
                switch (channel)
                {
                    case MeshChannel.Color:
                        return 0;
                    case MeshChannel.Tangent:
                        return 1;
                    case MeshChannel.UV0:
                        return 2;
                    case MeshChannel.UV2:
                        return 3;
                    case MeshChannel.UV3:
                        return 4;
                    case MeshChannel.UV4:
                        return 5;
                }
                return 0;
            }
        }

        enum PanelView
        {
            Paint,
            Configuration,
        }

        class EditableObjectData
        {
            public int VertexCount;
            public EditableObject CacheTarget;
            public List<Material> CacheMaterials;
            public SplatSet SplatCache,
                SplatTarget,
                SplatErase,
                SplatCurrent;
            public Dictionary<PolyEdge, List<int>> TriangleLookup;
        }

        internal SplatWeight brushColor = null;

        SplatWeight m_MinWeights = null;

        [SerializeField]
        int m_SelectedAttributeIndex = 0;
        int selectedAttributeIndex
        {
            get { return m_SelectedAttributeIndex; }
            set
            {
                m_SelectedAttributeIndex = Mathf.Clamp(value, 0, meshAttributes.Length-1);
            }
        }

        bool m_LikelySupportsTextureBlending = true;

        AttributeLayoutContainer m_MeshAttributesContainer = null;
        List<AttributeLayoutContainer> m_MeshAttributesContainers = new List<AttributeLayoutContainer>();

        string[] m_AvailableMaterialsAsString = { };
        EditableObject m_MainCacheTarget = null;
        List<Material> m_MainCacheMaterials = new List<Material>();

        Dictionary<EditableObject,EditableObjectData> m_EditableObjectsData = new Dictionary<EditableObject, EditableObjectData>();

        // temp vars
        PolyEdge[] m_FillModeEdges = new PolyEdge[3];
        List<int> m_FillModeAdjacentTriangles = null;

        internal int m_CurrentMeshACIndex = 0;
        internal PaintMode m_PaintMode = PaintMode.Brush;

        PanelView m_CurrentPanelView = PanelView.Paint;

        internal AttributeLayout[] meshAttributes
		{
			get
			{
				return m_MeshAttributesContainer != null ? m_MeshAttributesContainer.attributes : null;
			}
		}

        // The message that will accompany Undo commands for this brush.  Undo/Redo is handled by PolyEditor.
        internal override string UndoMessage { get { return "Paint Brush"; } }
		protected override string ModeSettingsHeader { get { return "Texture Paint Settings"; } }
		protected override string DocsLink { get { return PrefUtility.documentationTextureBrushLink; } }

		internal override void OnEnable()
		{
			base.OnEnable();

            m_CurrentPanelView = PanelView.Paint;

			m_LikelySupportsTextureBlending = false;
			m_MeshAttributesContainer = null;
			brushColor = null;

            RebuildMaterialCaches();

			if (meshAttributes != null)
                OnMaterialSelected();

			foreach(GameObject go in Selection.gameObjects)
				m_LikelySupportsTextureBlending = CheckForTextureBlendSupport(go);
		}

        internal override bool SetDefaultSettings()
        {
            m_PaintMode = PaintMode.Brush;
            return true;
        }

        // Inspector GUI shown in the Editor window.  Base class shows BrushSettings by default
        internal override void DrawGUI(BrushSettings brushSettings)
		{
			base.DrawGUI(brushSettings);

            using (new GUILayout.HorizontalScope())
            {
                GUILayout.FlexibleSpace();
                m_PaintMode = (PaintMode)GUILayout.Toolbar((int)m_PaintMode, Styles.k_ModeIcons, GUILayout.Width(150));
                GUILayout.FlexibleSpace();
            }

			GUILayout.Space(4);

            // Selection dropdown for material (for submeshes)
            if (m_AvailableMaterialsAsString.Count() > 0)
            {
                EditorGUILayout.BeginHorizontal();
                EditorGUI.BeginChangeCheck();

                EditorGUILayout.LabelField("Material", GUILayout.Width(60));
                if (m_CurrentPanelView == PanelView.Configuration)
                    GUI.enabled = false;

                m_CurrentMeshACIndex = EditorGUILayout.Popup(m_CurrentMeshACIndex, m_AvailableMaterialsAsString, "Popup");

                if (m_CurrentPanelView == PanelView.Configuration)
                    GUI.enabled = true;

                // Buttons to switch between Paint and Configuration views
                if (m_CurrentPanelView == PanelView.Paint && GUILayout.Button("Configure", GUILayout.Width(70)))
                    OpenConfiguration();
                else if (m_CurrentPanelView == PanelView.Configuration)
                {
                    if (GUILayout.Button("Revert", GUILayout.Width(70)))
                        CloseConfiguration(false);
                    if (GUILayout.Button("Save", GUILayout.Width(70)))
                        CloseConfiguration(true);

                }

                if (EditorGUI.EndChangeCheck())
                {
                    m_MeshAttributesContainer = m_MeshAttributesContainers[m_CurrentMeshACIndex];
                    OnMaterialSelected();
                }

                EditorGUILayout.EndHorizontal();
            }

            EditorGUILayout.Space();

            if (m_CurrentPanelView == PanelView.Paint)
                DrawGUIPaintView();
            else if (m_CurrentPanelView == PanelView.Configuration)
            {
                Material selectedMat = m_MainCacheMaterials[m_CurrentMeshACIndex];

                string[] names = selectedMat.GetTexturePropertyNames();

                using (new GUILayout.VerticalScope())
                {
                    for (int i = 0; i < names.Length; ++i)
                    {
                        string n = names[i];
                        if (selectedMat.HasProperty(n))
                            DrawConfigurationPanel(GetPropertyInfo(n), n, selectedMat);
                    }
                }
            }
        }

        struct MaterialPropertyInfo
        {
            public string PropertyName;
            public bool LinkedToAttributesLayout;
            public bool IsVisible;
        }

        List<MaterialPropertyInfo> materialPropertiesCache = new List<MaterialPropertyInfo>();

        AttributeLayoutContainer m_LoadedAttributes = null;

        private MaterialPropertyInfo GetPropertyInfo(string name)
        {
            MaterialPropertyInfo res = default(MaterialPropertyInfo);
            foreach (MaterialPropertyInfo p in materialPropertiesCache)
            {
                if (p.PropertyName == name)
                {
                    res = p;
                    break;
                }
            }
            return res;
        }

        private void UpdatePropertyInfo(MaterialPropertyInfo pUpdate)
        {
            int index = materialPropertiesCache.FindIndex(0, p => p.PropertyName == pUpdate.PropertyName);
            if (index >= 0)
                materialPropertiesCache[index] = pUpdate;
        }

        private void OnMaterialSelected()
        {
            Material selectedMat = m_MainCacheMaterials[m_CurrentMeshACIndex];
            string[] names = selectedMat.GetTexturePropertyNames();

            materialPropertiesCache.Clear();

            foreach (string n in names)
            {
                if (selectedMat.HasProperty(n))
                {
                    materialPropertiesCache.Add(new MaterialPropertyInfo()
                    {
                        PropertyName = n,
                        LinkedToAttributesLayout = false,
                        IsVisible = true
                    });
                }
            }
        }

        private void OpenConfiguration()
        {
            m_CurrentPanelView = PanelView.Configuration;

            if (m_MainCacheMaterials == null || m_CurrentMeshACIndex < 0 || m_CurrentMeshACIndex >= m_MainCacheMaterials.Count)
                return;
            Material mat = m_MainCacheMaterials[m_CurrentMeshACIndex];
            Shader shader = mat.shader;

            if (ShaderMetaDataUtility.IsValidShader(shader))
            {
#pragma warning disable 0618
                // Data conversion between Polybrush Beta and Polybrush 1.0.
                string path = ShaderMetaDataUtility.FindPolybrushMetaDataForShader(shader);
                if (!string.IsNullOrEmpty(path))
                    ShaderMetaDataUtility.ConvertMetaDataToNewFormat(shader);
#pragma warning restore 0618

                m_LoadedAttributes = ShaderMetaDataUtility.LoadShaderMetaData(shader);
            }
        }

        private void CloseConfiguration(bool saveOnDisk)
        {
            if (saveOnDisk)
            {
                Material mat = m_MainCacheMaterials[m_CurrentMeshACIndex];
                Shader shader = mat.shader;

                ShaderMetaDataUtility.SaveShaderMetaData(shader, m_LoadedAttributes);
                foreach(GameObject go in Selection.gameObjects)
                    m_LikelySupportsTextureBlending = CheckForTextureBlendSupport(go);
            }

            m_LoadedAttributes = null;
            m_CurrentPanelView = PanelView.Paint;
        }

        private void DrawGUIPaintView()
        {
            if (meshAttributes != null)
            {
                RefreshPreviewTextureCache();
                int prevSelectedAttributeIndex = selectedAttributeIndex;
                selectedAttributeIndex =
                    SplatWeightEditor.OnInspectorGUI(selectedAttributeIndex, ref brushColor, meshAttributes);
                if (prevSelectedAttributeIndex != selectedAttributeIndex)
                    SetBrushColorWithAttributeIndex(selectedAttributeIndex);

#if POLYBRUSH_DEBUG
				GUILayout.BeginHorizontal();

				GUILayout.FlexibleSpace();

				if(GUILayout.Button("MetaData", EditorStyles.miniButton))
				{
					Debug.Log(meshAttributes.ToString("\n"));

					string str = EditorUtility.FindPolybrushMetaDataForShader(meshAttributesContainer.shader);

					if(!string.IsNullOrEmpty(str))
					{
						TextAsset asset = AssetDatabase.LoadAssetAtPath<TextAsset>(str);

						if(asset != null)
							EditorGUIUtility.PingObject(asset);
						else
							Debug.LogWarning("No MetaData found for Shader \"" + meshAttributesContainer.shader.name + "\"");
					}
					else
					{
						Debug.LogWarning("No MetaData found for Shader \"" + meshAttributesContainer.shader.name + "\"");
					}
				}

				GUILayout.EndHorizontal();

				GUILayout.Space(4);

				if(GUILayout.Button("rebuild  targets"))
					RebuildColorTargets(brushColor, brushSettings.strength);


				GUILayout.Label(brushColor != null ? brushColor.ToString() : "brush color: null\n");
#endif
            }
            else
            {
                if (!m_LikelySupportsTextureBlending)
                {
                    EditorGUILayout.HelpBox("It doesn't look like any of the materials on this object support texture blending!\n\nSee the readme for information on creating custom texture blend shaders.", MessageType.Warning);
                }

            }
        }

        private void DrawConfigurationPanel(MaterialPropertyInfo guiInfo, string propertyName, Material mat)
        {
            using (new GUILayout.HorizontalScope("box"))
            {
                using (new GUILayout.VerticalScope())
                {
                    EditorGUI.BeginChangeCheck();
                    using (new GUILayout.HorizontalScope())
                    {
                        if (!m_LoadedAttributes.HasAttributes(propertyName))
                        {
                            GUILayout.Label(propertyName, GUILayout.Width(100));
                            GUILayout.FlexibleSpace();
                            if (GUILayout.Button("Create attributes",GUILayout.Width(120), GUILayout.Height(16)))
                            {
                                AttributeLayout newAttr = new AttributeLayout();
                                newAttr.propertyTarget = propertyName;
                                m_LoadedAttributes.AddAttribute(newAttr);
                            }
                        }
                        else
                        {
                            guiInfo.IsVisible = EditorGUILayout.Foldout(guiInfo.IsVisible, propertyName, true);
                            if (GUILayout.Button("Erase attributes", GUILayout.ExpandWidth(true), GUILayout.MinWidth(60), GUILayout.MaxWidth(120), GUILayout.Height(16)))
                                m_LoadedAttributes.RemoveAttribute(propertyName);
                        }
                    }

                    if (EditorGUI.EndChangeCheck())
                    {
                        UpdatePropertyInfo(guiInfo);
                    }

                    if (m_LoadedAttributes.HasAttributes(propertyName) && guiInfo.IsVisible)
                    {
                        AttributeLayout attr = m_LoadedAttributes.GetAttributes(propertyName);

                        EditorGUILayout.Space();

                        using (new GUILayout.HorizontalScope())
                        {
                            using (new GUILayout.VerticalScope(GUILayout.Width(70), GUILayout.ExpandWidth(false)))
                            {
                                Texture tex = mat.GetTexture(propertyName);
                                EditorGUI.DrawPreviewTexture(
                                    EditorGUILayout.GetControlRect(GUILayout.Width(64), GUILayout.Height(64)),
                                    (tex != null) ? tex : Texture2D.blackTexture);
                            }

                            using (new GUILayout.VerticalScope())
                            {
                                GUILayout.Label("Channel");
                                GUILayout.Label("Index");
                                GUILayout.Label("Range");
                                GUILayout.Label("Group");
                                GUILayout.Label("Is Base Texture");
                            }
                            GUILayout.FlexibleSpace();

                            using (new GUILayout.VerticalScope())
                            {
                                // Channel selection
                                attr.channel =
                                    Styles.ToMeshChannel(EditorGUILayout.Popup(Styles.ToInt(attr.channel), Styles.k_MeshChannel, GUILayout.Width(140)));

                                // Index selection
                                attr.index = (ComponentIndex)GUILayout.Toolbar((int)attr.index, ComponentIndexUtility.ComponentIndexPopupDescriptions, GUILayout.Width(140));

                                // Value range
                                attr.range = EditorGUILayout.Vector2Field("", attr.range, GUILayout.Width(140));

                                // Group selection
                                attr.mask = EditorGUILayout.Popup(attr.mask, AttributeLayout.DefaultMaskDescriptions, GUILayout.Width(140));

                                attr.isBaseTexture = EditorGUILayout.Toggle(attr.isBaseTexture);
                            }
                        }
                    }
                }
            }
        }

        internal override void OnBrushSettingsChanged(BrushTarget target, BrushSettings settings)
		{
			base.OnBrushSettingsChanged(target, settings);
			RebuildColorTargets(target?.editableObject, brushColor, settings.strength);
            //RebuildColorTargets(brushColor, settings.strength);
		}

        /// <summary>
        /// Test a gameObject and it's mesh renderers for compatible shaders, and if one is found
        /// load it's attribute data into meshAttributes.
        /// </summary>
        /// <param name="go">The GameObject being checked for texture blend support</param>
        /// <returns></returns>
        internal bool CheckForTextureBlendSupport(GameObject go)
		{
            bool supports = false;
            var materials = Util.GetMaterials(go);
            m_MeshAttributesContainers.Clear();
            Material mat;
            List<int> indexes = new List<int>();
            for(int i = 0; i < materials.Count; i++)
            {
                mat = materials[i];
                if (ShaderMetaDataUtility.IsValidShader(mat.shader))
                {
                    AttributeLayoutContainer detectedMeshAttributes = ShaderMetaDataUtility.LoadShaderMetaData(mat.shader);
                    {
                        if (detectedMeshAttributes != null)
                        {
                            m_MeshAttributesContainers.Add(detectedMeshAttributes);
                            indexes.Add(i);
                            m_MainCacheMaterials.Add(mat);
                            supports = true;
                        }
                    }
                }
            }

            if (supports)
            {
                m_MeshAttributesContainer = m_MeshAttributesContainers.First();
                foreach(int i in indexes)
                    ArrayUtility.Add<string>(ref m_AvailableMaterialsAsString, materials[i].name);
            }

            if (meshAttributes == null)
                supports = false;

            return supports;
		}

		internal void SetBrushColorWithAttributeIndex(int index)
		{
			if(	brushColor == null ||
				meshAttributes == null)
				return;

			if(meshAttributes[index].mask > -1)
			{
				for(int i = 0; i < meshAttributes.Length; i++)
				{
                    brushColor.SetAttributeValue(meshAttributes[i], meshAttributes[i].min);
				}
			}

			brushColor.SetAttributeValue(meshAttributes[index], meshAttributes[index].max);
		}

		// Called when the mouse begins hovering an editable object.
		internal override void OnBrushEnter(EditableObject target, BrushSettings settings)
        {
			base.OnBrushEnter(target, settings);

			if(target.editMesh == null)
				return;

            bool refresh = (m_MainCacheTarget != null && !m_MainCacheTarget.Equals(target)) || m_MainCacheTarget == null;

            if (m_MainCacheTarget != null && m_MainCacheTarget.Equals(target))
            {
                var targetMaterials = target.gameObjectAttached.GetMaterials();
                refresh = !targetMaterials.SequenceEqual(m_MainCacheMaterials);
            }

            if (refresh)
            {
                SetActiveObject(target);
                RebuildMaterialCaches();
                PolybrushEditor.instance.Repaint();
            }

            if (m_LikelySupportsTextureBlending && (brushColor == null || !brushColor.MatchesAttributes(meshAttributes)))
            {
                brushColor = new SplatWeight(SplatWeight.GetChannelMap(meshAttributes));
                SetBrushColorWithAttributeIndex(selectedAttributeIndex);
            }
            RebuildColorTargets(target, brushColor, settings.strength);
        }

        void RebuildMaterialCaches()
        {
            ArrayUtility.Clear(ref m_AvailableMaterialsAsString);
            m_CurrentMeshACIndex = 0;
            m_MainCacheMaterials.Clear();
            if (m_MainCacheTarget == null)
                return;
            m_MeshAttributesContainer = null;
            m_CurrentMeshACIndex = 0;
            m_LikelySupportsTextureBlending = CheckForTextureBlendSupport(m_MainCacheTarget.gameObjectAttached);
        }

		// Called whenever the brush is moved.  Note that @target may have a null editableObject.
		internal override void OnBrushMove(BrushTarget target, BrushSettings settings)
		{
			base.OnBrushMove(target, settings);

			if(!Util.IsValid(target) || !m_LikelySupportsTextureBlending || meshAttributes.Length == 0)
				return;

            if(!m_EditableObjectsData.ContainsKey(target.editableObject))
                return;

            var data = m_EditableObjectsData[target.editableObject];

            if(!data.CacheMaterials.Contains(m_MainCacheMaterials[m_CurrentMeshACIndex]))
                return;

			bool invert = settings.isUserHoldingControl;
			float[] weights;

			if(m_PaintMode == PaintMode.Brush)
			{
				weights = target.GetAllWeights();
			}
			else if(m_PaintMode == PaintMode.Flood)
			{
				weights = new float[data.VertexCount];

				for(int i = 0; i < data.VertexCount; i++)
					weights[i] = 1f;
			}
			else
			{
				weights = new float[data.VertexCount];
				int[] indices = target.editableObject.editMesh.GetTriangles();
				int index = 0;
				float weightTarget = 1f;

				foreach(PolyRaycastHit hit in target.raycastHits)
				{
					if(hit.triangle > -1)
					{
						index = hit.triangle * 3;

						m_FillModeEdges[0].x = indices[index+0];
						m_FillModeEdges[0].y = indices[index+1];

						m_FillModeEdges[1].x = indices[index+1];
						m_FillModeEdges[1].y = indices[index+2];

						m_FillModeEdges[2].x = indices[index+2];
						m_FillModeEdges[2].y = indices[index+0];

						for(int i = 0; i < 3; i++)
						{
							if(data.TriangleLookup.TryGetValue(m_FillModeEdges[i], out m_FillModeAdjacentTriangles))
							{
								for(int n = 0; n < m_FillModeAdjacentTriangles.Count; n++)
								{
									index = m_FillModeAdjacentTriangles[n] * 3;

									weights[indices[index  ]] = weightTarget;
									weights[indices[index+1]] = weightTarget;
									weights[indices[index+2]] = weightTarget;
								}
							}
						}
					}
				}
			}

			int mask = meshAttributes[selectedAttributeIndex].mask;

            if(data.SplatCurrent == null)
                RebuildCaches(data);

			data.SplatCurrent.LerpWeights(data.SplatCache, invert ? data.SplatErase : data.SplatTarget, mask, weights);
			data.SplatCurrent.Apply(target.editableObject.editMesh);
			target.editableObject.ApplyMeshAttributes();
		}

		// Called when the mouse exits hovering an editable object.
		internal override void OnBrushExit(EditableObject target)
        {
			base.OnBrushExit(target);

            if(!m_EditableObjectsData.ContainsKey(target))
                return;

            var data = m_EditableObjectsData[target];
			if(data.SplatCache != null)
			{
				data.SplatCache.Apply(target.editMesh);
				target.ApplyMeshAttributes();
				target.graphicsMesh.UploadMeshData(false);
			}

            if(m_MainCacheTarget != null && data.CacheTarget.Equals(m_MainCacheTarget))
                m_MainCacheTarget = null;

            m_EditableObjectsData.Remove(target);
		}

		// Called every time the brush should apply itself to a valid target.  Default is on mouse move.
		internal override void OnBrushApply(BrushTarget target, BrushSettings settings)
		{
			if(!m_LikelySupportsTextureBlending)
				return;

            var data = m_EditableObjectsData[target.editableObject];
			data.SplatCurrent.CopyTo(data.SplatCache);
			data.SplatCache.Apply(target.editableObject.editMesh);

            MeshChannel channelsChanged =
                MeshChannel.Color | MeshChannel.Tangent | MeshChannel.UV0 | MeshChannel.UV2 | MeshChannel.UV3 | MeshChannel.UV4;
            target.editableObject.modifiedChannels |= channelsChanged;
            base.OnBrushApply(target, settings);
		}

		// set mesh splat_current back to their original state before registering for undo
		internal override void RegisterUndo(BrushTarget brushTarget)
		{
            if(!m_EditableObjectsData.ContainsKey(brushTarget.editableObject))
                return;

            var data = m_EditableObjectsData[brushTarget.editableObject];
			if(data.SplatCache != null)
			{
				data.SplatCache.Apply(brushTarget.editableObject.editMesh);
				brushTarget.editableObject.ApplyMeshAttributes();
			}

			base.RegisterUndo(brushTarget);
		}

        internal override void UndoRedoPerformed(List<GameObject> modified)
        {
            base.UndoRedoPerformed(modified);
            foreach(var data in m_EditableObjectsData)
                RebuildCaches(data.Value);
        }

		internal override void DrawGizmos(BrushTarget target, BrushSettings settings)
		{
			PolyMesh mesh = target.editableObject.editMesh;

			if(Util.IsValid(target) && m_PaintMode == PaintMode.Fill)
			{
				Vector3[] vertices = mesh.vertices;
				int[] indices = mesh.GetTriangles();

                using(new Handles.DrawingScope(target.transform.localToWorldMatrix))
                {
				    int index = 0;

                    var data = m_EditableObjectsData[target.editableObject];
				    foreach(PolyRaycastHit hit in target.raycastHits)
				    {
					    if(hit.triangle > -1)
					    {
						    Handles.color = Color.green;

						    index = hit.triangle * 3;

						    Handles.DrawLine(vertices[indices[index+0]] + hit.normal * .1f, vertices[indices[index+1]] + hit.normal * .1f);
						    Handles.DrawLine(vertices[indices[index+1]] + hit.normal * .1f, vertices[indices[index+2]] + hit.normal * .1f);
						    Handles.DrawLine(vertices[indices[index+2]] + hit.normal * .1f, vertices[indices[index+0]] + hit.normal * .1f);

						    m_FillModeEdges[0].x = indices[index+0];
						    m_FillModeEdges[0].y = indices[index+1];

						    m_FillModeEdges[1].x = indices[index+1];
						    m_FillModeEdges[1].y = indices[index+2];

						    m_FillModeEdges[2].x = indices[index+2];
						    m_FillModeEdges[2].y = indices[index+0];

						    for(int i = 0; i < 3; i++)
						    {
							    if(data.TriangleLookup.TryGetValue(m_FillModeEdges[i], out m_FillModeAdjacentTriangles))
							    {
								    for(int n = 0; n < m_FillModeAdjacentTriangles.Count; n++)
								    {
									    index = m_FillModeAdjacentTriangles[n] * 3;

									    Handles.DrawLine(vertices[indices[index+0]] + hit.normal * .1f, vertices[indices[index+1]] + hit.normal * .1f);
									    Handles.DrawLine(vertices[indices[index+1]] + hit.normal * .1f, vertices[indices[index+2]] + hit.normal * .1f);
									    Handles.DrawLine(vertices[indices[index+2]] + hit.normal * .1f, vertices[indices[index+0]] + hit.normal * .1f);
								    }
							    }
						    }
					    }
				    }
                }
            }
			else
			{
				base.DrawGizmos(target, settings);
			}

		}

	    internal void RefreshPreviewTextureCache()
	    {
	        if (meshAttributes != null
                && m_MainCacheMaterials != null)
	        {
	            for (int i = 0; i < meshAttributes.Length; ++i)
	            {
	                AttributeLayout attributes = meshAttributes[i];
	                attributes.previewTexture = (Texture2D)m_MainCacheMaterials[m_CurrentMeshACIndex].GetTexture(attributes.propertyTarget);
	            }
	        }
	    }

        private AttributeLayout GetBaseTexture()
        {
            AttributeLayout selectedAttribute = meshAttributes[selectedAttributeIndex];
            foreach (var attr in meshAttributes)
            {
                if (attr.mask != selectedAttribute.mask)
                {
                    continue;
                }

                if (attr.isBaseTexture)
                {
                    return attr;
                }
            }
            return null;
        }

        void RebuildColorTargets(EditableObject target, SplatWeight blend, float strength)
        {
            if(target == null)
                return;

            var data = m_EditableObjectsData[target];

            if (blend == null || data.SplatCache == null || data.SplatTarget == null)
                return;

            m_MinWeights = data.SplatTarget.GetMinWeights();

            data.SplatTarget.LerpWeights(data.SplatCache, blend, strength);

            // get index of texture that is being painted
            var attrib = meshAttributes[selectedAttributeIndex];

            var baseTexture = attrib.isBaseTexture? attrib : GetBaseTexture();
            var baseTexIndex = baseTexture != null ? (int)baseTexture.index : -1;

            data.SplatErase.LerpWeightOnSingleChannel(data.SplatCache, m_MinWeights, strength, attrib.channel, (int)attrib.index, baseTexIndex);
        }

        void SetupBaseTextures(SplatSet set)
        {
            // map base texture index to mask index
            // map mask index to indices of other textures in mask
            Dictionary<MeshChannel, List<int>> channelsToBaseTex = new Dictionary<MeshChannel, List<int>>();
            Dictionary<int, int> baseTexToMask = new Dictionary<int, int>();
            Dictionary<int, List<int>> maskToIndices = new Dictionary<int, List<int>>();

            foreach(var attr in meshAttributes)
            {
                if (attr.isBaseTexture)
                {
                    if (channelsToBaseTex.TryGetValue(attr.channel, out List<int> baseTexIndices))
                    {
                        baseTexIndices.Add((int)attr.index);
                        channelsToBaseTex[attr.channel] = baseTexIndices;
                    }
                    else
                        channelsToBaseTex.Add(attr.channel, new List<int>() { (int)attr.index });

                    baseTexToMask.Add((int)attr.index, attr.mask);
                }
                else
                {
                    if (maskToIndices.TryGetValue(attr.mask, out List<int> indices))
                    {
                        indices.Add((int)attr.index);
                        maskToIndices[attr.mask] = indices;
                    }
                    else
                        maskToIndices.Add(attr.mask, new List<int>() { (int)attr.index });
                }
            }
            if(baseTexToMask.Count > 0)
                set.SetChannelBaseTextureWeights(channelsToBaseTex, baseTexToMask, maskToIndices);
        }

        void SetActiveObject(EditableObject activeObject)
        {
            m_MainCacheTarget = activeObject;

            EditableObjectData data;

            if(!m_EditableObjectsData.TryGetValue(activeObject, out data))
            {
                data = new EditableObjectData();
                m_EditableObjectsData.Add(activeObject, data);
            }

            data.CacheTarget = activeObject;
            data.CacheMaterials = activeObject.gameObjectAttached.GetMaterials();
            RebuildCaches(data);
        }

        void RebuildCaches(EditableObjectData data)
        {
            PolyMesh mesh = data.CacheTarget.editMesh;
            data.VertexCount = mesh.vertexCount;
            data.TriangleLookup = PolyMeshUtility.GetAdjacentTriangles(mesh);

            if (meshAttributes == null)
            {
                // clear caches
                data.SplatCache = null;
                data.SplatCurrent = null;
                data.SplatTarget = null;
                data.SplatErase = null;
                return;
            }

            data.SplatCache = new SplatSet(mesh, meshAttributes);
            SetupBaseTextures(data.SplatCache);
            data.SplatCurrent = new SplatSet(data.SplatCache);
            data.SplatTarget = new SplatSet(data.VertexCount, meshAttributes);
            data.SplatErase = new SplatSet(data.VertexCount, meshAttributes);
        }
    }
}