collision.go

// molecular is a 3D physics engine written in Go
// Copyright (C) 2023  Kevin Z <zyxkad@gmail.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

package molecular

import (
	"sync"
)

func (e *Engine) appendObjsInsideRange(objs []*Object, pos Vec3, radius float64) []*Object {
	radius2 := radius * radius
	for _, o := range e.objects {
		if o.AbsPos().Subbed(pos).SqLen() <= radius2 {
			objs = append(objs, o)
		}
	}
	return objs
}

func (e *Engine) appendObjsInsideRing(objs []*Object, pos Vec3, minR, maxR float64) []*Object {
	minR2 := minR * minR
	maxR2 := maxR * maxR
	for _, o := range e.objects {
		l := o.AbsPos().Subbed(pos).SqLen()
		if minR2 <= l && l <= maxR2 {
			objs = append(objs, o)
		}
	}
	return objs
}

type blockCollisionRecord struct {
	A, B Block
	Area Cube
}

// blockCollision check the fine collision between two objects' blocks
// hitarea is the relative area from "a" to "o"
func (o *Object) checkBlockCollisions(a *Object, hitarea *Cube) (records []*blockCollisionRecord) {
	obox := o.innerHitbox.Clone()
	obox.P.Add(hitarea.P)
	if !obox.Overlap(a.innerHitbox) {
		return
	}
	var ablocks []Block
	for _, d := range a.blocks {
		if d.Outline().Overlap(hitarea) {
			ablocks = append(ablocks, d)
		}
	}
	for _, b := range o.blocks {
		cubeB := b.Outline()
		if !cubeB.Overlap(hitarea) {
			continue
		}
		cubeB = cubeB.Clone()
		cubeB.P.Add(hitarea.P)
		for _, d := range ablocks {
			var rec blockCollisionRecord
			if cubeB.OverlapBox(d.Outline(), &rec.Area) {
				rec.A = b
				rec.B = d
				records = append(records, &rec)
			}
		}
	}
	return
}

type objCollisionRecord struct {
	A, B   *Object
	Blocks []*blockCollisionRecord
}

func (e *Engine) sendCollisionObjects(wg *sync.WaitGroup, ch chan<- *objCollisionRecord, a, b *Object, bpos Vec3) {
	defer wg.Done()
	for i, p := range a.children {
		pbox := p.outerHitbox.Clone()
		pbox.P.Add(bpos)
		for _, q := range b.children[i+1:] {
			var area Cube
			if pbox.OverlapBox(q.outerHitbox, &area) {
				wg.Add(1)
				go e.sendCollisionObjects(wg, ch, p, q, pbox.P.Subbed(q.outerHitbox.P))
				records := p.checkBlockCollisions(q, &area)
				if len(records) > 0 {
					ch <- &objCollisionRecord{
						A:      p,
						B:      q,
						Blocks: records,
					}
				}
			}
		}
	}
}