[fpc-pascal]how to add a package to fpc release

Arash Partow arashp at hotmail.com
Fri Dec 26 10:13:28 CET 2003 

Hi All,

I've recently begun writing a simple computational geometry unit
in object pascal. Its not object oriented just a large list of
geometric primitives etc, so far things seem to compile on FPC.

I was wondering if anyone could tell me what the protocols are
for adding such a package to FPC if it is deemed acceptable.



Regards

Arash


PS: Below are the method signatures for the unit

Function Orientation(x1,y1,x2,y2,Px,Py:Double):Double;
Function Orientation(Pnt1,Pnt2:TPoint2D; Px,Py:Double):Double;
Function Orientation(Pnt1,Pnt2,Pnt3:TPoint2D):Double;
Function Orientation(Ln:TLine2D; Pnt:TPoint2D):Double;
Function Orientation(Seg:TSegment2D; Pnt:TPoint2D):Double;

Function Orientation(x1,y1,z1,x2,y2,z2,x3,y3,z3,Px,Py,Pz:Double):Double;
Function Orientation(Pnt1,Pnt2,Pnt3:TPoint3D; Px,Py,Pz:Double):Double;
Function Orientation(Pnt1,Pnt2,Pnt3,Pnt4:TPoint3D):Double;
Function Orientation(Tri:TTriangle3D; Pnt:TPoint3D):Double;

Function Collinear(x1,y1,x2,y2,x3,y3:Double):Boolean;
Function Collinear(PntA,PntB,PntC:TPoint2D):Boolean;
Function Collinear(x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):Boolean;
Function Collinear(PntA,PntB,PntC:TPoint3D):Boolean;

Function IsPntCollinear(PntA,PntB,PntC:TPoint2D):Boolean;
Function IsPntCollinear(Line:TLine2D; PntC:TPoint2D):Boolean;
Function IsPntCollinear(PntA,PntB,PntC:TPoint3D):Boolean;
Function IsPntCollinear(Line:TLine3D; PntC:TPoint3D):Boolean;

Function IsOnRightSide(x,y:Double; Ln:TLine2D):Boolean;
Function IsOnRightSide(Pnt:TPoint2D; Ln:TLine2D):Boolean;

Function IsOnLeftSide(x,y:Double; Ln:TLine2D):Boolean;
Function IsOnLeftSide(Pnt:TPoint2D; Ln:TLine2D):Boolean;

Function Intersect(x1,y1,x2,y2,x3,y3,x4,y4:Double):Boolean;
Function Intersect(Pnt1,Pnt2,Pnt3,Pnt4:TPoint2D):Boolean;
Function Intersect(Ln1,Ln2:TLine2D):Boolean;

Function Intersect(x1,y1,z1,x2,y2,z2,x3,y3,z3,x4,y4,z4:Double):Boolean;
Function Intersect(P1,P2,P3,P4:TPoint3D):Boolean;
Function Intersect(Ln1,Ln2:TLine3D):Boolean;

Function Intersect(Ln:TLine2D; Rec:TRectangle):Boolean;
Function Intersect(Ln:TLine2D; Tri:TTriangle2D):Boolean;
Function Intersect(Ln:TLine2D; Quad:TQuadix2D):Boolean;
Function Intersect(Ln:TLine2D; Cir:TCircle):Boolean;
Function Intersect(Ln:TLine3D; Sphere:TSphere):Boolean;

Function IntersectPoint(P1,P2,P3,P4:TPoint2D; Var Nx,Ny:Double):Boolean;
Function IntersectPoint(P1,P2,P3,P4:TPoint2D):TPoint2D;
Function IntersectPoint(Ln1,Ln2:TLine2D):TPoint2D;

Function VertexAngle(x1,y1,x2,y2,x3,y3:Double):Double;
Function VertexAngle(Pnt1,Pnt2,Pnt3:TPoint2D):Double;
Function VertexAngle(x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):Double;
Function VertexAngle(Pnt1,Pnt2,Pnt3:TPoint3D):Double;

Function SegmentIntersectAngle(Pnt1,Pnt2,Pnt3,Pnt4:TPoint2D):Double;
Function SegmentIntersectAngle(Ln1,Ln2:TLine2D):Double;
Function SegmentIntersectAngle(Pnt1,Pnt2,Pnt3,Pnt4:TPoint3D):Double;
Function SegmentIntersectAngle(Ln1,Ln2:TLine3D):Double;

Function InPortal(P:TPoint2D):Boolean;
Function InPortal(P:TPoint3D):Boolean;

Function HighestPoint(Polygon: TPolygon):TPoint2D;
Function HighestPoint(Tri:TTriangle2D):TPoint2D;
Function HighestPoint(Tri:TTriangle3D):TPoint3D;
Function HighestPoint(Quadix:TQuadix2D):TPoint2D;
Function HighestPoint(Quadix:TQuadix3D):TPoint3D;

Function LowestPoint(Polygon: TPolygon):TPoint2D;
Function LowestPoint(Tri:TTriangle2D):TPoint2D;
Function LowestPoint(Tri:TTriangle3D):TPoint3D;
Function LowestPoint(Quadix:TQuadix2D):TPoint2D;
Function LowestPoint(Quadix:TQuadix3D):TPoint3D;

Function Coincident(Pnt1,Pnt2:TPoint2D):Boolean;
Function Coincident(Pnt1,Pnt2:TPoint3D):Boolean;
Function Coincident(Ln1,Ln2:TLine2D):Boolean;
Function Coincident(Ln1,Ln2:TLine3D):Boolean;
Function Coincident(Seg1,Seg2:TSegment2D):Boolean;
Function Coincident(Seg1,Seg2:TSegment3D):Boolean;
Function Coincident(Tri1,Tri2:TTriangle2D):Boolean;
Function Coincident(Tri1,Tri2:TTriangle3D):Boolean;
Function Coincident(Rect1,Rect2:TRectangle):Boolean;
Function Coincident(Quad1,Quad2:TQuadix2D):Boolean;
Function Coincident(Quad1,Quad2:TQuadix3D):Boolean;
Function Coincident(Cir1,Cir2:TCircle):Boolean;
Function Coincident(Sphr1,Sphr2:TSphere):Boolean;

Procedure PerpendicularPntToSegment(x1,y1,x2,y2,Px,Py:Double; Var 
Nx,Ny:Double);
Function  PerpendicularPntToSegment(Line:TLine2D; Pnt:TPoint2D):TPoint2D;
Function  PntToSegmentDistance(Px,Py,x1,y1,x2,y2:Double):Double;
Function  PntToSegmentDistance(Pnt:TPoint2D; Line:TLine2D):Double;

Function SegmentsParallel(x1,y1,x2,y2,x3,y3,x4,y4:Double):Boolean;
Function SegmentsParallel(Ln1,Ln2:TLine2D):Boolean;

Function 
SegmentsParallel(x1,y1,z1,x2,y2,z2,x3,y3,z3,x4,y4,z4:Double):Boolean;
Function SegmentsParallel(Pnt1,Pnt2,Pnt3,Pnt4:TPoint3D):Boolean;
Function SegmentsParallel(Ln1,Ln2:TLine3D):Boolean;

Function SegmentsPerpendicular(x1,y1,x2,y2,x3,y3,x4,y4:Double):Boolean;
Function SegmentsPerpendicular(Ln1,Ln2:TLine2D):Boolean;

Function 
SegmentsPerpendicular(x1,y1,z1,x2,y2,z2,x3,y3,z3,x4,y4,z4:Double):Boolean;
Function SegmentsPerpendicular(Ln1,Ln2:TLine3D):Boolean;

Procedure SetPlane(xh,xl,yh,yl:Double);
Procedure SetPlane(Pnt1,Pnt2:TPoint2D);
Procedure SetPlane(Rec:TRectangle);

Function RectangleIntersect(x1,y1,x2,y2,x3,y3,x4,y4:Double):Boolean;
Function RectangleIntersect(Rec1,Rec2:TRectangle):Boolean;

Function Intersect(Cir1,Cir2:TCircle):Boolean;
Function CircleInCircle(Cir1,Cir2:TCircle):Boolean;
Function IsTangent(Ln:TLine2D; Cir:TCircle):Boolean;

Function Distance(x1,y1,x2,y2:Double):Double;
Function Distance(Pnt1,Pnt2:TPoint2D):Double;
Function Distance(x1,y1,z1,x2,y2,z2:Double):Double;
Function Distance(Pnt1,Pnt2:TPoint3D):Double;
Function Distance(Line:TLine2D):Double;
Function Distance(Line:TLine3D):Double;

Function LayDistance(x1,y1,x2,y2:Double):Double;
Function LayDistance(Pnt1,Pnt2:TPoint2D):Double;
Function LayDistance(x1,y1,z1,x2,y2,z2:Double):Double;
Function LayDistance(Pnt1,Pnt2:TPoint3D):Double;
Function LayDistance(Line:TLine2D):Double;
Function LayDistance(Line:TLine3D):Double;

Function ManhattanDistance(x1,y1,x2,y2:Double):Double;
Function ManhattanDistance(Pnt1,Pnt2:TPoint2D):Double;
Function ManhattanDistance(x1,y1,z1,x2,y2,z2:Double):Double;
Function ManhattanDistance(Pnt1,Pnt2:TPoint3D):Double;
Function ManhattanDistance(Line:TLine2D):Double;
Function ManhattanDistance(Line:TLine3D):Double;

Function TriangleType(x1,y1,x2,y2,x3,y3:Double):TTriangleType;
Function TriangleType(x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):TTriangleType;
Function TriangleType(Pnt1,Pnt2,Pnt3:TPoint2D):TTriangleType;
Function TriangleType(Pnt1,Pnt2,Pnt3:TPoint3D):TTriangleType;
Function TriangleType(Tri:TTriangle2D):TTriangleType;
Function TriangleType(Tri:TTriangle3D):TTriangleType;

Function IsEquilateralTriangle(x1,y1,x2,y2,x3,y3:Double):Boolean;
Function IsEquilateralTriangle(x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):Boolean;
Function IsEquilateralTriangle(Pnt1,Pnt2,Pnt3:TPoint2D):Boolean;
Function IsEquilateralTriangle(Pnt1,Pnt2,Pnt3:TPoint3D):Boolean;
Function IsEquilateralTriangle(Tri:TTriangle2D):Boolean;
Function IsEquilateralTriangle(Tri:TTriangle3D):Boolean;

Function IsIsoscelesTriangle(x1,y1,x2,y2,x3,y3:Double):Boolean;
Function IsIsoscelesTriangle(x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):Boolean;
Function IsIsoscelesTriangle(Pnt1,Pnt2,Pnt3:TPoint2D):Boolean;
Function IsIsoscelesTriangle(Pnt1,Pnt2,Pnt3:TPoint3D):Boolean;
Function IsIsoscelesTriangle(Tri:TTriangle2D):Boolean;
Function IsIsoscelesTriangle(Tri:TTriangle3D):Boolean;

Function IsRightTriangle(x1,y1,x2,y2,x3,y3:Double):Boolean;
Function IsRightTriangle(x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):Boolean;
Function IsRightTriangle(Pnt1,Pnt2,Pnt3:TPoint2D):Boolean;
Function IsRightTriangle(Pnt1,Pnt2,Pnt3:TPoint3D):Boolean;
Function IsRightTriangle(Tri:TTriangle2D):Boolean;
Function IsRightTriangle(Tri:TTriangle3D):Boolean;

Function IsScaleneTriangle(x1,y1,x2,y2,x3,y3:Double):Boolean;
Function IsScaleneTriangle(x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):Boolean;
Function IsScaleneTriangle(Pnt1,Pnt2,Pnt3:TPoint2D):Boolean;
Function IsScaleneTriangle(Pnt1,Pnt2,Pnt3:TPoint3D):Boolean;
Function IsScaleneTriangle(Tri:TTriangle2D):Boolean;
Function IsScaleneTriangle(Tri:TTriangle3D):Boolean;

Function IsObtuseTriangle(x1,y1,x2,y2,x3,y3:Double):Boolean;
Function IsObtuseTriangle(x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):Boolean;
Function IsObtuseTriangle(Pnt1,Pnt2,Pnt3:TPoint2D):Boolean;
Function IsObtuseTriangle(Pnt1,Pnt2,Pnt3:TPoint3D):Boolean;
Function IsObtuseTriangle(Tri:TTriangle2D):Boolean;
Function IsObtuseTriangle(Tri:TTriangle3D):Boolean;

Function PntInTriangle(Px,Py,x1,y1,x2,y2,x3,y3:Double):Boolean;
Function PntInTriangle(Pnt:TPoint2D; Tri:TTriangle2D):Boolean;

Function PntInCircle(Px,Py:Double; Circle:TCircle):Boolean;
Function PntInCircle(Pnt:TPoint2D; Circle:TCircle):Boolean;
Function TriangleInCircle(Tri:TTriangle2D; Circle:TCircle):TInclusion;
Function RectangleInCircle(Rect:TRectangle; Circle:TCircle):TInclusion;
Function QuadixInCircle(Quad:TQuadix2D; Circle:TCircle):TInclusion;

Function PntInRectangle(Px,Py:Double; x1,y1,x2,y2:Double):Boolean;
Function PntInRectangle(Pnt:TPoint2D; x1,y1,x2,y2:Double):Boolean;
Function PntInRectangle(Px,Py:Double; Rec:TRectangle):Boolean;
Function PntInRectangle(Pnt:TPoint2D; Rec:TRectangle):Boolean;
Function TriangleInRectangle(Tri:TTriangle2D; Rec:TRectangle):TInclusion;
Function QuadixInRectangle(Quad:TQuadix2D; Rec:TRectangle):TInclusion;

Function PntInQuadix(Px,Py,x1,y1,x2,y2,x3,y3,x4,y4:Double):Boolean;
Function PntInQuadix(Pnt,Pnt1,Pnt2,Pnt3,Pnt4: TPoint2D):Boolean;
Function PntInQuadix(Pnt:TPoint2D; Quad:TQuadix2D):Boolean;
Function TriangleInQuadix(Tri:TTriangle2D; Quad:TQuadix2D):TInclusion;

Function PntInSphere(x,y,z: Double; Sphere:TSphere):Boolean;
Function PntInSphere(Pnt3D:TPoint3D; Sphere:TSphere):Boolean;
Function PntOnSphere(Pnt3D:TPoint3D; Sphere:TSphere):Boolean;
Function PolyhedronInSphere(Poly:TPolyhedron; Sphere:TSphere):TInclusion;

Function TriangleCircumcircle(P1,P2,P3:TPoint2D):TCircle;
Function TriangleCircumcircle(Tri:TTriangle2D):TCircle;
Function InscribedCircle(P1,P2,P3:TPoint2D):TCircle;
Function InscribedCircle(Tri:TTriangle2D):TCircle;

Function SegmentMidPoint(P1,P2:TPoint2D):TPoint2D;
Function SegmentMidPoint(Line:TLine2D):TPoint2D;
Function SegmentMidPoint(P1,P2:TPoint3D):TPoint3D;
Function SegmentMidPoint(Line:TLine3D):TPoint3D;

Function OrthoCenter(x1,y1,x2,y2,x3,y3:Double):TPoint2D;
Function OrthoCenter(Pnt1,Pnt2,CPnt:TPoint2D):TPoint2D;
Function OrthoCenter(Ln1,Ln2,Ln3:TLine2D):TPoint2D;
Function OrthoCenter(Tri:TTriangle2D):TPoint2D;

Function PolygonCentroid(Polygon :TPolygon):TPoint2D;
Function PolygonCentroid(Polygon :Array Of TPoint3D):TPoint3D;

Function PolygonSegmentIntersect(Ln:TLine2D; Poly: TPolygon):Boolean;
Function PolygonInPolygon(Poly1,Poly2: TPolygon):Boolean;
Function PolygonIntersect(Poly1,Poly2: TPolygon):Boolean;

Function PntInConvexPolygon(Px,Py:Double; Poly: TPolygon):Boolean;
Function PntInConvexPolygon(Pnt:TPoint2D; Poly: TPolygon):Boolean;

Function PntInConcavePolygon(Px,Py:Double; Poly: TPolygon):Boolean;
Function PntInConcavePolygon(Pnt:TPoint2D; Poly: TPolygon):Boolean;

Function PntOnPolygon(Px,Py:Double; Poly: TPolygon):Boolean;
Function PntOnPolygon(Pnt:TPoint2D; Poly: TPolygon):Boolean;

Function PntInPolygon(Px,Py:Double; Poly: TPolygon):Boolean;
Function PntInPolygon(Pnt:TPoint2D; Poly: TPolygon):Boolean;

Function ComplexPolygon(Poly: TPolygon):Boolean;
Function SimplePolygon(Poly: TPolygon):Boolean;
Function ConvexPolygon(Poly: TPolygon):Boolean;
Function ConcavePolygon(Poly: TPolygon):Boolean;

Procedure PolygonConstruction(Poly: TPolygon);

Function ConvexHull(Polygon:TPolygon):TPolygon;
Function ConvexHull(Polyhedron:TPolyhedron):TPolyhedron;

Function RectangularHull(Poly:TPolygon):TRectangle;
Function CircularHull(Poly:TPolygon):TCircle;
Function SphereHull(Poly: Array Of TPoint3D):TSphere;


Function Clip(Ln:TLine2D; Rec:TRectangle):TLine2D;
Function Clip(Ln:TLine2D; Tri:TTriangle2D):TLine2D;
Function Clip(Ln:TLine2D; Quad:TQuadix2D):TLine2D;

Function Area(Tri:TTriangle2D):Double;
Function Area(Tri:TTriangle3D):Double;
Function Area(Quad:TQuadix2D):Double;
Function Area(Quad:TQuadix3D):Double;
Function Area(Rec:TRectangle):Double;
Function Area(Cir:TCircle):Double;
Function Area(Poly:TPolygon):Double;

Function Perimeter(Tri:TTriangle2D):Double;
Function Perimeter(Tri:TTriangle3D):Double;
Function Perimeter(Quad:TQuadix2D):Double;
Function Perimeter(Quad:TQuadix3D):Double;
Function Perimeter(Rec:TRectangle):Double;
Function Perimeter(Cir:TCircle):Double;
Function Perimeter(Poly:TPolygon):Double;

Function Rotate(RotAng:Double; x,y:Double; Var Nx,Ny:Double):Boolean;
Function Rotate(RotAng:Double; x,y,ox,oy:Double; Var Nx,Ny:Double):Boolean;

Function Rotate(RotAng:Double; Pnt:TPoint2D):TPoint2D;
Function Rotate(RotAng:Double; Pnt,OPnt:TPoint2D):TPoint2D;

Function Rotate(RotAng:Double; Ln:TLine2D):TLine2D;
Function Rotate(RotAng:Double; Ln:TLine2D; Pnt: TPoint2D):TLine2D;

Function Rotate(RotAng:Double; Seg:TSegment2D):TSegment2D;
Function Rotate(RotAng:Double; Seg:TSegment2D; Pnt: TPoint2D):TSegment2D;

Function Rotate(RotAng:Double; Tri:TTriangle2D):TTriangle2D;
Function Rotate(RotAng:Double; Tri:TTriangle2D; OPnt:TPoint2D):TTriangle2D;

Function Rotate(RotAng:Double; Quad:TQuadix2D):TQuadix2D;
Function Rotate(RotAng:Double; Quad:TQuadix2D; OPnt:TPoint2D):TQuadix2D;

Function Rotate(RotAng:Double; Rec:TRectangle):TRectangle;
Function Rotate(RotAng:Double; Rec:TRectangle; OPnt:TPoint2D):TRectangle;

Function Rotate(RotAng:Double; Poly:TPolygon):TPolygon;
Function Rotate(RotAng:Double; Poly:TPolygon; OPnt:TPoint2D):TPolygon;

Function Rotate(Rx,Ry,Rz:Double; x,y,z:Double; Var Nx,Ny,Nz:Double):Boolean;
Function Rotate(Rx,Ry,Rz:Double; x,y,z,ox,oy,oz:Double; Var 
Nx,Ny,Nz:Double):Boolean;
Function Rotate(Rx,Ry,Rz:Double; Pnt:TPoint3D):TPoint3D;
Function Rotate(Rx,Ry,Rz:Double; Pnt,OPnt:TPoint3D):TPoint3D;

Function Rotate(Rx,Ry,Rz:Double; Ln:TLine3D):TLine3D;
Function Rotate(Rx,Ry,Rz:Double; Ln:TLine3D; Pnt: TPoint3D):TLine3D;

Function Rotate(Rx,Ry,Rz:Double; Seg:TSegment3D):TSegment3D;
Function Rotate(Rx,Ry,Rz:Double; Seg:TSegment3D; Pnt: TPoint3D):TSegment3D;

Function Rotate(Rx,Ry,Rz:Double; Tri:TTriangle3D):TTriangle3D;
Function Rotate(Rx,Ry,Rz:Double; Tri:TTriangle3D; 
OPnt:TPoint3D):TTriangle3D;

Function Rotate(Rx,Ry,Rz:Double; Quad:TQuadix3D):TQuadix3D;
Function Rotate(Rx,Ry,Rz:Double; Quad:TQuadix3D; OPnt:TPoint3D):TQuadix3D;

Function Rotate(Rx,Ry,Rz:Double; Poly:TPolygon3D):TPolygon3D;
Function Rotate(Rx,Ry,Rz:Double; Poly:TPolygon3D; OPnt:TPoint3D):TPolygon3D;

Function Translate(Dx,Dy:Double; Pnt:TPoint2D):TPoint2D;
Function Translate(Dx,Dy:Double; Ln:TLine2D):TLine2D;
Function Translate(Dx,Dy:Double; Seg:TSegment2D):TSegment2D;
Function Translate(Dx,Dy:Double; Tri:TTriangle2D):TTriangle2D;
Function Translate(Dx,Dy:Double; Quad:TQuadix2D):TQuadix2D;
Function Translate(Dx,Dy:Double; Rec:TRectangle):TRectangle;
Function Translate(Dx,Dy:Double; Cir:TCircle):TCircle;
Function Translate(Dx,Dy:Double; Poly: TPolygon):TPolygon;
Function Translate(Pnt:TPoint2D; Poly: TPolygon):TPolygon;

Function Translate(Dx,Dy,Dz:Double; Pnt:TPoint3D):TPoint3D;
Function Translate(Dx,Dy,Dz:Double; Ln:TLine3D):TLine3D;
Function Translate(Dx,Dy,Dz:Double; Seg:TSegment3D):TSegment3D;
Function Translate(Dx,Dy,Dz:Double; Tri:TTriangle3D):TTriangle3D;
Function Translate(Dx,Dy,Dz:Double; Quad:TQuadix3D):TQuadix3D;
Function Translate(Dx,Dy,Dz:Double; Sphere:TSphere):TSphere;
Function Translate(Dx,Dy,Dz:Double; Poly: TPolygon3D):TPolygon3D;
Function Translate(Pnt:TPoint3D; Poly: TPolygon3D):TPolygon3D;

Function Scale(Dx,Dy:Double; Pnt:TPoint2D):TPoint2D;
Function Scale(Dx,Dy:Double; Ln:TLine2D):TLine2D;
Function Scale(Dx,Dy:Double; Seg:TSegment2D):TSegment2D;
Function Scale(Dx,Dy:Double; Tri:TTriangle2D):TTriangle2D;
Function Scale(Dx,Dy:Double; Quad:TQuadix2D):TQuadix2D;
Function Scale(Dx,Dy:Double; Rec:TRectangle):TRectangle;
Function Scale(Dr:Double; Cir:TCircle):TCircle;
Function Scale(Dx,Dy:Double; Poly: TPolygon):TPolygon;

Function Scale(Dx,Dy,Dz:Double; Pnt:TPoint3D):TPoint3D;
Function Scale(Dx,Dy,Dz:Double; Ln:TLine3D):TLine3D;
Function Scale(Dx,Dy,Dz:Double; Seg:TSegment3D):TSegment3D;
Function Scale(Dx,Dy,Dz:Double; Tri:TTriangle3D):TTriangle3D;
Function Scale(Dx,Dy,Dz:Double; Quad:TQuadix3D):TQuadix3D;
Function Scale(Dr:Double; Sphere:TSphere):TSphere;
Function Scale(Dx,Dy,Dz:Double; Poly: TPolygon3D):TPolygon3D;


Function EquatePoint(x,y:Double):TPoint2D;
Function EquatePoint(x,y,z:Double):TPoint3D;

Function EquateLine(x1,y1,x2,y2:Double):TLine2D;
Function EquateLine(x1,y1,z1,x2,y2,z2:Double):TLine3D;

Function EquateQuadix(x1,y1,x2,y2,x3,y3,x4,y4:Double):TQuadix2D;
Function EquateQuadix(x1,y1,z1,x2,y2,z2,x3,y3,z3,x4,y4,z4:Double):TQuadix3D;

Function EquateRectangle(x1,y1,x2,y2:Double):TRectangle;

Function EquateTriangle(x1,y1,x2,y2,x3,y3:Double):TTriangle2D;
Function EquateTriangle(x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):TTriangle3D;

Function EquateCircle(x,y,r:Double):TCircle;
Function EquateSphere(x,y,z,r:Double):TSphere;

Function EquatePlane(x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):TPlane3D;
Function EquatePlane(Pnt1,Pnt2,Pnt3:TPoint3D):TPlane3D;

_________________________________________________________________
Hot chart ringtones and polyphonics. Go to  
http://ninemsn.com.au/mobilemania/default.asp

More information about the fpc-pascal mailing list