110 lines
2.3 KiB
Go
110 lines
2.3 KiB
Go
// SPDX-License-Identifier: Unlicense OR MIT
|
|
|
|
package gpu
|
|
|
|
import (
|
|
"image"
|
|
)
|
|
|
|
// packer packs a set of many smaller rectangles into
|
|
// much fewer larger atlases.
|
|
type packer struct {
|
|
maxDims image.Point
|
|
spaces []image.Rectangle
|
|
|
|
sizes []image.Point
|
|
pos image.Point
|
|
}
|
|
|
|
type placement struct {
|
|
Idx int
|
|
Pos image.Point
|
|
}
|
|
|
|
// add adds the given rectangle to the atlases and
|
|
// return the allocated position.
|
|
func (p *packer) add(s image.Point) (placement, bool) {
|
|
if place, ok := p.tryAdd(s); ok {
|
|
return place, true
|
|
}
|
|
p.newPage()
|
|
return p.tryAdd(s)
|
|
}
|
|
|
|
func (p *packer) clear() {
|
|
p.sizes = p.sizes[:0]
|
|
p.spaces = p.spaces[:0]
|
|
}
|
|
|
|
func (p *packer) newPage() {
|
|
p.pos = image.Point{}
|
|
p.sizes = append(p.sizes, image.Point{})
|
|
p.spaces = p.spaces[:0]
|
|
p.spaces = append(p.spaces, image.Rectangle{
|
|
Max: image.Point{X: 1e6, Y: 1e6},
|
|
})
|
|
}
|
|
|
|
func (p *packer) tryAdd(s image.Point) (placement, bool) {
|
|
if len(p.spaces) == 0 || len(p.sizes) == 0 {
|
|
return placement{}, false
|
|
}
|
|
|
|
var (
|
|
bestIdx *image.Rectangle
|
|
bestSize = p.maxDims
|
|
lastSize = p.sizes[len(p.sizes)-1]
|
|
)
|
|
// Go backwards to prioritize smaller spaces.
|
|
for i := range p.spaces {
|
|
space := &p.spaces[i]
|
|
rightSpace := space.Dx() - s.X
|
|
bottomSpace := space.Dy() - s.Y
|
|
if rightSpace < 0 || bottomSpace < 0 {
|
|
continue
|
|
}
|
|
size := lastSize
|
|
if x := space.Min.X + s.X; x > size.X {
|
|
if x > p.maxDims.X {
|
|
continue
|
|
}
|
|
size.X = x
|
|
}
|
|
if y := space.Min.Y + s.Y; y > size.Y {
|
|
if y > p.maxDims.Y {
|
|
continue
|
|
}
|
|
size.Y = y
|
|
}
|
|
if size.X*size.Y < bestSize.X*bestSize.Y {
|
|
bestIdx = space
|
|
bestSize = size
|
|
}
|
|
}
|
|
if bestIdx == nil {
|
|
return placement{}, false
|
|
}
|
|
// Remove space.
|
|
bestSpace := *bestIdx
|
|
*bestIdx = p.spaces[len(p.spaces)-1]
|
|
p.spaces = p.spaces[:len(p.spaces)-1]
|
|
// Put s in the top left corner and add the (at most)
|
|
// two smaller spaces.
|
|
pos := bestSpace.Min
|
|
if rem := bestSpace.Dy() - s.Y; rem > 0 {
|
|
p.spaces = append(p.spaces, image.Rectangle{
|
|
Min: image.Point{X: pos.X, Y: pos.Y + s.Y},
|
|
Max: image.Point{X: bestSpace.Max.X, Y: bestSpace.Max.Y},
|
|
})
|
|
}
|
|
if rem := bestSpace.Dx() - s.X; rem > 0 {
|
|
p.spaces = append(p.spaces, image.Rectangle{
|
|
Min: image.Point{X: pos.X + s.X, Y: pos.Y},
|
|
Max: image.Point{X: bestSpace.Max.X, Y: pos.Y + s.Y},
|
|
})
|
|
}
|
|
idx := len(p.sizes) - 1
|
|
p.sizes[idx] = bestSize
|
|
return placement{Idx: idx, Pos: pos}, true
|
|
}
|