public void SetCurrentTool(Transform toolButton)
{
if (activeToolButton)
{
activeToolButton.GetComponent <Image>().material = buttonMaterials[0];
}
activeToolButton = toolButton;
activeToolButton.GetComponent <Image>().material = buttonMaterials[1];
switch (activeToolButton.name)
{
case "Brush":
selectedTool = PaintTools.BRUSH;
break;
case "Eraser":
selectedTool = PaintTools.ERASER;
break;
case "Circle":
selectedTool = PaintTools.CIRCLE;
break;
case "Square":
selectedTool = PaintTools.SQUARE;
break;
default:
Debug.Log(activeToolButton.name + " not implemented yet");
break;
}
}
public void Fill(PaintTools paintTools, List <Vertex> vertices)
{
Dictionary <int, List <ActiveEdge> > edges = _GetEdgesTable(vertices);
int yMin = (int)vertices.Min(v => v.Location.Y);
int yMax = (int)vertices.Max(v => v.Location.Y);
List <ActiveEdge> activeEdges = new List <ActiveEdge>();
for (int y = yMax; y >= yMin; --y)
{
activeEdges.RemoveAll(e => e.YLast == y);
activeEdges.ForEach(e => e.UpdateX());
if (edges.ContainsKey(y))
{
activeEdges.AddRange(edges[y]);
}
activeEdges.Sort((a, b) => a.CurrentX.CompareTo(b.CurrentX));
for (int i = 0; i < activeEdges.Count; i += 2)
{
_DrawSegment(paintTools, y, (int)activeEdges[i].CurrentX, (int)activeEdges[i + 1].CurrentX);
}
}
}
public void DrawVertices(PaintTools paintTools)
{
foreach (Vertex vertex in _vertices)
{
vertex.Draw(paintTools);
}
}
private void _DrawVertices(PaintTools paintTools)
{
foreach (Vertex vertex in _vertices)
{
vertex.Draw(paintTools);
}
}
// Start is called before the first frame update
void Start()
{
Init();
paintTool = PaintTools.Pencil; // <---- Tube is default
ConfigureSubPanels();
ConfigureCursors();
paintLineRenderer = transform.gameObject.GetComponent <LineRenderer>();
if (paintLineRenderer == null)
{
Debug.LogWarning("Expected a line renderer on the paintItem game object.");
}
else
{
paintLineRenderer.startWidth = 0.005f; paintLineRenderer.endWidth = 0.005f;
}
freeDraw = new FreeDraw();
volumeGenerator = new VolumeMeshGenerator();
brushSize = mouthpiece.localScale.x;
OnPaintColor(GlobalState.CurrentColor);
SetTooltips();
GlobalState.colorChangedEvent.AddListener(OnPaintColor);
}
public override void DrawFilling(PaintTools paintTools)
{
if (_filler != null)
{
_filler.Fill(paintTools, _vertexManager.Vertices);
}
}
private void squareButton_Click(object sender, EventArgs e)
{
this.selectedTool = PaintTools.Square;
squareTimer.Enabled = true;
triangleTimer.Enabled = false;
houseTimer.Enabled = false;
}
public void DrawRelations(PaintTools paintTools)
{
for (int i = 0; i < this.NumberOfVertices; ++i)
{
_relations[i].Draw(paintTools, new Segment(_vertices[i].Location,
_vertices[(i + 1) % this.NumberOfVertices].Location));
}
}
private void _DrawSegments(PaintTools paintTools)
{
for (int i = 0; i < this.NumberOfVertices - 1; ++i)
{
paintTools.Graphics.DrawLine(_pen,
_vertices[i].Location,
_vertices[i + 1].Location);
}
}
public void Draw(PaintTools paintTools, Pen pen)
{
for (int i = 0; i < _curvePointsNumber - 1; ++i)
{
paintTools.Graphics.DrawLine(pen,
(Point)this.GetPoint(i),
(Point)this.GetPoint(i + 1));
}
}
private void _DrawSegment(PaintTools paintTools, int y, int begX, int endX)
{
for (int x = begX; x <= endX; ++x)
{
if (paintTools.Bitmap.IsInside(x, y))
{
paintTools.Bitmap.SetPixel(x, y, _GetColor(x, y));
}
}
}
public override void Draw(PaintTools paintTools, Segment side)
{
base.Draw(paintTools, side);
PointD location = _GetLocation(side);
paintTools.Graphics.DrawString(_length.ToString(), _font,
new SolidBrush(_penColor), (float)(location.X - 2 * _distanceFromMiddle - 3),
(float)(location.Y - _distanceFromMiddle));
}
public void UnlockTool(PaintTools tool)
{
switch (tool)
{
case PaintTools.SQUARE:
lockedTools[0].button.enabled = true;
lockedTools[0].lockObj.SetActive(false);
break;
}
}
public override void Draw(PaintTools paintTools, Segment side)
{
base.Draw(paintTools, side);
PointD location = _GetLocation(side);
Segment verticalSegment = new Segment(new PointD(location.X, location.Y - _distanceFromMiddle),
new PointD(location.X, location.Y + _distanceFromMiddle),
_penColor);
verticalSegment.Draw(paintTools);
}
public override void Draw(PaintTools paintTools)
{
PixelSet pixels = _rotator.GetRotated(_currentAngle);
for (int i = 0; i < pixels.Locations.Length; ++i)
{
Point translatedPoint = (Point)(pixels.Locations[i] + _moveVector);
paintTools.Bitmap.SetPixel(translatedPoint.X,
translatedPoint.Y,
pixels.Colors[i]);
}
}
public PdfPCellEntity()
{
BackgroundHexColor = "#f5f5f5";
FontSize = PaintTools.PdfPxToHtmlPx(12);
Colspan = 1;
Rowspan = 1;
BorderWidth = 0.01f;
Padding = 0;
FontStyle = Font.NORMAL;
PaddingTop = 2;
PaddingBottom = 2;
}
public override void Draw(PaintTools paintTools, Segment side)
{
base.Draw(paintTools, side);
PointD location = _GetLocation(side);
Segment horizontalSegment = new Segment(new PointD(location.X - _distanceFromMiddle, location.Y),
new PointD(location.X + _distanceFromMiddle, location.Y),
_penColor);
horizontalSegment.Draw(paintTools);
}
protected void _DrawPolyline(PaintTools paintTools)
{
for (int i = 0; i < this.NumberOfVertices - 1; ++i)
{
Segment side = new Segment(_vertexManager.GetVertex(i).Location,
_vertexManager.GetVertex(i + 1).Location,
_sideColors[i]);
side.Draw(paintTools);
}
_vertexManager.DrawVertices(paintTools);
}
public override void DrawContours(PaintTools paintTools)
{
int numberOfVertices = this.NumberOfVertices;
PointD firstPoint = _vertexManager.GetVertex(0).Location;
PointD lastPoint = _vertexManager.GetVertex(numberOfVertices - 1).Location;
Segment closingSegment = new Segment(lastPoint, firstPoint,
_sideColors[numberOfVertices - 1]);
closingSegment.Draw(paintTools);
_DrawPolyline(paintTools);
_vertexManager.DrawRelations(paintTools);
}
public override void DrawContours(PaintTools paintTools)
{
if (this.NumberOfVertices > 0)
{
if (_isComplete)
{
base.DrawContours(paintTools);
}
else
{
_DrawPolyline(paintTools);
}
}
}
private static GameObject Create(PaintTools what, Color color)
{
GameObject rootObject = new GameObject();
rootObject.transform.parent = SceneManager.RightHanded;
rootObject.transform.localPosition = Vector3.zero;
rootObject.transform.localRotation = Quaternion.identity;
rootObject.transform.localScale = Vector3.one;
GameObject gobject = new GameObject();
gobject.transform.parent = rootObject.transform;
gobject.name = Utils.CreateUniqueName(what == PaintTools.Volume ? "Volume" : "Paint");
gobject.transform.localPosition = Vector3.zero;
gobject.transform.localRotation = Quaternion.identity;
gobject.transform.localScale = Vector3.one;
gobject.tag = "PhysicObject";
Mesh mesh = new Mesh
{
indexFormat = UnityEngine.Rendering.IndexFormat.UInt32
};
MeshFilter meshFilter = gobject.AddComponent <MeshFilter>();
meshFilter.mesh = mesh;
MeshRenderer renderer = gobject.AddComponent <MeshRenderer>();
MaterialID materialId = color.a == 1f ? MaterialID.ObjectOpaque : MaterialID.ObjectTransparent;
Material paintMaterial = ResourceManager.GetMaterial(materialId);
renderer.sharedMaterial = paintMaterial;
renderer.material.SetColor("_BaseColor", color);
renderer.material.SetFloat("_Opacity", color.a);
// Update scene data for live sync
SceneManager.AddMaterialParameters(Utils.GetMaterialName(gobject), materialId, color);
gobject.AddComponent <MeshCollider>();
if (what == PaintTools.Volume)
{
gobject.AddComponent <VolumeController>();
}
else
{
gobject.AddComponent <PaintController>();
}
return(gobject);
}
void OnSelectPanel(PaintTools tool)
{
// If changing tool TO or FROM volume, reset the volume generator.
if (paintTool != tool && (paintTool == PaintTools.Volume || tool == PaintTools.Volume))
{
ResetVolume();
}
paintTool = tool;
// CHECKED button
tubeButton.Checked = tool == PaintTools.Pencil;
ribbonButton.Checked = tool == PaintTools.FlatPencil;
hullButton.Checked = tool == PaintTools.ConvexHull;
volumeButton.Checked = tool == PaintTools.Volume;
grassButton.Checked = tool == PaintTools.Grass;
// ACTIVE panel
tubePanel.gameObject.SetActive(tool == PaintTools.Pencil);
ribbonPanel.gameObject.SetActive(tool == PaintTools.FlatPencil);
hullPanel.gameObject.SetActive(tool == PaintTools.ConvexHull);
volumePanel.gameObject.SetActive(tool == PaintTools.Volume);
grassPanel.gameObject.SetActive(tool == PaintTools.Grass); grassListPanel.gameObject.SetActive(tool == PaintTools.Grass);
// Mouthpiece
pencilCursor.SetActive(tool == PaintTools.Pencil);
flatCursor.SetActive(tool == PaintTools.FlatPencil);
convexCursor.SetActive(tool == PaintTools.ConvexHull);
volumeCursor.SetActive(tool == PaintTools.Volume);
grassCursor.SetActive(tool == PaintTools.Grass);
// SubTool object activation
grassPainter.gameObject.SetActive(tool == PaintTools.Grass); // calls OnEnable
// Sub-Elements (put in its own function?)
switch (tool)
{
case PaintTools.Volume:
{
volumeCreateButton.Checked = true;
volumeEditButton.Checked = false;
// TODO: default values for sliders?
// ...
}
break;
default: break;
}
}
public override void Draw(PaintTools paintTools)
{
BezierCurve bezierCurve = _polyline.GetBezierCurve();
FreeVector tangentVector = bezierCurve.GetTangentVector(_bezierPointNumber);
Point curvePoint = bezierCurve.GetPoint(_bezierPointNumber);
float angle = (new FreeVector(new Point(1, 0))).GetAngleWith(tangentVector);
PixelSet points = _rotator.GetRotated(angle);
FreeVector translateVector = new FreeVector(_imageMiddle, curvePoint);
for (int i = 0; i < points.Locations.Length; ++i)
{
Point translatedPoint = (Point)(points.Locations[i] + translateVector);
paintTools.Bitmap.SetPixel(translatedPoint.X, translatedPoint.Y, points.Colors[i]);
}
}
public static void GenerateCompressImage(string sourceImagePath, string desImagePath, int compressionRate = 100)
{
DirectoryInfo dirInfo = new DirectoryInfo(Path.GetDirectoryName(desImagePath));
if (dirInfo.Exists == false)
{
dirInfo.Create();
}
if (new List <string> {
".PNG", ".GIF"
}.Contains(Path.GetExtension(sourceImagePath).ToUpper()))
{
new FileInfo(sourceImagePath).CopyTo(desImagePath);
}
else
{
using (Bitmap imageFrom = new Bitmap(sourceImagePath))
{
imageFrom.Save(desImagePath, PaintTools.GetEncoderByFormat(GetImageFormat(desImagePath)), PaintTools.GetEncoderParametersByNumber(compressionRate));
}
}
}
private void DoTools()
{
if (Event.current.rawType == EventType.KeyDown && Event.current.isKey && !isDown)
{
tool = curve.tool;
KeyCode key = Event.current.keyCode;
if (key == KeyCode.A)
{
curve.tool = PaintTools.Add;
}
else if (key == KeyCode.D)
{
curve.tool = PaintTools.Remove;
}
else if (key == KeyCode.I)
{
curve.tool = PaintTools.Insert;
}
isDown = true;
EditorUtility.SetDirty(curve);
Event.current.Use();
}
else if (Event.current.rawType == EventType.KeyUp)
{
curve.tool = tool;
isDown = false;
EditorUtility.SetDirty(curve);
Event.current.Use();
}
switch (curve.tool)
{
case PaintTools.Add:
EditorGUIUtility.AddCursorRect(new Rect(0, 0, Screen.width, Screen.height), MouseCursor.ArrowPlus);
SceneView.RepaintAll();
if (Event.current.type == EventType.MouseDown && Event.current.button == 0)
{
GUIUtility.hotControl = 0;
Plane plane = new Plane(Camera.current.transform.forward, Vector3.zero);
float dist = 0f;
Ray ray = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
if (plane.Raycast(ray, out dist))
{
Vector3 newPosition = ray.GetPoint(dist);
curve.AddPointAt(curve.transform.InverseTransformPoint(newPosition));
curve.SendMessage("OnRectTransformDimensionsChange", SendMessageOptions.DontRequireReceiver);
EditorUtility.SetDirty(curve);
}
Event.current.Use();
}
break;
case PaintTools.Insert:
int limit = curve.resolution + 1;
float _res = curve.resolution;
if (curve.count > 1)
{
for (int index = 0; index < curve.count - 1; index++)
{
BezierPoint p1 = curve[index];
BezierPoint p2 = curve[index + 1];
Vector3 lastPoint = p1.localPosition;
Vector3 currentPoint = Vector3.zero;
for (int i = 1; i < limit; i++)
{
currentPoint = BezierCurve.GetPoint(p1, p2, i / _res);
if (HandleUtility.DistanceToLine(curve.transform.TransformPoint(currentPoint), curve.transform.TransformPoint(lastPoint)) < 2f && Vector2.Distance(Event.current.mousePosition, HandleUtility.WorldToGUIPoint(curve.transform.TransformPoint(p1.localPosition))) > 5f && Vector2.Distance(Event.current.mousePosition, HandleUtility.WorldToGUIPoint(curve.transform.TransformPoint(p2.localPosition))) > 5f)
{
EditorGUIUtility.AddCursorRect(new Rect(0, 0, Screen.width, Screen.height), MouseCursor.ArrowPlus);
SceneView.RepaintAll();
if (Event.current.type == EventType.MouseDown)
{
GUIUtility.hotControl = 0;
curve.AddPointAt(index + 1, HandleUtility.ClosestPointToPolyLine(lastPoint, currentPoint));
curve.SendMessage("OnRectTransformDimensionsChange", SendMessageOptions.DontRequireReceiver);
EditorUtility.SetDirty(curve);
Event.current.Use();
}
}
lastPoint = currentPoint;
}
}
}
break;
case PaintTools.Remove:
if (curve.count > 2)
{
for (int index = 0; index < curve.count; index++)
{
BezierPoint p = curve[index];
Vector2 guiPoint = HandleUtility.WorldToGUIPoint(curve.transform.TransformPoint(p.localPosition));
if (Vector2.Distance(Event.current.mousePosition, guiPoint) < 5f)
{
EditorGUIUtility.AddCursorRect(new Rect(0, 0, Screen.width, Screen.height), MouseCursor.ArrowMinus);
SceneView.RepaintAll();
if (Event.current.type == EventType.MouseDown)
{
GUIUtility.hotControl = 0;
curve.RemovePoint(p);
curve.SendMessage("OnRectTransformDimensionsChange", SendMessageOptions.DontRequireReceiver);
EditorUtility.SetDirty(curve);
Event.current.Use();
}
}
}
}
break;
}
}
public void Draw(PaintTools paintTools)
{
paintTools.Graphics.DrawLine(_pen, (PointF)_beg, (PointF)_end);
}
private void rubberSelectLabel_Click(object sender, EventArgs e)
{
this.selectedTool = PaintTools.Rubber;
}
private void lineSelectLabel_Click(object sender, EventArgs e)
{
this.selectedTool = PaintTools.Line;
}
private void ellipsebox_Click(object sender, EventArgs e)
{
this.selectedTool = PaintTools.Ellipse;;
}
private void rectanglebox_Click(object sender, EventArgs e)
{
this.selectedTool = PaintTools.Rectangle;
}
