private void Lock(GameObject gameObject)
{
if (gameObject != null)
{
var newRenderer = gameObject.GetComponent <Renderer>();
if (newRenderer != null)
{
var newMesh = P3D_Helper.GetMesh(gameObject, ref bakedMesh);
if (newMesh != null)
{
if (locked == false)
{
locked = true;
oldTool = Tools.current;
}
lockedGameObject = gameObject;
lockedRenderer = newRenderer;
lockedMesh = newMesh;
locked = true;
}
}
}
}
private void DrawSaveTexture(string errorMessage = null)
{
var showError = string.IsNullOrEmpty(errorMessage) == false;
BeginError(showError);
{
if (showError == true)
{
EditorGUILayout.HelpBox(errorMessage, MessageType.Error);
}
BeginColor(showError == true ? Color.green : GUI.color);
{
if (Button("Save") == true)
{
var path = P3D_Helper.SaveDialog("Save Texture", "Assets", currentTexture.name, "asset");
if (string.IsNullOrEmpty(path) == false)
{
AssetDatabase.CreateAsset(currentTexture, path);
}
}
}
EndColor();
}
EndError();
}
private void DrawOverrideTilingOffset()
{
overrideTilingOffset = EditorGUILayout.Toggle("Override", overrideTilingOffset);
EditorGUI.BeginDisabledGroup(overrideTilingOffset == false);
{
var rect = P3D_Helper.Reserve(48.0f); rect.yMax = rect.yMin + 13.0f;
var left = rect; left.xMax = left.xMin + 24.0f;
var middle = rect; middle.xMin = middle.xMin + 25.0f;
var right = P3D_Helper.SplitHorizontal(ref middle, 1);
EditorGUI.LabelField(new Rect(left.xMin, left.yMin + 16.0f, left.width, left.height + 3.0f), "x", P3D_Helper.SmallLeftText);
EditorGUI.LabelField(new Rect(left.xMin, left.yMin + 32.0f, left.width, left.height + 3.0f), "y", P3D_Helper.SmallLeftText);
EditorGUI.LabelField(new Rect(middle.xMin, middle.yMin, middle.width, middle.height + 3.0f), "Tiling", P3D_Helper.SmallTopText);
EditorGUI.LabelField(new Rect(right.xMin, right.yMin, right.width, right.height + 3.0f), "Offset", P3D_Helper.SmallTopText);
customTiling.x = EditorGUI.FloatField(new Rect(middle.xMin, middle.yMin + 16.0f, middle.width, middle.height), customTiling.x, P3D_Helper.SmallEntryText);
customTiling.y = EditorGUI.FloatField(new Rect(middle.xMin, middle.yMin + 32.0f, middle.width, middle.height), customTiling.y, P3D_Helper.SmallEntryText);
customOffset.x = EditorGUI.FloatField(new Rect(right.xMin, right.yMin + 16.0f, right.width, right.height), customOffset.x, P3D_Helper.SmallEntryText);
customOffset.y = EditorGUI.FloatField(new Rect(right.xMin, right.yMin + 32.0f, right.width, right.height), customOffset.y, P3D_Helper.SmallEntryText);
}
EditorGUI.EndDisabledGroup();
}
public static void ScenePaintBetweenNearest(P3D_Brush brush, Vector3 startPosition, Vector3 endPosition, int layerMask = -1, int groupMask = -1)
{
float num = Vector3.Distance(startPosition, endPosition);
if (num != 0f)
{
P3D_Paintable paintable = null;
P3D_Result result = null;
for (int i = AllPaintables.Count - 1; i >= 0; i--)
{
P3D_Paintable paintable2 = AllPaintables[i];
if (P3D_Helper.IndexInMask(paintable2.gameObject.layer, layerMask))
{
P3D_Tree tree = paintable2.GetTree();
if (tree != null)
{
Transform transform = paintable2.transform;
Vector3 startPoint = transform.InverseTransformPoint(startPosition);
P3D_Result result2 = tree.FindBetweenNearest(startPoint, startPoint + ((transform.InverseTransformPoint(endPosition) - startPoint).normalized * num));
if (result2 != null)
{
paintable = paintable2;
result = result2;
num *= result2.Distance01;
}
}
}
}
if ((paintable != null) && (result != null))
{
paintable.Paint(brush, result, groupMask);
}
}
}
// This finds all triangles between the input positions
public List <P3D_Result> FindBetweenAll(Vector3 startPoint, Vector3 endPoint)
{
ClearResults();
if (IsReady == true)
{
BeginSearchBetween(startPoint, endPoint);
// Go through all potential triangles
for (var i = potentials.Count - 1; i >= 0; i--)
{
var triangle = potentials[i];
var weights = default(Vector3);
var distance01 = default(float);
// See if this triangle is between the start and end points
if (P3D_Helper.IntersectBarycentric(startPoint, endPoint, triangle, out weights, out distance01) == true)
{
AddToResults(triangle, weights, distance01);
}
}
}
return(results);
}
// This finds all triangles perpendicular to the input position
public List <P3D_Result> FindPerpendicularAll(Vector3 point, float maxDistance)
{
ClearResults();
if (IsReady == true && maxDistance > 0.0f)
{
var maxDistanceSqr = maxDistance * maxDistance;
BeginSearchDistance(point, maxDistanceSqr);
// Go through all potential triangles
for (var i = potentials.Count - 1; i >= 0; i--)
{
var triangle = potentials[i];
var weights = default(Vector3);
var distanceSqr = default(float);
// See if a perpendicular triangle point can be found
if (P3D_Helper.ClosestBarycentric(point, triangle, ref weights, ref distanceSqr) == true)
{
if (distanceSqr <= maxDistanceSqr)
{
AddToResults(triangle, weights, Mathf.Sqrt(distanceSqr) / maxDistance);
}
}
}
}
return(results);
}
private void Paint(Vector2 uv)
{
var xy = default(Vector2);
if (painter.CalculatePixelFromCoord(uv, ref xy) == true)
{
var angle = painter.Angle;
var size = painter.Size;
if (scatterPosition != 0.0f)
{
var direction = Random.insideUnitCircle;
xy.x += Mathf.RoundToInt(direction.x * scatterPosition);
xy.y += Mathf.RoundToInt(direction.y * scatterPosition);
}
if (scatterAngle > 0.0f)
{
painter.Angle += Random.Range(-scatterAngle, scatterAngle);
}
if (scatterScale > 0.0f)
{
size *= Random.Range(1.0f - scatterScale, 1.0f);
}
painter.Paint(P3D_Helper.CreateMatrix(xy, size, angle));
}
}
private void DrawCurrentTexture()
{
if (currentTexture != null)
{
var rect1 = P3D_Helper.Reserve(previewSize, true);
var rect2 = rect1;
var aspect = currentTexture.width / (float)currentTexture.height;
var ratio = rect1.width / rect1.height;
GUI.Box(rect1, "", "box");
rect2.xMin += 1;
rect2.yMin += 1;
rect2.xMax -= 1;
rect2.yMax -= 1;
if (ratio > aspect)
{
rect2.width *= aspect / ratio;
}
else
{
rect2.height *= ratio / aspect;
}
rect2.center = rect1.center;
GUI.DrawTexture(rect2, currentTexture, ScaleMode.StretchToFill);
rect1.yMax -= 5.0f;
EditorGUI.DropShadowLabel(rect1, "(" + currentTexture.width + " x " + currentTexture.height + ")");
}
}
private void DrawSaveBrush()
{
EditorGUILayout.Separator();
var rect = P3D_Helper.Reserve(16.0f, true);
var exists = PresetBrushes.Exists(b => b.Name == currentBrush.Name);
if (GUI.Button(rect, exists == true ? "Overwrite Preset" : "Save Preset") == true)
{
var presetBrush = PresetBrushes.Find(b => b.Name == currentBrush.Name);
if (presetBrush == null)
{
presetBrush = new P3D_Brush();
PresetBrushes.Add(presetBrush);
}
presetBrush.Name = currentBrush.Name.Replace("\n", "");
presetBrush.Blend = currentBrush.Blend;
presetBrush.Color = currentBrush.Color;
presetBrush.Direction = currentBrush.Direction;
presetBrush.Shape = currentBrush.Shape;
presetBrush.Size = currentBrush.Size;
presetBrush.Detail = currentBrush.Detail;
presetBrush.DetailScale = currentBrush.DetailScale;
SavePresets();
}
}
private bool NameOob(P3D_Paintable paintable)
{
var renderer = paintable.GetComponent <Renderer>();
if (renderer != null)
{
if (paintable.MaterialIndex >= 0)
{
var materials = renderer.sharedMaterials;
if (paintable.MaterialIndex < materials.Length)
{
var material = materials[paintable.MaterialIndex];
var names = P3D_Helper.GetTexEnvNames(material);
if (names.Contains(paintable.TextureName) == true)
{
return(false);
}
}
}
}
return(true);
}
public override void OnInspectorGUI()
{
P3D_Helper.BaseRect = P3D_Helper.Reserve(0.0f);
P3D_Helper.BaseRectSet = true;
EditorGUI.BeginChangeCheck();
serializedObject.UpdateIfDirtyOrScript();
Target = (T)target;
Targets = targets.Select(t => (T)t).ToArray();
Separator();
OnInspector();
Separator();
serializedObject.ApplyModifiedProperties();
if (EditorGUI.EndChangeCheck() == true)
{
GUI.changed = true; Repaint();
foreach (var t in Targets)
{
P3D_Helper.SetDirty(t);
}
}
P3D_Helper.BaseRectSet = false;
}
private void DrawCreateTexture()
{
BeginError();
{
EditorGUILayout.HelpBox("There is no texture in this texture slot", MessageType.Error);
BeginColor(Color.green);
{
newWidth = EditorGUILayout.IntField("Width", newWidth);
newHeight = EditorGUILayout.IntField("Height", newHeight);
newFormat = (P3D_Format)EditorGUILayout.EnumPopup("Format", newFormat);
newColor = EditorGUILayout.ColorField("Color", newColor);
newMipMaps = EditorGUILayout.Toggle("Mip Maps", newMipMaps);
if (GUI.Button(P3D_Helper.Reserve(), "Create") == true)
{
var format = P3D_Helper.GetTextureFormat(newFormat);
currentTexture = P3D_Helper.CreateTexture(newWidth, newHeight, format, newMipMaps);
currentTexture.name = "New Texture";
Clear(newColor, false);
ClearUndo();
currentMaterial.SetTexture(currentTexEnvName, currentTexture);
P3D_Helper.SetDirty(this);
}
}
EndColor();
}
EndError();
}
public static void Paint()
{
var shapeCoord = default(Vector2);
var detailX = P3D_Helper.Reciprocal(canvasW * detailScale.x);
var detailY = P3D_Helper.Reciprocal(canvasH * detailScale.y);
color.a *= opacity;
for (var x = rect.XMin; x < rect.XMax; x++)
{
for (var y = rect.YMin; y < rect.YMax; y++)
{
if (IsInsideShape(inverse, x, y, ref shapeCoord) == true)
{
var old = canvas.GetPixel(x, y);
var add = color;
if (shape != null)
{
add *= shape.GetPixelBilinear(shapeCoord.x, shapeCoord.y);
}
//if (detail != null) add *= SampleRepeat(detail, detailX * x, detailY * y);
canvas.SetPixel(x, y, Blend(old, add));
}
}
}
}
public static void ScenePaintPerpedicularNearest(P3D_Brush brush, Vector3 position, float maxDistance, int layerMask = -1, int groupMask = -1)
{
P3D_Paintable paintable = null;
P3D_Result result = null;
for (int i = AllPaintables.Count - 1; i >= 0; i--)
{
P3D_Paintable paintable2 = AllPaintables[i];
if (P3D_Helper.IndexInMask(paintable2.gameObject.layer, layerMask))
{
P3D_Tree tree = paintable2.GetTree();
if (tree != null)
{
Transform transform = paintable2.transform;
if (P3D_Helper.GetUniformScale(transform) != 0f)
{
P3D_Result result2 = tree.FindPerpendicularNearest(transform.InverseTransformPoint(position), maxDistance);
if (result2 != null)
{
paintable = paintable2;
result = result2;
maxDistance *= result2.Distance01;
}
}
}
}
}
if (paintable != null)
{
paintable.Paint(brush, result, groupMask);
}
}
private void DrawSaveBrush()
{
EditorGUILayout.Separator();
var rect = P3D_Helper.Reserve(16.0f, true);
var exists = PresetBrushes.Exists(b => b.Name == currentBrush.Name);
if (GUI.Button(rect, exists == true ? "Overwrite Preset" : "Save Preset") == true)
{
var presetBrush = PresetBrushes.Find(b => b.Name == currentBrush.Name);
if (presetBrush == null)
{
presetBrush = new P3D_Brush();
PresetBrushes.Add(presetBrush);
}
currentBrush.Name = currentBrush.Name.Replace("\n", "");
currentBrush.CopyTo(presetBrush);
SavePresets();
}
}
private void DrawAddMaterial()
{
BeginError();
{
EditorGUILayout.HelpBox("This renderer contains no material slots", MessageType.Error);
BeginColor(Color.green);
{
if (Button("Add Material") == true)
{
currentMaterialIndex = 0;
currentMaterial = new Material(Shader.Find("Diffuse"));
materials = new Material[] { currentMaterial };
currentMaterial.name = "New Material";
lockedRenderer.sharedMaterials = materials;
P3D_Helper.SetDirty(this);
}
}
EndColor();
}
EndError();
}
private void DrawDuplicateMaterial(string errorMessage = null)
{
var showError = string.IsNullOrEmpty(errorMessage) == false;
BeginError(showError);
{
if (showError == true)
{
EditorGUILayout.HelpBox(errorMessage, MessageType.Error);
}
BeginColor(showError == true ? Color.green : GUI.color);
{
if (Button("Duplicate") == true)
{
materials[currentMaterialIndex] = currentMaterial = P3D_Helper.Clone(currentMaterial);
lockedRenderer.sharedMaterials = materials;
P3D_Helper.SetDirty(this);
}
}
EndColor();
}
EndError();
}
protected virtual void Update()
{
TargetPitch = Mathf.Clamp(TargetPitch, -89.9f, 89.9f);
// Change the target pitch & yaw values if the required key is pressed
if (Requires == KeyCode.None || Input.GetKey(Requires) == true)
{
TargetPitch -= Input.GetAxisRaw("Mouse Y") * Sensitivity;
TargetYaw += Input.GetAxisRaw("Mouse X") * Sensitivity;
}
// If it's in edit mode there is no Time.deltaTime, so instantly snap to the target rotation
#if UNITY_EDITOR
if (Application.isPlaying == false)
{
currentPitch = TargetPitch;
currentYaw = TargetYaw;
}
#endif
// Move current rotation toward the target position
currentPitch = P3D_Helper.Dampen(currentPitch, TargetPitch, Acceleration, Time.deltaTime);
currentYaw = P3D_Helper.Dampen(currentYaw, TargetYaw, Acceleration, Time.deltaTime);
transform.localRotation = Quaternion.Euler(currentPitch, currentYaw, 0.0f);
}
private void AddLayer(string shaderName)
{
P3D_Helper.AddMaterial(lockedRenderer, Shader.Find(shaderName), currentMaterialIndex + 1);
P3D_Helper.SetDirty(this);
UpdateState();
}
private void DrawDetailAndTiling()
{
EditorGUILayout.Separator();
currentBrush.Detail = (Texture2D)EditorGUI.ObjectField(P3D_Helper.Reserve(), "Detail", currentBrush.Detail, typeof(Texture2D), true);
currentBrush.DetailScale = EditorGUILayout.Vector2Field("Detail Scale", currentBrush.DetailScale);
}
// This will paint the nearest surface between the start and end positions in world space, unless something is blocking it
public static void ScenePaintBetweenNearest(P3D_Brush brush, Vector3 startPosition, Vector3 endPosition, int layerMask = -1, int groupMask = -1)
{
var maxDistance = Vector3.Distance(startPosition, endPosition); if (maxDistance == 0.0f)
{
return;
}
var nearestPaintable = default(P3D_Paintable);
var nearestHit = default(RaycastHit);
var nearestResult = default(P3D_Result);
// Raycast scene to see if we hit a paintable
if (Physics.Raycast(startPosition, endPosition - startPosition, out nearestHit, maxDistance, layerMask) == true)
{
nearestPaintable = nearestHit.collider.GetComponent <P3D_Paintable>();
maxDistance = nearestHit.distance;
}
// See if any paintables are closer (this happens if they have no collider, e.g. skinned meshes)
for (var i = AllPaintables.Count - 1; i >= 0; i--)
{
var paintable = AllPaintables[i];
if (P3D_Helper.IndexInMask(paintable.gameObject.layer, layerMask) == true)
{
var tree = paintable.GetTree();
if (tree != null)
{
var transform = paintable.transform;
var start = transform.InverseTransformPoint(startPosition);
var end = transform.InverseTransformPoint(endPosition);
var direction = (end - start).normalized;
var result = tree.FindBetweenNearest(start, start + direction * maxDistance);
if (result != null)
{
nearestPaintable = paintable;
nearestResult = result;
maxDistance *= result.Distance01;
}
}
}
}
// Paint something?
if (nearestPaintable != null)
{
if (nearestResult != null)
{
nearestPaintable.Paint(brush, nearestResult, groupMask);
}
else
{
nearestPaintable.Paint(brush, nearestHit, groupMask);
}
}
}
private void DrawClear()
{
var rect = P3D_Helper.Reserve(16.0f, true);
if (GUI.Button(rect, "Clear") == true)
{
P3D_ClearWindow.Pop(GetPopupRect(rect), currentTexture);
}
}
private void DrawResize()
{
var rect = P3D_Helper.Reserve(16.0f, true);
if (GUI.Button(rect, "Resize") == true)
{
P3D_ResizeWindow.Pop(GetPopupRect(rect), currentTexture);
}
}
// This causes the current paint operation to get applied to the specified u/v coordinate
public bool Paint(P3D_Brush brush, Vector2 uv)
{
if (Canvas != null)
{
var xy = P3D_Helper.CalculatePixelFromCoord(uv, Tiling, Offset, Canvas.width, Canvas.height);
return(Paint(brush, xy.x, xy.y));
}
return(false);
}
public bool Paint(P3D_Brush brush, Vector2 uv)
{
if (this.Canvas == null)
{
return(false);
}
Vector2 vector = P3D_Helper.CalculatePixelFromCoord(uv, this.Tiling, this.Offset, this.Canvas.width, this.Canvas.height);
return(this.Paint(brush, vector.x, vector.y));
}
public virtual void OnSceneGUI()
{
Target = (T)target;
OnScene();
if (GUI.changed == true)
{
P3D_Helper.SetDirty(target);
}
}
private void ShowBrushPreview(P3D_Result result)
{
var width = currentTexture.width;
var height = currentTexture.height;
var uv = result.GetUV(P3D_CoordType.UV1);
var xy = P3D_Helper.CalculatePixelFromCoord(uv, CurrentTiling, CurrentOffset, width, height);
var matrix = P3D_Helper.CreateMatrix(xy + new Vector2(0.01f, 0.01f), currentBrush.Size * 0.999f, currentBrush.Angle).Inverse;
var resolution = new Vector2(width, height);
P3D_BrushPreview.Show(lockedMesh, currentMaterialIndex, lockedGameObject.transform, previewBrushOpacity, matrix, resolution, currentBrush.Shape, CurrentTiling, CurrentOffset);
}
public bool Paint(P3D_Brush brush, float x, float y)
{
if (brush == null)
{
return(false);
}
Vector2 vector = new Vector2(x, y);
P3D_Matrix matrix = P3D_Helper.CreateMatrix(vector + brush.Offset, brush.Size, brush.Angle);
return(this.Paint(brush, matrix));
}
public static void ScenePaintBetweenAll(P3D_Brush brush, Vector3 startPosition, Vector3 endPosition, int layerMask = -1, int groupMask = -1)
{
for (int i = AllPaintables.Count - 1; i >= 0; i--)
{
P3D_Paintable paintable = AllPaintables[i];
if (P3D_Helper.IndexInMask(paintable.gameObject.layer, layerMask))
{
paintable.PaintBetweenAll(brush, startPosition, endPosition, groupMask);
}
}
}
public static void ScenePaintPerpedicularAll(P3D_Brush brush, Vector3 position, float maxDistance, int layerMask = -1, int groupMask = -1)
{
for (int i = AllPaintables.Count - 1; i >= 0; i--)
{
P3D_Paintable paintable = AllPaintables[i];
if (P3D_Helper.IndexInMask(paintable.gameObject.layer, layerMask))
{
paintable.PaintPerpendicularAll(brush, position, maxDistance, groupMask);
}
}
}
