123 lines
2.7 KiB
Go
123 lines
2.7 KiB
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
|
|
}
|