128 lines
2.5 KiB
Go
128 lines
2.5 KiB
Go
package dc6
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/binary"
|
|
"io"
|
|
)
|
|
|
|
const (
|
|
FlagIsSerialized = 1 << iota
|
|
FlagIsLoadedInHw
|
|
FlagIs24Bits
|
|
)
|
|
|
|
type FileHeader struct {
|
|
Version uint32
|
|
Flags uint32
|
|
Format uint32
|
|
SkipColor uint32
|
|
DirCount uint32
|
|
FramesPerDir uint32
|
|
}
|
|
|
|
type FrameHeader struct {
|
|
Flip uint32
|
|
Width uint32
|
|
Height uint32
|
|
OffsetX uint32
|
|
OffsetY uint32
|
|
AllocSize uint32
|
|
NextBlock uint32
|
|
Length uint32
|
|
}
|
|
|
|
type Frame struct {
|
|
Width int
|
|
Height int
|
|
OffsetX int
|
|
OffsetY int
|
|
Data []byte
|
|
}
|
|
|
|
type Dc6 struct {
|
|
Frames []Frame
|
|
}
|
|
|
|
func New(reader io.ReadSeeker) (*Dc6, error) {
|
|
sprite := new(Dc6)
|
|
|
|
var fileHeader FileHeader
|
|
if err := binary.Read(reader, binary.LittleEndian, &fileHeader); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var frameOffsets []uint32
|
|
for i := 0; i < int(fileHeader.DirCount*fileHeader.FramesPerDir); i++ {
|
|
var frameOffset uint32
|
|
if err := binary.Read(reader, binary.LittleEndian, &frameOffset); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
frameOffsets = append(frameOffsets, frameOffset)
|
|
}
|
|
|
|
for _, frameOffset := range frameOffsets {
|
|
var frameHeader FrameHeader
|
|
if _, err := reader.Seek(int64(frameOffset), io.SeekStart); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := binary.Read(reader, binary.LittleEndian, &frameHeader); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
buff := bytes.NewBuffer(make([]byte, frameHeader.Width*frameHeader.Height))
|
|
// if err := extractFrame(reader, buff, frameHeader); err != nil {
|
|
if err := extractFrame(reader, nil, frameHeader); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
frame := Frame{
|
|
int(frameHeader.Width),
|
|
int(frameHeader.Height),
|
|
int(frameHeader.OffsetX),
|
|
int(frameHeader.OffsetY),
|
|
buff.Bytes(),
|
|
}
|
|
|
|
sprite.Frames = append(sprite.Frames, frame)
|
|
}
|
|
|
|
return sprite, nil
|
|
}
|
|
|
|
func extractFrame(reader io.ReadSeeker, writer io.WriteSeeker, header FrameHeader) error {
|
|
var (
|
|
x uint32
|
|
y = header.Height - 1
|
|
)
|
|
|
|
var offset uint32
|
|
for offset < header.Length {
|
|
var chunkSize byte
|
|
if err := binary.Read(reader, binary.LittleEndian, &chunkSize); err != nil {
|
|
return err
|
|
}
|
|
|
|
if chunkSize == 0x80 {
|
|
x = 0
|
|
y--
|
|
} else if (chunkSize & 0x80) != 0 {
|
|
x += uint32(chunkSize & 0x7f)
|
|
} else {
|
|
if _, err := writer.Seek(int64(header.Width*y+x), io.SeekStart); err != nil {
|
|
return err
|
|
}
|
|
if _, err := io.CopyN(writer, reader, int64(chunkSize)); err != nil {
|
|
return err
|
|
}
|
|
|
|
offset += uint32(chunkSize)
|
|
x += uint32(chunkSize)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|