public override void DrawInternal(
DrawContext.Surface context,
ISurfaceGraphicsFactory graphicsFactory)
{
PointDisplayMode pointDisplayMode = context.Model.Header.PointDisplayMode;
bool flag = this.Layer != null && this.Layer == context.DefPointsLayer;
if (pointDisplayMode == PointDisplayMode.None && !flag)
{
return;
}
ArgbColor plotColor = context.GetPlotColor((DxfEntity)this);
graphicsFactory.SetColor(plotColor);
Interface41 transformer = context.GetTransformer();
if (this.double_1 != 0.0)
{
graphicsFactory.CreateSegment(transformer.Transform(this.point3D_0), transformer.Transform(this.point3D_0 + this.double_1 * this.vector3D_0));
}
else
{
graphicsFactory.CreatePoint(transformer.Transform(this.point3D_0));
}
}
public override void DrawInternal(
DrawContext.Surface context,
ISurfaceGraphicsFactory graphicsFactory)
{
graphicsFactory.SetColor(context.GetPlotColor((DxfEntity)this));
IList <WW.Math.Geometry.Polyline3D> polylines;
IList <FlatShape4D> shapes;
this.GetPolylines((DrawContext)context, context.GetTransformer().LineTypeScaler, out polylines, out shapes);
Interface41 transformer = (Interface41)context.GetTransformer().Clone();
transformer.SetPreTransform(this.Transform);
IList <Polyline4D> polyline4DList = DxfUtil.smethod_51(polylines, transformer);
if (polyline4DList.Count > 0)
{
foreach (Polyline4D polyline4D in (IEnumerable <Polyline4D>)polyline4DList)
{
graphicsFactory.CreatePolyline((IList <Vector4D>)polyline4D, polyline4D.Closed);
}
}
if (shapes == null)
{
return;
}
Class940.smethod_24((IPathDrawer) new Class473((DxfEntity)this, context, graphicsFactory), (IEnumerable <FlatShape4D>)shapes, this.Color.ToColor(), context.GetLineWeight((DxfEntity)this), 0.0);
}
public override void DrawInternal(
DrawContext.Surface context,
ISurfaceGraphicsFactory graphicsFactory)
{
ushort mApproximationPointCount;
ushort nApproximationPointCount;
this.method_13(out mApproximationPointCount, out nApproximationPointCount);
WW.Math.Point3D[,] point3DArray = this.method_19((int)mApproximationPointCount - 1, (int)nApproximationPointCount - 1);
int length1 = point3DArray.GetLength(0);
int length2 = point3DArray.GetLength(1);
Vector4D[,] polygonMesh = new Vector4D[length1, length2];
Interface41 transformer = context.GetTransformer();
for (int index1 = 0; index1 < length1; ++index1)
{
for (int index2 = 0; index2 < length2; ++index2)
{
polygonMesh[index1, index2] = transformer.Transform(point3DArray[index1, index2]);
}
}
graphicsFactory.SetColor(context.GetPlotColor((DxfEntity)this));
graphicsFactory.CreatePolygonMesh(polygonMesh, this.ClosedInMDirection, this.ClosedInNDirection);
}
public static void smethod_19(
DxfEntity entity,
DrawContext.Surface context,
ISurfaceGraphicsFactory graphicsFactory,
List <WW.Math.Point3D> boundary,
List <bool> edgeVisibleList)
{
Interface41 transformer = context.GetTransformer();
Polyline4D boundary1 = DxfUtil.smethod_46(new WW.Math.Geometry.Polyline3D((IList <WW.Math.Point3D>)boundary), transformer);
Class940.smethod_20(entity, context, graphicsFactory, boundary1, edgeVisibleList);
}
public static void smethod_15(
DxfEntity entity,
DrawContext.Surface context,
ISurfaceGraphicsFactory graphicsFactory,
IList <WW.Math.Geometry.Polyline3D> polylines)
{
Interface41 transformer = context.GetTransformer();
foreach (WW.Math.Geometry.Polyline3D polyline in (IEnumerable <WW.Math.Geometry.Polyline3D>)polylines)
{
Polyline4D polyline4D = DxfUtil.smethod_46(polyline, transformer);
graphicsFactory.CreatePolyline((IList <Vector4D>)polyline4D, polyline.Closed);
}
}
private static void smethod_9(
DxfEntity entity,
ISurfaceGraphicsFactory graphicsFactory,
WW.Cad.Drawing.Polyline2D2N polyline2D,
Interface41 transformer,
Polyline4D polyline4DBottom,
Polyline4D polyline4DTop)
{
int count = polyline2D.Count;
int startVertexIndex = polyline2D.Closed ? count - 1 : 0;
for (int endVertexIndex = polyline2D.Closed ? 0 : 1; endVertexIndex < count; ++endVertexIndex)
{
Point2D2N point2D2N1 = polyline2D[startVertexIndex];
Point2D2N point2D2N2 = point2D2N1;
int num1 = endVertexIndex;
while (endVertexIndex < count)
{
Point2D2N point2D2N3 = polyline2D[endVertexIndex];
if (!(point2D2N1.EndNormal != point2D2N3.StartNormal))
{
++endVertexIndex;
point2D2N1 = point2D2N3;
}
else
{
break;
}
}
if (endVertexIndex == count)
{
endVertexIndex = count - 1;
}
Vector3D[] vector3DArray = new Vector3D[endVertexIndex - num1 + 2];
vector3DArray[0] = transformer.Transform((Vector3D)point2D2N2.StartNormal);
vector3DArray[1] = transformer.Transform((Vector3D)point2D2N2.EndNormal);
int num2 = num1;
int index1 = 2;
while (num2 < endVertexIndex)
{
int index2 = num2 >= count ? 0 : num2;
vector3DArray[index1] = transformer.Transform((Vector3D)polyline2D[index2].EndNormal);
++num2;
++index1;
}
graphicsFactory.CreateQuadStrip((IList <Vector4D>)polyline4DBottom, (IList <Vector4D>)polyline4DTop, (IList <Vector3D>)vector3DArray, startVertexIndex, endVertexIndex);
startVertexIndex = endVertexIndex;
}
}
public override void DrawInternal(
DrawContext.Surface context,
ISurfaceGraphicsFactory graphicsFactory)
{
DxfImageDef imageDef = this.ImageDef;
if (imageDef == null || !imageDef.Bitmap.IsValid)
{
return;
}
List <WW.Math.Point2D> clipBoundary = (List <WW.Math.Point2D>) this.GetClipBoundary((DrawContext)context);
if (clipBoundary == null || clipBoundary.Count <= 0)
{
return;
}
List <Triangulator2D.Triangle> triangleList = new List <Triangulator2D.Triangle>();
List <WW.Math.Point2D> point2DList = new List <WW.Math.Point2D>();
Triangulator2D.Triangulate((IList <IList <WW.Math.Point2D> >) new List <WW.Math.Point2D>[1]
{
clipBoundary
}, (IList <Triangulator2D.Triangle>)triangleList, (IList <WW.Math.Point2D>)point2DList);
Interface41 nterface41 = (Interface41)context.GetTransformer().Clone();
Matrix4D preTransform = this.method_15();
nterface41.SetPreTransform(preTransform);
WW.Math.Point2D[] point2DArray = new WW.Math.Point2D[point2DList.Count];
Vector4D[] vector4DArray = new Vector4D[point2DList.Count];
Size2D referencedImageSize = this.ReferencedImageSize;
double num1 = 1.0 / referencedImageSize.X;
double num2 = 1.0 / referencedImageSize.Y;
Vector2D vector2D = new Vector2D(0.5, 0.5);
for (int index = point2DList.Count - 1; index >= 0; --index)
{
WW.Math.Point2D point2D = point2DList[index] + vector2D;
point2DArray[index] = new WW.Math.Point2D(num1 * point2D.X, 1.0 - num2 * point2D.Y);
vector4DArray[index] = nterface41.Transform(new WW.Math.Point3D(point2D.X, point2D.Y, 0.0));
}
byte[] rgbaBytes = imageDef.Bitmap.GetRgbaBytes();
graphicsFactory.CreateTexturedTriangles(rgbaBytes, imageDef.Bitmap.Width, imageDef.Bitmap.Height, preTransform.Transform(WW.Math.Vector3D.ZAxis), (IList <Triangulator2D.Triangle>)triangleList, (IList <WW.Math.Point2D>)point2DArray, (IList <Vector4D>)vector4DArray);
}
public static void smethod_17(
DxfEntity entity,
DrawContext.Surface context,
ISurfaceGraphicsFactory graphicsFactory,
WW.Math.Geometry.Polyline3D polyline,
bool isSurface)
{
Interface41 transformer = context.GetTransformer();
Polyline4D boundary = DxfUtil.smethod_46(polyline, transformer);
if (isSurface)
{
Class940.smethod_20(entity, context, graphicsFactory, boundary, (List <bool>)null);
}
else
{
graphicsFactory.CreatePolyline((IList <Vector4D>)boundary, polyline.Closed);
}
}
public override void DrawInternal(
DrawContext.Surface context,
ISurfaceGraphicsFactory graphicsFactory)
{
Vector4D[,] polygonMesh = new Vector4D[(int)this.ushort_0, (int)this.ushort_1];
Interface41 transformer = context.GetTransformer();
int index1 = 0;
for (int index2 = 0; index2 < (int)this.ushort_0; ++index2)
{
int index3 = 0;
while (index3 < (int)this.ushort_1)
{
polygonMesh[index2, index3] = transformer.Transform(this.dxfHandledObjectCollection_1[index1].Position);
++index3;
++index1;
}
}
graphicsFactory.SetColor(context.GetPlotColor((DxfEntity)this));
graphicsFactory.CreatePolygonMesh(polygonMesh, this.ClosedInMDirection, this.ClosedInNDirection);
}
public void imethod_22(Interface41 interface41_1)
{
this.interface41_0 = interface41_1;
}
internal static void smethod_11(
DxfEntity entity,
DrawContext.Surface context,
ISurfaceGraphicsFactory graphicsFactory,
WW.Cad.Drawing.Polyline2D2N polylineA,
WW.Cad.Drawing.Polyline2D2N polylineB,
Matrix4D transform,
Vector3D normal,
bool isSurface)
{
Interface41 transformer = (Interface41)context.GetTransformer().Clone();
transformer.SetPreTransform(transform);
if (polylineA.Count == 1)
{
Point2D2N point2D2N1 = polylineA[0];
Point2D2N point2D2N2 = polylineB[0];
if (point2D2N1.Position == point2D2N2.Position)
{
graphicsFactory.CreatePoint(transformer.Transform(point2D2N1.Position));
}
else
{
graphicsFactory.CreateSegment(transformer.Transform(point2D2N1.Position), transformer.Transform(point2D2N2.Position));
}
}
else if (polylineA.Count == 2)
{
Point2D2N point2D2N1 = polylineA[0];
Point2D2N point2D2N2 = polylineA[1];
Point2D2N point2D2N3 = polylineB[0];
Point2D2N point2D2N4 = polylineB[1];
Vector4D[] vector4DArray = new Vector4D[4] {
transformer.Transform(point2D2N1.Position), transformer.Transform(point2D2N2.Position), transformer.Transform(point2D2N4.Position), transformer.Transform(point2D2N3.Position)
};
if (isSurface)
{
graphicsFactory.CreateQuad((IList <Vector4D>)vector4DArray, (IList <bool>)null);
}
else
{
graphicsFactory.CreatePolyline((IList <Vector4D>)vector4DArray, true);
}
}
else
{
int count = polylineA.Count;
bool closed = polylineA.Closed;
Polyline4D polyline4D1 = DxfUtil.smethod_47(polylineA, transformer);
Polyline4D polyline4D2 = DxfUtil.smethod_47(polylineB, transformer);
if (isSurface)
{
graphicsFactory.CreateQuadStrip((IList <Vector4D>)polyline4D1, (IList <Vector4D>)polyline4D2, normal, closed);
}
else
{
int index1 = 0;
int num = 1;
if (closed)
{
index1 = count - 1;
num = 0;
}
Vector4D start = polyline4D1[index1];
Vector4D end = polyline4D2[index1];
for (int index2 = num; index2 < count; ++index2)
{
Vector4D vector4D1 = polyline4D1[index2];
Vector4D vector4D2 = polyline4D2[index2];
graphicsFactory.CreateSegment(start, end);
start = vector4D1;
end = vector4D2;
}
graphicsFactory.CreatePolyline((IList <Vector4D>)polyline4D1, closed);
graphicsFactory.CreatePolyline((IList <Vector4D>)polyline4D2, closed);
}
}
}
internal static void smethod_8(
DxfEntity entity,
DrawContext.Surface context,
ISurfaceGraphicsFactory graphicsFactory,
WW.Cad.Drawing.Polyline2D2N polylineA,
WW.Cad.Drawing.Polyline2D2N polylineB,
bool isSurface,
Matrix4D transform,
Vector3D normal,
double extrusion)
{
Interface41 transformer = (Interface41)context.GetTransformer().Clone();
transformer.SetPreTransform(transform);
Vector3D vector3D = transformer.Transform(new Vector3D(0.0, 0.0, extrusion));
Vector4D vector4D1 = (Vector4D)vector3D;
if (polylineA.Count == 1)
{
Point2D2N point2D2N1 = polylineA[0];
Point2D2N point2D2N2 = polylineB[0];
if (point2D2N1.Position == point2D2N2.Position)
{
Vector4D start = transformer.Transform((WW.Math.Point3D)point2D2N1.Position);
graphicsFactory.CreateSegment(start, start + vector4D1);
}
else
{
Vector4D vector4D2 = transformer.Transform(point2D2N1.Position);
Vector4D vector4D3 = transformer.Transform(point2D2N2.Position);
Vector4D[] vector4DArray = new Vector4D[4] {
vector4D2, vector4D3, vector4D3 + vector4D1, vector4D2 + vector4D1
};
if (isSurface)
{
graphicsFactory.CreateQuad((IList <Vector4D>)vector4DArray, (IList <bool>)null);
}
else
{
graphicsFactory.CreatePolyline((IList <Vector4D>)vector4DArray, true);
}
}
}
else if (polylineA.Count == 2)
{
Point2D2N point2D2N1 = polylineA[0];
Point2D2N point2D2N2 = polylineA[1];
Point2D2N point2D2N3 = polylineB[0];
Point2D2N point2D2N4 = polylineB[1];
Vector4D vector4D2 = transformer.Transform(new WW.Math.Point3D(point2D2N1.Position, 0.0));
Vector4D vector4D3 = transformer.Transform(new WW.Math.Point3D(point2D2N2.Position, 0.0));
Vector4D vector4D4 = transformer.Transform(new WW.Math.Point3D(point2D2N3.Position, 0.0));
Vector4D vector4D5 = transformer.Transform(new WW.Math.Point3D(point2D2N4.Position, 0.0));
Vector4D vector4D6 = vector4D2 + vector4D1;
Vector4D vector4D7 = vector4D3 + vector4D1;
Vector4D vector4D8 = vector4D4 + vector4D1;
Vector4D vector4D9 = vector4D5 + vector4D1;
Vector4D[] vector4DArray1 = new Vector4D[4] {
vector4D2, vector4D3, vector4D5, vector4D4
};
Vector4D[] vector4DArray2 = new Vector4D[4] {
vector4D6, vector4D7, vector4D9, vector4D8
};
if (isSurface)
{
graphicsFactory.CreateQuad((IList <Vector4D>)vector4DArray1, (IList <bool>)null);
graphicsFactory.CreateQuad((IList <Vector4D>)vector4DArray2, (IList <bool>)null);
graphicsFactory.CreateQuad((IList <Vector4D>) new Vector4D[4]
{
vector4D2,
vector4D4,
vector4D8,
vector4D6
}, (IList <bool>)null);
graphicsFactory.CreateQuad((IList <Vector4D>) new Vector4D[4]
{
vector4D3,
vector4D5,
vector4D9,
vector4D7
}, (IList <bool>)null);
graphicsFactory.CreateQuadStrip((IList <Vector4D>) new Vector4D[2]
{
vector4D2,
vector4D3
}, (IList <Vector4D>) new Vector4D[2]
{
vector4D6,
vector4D7
}, (IList <Vector3D>) new Vector3D[2]
{
transformer.Transform(new Vector3D(point2D2N1.StartNormal, 0.0)),
transformer.Transform(new Vector3D(point2D2N1.EndNormal, 0.0))
}, 0, 1);
graphicsFactory.CreateQuadStrip((IList <Vector4D>) new Vector4D[2]
{
vector4D8,
vector4D9
}, (IList <Vector4D>) new Vector4D[2]
{
vector4D4,
vector4D5
}, (IList <Vector3D>) new Vector3D[2]
{
transformer.Transform(new Vector3D(point2D2N3.StartNormal, 0.0)),
transformer.Transform(new Vector3D(point2D2N3.EndNormal, 0.0))
}, 0, 1);
}
else
{
graphicsFactory.CreatePolyline((IList <Vector4D>)vector4DArray1, true);
graphicsFactory.CreatePolyline((IList <Vector4D>)vector4DArray2, true);
for (int index = 0; index < 4; ++index)
{
graphicsFactory.CreateSegment(vector4DArray1[index], vector4DArray2[index]);
}
}
}
else
{
int count = polylineA.Count;
int index1 = count - 1;
bool closed = polylineA.Closed;
Polyline4D polyline4DBottom1 = DxfUtil.smethod_47(polylineA, transformer);
Polyline4D polyline4DTop1 = DxfUtil.smethod_47(polylineB, transformer);
Polyline4D polyline4DTop2 = new Polyline4D(count, closed);
Polyline4D polyline4DBottom2 = new Polyline4D(count, closed);
for (int index2 = 0; index2 < count; ++index2)
{
polyline4DTop2.Add(polyline4DBottom1[index2] + vector3D);
polyline4DBottom2.Add(polyline4DTop1[index2] + vector3D);
}
if (isSurface)
{
graphicsFactory.CreateQuadStrip((IList <Vector4D>)polyline4DBottom1, (IList <Vector4D>)polyline4DTop1, normal, closed);
graphicsFactory.CreateQuadStrip((IList <Vector4D>)polyline4DTop2, (IList <Vector4D>)polyline4DBottom2, normal, closed);
if (!closed)
{
graphicsFactory.CreateQuad((IList <Vector4D>) new Vector4D[4]
{
polyline4DBottom1[0],
polyline4DTop2[0],
polyline4DBottom2[0],
polyline4DTop1[0]
}, (IList <bool>)null);
graphicsFactory.CreateQuad((IList <Vector4D>) new Vector4D[4]
{
polyline4DBottom1[index1],
polyline4DTop2[index1],
polyline4DBottom2[index1],
polyline4DTop1[index1]
}, (IList <bool>)null);
}
Class940.smethod_9(entity, graphicsFactory, polylineA, transformer, polyline4DBottom1, polyline4DTop2);
Class940.smethod_9(entity, graphicsFactory, polylineB, transformer, polyline4DBottom2, polyline4DTop1);
if (closed)
{
return;
}
Vector4D vector4D2 = polyline4DBottom1[0];
Vector4D vector4D3 = polyline4DTop1[0];
Vector4D vector4D4 = polyline4DTop2[0];
Vector4D vector4D5 = polyline4DBottom2[0];
graphicsFactory.CreateQuad((IList <Vector4D>) new Vector4D[4]
{
vector4D2,
vector4D3,
vector4D5,
vector4D4
}, (IList <bool>)null);
int index2 = count - 1;
Vector4D vector4D6 = polyline4DBottom1[index2];
Vector4D vector4D7 = polyline4DTop1[index2];
Vector4D vector4D8 = polyline4DTop2[index2];
Vector4D vector4D9 = polyline4DBottom2[index2];
graphicsFactory.CreateQuad((IList <Vector4D>) new Vector4D[4]
{
vector4D6,
vector4D7,
vector4D9,
vector4D8
}, (IList <bool>)null);
}
else
{
int index2 = 0;
int num = 1;
if (closed)
{
index2 = count - 1;
num = 0;
}
Vector4D start = polyline4DBottom1[index2];
Vector4D vector4D2 = polyline4DTop1[index2];
Vector4D vector4D3 = polyline4DTop2[index2];
Vector4D end = polyline4DBottom2[index2];
for (int index3 = num; index3 < count; ++index3)
{
Vector4D vector4D4 = polyline4DBottom1[index3];
Vector4D vector4D5 = polyline4DTop1[index3];
Vector4D vector4D6 = polyline4DTop2[index3];
Vector4D vector4D7 = polyline4DBottom2[index3];
graphicsFactory.CreateSegment(start, vector4D2);
graphicsFactory.CreateSegment(vector4D3, end);
graphicsFactory.CreateSegment(start, vector4D3);
graphicsFactory.CreateSegment(vector4D2, end);
start = vector4D4;
vector4D2 = vector4D5;
vector4D3 = vector4D6;
end = vector4D7;
}
graphicsFactory.CreatePolyline((IList <Vector4D>)polyline4DBottom1, closed);
graphicsFactory.CreatePolyline((IList <Vector4D>)polyline4DTop1, closed);
graphicsFactory.CreatePolyline((IList <Vector4D>)polyline4DTop2, closed);
graphicsFactory.CreatePolyline((IList <Vector4D>)polyline4DBottom2, closed);
}
}
}
internal static void smethod_6(
DxfEntity entity,
DrawContext.Surface context,
ISurfaceGraphicsFactory graphicsFactory,
WW.Cad.Drawing.Polyline2D2N polyline,
bool isSurface,
Matrix4D transform,
Vector3D normal,
double extrusion)
{
Interface41 transformer = (Interface41)context.GetTransformer().Clone();
transformer.SetPreTransform(transform);
Vector3D vector3D = transformer.Transform(new Vector3D(0.0, 0.0, extrusion));
Vector4D vector4D1 = (Vector4D)vector3D;
if (polyline.Count == 1)
{
Point2D2N point2D2N = polyline[0];
Vector4D start = transformer.Transform(point2D2N.Position);
graphicsFactory.CreateSegment(start, start + vector4D1);
}
else if (polyline.Count == 2)
{
Point2D2N point2D2N1 = polyline[0];
Point2D2N point2D2N2 = polyline[1];
Vector4D vector4D2 = transformer.Transform(point2D2N1.Position);
Vector4D vector4D3 = transformer.Transform(point2D2N2.Position);
Vector4D vector4D4 = vector4D2 + vector4D1;
Vector4D vector4D5 = vector4D3 + vector4D1;
if (isSurface)
{
graphicsFactory.CreateQuadStrip((IList <Vector4D>) new Vector4D[2]
{
vector4D2,
vector4D3
}, (IList <Vector4D>) new Vector4D[2]
{
vector4D4,
vector4D5
}, (IList <Vector3D>) new Vector3D[2]
{
transformer.Transform(new Vector3D(point2D2N1.StartNormal, 0.0)),
transformer.Transform(new Vector3D(point2D2N1.EndNormal, 0.0))
}, 0, 1);
}
else
{
graphicsFactory.CreatePolyline((IList <Vector4D>) new Vector4D[4]
{
vector4D2,
vector4D3,
vector4D5,
vector4D4
}, true);
}
}
else
{
int count = polyline.Count;
bool closed = polyline.Closed;
Polyline4D polyline4DBottom = DxfUtil.smethod_47(polyline, transformer);
Polyline4D polyline4DTop = new Polyline4D(count, closed);
for (int index = 0; index < count; ++index)
{
polyline4DTop.Add(polyline4DBottom[index] + vector3D);
}
if (isSurface)
{
Class940.smethod_9(entity, graphicsFactory, polyline, transformer, polyline4DBottom, polyline4DTop);
}
else
{
for (int index = 0; index < count; ++index)
{
Vector4D start = polyline4DBottom[index];
Vector4D end = polyline4DTop[index];
graphicsFactory.CreateSegment(start, end);
}
graphicsFactory.CreatePolyline((IList <Vector4D>)polyline4DBottom, closed);
graphicsFactory.CreatePolyline((IList <Vector4D>)polyline4DTop, closed);
}
}
}
internal static void Extrude(
DxfEntity entity,
DrawContext.Surface context,
ISurfaceGraphicsFactory graphicsFactory,
WW.Math.Geometry.Polyline3D polyline,
bool isSurface,
Vector3D extrusion)
{
Interface41 transformer = context.GetTransformer();
if (polyline.Count == 1)
{
WW.Math.Point3D start = polyline[0];
Segment4D segment4D = DxfUtil.smethod_50(new Segment3D(start, start + extrusion), transformer);
graphicsFactory.CreateSegment(segment4D.Start, segment4D.End);
}
else if (polyline.Count == 2)
{
WW.Math.Point3D point3D1 = polyline[0];
WW.Math.Point3D point3D2 = polyline[1];
Polyline4D boundary = DxfUtil.smethod_46(new WW.Math.Geometry.Polyline3D(true, new WW.Math.Point3D[4] {
point3D1, point3D2, point3D2 + extrusion, point3D1 + extrusion
}), transformer);
Class940.smethod_20(entity, context, graphicsFactory, boundary, (List <bool>)null);
}
else if (isSurface)
{
Polyline4D boundary1 = DxfUtil.smethod_46(polyline, transformer);
Class940.smethod_20(entity, context, graphicsFactory, boundary1, (List <bool>)null);
WW.Math.Point3D point3D1 = polyline[polyline.Count - 1];
WW.Math.Point3D point3D2 = point3D1 + extrusion;
WW.Math.Geometry.Polyline3D polyline1 = new WW.Math.Geometry.Polyline3D(polyline.Count, polyline.Closed);
for (int index = 0; index < polyline.Count; ++index)
{
WW.Math.Point3D point3D3 = polyline[index];
WW.Math.Point3D point3D4 = point3D3 + extrusion;
polyline1.Add(point3D4);
Polyline4D boundary2 = DxfUtil.smethod_46(new WW.Math.Geometry.Polyline3D(true, new WW.Math.Point3D[4] {
point3D3, point3D1, point3D2, point3D4
}), transformer);
Class940.smethod_20(entity, context, graphicsFactory, boundary2, (List <bool>)null);
point3D1 = point3D3;
point3D2 = point3D4;
}
Polyline4D boundary3 = DxfUtil.smethod_46(polyline1, transformer);
Class940.smethod_20(entity, context, graphicsFactory, boundary3, (List <bool>)null);
}
else
{
WW.Math.Point3D point3D1 = polyline[polyline.Count - 1];
WW.Math.Point3D point3D2 = point3D1 + extrusion;
WW.Math.Geometry.Polyline3D polyline3D = new WW.Math.Geometry.Polyline3D(polyline.Count, polyline.Closed);
for (int index = 0; index < polyline.Count; ++index)
{
WW.Math.Point3D point3D3 = polyline[index];
WW.Math.Point3D point3D4 = point3D3 + extrusion;
polyline3D.Add(point3D4);
Polyline4D boundary = DxfUtil.smethod_46(new WW.Math.Geometry.Polyline3D(true, new WW.Math.Point3D[4] {
point3D3, point3D1, point3D2, point3D4
}), transformer);
Class940.smethod_20(entity, context, graphicsFactory, boundary, (List <bool>)null);
point3D1 = point3D3;
point3D2 = point3D4;
}
}
}
private void method_0(
IShape2D path,
Color color,
Matrix4D transform,
bool filled,
double extrusion,
bool isChar)
{
if (!path.HasSegments)
{
return;
}
ISurfaceGraphicsFactory graphicsFactory0 = this.isurfaceGraphicsFactory_0;
IList <Polyline2D> flattened = (IList <Polyline2D>)ShapeTool.GetFlattened(path, this.surface_0.Config.ShapeFlattenEpsilon);
this.isurfaceGraphicsFactory_0.SetColor(this.surface_0.GetPlotColor(this.dxfEntity_0, color));
Interface41 transformer = (Interface41)this.surface_0.GetTransformer().Clone();
transformer.SetPreTransform(transform);
if (!filled)
{
IList <Polyline4D> polyline4DList1 = DxfUtil.smethod_48(flattened, transformer);
foreach (Polyline4D polyline4D in (IEnumerable <Polyline4D>)polyline4DList1)
{
graphicsFactory0.CreatePolyline((IList <Vector4D>)polyline4D, polyline4D.Closed);
}
if (extrusion == 0.0)
{
return;
}
transformer.SetPreTransform(Transformation4D.Translation(0.0, 0.0, extrusion));
IList <Polyline4D> polyline4DList2 = DxfUtil.smethod_48(flattened, transformer);
foreach (Polyline4D polyline4D in (IEnumerable <Polyline4D>)polyline4DList2)
{
graphicsFactory0.CreatePolyline((IList <Vector4D>)polyline4D, polyline4D.Closed);
}
Polyline4D polyline4D1 = new Polyline4D(2);
polyline4D1.Add(Vector4D.Zero);
polyline4D1.Add(Vector4D.Zero);
for (int index1 = polyline4DList1.Count - 1; index1 >= 0; --index1)
{
Polyline4D polyline4D2 = polyline4DList1[index1];
Polyline4D polyline4D3 = polyline4DList2[index1];
for (int index2 = polyline4D2.Count - 1; index2 >= 0; --index2)
{
polyline4D1[0] = polyline4D2[index2];
polyline4D1[1] = polyline4D3[index2];
graphicsFactory0.CreatePolyline((IList <Vector4D>)polyline4D1, false);
}
}
}
else
{
List <Triangulator2D.Triangle> triangleList;
List <WW.Math.Point2D> point2DList;
if (isChar)
{
Class454 class454 = this.surface_0.CharTriangulationCache.method_0(path, this.surface_0.Config);
triangleList = class454.Triangles;
point2DList = class454.Points;
}
else
{
triangleList = new List <Triangulator2D.Triangle>();
point2DList = new List <WW.Math.Point2D>();
IList <IList <WW.Math.Point2D> > polygons = (IList <IList <WW.Math.Point2D> >) new List <IList <WW.Math.Point2D> >();
foreach (Polyline2D polyline2D in (IEnumerable <Polyline2D>)flattened)
{
polygons.Add((IList <WW.Math.Point2D>)polyline2D);
}
Triangulator2D.Triangulate(polygons, (IList <Triangulator2D.Triangle>)triangleList, (IList <WW.Math.Point2D>)point2DList);
}
Polyline2D polyline = new Polyline2D((IEnumerable <WW.Math.Point2D>)point2DList);
Polyline4D polyline4D1 = DxfUtil.smethod_49(polyline, transformer);
if (extrusion == 0.0)
{
for (int index = 0; index < triangleList.Count; ++index)
{
Triangulator2D.Triangle triangle = triangleList[index];
this.isurfaceGraphicsFactory_0.CreateTriangle(polyline4D1[triangle.I0], polyline4D1[triangle.I1], polyline4D1[triangle.I2], (IList <bool>)null);
}
}
else
{
if (extrusion == 0.0)
{
return;
}
IList <Polyline4D> polyline4DList1 = DxfUtil.smethod_48(flattened, transformer);
transformer.SetPreTransform(Transformation4D.Translation(0.0, 0.0, extrusion));
Polyline4D polyline4D2 = DxfUtil.smethod_49(polyline, transformer);
IList <Polyline4D> polyline4DList2 = DxfUtil.smethod_48(flattened, transformer);
if (extrusion > 0.0)
{
for (int index = 0; index < triangleList.Count; ++index)
{
Triangulator2D.Triangle triangle = triangleList[index];
this.isurfaceGraphicsFactory_0.CreateTriangle(polyline4D1[triangle.I0], polyline4D1[triangle.I2], polyline4D1[triangle.I1], (IList <bool>)null);
}
for (int index = 0; index < triangleList.Count; ++index)
{
Triangulator2D.Triangle triangle = triangleList[index];
this.isurfaceGraphicsFactory_0.CreateTriangle(polyline4D2[triangle.I0], polyline4D2[triangle.I1], polyline4D2[triangle.I2], (IList <bool>)null);
}
}
else
{
for (int index = 0; index < triangleList.Count; ++index)
{
Triangulator2D.Triangle triangle = triangleList[index];
this.isurfaceGraphicsFactory_0.CreateTriangle(polyline4D1[triangle.I0], polyline4D1[triangle.I1], polyline4D1[triangle.I2], (IList <bool>)null);
}
for (int index = 0; index < triangleList.Count; ++index)
{
Triangulator2D.Triangle triangle = triangleList[index];
this.isurfaceGraphicsFactory_0.CreateTriangle(polyline4D2[triangle.I0], polyline4D2[triangle.I2], polyline4D2[triangle.I1], (IList <bool>)null);
}
}
for (int index1 = polyline4DList1.Count - 1; index1 >= 0; --index1)
{
Polyline4D polyline4D3 = polyline4DList1[index1];
Polyline4D polyline4D4 = polyline4DList2[index1];
Polyline2D polyline2D = flattened[index1];
IList <Vector3D> normals = (IList <Vector3D>) new List <Vector3D>(polyline4D3.Count + 1);
for (int index2 = 0; index2 < polyline4D3.Count; ++index2)
{
int index3 = (index2 + 1) % polyline4D3.Count;
Vector2D vector2D = polyline2D[index3] - polyline2D[index2];
normals.Add(transformer.Transform(new Vector3D(vector2D.Y, -vector2D.X, 0.0)));
}
normals.Add(normals[0]);
this.isurfaceGraphicsFactory_0.CreateQuadStrip((IList <Vector4D>)polyline4D3, (IList <Vector4D>)polyline4D4, normals, 0, 0);
}
}
}
}
