ml
95 lines
2.7 KiB
Go
95 lines
2.7 KiB
Go
package graphics
|
|
|
|
import (
|
|
"github.com/inkyblackness/hacked/ss1"
|
|
"github.com/inkyblackness/hacked/ss1/content/bitmap"
|
|
"github.com/inkyblackness/hacked/ss1/resource"
|
|
"github.com/inkyblackness/hacked/ui/opengl"
|
|
)
|
|
|
|
const (
|
|
errReferenceNotFound ss1.StringError = "reference not existing"
|
|
errReferenceWrongDimensions ss1.StringError = "reference has wrong dimensions"
|
|
)
|
|
|
|
// TextureCache loads bitmaps and provides OpenGL textures.
|
|
type TextureCache struct {
|
|
gl opengl.OpenGL
|
|
localizer resource.Localizer
|
|
|
|
textures map[resource.Key]*BitmapTexture
|
|
}
|
|
|
|
// NewTextureCache returns a new instance.
|
|
func NewTextureCache(gl opengl.OpenGL, localizer resource.Localizer) *TextureCache {
|
|
cache := &TextureCache{
|
|
gl: gl,
|
|
localizer: localizer,
|
|
textures: make(map[resource.Key]*BitmapTexture),
|
|
}
|
|
return cache
|
|
}
|
|
|
|
// InvalidateResources lets the cache remove any textures from resources that are specified in the given slice.
|
|
func (cache *TextureCache) InvalidateResources(ids []resource.ID) {
|
|
for _, id := range ids {
|
|
for key, texture := range cache.textures {
|
|
if key.ID == id {
|
|
texture.Dispose()
|
|
delete(cache.textures, key)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Texture returns the texture with given key - if available.
|
|
func (cache *TextureCache) Texture(key resource.Key) (*BitmapTexture, error) {
|
|
return cache.TextureReferenced(key, nil)
|
|
}
|
|
|
|
// TextureReferenced returns the texture with given key - if available.
|
|
// Should the underlying bitmap have to be loaded, then the given reference is taken as a basis for compressed bitmaps.
|
|
// If reference is nil, then no reference is used.
|
|
func (cache *TextureCache) TextureReferenced(key resource.Key, reference *resource.Key) (*BitmapTexture, error) {
|
|
tex, existing := cache.textures[key]
|
|
if existing {
|
|
return tex, nil
|
|
}
|
|
selector := cache.localizer.LocalizedResources(key.Lang)
|
|
view, err := selector.Select(key.ID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if view.ContentType() != resource.Bitmap {
|
|
return nil, resource.ErrWrongType(key, resource.Bitmap)
|
|
}
|
|
reader, err := view.Block(key.Index)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
bmp, err := bitmap.DecodeReferenced(reader, func(width, height int16) ([]byte, error) {
|
|
buf := make([]byte, int(width)*int(height))
|
|
if reference == nil {
|
|
return buf, nil
|
|
}
|
|
refTex, refExisting := cache.textures[*reference]
|
|
if !refExisting {
|
|
return nil, errReferenceNotFound
|
|
}
|
|
refWidth, refHeight := refTex.Size()
|
|
if (int16(refWidth) != width) || (int16(refHeight) != height) {
|
|
return nil, errReferenceWrongDimensions
|
|
}
|
|
copy(buf, refTex.PixelData())
|
|
return buf, nil
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
tex = NewBitmapTexture(cache.gl, int(bmp.Header.Width), int(bmp.Header.Height), bmp.Pixels)
|
|
cache.textures[key] = tex
|
|
|
|
return tex, nil
|
|
}
|