Commit: 30b260132b06ec3d39d164d125e4c4e4fcf2e3d9 - ikemen_go (git)

Go で書き直した Ikemen

Commit MetaInfo

• Revision: 30b260132b06ec3d39d164d125e4c4e4fcf2e3d9 (tree)
• Zeit: 2016-11-05 22:29:50
• Autor: SUEHIRO <supersuehiro@user...>
• Commiter: SUEHIRO

Log Message

Sprite 途中

Ändern Zusammenfassung

• modified: src/gen/gen.go
• modified: src/generated.go
• modified: src/image.go
• modified: src/sound.go

Diff

--- a/src/gen/gen.go
+++ b/src/gen/gen.go
@@ -4,7 +4,7 @@ import "os"
 
 var AppendFunc = [...][2]string{
 	{"I", "int"},
-	{"Pal", "[]color.Color"},
+	{"Pal", "[]uint32"},
 }
 
 func main() {
@@ -19,7 +19,7 @@ func main() {
 			panic(err)
 		}
 	}
-	write("package main\n\nimport \"image/color\"\n\n")
+	write("package main\n\n")
 	for i := range AppendFunc {
 		write("func Append")
 		write(AppendFunc[i][0])

--- a/src/generated.go
+++ b/src/generated.go
@@ -1,7 +1,5 @@
 package main
 
-import "image/color"
-
 func AppendI(slice *[]int, data ...int) {
 	m := len(*slice)
 	n := m + len(data)
@@ -13,11 +11,11 @@ func AppendI(slice *[]int, data ...int) {
 	*slice = (*slice)[:n]
 	copy((*slice)[m:n], data)
 }
-func AppendPal(slice *[][]color.Color, data ...[]color.Color) {
+func AppendPal(slice *[][]uint32, data ...[]uint32) {
 	m := len(*slice)
 	n := m + len(data)
 	if n > cap(*slice) {
-		newSlice := make([][]color.Color, n+n/4)
+		newSlice := make([][]uint32, n+n/4)
 		copy(newSlice, *slice)
 		*slice = newSlice
 	}

--- a/src/image.go
+++ b/src/image.go
@@ -1,11 +1,19 @@
 package main
 
+// #cgo pkg-config: libpng
+// #include <png.h>
+import "C"
 import (
 	"encoding/binary"
 	"github.com/go-gl/gl/v2.1/gl"
-	"image/color"
+	"image"
+	"image/draw"
+	"image/png"
+	"io"
 	"os"
+	"runtime"
 	"strings"
+	"unsafe"
 )
 
 func gltest() {
@@ -111,8 +119,42 @@ func gltest() {
 	gl.DeleteObjectARB(vertObj)
 }
 
+type Texture uint32
+
+func textureFinalizer(t *Texture) {
+	if *t != 0 {
+		gl.DeleteTextures(1, (*uint32)(t))
+	}
+}
+func NewTexture() (t *Texture) {
+	t = new(Texture)
+	runtime.SetFinalizer(t, textureFinalizer)
+	return
+}
+func (t *Texture) FromImageRGBA(rgba *image.RGBA) {
+	gl.BindTexture(gl.TEXTURE_2D, uint32(*t))
+	gl.PixelStorei(gl.UNPACK_ALIGNMENT, 1)
+	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA,
+		int32(rgba.Bounds().Dx()), int32(rgba.Bounds().Dy()),
+		0, gl.RGBA, gl.UNSIGNED_BYTE, unsafe.Pointer(&rgba.Pix[0]))
+	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
+	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
+	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP)
+	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP)
+}
+func (t *Texture) FromImage(im image.Image) {
+	switch trueim := im.(type) {
+	case *image.RGBA:
+		t.FromImageRGBA(trueim)
+	default:
+		copy := image.NewRGBA(trueim.Bounds())
+		draw.Draw(copy, trueim.Bounds(), trueim, image.Pt(0, 0), draw.Src)
+		t.FromImageRGBA(copy)
+	}
+}
+
 type PalleteList struct {
-	palletes   [][]color.Color
+	palletes   [][]uint32
 	palleteMap []int
 	PalTable   map[[2]int16]int
 }
@@ -122,7 +164,7 @@ func (pl *PalleteList) Clear() {
 	pl.palleteMap = nil
 	pl.PalTable = make(map[[2]int16]int)
 }
-func (pl *PalleteList) SetSource(i int, p []color.Color) {
+func (pl *PalleteList) SetSource(i int, p []uint32) {
 	if i < len(pl.palleteMap) {
 		pl.palleteMap[i] = i
 	} else {
@@ -140,13 +182,13 @@ func (pl *PalleteList) SetSource(i int, p []color.Color) {
 		AppendPal(&pl.palletes, p)
 	}
 }
-func (pl *PalleteList) NewPal() (i int, p []color.Color) {
+func (pl *PalleteList) NewPal() (i int, p []uint32) {
 	i = len(pl.palletes)
-	p = make([]color.Color, 256)
+	p = make([]uint32, 256)
 	pl.SetSource(i, p)
 	return
 }
-func (pl *PalleteList) Get(i int) []color.Color {
+func (pl *PalleteList) Get(i int) []uint32 {
 	return pl.palletes[pl.palleteMap[i]]
 }
 func (pl *PalleteList) Remap(source int, destination int) {
@@ -178,9 +220,9 @@ type SffHeader struct {
 	NumberOfPalettes         uint32
 }
 
-func (sh *SffHeader) Read(f *os.File, lofs *uint32, tofs *uint32) error {
+func (sh *SffHeader) Read(r io.Reader, lofs *uint32, tofs *uint32) error {
 	buf := make([]byte, 12)
-	n, err := f.Read(buf)
+	n, err := r.Read(buf)
 	if err != nil {
 		return err
 	}
@@ -188,7 +230,7 @@ func (sh *SffHeader) Read(f *os.File, lofs *uint32, tofs *uint32) error {
 		return Error("ElecbyteSprではありません")
 	}
 	read := func(x interface{}) error {
-		return binary.Read(f, binary.LittleEndian, x)
+		return binary.Read(r, binary.LittleEndian, x)
 	}
 	if err := read(&sh.Ver3); err != nil {
 		return err
@@ -250,3 +292,424 @@ func (sh *SffHeader) Read(f *os.File, lofs *uint32, tofs *uint32) error {
 	}
 	return nil
 }
+
+type Sprite struct {
+	Pal           []uint32
+	Tex           *Texture
+	Group, Number int16
+	Size          [2]uint16
+	Offset        [2]int16
+	palidx, link  int
+	rle           int
+}
+
+func NewSprite() *Sprite {
+	return &Sprite{palidx: -1, link: -1}
+}
+func (s *Sprite) shareCopy(src *Sprite) {
+	s.Pal = src.Pal
+	s.Tex = src.Tex
+	s.Size = src.Size
+	s.palidx = src.palidx
+}
+func (s *Sprite) GetPal(pl *PalleteList) []uint32 {
+	if s.Pal != nil || s.rle == -12 {
+		return s.Pal
+	}
+	return pl.Get(int(s.palidx))
+}
+func (s *Sprite) SetPxl(px []byte) {
+	if int64(len(px)) != int64(s.Size[0])*int64(s.Size[1]) {
+		return
+	}
+	s.Tex = NewTexture()
+	gl.BindTexture(gl.TEXTURE_2D, uint32(*s.Tex))
+	gl.PixelStorei(gl.UNPACK_ALIGNMENT, 1)
+	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.LUMINANCE,
+		int32(s.Size[0]), int32(s.Size[1]),
+		0, gl.LUMINANCE, gl.UNSIGNED_BYTE, unsafe.Pointer(&px[0]))
+	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
+	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
+	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP)
+	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP)
+}
+func (s *Sprite) readHeader(r io.Reader, ofs *uint32, size *uint32,
+	link *uint16) error {
+	read := func(x interface{}) error {
+		return binary.Read(r, binary.LittleEndian, x)
+	}
+	if err := read(ofs); err != nil {
+		return err
+	}
+	if err := read(size); err != nil {
+		return err
+	}
+	if err := read(s.Offset[:]); err != nil {
+		return err
+	}
+	if err := read(&s.Group); err != nil {
+		return err
+	}
+	if err := read(&s.Number); err != nil {
+		return err
+	}
+	if err := read(link); err != nil {
+		return err
+	}
+	return nil
+}
+func (s *Sprite) readPcxHeader(f *os.File, offset int64) error {
+	f.Seek(offset, 0)
+	read := func(x interface{}) error {
+		return binary.Read(f, binary.LittleEndian, x)
+	}
+	var dummy uint16
+	if err := read(&dummy); err != nil {
+		return err
+	}
+	var encoding, bpp byte
+	if err := read(&encoding); err != nil {
+		return err
+	}
+	if err := read(&bpp); err != nil {
+		return err
+	}
+	if bpp != 8 {
+		return Error("256色でありません")
+	}
+	var rect [4]uint16
+	if err := read(rect[:]); err != nil {
+		return err
+	}
+	f.Seek(offset+66, 0)
+	var bpl uint16
+	if err := read(&bpl); err != nil {
+		return err
+	}
+	s.Size[0] = rect[2] - rect[0] + 1
+	s.Size[1] = rect[3] - rect[1] + 1
+	if encoding == 1 {
+		s.rle = int(bpl)
+	} else {
+		s.rle = 0
+	}
+	return nil
+}
+func (s *Sprite) RlePcxDecode(rle []byte) (p []byte) {
+	if len(rle) == 0 || s.rle <= 0 {
+		return rle
+	}
+	p = make([]byte, int(s.Size[0])*int(s.Size[1]))
+	i, j, k, w := 0, 0, 0, int(s.Size[0])
+	for j < len(p) {
+		n, d := 1, rle[i]
+		if i < len(rle)-1 {
+			i++
+		}
+		if d >= 0xc0 {
+			n = int(d & 0x3f)
+			d = rle[i]
+			if i < len(rle)-1 {
+				i++
+			}
+		}
+		for ; n > 0; n-- {
+			if k < w && j < len(p) {
+				p[j] = d
+				j++
+			}
+			k++
+			if k == s.rle {
+				k = 0
+				n = 1
+			}
+		}
+	}
+	s.rle = 0
+	return
+}
+func (s *Sprite) read(f *os.File, sh *SffHeader, offset int64,
+	datasize uint32, nextSubheader uint32, prev *Sprite,
+	palletSame *bool, pl *PalleteList, c00 bool) error {
+	if int64(nextSubheader) > offset {
+		// 最後以外datasizeを無視
+		datasize = nextSubheader - uint32(offset)
+	}
+	read := func(x interface{}) error {
+		return binary.Read(f, binary.LittleEndian, x)
+	}
+	var ps byte
+	if err := read(&ps); err != nil {
+		return err
+	}
+	*palletSame = ps != 0 && prev != nil
+	if err := s.readPcxHeader(f, offset); err != nil {
+		return err
+	}
+	f.Seek(offset+128, 0)
+	var palSize int
+	if c00 || *palletSame {
+		palSize = 0
+	} else {
+		palSize = 768
+	}
+	px := make([]byte, int(datasize)-(128+palSize))
+	if err := read(px); err != nil {
+		return err
+	}
+	if *palletSame {
+		if prev != nil {
+			s.palidx = prev.palidx
+		}
+		if s.palidx < 0 {
+			s.palidx, _ = pl.NewPal()
+		}
+	} else {
+		var pal []uint32
+		s.palidx, pal = pl.NewPal()
+		if c00 {
+			f.Seek(offset+int64(datasize)-768, 0)
+		}
+		var rgb [3]byte
+		for i := range pal {
+			if err := read(rgb[:]); err != nil {
+				return err
+			}
+			pal[i] = uint32(rgb[0])<<16 | uint32(rgb[1])<<16 | uint32(rgb[2])
+		}
+	}
+	s.SetPxl(s.RlePcxDecode(px))
+	return nil
+}
+func (s *Sprite) readHeaderV2(r io.Reader, ofs *uint32, size *uint32,
+	lofs uint32, tofs uint32, link *uint16) error {
+	read := func(x interface{}) error {
+		return binary.Read(r, binary.LittleEndian, x)
+	}
+	if err := read(&s.Group); err != nil {
+		return err
+	}
+	if err := read(&s.Number); err != nil {
+		return err
+	}
+	if err := read(s.Size[:]); err != nil {
+		return err
+	}
+	if err := read(s.Offset[:]); err != nil {
+		return err
+	}
+	if err := read(link); err != nil {
+		return err
+	}
+	var format byte
+	if err := read(&format); err != nil {
+		return err
+	}
+	s.rle = -int(format)
+	var dummy byte
+	if err := read(&dummy); err != nil {
+		return err
+	}
+	if err := read(ofs); err != nil {
+		return err
+	}
+	if err := read(size); err != nil {
+		return err
+	}
+	var tmp uint16
+	if err := read(&tmp); err != nil {
+		return err
+	}
+	s.palidx = int(tmp)
+	if err := read(&tmp); err != nil {
+		return err
+	}
+	if tmp&1 == 0 {
+		*ofs += lofs
+	} else {
+		*ofs += tofs
+	}
+	return nil
+}
+func (s *Sprite) Rle8Decode(rle []byte) (p []byte) {
+	if len(rle) == 0 {
+		return rle
+	}
+	p = make([]byte, int(s.Size[0])*int(s.Size[1]))
+	i, j := 0, 0
+	for j < len(p) {
+		n, d := 1, rle[i]
+		if i < len(rle)-1 {
+			i++
+		}
+		if d&0xc0 == 0x40 {
+			n = int(d & 0x3f)
+			d = rle[i]
+			if i < len(rle)-1 {
+				i++
+			}
+		}
+		for ; n > 0; n-- {
+			if j < len(p) {
+				p[j] = d
+				j++
+			}
+		}
+	}
+	return
+}
+func (s *Sprite) Rle5Decode(rle []byte) (p []byte) {
+	if len(rle) == 0 {
+		return rle
+	}
+	p = make([]byte, int(s.Size[0])*int(s.Size[1]))
+	i, j := 0, 0
+	for j < len(p) {
+		rl := int(rle[i])
+		if i < len(rle)-1 {
+			i++
+		}
+		dl := int(rle[i] & 0x7f)
+		c := byte(0)
+		if rle[i]>>7 != 0 {
+			if i < len(rle)-1 {
+				i++
+			}
+			c = rle[i]
+		}
+		if i < len(rle)-1 {
+			i++
+		}
+		for {
+			if j < len(p) {
+				p[j] = c
+				j++
+			}
+			rl--
+			if rl < 0 {
+				dl--
+				if dl < 0 {
+					break
+				}
+				c = rle[i] & 0x1f
+				rl = int(rle[i] >> 5)
+				if i < len(rle)-1 {
+					i++
+				}
+			}
+		}
+	}
+	return
+}
+func (s *Sprite) Lz5Decode(rle []byte) (p []byte) {
+	if len(rle) == 0 {
+		return rle
+	}
+	p = make([]byte, int(s.Size[0])*int(s.Size[1]))
+	i, j, n := 0, 0, 0
+	ct, cts, rb, rbc := rle[i], uint(0), byte(0), uint(0)
+	if i < len(rle)-1 {
+		i++
+	}
+	for j < len(p) {
+		d := int(rle[i])
+		if i < len(rle)-1 {
+			i++
+		}
+		if ct&byte(1<<cts) != 0 {
+			if d&0x3f == 0 {
+				d = (d<<2 | int(rle[i])) + 1
+				if i < len(rle)-1 {
+					i++
+				}
+				n = int(rle[i]) + 2
+				if i < len(rle)-1 {
+					i++
+				}
+			} else {
+				rb |= byte(d & 0xc0 >> rbc)
+				rbc += 2
+				n = int(d & 0x3f)
+				if rbc < 8 {
+					d = int(rle[i]) + 1
+					if i < len(rle)-1 {
+						i++
+					}
+				} else {
+					d = int(rb) + 1
+					rb, rbc = 0, 0
+				}
+			}
+			for {
+				if j < len(p) {
+					p[j] = p[j-d]
+					j++
+				}
+				n--
+				if n < 0 {
+					break
+				}
+			}
+		} else {
+			if d&0xe0 == 0 {
+				n = int(rle[i]) + 8
+				if i < len(rle)-1 {
+					i++
+				}
+			} else {
+				n = d >> 5
+				d &= 0x1f
+			}
+			for ; n > 0; n-- {
+				if j < len(p) {
+					p[j] = byte(d)
+					j++
+				}
+			}
+		}
+		cts++
+		if cts >= 8 {
+			ct, cts = rle[i], 0
+			if i < len(rle)-1 {
+				i++
+			}
+		}
+	}
+	return
+}
+func (s *Sprite) readV2(f *os.File, sh *SffHeader, offset int64,
+	datasize uint32) error {
+	f.Seek(offset+4, 0)
+	if s.rle < 0 {
+		format := -s.rle
+		var px []byte
+		if 2 <= format && format <= 4 {
+			px = make([]byte, datasize)
+			if err := binary.Read(f, binary.LittleEndian, px); err != nil {
+				return err
+			}
+		}
+		switch format {
+		case 2:
+			px = s.Rle8Decode(px)
+		case 3:
+			px = s.Rle5Decode(px)
+		case 4:
+			px = s.Lz5Decode(px)
+		case 10:
+		case 11, 12:
+			s.rle = -12
+			img, err := png.Decode(f)
+			if err != nil {
+				return err
+			}
+			s.Tex = NewTexture()
+			s.Tex.FromImage(img)
+			return nil
+		default:
+			return Error("不明な形式です")
+		}
+		s.SetPxl(px)
+	}
+	return nil
+}

--- a/src/sound.go
+++ b/src/sound.go
@@ -300,7 +300,7 @@ func (n *NormalizerLR) process(bai float64, sam *float32) float64 {
 
 type Vorbis struct {
 	dec        *vorbis.Vorbis
-	fh         *os.File
+	fd         *os.File
 	buf        []int16
 	bufi       float64
 	openReq    chan string
@@ -316,18 +316,18 @@ func (v *Vorbis) Open(file string) {
 func (v *Vorbis) openFile(file string) bool {
 	v.clear()
 	var err error
-	if v.fh, err = os.Open(file); err != nil {
+	if v.fd, err = os.Open(file); err != nil {
 		return false
 	}
 	return v.restart()
 }
 func (v *Vorbis) restart() bool {
-	if v.fh == nil {
+	if v.fd == nil {
 		return false
 	}
-	_, err := v.fh.Seek(0, 0)
+	_, err := v.fd.Seek(0, 0)
 	chk(err)
-	if v.dec, err = vorbis.Open(v.fh); err != nil {
+	if v.dec, err = vorbis.Open(v.fd); err != nil {
 		v.clear()
 		return false
 	}
@@ -338,9 +338,9 @@ func (v *Vorbis) clear() {
 	if v.dec != nil {
 		v.dec = nil
 	}
-	if v.fh != nil {
-		chk(v.fh.Close())
-		v.fh = nil
+	if v.fd != nil {
+		chk(v.fd.Close())
+		v.fd = nil
 	}
 }
 func (v *Vorbis) samToAudioOut(buf [][]float32) (out []int16) {
@@ -495,7 +495,7 @@ func LoadSndFile(filename string) (*Snd, error) {
 	if err != nil {
 		return nil, err
 	}
-	defer f.Close()
+	defer func() { chk(f.Close()) }()
 	buf := make([]byte, 12)
 	var n int
 	if n, err = f.Read(buf); err != nil {