public void Select_BrushTool_Should_Be_Draw_Line()
{
ITool brush = new BrushTool();
canvas = new Canvas(brush);
canvas.MouseDown();
canvas.MouseUp();
Assert.Pass();
}
public FrameCanvasEditor()
{
InitializeComponent();
SetMeasures(Zoom);
Image.Source = new WriteableBitmap(256, 192, 96, 96, PixelFormats.Indexed2, DecodedFrame.Palette);
DrawingTool = new BrushTool();
DrawingTool.Attach(this);
ToolBox.Target = this;
}
public BrushCommand(string id, BrushTool tool, List <Vector3> verts, List <int> tris, List <Vector2> uvs, Transform parent, Material mat)
{
_id = id;
_tool = tool;
_verts = verts;
_tris = tris;
_uvs = uvs;
_parent = parent;
_mat = new Material(mat);;
}
/// <summary>
/// Switch between floating window and dockable window
/// </summary>
/// <param name="floating">should reopen the window as floating or not ?</param>
void SetWindowFloating(bool floating)
{
s_FloatingWindow.value = floating;
BrushTool tool = s_Instance.tool;
EditorWindow.GetWindow <PolyEditor>().Close();
MenuItems.MenuInitEditorWindow();
s_Instance.SetTool(tool);
}
public void BrushMaterial(Player player, Pattern pattern)
{
BrushTool brush = player.Inventory.GetItemInHand() as BrushTool;
if (brush == null)
{
return;
}
brush.Pattern = pattern;
player.SendMessage($"Set brush material");
}
/// <summary>
/// Switch Polybrush to the given tool.
/// </summary>
/// <param name="brushTool">Tool to show in Polybrush window.</param>
/// <param name="enableTool">If true, will activate the given tool automatically. Default: true.</param>
internal void SetTool(BrushTool brushTool, bool enableTool = true)
{
if (brushTool == tool && mode != null)
{
return;
}
#if PROBUILDER_4_0_OR_NEWER
if (ProBuilderBridge.ProBuilderExists())
{
ProBuilderBridge.SetSelectMode(ProBuilderBridge.SelectMode.Object);
}
#endif
if (mode != null)
{
// Exiting edit mode
if (m_LastHoveredGameObject != null)
{
OnBrushExit(m_LastHoveredGameObject);
FinalizeAndResetHovering();
}
mode.OnDisable();
}
m_LastHoveredGameObject = null;
System.Type modeType = brushTool.GetModeType();
if (modeType != null)
{
mode = modes.FirstOrDefault(x => x != null && x.GetType() == modeType);
if (mode == null)
{
mode = (BrushMode)ScriptableObject.CreateInstance(modeType);
}
}
// Handle tool auto activation/deactivation.
tool = enableTool? brushTool : BrushTool.None;
if (tool != BrushTool.None)
{
Tools.current = Tool.None;
mode.OnEnable();
}
EnsureBrushSettingsListIsValid();
DoRepaint();
}
public void BrushSize(Player player, int radius = 2)
{
BrushTool brush = player.Inventory.GetItemInHand() as BrushTool;
if (brush == null)
{
return;
}
brush.Radius = radius;
player.SendMessage($"Set brush radius to {radius}");
}
public void BrushRange(Player player, int range = 300)
{
BrushTool brush = player.Inventory.GetItemInHand() as BrushTool;
if (brush == null)
{
return;
}
brush.Range = range;
player.SendMessage($"Set brush range to {range}");
}
public void BrushMelt(Player player, int radius = 2)
{
BrushTool brush = player.Inventory.GetItemInHand() as BrushTool;
string op = "Set";
if (brush == null)
{
brush = new BrushTool();
player.Inventory.SetFirstEmptySlot(brush, true, false);
op = "Added";
}
brush.BrushType = 2; // Melt
brush.Radius = radius;
player.SendMessage($"{op} melt brush with radius={radius}");
}
void DrawToolbar()
{
EditorGUI.BeginChangeCheck();
int toolbarIndex = (int)tool - 1;
using (new GUILayout.HorizontalScope())
{
toolbarIndex = GUILayout.Toolbar(toolbarIndex, m_GCToolmodeIcons, GUILayout.Width(s_Instance.position.width - 6), GUILayout.Height(23));
}
if (EditorGUI.EndChangeCheck())
{
BrushTool newTool = (BrushTool)(toolbarIndex + 1);
SetTool(newTool == tool ? BrushTool.None : (BrushTool)toolbarIndex + 1);
}
}
private void OnButtonClick(string toolName)
{
Tool chosenTool = null;
if (toolName == "arrowBtn")
{
//chosenTool = new PointerTool(toolArgs);
}
if (toolName == "lineBtn")
{
//toolArgs.pictureBox.Cursor = Cursors.Cross;
chosenTool = new ShapeTool(new LineCreator());
}
else if (toolName == "rectangleBtn")
{
//toolArgs.pictureBox.Cursor = Cursors.Cross;
chosenTool = new ShapeTool(new RectangleCreator());
}
else if (toolName == "pencilBtn")
{
//chosenTool = new PencilTool(toolArgs);
}
else if (toolName == "brushBtn")
{
chosenTool = new BrushTool();
}
else if (toolName == "ellipseBtn")
{
//toolArgs.pictureBox.Cursor = Cursors.Cross;
chosenTool = new ShapeTool(new ElipseCreator());
}
else if (toolName == "textBtn")
{
//chosenTool = new TextTool(toolArgs);
}
else if (toolName == "fillBtn")
{
//chosenTool = new FillTool(toolArgs);
}
else if (toolName == "eraserBtn")
{
//chosenTool = new BrushTool(toolArgs, BrushToolType.Eraser);
}
model.DrawingTool = chosenTool;
}
public void BrushFill(Player player, int radius = 2)
{
BrushTool brush = player.Inventory.GetItemInHand() as BrushTool;
string op = "Set";
if (brush == null)
{
brush = new BrushTool();
player.Inventory.AddItem(brush, true);
op = "Added";
}
brush.BrushType = 3; // Fill
brush.Radius = radius;
brush.Mask = new AirBlocksMask(player.Level);
player.SendMessage($"{op} fill brush with radius={radius}");
}
public void BrushMelt(Player player, int radius = 2)
{
BrushTool brush = player.Inventory.GetItemInHand() as BrushTool;
string op = "Set";
if (brush == null)
{
brush = new BrushTool();
player.Inventory.AddItem(brush, true);
op = "Added";
}
brush.BrushType = 2; // Melt
brush.Radius = radius;
brush.UpdateDisplay(player);
player.SendMessage($"{op} melt brush with radius={radius}");
}
public void Apply(int x, int y, int radius)
{
var tile = new Tile {
WallId = 1
};
var template = Mock.Of <ITemplate>(t => t.Apply(It.IsAny <Tile>()) == tile);
var tool = new BrushTool(radius, template);
var extent = Mock.Of <Extent>(e => e.Dimensions == new Vector(10, 10) &&
e.SetTile(It.IsAny <Vector>(), It.IsAny <Tile>()));
tool.Apply(extent, new Vector(x, y));
var region = new EllipticRegion(new Vector(x, y), radius * Vector.One);
foreach (var position in region.Where(extent.IsInBounds))
{
Mock.Get(extent).Verify(e => e.SetTile(position, tile), Times.Once);
}
}
public void BrushSphere(Player player, Pattern pattern, int radius = 2, bool hollow = false)
{
BrushTool brush = player.Inventory.GetItemInHand() as BrushTool;
string op = "Set";
if (brush == null)
{
brush = new BrushTool();
player.Inventory.SetFirstEmptySlot(brush, true, false);
op = "Added";
}
brush.BrushType = 0; // Sphere
brush.Radius = radius;
brush.Pattern = pattern;
brush.Filled = !hollow;
player.SendMessage($"{op} {(!hollow ? "filling" : "hollow")} sphere brush with radius={radius}");
}
public void BrushMask(Player player, Mask mask = null)
{
BrushTool brush = player.Inventory.GetItemInHand() as BrushTool;
if (brush == null)
{
return;
}
if (mask == null)
{
brush.Mask = new AnyBlockMask();
player.SendMessage($"Removed source mask from brush");
return;
}
brush.Mask = mask;
player.SendMessage($"Set new brush source mask");
}
public void BrushSphere(Player player, Pattern material, int radius = 2, bool hollow = false)
{
BrushTool brush = player.Inventory.GetItemInHand() as BrushTool;
string op = "Set";
if (brush == null)
{
brush = new BrushTool();
player.Inventory.AddItem(brush, true);
op = "Added";
}
brush.BrushType = 0; // Sphere
brush.Radius = radius;
brush.Pattern = material;
brush.Filled = !hollow;
brush.Mask = new AirBlocksMask(player.Level);
player.SendMessage($"{op} {(!hollow ? "filling" : "hollow")} sphere brush with radius={radius}");
}
internal void Initialize()
{
LoadTrees();
LoadTreeAuthors();
UITabstrip tabstrip = ToolsModifierControl.mainToolbar.component as UITabstrip;
toggleButtonComponents = CreateToggleButtonComponents(tabstrip);
ForestBrushPanel = toggleButtonComponents.TabStripPage.GetComponent <UIPanel>().AddUIComponent <ForestBrushPanel>();
BrushTool = gameObject.AddComponent <ForestBrushTool>();
BrushTool.UpdateTool(UserMod.Settings.SelectedBrush.Name);
SetTutorialLocale();
toggleButtonComponents.ToggleButton.eventClick += OnToggleClick;
ForestBrushPanel.eventVisibilityChanged += OnForestBrushPanelVisibilityChanged;
LocaleManager.eventLocaleChanged += SetTutorialLocale;
Tool = ToolsModifierControl.toolController.gameObject.AddComponent <ForestTool>();
Initialized = true;
}
/// <summary>
/// Return the Brush Mode type corresponding to a BrushTool enum value
/// </summary>
/// <param name="tool"></param>
/// <returns>The Type of the tool</returns>
internal static System.Type GetModeType(this BrushTool tool)
{
switch (tool)
{
case BrushTool.RaiseLower:
return(typeof(BrushModeRaiseLower));
case BrushTool.Smooth:
return(typeof(BrushModeSmooth));
case BrushTool.Paint:
return(typeof(BrushModePaint));
case BrushTool.Prefab:
return(typeof(BrushModePrefab));
case BrushTool.Texture:
return(typeof(BrushModeTexture));
}
return(null);
}
internal PropertyReference GetBrushPropertyReference(SceneNode sceneNode)
{
return(BrushTool.GetBrushPropertyReference(sceneNode));
}
public void SwitchTool(ToolType toolType)
{
if (toolType != ToolType.Move && ToolWhileMoveTool != null && ToolWhileMoveTool.GetToolType() == toolType)
{
ToolCurrent = ToolWhileMoveTool;
ToolWhileMoveTool = null;
return;
}
ToolWhileMoveTool = null;
if (ToolCurrent != null)
{
ToolCurrent.ResetUsedElements();
}
switch (toolType)
{
case ToolType.Brush:
ToolCurrent = new BrushTool();
break;
case ToolType.Crop:
ToolCurrent = new CropTool();
break;
case ToolType.Cursor:
ToolCurrent = new CursorTool();
break;
case ToolType.Fill:
ToolCurrent = new FillTool();
break;
case ToolType.Ellipse:
ToolCurrent = new EllipseTool();
break;
case ToolType.Eraser:
ToolCurrent = new EraserTool();
break;
case ToolType.ImportPng:
ToolCurrent = new ImportTool();
break;
case ToolType.Flip:
ToolCurrent = new FlipTool();
break;
case ToolType.Line:
ToolCurrent = new LineTool();
break;
case ToolType.Zoom:
ToolCurrent = new MoveZoomTool();
break;
case ToolType.Move:
ToolWhileMoveTool = ToolCurrent;
ToolCurrent = new MoveZoomTool(false);
break;
case ToolType.Pipette:
ToolCurrent = new PipetteTool();
break;
case ToolType.Rotate:
ToolCurrent = new RotateTool();
break;
case ToolType.Rect:
ToolCurrent = new RectangleTool();
break;
case ToolType.Stamp:
ToolCurrent = new StampTool();
break;
default:
break;
}
}
public void ToolChangedHere(ToolBase tool)
{
ImageBrush img_front = new ImageBrush();
ImageBrush img_behind = new ImageBrush();
img_behind.ImageSource = new BitmapImage(
new Uri("ms-resource:/Files/Assets/ToolMenu/icon_menu_move.png", UriKind.Absolute));
Visibility currentStateOfGridThicknessControl = PocketPaintApplication.GetInstance().GrdThicknessControlState;
PocketPaintApplication.GetInstance().PaintingAreaView.GrdThicknessControlVisibility = Visibility.Collapsed;
if (tool.GetToolType() == ToolType.Eraser && PocketPaintApplication.GetInstance().isBrushEraser == true)
{
tool = new BrushTool();
}
else
{
if (PocketPaintApplication.GetInstance().isToolPickerUsed)
{
PocketPaintApplication.GetInstance().isBrushEraser = false;
}
}
switch (tool.GetToolType())
{
case ToolType.Brush:
img_front.ImageSource = new BitmapImage(GetToolImageUri(ToolType.Brush));
PocketPaintApplication.GetInstance().PaintingAreaView.GrdThicknessControlVisibility
= currentStateOfGridThicknessControl;
break;
case ToolType.Crop:
img_front.ImageSource = new BitmapImage(GetToolImageUri(ToolType.Crop));
PocketPaintApplication.GetInstance().PaintingAreaView.GrdThicknessControlVisibility
= currentStateOfGridThicknessControl;
break;
case ToolType.Cursor:
img_front.ImageSource = new BitmapImage(GetToolImageUri(ToolType.Cursor));
break;
case ToolType.Ellipse:
img_front.ImageSource = new BitmapImage(GetToolImageUri(ToolType.Ellipse));
break;
case ToolType.Eraser:
img_front.ImageSource = new BitmapImage(GetToolImageUri(ToolType.Eraser));
break;
case ToolType.Fill:
img_front.ImageSource = new BitmapImage(GetToolImageUri(ToolType.Fill));
PocketPaintApplication.GetInstance().PaintingAreaView.GrdThicknessControlVisibility
= currentStateOfGridThicknessControl;
break;
case ToolType.Flip:
img_front.ImageSource = new BitmapImage(GetToolImageUri(ToolType.Flip));
break;
case ToolType.ImportPng:
img_front.ImageSource = new BitmapImage(GetToolImageUri(ToolType.ImportPng));
PocketPaintApplication.GetInstance().PaintingAreaView.GrdThicknessControlVisibility
= currentStateOfGridThicknessControl;
break;
case ToolType.Line:
img_front.ImageSource = new BitmapImage(GetToolImageUri(ToolType.Line));
PocketPaintApplication.GetInstance().PaintingAreaView.GrdThicknessControlVisibility
= currentStateOfGridThicknessControl;
break;
case ToolType.Move:
img_front.ImageSource = new BitmapImage(GetToolImageUri(ToolType.Move));
img_behind.ImageSource = new BitmapImage(
GetToolImageUri(PocketPaintApplication.GetInstance().ToolWhileMoveTool.GetToolType()));
break;
case ToolType.Pipette:
img_front.ImageSource = new BitmapImage(GetToolImageUri(ToolType.Pipette));
break;
case ToolType.Rect:
img_front.ImageSource = new BitmapImage(GetToolImageUri(ToolType.Rect));
break;
case ToolType.Rotate:
img_front.ImageSource = new BitmapImage(GetToolImageUri(ToolType.Rotate));
break;
case ToolType.Stamp:
img_front.ImageSource = new BitmapImage(GetToolImageUri(ToolType.Stamp));
break;
case ToolType.Zoom:
img_front.ImageSource = new BitmapImage(GetToolImageUri(ToolType.Zoom));
break;
default:
// TODO: BtnMoveScreen.ImageSource = null;
// TODO: BtnMoveScreen.Background = null;
break;
}
ellipseTool_behind.Opacity = 0.1;
ellipseTool_behind.Fill = img_behind;
ellipseTool_front.Fill = img_front;
}
private void TurnOff()
{
var gridLayerController = map.GetLayerController <GridLayerController>();
gridLayerController.OnShowGrid -= OnShowGrid;
// Tools
int index = 0;
var tools = toolsGroup.GetComponentsInChildren <Toggle>();
foreach (var tool in tools)
{
int id = index++;
OnToolChange(false, id);
tool.onValueChanged.RemoveAllListeners();
}
toolsGroup.SetAllTogglesOff();
if (lassoTool != null)
{
Destroy(lassoTool.gameObject);
lassoTool = null;
}
if (brushTool != null)
{
Destroy(brushTool.gameObject);
brushTool = null;
}
// Reset typologyGroup to have first typology toggle to be on
foreach (var toggle in toggles)
{
toggle.isOn = false;
}
toggles[0].isOn = true;
// hide typologies, show tools
OnClickReturn();
// Kill the planner
if (planner != null)
{
planner.ShowAllFlags(true);
Destroy(planner.gameObject);
planner = null;
}
// Destroy the planning layer
if (planningLayer != null)
{
toolLayers.Remove(planningLayer);
Destroy(planningLayer.gameObject);
planningLayer = null;
}
toogleTarget.GetComponentInChildren <Toggle>().onValueChanged.RemoveListener(OnToggleTargetChange);
if (targetPanel != null)
{
Destroy(targetPanel.gameObject);
}
// Additional settings
displayPlanningSummaryToggle.onValueChanged.RemoveListener(OnDisplayPlanningSummary);
displayPlanningSummaryToggle.isOn = true;
//siteBrowser.OnBeforeActiveSiteChange -= OnBeforeActiveSiteChange;
//siteBrowser.OnAfterActiveSiteChange -= OnAfterActiveSiteChange;
}
private void FinishTurnOn(GridLayerController gridLayerController)
{
var mapLayers = gridLayerController.mapLayers;
// For now, just get any grid
var referenceGridData = mapLayers[0].Grid;
HideMessage();
// Create the planning grid
var grid = new GridData
{
countX = referenceGridData.countX,
countY = referenceGridData.countY
};
grid.ChangeBounds(referenceGridData.west, referenceGridData.east, referenceGridData.north, referenceGridData.south);
grid.InitGridValues(false);
// Build the planning categories list
int index = 0;
List <IntCategory> cats = new List <IntCategory>
{
new IntCategory()
{
color = new Color(0, 0, 0, 0.2f), name = "noData", value = index++
},
new IntCategory()
{
color = Color.black, name = "empty", value = index++
}
};
for (int i = 0; i < typologies.Count; ++i)
{
cats.Add(new IntCategory()
{
color = typologies[i].color,
name = typologies[i].name,
value = index++
});
}
grid.categories = cats.ToArray();
// Create planning layer
planningLayer = Instantiate(planningLayerPrefab);
planningLayer.name = planningLayerPrefab.name;
planningLayer.SetCellSize(0.25f);
// Add planning layer to tool layers
toolLayers.Add(planningLayer, grid, "PlanningLayer", Color.white);
var cellGroupGrid = new GridData
{
countX = grid.countX,
countY = grid.countY
};
cellGroupGrid.ChangeBounds(grid.west, grid.east, grid.north, grid.south);
cellGroupGrid.InitGridValues(false);
// Create planner
planner = Instantiate(plannerPrefab);
planner.name = plannerPrefab.name;
planner.Init(typologyLibrary, planningLayer.Grid, typologies);
// set output after initialization
planner.SetOutput(gameObject.activeInHierarchy);
// Select the first typology in the list (only if none selected)
if (!typologyGroup.AnyTogglesOn() && typologies.Count > 0)
{
typologyGroup.transform.GetChild(0).GetComponent <TypologyToggleWithText>().toggle.isOn = true;
}
// Tools
lassoTool = Instantiate(lassoToolPrefab);
lassoTool.name = lassoToolPrefab.name;
lassoTool.Deactivate();
brushTool = Instantiate(brushToolPrefab);
brushTool.name = brushToolPrefab.name;
brushTool.Deactivate();
// Setup tool callbacks
index = 0;
var tools = toolsGroup.GetComponentsInChildren <Toggle>();
foreach (var tool in tools)
{
int id = index++;
tool.onValueChanged.AddListener((isOn) => OnToolChange(isOn, id));
}
typologyGroup.gameObject.SetActive(true);
ToggleSiteSpecificTypologies();
}
/// <summary>
/// Calculates the per-vertex weight for each raycast hit and fills in brush target weights.
/// </summary>
/// <param name="target"></param>
/// <param name="settings"></param>
/// <param name="tool"></param>
/// <param name="bMode"></param>
internal static void CalculateWeightedVertices(BrushTarget target, BrushSettings settings, BrushTool tool = BrushTool.None, BrushMode bMode = null)
{
if (target == null || settings == null)
{
return;
}
if (target.editableObject == null)
{
return;
}
bool uniformScale = Math.VectorIsUniform(target.transform.lossyScale);
float scale = uniformScale ? 1f / target.transform.lossyScale.x : 1f;
PolyMesh mesh = target.editableObject.visualMesh;
Transform transform = target.transform;
int vertexCount = mesh.vertexCount;
Vector3[] vertices = mesh.vertices;
if (!uniformScale)
{
// As we only increase size only when it's needed, always make sure to
// use the vertexCount variable in loop statements and not the buffer length.
if (s_WorldBuffer.Length < vertexCount)
{
System.Array.Resize <Vector3>(ref s_WorldBuffer, vertexCount);
}
for (int i = 0; i < vertexCount; i++)
{
s_WorldBuffer[i] = transform.TransformPoint(vertices[i]);
}
vertices = s_WorldBuffer;
}
AnimationCurve curve = settings.falloffCurve;
float radius = settings.radius * scale, falloff_mag = Mathf.Max((radius - radius * settings.falloff), 0.00001f);
Vector3 hitPosition = Vector3.zero;
PolyRaycastHit hit;
if (tool == BrushTool.Texture && mesh.subMeshCount > 1)
{
var mode = bMode as BrushModeTexture;
int[] submeshIndices = mesh.subMeshes[mode.m_CurrentMeshACIndex].indexes;
for (int n = 0; n < target.raycastHits.Count; n++)
{
hit = target.raycastHits[n];
hit.SetVertexCount(vertexCount);
for (int i = 0; i < vertexCount; i++)
{
hit.weights[i] = 0f;
}
hitPosition = uniformScale ? hit.position : transform.TransformPoint(hit.position);
for (int i = 0; i < submeshIndices.Length; i++)
{
int currentIndex = submeshIndices[i];
float dist = (hitPosition - vertices[currentIndex]).magnitude;
float delta = radius - dist;
if (delta >= 0)
{
float weight = Mathf.Clamp(curve.Evaluate(1f - Mathf.Clamp(delta / falloff_mag, 0f, 1f)), 0f, 1f);
hit.weights[currentIndex] = weight;
}
}
}
}
else
{
int[][] common = PolyMeshUtility.GetCommonVertices(mesh);
Vector3 buf = Vector3.zero;
for (int n = 0; n < target.raycastHits.Count; n++)
{
hit = target.raycastHits[n];
hit.SetVertexCount(vertexCount);
hitPosition = uniformScale ? hit.position : transform.TransformPoint(hit.position);
for (int i = 0; i < common.Length; i++)
{
int[] commonItem = common[i];
int commonArrayCount = commonItem.Length;
Math.Subtract(vertices[commonItem[0]], hitPosition, ref buf);
float sqrDist = buf.sqrMagnitude;
if (sqrDist > radius * radius)
{
for (int j = 0; j < commonArrayCount; j++)
{
hit.weights[commonItem[j]] = 0f;
}
}
else
{
float weight = Mathf.Clamp(curve.Evaluate(1f - Mathf.Clamp((radius - Mathf.Sqrt(sqrDist)) / falloff_mag, 0f, 1f)), 0f, 1f);
for (int j = 0; j < commonArrayCount; j++)
{
hit.weights[commonItem[j]] = weight;
}
}
}
}
}
target.GetAllWeights(true);
}
public static bool IsAdorningFillProperty(SceneElement element)
{
return(new PropertyReference((ReferenceStep)element.ProjectContext.ResolveProperty(ShapeElement.FillProperty)).Equals((object)BrushTool.GetBrushPropertyReference((SceneNode)element)));
}
/// <summary>
/// Calculates the per-vertex weight for each raycast hit and fills in brush target weights.
/// </summary>
/// <param name="target"></param>
/// <param name="settings"></param>
/// <param name="tool"></param>
/// <param name="bMode"></param>
internal static void CalculateWeightedVertices(BrushTarget target, BrushSettings settings, BrushTool tool = BrushTool.None, BrushMode bMode = null)
{
//null checks
if (target == null || settings == null)
{
return;
}
if (target.editableObject == null)
{
return;
}
bool uniformScale = PolyMath.VectorIsUniform(target.transform.lossyScale);
float scale = uniformScale ? 1f / target.transform.lossyScale.x : 1f;
PolyMesh mesh = target.editableObject.visualMesh;
if (tool == BrushTool.Texture && mesh.subMeshCount > 1)
{
var mode = bMode as BrushModeTexture;
int[] submeshIndices = mesh.subMeshes[mode.currentMeshACIndex].indexes;
//List<List<int>> common = PolyMeshUtility.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;
PolyRaycastHit hit;
for (int n = 0; n < target.raycastHits.Count; n++)
{
hit = target.raycastHits[n];
hit.SetVertexCount(vertexCount);
for (int i = 0; i < vertexCount; i++)
{
hit.weights[i] = 0f;
}
hitPosition = uniformScale ? hit.position : transform.TransformPoint(hit.position);
for (int i = 0; i < submeshIndices.Length; i++)
{
int currentIndex = submeshIndices[i];
float dist = (hitPosition - vertices[currentIndex]).magnitude;
float delta = radius - dist;
if (delta >= 0)
{
float weight = Mathf.Clamp(curve.Evaluate(1f - Mathf.Clamp(delta / falloff_mag, 0f, 1f)), 0f, 1f);
hit.weights[currentIndex] = weight;
}
}
}
}
else
{
List <List <int> > common = PolyMeshUtility.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;
PolyRaycastHit 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);
for (int i = 0; i < common.Count; i++)
{
int commonArrayCount = common[i].Count;
float sqrDist = (hitPosition - vertices[common[i][0]]).sqrMagnitude;
if (sqrDist > radius * 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 - Mathf.Sqrt(sqrDist)) / falloff_mag, 0f, 1f)), 0f, 1f);
for (int j = 0; j < commonArrayCount; j++)
{
hit.weights[common[i][j]] = weight;
}
}
}
}
}
target.GetAllWeights(true);
}
