lupine/ordoor
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

WIP: Speed up rendering by using a spritesheet

Browse Source
This commit is contained in:
Nick Thomas
2018-10-12 23:02:24 +01:00
parent aa093faabc
commit 1fa61c72c2
4 changed files with 152 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
cmd/view-map/main.go
View File

@@ -31,6 +31,7 @@ type env struct {
set *sets.MapSet
objects map[string]*conv.Object
sprites map[string][]*pixel.Sprite
batch *pixel.Batch
}
type state struct {
@@ -68,8 +69,7 @@ func main() {
log.Fatalf("Couldn't load set file %s: %v", setFile, err)
}
objects := make(map[string]*conv.Object)
rawObjs := []*data.Object{}
for _, name := range mapSet.Palette {
objFile := filepath.Join(*gamePath, "Obj", name+".obj")
obj, err := data.LoadObject(objFile)
@@ -77,13 +77,18 @@ func main() {
log.Fatalf("Failed to load %s: %v", name, err)
}
objects[name] = conv.ConvertObject(obj, name)
obj.Name = name
rawObjs = append(rawObjs, obj)
}
objects, spritesheet := conv.ConvertObjects(rawObjs)
batch := pixel.NewBatch(&pixel.TrianglesData{}, spritesheet)
env := &env{
gameMap: gameMap,
set: mapSet,
objects: objects,
batch: batch,
}
// The main thread now belongs to pixelgl
@@ -153,21 +158,19 @@ func (e *env) getSprite(palette []string, ref maps.ObjRef) (*conv.Sprite, error)
return &obj.Sprites[ref.Sprite()], nil
}
// TODO: build all the sprites in the set into a single spritesheet so we can
// use pixel.Batch
func (s *state) present(pWin *pixelgl.Window) {
pWin.Clear(colornames.Black)
s.env.batch.Clear()
/*
center := pWin.Bounds().Center()
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.Moved(center.Sub(s.camPos)) // Make it central
// cam = cam.Rotated(center.Sub(s.camPos), s.rot) // Apply isometric angle
s.cam = cam
pWin.SetMatrix(cam)
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.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)
@@ -179,13 +182,16 @@ func (s *state) present(pWin *pixelgl.Window) {
for z := minZ; z < maxZ; z++ {
for y := minY; y < maxY; y++ {
for x := minX; x < maxX; x++ {
s.renderCell(x, y, z, pWin)
s.renderCell(x, y, z, s.env.batch)
}
}
}
s.env.batch.Draw(pWin)
pWin.Update()
}
func (s *state) renderCell(x, y, z int, pWin *pixelgl.Window) {
func (s *state) renderCell(x, y, z int, batch *pixel.Batch) {
var sprites []*conv.Sprite
cell := s.env.gameMap.Cells.At(x, y, z)
@@ -223,7 +229,7 @@ func (s *state) renderCell(x, y, z int, pWin *pixelgl.Window) {
for _, sprite := range sprites {
if sprite != nil {
sprite.Spr.Draw(pWin, pixel.IM.Moved(iso))
sprite.Spr.Draw(batch, pixel.IM.Moved(iso))
}
}
}

21
cmd/view-set/main.go
View File

@@ -25,6 +25,7 @@ var (
type env struct {
set *sets.MapSet
objects map[string]*conv.Object
batch *pixel.Batch
}
type state struct {
@@ -53,19 +54,22 @@ func main() {
log.Fatalf("Couldn't load set file %s: %v", *setFile, err)
}
objects := make(map[string]*conv.Object)
rawObjs := []*data.Object{}
for _, name := range mapSet.Palette {
objFile := filepath.Join(*gamePath, "Obj", name+".obj")
obj, err := data.LoadObject(objFile)
if err != nil {
log.Fatalf("Failed to load %s: %v", name, err)
}
obj.Name = name
objects[name] = conv.ConvertObject(obj, name)
rawObjs = append(rawObjs, obj)
}
env := &env{objects: objects, set: mapSet}
objects, spritesheet := conv.ConvertObjects(rawObjs)
batch := pixel.NewBatch(&pixel.TrianglesData{}, spritesheet)
env := &env{objects: objects, set: mapSet, batch: batch}
// The main thread now belongs to pixelgl
pixelgl.Run(env.run)
@@ -129,7 +133,12 @@ func (s *state) present(pWin *pixelgl.Window) {
pWin.SetMatrix(s.cam)
pWin.Clear(colornames.Black)
pixel.NewSprite(sprite.Pic, sprite.Pic.Bounds()).Draw(pWin, pixel.IM.Moved(center))
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) {
@@ -165,6 +174,6 @@ 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)
//log.Printf("name: %v, objects: %#v", name, s.env.objects)
return s.env.objects[name]
}

120
internal/conv/object.go
View File

@@ -3,7 +3,9 @@ package conv
import (
"fmt"
"image/color"
"image/png"
"log"
"os"
"github.com/faiface/pixel"
@@ -29,6 +31,89 @@ type Object struct {
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
maxX := 0
for _, obj := range objects {
maxX = maxX + maxWidth(obj)
}
// 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
}
}
xOffset := 0
spritesheet := pixel.MakePictureData(pixel.R(0.0, 0.0, float64(maxX), float64(maxY)))
out := make(map[string]*Object)
for _, rawObj := range objects {
log.Println("xOffset:", xOffset)
cObj := ConvertObjectWithSpritesheet(rawObj, rawObj.Name, spritesheet, xOffset)
xOffset = xOffset + maxWidth(rawObj)
out[cObj.Name] = cObj
}
f, _ := os.Create("spritesheet.png")
img := spritesheet.Image()
png.Encode(f, img)
f.Close()
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)
for i, rawSpr := range rawObj.Sprites {
spr := spriteToPic(name, i, rawSpr, pic, xOffset, yOffset)
log.Printf(" %#v", spr.Frame())
out.Sprites[i] = Sprite{
Width: int(rawSpr.Width),
Height: int(rawSpr.Height),
Pic: pic,
Spr: spr,
}
yOffset = yOffset + int(rawSpr.Height)
}
return out
}
func ConvertObject(rawObj *data.Object, name string) *Object {
out := &Object{
Name: name,
@@ -36,37 +121,56 @@ func ConvertObject(rawObj *data.Object, name string) *Object {
}
for i, rawSpr := range rawObj.Sprites {
pic := spriteToPic(name, i, rawSpr)
pic := pixel.MakePictureData(
pixel.R(
float64(0),
float64(0),
float64(rawSpr.Width),
float64(rawSpr.Height),
),
)
spr := spriteToPic(name, i, rawSpr, pic, 0, 0)
out.Sprites[i] = Sprite{
Width: int(rawSpr.Width),
Height: int(rawSpr.Height),
Pic: pic,
Spr: pixel.NewSprite(pic, pic.Bounds()),
Spr: spr,
}
}
return out
}
func spriteToPic(name string, idx int, sprite *data.Sprite) *pixel.PictureData {
pic := pixel.MakePictureData(pixel.R(float64(0), float64(0), float64(sprite.Width), float64(sprite.Height)))
func spriteToPic(name string, idx int, sprite *data.Sprite, pic *pixel.PictureData, xOffset, yOffset int) *pixel.Sprite {
width := int(sprite.Width)
height := int(sprite.Height)
log.Printf("%v %v: width=%v height=%v", name, idx, width, 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, y, b); err != nil {
log.Printf("%s %d: %d,%d: %v", name, idx, x, y, err)
if err := setPaletteColor(pic, x+xOffset, y+yOffset, b); err != nil {
//log.Printf("%s %d: %d,%d: %v", name, idx, x, y, err)
}
}
}
return pic
// FIXME: I really don't get this fetish for starting at the bottom-left
bounds := pixel.R(
float64(xOffset),
float64(yOffset),
float64(xOffset+width),
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)
}
func setPaletteColor(pic *pixel.PictureData, x int, y int, colorIdx byte) error {

1
internal/data/object.go
View File

@@ -80,6 +80,7 @@ type Object struct {
ObjectHeader
Filename string
Name string // left blank for use by you
Sprites []*Sprite
}