spatial

type DynamicOctree[T any] struct {
	// contains filtered or unexported fields
}

type DynamicOctreeItemID uint32

type DynamicOctreeSettings struct {

	// Size specifies the dimension of the octree cube. If not specified,
	// then a default size of 4096 will be used. Inserting an item outside
	// these bounds will be suboptimal (placed in root node).
	Size opt.T[float64]

	// MaxDepth controls the maximum depth that the octree could reach. If not
	// specified, then a default max depth of 8 will be used.
	MaxDepth opt.T[int32]

	// BiasRatio is multiplied to the item radius in order to force items to
	// be placed upper in the octree hierarchy. This can lead to better
	// performance in certain cases, as it can prevent double visibility check
	// on both the item and the (tightly fit) node that contains it.
	//
	// The value must not be smaller than 1.0 and is 2.0 by default.
	BiasRatio opt.T[float64]

	// InitialNodeCapacity is a hint as to the number of nodes that will be
	// needed to place all items. Usually one would find that number empirically.
	// This allows the octree to preallocate memory and avoid dynamic allocations.
	//
	// By default the initial capacity is 4096.
	InitialNodeCapacity opt.T[int32]

	// InitialItemCapacity is a hint as to the likely upper bound of items that
	// will be inserted into the octree. This allows the octree to preallocate
	// memory and avoid dynamic allocations during insertion.
	//
	// By default the initial capacity is 1024.
	InitialItemCapacity opt.T[int32]
}

type DynamicOctreeStats struct {
	NodeCount          int32
	ItemCount          int32
	ItemsCountPerDepth []int32
}

type DynamicOctreeVisitStats struct {
	NodeCount         int32
	NodeCountVisited  int32
	NodeCountAccepted int32
	NodeCountRejected int32
	ItemCount         int32
	ItemCountVisited  int32
	ItemCountAccepted int32
	ItemCountRejected int32
}

type DynamicSet[T any] struct {
	// contains filtered or unexported fields
}

type DynamicSetItemID uint32

type DynamicSetSettings struct {

	// InitialItemCapacity is a hint as to the likely upper bound of items that
	// will be inserted into the set. This allows the set to preallocate
	// memory and avoid dynamic allocations during insertion.
	//
	// By default the initial capacity is 1024.
	InitialItemCapacity opt.T[int32]
}

type HexahedronRegion [6]Plane

type PairVisitor[T any] interface {
	// Visit is called for each observed pair of items.
	Visit(first, second T)
}

type PairVisitorBucket[T any] struct {
	// contains filtered or unexported fields
}

type PairVisitorFunc[T any] func(first, second T)

type Plane dprec.Vec4

type SphericalRegion struct {
	Position dprec.Vec3
	Radius   float64
}

type StaticOctree[T any] struct {
	// contains filtered or unexported fields
}

type StaticOctreeSettings struct {

	// Size specifies the dimension of the octree cube. If not specified,
	// then a default size of 4096 will be used. Inserting an item outside
	// these bounds will be suboptimal (placed in root node).
	Size opt.T[float64]

	// MaxDepth controls the maximum depth that the octree could reach. If not
	// specified, then a default max depth of 8 will be used.
	MaxDepth opt.T[int32]

	// BiasRatio is multiplied to the item radius in order to force items to
	// be placed upper in the octree hierarchy. This can lead to better
	// performance in certain cases, as it can prevent double visibility check
	// on both the item and the (tightly fit) node that contains it.
	//
	// The value must not be smaller than 1.0 and is 2.0 by default.
	BiasRatio opt.T[float64]

	// InitialNodeCapacity is a hint as to the number of nodes that will be
	// needed to place all items. Usually one would find that number empirically.
	// This allows the octree to preallocate memory and avoid dynamic allocations.
	//
	// By default the initial capacity is 4096.
	InitialNodeCapacity opt.T[int32]

	// InitialItemCapacity is a hint as to the likely upper bound of items that
	// will be inserted into the octree. This allows the octree to preallocate
	// memory and avoid dynamic allocations during insertion.
	//
	// By default the initial capacity is 1024.
	InitialItemCapacity opt.T[int32]
}

type StaticOctreeStats struct {
	NodeCount          int32
	ItemCount          int32
	ItemsCountPerDepth []int32
}

type StaticOctreeVisitStats struct {
	NodeCount         int32
	NodeCountVisited  int32
	NodeCountAccepted int32
	NodeCountRejected int32
	ItemCount         int32
	ItemCountVisited  int32
	ItemCountAccepted int32
	ItemCountRejected int32
}

type StaticSet[T any] struct {
	// contains filtered or unexported fields
}

type StaticSetSettings struct {

	// InitialItemCapacity is a hint as to the likely upper bound of items that
	// will be inserted into the set. This allows the set to preallocate
	// memory and avoid dynamic allocations during insertion.
	//
	// By default the initial capacity is 1024.
	InitialItemCapacity opt.T[int32]
}

type SweepPruneItemID uint32

type SweepPruneSet[T any] struct {
	// contains filtered or unexported fields
}

type SweepPruneSetSettings struct {

	// InitialItemCapacity is a hint as to the likely upper bound of items that
	// will be inserted into the set. This allows the set to preallocate
	// memory and avoid dynamic allocations during insertion.
	//
	// By default the initial capacity is 1024.
	InitialItemCapacity opt.T[int32]
}

type Visitor[T any] interface {
	// Visit is called for each observed item.
	Visit(item T)
}

type VisitorBucket[T any] struct {
	// contains filtered or unexported fields
}

type VisitorFunc[T any] func(item T)