private WW.Math.Geometry.Polyline3D method_14(GraphicsConfig graphicsConfig)
{
double num1 = 2.0 * System.Math.PI / (double)graphicsConfig.NoOfArcLineSegments;
double double2 = this.double_2;
double double3 = this.double_3;
if (double3 <= double2)
{
double3 += 2.0 * System.Math.PI;
}
Matrix4D transform = this.Transform;
Vector3D vector3D0 = this.vector3D_0;
vector3D0.Normalize();
Vector3D vector3D = Vector3D.CrossProduct(this.vector3D_1, vector3D0);
vector3D.Normalize();
double length = this.vector3D_0.GetLength();
double num2 = this.double_1 * length;
WW.Math.Geometry.Polyline3D polyline3D = new WW.Math.Geometry.Polyline3D();
for (; double2 < double3; double2 += num1)
{
WW.Math.Point3D point = (WW.Math.Point3D)(length * System.Math.Cos(double2) * vector3D0 + num2 * System.Math.Sin(double2) * vector3D);
polyline3D.Add(transform.Transform(point));
}
polyline3D.Add(transform.Transform((WW.Math.Point3D)(length * System.Math.Cos(double3) * vector3D0 + num2 * System.Math.Sin(double3) * vector3D)));
return(polyline3D);
}
private WW.Math.Geometry.Polyline3D method_14(
GraphicsConfig graphicsConfig,
double startAngle,
double endAngle)
{
double num1 = 2.0 * System.Math.PI / (double)graphicsConfig.NoOfArcLineSegments;
double num2 = startAngle;
Matrix4D denormalizationTransform = this.DenormalizationTransform;
WW.Math.Geometry.Polyline3D polyline3D = new WW.Math.Geometry.Polyline3D();
if ((endAngle - num2) / num1 < (double)graphicsConfig.NoOfArcLineSegmentsMinimum)
{
double lineSegmentsMinimum = (double)graphicsConfig.NoOfArcLineSegmentsMinimum;
double a = (endAngle - num2) / lineSegmentsMinimum;
if (!MathUtil.AreApproxEqual(a, 0.0))
{
num1 = a;
}
}
for (; num2 <= endAngle; num2 += num1)
{
WW.Math.Point2D point = new WW.Math.Point2D(System.Math.Cos(num2), System.Math.Sin(num2));
polyline3D.Add(denormalizationTransform.TransformTo3D4x3(point));
}
polyline3D.Add(denormalizationTransform.TransformTo3D4x3(new WW.Math.Point2D(System.Math.Cos(endAngle), System.Math.Sin(endAngle))));
return(polyline3D);
}
private void method_22(
IList <WW.Math.Geometry.Polyline3D> polylines,
int mNoOfSplineLineParts,
int nNoOfSplineLineParts)
{
WW.Math.Point3D[,] point3DArray = this.method_23(mNoOfSplineLineParts, nNoOfSplineLineParts);
int length1 = point3DArray.GetLength(0);
int length2 = point3DArray.GetLength(1);
bool closedInNdirection = this.ClosedInNDirection;
for (int index1 = 0; index1 < length1; ++index1)
{
WW.Math.Geometry.Polyline3D polyline3D = new WW.Math.Geometry.Polyline3D(closedInNdirection);
polylines.Add(polyline3D);
for (int index2 = 0; index2 < length2; ++index2)
{
polyline3D.Add(point3DArray[index1, index2]);
}
}
bool closedInMdirection = this.ClosedInMDirection;
for (int index1 = 0; index1 < length2; ++index1)
{
WW.Math.Geometry.Polyline3D polyline3D = new WW.Math.Geometry.Polyline3D(closedInMdirection);
polylines.Add(polyline3D);
for (int index2 = 0; index2 < length1; ++index2)
{
polyline3D.Add(point3DArray[index2, index1]);
}
}
}
private WW.Math.Geometry.Polyline3D method_18(int power, int noOfSplineLineParts)
{
WW.Math.Geometry.Polyline3D polyline3D = new WW.Math.Geometry.Polyline3D(this.Closed);
int count = this.dxfVertex3DCollection_0.Count;
if (count < power + 1)
{
return(this.method_17());
}
BSplineD bsplineD = new BSplineD(power, count, this.Closed);
double[] result = new double[power + 1];
double maxU = bsplineD.MaxU;
int num1 = noOfSplineLineParts + 1;
double num2 = maxU / (double)(num1 - 1);
int num3 = 0;
double u = 0.0;
while (num3 < num1)
{
int knotSpanIndex = bsplineD.GetKnotSpanIndex(u);
bsplineD.EvaluateBasisFunctions(knotSpanIndex, u, result);
WW.Math.Point3D zero = WW.Math.Point3D.Zero;
for (int index = 0; index < power + 1; ++index)
{
DxfVertex3D dxfVertex3D = this.dxfVertex3DCollection_0[(knotSpanIndex - power + index) % count];
zero += result[index] * (Vector3D)dxfVertex3D.Position;
}
polyline3D.Add(zero);
++num3;
u += num2;
}
return(polyline3D);
}
private void method_13(IList <WW.Math.Geometry.Polyline3D> polylines)
{
foreach (DxfMeshFace dxfMeshFace in this.list_0)
{
int count = dxfMeshFace.Corners.Count;
if (count > 0)
{
DxfMeshFace.Corner corner1 = dxfMeshFace.Corners[0];
int num;
switch (count)
{
case 1:
WW.Math.Geometry.Polyline3D polyline3D1 = new WW.Math.Geometry.Polyline3D(new WW.Math.Point3D[1] {
corner1.Vertex.Position
});
polylines.Add(polyline3D1);
continue;
case 2:
num = 1;
break;
default:
num = count;
break;
}
for (int index = 0; index < num; ++index)
{
DxfMeshFace.Corner corner2 = dxfMeshFace.Corners[(index + 1) % count];
if (corner1.EdgeVisible)
{
WW.Math.Geometry.Polyline3D polyline3D2 = new WW.Math.Geometry.Polyline3D();
polylines.Add(polyline3D2);
if (corner1.Vertex != null)
{
polyline3D2.Add(corner1.Vertex.Position);
}
if (corner2.Vertex != null)
{
polyline3D2.Add(corner2.Vertex.Position);
}
}
corner1 = corner2;
}
}
}
}
private WW.Math.Geometry.Polyline3D method_13()
{
WW.Math.Geometry.Polyline3D polyline3D = new WW.Math.Geometry.Polyline3D(this.Closed);
foreach (DxfVertex3D dxfVertex3D in (DxfHandledObjectCollection <DxfVertex3D>) this.dxfVertex3DCollection_0)
{
polyline3D.Add(dxfVertex3D.Position);
}
return(polyline3D);
}
public Polyline3D ToPolyline3D()
{
Polyline3D polyline3D = new Polyline3D(this.Count, this.Closed);
foreach (Vector4D vector4D in (List <Vector4D>) this)
{
polyline3D.Add(vector4D.ToPoint3D());
}
return(polyline3D);
}
public Polyline3D GetReverse()
{
Polyline3D polyline3D = new Polyline3D(this.Count, this.Closed);
for (int index = this.Count - 1; index >= 0; --index)
{
polyline3D.Add(this[index]);
}
return(polyline3D);
}
public static Polyline3D GetSubPolyline(IList <Point3D> points, int start, int length)
{
Polyline3D polyline3D = new Polyline3D(length);
int num = start + length;
for (int index = start; index < num; ++index)
{
polyline3D.Add(points[index]);
}
return(polyline3D);
}
private WW.Math.Geometry.Polyline3D method_13()
{
WW.Math.Geometry.Polyline3D polyline3D = new WW.Math.Geometry.Polyline3D(true);
Matrix4D transform = this.Transform;
polyline3D.Add(transform.Transform(this.list_0[0]));
polyline3D.Add(transform.Transform(this.list_0[1]));
if (this.list_0.Count == 3)
{
polyline3D.Add(transform.Transform(this.list_0[2]));
}
else
{
if (this.list_0[3] != this.list_0[0] && this.list_0[3] != this.list_0[2])
{
polyline3D.Add(transform.Transform(this.list_0[3]));
}
polyline3D.Add(transform.Transform(this.list_0[2]));
}
return(polyline3D);
}
internal static void Extrude(
WW.Cad.Drawing.Surface.Geometry geometry,
WW.Math.Geometry.Polyline3D polyline,
bool isSurface,
Vector3D extrusion)
{
if (polyline.Count == 1)
{
WW.Math.Point3D start = polyline[0];
geometry.Add((IPrimitive) new WW.Cad.Drawing.Surface.Segment(start, start + extrusion));
}
else if (polyline.Count == 2)
{
WW.Math.Point3D v0 = polyline[0];
WW.Math.Point3D v1 = polyline[1];
geometry.Add((IPrimitive) new Quad(v0, v1, v1 + extrusion, v0 + extrusion));
}
else if (isSurface)
{
Class940.smethod_22(geometry, (IList <WW.Math.Point3D>)polyline);
WW.Math.Point3D v1 = polyline[polyline.Count - 1];
WW.Math.Point3D v2 = v1 + 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 v0 = polyline[index];
WW.Math.Point3D v3 = v0 + extrusion;
polyline3D.Add(v3);
geometry.Add((IPrimitive) new Quad(v0, v1, v2, v3));
v1 = v0;
v2 = v3;
}
Class940.smethod_22(geometry, (IList <WW.Math.Point3D>)polyline3D);
}
else
{
WW.Math.Point3D v1 = polyline[polyline.Count - 1];
WW.Math.Point3D v2 = v1 + 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 v0 = polyline[index];
WW.Math.Point3D v3 = v0 + extrusion;
polyline3D.Add(v3);
geometry.Add((IPrimitive) new Quad(v0, v1, v2, v3));
v1 = v0;
v2 = v3;
}
}
}
private WW.Math.Geometry.Polyline3D method_17(DrawContext.Surface context)
{
Polygon2D clipBoundary = this.GetClipBoundary((DrawContext)context);
if (clipBoundary == null || clipBoundary.Count == 0)
{
return(new WW.Math.Geometry.Polyline3D());
}
Matrix4D matrix4D = this.method_15();
WW.Math.Geometry.Polyline3D polyline3D = new WW.Math.Geometry.Polyline3D(true);
foreach (WW.Math.Point2D point in (List <WW.Math.Point2D>)clipBoundary)
{
polyline3D.Add(matrix4D.TransformTo3D(point));
}
return(polyline3D);
}
public override void DrawInternal(
DrawContext.Wireframe context,
IWireframeGraphicsFactory graphicsFactory)
{
if (this.list_0.Count <= 0)
{
return;
}
Polygon2D clipBoundary = this.GetClipBoundary((DrawContext)context);
if (clipBoundary == null)
{
return;
}
Matrix4D preTransform = this.method_15();
IClippingTransformer clippingTransformer = (IClippingTransformer)context.GetTransformer().Clone();
clippingTransformer.SetPreTransform(preTransform);
Matrix4D matrix = clippingTransformer.Matrix;
WW.Math.Point3D point = new WW.Math.Point3D(-0.5, -0.5, 0.0);
Vector4D transformedOrigin = matrix.TransformTo4D(point);
Vector4D transformedXAxis = matrix.TransformTo4D(point + WW.Math.Vector3D.XAxis);
Vector4D transformedYAxis = matrix.TransformTo4D(point + WW.Math.Vector3D.YAxis);
WW.Math.Geometry.Polyline3D polyline = new WW.Math.Geometry.Polyline3D(true);
foreach (WW.Math.Point2D point2D in (List <WW.Math.Point2D>)clipBoundary)
{
polyline.Add((WW.Math.Point3D)point2D);
}
IList <Polyline4D> polyline4DList = clippingTransformer.Transform(polyline, true);
if (polyline4DList.Count <= 0)
{
return;
}
Polyline4D imageBoundary = polyline4DList[0];
graphicsFactory.CreateImage(this, context, this.bool_2 ? imageBoundary : (Polyline4D)null, imageBoundary, transformedOrigin, transformedXAxis, transformedYAxis);
}
public override void DrawInternal(
DrawContext.Surface context,
ISurfaceGraphicsFactory graphicsFactory)
{
if (this.list_0.Count <= 0)
{
return;
}
graphicsFactory.SetColor(context.GetPlotColor((DxfEntity)this));
foreach (DxfMeshFace dxfMeshFace in this.list_0)
{
WW.Math.Geometry.Polyline3D boundary = new WW.Math.Geometry.Polyline3D(4);
List <bool> edgeVisibleList = new List <bool>(4);
foreach (DxfMeshFace.Corner corner in dxfMeshFace.Corners)
{
if (corner.Vertex != null)
{
boundary.Add(corner.Vertex.Position);
edgeVisibleList.Add(corner.EdgeVisible);
}
}
Class940.smethod_18((DxfEntity)this, context, graphicsFactory, boundary, edgeVisibleList);
}
}
public override void DrawInternal(
DrawContext.Wireframe context,
IWireframeGraphicsFactory2 graphicsFactory)
{
if (this.list_0.Count > 0)
{
Bounds2D bounds2D = this.method_14((DrawContext)context);
Matrix4D preTransform = this.method_15();
IClippingTransformer clippingTransformer = (IClippingTransformer)context.GetTransformer().Clone();
clippingTransformer.SetPreTransform(preTransform);
Vector4D?nullable1 = clippingTransformer.Transform(WW.Math.Point3D.Zero);
Vector4D?nullable2 = clippingTransformer.Transform(WW.Math.Point3D.Zero + WW.Math.Vector3D.XAxis);
Vector4D?nullable3 = clippingTransformer.Transform(WW.Math.Point3D.Zero + WW.Math.Vector3D.YAxis);
if (this.ImageDef != null && nullable1.HasValue && (nullable2.HasValue && nullable3.HasValue))
{
graphicsFactory.BeginGeometry((DxfEntity)this, context, ArgbColor.Empty, false, false, false, true);
graphicsFactory.CreateImage(this, bounds2D.Corner1, bounds2D.Corner2, nullable1.Value, nullable2.Value, nullable3.Value, context);
graphicsFactory.EndGeometry();
}
}
if (this.ImageDef != null && !context.Config.DrawImageFrame)
{
return;
}
Polygon2D clipBoundary = this.GetClipBoundary((DrawContext)context);
if (clipBoundary == null)
{
return;
}
Matrix4D preTransform1 = this.method_15();
IClippingTransformer clippingTransformer1 = (IClippingTransformer)context.GetTransformer().Clone();
clippingTransformer1.SetPreTransform(preTransform1);
WW.Math.Geometry.Polyline3D polyline1 = new WW.Math.Geometry.Polyline3D(true);
foreach (WW.Math.Point2D point2D in (List <WW.Math.Point2D>)clipBoundary)
{
polyline1.Add((WW.Math.Point3D)point2D);
}
List <Polyline4D> polyline4DList = new List <Polyline4D>((IEnumerable <Polyline4D>)clippingTransformer1.Transform(polyline1, true));
if (this.ImageDef == null)
{
graphicsFactory.BeginGeometry((DxfEntity)this, context, context.Config.BackColor, false, true, false, false);
foreach (Polyline4D polyline2 in polyline4DList)
{
graphicsFactory.CreatePolyline((DxfEntity)this, polyline2);
}
graphicsFactory.EndGeometry();
}
if (this.ImageDef != null && !context.Config.DrawImageFrame)
{
return;
}
graphicsFactory.BeginGeometry((DxfEntity)this, context, this.GetColor((DrawContext)context), false, false, true, true);
foreach (Polyline4D polyline2 in polyline4DList)
{
graphicsFactory.CreatePolyline((DxfEntity)this, polyline2);
}
graphicsFactory.EndGeometry();
}
private void GetPolylines4D(
DrawContext context,
IClippingTransformer transformer,
out IList <Polyline4D> polylines4D,
out IList <IShape4D> shapes)
{
IList <WW.Math.Geometry.Polyline3D> polyline3DList = (IList <WW.Math.Geometry.Polyline3D>) new List <WW.Math.Geometry.Polyline3D>(4);
IList <FlatShape4D> resultShapes = (IList <FlatShape4D>)null;
int count = this.list_0.Count;
if (count > 1)
{
bool flag = true;
if (this.FirstEdgeInvisible)
{
flag = false;
}
if (this.SecondEdgeInvisible)
{
flag = false;
}
if (count > 2)
{
if (this.ThirdEdgeInvisible)
{
flag = false;
}
if (count > 3 && this.FourthEdgeInvisible)
{
flag = false;
}
}
if (flag)
{
WW.Math.Geometry.Polyline3D polyline3D = new WW.Math.Geometry.Polyline3D(count, count > 2);
for (int index = 0; index < count; ++index)
{
polyline3D.Add(this.list_0[index]);
}
polyline3DList.Add(polyline3D);
}
else
{
if (!this.FirstEdgeInvisible)
{
polyline3DList.Add(new WW.Math.Geometry.Polyline3D(new WW.Math.Point3D[2]
{
this.list_0[0],
this.list_0[1]
}));
}
if (count > 2)
{
if (!this.SecondEdgeInvisible)
{
polyline3DList.Add(new WW.Math.Geometry.Polyline3D(new WW.Math.Point3D[2]
{
this.list_0[1],
this.list_0[2]
}));
}
if (this.Points.Count == 3)
{
if (!this.ThirdEdgeInvisible)
{
polyline3DList.Add(new WW.Math.Geometry.Polyline3D(new WW.Math.Point3D[2]
{
this.list_0[2],
this.list_0[0]
}));
}
}
else if (this.Points.Count == 4)
{
if (!this.ThirdEdgeInvisible)
{
polyline3DList.Add(new WW.Math.Geometry.Polyline3D(new WW.Math.Point3D[2]
{
this.list_0[2],
this.list_0[3]
}));
}
if (!this.FourthEdgeInvisible)
{
polyline3DList.Add(new WW.Math.Geometry.Polyline3D(new WW.Math.Point3D[2]
{
this.list_0[3],
this.list_0[0]
}));
}
}
}
}
IList <WW.Math.Geometry.Polyline3D> polylines = (IList <WW.Math.Geometry.Polyline3D>) new List <WW.Math.Geometry.Polyline3D>(4);
resultShapes = (IList <FlatShape4D>) new List <FlatShape4D>();
DxfUtil.smethod_2(context.Config, polyline3DList, resultShapes, polylines, this.GetLineType(context), Vector3D.ZAxis, context.TotalLineTypeScale * this.LineTypeScale, transformer.LineTypeScaler);
}
polylines4D = DxfUtil.smethod_36(polyline3DList, false, transformer);
shapes = DxfUtil.smethod_37((ICollection <FlatShape4D>)resultShapes, transformer);
}
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 DxfInsert.Enum44 method_16(
Matrix4D insertionTransform,
DxfInsert.Interface46 drawHandler)
{
if (drawHandler.InsertCellDrawContext.Config.UseSpatialFilters)
{
DxfSpatialFilter spatialFilter = this.SpatialFilter;
if (spatialFilter != null && spatialFilter.ClipBoundaryDisplayEnabled)
{
Polygon2D clipPolygon = spatialFilter.GetClipBoundaryPolygon();
if (clipPolygon.Count < 3)
{
return(DxfInsert.Enum44.const_1);
}
if (clipPolygon.GetArea() < 0.0)
{
clipPolygon = clipPolygon.GetReverse();
}
Matrix4D boundaryTransform = spatialFilter.ClipBoundaryTransform;
Matrix4D transform = insertionTransform * this.Block.BaseTransformation * spatialFilter.InverseInsertionTransform;
Matrix4D inverse1 = boundaryTransform.GetInverse();
Matrix4D clipBoundaryTransform = transform * inverse1;
DxfInsert.Enum44 enum44;
if (clipPolygon.IsConvex())
{
List <BlinnClipper4D.ClipPlane> clipPlaneList = new List <BlinnClipper4D.ClipPlane>();
WW.Math.Point2D point2D = clipPolygon[clipPolygon.Count - 1];
WW.Math.Vector3D boundaryPlaneNormal = spatialFilter.ClipBoundaryPlaneNormal;
Matrix4D inverse2 = transform.GetInverse();
inverse2.Transpose();
foreach (WW.Math.Point2D point in (List <WW.Math.Point2D>)clipPolygon)
{
Vector2D v = point - point2D;
BlinnClipper4D.ClipPlane clipPlane = new BlinnClipper4D.ClipPlane(WW.Math.Vector3D.CrossProduct(inverse1.TransformTo3D(v), boundaryPlaneNormal), inverse1.TransformTo3D(point));
clipPlane.TransformBy(transform, inverse2);
clipPlaneList.Add(clipPlane);
point2D = point;
}
BoundsCalculator boundsCalculator = new BoundsCalculator();
boundsCalculator.GetBounds(drawHandler.InsertCellDrawContext.Model, (IEnumerable <DxfEntity>) this.Block.Entities, insertionTransform * this.Block.BaseTransformation);
switch (new BlinnClipper4D((ICollection <BlinnClipper4D.ClipPlane>)clipPlaneList).TryIsInside(boundsCalculator.Bounds))
{
case InsideTestResult.Inside:
enum44 = DxfInsert.Enum44.const_2;
break;
case InsideTestResult.Outside:
enum44 = DxfInsert.Enum44.const_0;
break;
default:
enum44 = DxfInsert.Enum44.const_3;
break;
}
if (enum44 == DxfInsert.Enum44.const_3)
{
Class808 class808 = new Class808((ICollection <BlinnClipper4D.ClipPlane>)clipPlaneList);
class808.imethod_0(insertionTransform.GetInverse());
GraphicsConfig config = drawHandler.InsertCellDrawContext.Config;
ModelSpaceClippingTransformer clippingTransformer = new ModelSpaceClippingTransformer(Matrix4D.Identity, (Interface32)class808, config.ShapeFlattenEpsilon, config.ShapeFlattenEpsilonForBoundsCalculation);
drawHandler.InsertCellDrawContext.vmethod_0((IClippingTransformer)clippingTransformer);
}
}
else
{
Class455 class455 = new Class455(clipBoundaryTransform, clipPolygon, false);
BoundsCalculator boundsCalculator = new BoundsCalculator();
boundsCalculator.GetBounds(drawHandler.InsertCellDrawContext.Model, (IEnumerable <DxfEntity>) this.Block.Entities, insertionTransform * this.Block.BaseTransformation);
switch (class455.TryIsInside(boundsCalculator.Bounds))
{
case InsideTestResult.Inside:
enum44 = DxfInsert.Enum44.const_2;
break;
case InsideTestResult.Outside:
enum44 = DxfInsert.Enum44.const_0;
break;
default:
enum44 = DxfInsert.Enum44.const_3;
break;
}
if (enum44 == DxfInsert.Enum44.const_3)
{
Matrix4D inverse2 = insertionTransform.GetInverse();
class455.imethod_0(inverse2);
GraphicsConfig config = drawHandler.InsertCellDrawContext.Config;
ModelSpaceClippingTransformer clippingTransformer = new ModelSpaceClippingTransformer(Matrix4D.Identity, (Interface32)class455, config.ShapeFlattenEpsilon, config.ShapeFlattenEpsilonForBoundsCalculation);
drawHandler.InsertCellDrawContext.vmethod_0((IClippingTransformer)clippingTransformer);
}
}
if ((!spatialFilter.ClipBoundaryDisplayEnabled || drawHandler.InsertCellDrawContext.Model.Header.ExternalReferenceClippingBoundaryType == WW.Cad.Model.SimpleLineType.Off ? 0 : (this.IsEntityVisibleInContext(drawHandler.InsertCellDrawContext, true) ? 1 : 0)) != 0)
{
WW.Math.Geometry.Polyline3D polygon = new WW.Math.Geometry.Polyline3D(clipPolygon.Count);
foreach (WW.Math.Point2D point in (List <WW.Math.Point2D>)clipPolygon)
{
polygon.Add(clipBoundaryTransform.TransformTo3D(point));
}
polygon.Closed = true;
drawHandler.Draw(polygon);
}
return(enum44);
}
}
return(DxfInsert.Enum44.const_1);
}