[OvldGenCallTarget] static void RegularPolygon([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
[OvldDefault(nameof(RegularPolygonRadiusSpace))] ThicknessSpace spaceRadius,
[OvldDefault(nameof(RegularPolygonThicknessSpace))] ThicknessSpace spaceThickness,
Vector3 pos,
[OvldDefault("Quaternion.identity")] Quaternion rot,
[OvldDefault(nameof(RegularPolygonSideCount))] int sideCount,
[OvldDefault(nameof(RegularPolygonRadius))] float radius,
[OvldDefault(nameof(RegularPolygonThickness))] float thickness,
[OvldDefault(nameof(Color))] Color color,
bool hollow,
[OvldDefault("0f")] float roundness,
[OvldDefault("0f")] float angle,
[OvldDefault(nameof(PolygonShapeFill))] ShapeFill fill)
{
using (new IMDrawer(mpbRegularPolygon, ShapesMaterialUtils.matRegularPolygon[blendMode], ShapesMeshUtils.QuadMesh[0], pos, rot)) {
MetaMpb.ApplyColorOrFill(mpbRegularPolygon, fill, color);
mpbRegularPolygon.radius.Add(radius);
mpbRegularPolygon.radiusSpace.Add((int)spaceRadius);
mpbRegularPolygon.geometry.Add((int)Draw.RegularPolygonGeometry);
mpbRegularPolygon.sides.Add(Mathf.Max(3, sideCount));
mpbRegularPolygon.angle.Add(angle);
mpbRegularPolygon.roundness.Add(roundness);
mpbRegularPolygon.hollow.Add(hollow.AsInt());
mpbRegularPolygon.thicknessSpace.Add((int)spaceThickness);
mpbRegularPolygon.thickness.Add(thickness);
mpbRegularPolygon.scaleMode.Add((int)ScaleMode);
}
}
[OvldGenCallTarget] public static void Line([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
[OvldDefault(nameof(LineGeometry))] LineGeometry geometry,
[OvldDefault(nameof(LineEndCaps))] LineEndCap endCaps,
[OvldDefault(nameof(LineThicknessSpace))] ThicknessSpace thicknessSpace,
Vector3 start,
Vector3 end,
[OvldDefault(nameof(Color))] Color colorStart,
[OvldDefault(nameof(Color))] Color colorEnd,
[OvldDefault(nameof(LineThickness))] float thickness,
[OvldDefault(nameof(LineDashStyle))] DashStyle dashStyle = null)
{
Material mat = ShapesMaterialUtils.GetLineMat(geometry, endCaps)[blendMode];
ApplyGlobalProperties(mat);
mat.SetColor(ShapesMaterialUtils.propColor, colorStart);
mat.SetColor(ShapesMaterialUtils.propColorEnd, colorEnd);
mat.SetVector(ShapesMaterialUtils.propPointStart, start);
mat.SetVector(ShapesMaterialUtils.propPointEnd, end);
mat.SetFloat(ShapesMaterialUtils.propThickness, thickness);
mat.SetInt(ShapesMaterialUtils.propAlignment, (int)geometry);
mat.SetInt(ShapesMaterialUtils.propThicknessSpace, (int)thicknessSpace);
mat.SetInt(ShapesMaterialUtils.propScaleMode, (int)ScaleMode);
ApplyDashSettings(mat, dashStyle, thickness, useType: geometry != LineGeometry.Volumetric3D);
DrawMesh(Vector3.zero, Quaternion.identity, ShapesMeshUtils.GetLineMesh(geometry, endCaps), mat);
}
[OvldGenCallTarget] static void Torus_Internal(float radius,
float thickness,
[OvldDefault(nameof(Color))] Color color)
{
if (thickness < 0.0001f)
{
return;
}
if (radius < 0.00001f)
{
ThicknessSpace cached = Draw.RadiusSpace;
Draw.RadiusSpace = Draw.ThicknessSpace;
Sphere(thickness / 2, color);
Draw.RadiusSpace = cached;
return;
}
using (new IMDrawer(mpbTorus, ShapesMaterialUtils.matTorus[Draw.BlendMode], ShapesMeshUtils.TorusMesh[(int)DetailLevel])) {
mpbTorus.color.Add(color.ColorSpaceAdjusted());
mpbTorus.radius.Add(radius);
mpbTorus.thickness.Add(thickness);
mpbTorus.radiusSpace.Add((int)Draw.RadiusSpace);
mpbTorus.thicknessSpace.Add((int)Draw.ThicknessSpace);
mpbTorus.scaleMode.Add((int)Draw.ScaleMode);
}
}
[OvldGenCallTarget] public static void Torus([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
[OvldDefault(nameof(TorusRadiusSpace))] ThicknessSpace spaceRadius,
[OvldDefault(nameof(TorusThicknessSpace))] ThicknessSpace spaceThickness,
Vector3 pos,
[OvldDefault("Quaternion.identity")] Quaternion rot,
float radius,
float thickness,
[OvldDefault(nameof(Color))] Color color)
{
if (thickness < 0.0001f)
{
return;
}
if (radius < 0.00001f)
{
Sphere(blendMode, spaceThickness, pos, thickness, color);
return;
}
Material mat = ShapesMaterialUtils.matTorus[blendMode];
ApplyGlobalProperties(mat);
mat.SetColor(ShapesMaterialUtils.propColor, color);
mat.SetFloat(ShapesMaterialUtils.propRadius, radius);
mat.SetFloat(ShapesMaterialUtils.propThickness, thickness);
mat.SetInt(ShapesMaterialUtils.propRadiusSpace, (int)spaceRadius);
mat.SetInt(ShapesMaterialUtils.propThicknessSpace, (int)spaceThickness);
mat.SetInt(ShapesMaterialUtils.propScaleMode, (int)ScaleMode);
DrawMesh(pos, rot, ShapesMeshUtils.TorusMesh, mat);
}
[OvldGenCallTarget] static void Torus([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
[OvldDefault(nameof(TorusRadiusSpace))] ThicknessSpace spaceRadius,
[OvldDefault(nameof(TorusThicknessSpace))] ThicknessSpace spaceThickness,
Vector3 pos,
[OvldDefault("Quaternion.identity")] Quaternion rot,
float radius,
float thickness,
[OvldDefault(nameof(Color))] Color color)
{
if (thickness < 0.0001f)
{
return;
}
if (radius < 0.00001f)
{
Sphere(blendMode, spaceThickness, pos, thickness, color); // todo: thickness/2 ?
return;
}
using (new IMDrawer(mpbTorus, ShapesMaterialUtils.matTorus[blendMode], ShapesMeshUtils.TorusMesh[(int)DetailLevel], pos, rot)) {
mpbTorus.color.Add(color);
mpbTorus.radius.Add(radius);
mpbTorus.thickness.Add(thickness);
mpbTorus.spaceRadius.Add((int)spaceRadius);
mpbTorus.spaceThickness.Add((int)spaceThickness);
mpbTorus.scaleMode.Add((int)ScaleMode);
}
}
[OvldGenCallTarget] static void Line([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
[OvldDefault(nameof(LineGeometry))] LineGeometry geometry,
[OvldDefault(nameof(LineEndCaps))] LineEndCap endCaps,
[OvldDefault(nameof(LineThicknessSpace))] ThicknessSpace thicknessSpace,
Vector3 start,
Vector3 end,
[OvldDefault(nameof(Color))] Color colorStart,
[OvldDefault(nameof(Color))] Color colorEnd,
[OvldDefault(nameof(LineThickness))] float thickness,
[OvldDefault(nameof(LineDashStyle))] DashStyle dashStyle = null)
{
using (new IMDrawer(
metaMpb: mpbLine,
sourceMat: ShapesMaterialUtils.GetLineMat(geometry, endCaps)[blendMode],
sourceMesh: ShapesMeshUtils.GetLineMesh(geometry, endCaps, DetailLevel))) {
MetaMpb.ApplyDashSettings(mpbLine, dashStyle, thickness);
mpbLine.color.Add(colorStart);
mpbLine.colorEnd.Add(colorEnd);
mpbLine.pointStart.Add(start);
mpbLine.pointEnd.Add(end);
mpbLine.thickness.Add(thickness);
mpbLine.alignment.Add((float)geometry);
mpbLine.thicknessSpace.Add((float)thicknessSpace);
mpbLine.scaleMode.Add((float)ScaleMode);
}
}
[OvldGenCallTarget] static void Sphere([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
[OvldDefault(nameof(SphereRadiusSpace))] ThicknessSpace spaceRadius,
Vector3 pos,
[OvldDefault(nameof(SphereRadius))] float radius,
[OvldDefault(nameof(Color))] Color color)
{
using (new IMDrawer(metaMpbSphere, ShapesMaterialUtils.matSphere[blendMode], ShapesMeshUtils.SphereMesh[(int)DetailLevel], pos, Quaternion.identity)) {
metaMpbSphere.color.Add(color);
metaMpbSphere.radius.Add(radius);
metaMpbSphere.radiusSpace.Add((float)spaceRadius);
}
}
[OvldGenCallTarget] public static void Sphere([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
[OvldDefault(nameof(SphereRadiusSpace))] ThicknessSpace spaceRadius,
Vector3 pos,
[OvldDefault(nameof(SphereRadius))] float radius,
[OvldDefault(nameof(Color))] Color color)
{
Material mat = ShapesMaterialUtils.matSphere[blendMode];
mat.SetColor(ShapesMaterialUtils.propColor, color);
mat.SetFloat(ShapesMaterialUtils.propRadius, radius);
mat.SetInt(ShapesMaterialUtils.propRadiusSpace, (int)spaceRadius);
DrawMesh(pos, Quaternion.identity, ShapesMeshUtils.SphereMesh, mat);
}
[OvldGenCallTarget] static void Cuboid([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
[OvldDefault(nameof(CuboidSizeSpace))] ThicknessSpace sizeSpace,
Vector3 pos,
[OvldDefault("Quaternion.identity")] Quaternion rot,
Vector3 size,
[OvldDefault(nameof(Color))] Color color)
{
using (new IMDrawer(mpbCuboid, ShapesMaterialUtils.matCuboid[blendMode], ShapesMeshUtils.CuboidMesh[0], pos, rot)) {
mpbCuboid.color.Add(color);
mpbCuboid.size.Add(size);
mpbCuboid.sizeSpace.Add((float)sizeSpace);
}
}
[OvldGenCallTarget] public static void Cuboid([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
[OvldDefault(nameof(CuboidSizeSpace))] ThicknessSpace sizeSpace,
Vector3 pos,
[OvldDefault("Quaternion.identity")] Quaternion rot,
Vector3 size,
[OvldDefault(nameof(Color))] Color color)
{
Material mat = ShapesMaterialUtils.matCuboid[blendMode];
mat.SetColor(ShapesMaterialUtils.propColor, color);
mat.SetVector(ShapesMaterialUtils.propSize, size);
mat.SetInt(ShapesMaterialUtils.propSizeSpace, (int)sizeSpace);
DrawMesh(pos, rot, ShapesMeshUtils.CuboidMesh, mat);
}
static void DiscCore(ShapesBlendMode blendMode, ThicknessSpace spaceRadius, ThicknessSpace spaceThickness, bool hollow, bool sector, Vector3 pos, Quaternion rot, float radius, float thickness, Color colorInnerStart, Color colorOuterStart, Color colorInnerEnd, Color colorOuterEnd, DashStyle dashStyle = null, float angleRadStart = 0f, float angleRadEnd = 0f, ArcEndCap arcEndCaps = ArcEndCap.None)
{
if (sector && Mathf.Abs(angleRadEnd - angleRadStart) < 0.0001f)
{
return;
}
Material mat = ShapesMaterialUtils.GetDiscMaterial(hollow, sector)[blendMode];
ApplyGlobalProperties(mat);
mat.SetFloat(ShapesMaterialUtils.propRadius, radius);
mat.SetInt(ShapesMaterialUtils.propRadiusSpace, (int)spaceRadius);
mat.SetInt(ShapesMaterialUtils.propAlignment, (int)Draw.DiscGeometry);
if (hollow)
{
mat.SetInt(ShapesMaterialUtils.propThicknessSpace, (int)spaceThickness);
mat.SetFloat(ShapesMaterialUtils.propThickness, thickness);
mat.SetInt(ShapesMaterialUtils.propScaleMode, (int)ScaleMode);
}
if (sector)
{
mat.SetFloat(ShapesMaterialUtils.propAngStart, angleRadStart);
mat.SetFloat(ShapesMaterialUtils.propAngEnd, angleRadEnd);
if (hollow)
{
mat.SetFloat(ShapesMaterialUtils.propRoundCaps, (int)arcEndCaps);
}
}
mat.SetColor(ShapesMaterialUtils.propColor, colorInnerStart);
mat.SetColor(ShapesMaterialUtils.propColorOuterStart, colorOuterStart);
mat.SetColor(ShapesMaterialUtils.propColorInnerEnd, colorInnerEnd);
mat.SetColor(ShapesMaterialUtils.propColorOuterEnd, colorOuterEnd);
bool dashed = dashStyle?.size > 0f;
mat.SetFloat(ShapesMaterialUtils.propDashSize, dashed ? dashStyle.GetNetAbsoluteSize(true, thickness) : 0);
if (dashed)
{
mat.SetInt(ShapesMaterialUtils.propDashType, (int)dashStyle.type);
mat.SetInt(ShapesMaterialUtils.propDashSpace, (int)dashStyle.space);
mat.SetInt(ShapesMaterialUtils.propDashSnap, (int)dashStyle.snap);
mat.SetFloat(ShapesMaterialUtils.propDashOffset, dashStyle.offset);
mat.SetFloat(ShapesMaterialUtils.propDashSpacing, dashStyle.GetNetAbsoluteSpacing(true, thickness));
}
DrawMesh(pos, rot, ShapesMeshUtils.QuadMesh, mat);
}
[OvldGenCallTarget] public static void Polyline([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
PolylinePath path,
[OvldDefault("false")] bool closed,
[OvldDefault(nameof(PolylineGeometry))] PolylineGeometry geometry,
[OvldDefault(nameof(PolylineJoins))] PolylineJoins joins,
[OvldDefault(nameof(LineThickness))] float thickness,
[OvldDefault(nameof(LineThicknessSpace))] ThicknessSpace thicknessSpace,
[OvldDefault(nameof(Color))] Color color)
{
if (path.EnsureMeshIsReadyToRender(closed, joins, out Mesh mesh) == false)
{
return; // no points defined in the mesh
}
switch (path.Count)
{
case 0:
Debug.LogWarning("Tried to draw polyline with no points");
return;
case 1:
Debug.LogWarning("Tried to draw polyline with only one point");
return;
}
Material matPolyLine = ShapesMaterialUtils.GetPolylineMat(joins)[blendMode];
ApplyGlobalProperties(matPolyLine);
matPolyLine.SetFloat(ShapesMaterialUtils.propThickness, thickness);
matPolyLine.SetFloat(ShapesMaterialUtils.propThicknessSpace, (int)thicknessSpace);
matPolyLine.SetColor(ShapesMaterialUtils.propColor, color);
matPolyLine.SetInt(ShapesMaterialUtils.propAlignment, (int)geometry);
matPolyLine.SetInt(ShapesMaterialUtils.propScaleMode, (int)ScaleMode);
if (joins == PolylineJoins.Miter)
{
DrawMesh(Vector3.zero, Quaternion.identity, mesh, matPolyLine);
}
else
{
Material matPolyLineJoins = ShapesMaterialUtils.GetPolylineJoinsMat(joins)[blendMode];
ApplyGlobalProperties(matPolyLineJoins);
matPolyLineJoins.SetFloat(ShapesMaterialUtils.propThickness, thickness);
matPolyLineJoins.SetFloat(ShapesMaterialUtils.propThicknessSpace, (int)thicknessSpace);
matPolyLineJoins.SetColor(ShapesMaterialUtils.propColor, color);
matPolyLineJoins.SetInt(ShapesMaterialUtils.propAlignment, (int)geometry);
matPolyLineJoins.SetInt(ShapesMaterialUtils.propScaleMode, (int)ScaleMode);
DrawTwoSubmeshes(Vector3.zero, Quaternion.identity, mesh, matPolyLine, matPolyLineJoins);
}
}
[OvldGenCallTarget] public static void Cone([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
[OvldDefault(nameof(ConeSizeSpace))] ThicknessSpace sizeSpace,
Vector3 pos,
[OvldDefault("Quaternion.identity")] Quaternion rot,
float radius,
float length,
[OvldDefault("true")] bool fillCap,
[OvldDefault(nameof(Color))] Color color)
{
Material mat = ShapesMaterialUtils.matCone[blendMode];
mat.SetColor(ShapesMaterialUtils.propColor, color);
mat.SetFloat(ShapesMaterialUtils.propRadius, radius);
mat.SetFloat(ShapesMaterialUtils.propLength, length);
mat.SetInt(ShapesMaterialUtils.propSizeSpace, (int)sizeSpace);
DrawMesh(pos, rot, fillCap ? ShapesMeshUtils.ConeMesh : ShapesMeshUtils.ConeMeshUncapped, mat);
}
[OvldGenCallTarget] static void Polyline_Internal(PolylinePath path,
[OvldDefault("false")] bool closed,
[OvldDefault(nameof(PolylineGeometry))] PolylineGeometry geometry,
[OvldDefault(nameof(PolylineJoins))] PolylineJoins joins,
[OvldDefault(nameof(Thickness))] float thickness,
[OvldDefault(nameof(ThicknessSpace))] ThicknessSpace thicknessSpace,
[OvldDefault(nameof(Color))] Color color)
{
if (path.EnsureMeshIsReadyToRender(closed, joins, out Mesh mesh) == false)
{
return; // no points defined in the mesh
}
switch (path.Count)
{
case 0:
Debug.LogWarning("Tried to draw polyline with no points");
return;
case 1:
Debug.LogWarning("Tried to draw polyline with only one point");
return;
}
void ApplyToMpb(MpbPolyline2D mpb)
{
mpb.thickness.Add(thickness);
mpb.thicknessSpace.Add((int)thicknessSpace);
mpb.color.Add(color.ColorSpaceAdjusted());
mpb.alignment.Add((int)geometry);
mpb.scaleMode.Add((int)ScaleMode);
}
if (DrawCommand.IsAddingDrawCommandsToBuffer) // mark as used by this command to prevent destroy in dispose
{
path.RegisterToCommandBuffer(DrawCommand.CurrentWritingCommandBuffer);
}
using (new IMDrawer(mpbPolyline, ShapesMaterialUtils.GetPolylineMat(joins)[Draw.BlendMode], mesh, 0))
ApplyToMpb(mpbPolyline);
if (joins.HasJoinMesh())
{
using (new IMDrawer(mpbPolylineJoins, ShapesMaterialUtils.GetPolylineJoinsMat(joins)[Draw.BlendMode], mesh, 1))
ApplyToMpb(mpbPolylineJoins);
}
}
[OvldGenCallTarget] static void Cone([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
[OvldDefault(nameof(ConeSizeSpace))] ThicknessSpace sizeSpace,
Vector3 pos,
[OvldDefault("Quaternion.identity")] Quaternion rot,
float radius,
float length,
[OvldDefault("true")] bool fillCap,
[OvldDefault(nameof(Color))] Color color)
{
Mesh mesh = fillCap ? ShapesMeshUtils.ConeMesh[(int)DetailLevel] : ShapesMeshUtils.ConeMeshUncapped[(int)DetailLevel];
using (new IMDrawer(mpbCone, ShapesMaterialUtils.matCone[blendMode], mesh, pos, rot)) {
mpbCone.color.Add(color);
mpbCone.radius.Add(radius);
mpbCone.length.Add(length);
mpbCone.sizeSpace.Add((float)sizeSpace);
}
}
[OvldGenCallTarget] static void Polyline([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
PolylinePath path,
[OvldDefault("false")] bool closed,
[OvldDefault(nameof(PolylineGeometry))] PolylineGeometry geometry,
[OvldDefault(nameof(PolylineJoins))] PolylineJoins joins,
[OvldDefault(nameof(LineThickness))] float thickness,
[OvldDefault(nameof(LineThicknessSpace))] ThicknessSpace thicknessSpace,
[OvldDefault(nameof(Color))] Color color)
{
if (path.EnsureMeshIsReadyToRender(closed, joins, out Mesh mesh) == false)
{
return; // no points defined in the mesh
}
switch (path.Count)
{
case 0:
Debug.LogWarning("Tried to draw polyline with no points");
return;
case 1:
Debug.LogWarning("Tried to draw polyline with only one point");
return;
}
void ApplyToMpb(MpbPolyline mpb)
{
mpb.thickness.Add(thickness);
mpb.thicknessSpace.Add((int)thicknessSpace);
mpb.color.Add(color);
mpb.alignment.Add((int)geometry);
mpb.scaleMode.Add((int)ScaleMode);
}
using (new IMDrawer(mpbPolyline, ShapesMaterialUtils.GetPolylineMat(joins)[blendMode], mesh, 0))
ApplyToMpb(mpbPolyline);
if (joins.HasJoinMesh())
{
using (new IMDrawer(mpbPolylineJoins, ShapesMaterialUtils.GetPolylineJoinsMat(joins)[blendMode], mesh, 1))
ApplyToMpb(mpbPolylineJoins);
}
}
[OvldGenCallTarget] public static void Line([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
[OvldDefault(nameof(LineGeometry))] LineGeometry geometry,
[OvldDefault(nameof(LineEndCaps))] LineEndCap endCaps,
[OvldDefault(nameof(LineThicknessSpace))] ThicknessSpace thicknessSpace,
Vector3 start,
Vector3 end,
[OvldDefault(nameof(Color))] Color colorStart,
[OvldDefault(nameof(Color))] Color colorEnd,
[OvldDefault(nameof(LineThickness))] float thickness,
[OvldDefault(nameof(LineDashStyle))] DashStyle dashStyle = null)
{
Material mat = ShapesMaterialUtils.GetLineMat(geometry, endCaps)[blendMode];
ApplyGlobalProperties(mat);
mat.SetColor(ShapesMaterialUtils.propColor, colorStart);
mat.SetColor(ShapesMaterialUtils.propColorEnd, colorEnd);
mat.SetVector(ShapesMaterialUtils.propPointStart, start);
mat.SetVector(ShapesMaterialUtils.propPointEnd, end);
mat.SetFloat(ShapesMaterialUtils.propThickness, thickness);
mat.SetInt(ShapesMaterialUtils.propAlignment, (int)geometry);
mat.SetInt(ShapesMaterialUtils.propThicknessSpace, (int)thicknessSpace);
mat.SetInt(ShapesMaterialUtils.propScaleMode, (int)ScaleMode);
bool dashed = dashStyle?.size > 0f;
mat.SetFloat(ShapesMaterialUtils.propDashSize, dashed ? dashStyle.GetNetAbsoluteSize(true, thickness) : 0);
if (dashed)
{
if (geometry != LineGeometry.Volumetric3D)
{
mat.SetInt(ShapesMaterialUtils.propDashType, (int)dashStyle.type);
}
mat.SetInt(ShapesMaterialUtils.propDashSpace, (int)dashStyle.space);
mat.SetInt(ShapesMaterialUtils.propDashSnap, (int)dashStyle.snap);
mat.SetFloat(ShapesMaterialUtils.propDashOffset, dashStyle.offset);
mat.SetFloat(ShapesMaterialUtils.propDashSpacing, dashStyle.GetNetAbsoluteSpacing(true, thickness));
}
DrawMesh(Vector3.zero, Quaternion.identity, ShapesMeshUtils.GetLineMesh(geometry, endCaps), mat);
}
static void DiscCore(ShapesBlendMode blendMode, ThicknessSpace spaceRadius, ThicknessSpace spaceThickness, bool hollow, bool sector, Vector3 pos, Quaternion rot, float radius, float thickness, Color colorInnerStart, Color colorOuterStart, Color colorInnerEnd, Color colorOuterEnd, DashStyle dashStyle = null, float angleRadStart = 0f, float angleRadEnd = 0f, ArcEndCap arcEndCaps = ArcEndCap.None)
{
if (sector && Mathf.Abs(angleRadEnd - angleRadStart) < 0.0001f)
{
return;
}
Material mat = ShapesMaterialUtils.GetDiscMaterial(hollow, sector)[blendMode];
ApplyGlobalProperties(mat);
mat.SetFloat(ShapesMaterialUtils.propRadius, radius);
mat.SetInt(ShapesMaterialUtils.propRadiusSpace, (int)spaceRadius);
mat.SetInt(ShapesMaterialUtils.propAlignment, (int)Draw.DiscGeometry);
if (hollow)
{
mat.SetInt(ShapesMaterialUtils.propThicknessSpace, (int)spaceThickness);
mat.SetFloat(ShapesMaterialUtils.propThickness, thickness);
mat.SetInt(ShapesMaterialUtils.propScaleMode, (int)ScaleMode);
}
if (sector)
{
mat.SetFloat(ShapesMaterialUtils.propAngStart, angleRadStart);
mat.SetFloat(ShapesMaterialUtils.propAngEnd, angleRadEnd);
if (hollow)
{
mat.SetFloat(ShapesMaterialUtils.propRoundCaps, (int)arcEndCaps);
}
}
mat.SetColor(ShapesMaterialUtils.propColor, colorInnerStart);
mat.SetColor(ShapesMaterialUtils.propColorOuterStart, colorOuterStart);
mat.SetColor(ShapesMaterialUtils.propColorInnerEnd, colorInnerEnd);
mat.SetColor(ShapesMaterialUtils.propColorOuterEnd, colorOuterEnd);
ApplyDashSettings(mat, dashStyle, thickness);
DrawMesh(pos, rot, ShapesMeshUtils.QuadMesh, mat);
}
[OvldGenCallTarget] static void Line_Internal([OvldDefault(nameof(LineEndCaps))] LineEndCap endCaps,
[OvldDefault(nameof(ThicknessSpace))] ThicknessSpace thicknessSpace,
Vector3 start,
Vector3 end,
[OvldDefault(nameof(Color))] Color colorStart,
[OvldDefault(nameof(Color))] Color colorEnd,
[OvldDefault(nameof(Thickness))] float thickness)
{
using (new IMDrawer(
metaMpb: mpbLine,
sourceMat: ShapesMaterialUtils.GetLineMat(Draw.LineGeometry, endCaps)[Draw.BlendMode],
sourceMesh: ShapesMeshUtils.GetLineMesh(Draw.LineGeometry, endCaps, DetailLevel))) {
MetaMpb.ApplyDashSettings(mpbLine, thickness);
mpbLine.color.Add(colorStart.ColorSpaceAdjusted());
mpbLine.colorEnd.Add(colorEnd.ColorSpaceAdjusted());
mpbLine.pointStart.Add(start);
mpbLine.pointEnd.Add(end);
mpbLine.thickness.Add(thickness);
mpbLine.alignment.Add((float)Draw.LineGeometry); // this is redundant for 3D lines, but, that's okay, fixing that makes things messier
mpbLine.thicknessSpace.Add((float)thicknessSpace);
mpbLine.scaleMode.Add((float)ScaleMode);
}
}
static void DiscCore(ShapesBlendMode blendMode, ThicknessSpace spaceRadius, ThicknessSpace spaceThickness, bool hollow, bool sector, Vector3 pos, Quaternion rot, float radius, float thickness, Color colorInnerStart, Color colorOuterStart, Color colorInnerEnd, Color colorOuterEnd, DashStyle dashStyle = null, float angleRadStart = 0f, float angleRadEnd = 0f, ArcEndCap arcEndCaps = ArcEndCap.None)
{
if (sector && Mathf.Abs(angleRadEnd - angleRadStart) < 0.0001f)
{
return;
}
using (new IMDrawer(mpbDisc, ShapesMaterialUtils.GetDiscMaterial(hollow, sector)[blendMode], ShapesMeshUtils.QuadMesh[0], pos, rot)) {
MetaMpb.ApplyDashSettings(mpbDisc, dashStyle, thickness);
mpbDisc.radius.Add(radius);
mpbDisc.radiusSpace.Add((int)spaceRadius);
mpbDisc.alignment.Add((int)Draw.DiscGeometry);
mpbDisc.thicknessSpace.Add((int)spaceThickness);
mpbDisc.thickness.Add(thickness);
mpbDisc.scaleMode.Add((int)ScaleMode);
mpbDisc.angStart.Add(angleRadStart);
mpbDisc.angEnd.Add(angleRadEnd);
mpbDisc.roundCaps.Add((int)arcEndCaps);
mpbDisc.color.Add(colorInnerStart);
mpbDisc.colorOuterStart.Add(colorOuterStart);
mpbDisc.colorInnerEnd.Add(colorInnerEnd);
mpbDisc.colorOuterEnd.Add(colorOuterEnd);
}
}
[OvldGenCallTarget] public static void RegularPolygon([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
[OvldDefault(nameof(RegularPolygonRadiusSpace))] ThicknessSpace spaceRadius,
[OvldDefault(nameof(RegularPolygonThicknessSpace))] ThicknessSpace spaceThickness,
Vector3 pos,
[OvldDefault("Quaternion.identity")] Quaternion rot,
[OvldDefault(nameof(RegularPolygonSideCount))] int sideCount,
[OvldDefault(nameof(RegularPolygonRadius))] float radius,
[OvldDefault(nameof(RegularPolygonThickness))] float thickness,
[OvldDefault(nameof(Color))] Color color,
bool hollow,
[OvldDefault("0f")] float roundness,
[OvldDefault("0f")] float angle,
[OvldDefault(nameof(PolygonShapeFill))] ShapeFill fill)
{
Material mat = ShapesMaterialUtils.matRegularPolygon[blendMode];
ApplyGlobalProperties(mat);
mat.SetFloat(ShapesMaterialUtils.propRadius, radius);
mat.SetInt(ShapesMaterialUtils.propRadiusSpace, (int)spaceRadius);
mat.SetInt(ShapesMaterialUtils.propAlignment, (int)Draw.RegularPolygonGeometry);
mat.SetInt(ShapesMaterialUtils.propSides, Mathf.Max(3, sideCount));
mat.SetFloat(ShapesMaterialUtils.propAng, angle);
mat.SetFloat(ShapesMaterialUtils.propRoundness, roundness);
mat.SetInt(ShapesMaterialUtils.propHollow, hollow.AsInt());
if (hollow)
{
mat.SetInt(ShapesMaterialUtils.propThicknessSpace, (int)spaceThickness);
mat.SetFloat(ShapesMaterialUtils.propThickness, thickness);
mat.SetInt(ShapesMaterialUtils.propScaleMode, (int)ScaleMode);
}
TryApplyFillAndColor(mat, fill, color);
DrawMesh(pos, rot, ShapesMeshUtils.QuadMesh, mat);
}
void DrawShapes()
{
Vector2 center = position.size / 2;
float fitRadius = Mathf.Min(position.width, position.height) / 2 - 8;
// set doot positions
float t = (float)EditorApplication.timeSinceStartup / 2;
foreach (Doot doot in doots)
{
float ang = doot.angSpeed * t * ShapesMath.TAU + doot.angOffset;
Vector2 dir = ShapesMath.AngToDir(ang);
doot.pos = dir * (fitRadius * doot.radialOffset);
}
// mouse doot~
Vector2 mouseRawPos = Event.current.mousePosition - center;
float maxRadius = fitRadius * DOOT_MAX_RADIUS;
Vector2 mouseTargetPos = Vector2.ClampMagnitude(mouseRawPos, maxRadius);
doots[0].pos = Vector2.Lerp(doots[0].pos, mouseTargetPos, mouseDootT);
bool mouseOver = mouseOverWindow == this;
mouseDootT = Mathf.Lerp(mouseDootT, mouseOver ? 1f : 0f, 0.05f);
// save state
Matrix4x4 prevMtx = Draw.Matrix;
ShapesBlendMode prevBlendMode = Draw.BlendMode;
ThicknessSpace prevDiscRadiusSpace = Draw.DiscRadiusSpace;
ThicknessSpace prevLineThicknessSpace = Draw.LineThicknessSpace;
LineGeometry prevLineGeometry = Draw.LineGeometry;
ThicknessSpace prevRingThicknessSpace = Draw.RingThicknessSpace;
// draw setup
Draw.Matrix = Matrix4x4.TRS(new Vector3(center.x, center.y, 1f), Quaternion.identity, Vector3.one);
Draw.BlendMode = ShapesBlendMode.Transparent;
Draw.DiscRadiusSpace = ThicknessSpace.Meters;
Draw.LineThicknessSpace = ThicknessSpace.Meters;
Draw.LineGeometry = LineGeometry.Flat2D;
Draw.RingThicknessSpace = ThicknessSpace.Meters;
// Drawing
Draw.RingGradientRadial(Vector3.zero, fitRadius, fitRadius * 0.1f, Color.black, new Color(0, 0, 0, 0));
Draw.Disc(Vector3.zero, fitRadius, Color.black);
// edge noodles
const int noodCount = 64;
for (int i = 0; i < noodCount; i++)
{
float tDir = i / ((float)noodCount);
float tAng = ShapesMath.TAU * tDir;
Vector2 dir = ShapesMath.AngToDir(tAng);
if (Mathf.Abs(dir.y) > 0.75f)
{
continue;
}
Vector2 root = dir * fitRadius;
float distToNearest = float.MaxValue;
for (int j = 0; j < doots.Length; j++)
{
distToNearest = Mathf.Min(distToNearest, Vector2.Distance(doots[j].pos, root));
}
float distMod = Mathf.InverseLerp(fitRadius * 0.5f, fitRadius * 0.1f, distToNearest);
float noodMaxOffset = fitRadius * (1 + 0.1f * distMod);
Draw.Line(root, dir * noodMaxOffset, fitRadius * Mathf.Lerp(0.07f, 0.04f, distMod));
}
// ring
Draw.Ring(Vector3.zero, fitRadius, fitRadius * 0.0125f, colMain);
// connecting lines
for (int i = 0; i < doots.Length; i++)
{
Vector2 a = doots[i].pos;
for (int j = i; j < doots.Length; j++)
{
Vector2 b = doots[j].pos;
float dist = Vector2.Distance(a, b);
float rangeValue = Mathf.InverseLerp(fitRadius * 1f, fitRadius * 0.02f, dist);
if (rangeValue > 0)
{
Color col = Color.Lerp(colFade, colMain, rangeValue);
Draw.Line(a, b, fitRadius * 0.015f * rangeValue, LineEndCap.Round, col);
}
}
}
// doots~
foreach (Doot doot in doots)
{
Draw.BlendMode = ShapesBlendMode.Transparent;
Draw.Disc(doot.pos, fitRadius * 0.025f, Color.black);
Draw.Disc(doot.pos, fitRadius * 0.015f, colMain);
Draw.BlendMode = ShapesBlendMode.Additive;
Color innerColor = colMain;
innerColor.a = 0.25f;
Color outerColor = Color.clear;
Draw.DiscGradientRadial(doot.pos, fitRadius * 0.18f, innerColor, outerColor);
}
Draw.BlendMode = ShapesBlendMode.Multiplicative;
Draw.DiscGradientRadial(Vector3.zero, fitRadius * 0.5f, Color.black, Color.clear);
// restore state
Draw.Matrix = prevMtx;
Draw.BlendMode = prevBlendMode;
Draw.DiscRadiusSpace = prevDiscRadiusSpace;
Draw.LineThicknessSpace = prevLineThicknessSpace;
Draw.LineGeometry = prevLineGeometry;
Draw.RingThicknessSpace = prevRingThicknessSpace;
}
