Extract tileset caching into own loader

this commit also introduces an optional
experimental interface to clean unused resource

Author: sharpner

renderer.go

@@ -22,7 +22,7 @@ type fullRenderer struct {
 //NewRenderer lets you draw the map on a custom canvas
 //with a default FilesystemLocator
 func NewRenderer(m Map, c Canvas) Renderer {
-	return NewRendererWithResourceLocator(m, c, FilesystemLocator{})
+	return NewRendererWithResourceLocator(m, c, NewLazyResourceLocator(FilesystemLocator{}))
 }
 
 //NewRendererWithResourceLocator return a new renderer
@@ -32,7 +32,7 @@ func NewRendererWithResourceLocator(m Map, c Canvas, locator ResourceLocator) Re
 
 //Render will generate a preview image of the tmx map provided
 func (r fullRenderer) Render() error {
-	canvas := tilemap{subject: r.m, tilesets: map[string]image.Image{}}
+	canvas := tilemap{subject: r.m}
 	canvas.renderBackground(r)
 	err := canvas.renderLayer(r)
 	if err != nil {
@@ -43,8 +43,7 @@ func (r fullRenderer) Render() error {
 }
 
 type tilemap struct {
-	subject  Map
-	tilesets map[string]image.Image
+	subject Map
 }
 
 type subImager interface {
@@ -57,18 +56,6 @@ func (t tilemap) renderBackground(r fullRenderer) {
 }
 
 func (t *tilemap) renderLayer(r fullRenderer) error {
-	for _, tileset := range t.subject.Tilesets {
-		path := tileset.Image.Source
-
-		tileset, err := r.loader.LocateResource(filepath.Clean(t.subject.filename + path))
-
-		if err != nil {
-			return err
-		}
-
-		t.tilesets[path] = tileset
-	}
-
 	for _, l := range t.subject.Layers {
 		if !l.IsVisible() {
 			continue
@@ -89,8 +76,8 @@ func (t *tilemap) renderLayer(r fullRenderer) error {
 			tx *= t.subject.TileWidth
 			ty *= t.subject.TileHeight
 
-			tilesetgfx, found := t.tilesets[tileset.Image.Source]
-			if !found {
+			tilesetgfx, err := r.loader.LocateResource(filepath.Clean(t.subject.filename + tileset.Image.Source))
+			if err != nil {
 				panic("invalid tileset path")
 			}
 

resource.go

@@ -18,6 +18,12 @@ type ResourceLocator interface {
 	LocateResource(filepath string) (image.Image, error)
 }
 
+//ResourceManager allows better memory handling
+//and cleanup of resources
+type ResourceManager interface {
+	UnsetResource(filepath string)
+}
+
 //FilesystemLocator loads files simply from the filesystem
 //it supports png, jpeg and non animated gifs
 type FilesystemLocator struct {
@@ -33,3 +39,33 @@ func (f FilesystemLocator) LocateResource(filepath string) (image.Image, error)
 	data, _, err := image.Decode(file)
 	return data, err
 }
+
+type lazyLocator struct {
+	parent   ResourceLocator
+	tilesets map[string]image.Image
+}
+
+func (l *lazyLocator) LocateResource(filepath string) (image.Image, error) {
+	cached, ok := l.tilesets[filepath]
+	if ok {
+		return cached, nil
+	}
+
+	data, err := l.parent.LocateResource(filepath)
+	if err != nil {
+		return nil, err
+	}
+
+	l.tilesets[filepath] = data
+
+	return data, nil
+}
+
+func (l *lazyLocator) UnsetResource(filepath string) {
+	delete(l.tilesets, filepath)
+}
+
+//NewLazyResourceLocator wraps a ResourceLocator and caches results
+func NewLazyResourceLocator(l ResourceLocator) ResourceLocator {
+	return &lazyLocator{parent: l, tilesets: map[string]image.Image{}}
+}

resource_test.go

@@ -1,7 +1,10 @@
 package tmx_test
 
 import (
+	"errors"
 	"image"
+	"io"
+	"os"
 
 	. "github.com/manyminds/tmx"
 	. "github.com/onsi/ginkgo"
@@ -15,6 +18,21 @@ func (m nilResourceLoader) LocateResource(filepath string) (image.Image, error)
 	return nil, nil
 }
 
+type moduloErrorResourceLoader struct {
+	callCount int
+}
+
+var errAlreadyLoaded = errors.New("Already loaded")
+
+func (m *moduloErrorResourceLoader) LocateResource(filepath string) (image.Image, error) {
+	m.callCount++
+	if m.callCount%2 == 0 {
+		return nil, errAlreadyLoaded
+	}
+
+	return nil, nil
+}
+
 var _ = Describe("Test public api", func() {
 	Context("check types for interface interface", func() {
 		It("can be implemented", func() {
@@ -36,5 +54,54 @@ var _ = Describe("Test public api", func() {
 			_, err := loader.LocateResource("/null")
 			Expect(err).To(HaveOccurred())
 		})
+
+		It("will find a testfile", func() {
+			loader := FilesystemLocator{}
+			_, err := loader.LocateResource("testfiles/chipset.png")
+			Expect(err).ToNot(HaveOccurred())
+		})
+	})
+
+	Context("test lazy resource locator", func() {
+		BeforeEach(func() {
+			c, err := os.Open("testfiles/chipset.png")
+			Expect(err).ToNot(HaveOccurred())
+			t, err := os.Create("testfiles/chipset_copy.png")
+			Expect(err).ToNot(HaveOccurred())
+			_, err = io.Copy(t, c)
+			Expect(err).ToNot(HaveOccurred())
+		})
+
+		AfterEach(func() {
+			os.Remove("testfiles/chipset_copy.png")
+		})
+
+		It("caches files even after remove", func() {
+			loader := NewLazyResourceLocator(FilesystemLocator{})
+			img, err := loader.LocateResource("testfiles/chipset_copy.png")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(img).ToNot(BeNil())
+			err = os.Remove("testfiles/chipset_copy.png")
+			Expect(err).ToNot(HaveOccurred())
+			img, err = loader.LocateResource("testfiles/chipset_copy.png")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(img).ToNot(BeNil())
+
+			manager, ok := loader.(ResourceManager)
+			Expect(ok).To(BeTrue())
+			manager.UnsetResource("testfiles/chipset_copy.png")
+			img, err = loader.LocateResource("testfiles/chipset_copy.png")
+			Expect(err).To(HaveOccurred())
+			Expect(img).To(BeNil())
+		})
+
+		It("will only load a specific resource once", func() {
+			loader := &moduloErrorResourceLoader{}
+			lazyLoader := NewLazyResourceLocator(loader)
+			_, err := lazyLoader.LocateResource("lol")
+			Expect(err).ToNot(HaveOccurred())
+			_, err = lazyLoader.LocateResource("lol")
+			Expect(err).ToNot(HaveOccurred())
+		})
 	})
 })