spatial

type ObjectContainer ¶

type ObjectContainer struct {

	// Cache-friendly list of sphere intersection data
	SphereInfos [MAX_SPHERES_PER_CONTAINER]scene.SphereIntersectionInfo

	// Less frequently accessed sphere data. This is assumed to have the
	// same length and order as SphereInfos, so that the remaining sphere
	// data corresponding to a certain intersection info can be retrieved using
	// an index into SphereInfos
	SphereRemainders []*scene.TraceableBase

	// Non-spheres (not optimized)
	Objects []*scene.Traceable
}

Back end for spatial data structures: A flat list of traceables, that allows checking against rays. When used directly as tracing Engine, you get the classic "naive ray tracing" algorithm.

func (self *ObjectContainer) FindClosestObject(ray *scene.Ray) (*scene.Traceable, float32)

func (self *ObjectContainer) FindOccluder(ray *scene.Ray, lightDistance float32) bool

func (self *ObjectContainer) Insert(object *scene.Traceable)

type Octree ¶

type Octree struct {
	Root OctreeNode
}

A very naive and unoptimized Octree. This actually uses an AABB per node - normally you wouldn't do that, since there are Octree-specific ray intersection testing/walking algorithms. The placement heuristics are also super simple and not tweaked at all.

I'm planning to replace this with a Kd-Tree anyway

func MakeOctree(bounds scene.AABB) Octree

func (self *Octree) FindClosestObject(ray *scene.Ray) (
	foundObject *scene.Traceable, distance float32,
)

func (self *Octree) FindOccluder(ray *scene.Ray, lightDistance float32) bool

func (self *Octree) InsertObject(object *scene.Traceable)

type OctreeNode ¶

type OctreeNode struct {
	Bounds   scene.AABB
	Children [8]*OctreeNode

	Objects *ObjectContainer
	// contains filtered or unexported fields
}

func MakeNode(bounds scene.AABB) *OctreeNode

func (self *OctreeNode) AddObject(object *scene.Traceable)

func (self *OctreeNode) IsLeaf() bool

func (self *OctreeNode) Split()