Limit texture size to 8192x8192 pixels

cmd/view-map/main.go

@@ -155,22 +155,22 @@ func (e *env) getSprite(palette []string, ref maps.ObjRef) (*conv.Sprite, error)
 		return nil, fmt.Errorf("Out-of-index sprite %v requested for %v", ref.Sprite(), name)
 	}
 
-	return &obj.Sprites[ref.Sprite()], nil
+	return obj.Sprites[ref.Sprite()], nil
 }
 
 func (s *state) present(pWin *pixelgl.Window) {
 	pWin.Clear(colornames.Black)
 	s.env.batch.Clear()
-	/*
+
 	center := pWin.Bounds().Center()
 
 	cam := pixel.IM
 	cam = cam.ScaledXY(center, pixel.Vec{1.0, -1.0}) // invert the Y axis
-		cam = cam.Scaled(pixel.ZV, s.zoom)               // apply current zoom factor
+	cam = cam.Scaled(center, s.zoom)                 // apply current zoom factor
 	cam = cam.Moved(center.Sub(s.camPos))            // Make it central
 	s.cam = cam
 	pWin.SetMatrix(cam)
-	*/
+
 	// TODO: we should be able to perform bounds clipping on these
 	minX := int(s.env.gameMap.MinWidth)
 	maxX := int(s.env.gameMap.MaxWidth)
@@ -191,32 +191,32 @@ func (s *state) present(pWin *pixelgl.Window) {
 	pWin.Update()
 }
 
-func (s *state) renderCell(x, y, z int, batch *pixel.Batch) {
+func (s *state) renderCell(x, y, z int, target pixel.Target) {
 	var sprites []*conv.Sprite
 
 	cell := s.env.gameMap.Cells.At(x, y, z)
 
 	if spr, err := s.env.getSprite(s.env.set.Palette, cell.Surface); err != nil {
 		log.Printf("%v %v %v surface: %v", x, y, z, err)
-	} else {
+	} else if spr != nil {
 		sprites = append(sprites, spr)
 	}
 
 	if spr, err := s.env.getSprite(s.env.set.Palette, cell.Center); err != nil {
 		log.Printf("%v %v %v center: %v", x, y, z, err)
-	} else {
+	} else if spr != nil {
 		sprites = append(sprites, spr)
 	}
 
 	if spr, err := s.env.getSprite(s.env.set.Palette, cell.Left); err != nil {
 		log.Printf("%v %v %v left: %v", x, y, z, err)
-	} else {
+	} else if spr != nil {
 		sprites = append(sprites, spr)
 	}
 
 	if spr, err := s.env.getSprite(s.env.set.Palette, cell.Right); err != nil {
 		log.Printf("%v %v %v right: %v", x, y, z, err)
-	} else {
+	} else if spr != nil {
 		sprites = append(sprites, spr)
 	}
 
@@ -228,9 +228,7 @@ func (s *state) renderCell(x, y, z int, batch *pixel.Batch) {
 	iso := s.cellToPix(pixel.V(fX, fY))
 
 	for _, sprite := range sprites {
-		if sprite != nil {
+		sprite.Spr.Draw(target, pixel.IM.Moved(iso))
-			sprite.Spr.Draw(batch, pixel.IM.Moved(iso))
-		}
 	}
 }
 
@@ -271,9 +269,12 @@ func (s *state) handleKeys(pWin *pixelgl.Window) {
 			log.Printf("WARNING: z-index not yet taken into account")
 		}
 
+		log.Printf("cam: %#v", s.cam)
+
 		pos := s.pixToCell(s.cam.Unproject(pWin.MousePosition()))
-		cell := s.env.gameMap.Cells.At(int(pos.X), int(pos.Y), s.zIdx)
 		log.Printf("X=%v Y=%v, zIdx=%v", pos.X, pos.Y, s.zIdx)
+
+		cell := s.env.gameMap.Cells.At(int(pos.X), int(pos.Y), s.zIdx)
 		log.Printf("Cell=%#v", cell)
 	}
 

cmd/view-set/main.go

@@ -122,23 +122,19 @@ func (s *state) present(pWin *pixelgl.Window) {
 	obj := s.curObject()
 	sprite := obj.Sprites[s.spriteIdx]
 
+	pWin.Clear(colornames.Black)
+	s.env.batch.Clear()
+
 	center := pWin.Bounds().Center()
 
 	cam := pixel.IM
 	cam = cam.ScaledXY(center, pixel.Vec{1.0, -1.0}) // invert the Y axis
 	cam = cam.Scaled(center, s.zoom)                 // apply current zoom factor
-	//cam = cam.Moved(center.Sub(s.camPos))           // Make it central
-	//cam = cam.Rotated(center, -0.785) // Apply isometric angle
 	s.cam = cam
 	pWin.SetMatrix(s.cam)
 
-	pWin.Clear(colornames.Black)
-	s.env.batch.Clear()
-
 	sprite.Spr.Draw(s.env.batch, pixel.IM.Moved(center))
-	//pixel.NewSprite(sprite.Pic, sprite.Pic.Bounds()).Draw(pWin, pixel.IM.Moved(center))
 	s.env.batch.Draw(pWin)
-	pWin.Update()
 }
 
 func (s *state) handleKeys(pWin *pixelgl.Window) {
@@ -174,6 +170,5 @@ func (s *state) handleKeys(pWin *pixelgl.Window) {
 
 func (s *state) curObject() *conv.Object {
 	name := s.env.set.Palette[s.objIdx]
-	//log.Printf("name: %v, objects: %#v", name, s.env.objects)
 	return s.env.objects[name]
 }

internal/conv/object.go

@@ -3,16 +3,20 @@ package conv
 import (
 	"fmt"
 	"image/color"
-	"image/png"
 	"log"
-	"os"
 
 	"github.com/faiface/pixel"
 
 	"ur.gs/ordoor/internal/data"
 )
 
-var transparent = color.RGBA{0, 0, 0, 0}
+const (
+	// Textures can be this size at most. So putting every sprite onto the same
+	// sheet is a fraught business. With effective packing, it may be fine.
+	// If not, I'll have to come up with another idea
+	maxTextureX = 8192
+	maxTextureY = 8192
+)
 
 // Important conversions:
 //
@@ -28,86 +32,73 @@ type Sprite struct {
 
 type Object struct {
 	Name    string
-	Sprites []Sprite
+	Sprites []*Sprite
-}
-
-func maxWidth(obj *data.Object) int {
-	out := 0
-
-	for _, spr := range obj.Sprites {
-		width := int(spr.Width)
-		if width > out {
-			out = width
-		}
-	}
-
-	return out
-}
-
-func fullHeight(obj *data.Object) int {
-	out := 0
-
-	for _, spr := range obj.Sprites {
-		out = out + int(spr.Height)
-	}
-
-	return out
 }
 
 func ConvertObjects(objects []*data.Object) (map[string]*Object, *pixel.PictureData) {
-	// This needs to be the maxWidth of all the objects, added together
+	// FIXME: this is rather inefficient. It would be better to determine the
-	maxX := 0
+	// maximum size we need for the objects at hand.
-	for _, obj := range objects {
+	spritesheet := pixel.MakePictureData(
-		maxX = maxX + maxWidth(obj)
+		pixel.R(0.0, 0.0, float64(maxTextureX), float64(maxTextureY)),
-	}
+	)
-
-	// This needs to be the largest fullHeight of all the objects
-	maxY := 0
-	for _, obj := range objects {
-		height := fullHeight(obj)
-		if height > maxY {
-			maxY = height
-		}
-	}
 
+	// These are updated each time a sprite is added to the sheet
 	xOffset := 0
-	spritesheet := pixel.MakePictureData(pixel.R(0.0, 0.0, float64(maxX), float64(maxY)))
+	yOffset := 0
+	rowMaxY := 0
 
 	out := make(map[string]*Object)
+
 	for _, rawObj := range objects {
-		log.Println("xOffset:", xOffset)
+		sprites := make([]*Sprite, 0, len(rawObj.Sprites))
-		cObj := ConvertObjectWithSpritesheet(rawObj, rawObj.Name, spritesheet, xOffset)
+
-		xOffset = xOffset + maxWidth(rawObj)
+		for i, rawSpr := range rawObj.Sprites {
-		out[cObj.Name] = cObj
+			width := int(rawSpr.Width)
+			height := int(rawSpr.Height)
+
+			// CR+LF if needed
+			if xOffset+width > maxTextureX {
+				xOffset = 0
+				yOffset += rowMaxY
 			}
 
-	f, _ := os.Create("spritesheet.png")
+			if xOffset+width > maxTextureX || yOffset+height > maxTextureY {
-	img := spritesheet.Image()
+				panic("Sprite does not fit in spritesheet")
-	png.Encode(f, img)
+			}
-	f.Close()
+
+			spr := spriteToPic(rawObj.Name, i, rawSpr, spritesheet, xOffset, yOffset)
+			sprites = append(sprites, &Sprite{width, height, spritesheet, spr})
+
+			xOffset = xOffset + width
+			if height > rowMaxY {
+				rowMaxY = height
+			}
+		}
+
+		out[rawObj.Name] = &Object{Name: rawObj.Name, Sprites: sprites}
+	}
 
 	return out, spritesheet
 }
 
 func ConvertObjectWithSpritesheet(rawObj *data.Object, name string, pic *pixel.PictureData, xOffset int) *Object {
-	out := &Object{
-		Name:    name,
-		Sprites: make([]Sprite, len(rawObj.Sprites)),
-	}
-
 	// We store the sprites vertically in the provided pic
 	yOffset := 0
-	log.Printf("Converting %v: xOffset = %v", name, xOffset)
+
+	out := &Object{
+		Name:    name,
+		Sprites: make([]*Sprite, len(rawObj.Sprites)),
+	}
 
 	for i, rawSpr := range rawObj.Sprites {
 		spr := spriteToPic(name, i, rawSpr, pic, xOffset, yOffset)
-		log.Printf("	%#v", spr.Frame())
+		out.Sprites[i] = &Sprite{
-		out.Sprites[i] = Sprite{
 			Width:  int(rawSpr.Width),
 			Height: int(rawSpr.Height),
 			Pic:    pic,
 			Spr:    spr,
 		}
+
 		yOffset = yOffset + int(rawSpr.Height)
 	}
 
@@ -117,7 +108,7 @@ func ConvertObjectWithSpritesheet(rawObj *data.Object, name string, pic *pixel.P
 func ConvertObject(rawObj *data.Object, name string) *Object {
 	out := &Object{
 		Name:    name,
-		Sprites: make([]Sprite, len(rawObj.Sprites)),
+		Sprites: make([]*Sprite, len(rawObj.Sprites)),
 	}
 
 	for i, rawSpr := range rawObj.Sprites {
@@ -131,7 +122,7 @@ func ConvertObject(rawObj *data.Object, name string) *Object {
 		)
 		spr := spriteToPic(name, i, rawSpr, pic, 0, 0)
 
-		out.Sprites[i] = Sprite{
+		out.Sprites[i] = &Sprite{
 			Width:  int(rawSpr.Width),
 			Height: int(rawSpr.Height),
 			Pic:    pic,
@@ -146,20 +137,17 @@ func spriteToPic(name string, idx int, sprite *data.Sprite, pic *pixel.PictureDa
 	width := int(sprite.Width)
 	height := int(sprite.Height)
 
-	//log.Printf("%v %v: width=%v height=%v", name, idx, width, height)
-
 	for y := 0; y < height; y++ {
 		for x := 0; x < width; x++ {
 			b := sprite.Data[y*width+x]
 
 			// Update the picture
 			if err := setPaletteColor(pic, x+xOffset, y+yOffset, b); err != nil {
-				//log.Printf("%s %d: %d,%d: %v", name, idx, x, y, err)
+				log.Printf("%s %d: %d,%d: %v", name, idx, x, y, err)
 			}
 		}
 	}
 
-	// FIXME: I really don't get this fetish for starting at the bottom-left
 	bounds := pixel.R(
 		float64(xOffset),
 		float64(yOffset),
@@ -167,9 +155,6 @@ func spriteToPic(name string, idx int, sprite *data.Sprite, pic *pixel.PictureDa
 		float64(yOffset+height),
 	)
 
-	//bounds.Min = bounds.Min.ScaledXY(pixel.Vec{1.0, -1.0})
-	//bounds.Max = bounds.Max.ScaledXY(pixel.Vec{1.0, -1.0})
-
 	return pixel.NewSprite(pic, bounds)
 }