ordoor/internal/conv/object.go

package conv

import (
	"fmt"
	"image/color"
	"log"

	"github.com/faiface/pixel"

	"ur.gs/ordoor/internal/data"
)

// Important conversions:
//
//   * Width & height now stored using int
//   * Colour data is now 32-bit rather than using a palette
type Sprite struct {
	Width  int
	Height int

	Pic *pixel.PictureData
	Spr *pixel.Sprite
}

type Object struct {
	Name    string
	Sprites []Sprite
}

func ConvertObject(rawObj *data.Object, name string) *Object {
	out := &Object{
		Name:    name,
		Sprites: make([]Sprite, len(rawObj.Sprites)),
	}

	for i, rawSpr := range rawObj.Sprites {
		pic := spriteToPic(name, i, rawSpr)
		out.Sprites[i] = Sprite{
			Width:  int(rawSpr.Width),
			Height: int(rawSpr.Height),
			Pic:    pic,
			Spr:    pixel.NewSprite(pic, pic.Bounds()),
		}
	}

	return out
}

var transparent = color.RGBA{0, 0, 0, 0}

// WIP. Try to convert the pixeldata into a picture.
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)))

	log.Printf("%v %v: width=%v height=%v", name, idx, sprite.Width, sprite.Height)

	for y := 0; y < int(sprite.Height); y++ {
		encoded := sprite.Rows[y]
		decoded := make([]byte, 0, int(sprite.Width))

		// Start with all bytes transparent
		for x := 0; x < int(sprite.Width); x++ {
			pic.Pix[pic.Index(pixel.V(float64(x), float64(y)))] = transparent
		}

		for i := 0; i < len(encoded); i++ {
			b := encoded[i]

			// This appears to be a kind of RLE
			if b == 0 {
				continue // finished
			} else if b < 0x80 {
				// repeat the next byte this many times
				for j := 0; j < int(b); j++ {
					decoded = append(decoded, encoded[i+1])
				}

				i++ // skip the repeat byte
			} else if b == 0x80 {
				// transparent value, skip forward *x+1 rows
				skip := int(encoded[i+1])
				for i := 0; i < skip; i++ {
					decoded = append(decoded, byte(0x00))
				}

				i++ // skip the count byte
			} else {
				// take the next b-0x80 bytes literally
				literals := int(b) - 0x80
				for j := i + 1; j <= i+literals; j++ {
					decoded = append(decoded, encoded[j])
				}

				i = i + literals
			}
		}

		// Update the picture
		for x, b := range decoded {
			if err := setPaletteColor(pic, x, y, b); err != nil {
				log.Printf("%s %d: %d,%d: %v", name, idx, x, y, err)
			}
		}
	}

	return pic
}

func setPaletteColor(pic *pixel.PictureData, x int, y int, colorIdx byte) error {
	vec := pixel.V(float64(x), float64(y))
	idx := pic.Index(vec)

	if idx > len(pic.Pix)-1 {
		return fmt.Errorf("Got index %v which exceeds bounds", idx)
	}

	r, g, b, a := data.ColorPalette[int(colorIdx)].RGBA()
	color := color.RGBA{uint8(r), uint8(g), uint8(b), uint8(a)}

	pic.Pix[idx] = color
	return nil
}