void DrawGridRect(Rect grid, int dp, Color color, float width)
{
using (Handles.DrawingScope d = new Handles.DrawingScope(color))
{
Handles.BeginGUI();
float spacing = grid.width / dp;
Vector3 from = new Vector3(grid.x, grid.yMin);
Vector3 to = new Vector3(grid.x, grid.yMax);
for (int x = 0; x <= dp; x++)
{
Handles.DrawAAPolyLine(width, from, to);
from.x += spacing;
to.x += spacing;
}
from = new Vector3(grid.xMin, grid.y);
to = new Vector3(grid.xMax, grid.y);
for (int y = 0; y <= dp; y++)
{
Handles.DrawAAPolyLine(width, from, to);
from.y += spacing;
to.y += spacing;
}
Handles.EndGUI();
}
}
public static void DrawLine(Vector2 start, Vector2 end, Color c)
{
Handles.BeginGUI();
using (var scope = new Handles.DrawingScope(c))
{
Handles.DrawLine(start, end);
}
Handles.EndGUI();
}
void Draw(LatticeGridComponent lattice)
{
Camera cam = SceneView.lastActiveSceneView.camera;
var verts = lattice.Grid.Vertices;
Vector3 locCam = lattice.transform.InverseTransformPoint(cam.transform.position);
float closeDist = float.MaxValue;
float farDist = 0;
for (int i = 0; i < verts.Length; i++)
{
float dist = Vector3.Distance(verts[i], locCam);
closeDist = Mathf.Min(closeDist, dist);
farDist = Mathf.Max(farDist, dist);
}
using (var scope = new Handles.DrawingScope(lattice.transform.localToWorldMatrix))
{
var handleNormal = cam == null ? Vector3.up : cam.transform.forward;
handleNormal = lattice.transform.InverseTransformDirection(handleNormal);
var grid = lattice.Grid;
for (int i = 0; i < verts.Length; i++)
{
int forward = grid.StepIndex(i, 0, 0, 1);
int right = grid.StepIndex(i, 0, 1, 0);
int up = grid.StepIndex(i, 1, 0, 0);
float alpha = drawOpaque ? 1 : CalcAlpha(verts[i]);
if (forward >= 0)
{
DrawLine(i, forward, verts, alpha);
}
if (right >= 0)
{
DrawLine(i, right, verts, alpha);
}
if (up >= 0)
{
DrawLine(i, up, verts, alpha);
}
DrawPoint(i, verts[i], handleNormal, alpha);
}
needsRepaint = false;
}
float CalcAlpha(Vector3 p)
{
float dist = Vector3.Distance(p, locCam);
var a = 1.0f - ((dist - closeDist) / (farDist - closeDist));
return(a * a * a);
}
}
private static void SceneViewOnDuringSceneGui(SceneView obj)
{
using (var scope = new Handles.DrawingScope())
{
foreach (var drawing in Drawings)
{
drawing.Draw();
}
}
CheckForFrameChange();
}
public virtual void DrawCoord()
{
if (null == parent)
{
return;
}
if (this != UISelectable.Selected)
{
return;
}
using (var g = new Handles.DrawingScope(Color.black))
{
Vector3 leftCenter = WorldRect.GetLeftCenter();
Vector3 rightCenter = WorldRect.GetRightCenter();
Vector3 centerTop = WorldRect.GetCenterTop();
Vector3 centerBottom = WorldRect.GetCenterBottom();
Vector3 left = new Vector3(parent.WorldRect.xMin, WorldRect.center.y);
Vector3 right = new Vector3(parent.WorldRect.xMax, WorldRect.center.y);
Vector3 up = new Vector3(WorldRect.center.x, parent.WorldRect.yMin);
Vector3 bottom = new Vector3(WorldRect.center.x, parent.WorldRect.yMax);
Vector3 leftLineCenter = left + (leftCenter - left) / 2f;
Vector3 rightLineCenter = rightCenter + (right - rightCenter) / 2f;
Vector3 upLineCenter = centerTop + (up - centerTop) / 2f;
Vector3 bottomLineCenter = centerBottom + (bottom - centerBottom) / 2f;
Vector2 labelSize = new Vector2(50, 30);
Handles.DrawDottedLine(left, leftCenter, DOTTED_HORIZONTAL_LINE_WIDTH);
EditorGUI.LabelField(new Rect(leftLineCenter, labelSize), (leftCenter.x - left.x).ToString());
Handles.DrawDottedLine(right, rightCenter, DOTTED_HORIZONTAL_LINE_WIDTH);
EditorGUI.LabelField(new Rect(rightLineCenter, labelSize), (right.x - rightCenter.x).ToString());
Handles.DrawDottedLine(centerTop, up, DOTTED_VERTICAL_LINE_WIDTH);
EditorGUI.LabelField(new Rect(upLineCenter, labelSize), (centerTop.y - up.y).ToString());
Handles.DrawDottedLine(centerBottom, bottom, DOTTED_VERTICAL_LINE_WIDTH);
EditorGUI.LabelField(new Rect(bottomLineCenter, labelSize), (bottom.y - centerBottom.y).ToString());
//Draw Width
EditorGUI.LabelField(new Rect(centerTop, labelSize), localRect.width.ToString());
rightCenter.x -= 50;
EditorGUI.LabelField(new Rect(rightCenter, labelSize), localRect.height.ToString());
}
}
private void Draw(EditableTileVolume volume)
{
Camera cam = SceneView.lastActiveSceneView.camera;
Transform trans = volume.transform;
using (var scope = new Handles.DrawingScope(trans.localToWorldMatrix))
{
var camPos = trans.InverseTransformPoint(cam.transform.position);
var camLook = trans.InverseTransformDirection(cam.transform.forward);
DrawBgGrid(volume, camPos, camLook, Vector3.one);
DrawHitList(hitList, volume);
}
needsRepaint = false;
}
public override void OnToolGUI(EditorWindow window)
{
var evt = Event.current;
DoSceneViewOverlay();
for (int i = 0, c = m_Meshes.Length; i < c; ++i)
{
using var matrix = new Handles.DrawingScope(m_Meshes[i].transform.localToWorldMatrix);
foreach (var info in m_Invalid[i])
{
Handles.DotHandleCap(0, info.position, Quaternion.identity, HandleUtility.GetHandleSize(info.position), evt.type);
Handles.ShowSceneViewLabel(info.position, EditorGUIUtility.TempContent(info.problems));
}
}
}
private void DuringSceneGUI(SceneView sv)
{
if (instance.Water == null || instance.Profile == null)
{
return;
}
Bounds waterBounds = instance.Water.Bounds;
Vector3 size = waterBounds.size + instance.VolumeExtent;
Color color = Handles.yAxisColor;
Matrix4x4 matrix = Matrix4x4.TRS(waterBounds.center + instance.transform.position, instance.transform.rotation, instance.transform.localScale);
using (var scope = new Handles.DrawingScope(color, matrix))
{
Handles.DrawWireCube(Vector3.zero, size);
}
}
public static void DrawOutlineBox(Rect r, Color c)
{
Handles.BeginGUI();
using (var scope = new Handles.DrawingScope(c))
{
Vector2 p1 = new Vector2(r.xMin, r.yMin);
Vector2 p2 = new Vector2(r.xMax, r.yMin);
Vector2 p3 = new Vector2(r.xMax, r.yMax);
Vector2 p4 = new Vector2(r.xMin, r.yMax);
Handles.DrawLines(new Vector3[]
{
p1, p2,
p2, p3,
p3, p4,
p4, p1
});
}
Handles.EndGUI();
}
public override void Draw()
{
base.Draw();
if (selected == owner || resizeStart)
{
using (var h = new Handles.DrawingScope(Color.blue))
{
Handles.DrawAAPolyLine(owner.WorldRect.GetLeftBottom(), owner.WorldRect.GetRightBottom(),
owner.WorldRect.GetRightTop(), owner.WorldRect.GetLeftTop(),
owner.WorldRect.GetLeftBottom());
Handles.DrawSolidRectangleWithOutline(LeftTopPoint, GetPointColor(E_SelectedPoint.LeftTop), Color.black);
Handles.DrawSolidRectangleWithOutline(LeftCenterPoint, GetPointColor(E_SelectedPoint.LeftCenter), Color.black);
Handles.DrawSolidRectangleWithOutline(LeftBottomPoint, GetPointColor(E_SelectedPoint.LeftBottom), Color.black);
Handles.DrawSolidRectangleWithOutline(CenterTopPoint, GetPointColor(E_SelectedPoint.CenterTop), Color.black);
Handles.DrawSolidRectangleWithOutline(CenterBottomPoint, GetPointColor(E_SelectedPoint.CenterBottom), Color.black);
Handles.DrawSolidRectangleWithOutline(RightTopPoint, GetPointColor(E_SelectedPoint.RightTop), Color.black);
Handles.DrawSolidRectangleWithOutline(RightCenterPoint, GetPointColor(E_SelectedPoint.RightCenter), Color.black);
Handles.DrawSolidRectangleWithOutline(RightBottomPoint, GetPointColor(E_SelectedPoint.RightBottom), Color.black);
}
}
}
static void OnSceneGUI(SceneView sceneView)
{
if (Event.current.type != EventType.Repaint)
{
return;
}
var mesh = clip.settings.transferTarget;
if (mesh == null)
{
return;
}
var updateDenoiseIndices = !CompareTextAssetArrays(activeDenoiseIndices, clip.settings.denoiseRegions);
var updateTransplantIndices = !CompareTextAssetArrays(activeTransplantIndices, clip.settings.transplantRegions);
foreach (var deformationRenderer in SkinDeformationRenderer.enabledInstances)
{
if (deformationRenderer.meshAsset != mesh)
{
continue;
}
var target = deformationRenderer.GetComponent <SkinAttachmentTarget>();
if (target == null)
{
continue;
}
var targetMeshInfo = target.GetCachedMeshInfo();
if (targetMeshInfo.valid == false)
{
continue;
}
if (updateDenoiseIndices)
{
updateDenoiseIndices = false;
activeDenoiseIndices = clip.settings.denoiseRegions.Clone() as TextAsset[];
pairedDenoiseIndices = BuildPairsFromIndices(targetMeshInfo.meshAdjacency, SkinDeformationClipEditor.ResolveIndexArrayFromVertexSelectionArray(activeDenoiseIndices));
}
if (updateTransplantIndices)
{
updateTransplantIndices = false;
activeTransplantIndices = clip.settings.transplantRegions.Clone() as TextAsset[];
pairedTransplantIndices = BuildPairsFromIndices(targetMeshInfo.meshAdjacency, SkinDeformationClipEditor.ResolveIndexArrayFromVertexSelectionArray(activeTransplantIndices));
}
var meshMatrix = deformationRenderer.transform.localToWorldMatrix;
var meshBuffers = targetMeshInfo.meshBuffers;
using (var scope = new Handles.DrawingScope(Color.Lerp(Color.clear, Color.magenta, 0.5f), meshMatrix))
{
Handles.DrawLines(meshBuffers.vertexPositions, pairedDenoiseIndices);
}
using (var scope = new Handles.DrawingScope(Color.Lerp(Color.clear, Color.green, 0.5f), meshMatrix))
{
Handles.DrawLines(meshBuffers.vertexPositions, pairedTransplantIndices);
}
}
}
public static void DrawSceneGUIMouseOver(SkinAttachmentTarget driver)
{
var mouseScreen = Event.current.mousePosition;
var mouseWorldRay = HandleUtility.GUIPointToWorldRay(mouseScreen);
var objectRayPos = driver.transform.InverseTransformPoint(mouseWorldRay.origin);
var objectRayDir = driver.transform.InverseTransformDirection(mouseWorldRay.direction);
var meshInfo = driver.GetCachedMeshInfo();
if (meshInfo.valid == false)
{
return;
}
var vertex = meshInfo.meshVertexBSP.RaycastApprox(ref objectRayPos, ref objectRayDir, 10);
if (vertex == -1)
{
return;
}
using (var scope = new Handles.DrawingScope(Color.blue, driver.transform.localToWorldMatrix))
{
const int maxDepth = 3;
var triangleColor = Handles.color;
var triangleDepth = 0;
using (var triangleBFS = new UnsafeBFS(meshInfo.meshAdjacency.triangleCount))
{
foreach (var triangle in meshInfo.meshAdjacency.vertexTriangles[vertex])
{
triangleBFS.Insert(triangle);
}
while (triangleBFS.MoveNext() && triangleBFS.depth < maxDepth)
{
if (triangleDepth < triangleBFS.depth)
{
triangleDepth = triangleBFS.depth;
Handles.color = Color.Lerp(triangleColor, Color.clear, Mathf.InverseLerp(0, maxDepth, triangleDepth));
}
var _e = meshInfo.meshAdjacency.triangleVertices[triangleBFS.position].GetEnumerator();
int v0 = _e.ReadNext();
int v1 = _e.ReadNext();
int v2 = _e.ReadNext();
Handles.DrawLine(meshInfo.meshBuffers.vertexPositions[v0], meshInfo.meshBuffers.vertexPositions[v1]);
Handles.DrawLine(meshInfo.meshBuffers.vertexPositions[v1], meshInfo.meshBuffers.vertexPositions[v2]);
Handles.DrawLine(meshInfo.meshBuffers.vertexPositions[v2], meshInfo.meshBuffers.vertexPositions[v0]);
foreach (var triangle in meshInfo.meshAdjacency.triangleTriangles[triangleBFS.position])
{
triangleBFS.Insert(triangle);
}
}
}
}
}
public override void OnSceneGUI(Terrain terrain, IOnSceneGUI editContext)
{
// don't render mesh previews, etc. if the mesh field has not been populated yet
// or the mouse is not over a Terrain tile
if (m_Mesh == null || !editContext.hitValidTerrain)
{
return;
}
if (!Event.current.shift)
{
m_SceneRaycastHitPoint = editContext.raycastHit.point + new Vector3(0, m_StampHeight, 0);
}
if (m_LastBrushSize != (int)editContext.brushSize)
{
m_LastBrushSize = (int)editContext.brushSize;
CalculateBrushSizeToWorldScale();
}
Vector3 posTerrainSpace = m_SceneRaycastHitPoint - terrain.GetPosition();
PaintContext context = ApplyBrushInternal(terrain, new Vector2(posTerrainSpace.x, posTerrainSpace.z), 1);
Material material = TerrainPaintUtilityEditor.GetDefaultBrushPreviewMaterial();
// restore old render target
RenderTexture.active = context.oldRenderTexture;
material.SetTexture("_HeightmapOrig", context.sourceRenderTexture);
TerrainPaintUtilityEditor.DrawBrushPreview(context, TerrainPaintUtilityEditor.BrushPreview.DestinationRenderTexture,
editContext.brushTexture, brushXformIdentity,
material, 1);
TerrainPaintUtility.ReleaseContextResources(context);
// draw transform Handles for rot, scale, and height translation
if (Event.current.shift)
{
EditorGUI.BeginChangeCheck();
float size = HandleUtility.GetHandleSize(m_SceneRaycastHitPoint);
Vector3 scale = Handles.ScaleHandle(m_StampScale, m_SceneRaycastHitPoint, m_StampRotation, size * 1.5f);
scale.x = Mathf.Max(scale.x, 0.02f);
scale.y = Mathf.Max(scale.y, 0.02f);
scale.z = Mathf.Max(scale.z, 0.02f);
Quaternion rot = Handles.RotationHandle(m_StampRotation, m_SceneRaycastHitPoint);
Handles.DrawingScope drawingScope = new Handles.DrawingScope(Handles.yAxisColor);
float height = (Handles.Slider(m_SceneRaycastHitPoint, Vector3.up, size, Handles.ArrowHandleCap, 0.01f).y - m_SceneRaycastHitPoint.y) * 0.5f;
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(this, "Mesh Stamp Tool - Scaling Mesh");
m_StampScale = scale;
m_StampRotation = rot;
m_SceneRaycastHitPoint.y += height;
m_StampHeight += height;
RepaintInspector();
}
}
}
