public override void OnBrushApply(z_BrushTarget target, z_BrushSettings settings)
		{
			Vector3[] vertices = target.editableObject.vertices;
			Vector3 v, n = direction.ToVector3();

			float scale = 1f / ( Vector3.Scale(target.transform.lossyScale, n).magnitude );
			float sign = Event.current.shift ? -1f : 1f;

			float maxMoveDistance = settings.strength * STRENGTH_MODIFIER * sign * brushStrength;

			foreach(KeyValuePair<int, float> weight in target.weights)
			{
				if(ignoreNonManifoldIndices && nonManifoldIndices.Contains(weight.Key))
					continue;

				v = vertices[weight.Key];

				if(direction == z_Direction.Normal)
				{
					n = normalLookup[weight.Key];
					scale = 1f / ( Vector3.Scale(target.transform.lossyScale, n).magnitude );
				}

				vertices[weight.Key] = v + n * weight.Value * maxMoveDistance * scale;
			}

			target.editableObject.mesh.vertices = vertices;

			if(tempComponent != null)
				tempComponent.OnVerticesMoved();

			base.OnBrushApply(target, settings);
		}
		public static void DrawScatterBrush(Vector3 point, Vector3 normal, z_BrushSettings settings, Matrix4x4 localToWorldMatrix)
		{
			Vector3 p = localToWorldMatrix.MultiplyPoint3x4(point);
			Vector3 n = localToWorldMatrix.MultiplyVector(normal).normalized;
			
			float r = settings.radius;
			Vector3 a = Vector3.zero;
			Quaternion rotation = Quaternion.LookRotation(normal, Vector3.up);

			for(int i = 0; i < 10; i++)
			{
				a.x = Mathf.Cos(Random.Range(0f, 360f));
				a.y = Mathf.Sin(Random.Range(0f, 360f));
				a = a.normalized * Random.Range(0f, r);

				Vector3 v = localToWorldMatrix.MultiplyPoint3x4(point + rotation * a);

				Handles.DrawLine(v, v  + (n * .5f));

				Handles.CubeCap(i + 2302, v, Quaternion.identity, .01f);
			}

			/// radius
			Handles.DrawWireDisc(p, n, settings.radius);
		}
		protected override void UpdateTempComponent(z_BrushTarget target, z_BrushSettings settings)
		{
			if(tempComponent != null && target.weights != null)
			{
				((z_OverlayRenderer)tempComponent).SetWeights(target.weights, settings.strength);
			}
		}
		/// Called when the mouse begins hovering an editable object.
		public virtual void OnBrushEnter(z_EditableObject target, z_BrushSettings settings)
		{
			if(z_Pref.GetBool(z_Pref.hideWireframe) && target.renderer != null)
				EditorUtility.SetSelectedWireframeHidden(target.renderer, true);

			CreateTempComponent(target, settings);
		}
		public override void DrawGUI(z_BrushSettings settings)
		{
			base.DrawGUI(settings);

			if(direction == z_Direction.Normal)
				relax = EditorGUILayout.Toggle(gc_relax, relax);
		}
		protected virtual void UpdateTempComponent(z_BrushTarget target, z_BrushSettings settings)
		{
			if(!z_Util.IsValid(target))
				return;
				
			tempComponent.SetWeights(target.weights, settings.strength);
		}
		public static void DrawBrush(	Vector3 point,
										Vector3 normal,
										z_BrushSettings brushSettings,
										Matrix4x4 matrix,
										Color innerColor,
										Color outerColor)
		{
			PushHandleColor();

			Vector3 p = matrix.MultiplyPoint3x4(point);
			Vector3 n = matrix.MultiplyVector(normal).normalized;
			
			/// radius
			Handles.color = outerColor;
			Handles.DrawWireDisc(p, n, brushSettings.radius);

			/// falloff
			Handles.color = innerColor;
			Handles.DrawWireDisc(p, n, brushSettings.radius * brushSettings.falloff);

			Handles.color = new Color(	Mathf.Abs(n.x),
										Mathf.Abs(n.y),
										Mathf.Abs(n.z),
										1f);

			Handles.DrawLine(p, p + n.normalized * HandleUtility.GetHandleSize(p));

			PopHandleColor();
		}
 public override void OnBrushEnter(z_EditableObject target, z_BrushSettings settings)
 {
     base.OnBrushEnter(target, settings);
     vertices          = target.editMesh.vertices;
     normalLookup      = z_MeshUtility.GetSmoothNormalLookup(target.editMesh);
     commonVertices    = z_MeshUtility.GetCommonVertices(target.editMesh);
     commonVertexCount = commonVertices.Count;
 }
Exemple #9
0
        protected virtual void UpdateTempComponent(z_BrushTarget target, z_BrushSettings settings)
        {
            if (!z_Util.IsValid(target))
            {
                return;
            }

            tempComponent.SetWeights(target.GetAllWeights(), settings.strength);
        }
		protected virtual void CreateTempComponent(z_EditableObject target, z_BrushSettings settings)
		{
			if(!z_Util.IsValid(target))
				return;

			tempComponent = target.gameObject.AddComponent<z_ZoomOverride>();
			tempComponent.hideFlags = HideFlags.HideAndDontSave;
			tempComponent.SetWeights(null, 0f);
		}
Exemple #11
0
        protected virtual void CreateTempComponent(z_EditableObject target, z_BrushSettings settings)
        {
            if(!z_Util.IsValid(target))
                return;

            tempComponent = target.gameObject.AddComponent<z_ZoomOverride>();
            tempComponent.hideFlags = HideFlags.HideAndDontSave;
            tempComponent.SetWeights(null, 0f);
        }
		public override void DrawGUI(z_BrushSettings settings)
		{
			base.DrawGUI(settings);

			EditorGUI.BeginChangeCheck();
			brushStrength = EditorGUILayout.FloatField(gc_BrushEffect, brushStrength);
			if(EditorGUI.EndChangeCheck())
				EditorPrefs.SetFloat(BRUSH_EFFECT_PREF, brushStrength);
		}
Exemple #13
0
        // Called when the mouse begins hovering an editable object.
        public virtual void OnBrushEnter(z_EditableObject target, z_BrushSettings settings)
        {
            if (z_Pref.GetBool(z_Pref.hideWireframe) && target.renderer != null)
            {
                // disable wirefame
                z_EditorUtility.SetSelectionRenderState(target.renderer, z_EditorUtility.GetSelectionRenderState() & z_SelectionRenderState.Outline);
            }

            CreateTempComponent(target, settings);
        }
		protected override void CreateTempComponent(z_EditableObject target, z_BrushSettings settings)
		{
			z_OverlayRenderer ren = target.gameObject.AddComponent<z_OverlayRenderer>();
			ren.SetMesh(target.mesh);
			
			ren.fullColor = z_Pref.GetColor(z_Pref.brushColor);
			ren.gradient = z_Pref.GetGradient(z_Pref.brushGradient);

			tempComponent = ren;
		}
		public override void OnBrushApply(z_BrushTarget brushTarget, z_BrushSettings brushSettings)
		{
			// false means no ToMesh or Refresh, true does.  Optional addl bool runs pb_Object.Optimize()
			brushTarget.editableObject.Apply(true);
			
			if(_pbEditor != null)
				z_ReflectionUtil.Invoke(_pbEditor, "Internal_UpdateSelectionFast", BindingFlags.Instance | BindingFlags.NonPublic);	

			UpdateTempComponent(brushTarget, brushSettings);
		}
Exemple #16
0
        // Called every time the brush should apply itself to a valid target.  Default is on mouse move.
        public override void OnBrushApply(z_BrushTarget target, z_BrushSettings settings)
        {
            if (!likelySupportsTextureBlending)
            {
                return;
            }

            splat_current.CopyTo(splat_cache);
            splat_cache.Apply(target.editableObject.editMesh);
            base.OnBrushApply(target, settings);
        }
Exemple #17
0
        public override void DrawGUI(z_BrushSettings settings)
        {
            base.DrawGUI(settings);

            EditorGUI.BeginChangeCheck();
            brushStrength = z_GUILayout.FloatField(gc_BrushEffect, brushStrength);
            if (EditorGUI.EndChangeCheck())
            {
                z_Pref.SetFloat(BRUSH_EFFECT_PREF, brushStrength);
            }
        }
		public override void OnBrushEnter(z_EditableObject target, z_BrushSettings settings)
		{
			base.OnBrushEnter(target, settings);
			
			neighborLookup = z_MeshUtility.GetAdjacentVertices(target.mesh);
			int vertexCount = target.mesh.vertexCount;
			cached_vertices = new Vector3[vertexCount];
			cached_normals = new Vector3[vertexCount];
			System.Array.Copy(target.mesh.vertices, cached_vertices, vertexCount);
			System.Array.Copy(target.mesh.normals, cached_normals, vertexCount);
		}
Exemple #19
0
 /**
  * Copy all properties to target
  */
 public void CopyTo(z_BrushSettings target)
 {
     target.name                      = this.name;
     target.brushRadiusMin            = this.brushRadiusMin;
     target.brushRadiusMax            = this.brushRadiusMax;
     target._radius                   = this._radius;
     target._falloff                  = this._falloff;
     target._strength                 = this._strength;
     target._curve                    = new AnimationCurve(this._curve.keys);
     target.allowNonNormalizedFalloff = this.allowNonNormalizedFalloff;
 }
        protected override void CreateTempComponent(z_EditableObject target, z_BrushSettings settings)
        {
            z_OverlayRenderer ren = target.gameObject.AddComponent <z_OverlayRenderer>();

            ren.SetMesh(target.editMesh);

            ren.fullColor = z_Pref.GetColor(z_Pref.brushColor);
            ren.gradient  = z_Pref.GetGradient(z_Pref.brushGradient);

            tempComponent = ren;
        }
Exemple #21
0
        public override void OnBrushApply(z_BrushTarget brushTarget, z_BrushSettings brushSettings)
        {
            // false means no ToMesh or Refresh, true does.  Optional addl bool runs pb_Object.Optimize()
            brushTarget.editableObject.Apply(true);

            if (_pbEditor != null)
            {
                z_ReflectionUtil.Invoke(_pbEditor, "Internal_UpdateSelectionFast", BindingFlags.Instance | BindingFlags.NonPublic);
            }

            UpdateTempComponent(brushTarget, brushSettings);
        }
		public override void DrawGUI(z_BrushSettings settings)
		{
			base.DrawGUI(settings);

			GUILayout.Label(ModeSettingsHeader, z_GUI.headerTextStyle);

			ignoreNonManifoldIndices = EditorGUILayout.Toggle(gc_ignoreOpenEdges, ignoreNonManifoldIndices);

			EditorGUI.BeginChangeCheck();
			direction = (z_Direction) EditorGUILayout.EnumPopup(gc_direction, direction);
			if(EditorGUI.EndChangeCheck())
				EditorPrefs.SetInt(z_Pref.sculptDirection, (int) direction);
		}
		public void SetBrushSettings(z_BrushSettings settings)
		{
			if(settings == null)
				return;

			if(brushSettings != null && brushSettings != settings)
				GameObject.DestroyImmediate(brushSettings);

			brushSettingsAsset = settings;
			brushSettings = settings.DeepCopy();
			brushSettings.hideFlags = HideFlags.HideAndDontSave;
			RefreshAvailableBrushes();

			Repaint();
		}
Exemple #24
0
        public override void DrawGizmos(z_BrushTarget target, z_BrushSettings settings)
        {
            base.DrawGizmos(target, settings);

            // SphereBounds bounds;

            // foreach(GameObject go in instances)
            // {
            //  if(!GetSphereBounds(go, out bounds))
            //      continue;

            //  Handles.CircleCap(-1, bounds.position, Quaternion.Euler(Vector3.up * 90f), bounds.radius);
            //  Handles.CircleCap(-1, bounds.position, Quaternion.Euler(Vector3.right * 90f), bounds.radius);
            //  Handles.CircleCap(-1, bounds.position, Quaternion.Euler(Vector3.forward * 90f), bounds.radius);
            // }
        }
		/// Inspector GUI shown in the Editor window.  Base class shows z_BrushSettings by default
		public override void DrawGUI(z_BrushSettings brushSettings)
		{
			base.DrawGUI(brushSettings);

			GUILayout.Label("Placement Settings", z_GUI.headerTextStyle);

			placeWithPivot = EditorGUILayout.Toggle("Use Pivot", placeWithPivot);

			GUILayout.Space(4);

			gameObject = (GameObject) EditorGUILayout.ObjectField("GameObject", gameObject, typeof(GameObject), true);

			GUILayout.BeginVertical( paletteStyle );
				prefabPaletteEditor.OnInspectorGUI();
			GUILayout.EndHorizontal();
		}
Exemple #26
0
        // Inspector GUI shown in the Editor window.  Base class shows z_BrushSettings by default
        public override void DrawGUI(z_BrushSettings brushSettings)
        {
            base.DrawGUI(brushSettings);

            placeWithPivot = z_GUILayout.Toggle(gc_usePrefabPivot, placeWithPivot);

            z_GlobalSettingsEditor.lockBrushToFirst = z_GUILayout.Toggle(z_GlobalSettingsEditor.gc_lockBrushToFirst, z_GlobalSettingsEditor.lockBrushToFirst);

            hitSurfaceIsParent.prefValue          = z_GUILayout.Toggle(gc_hitSurfaceIsParent, hitSurfaceIsParent);
            avoidOverlappingGameObjects.prefValue = z_GUILayout.Toggle(gc_avoidOverlappingGameObjects, avoidOverlappingGameObjects);

            GUILayout.Space(4);

            if (prefabPalette == null)
            {
                RefreshAvailablePalettes();
            }

            EditorGUI.BeginChangeCheck();
            currentPaletteIndex = EditorGUILayout.Popup(currentPaletteIndex, availablePalettes_str, "popup");
            if (EditorGUI.EndChangeCheck())
            {
                if (currentPaletteIndex >= availablePalettes.Length)
                {
                    SetPrefabPalette(z_PrefabPaletteEditor.AddNew());
                }
                else
                {
                    SetPrefabPalette(availablePalettes[currentPaletteIndex]);
                }
            }

            GUILayout.Space(4);

            GUILayout.BeginHorizontal();
            GUILayout.Label("Prefabs", z_GUI.headerTextStyle);
            previewThumbSize.prefValue = (int)GUILayout.HorizontalSlider((float)previewThumbSize, 16f, 128f);
            GUILayout.EndHorizontal();

            GUILayout.BeginVertical(paletteStyle);
            if (prefabPaletteEditor != null)
            {
                prefabPaletteEditor.OnInspectorGUI_Internal(previewThumbSize);
            }
            GUILayout.EndVertical();
        }
Exemple #27
0
        private void RemoveGameObjects(z_RaycastHit hit, z_BrushTarget target, z_BrushSettings settings)
        {
            Vector3 worldHitPosition = target.editableObject.transform.TransformPoint(hit.position);

            int count = instances.Count;

            for (int i = 0; i < count; i++)
            {
                if (instances[i] != null && Vector3.Distance(worldHitPosition, instances[i].transform.position) < settings.radius)
                {
                    GameObject go = instances[i];
                    instances.RemoveAt(i);
                    count--;
                    Undo.DestroyObjectImmediate(go);
                }
            }
        }
Exemple #28
0
        // Called when the mouse begins hovering an editable object.
        public override void OnBrushEnter(z_EditableObject target, z_BrushSettings settings)
        {
            base.OnBrushEnter(target, settings);

            if (target.editMesh == null)
            {
                return;
            }

            likelySupportsTextureBlending = CheckForTextureBlendSupport(target.gameObject);

            if (likelySupportsTextureBlending && (brushColor == null || !brushColor.MatchesAttributes(meshAttributes)))
            {
                brushColor = new z_SplatWeight(z_SplatWeight.GetChannelMap(meshAttributes));
                SetBrushColorWithAttributeIndex(z_Math.Clamp(selectedAttributeIndex, 0, meshAttributes.Length - 1));
            }

            RebuildCaches(target.editMesh, settings.strength);
            RebuildColorTargets(brushColor, settings.strength);
        }
Exemple #29
0
        private void RebuildCaches(z_EditableObject target, z_BrushSettings settings)
        {
            z_Mesh m           = target.editMesh;
            int    vertexCount = m.vertexCount;

            if (m.colors != null && m.colors.Length == vertexCount)
            {
                colors_cache = z_Util.Duplicate(m.colors);
            }
            else
            {
                colors_cache = z_Util.Fill <Color32>(x => { return(Color.white); }, vertexCount);
            }

            colors        = new Color32[vertexCount];
            target_colors = new Color32[vertexCount];
            erase_colors  = new Color32[vertexCount];

            RebuildColorTargets(brushColor, settings.strength);
        }
Exemple #30
0
        // Inspector GUI shown in the Editor window.  Base class shows z_BrushSettings by default
        public override void DrawGUI(z_BrushSettings brushSettings)
        {
            base.DrawGUI(brushSettings);

            GUILayout.BeginHorizontal();

            if (colorPalette == null)
            {
                RefreshAvailablePalettes();
            }

            EditorGUI.BeginChangeCheck();
            currentPaletteIndex = EditorGUILayout.Popup(currentPaletteIndex, availablePalettes_str, "popup");
            if (EditorGUI.EndChangeCheck())
            {
                if (currentPaletteIndex >= availablePalettes.Length)
                {
                    SetColorPalette(z_ColorPaletteEditor.AddNew());
                }
                else
                {
                    SetColorPalette(availablePalettes[currentPaletteIndex]);
                }
            }

            paintMode = (z_PaintMode)GUILayout.Toolbar((int)paintMode, modeIcons, "Command", GUILayout.Width(120));

            GUILayout.EndHorizontal();

            if (!likelySupportsVertexColors)
            {
                EditorGUILayout.HelpBox("It doesn't look like any of the materials on this object support vertex colors!", MessageType.Warning);
            }

            colorPaletteEditor.onSelectIndex = (color) => { SetBrushColor(color, brushSettings.strength); };
            colorPaletteEditor.onSaveAs      = SetColorPalette;

            mask = z_GUILayout.ColorMaskField("Color Mask", mask);

            colorPaletteEditor.OnInspectorGUI();
        }
		public override void OnBrushApply(z_BrushTarget target, z_BrushSettings settings)
		{
			Vector3[] vertices = target.editableObject.vertices;
			Vector3 v, t, avg, dirVec = direction.ToVector3();
			Plane plane = new Plane(Vector3.up, Vector3.zero);

			foreach(KeyValuePair<int, float> weight in target.weights)
			{
				if(weight.Value < .0001f || (ignoreNonManifoldIndices && nonManifoldIndices.Contains(weight.Key)))
					continue;

				v = vertices[weight.Key];

				if(direction == z_Direction.Normal && relax)
					avg = z_Math.Average(cached_vertices, neighborLookup[weight.Key]);
				else
					avg = z_Math.WeightedAverage(cached_vertices, neighborLookup[weight.Key], target.weights);

				if(direction != z_Direction.Normal || !relax)
				{
					if(direction == z_Direction.Normal)
						dirVec = z_Math.WeightedAverage(cached_normals, neighborLookup[weight.Key], target.weights).normalized;

					plane.SetNormalAndPosition(dirVec, avg);
					avg = v - dirVec * plane.GetDistanceToPoint(v);
				}

				t = Vector3.Lerp(v, avg, weight.Value);

				vertices[weight.Key] = v + (t-v) * settings.strength * SMOOTH_STRENGTH_MODIFIER;
			}

			target.editableObject.mesh.vertices = vertices;

			if(tempComponent != null)
				tempComponent.OnVerticesMoved();

			base.OnBrushApply(target, settings);
		}
Exemple #32
0
        // Called every time the brush should apply itself to a valid target.  Default is on mouse move.
        public override void OnBrushApply(z_BrushTarget target, z_BrushSettings settings)
        {
            bool shift = Event.current.shift && Event.current.type != EventType.ScrollWheel;

            if ((EditorApplication.timeSinceStartup - lastBrushApplication) > Mathf.Max(.06f, (1f - settings.strength)))
            {
                lastBrushApplication = EditorApplication.timeSinceStartup;

                if (shift)
                {
                    foreach (z_RaycastHit hit in target.raycastHits)
                    {
                        RemoveGameObjects(hit, target, settings);
                    }
                }
                else
                {
                    foreach (z_RaycastHit hit in target.raycastHits)
                    {
                        PlaceGameObject(hit, GetPrefab().gameObject, target, settings);
                    }
                }
            }
        }
		/// Inspector GUI shown in the Editor window.  Base class shows z_BrushSettings by default
		public override void DrawGUI(z_BrushSettings brushSettings)
		{
			base.DrawGUI(brushSettings);

			GUILayout.Label("Paint Settings", z_GUI.headerTextStyle);

			GUILayout.BeginHorizontal();
			GUILayout.FlexibleSpace();
			paintMode = (z_PaintMode) GUILayout.Toolbar( (int) paintMode, modeIcons, "Command", null);
			GUILayout.FlexibleSpace();
			GUILayout.EndHorizontal();

			GUILayout.Space(4);

			// GUILayout.Label( brushColor.ToString() );
			// GUILayout.Label( meshAttributes.ToString("\n"));
			// GUILayout.Space(4);
			
			if(!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);
			else
				brushColor = z_SplatWeightEditor.OnInspectorGUI(brushColor, textures);

		}
Exemple #34
0
        // Called when the mouse begins hovering an editable object.
        public override void OnBrushEnter(z_EditableObject target, z_BrushSettings settings)
        {
            base.OnBrushEnter(target, settings);

            if (target.graphicsMesh == null)
            {
                return;
            }

            RebuildCaches(target, settings);

            triangleLookup = z_MeshUtility.GetAdjacentTriangles(target.editMesh);

            MeshRenderer mr = target.gameObject.GetComponent <MeshRenderer>();

            if (mr != null && mr.sharedMaterials != null)
            {
                likelySupportsVertexColors = mr.sharedMaterials.Any(x => x.shader != null && z_ShaderUtil.SupportsVertexColors(x.shader));
            }
            else
            {
                likelySupportsVertexColors = false;
            }
        }
Exemple #35
0
        // Inspector GUI shown in the Editor window.  Base class shows z_BrushSettings by default
        public override void DrawGUI(z_BrushSettings brushSettings)
        {
            base.DrawGUI(brushSettings);

            GUILayout.BeginHorizontal();
            GUILayout.FlexibleSpace();
            paintMode = (z_PaintMode)GUILayout.Toolbar((int)paintMode, modeIcons, "Command", null);
            GUILayout.FlexibleSpace();
            GUILayout.EndHorizontal();

            GUILayout.Space(4);

            if (!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);
            }

            if (meshAttributes != null)
            {
                int prevSelectedAttributeIndex = selectedAttributeIndex;
                selectedAttributeIndex = z_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 = z_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
            }
        }
Exemple #36
0
		private void AddNewBrush()
		{
			brushSettings = z_BrushSettingsEditor.AddNew();
			RefreshAvailableBrushes();
		}
Exemple #37
0
		public void SetBrush(z_BrushSettings settings)
		{
			if(settings == null)
				return;

			brushSettings = settings;

			RefreshAvailableBrushes();

			Repaint();
		}
		public override void OnBrushEnter(z_EditableObject target, z_BrushSettings settings)
		{
			base.OnBrushEnter(target, settings);
			nonManifoldIndices = z_MeshUtility.GetNonManifoldIndices(target.mesh);
		}
Exemple #39
0
		void OnBrushEnter(z_EditableObject editableObject, z_BrushSettings settings)
		{
			mode.OnBrushEnter(editableObject, settings);
		}
		void OnBrushEnter(z_BrushTarget target, z_BrushSettings settings)
		{
			mode.OnBrushEnter(target.editableObject, settings);
		}
		public override void OnBrushBeginApply(z_BrushTarget brushTarget, z_BrushSettings brushSettings)
		{
			_pbEditor = z_ReflectionUtil.pbEditor;

			base.OnBrushBeginApply(brushTarget, brushSettings);
		}
		void OnGUI()
		{
			Event e = Event.current;
			z_GUI.PushGUISkin(z_GUI.PolybrushSkin);

			if(e.type == EventType.ContextClick)
				OpenContextMenu();

			GUILayout.Space(8);

			EditorGUI.BeginChangeCheck();

			int toolbarIndex = (int) tool - 1;
			toolbarIndex = GUILayout.Toolbar(toolbarIndex, modeIcons, "Mode");

			if(EditorGUI.EndChangeCheck())
			{
				z_BrushTool newTool = (z_BrushTool) (toolbarIndex + 1);
				SetTool( newTool == tool ? z_BrushTool.None : (z_BrushTool)toolbarIndex + 1 );
			}

			// Call current mode GUI
			if(mode != null && tool != z_BrushTool.Settings)
			{
				if(!z_Pref.GetBool(z_Pref.lockBrushSettings))
				{
					z_GUI.PopGUISkin();
					scroll = EditorGUILayout.BeginScrollView(scroll);
					z_GUI.PushGUISkin(z_GUI.PolybrushSkin);
				}

				// Show the settings header in z_Editor so that the preset selector can be included in the block.
				// Can't move preset selector to z_BrushSettingsEditor because it's a CustomEditor for z_BrushSettings,
//commented out code was ommited here 
				if(z_GUILayout.HeaderWithDocsLink(z_GUI.TempContent("Brush Settings")))
					Application.OpenURL("http://procore3d.github.io/polybrush/brushSettings/");

				/**
				 * Brush preset selector
				 */
				GUILayout.BeginHorizontal();
					EditorGUI.BeginChangeCheck();

					currentBrushIndex = EditorGUILayout.Popup(currentBrushIndex, availableBrushes_str, "Popup");

					if(EditorGUI.EndChangeCheck())
					{
						if(currentBrushIndex >= availableBrushes.Count)
							SetBrushSettings(z_BrushSettingsEditor.AddNew());
						else
							SetBrushSettings(availableBrushes[currentBrushIndex]);
					}

					if(GUILayout.Button( gc_SaveBrushSettings, GUILayout.Width(40) ))
					{
						if(brushSettings != null && brushSettingsAsset != null)
						{
							// integer 0, 1 or 2 corresponding to ok, cancel and alt buttons
							int res = EditorUtility.DisplayDialogComplex("Save Brush Settings", "Overwrite brush preset or save as a new preset? ", "Save", "Save As", "Cancel");

							if(res == 0)
							{
								brushSettings.CopyTo(brushSettingsAsset);
								EditorGUIUtility.PingObject(brushSettingsAsset);
							}
							else if(res == 1)
							{
								z_BrushSettings dup = z_BrushSettingsEditor.AddNew();
								string name = dup.name;
								brushSettings.CopyTo(dup);
								dup.name = name;	// want to retain the unique name generated by AddNew()
								SetBrushSettings(dup);
								EditorGUIUtility.PingObject(brushSettingsAsset);
							}
						}
						else
						{
							Debug.LogWarning("Something went wrong saving brush settings.");
						}
					}
				GUILayout.EndHorizontal();

				EditorGUI.BeginChangeCheck();

					brushEditor.OnInspectorGUI();

					if(z_Pref.GetBool(z_Pref.lockBrushSettings))
					{
						z_GUI.PopGUISkin();
						scroll = EditorGUILayout.BeginScrollView(scroll);
						z_GUI.PushGUISkin(z_GUI.PolybrushSkin);
//commented out code was ommited here 

					/**
					 * Mirroring
					 */
					if(z_GUILayout.HeaderWithDocsLink(z_GUI.TempContent("Brush Mirroring")))
						Application.OpenURL("http://procore3d.github.io/polybrush/brushMirroring/");

					GUILayout.BeginHorizontal();
						brushMirror = (z_BrushMirror) z_GUILayout.BitMaskField((uint)brushMirror, System.Enum.GetNames(typeof(z_BrushMirror)), "Set Brush Mirroring");
						mirrorSpace = (z_MirrorCoordinateSpace) GUILayout.Toolbar((int) mirrorSpace, mirrorSpaceGuiContent, "Command");
					GUILayout.EndHorizontal();

					mode.DrawGUI(brushSettings);

					// When using non-conforming heights in a GUIStyle the GUI will sometimes
					// clip the content too early - this pads the size so that doesn't happen.
					GUILayout.Space(16);

				if(EditorGUI.EndChangeCheck())
					mode.OnBrushSettingsChanged(brushTarget, brushSettings);

				EditorGUILayout.EndScrollView();
			}
			else
			{
				if(tool == z_BrushTool.Settings)
				{
					z_GlobalSettingsEditor.OnGUI();
				}
				else
				{
					// ...yo dawg, heard you like FlexibleSpace
					GUILayout.BeginVertical();
						GUILayout.FlexibleSpace();
							GUILayout.BeginHorizontal();
								GUILayout.FlexibleSpace();
									GUILayout.Label("Select an Edit Mode", z_GUI.headerTextStyle);
								GUILayout.FlexibleSpace();
							GUILayout.EndHorizontal();
						GUILayout.FlexibleSpace();
					GUILayout.EndVertical();
				}
			}

#if POLYBRUSH_DEBUG
			z_GUI.PushUnitySkin();
			GUILayout.Label("DEBUG", EditorStyles.boldLabel);

			GUILayout.Label("target: " + (z_Util.IsValid(brushTarget) ? brushTarget.editableObject.gameObject.name : "null"));
			GUILayout.Label("vertex: " + (z_Util.IsValid(brushTarget) ? brushTarget.editableObject.vertexCount : 0));
			GUILayout.Label("applying: " + applyingBrush);
			GUILayout.Label("lockBrushToFirst: " + lockBrushToFirst);
			GUILayout.Label("lastHoveredGameObject: " + lastHoveredGameObject);

			GUILayout.Space(6);

			foreach(var kvp in hovering)
			{
				z_BrushTarget t = kvp.Value;
				z_EditableObject dbg_editable = t.editableObject;
				GUILayout.Label("Vertex Streams: " + dbg_editable.usingVertexStreams);
				GUILayout.Label("Original: " + (dbg_editable.originalMesh == null ? "null" : dbg_editable.originalMesh.name));
				GUILayout.Label("Active: " + (dbg_editable.editMesh == null ? "null" : dbg_editable.editMesh.name));
				GUILayout.Label("Graphics: " + (dbg_editable.graphicsMesh == null ? "null" : dbg_editable.graphicsMesh.name));
			}
			z_GUI.PopGUISkin();
#endif

			z_GUI.PopGUISkin();

			if(wantsRepaint)
			{
				wantsRepaint = false;
				Repaint();
			}
		}

		void OpenContextMenu()
		{
			GenericMenu menu = new GenericMenu();

			menu.AddItem (new GUIContent("Open as Floating Window", ""), z_Pref.GetBool(z_Pref.floatingEditorWindow, false), () => { SetWindowFloating(true); } );
			menu.AddItem (new GUIContent("Open as Dockable Window", ""), !z_Pref.GetBool(z_Pref.floatingEditorWindow, false), () => { SetWindowFloating(false); } );

			menu.ShowAsContext ();
		}

		void OnProBuilderEditLevelChanged(int i)
		{
			// Top = 0,
			// Geometry = 1,
			// Texture = 2,
			// Plugin = 4

			if(i > 0 && tool != z_BrushTool.None)
				SetTool(z_BrushTool.None);
		}

		void SetTool(z_BrushTool brushTool)
		{
			if(brushTool == tool && mode != null)
				return;

			if(z_ReflectionUtil.ProBuilderEditorWindow != null && brushTool != z_BrushTool.None)
				z_ReflectionUtil.Invoke(z_ReflectionUtil.ProBuilderEditorWindow, "SetEditLevel", BindingFlags.Public | BindingFlags.Instance, 0);

			if(mode != null)
			{
				// Exiting edit mode
				if(lastHoveredGameObject != null)
				{
					OnBrushExit( lastHoveredGameObject );
					FinalizeAndResetHovering();
				}

				mode.OnDisable();
			}
			else
			{
				if(z_ReflectionUtil.ProBuilderEditorWindow != null && brushTool != z_BrushTool.None)
					z_ReflectionUtil.Invoke(z_ReflectionUtil.ProBuilderEditorWindow, "SetEditLevel", BindingFlags.Public | BindingFlags.Instance, 0);
			}

			lastHoveredGameObject = null;

			System.Type modeType = brushTool.GetModeType();

			if(modeType != null)
			{
				mode = modes.FirstOrDefault(x => x != null && x.GetType() == modeType);

				if(mode == null)
					mode = (z_BrushMode) ScriptableObject.CreateInstance( modeType );
			}

			tool = brushTool;

			if(tool != z_BrushTool.None)
			{
				Tools.current = Tool.None;
				mode.OnEnable();
			}

			Repaint();
		}
		/// Called every time the brush should apply itself to a valid target.  Default is on mouse move.
		public override void OnBrushApply(z_BrushTarget target, z_BrushSettings settings)
		{
			if(!likelySupportsTextureBlending)
				return;

			colors.CopyTo(colors_cache);
			colors_cache.Apply(target.mesh);

			base.OnBrushApply(target, settings);
		}
Exemple #44
0
 // Called every time the brush should apply itself to a valid target.  Default is on mouse move.
 public override void OnBrushApply(z_BrushTarget target, z_BrushSettings settings)
 {
     System.Array.Copy(colors, colors_cache, colors.Length);
     target.editableObject.editMesh.colors = colors_cache;
     base.OnBrushApply(target, settings);
 }
Exemple #45
0
        // Called whenever the brush is moved.  Note that @target may have a null editableObject.
        public override void OnBrushMove(z_BrushTarget target, z_BrushSettings settings)
        {
            base.OnBrushMove(target, settings);

            if (!z_Util.IsValid(target))
            {
                return;
            }

            bool shift = Event.current.shift && Event.current.type != EventType.ScrollWheel;

            z_Mesh mesh        = target.editableObject.editMesh;
            int    vertexCount = mesh.vertexCount;

            float[] weights = target.GetAllWeights();

            switch (paintMode)
            {
            case z_PaintMode.Flood:
                for (int i = 0; i < vertexCount; i++)
                {
                    colors[i] = target_colors[i];
                }
                break;

            case z_PaintMode.Fill:

                System.Array.Copy(colors_cache, colors, vertexCount);
                int[] indices = target.editableObject.editMesh.GetTriangles();
                int   index   = 0;

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

                        colors[indices[index + 0]] = shift ? WHITE : target_colors[indices[index + 0]];
                        colors[indices[index + 1]] = shift ? WHITE : target_colors[indices[index + 1]];
                        colors[indices[index + 2]] = shift ? WHITE : target_colors[indices[index + 2]];

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

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

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

                        for (int i = 0; i < 3; i++)
                        {
                            if (triangleLookup.TryGetValue(_fillModeEdges[i], out _fillModeAdjacentTris))
                            {
                                for (int n = 0; n < _fillModeAdjacentTris.Count; n++)
                                {
                                    index = _fillModeAdjacentTris[n] * 3;

                                    colors[indices[index + 0]] = shift ? WHITE : target_colors[indices[index + 0]];
                                    colors[indices[index + 1]] = shift ? WHITE : target_colors[indices[index + 1]];
                                    colors[indices[index + 2]] = shift ? WHITE : target_colors[indices[index + 2]];
                                }
                            }
                        }
                    }
                }

                break;

            default:
            {
                for (int i = 0; i < vertexCount; i++)
                {
                    colors[i] = z_Util.Lerp(colors_cache[i],
                                            shift ? erase_colors[i] : target_colors[i],
                                            mask,
                                            weights[i]);
                }
                break;
            }
            }

            target.editableObject.editMesh.colors = colors;
            target.editableObject.ApplyMeshAttributes(z_MeshChannel.Color);
        }
		public override void DrawGizmos(z_BrushTarget target, z_BrushSettings settings)
		{
			if(z_Util.IsValid(target) && paintMode == z_PaintMode.Fill)
			{
				Vector3[] vertices = target.mesh.vertices;
				int[] indices = target.mesh.triangles;

				z_Handles.PushMatrix();
				z_Handles.PushHandleColor();

				Handles.matrix = target.transform.localToWorldMatrix;

				int index = 0;

				foreach(z_RaycastHit hit in target.raycastHits)
				{
					if(hit.triangle > -1)
					{
						Handles.color = target_colors[indices[index]].GetColor32(0);

						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);

						if(triangleLookup.ContainsKey(hit.triangle))
						{
							foreach(int i in triangleLookup[hit.triangle])
							{
								Handles.color = target_colors[indices[index]].GetColor32(0);

								index = i * 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);
							}
						}
					}
				}

				z_Handles.PopHandleColor();
				z_Handles.PopMatrix();
			}
			else
			{
				base.DrawGizmos(target, settings);
			}
		}
		public override void OnBrushSettingsChanged(z_BrushTarget target, z_BrushSettings settings)
		{
			base.OnBrushSettingsChanged(target, settings);
			RebuildColorTargets(brushColor, settings.strength);
		}
		/// Called whenever the brush is moved.  Note that @target may have a null editableObject.
		public override void OnBrushMove(z_BrushTarget target, z_BrushSettings settings)
		{
			base.OnBrushMove(target, settings);

			if(!z_Util.IsValid(target) || !likelySupportsTextureBlending)
				return;

			bool shift = Event.current.shift;

			switch(paintMode)
			{
				case z_PaintMode.Fill:
				
					colors_cache.CopyTo(colors);

					int[] indices = target.mesh.triangles;
					int index = 0;

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

							colors[indices[index + 0]] = shift ? z_SplatWeight.Channel0 : target_colors[indices[index + 0]];
							colors[indices[index + 1]] = shift ? z_SplatWeight.Channel0 : target_colors[indices[index + 1]];
							colors[indices[index + 2]] = shift ? z_SplatWeight.Channel0 : target_colors[indices[index + 2]];

							if(triangleLookup.ContainsKey(hit.triangle))
							{
								foreach(int i in triangleLookup[hit.triangle])
								{
									index = i * 3;

									colors[indices[index + 0]] = shift ? z_SplatWeight.Channel0 : target_colors[indices[index + 0]];
									colors[indices[index + 1]] = shift ? z_SplatWeight.Channel0 : target_colors[indices[index + 1]];
									colors[indices[index + 2]] = shift ? z_SplatWeight.Channel0 : target_colors[indices[index + 2]];
								}
							}
						}
					}

					break;

				default:
					foreach(KeyValuePair<int, float> weight in target.weights)
						colors[weight.Key] = z_SplatWeight.Lerp( colors_cache[weight.Key],
											shift ? erase_colors[weight.Key] : target_colors[weight.Key],
											weight.Value);
					break;
			}

			colors.Apply(target.mesh);
		}
Exemple #49
0
        public override void OnBrushApply(z_BrushTarget target, z_BrushSettings settings)
        {
            int rayCount = target.raycastHits.Count;

            if (rayCount < 1)
            {
                return;
            }

            Vector3 n = direction.ToVector3();

            float scale = 1f / (Vector3.Scale(target.transform.lossyScale, n).magnitude);
            float sign  = Event.current.shift ? -1f : 1f;

            float maxMoveDistance = settings.strength * STRENGTH_MODIFIER * sign * brushStrength;
            int   vertexCount     = target.editableObject.vertexCount;

            z_Mesh mesh = target.editableObject.editMesh;

            for (int ri = 0; ri < rayCount; ri++)
            {
                z_RaycastHit hit = target.raycastHits[ri];

                if (hit.weights == null || hit.weights.Length < vertexCount)
                {
                    continue;
                }

                if (direction == z_Direction.BrushNormal)
                {
                    if (brushNormalIsSticky)
                    {
                        n = brushNormalOnBeginApply[ri];
                    }
                    else
                    {
                        n = target.raycastHits[ri].normal;
                    }

                    scale = 1f / (Vector3.Scale(target.transform.lossyScale, n).magnitude);
                }

                for (int i = 0; i < commonVertexCount; i++)
                {
                    int index = commonVertices[i][0];

                    if (hit.weights[index] < .0001f || (ignoreNonManifoldIndices && nonManifoldIndices.Contains(index)))
                    {
                        continue;
                    }

                    if (direction == z_Direction.VertexNormal)
                    {
                        n     = normalLookup[index];
                        scale = 1f / (Vector3.Scale(target.transform.lossyScale, n).magnitude);
                    }

                    Vector3 pos = vertices[index] + n * (hit.weights[index] * maxMoveDistance * scale);

                    List <int> indices = commonVertices[i];

                    for (int it = 0; it < indices.Count; it++)
                    {
                        vertices[indices[it]] = pos;
                    }
                }
            }

            mesh.vertices = vertices;

            // different than setting weights on temp component,
            // which is what z_BrushModeMesh.OnBrushApply does.
            if (tempComponent != null)
            {
                tempComponent.OnVerticesMoved(mesh);
            }

            base.OnBrushApply(target, settings);
        }
Exemple #50
0
 public override void OnBrushSettingsChanged(z_BrushTarget target, z_BrushSettings settings)
 {
     base.OnBrushSettingsChanged(target, settings);
     RebuildColorTargets(brushColor, settings.strength);
 }
Exemple #51
0
        private void PlaceGameObject(z_RaycastHit hit, GameObject prefab, z_BrushTarget target, z_BrushSettings settings)
        {
            if (prefab == null)
            {
                return;
            }

            Ray ray = RandomRay(hit.position, hit.normal, settings.radius, settings.falloff, settings.falloffCurve);

            z_RaycastHit rand_hit;

            Vector3[] vertices  = target.editableObject.editMesh.vertices;
            int[]     triangles = target.editableObject.editMesh.GetTriangles();

            if (z_SceneUtility.MeshRaycast(ray, vertices, triangles, out rand_hit))
            {
                float pivotOffset = placeWithPivot ? 0f : GetPivotOffset(prefab);

                Quaternion rotation = Quaternion.FromToRotation(Vector3.up, target.transform.TransformDirection(rand_hit.normal));
                Quaternion random   = Quaternion.AngleAxis(Random.Range(0f, 360f), Vector3.up);

                GameObject inst = (GameObject)GameObject.Instantiate(
                    prefab,
                    target.transform.TransformPoint(rand_hit.position),
                    rotation * random);

                inst.name = FormatInstanceName(prefab);

                inst.transform.position = inst.transform.position + inst.transform.up * pivotOffset;

                if (avoidOverlappingGameObjects && TestIntersection(inst))
                {
                    Object.DestroyImmediate(inst);
                    return;
                }

                if (hitSurfaceIsParent)
                {
                    inst.transform.SetParent(target.transform);
                }

                instances.Add(inst);

                Undo.RegisterCreatedObjectUndo(inst, UndoMessage);
            }
        }
		private void RebuildCaches(Mesh m, z_BrushSettings settings)
		{
			vertexCount = m.vertexCount;

			colors_cache = new z_SplatSet(m, meshAttributes);

			colors = new z_SplatSet(vertexCount, meshAttributes);
			target_colors = new z_SplatSet(vertexCount, meshAttributes);
			erase_colors = new z_SplatSet(vertexCount, meshAttributes);

			triangleLookup = z_MeshUtility.GetAdjacentTriangles(m);

			for(int i = 0; i < colors_cache.Length; i++)
			{
				target_colors[i] = z_SplatWeight.Lerp(colors_cache[i], brushColor, settings.strength);
				erase_colors[i] = z_SplatWeight.Lerp(colors_cache[i], z_SplatWeight.Channel0, settings.strength);
			}
		}
		/**
		 *	Returns a dictionary of the indices of all affected vertices and the weight with 
		 *	which modifications should be applied.
		 */
		public static void GetWeightedVerticesWithBrush(z_BrushTarget target, z_BrushSettings settings)
		{
			if( target.editableObject == null)
				return;

			Dictionary<int, float> weights = target.weights;

			if(target.raycastHits.Count < 1)
			{
				for(int i = 0; i < target.mesh.vertexCount; i++)
					weights[i] = 0f;
				return;
			}

			bool uniformScale = z_Math.VectorIsUniform(target.transform.lossyScale);
			float scale = uniformScale ? 1f / target.transform.lossyScale.x : 1f;

			int vertexCount = target.mesh.vertexCount;
			Transform transform = target.transform;
			Vector3[] vertices = target.editableObject.vertices;

			if(!uniformScale)
			{
				Vector3[] world = new Vector3[vertexCount];
				for(int i = 0; i < vertexCount; i++)	
					world[i] = transform.TransformPoint(vertices[i]);
				vertices = world;
			}

			float radius = settings.radius * scale, falloff_mag = Mathf.Max((radius - radius * settings.falloff), 0.00001f);

			Vector3 hitPosition = Vector3.zero;
			z_RaycastHit hit = target.raycastHits[0];

			hitPosition = uniformScale ? hit.position : transform.TransformPoint(hit.position);

			// apply first brush hit, then add values on subsequent hits
			for(int i = 0; i < vertexCount; i++)
			{
				float dist = Vector3.Distance(hitPosition, vertices[i]);
				weights[i] = Mathf.Clamp(settings.falloffCurve.Evaluate(1f - Mathf.Clamp((radius - dist) / falloff_mag, 0f, 1f)), 0f, 1f);
			}

			for(int n = 1; n < target.raycastHits.Count; n++)
			{
				hit = target.raycastHits[n];

				hitPosition = uniformScale ? hit.position : transform.TransformPoint(hit.position);

				for(int i = 0; i < vertexCount; i++)
				{
					float dist = Vector3.Distance(hitPosition, vertices[i]);
					weights[i] += Mathf.Clamp(settings.falloffCurve.Evaluate(1f - Mathf.Clamp((radius - dist) / falloff_mag, 0f, 1f)), 0f, 1f);
				}
			}
		}
Exemple #54
0
        // Called whenever the brush is moved.  Note that @target may have a null editableObject.
        public override void OnBrushMove(z_BrushTarget target, z_BrushSettings settings)
        {
            base.OnBrushMove(target, settings);

            if (!z_Util.IsValid(target) || !likelySupportsTextureBlending)
            {
                return;
            }

            bool shift = Event.current.shift;

            float[] weights;

            if (paintMode == z_PaintMode.Brush)
            {
                weights = target.GetAllWeights();
            }
            else if (paintMode == z_PaintMode.Flood)
            {
                weights = new float[vertexCount];

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

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

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

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

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

                        for (int i = 0; i < 3; i++)
                        {
                            if (triangleLookup.TryGetValue(_fillModeEdges[i], out _fillModeAdjacentTris))
                            {
                                for (int n = 0; n < _fillModeAdjacentTris.Count; n++)
                                {
                                    index = _fillModeAdjacentTris[n] * 3;

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

            if (selectedAttributeIndex < 0 || selectedAttributeIndex >= meshAttributes.Length)
            {
                SetBrushColorWithAttributeIndex(0);
            }

            int mask = meshAttributes[selectedAttributeIndex].mask;

            splat_current.LerpWeights(splat_cache, shift ? splat_erase : splat_target, mask, weights);
            splat_current.Apply(target.editableObject.editMesh);
            target.editableObject.ApplyMeshAttributes();
        }
Exemple #55
0
		void OnBrushBeginApply(z_BrushTarget brushTarget, z_BrushSettings settings)
		{
			z_SceneUtility.PushGIWorkflowMode();
			mode.RegisterUndo(brushTarget);
			undoQueue.Add(brushTarget.gameObject);
			mode.OnBrushBeginApply(brushTarget, brushSettings);
		}
		/// Called when the mouse begins hovering an editable object.
		public override void OnBrushEnter(z_EditableObject target, z_BrushSettings settings)
		{
			base.OnBrushEnter(target, settings);

			if(target.mesh == null)
				return;

			MeshRenderer mr = target.gameObject.GetComponent<MeshRenderer>();

			Material mat = mr == null ? null : mr.sharedMaterials.FirstOrDefault(x => x != null && z_ShaderUtil.SupportsTextureBlending(x.shader));

			likelySupportsTextureBlending = mat != null;

			if(likelySupportsTextureBlending)
			{
				textures = z_ShaderUtil.GetBlendTextures(mat);

				z_MeshChannel[] c = z_ShaderUtil.GetUsedMeshAttributes(mat);
				if(c != null) meshAttributes = c;
			}

			if( textures != null && brushColor.Length != textures.Length )
				brushColor.Resize(textures.Length);

			RebuildCaches(target.mesh, settings);
		}
		public override void OnBrushEnter(z_EditableObject target, z_BrushSettings settings)
		{
			base.OnBrushEnter(target, settings);
			normalLookup = z_MeshUtility.GetSmoothNormalLookup(target.mesh);
		}
Exemple #58
0
        public override void DrawGizmos(z_BrushTarget target, z_BrushSettings settings)
        {
            z_Mesh mesh = target.editableObject.editMesh;

            if (z_Util.IsValid(target) && paintMode == z_PaintMode.Fill)
            {
                Vector3[] vertices = mesh.vertices;
                int[]     indices  = mesh.GetTriangles();

                z_Handles.PushMatrix();
                z_Handles.PushHandleColor();

                Handles.matrix = target.transform.localToWorldMatrix;

                int index = 0;

                foreach (z_RaycastHit 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);

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

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

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

                        for (int i = 0; i < 3; i++)
                        {
                            if (triangleLookup.TryGetValue(_fillModeEdges[i], out _fillModeAdjacentTris))
                            {
                                for (int n = 0; n < _fillModeAdjacentTris.Count; n++)
                                {
                                    index = _fillModeAdjacentTris[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);
                                }
                            }
                        }
                    }
                }

                z_Handles.PopHandleColor();
                z_Handles.PopMatrix();
            }
            else
            {
                base.DrawGizmos(target, settings);
            }
        }
Exemple #59
0
        /**
         *	Calculates the per-vertex weight for each raycast hit and fills in brush target weights.
         */
        public static void CalculateWeightedVertices(z_BrushTarget target, z_BrushSettings settings)
        {
            if (target.editableObject == null)
            {
                return;
            }

            bool  uniformScale = z_Math.VectorIsUniform(target.transform.lossyScale);
            float scale        = uniformScale ? 1f / target.transform.lossyScale.x : 1f;

            z_Mesh mesh = target.editableObject.editMesh;

            List <List <int> > common = z_MeshUtility.GetCommonVertices(mesh);

            Transform transform   = target.transform;
            int       vertexCount = mesh.vertexCount;

            Vector3[] vertices = mesh.vertices;

            if (!uniformScale)
            {
                Vector3[] world = new Vector3[vertexCount];
                for (int i = 0; i < vertexCount; i++)
                {
                    world[i] = transform.TransformPoint(vertices[i]);
                }
                vertices = world;
            }

            AnimationCurve curve = settings.falloffCurve;
            float          radius = settings.radius * scale, falloff_mag = Mathf.Max((radius - radius * settings.falloff), 0.00001f);

            Vector3      hitPosition = Vector3.zero;
            z_RaycastHit hit;

            for (int n = 0; n < target.raycastHits.Count; n++)
            {
                hit = target.raycastHits[n];
                hit.SetVertexCount(vertexCount);

                hitPosition = uniformScale ? hit.position : transform.TransformPoint(hit.position);
                int c = common.Count;

                for (int i = 0; i < c; i++)
                {
                    int     commonArrayCount = common[i].Count;
                    Vector3 a = hitPosition, b = vertices[common[i][0]];
                    float   x = a.x - b.x, y = a.y - b.y, z = a.z - b.z;
                    float   dist = Mathf.Sqrt(x * x + y * y + z * z);

                    if (dist > radius)
                    {
                        for (int j = 0; j < commonArrayCount; j++)
                        {
                            hit.weights[common[i][j]] = 0f;
                        }
                    }
                    else
                    {
                        float weight = Mathf.Clamp(curve.Evaluate(1f - Mathf.Clamp((radius - dist) / falloff_mag, 0f, 1f)), 0f, 1f);

                        for (int j = 0; j < commonArrayCount; j++)
                        {
                            hit.weights[common[i][j]] = weight;
                        }
                    }
                }
            }

            target.GetAllWeights(true);
        }
Exemple #60
0
        public override void OnBrushBeginApply(z_BrushTarget brushTarget, z_BrushSettings brushSettings)
        {
            _pbEditor = z_ReflectionUtil.pbEditor;

            base.OnBrushBeginApply(brushTarget, brushSettings);
        }