TpvCSGBSP

type TpvCSGBSP = class

public

const

  Epsilon = 1e-5

  SquaredEpsilon = Epsilon * Epsilon

  OneMinusEpsilon = 1.0 - Epsilon

  OnePlusEpsilon = 1.0 + Epsilon

  TJunctionEpsilon = 1e-4

  TJunctionOneMinusEpsilon = 1.0 - TJunctionEpsilon

  TJunctionOnePlusEpsilon = 1.0 + TJunctionEpsilon

  NearPositionEpsilon = 1e-5

  SquaredNearPositionEpsilon = NearPositionEpsilon * NearPositionEpsilon

  CSGOptimizationBoundEpsilon = 1e-1

  daabbtNULLNODE = - 1

  AABBMULTIPLIER = 2.0

public

type

  TFloat = TpvDouble;

  PFloat = ^TFloat;

  TDynamicArray = record

public

  Items: array of T;

  Count: TpvSizeInt;

  procedure Initialize;

  procedure Finalize;

  procedure Clear;

  procedure Finish;

  procedure Assign();

  function AddNew; overload;

  function Insert(); overload;

  function Add();

  function AddRangeFrom(); overload;

  function AssignRangeFrom(); overload;

  procedure Exchange();

  procedure Delete();

end;

  TDynamicStack = record

public

  Items: array of T;

  Count: TpvSizeInt;

  procedure Initialize;

  procedure Finalize;

  procedure Push();

  function Pop();

end;

  TDynamicQueue = record

public

type

  TQueueItems = array of T;

public

  Items: TQueueItems;

  Head: TpvSizeInt;

  Tail: TpvSizeInt;

  Count: TpvSizeInt;

  Size: TpvSizeInt;

  procedure Initialize;

  procedure Finalize;

  procedure GrowResize();

  procedure Clear;

  function IsEmpty;

  procedure EnqueueAtFront();

  procedure Enqueue();

  function Dequeue();

  function Peek();

end;

  THashMap = THashMap;

  TFloatHashMap = TFloatHashMap;

  TSizeIntSparseSet = TSizeIntSparseSet;

  TVector2 = record

public

  x: TFloat;

  y: TFloat;

  constructor Create();

  class operator equal(TVector2,TVector2):Boolean();

  class operator notequal(TVector2,TVector2):Boolean();

  class operator add(TVector2,TVector2):TVector2();

  class operator subtract(TVector2,TVector2):TVector2();

  class operator multiply(TVector2,TFloat):TVector2();

  class operator divide(TVector2,TFloat):TVector2();

  class operator negative(TVector2):TVector2();

  function Length;

  function SquaredLength;

  function Lerp();

  function ToVector;

end;

  PVector2 = ^TVector2;

  TVector3 = record

public

  x: TFloat;

  y: TFloat;

  z: TFloat;

  constructor Create();

  class operator equal(TVector3,TVector3):Boolean();

  class operator notequal(TVector3,TVector3):Boolean();

  class operator add(TVector3,TVector3):TVector3();

  class operator subtract(TVector3,TVector3):TVector3();

  class operator multiply(TVector3,TFloat):TVector3();

  class operator divide(TVector3,TFloat):TVector3();

  class operator negative(TVector3):TVector3();

  function Cross();

  function Spacing();

  function Dot();

  function Length;

  function SquaredLength;

  function Lerp();

  function Normalize;

  function Perpendicular;

  function ToVector;

end;

  PVector3 = ^TVector3;

  TVector4 = record

public

  x: TFloat;

  y: TFloat;

  z: TFloat;

  w: TFloat;

  constructor Create();

  class operator equal(TVector4,TVector4):Boolean();

  class operator notequal(TVector4,TVector4):Boolean();

  class operator add(TVector4,TVector4):TVector4();

  class operator subtract(TVector4,TVector4):TVector4();

  class operator multiply(TVector4,TFloat):TVector4();

  class operator divide(TVector4,TFloat):TVector4();

  class operator negative(TVector4):TVector4();

  function Length;

  function SquaredLength;

  function Lerp();

  function ToVector;

end;

  PVector4 = ^TVector4;

  TVertex = record

public

  Position: TVector3;

  Normal: TVector3;

  TexCoord: TVector4;

  Color: TVector4;

  class operator equal(TVertex,TVertex):Boolean();

  class operator notequal(TVertex,TVertex):Boolean();

  class operator add(TVertex,TVertex):TVertex();

  class operator subtract(TVertex,TVertex):TVertex();

  class operator multiply(TVertex,TFloat):TVertex();

  class operator divide(TVertex,TFloat):TVertex();

  class operator negative(TVertex):TVertex();

  function Lerp();

  procedure Flip;

  function CloneFlip;

  function Normalize;

end;

  TAABB = packed record

public

  function Cost;

  function Combine();

  function Contains();

  function Intersects();

  function Intersection();

  case Boolean of

    False: (

        Min: TVector3;

        Max: TVector3;

      );

    True: (

        MinMax: array [0..1] of TVector3;

      );

end;

  PAABB = ^TAABB;

  PVertex = ^TVertex;

  TDynamicArray = TDynamicArray;

  PVertexList = ^TVertexList;

  TIndex = TpvSizeInt;

  PIndex = ^TIndex;

  TDynamicArray = TDynamicArray;

  PIndexList = ^TIndexList;

  TPlane = record

public

  Normal: TVector3;

  Distance: TFloat;

  constructor Create();

  class function CreateEmpty;

  function DistanceTo();

  function IntersectWithPointToPoint();

  function OK;

  function Flip;

  procedure SplitTriangles();

  procedure SplitPolygons();

end;

  PPlane = ^TPlane;

  PDynamicAABBTreeNode = ^TDynamicAABBTreeNode;

  TDynamicAABBTreeNode = record

  AABB: TAABB;

  UserData: TpvPtrInt;

  Children: array [0..1] of TpvSizeInt;

  Height: TpvSizeInt;

  case Boolean of

    False: (

        Parent: TpvSizeInt;

      );

    True: (

        Next: TpvSizeInt;

      );

end;

  PDynamicAABBTreeNodes = ^TDynamicAABBTreeNodes;

  TDynamicAABBTreeNodes = array [0..0] of TDynamicAABBTreeNode;

  PDynamicAABBTreeSizeIntArray = ^TDynamicAABBTreeSizeIntArray;

  TDynamicAABBTreeSizeIntArray = array [0..65535] of TpvSizeInt;

  TDynamicAABBFrozenTreeNode = record

  Left: TpvSizeInt;

  Right: TpvSizeInt;

  AABB: TAABB;

  UserData: pointer;

end;

  TDynamicAABBTree = TDynamicAABBTree;

  TSplitSettings = record

  SearchBestFactor: TFloat;

  PolygonSplitCost: TFloat;

  PolygonImbalanceCost: TFloat;

end;

  PSplitSettings = ^TSplitSettings;

  TVector3HashMap = TVector3HashMap;

  TSingleTreeNode = TSingleTreeNode;

  TDualTree = TDualTree;

  TMesh = TMesh;

  TSingleTreeNode = TSingleTreeNode;

  TDualTree = TDualTree;

public

const

  DefaultSplitSettings = TSplitSettings; = (SearchBestFactor: 0.0; PolygonSplitCost: 1.0; PolygonImbalanceCost: 0.25)

  ThresholdAABBVector = TVector3; = (x: AABBEPSILON; y: AABBEPSILON; z: AABBEPSILON)

public

  class function EpsilonSign();

end;

TpvCSGBSP

TObject