Commit: abf1f49b3c2f7ef567e8db46e36d07a3d193080f - ikemen_go (git)

Go で書き直した Ikemen

Commit MetaInfo

• Revision: abf1f49b3c2f7ef567e8db46e36d07a3d193080f (tree)
• Time: 2016-11-08 23:16:36
• Author: SUEHIRO <supersuehiro@user...>
• Commiter: SUEHIRO

Log Message

画像の表示テスト

Change Summary

• modified: .gitignore
• modified: run.sh
• modified: src/common.go
• modified: src/gen/gen.go
• modified: src/generated.go
• modified: src/image.go
• modified: src/main.go
• add: src/render.go

Incremental Difference

--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,3 @@
 /data
 /go
-/godoc.txt
 /sound

--- a/run.sh
+++ b/run.sh
@@ -2,5 +2,5 @@
 GOPATH=$PWD/go
 export GOPATH
 go fmt ./src/*.go
-godoc -src ./src .* > godoc.txt
-go generate ./src/*.go && GODEBUG=cgocheck=0 go run ./src/*.go
+# godoc -src ./src .* > godoc.txt
+go generate ./src/main.go && GODEBUG=cgocheck=0 go run ./src/*.go

--- a/src/common.go
+++ b/src/common.go
@@ -1,7 +1,17 @@
 package main
 
-type Error string
+import "math"
 
-func (e Error) Error() string {
-	return string(e)
+func Abs(f float32) float32 {
+	if f < 0 {
+		return -f
+	}
+	return f
+}
+func IsFinite(f float32) bool {
+	return math.Abs(float64(f)) <= math.MaxFloat64
 }
+
+type Error string
+
+func (e Error) Error() string { return string(e) }

--- a/src/gen/gen.go
+++ b/src/gen/gen.go
@@ -4,6 +4,7 @@ import "os"
 
 var AppendFunc = [...][2]string{
 	{"I", "int"},
+	{"U32", "uint32"},
 	{"Pal", "[]uint32"},
 }
 

--- a/src/generated.go
+++ b/src/generated.go
@@ -11,6 +11,17 @@ func AppendI(slice *[]int, data ...int) {
 	*slice = (*slice)[:n]
 	copy((*slice)[m:n], data)
 }
+func AppendU32(slice *[]uint32, data ...uint32) {
+	m := len(*slice)
+	n := m + len(data)
+	if n > cap(*slice) {
+		newSlice := make([]uint32, n+n/4)
+		copy(newSlice, *slice)
+		*slice = newSlice
+	}
+	*slice = (*slice)[:n]
+	copy((*slice)[m:n], data)
+}
 func AppendPal(slice *[][]uint32, data ...[]uint32) {
 	m := len(*slice)
 	n := m + len(data)

--- a/src/image.go
+++ b/src/image.go
@@ -5,120 +5,14 @@ package main
 import "C"
 import (
 	"encoding/binary"
+	"fmt"
 	"github.com/go-gl/gl/v2.1/gl"
-	"image"
-	"image/draw"
-	"image/png"
 	"io"
 	"os"
 	"runtime"
-	"strings"
 	"unsafe"
 )
 
-func gltest() {
-	vertShader := strings.Join([]string{
-		"void main(void){",
-		"gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;",
-		"gl_Position = ftransform();",
-		"}\x00"}, "")
-	fragShader := strings.Join([]string{
-		"uniform float a;",
-		"uniform sampler2D tex;",
-		"uniform sampler1D pal;",
-		"uniform int msk;",
-		"void main(void){",
-		"float r = texture2D(tex, gl_TexCoord[0].st).r;",
-		"vec4 c;",
-		"gl_FragColor =",
-		"int(255.0*r) == msk ? vec4(0.0)",
-		": (c = texture1D(pal, r*0.9961), vec4(c.b, c.g, c.r, a));",
-		"}\x00"}, "")
-	fragShaderFc := strings.Join([]string{
-		"uniform float a;",
-		"uniform sampler2D tex;",
-		"uniform bool neg;",
-		"uniform float gray;",
-		"uniform vec3 add;",
-		"uniform vec3 mul;",
-		"void main(void){",
-		"vec4 c = texture2D(tex, gl_TexCoord[0].st);",
-		"if(neg) c.rgb = vec3(1.0) - c.rgb;",
-		"float gcol = (c.r + c.g + c.b) / 3.0;",
-		"c.r += (gcol - c.r) * gray + add.r;",
-		"c.g += (gcol - c.g) * gray + add.g;",
-		"c.b += (gcol - c.b) * gray + add.b;",
-		"c.rgb *= mul;",
-		"c.a *= a;",
-		"gl_FragColor = c;",
-		"}\x00"}, "")
-	fragShaderFcS := strings.Join([]string{
-		"uniform float a;",
-		"uniform sampler2D tex;",
-		"uniform vec3 color;",
-		"void main(void){",
-		"vec4 c = texture2D(tex, gl_TexCoord[0].st);",
-		"c.rgb = color * c.a;",
-		"c.a *= a;",
-		"gl_FragColor = c;",
-		"}\x00"}, "")
-	errLog := func(obl uintptr) error {
-		var size int32
-		gl.GetObjectParameterivARB(obl, gl.INFO_LOG_LENGTH, &size)
-		if size <= 0 {
-			return nil
-		}
-		var l int32
-		str := make([]byte, size+1)
-		gl.GetInfoLogARB(obl, size, &l, &str[0])
-		return Error(str[:l])
-	}
-	compile := func(shaderType uint32, src string) (shader uintptr) {
-		shader = gl.CreateShaderObjectARB(shaderType)
-		s, l := gl.Str(src), int32(len(src)-1)
-		gl.ShaderSourceARB(shader, 1, &s, &l)
-		gl.CompileShaderARB(shader)
-		var ok int32
-		gl.GetObjectParameterivARB(shader, gl.OBJECT_COMPILE_STATUS_ARB, &ok)
-		if ok == 0 {
-			chk(errLog(shader))
-			panic(Error("コンパイルエラー"))
-		}
-		return
-	}
-	link := func(v uintptr, f uintptr) (program uintptr) {
-		program = gl.CreateProgramObjectARB()
-		gl.AttachObjectARB(program, v)
-		gl.AttachObjectARB(program, f)
-		gl.LinkProgramARB(program)
-		var ok int32
-		gl.GetObjectParameterivARB(program, gl.OBJECT_LINK_STATUS_ARB, &ok)
-		if ok == 0 {
-			chk(errLog(program))
-			panic(Error("リンクエラー"))
-		}
-		return
-	}
-	vertObj := compile(gl.VERTEX_SHADER, vertShader)
-	fragObj := compile(gl.FRAGMENT_SHADER, fragShader)
-	shader := link(vertObj, fragObj)
-	gl.GetUniformLocationARB(shader, gl.Str("pal\x00"))
-	gl.GetUniformLocationARB(shader, gl.Str("msk\x00"))
-	gl.DeleteObjectARB(fragObj)
-	fragObj = compile(gl.FRAGMENT_SHADER, fragShaderFc)
-	shaderFc := link(vertObj, fragObj)
-	gl.GetUniformLocationARB(shaderFc, gl.Str("neg\x00"))
-	gl.GetUniformLocationARB(shaderFc, gl.Str("gray\x00"))
-	gl.GetUniformLocationARB(shaderFc, gl.Str("add\x00"))
-	gl.GetUniformLocationARB(shaderFc, gl.Str("mul\x00"))
-	gl.DeleteObjectARB(fragObj)
-	fragObj = compile(gl.FRAGMENT_SHADER, fragShaderFcS)
-	shaderFcS := link(vertObj, fragObj)
-	gl.GetUniformLocationARB(shaderFcS, gl.Str("color\x00"))
-	gl.DeleteObjectARB(fragObj)
-	gl.DeleteObjectARB(vertObj)
-}
-
 type Texture uint32
 
 func textureFinalizer(t *Texture) {
@@ -128,29 +22,24 @@ func textureFinalizer(t *Texture) {
 }
 func NewTexture() (t *Texture) {
 	t = new(Texture)
+	gl.GenTextures(1, (*uint32)(t))
 	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 PalFX struct{}
+
+func (fx *PalFX) GetFcPalFx(trans int32) (neg bool, color float32,
+	add, mul [3]float32) {
+	neg = false
+	color = 1
+	for i := range add {
+		add[i] = 0
+	}
+	for i := range mul {
+		mul[i] = 1
 	}
+	return
 }
 
 type PalleteList struct {
@@ -159,7 +48,7 @@ type PalleteList struct {
 	PalTable   map[[2]int16]int
 }
 
-func (pl *PalleteList) Clear() {
+func (pl *PalleteList) init() {
 	pl.palletes = nil
 	pl.palleteMap = nil
 	pl.PalTable = make(map[[2]int16]int)
@@ -306,6 +195,128 @@ type Sprite struct {
 func NewSprite() *Sprite {
 	return &Sprite{palidx: -1, link: -1}
 }
+func LoadFromSff(filename string, g int16, n int16) (*Sprite, error) {
+	s := NewSprite()
+	f, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	defer func() { chk(f.Close()) }()
+	h := &SffHeader{}
+	var lofs, tofs uint32
+	if err := h.Read(f, &lofs, &tofs); err != nil {
+		return nil, err
+	}
+	var shofs, xofs, size uint32 = h.FirstSpriteHeaderOffset, 0, 0
+	var indexOfPrevious uint16
+	pl := &PalleteList{}
+	pl.init()
+	foo := func() error {
+		switch h.Ver0 {
+		case 1:
+			if err := s.readHeader(f, &xofs, &size, &indexOfPrevious); err != nil {
+				return err
+			}
+		case 2:
+			if err := s.readHeaderV2(f, &xofs, &size,
+				lofs, tofs, &indexOfPrevious); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+	var palletSame bool
+	var dummy *Sprite
+	var newSubHeaderOffset []uint32
+	AppendU32(&newSubHeaderOffset, shofs)
+	i := 0
+	for ; i < int(h.NumberOfSprites); i++ {
+		AppendU32(&newSubHeaderOffset, shofs)
+		f.Seek(int64(shofs), 0)
+		if err := foo(); err != nil {
+			return nil, err
+		}
+		if s.palidx < 0 || s.Group == g && s.Number == n {
+			ip := len(newSubHeaderOffset)
+			for size == 0 {
+				if int(indexOfPrevious) >= ip {
+					return nil, Error("linkが不正です")
+				}
+				ip = int(indexOfPrevious)
+				if h.Ver0 == 1 {
+					shofs = newSubHeaderOffset[ip]
+				} else {
+					shofs = h.FirstSpriteHeaderOffset + uint32(ip)*28
+				}
+				f.Seek(int64(shofs), 0)
+				if err := foo(); err != nil {
+					return nil, err
+				}
+			}
+			switch h.Ver0 {
+			case 1:
+				if err := s.read(f, h, int64(shofs+32), size, xofs, dummy,
+					&palletSame, pl, false); err != nil {
+					return nil, err
+				}
+			case 2:
+				if err := s.readV2(f, int64(xofs), size); err != nil {
+					return nil, err
+				}
+			}
+			if s.Group == g && s.Number == n {
+				break
+			}
+			dummy = &Sprite{palidx: s.palidx}
+		}
+		if h.Ver0 == 1 {
+			shofs = xofs
+		} else {
+			shofs += 28
+		}
+	}
+	if i == int(h.NumberOfSprites) {
+		return nil, Error(fmt.Sprintf("%d, %d のスプライトが見つかりません", g, n))
+	}
+	if h.Ver0 == 1 {
+		s.Pal = pl.Get(s.palidx)
+		s.palidx = -1
+		return s, nil
+	}
+	read := func(x interface{}) error {
+		return binary.Read(f, binary.LittleEndian, x)
+	}
+	size = 0
+	indexOfPrevious = uint16(s.palidx)
+	ip := indexOfPrevious + 1
+	for size == 0 && ip != indexOfPrevious {
+		ip = indexOfPrevious
+		shofs = h.FirstPaletteHeaderOffset + uint32(ip)*16
+		f.Seek(int64(shofs)+6, 0)
+		if err := read(&indexOfPrevious); err != nil {
+			return nil, err
+		}
+		if err := read(&xofs); err != nil {
+			return nil, err
+		}
+		if err := read(&size); err != nil {
+			return nil, err
+		}
+	}
+	if s.rle != -12 {
+		f.Seek(int64(lofs+xofs), 0)
+		s.Pal = make([]uint32, 256)
+		var rgba [4]byte
+		for i := 0; i < int(size)/4 && i < len(s.Pal); i++ {
+			if err := read(rgba[:]); err != nil {
+				return nil, err
+			}
+			s.Pal[i] = uint32(rgba[2])<<16 | uint32(rgba[1])<<8 | uint32(rgba[0])
+		}
+	}
+	s.palidx = -1
+	return s, nil
+}
 func (s *Sprite) shareCopy(src *Sprite) {
 	s.Pal = src.Pal
 	s.Tex = src.Tex
@@ -475,7 +486,7 @@ func (s *Sprite) read(f *os.File, sh *SffHeader, offset int64,
 			if err := read(rgb[:]); err != nil {
 				return err
 			}
-			pal[i] = uint32(rgb[0])<<16 | uint32(rgb[1])<<16 | uint32(rgb[2])
+			pal[i] = uint32(rgb[2])<<16 | uint32(rgb[1])<<8 | uint32(rgb[0])
 		}
 	}
 	s.SetPxl(s.RlePcxDecode(px))
@@ -677,8 +688,7 @@ func (s *Sprite) Lz5Decode(rle []byte) (p []byte) {
 	}
 	return
 }
-func (s *Sprite) readV2(f *os.File, sh *SffHeader, offset int64,
-	datasize uint32) error {
+func (s *Sprite) readV2(f *os.File, offset int64, datasize uint32) error {
 	f.Seek(offset+4, 0)
 	if s.rle < 0 {
 		format := -s.rle
@@ -689,6 +699,36 @@ func (s *Sprite) readV2(f *os.File, sh *SffHeader, offset int64,
 				return err
 			}
 		}
+		getIHDR := func() (png_ptr C.png_structp, info_ptr C.png_infop,
+			width, height C.png_uint_32, bit_depth, color_type C.int,
+			ok bool, err error) {
+			png_sig := make([]C.png_byte, 8)
+			if err = binary.Read(f, binary.LittleEndian, png_sig); err != nil {
+				return
+			}
+			if C.png_sig_cmp(&png_sig[0], 0, 8) != 0 {
+				err = Error("png_sig_cmp failed")
+				return
+			}
+			png_ptr = C.png_create_read_struct(C.CString(C.PNG_LIBPNG_VER_STRING),
+				nil, nil, nil)
+			if png_ptr == nil {
+				err = Error("png_create_read_struct failed")
+				return
+			}
+			info_ptr = C.png_create_info_struct(png_ptr)
+			if info_ptr == nil {
+				C.png_destroy_read_struct(&png_ptr, nil, nil)
+				err = Error("png_create_info_struct failed")
+				return
+			}
+			C.png_init_io(png_ptr, C.fdopen(C.int(f.Fd()), C.CString("rb")))
+			C.png_set_sig_bytes(png_ptr, 8)
+			C.png_read_info(png_ptr, info_ptr)
+			ok = C.png_get_IHDR(png_ptr, info_ptr, &width, &height,
+				&bit_depth, &color_type, nil, nil, nil) != 0
+			return
+		}
 		switch format {
 		case 2:
 			px = s.Rle8Decode(px)
@@ -697,14 +737,75 @@ func (s *Sprite) readV2(f *os.File, sh *SffHeader, offset int64,
 		case 4:
 			px = s.Lz5Decode(px)
 		case 10:
+			png_ptr, info_ptr, width, height, bit_depth, color_type, ok, err :=
+				getIHDR()
+			if err != nil {
+				return err
+			}
+			if ok && color_type == C.PNG_COLOR_TYPE_PALETTE && bit_depth <= 8 {
+				px = make([]byte, int(width*height))
+				pp := make([]*C.png_byte, int(height))
+				for i := range pp {
+					pp[i] = (*C.png_byte)(&px[i*int(width)])
+				}
+				C.png_read_image(png_ptr, &pp[0])
+				switch bit_depth {
+				case 1:
+					for y := range pp {
+						for i := width - 1; i >= 0; i-- {
+							p := (*[1 << 30]byte)(unsafe.Pointer(pp[y]))[:width:width]
+							p[i] = p[i>>3] & (1 << uint(i&7)) >> uint(i&7)
+						}
+					}
+				case 2:
+					for y := range pp {
+						for i := width - 1; i >= 0; i-- {
+							p := (*[1 << 30]byte)(unsafe.Pointer(pp[y]))[:width:width]
+							p[i] = p[i>>2] & (3 << uint(i&3*2)) >> uint(i&3*2)
+						}
+					}
+				case 4:
+					for y := range pp {
+						for i := width - 1; i >= 0; i-- {
+							p := (*[1 << 30]byte)(unsafe.Pointer(pp[y]))[:width:width]
+							p[i] = p[i>>1] & (15 << uint(i&1*4)) >> uint(i&1*4)
+						}
+					}
+				}
+			}
+			C.png_destroy_read_struct(&png_ptr, &info_ptr, nil)
 		case 11, 12:
 			s.rle = -12
-			img, err := png.Decode(f)
+			png_ptr, info_ptr, width, height, bit_depth, color_type, ok, err :=
+				getIHDR()
 			if err != nil {
 				return err
 			}
-			s.Tex = NewTexture()
-			s.Tex.FromImage(img)
+			if ok {
+				if bit_depth > 8 {
+					C.png_set_strip_16(png_ptr)
+				}
+				C.png_set_expand(png_ptr)
+				if color_type&C.PNG_COLOR_MASK_ALPHA == 0 {
+					C.png_set_add_alpha(png_ptr, 0xFF, C.PNG_FILLER_AFTER)
+				}
+				px = make([]byte, int(width*height*4))
+				pp := make([]*C.png_byte, int(height))
+				for i := range pp {
+					pp[i] = (*C.png_byte)(&px[i*int(width)*4])
+				}
+				C.png_read_image(png_ptr, &pp[0])
+				s.Tex = NewTexture()
+				gl.BindTexture(gl.TEXTURE_2D, uint32(*s.Tex))
+				gl.PixelStorei(gl.UNPACK_ALIGNMENT, 1)
+				gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int32(width), int32(height),
+					0, gl.RGBA, gl.UNSIGNED_BYTE, unsafe.Pointer(&px[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)
+			}
+			C.png_destroy_read_struct(&png_ptr, &info_ptr, nil)
 			return nil
 		default:
 			return Error("不明な形式です")
@@ -713,3 +814,31 @@ func (s *Sprite) readV2(f *os.File, sh *SffHeader, offset int64,
 	}
 	return nil
 }
+func (s *Sprite) glDraw(pal []uint32, mask int32, x, y float32, tile *[4]int32,
+	xts, xbs, ys, rxadd, agl float32, trans int32, window *[4]int32,
+	rcx, rcy float32, fx *PalFX) {
+	if s.Tex == nil {
+		return
+	}
+	if s.rle == -12 {
+		neg, color, padd, pmul := fx.GetFcPalFx(trans)
+		RenderMugenFc(*s.Tex, s.Size, x, y, tile, xts, xbs, ys, 1, rxadd, agl,
+			trans, window, rcx, rcy, neg, color, &padd, &pmul)
+	} else {
+		RenderMugen(*s.Tex, pal, mask, s.Size, x, y, tile, xts, xbs, ys, 1,
+			rxadd, agl, trans, window, rcx, rcy)
+	}
+}
+func (s *Sprite) Draw(x, y, xscale, yscale float32, pal []uint32) {
+	x -= xscale*float32(s.Offset[0]) + float32(GameWidth-320)/2
+	y -= yscale*float32(s.Offset[1]) + float32(GameHeight-240)
+	if xscale < 0 {
+		x *= -1
+	}
+	if yscale < 0 {
+		y *= -1
+	}
+	s.glDraw(pal, 0, -x*WidthScale, -y*HeightScale, &notiling,
+		xscale*WidthScale, xscale*WidthScale, yscale*HeightScale, 0, 0, 255,
+		&scrrect, 0, 0, nil)
+}

--- a/src/main.go
+++ b/src/main.go
@@ -9,10 +9,14 @@ import (
 	"time"
 )
 
+var windowWidth, windowHeight int32 = 640, 480
+var GameWidth, GameHeight int32 = 320, 240
+var WidthScale = float32(windowWidth) / float32(GameWidth)
+var HeightScale = float32(windowHeight) / float32(GameHeight)
 var window *glfw.Window
-var windowWidth, windowHeight = 640, 480
 var gameEnd, frameSkip = false, false
 var redrawWait = struct{ nextTime, lastDraw time.Time }{}
+var testSprite *Sprite
 
 func init() {
 	runtime.LockOSThread()
@@ -49,9 +53,9 @@ func await(fps int) {
 	glfw.PollEvents()
 	gameEnd = window.ShouldClose()
 	if !frameSkip {
-		windowWidth, windowHeight = window.GetFramebufferSize()
 		gl.Viewport(0, 0, int32(windowWidth), int32(windowHeight))
 		gl.Clear(gl.COLOR_BUFFER_BIT)
+		testSprite.Draw(160, 120, 1, 1, testSprite.GetPal(nil))
 	}
 }
 func main() {
@@ -61,15 +65,18 @@ func main() {
 	glfw.WindowHint(glfw.ContextVersionMajor, 2)
 	glfw.WindowHint(glfw.ContextVersionMinor, 1)
 	var err error
-	window, err =
-		glfw.CreateWindow(windowWidth, windowHeight, "Ikemen GO", nil, nil)
+	window, err = glfw.CreateWindow(int(windowWidth), int(windowHeight),
+		"Ikemen GO", nil, nil)
 	chk(err)
 	window.MakeContextCurrent()
-	chk(gl.Init())
-	gltest()
 	glfw.SwapInterval(1)
-	l := lua.NewState()
+	chk(gl.Init())
+	RenderInit()
+	if testSprite, err = LoadFromSff("data/testv2.sff", 0, 0); err != nil {
+		panic(err)
+	}
 	audioOpen()
+	l := lua.NewState()
 	lua.OpenLibraries(l)
 	systemScriptInit(l)
 	if err := lua.DoFile(l, "script/main.lua"); err != nil {

--- /dev/null
+++ b/src/render.go
@@ -0,0 +1,449 @@
+package main
+
+import (
+	"github.com/go-gl/gl/v2.1/gl"
+	"math"
+	"strings"
+	"unsafe"
+)
+
+var notiling = [4]int32{0, 0, 0, 0}
+var scrrect = [4]int32{0, 0, int32(windowWidth), int32(windowHeight)}
+var mugenShader uintptr
+var uniformA, uniformPal, uniformMsk int32
+var mugenShaderFc uintptr
+var uniformFcA, uniformNeg, uniformGray, uniformAdd, uniformMul int32
+var mugenShaderFcS uintptr
+var uniformFcSA, uniformColor int32
+
+func RenderInit() {
+	vertShader := strings.Join([]string{
+		"void main(void){",
+		"gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;",
+		"gl_Position = ftransform();",
+		"}\x00"}, "")
+	fragShader := strings.Join([]string{
+		"uniform float a;",
+		"uniform sampler2D tex;",
+		"uniform sampler1D pal;",
+		"uniform int msk;",
+		"void main(void){",
+		"float r = texture2D(tex, gl_TexCoord[0].st).r;",
+		"vec4 c;",
+		"gl_FragColor =",
+		"int(255.0*r) == msk ? vec4(0.0)",
+		": (c = texture1D(pal, r*0.9961), vec4(c.rgb, a));",
+		"}\x00"}, "")
+	fragShaderFc := strings.Join([]string{
+		"uniform float a;",
+		"uniform sampler2D tex;",
+		"uniform bool neg;",
+		"uniform float gray;",
+		"uniform vec3 add;",
+		"uniform vec3 mul;",
+		"void main(void){",
+		"vec4 c = texture2D(tex, gl_TexCoord[0].st);",
+		"if(neg) c.rgb = vec3(1.0) - c.rgb;",
+		"float gcol = (c.r + c.g + c.b) / 3.0;",
+		"c.r += (gcol - c.r) * gray + add.r;",
+		"c.g += (gcol - c.g) * gray + add.g;",
+		"c.b += (gcol - c.b) * gray + add.b;",
+		"c.rgb *= mul;",
+		"c.a *= a;",
+		"gl_FragColor = c;",
+		"}\x00"}, "")
+	fragShaderFcS := strings.Join([]string{
+		"uniform float a;",
+		"uniform sampler2D tex;",
+		"uniform vec3 color;",
+		"void main(void){",
+		"vec4 c = texture2D(tex, gl_TexCoord[0].st);",
+		"c.rgb = color * c.a;",
+		"c.a *= a;",
+		"gl_FragColor = c;",
+		"}\x00"}, "")
+	errLog := func(obl uintptr) error {
+		var size int32
+		gl.GetObjectParameterivARB(obl, gl.INFO_LOG_LENGTH, &size)
+		if size <= 0 {
+			return nil
+		}
+		var l int32
+		str := make([]byte, size+1)
+		gl.GetInfoLogARB(obl, size, &l, &str[0])
+		return Error(str[:l])
+	}
+	compile := func(shaderType uint32, src string) (shader uintptr) {
+		shader = gl.CreateShaderObjectARB(shaderType)
+		s, l := gl.Str(src), int32(len(src)-1)
+		gl.ShaderSourceARB(shader, 1, &s, &l)
+		gl.CompileShaderARB(shader)
+		var ok int32
+		gl.GetObjectParameterivARB(shader, gl.OBJECT_COMPILE_STATUS_ARB, &ok)
+		if ok == 0 {
+			chk(errLog(shader))
+			panic(Error("コンパイルエラー"))
+		}
+		return
+	}
+	link := func(v uintptr, f uintptr) (program uintptr) {
+		program = gl.CreateProgramObjectARB()
+		gl.AttachObjectARB(program, v)
+		gl.AttachObjectARB(program, f)
+		gl.LinkProgramARB(program)
+		var ok int32
+		gl.GetObjectParameterivARB(program, gl.OBJECT_LINK_STATUS_ARB, &ok)
+		if ok == 0 {
+			chk(errLog(program))
+			panic(Error("リンクエラー"))
+		}
+		return
+	}
+	vertObj := compile(gl.VERTEX_SHADER, vertShader)
+	fragObj := compile(gl.FRAGMENT_SHADER, fragShader)
+	mugenShader = link(vertObj, fragObj)
+	uniformA = gl.GetUniformLocationARB(mugenShader, gl.Str("a\x00"))
+	uniformPal = gl.GetUniformLocationARB(mugenShader, gl.Str("pal\x00"))
+	uniformMsk = gl.GetUniformLocationARB(mugenShader, gl.Str("msk\x00"))
+	gl.DeleteObjectARB(fragObj)
+	fragObj = compile(gl.FRAGMENT_SHADER, fragShaderFc)
+	mugenShaderFc = link(vertObj, fragObj)
+	uniformFcA = gl.GetUniformLocationARB(mugenShader, gl.Str("a\x00"))
+	uniformNeg = gl.GetUniformLocationARB(mugenShaderFc, gl.Str("neg\x00"))
+	uniformGray = gl.GetUniformLocationARB(mugenShaderFc, gl.Str("gray\x00"))
+	uniformAdd = gl.GetUniformLocationARB(mugenShaderFc, gl.Str("add\x00"))
+	uniformMul = gl.GetUniformLocationARB(mugenShaderFc, gl.Str("mul\x00"))
+	gl.DeleteObjectARB(fragObj)
+	fragObj = compile(gl.FRAGMENT_SHADER, fragShaderFcS)
+	mugenShaderFcS = link(vertObj, fragObj)
+	uniformFcSA = gl.GetUniformLocationARB(mugenShader, gl.Str("a\x00"))
+	uniformColor = gl.GetUniformLocationARB(mugenShaderFcS, gl.Str("color\x00"))
+	gl.DeleteObjectARB(fragObj)
+	gl.DeleteObjectARB(vertObj)
+	scrrect[2], scrrect[3] = int32(windowWidth), int32(windowHeight)
+}
+func kaiten(x *float32, y *float32,
+	angle float64, rcx float32, rcy float32, vscl float32) {
+	temp := (*y - rcy) / vscl
+	length := math.Sqrt(float64((*x-rcx)*(*x-rcx) + temp*temp))
+	if *x-rcx == 0 {
+		if *y-rcy > 0 {
+			angle += math.Pi / 2
+		} else {
+			angle -= math.Pi / 2
+		}
+		*x = rcx + float32(length*math.Cos(angle))
+		*y = rcy + float32(length*math.Sin(angle))*vscl
+		return
+	}
+	kakudo := math.Atan(float64(temp/(*x-rcx))) + angle
+	if *x-rcx < 0 {
+		kakudo += math.Pi
+	}
+	*x = rcx + float32(length*math.Cos(kakudo))
+	*y = rcy + float32(length*math.Sin(kakudo))*vscl
+}
+func drawQuads(x1, y1, x2, y2, x3, y3, x4, y4, r, g, b, a, pers float32) {
+	gl.Color4f(r, g, b, a)
+	gl.Begin(gl.TRIANGLE_STRIP)
+	gl.TexCoord2f(0, 1)
+	gl.Vertex2f(x1, y1)
+	gl.TexCoord2f(0, 0)
+	gl.Vertex2f(x4, y4)
+	if pers != 1 {
+		n := int((1 - (pers * pers)) * Abs(x1-x2) *
+			float32(windowHeight>>5) / (Abs(y1-y4) + float32(windowHeight>>5)))
+		for i := 1; i < n; i++ {
+			gl.TexCoord2f(float32(i)/float32(n), 1)
+			gl.Vertex2f(x1+(x2-x1)*float32(i)/float32(n),
+				y1+(y2-y1)*float32(i)/float32(n))
+			gl.TexCoord2f(float32(i)/float32(n), 0)
+			gl.Vertex2f(x4+(x3-x4)*float32(i)/float32(n),
+				y4+(y3-y4)*float32(i)/float32(n))
+		}
+	}
+	gl.TexCoord2f(1, 1)
+	gl.Vertex2f(x2, y2)
+	gl.TexCoord2f(1, 0)
+	gl.Vertex2f(x3, y3)
+	gl.End()
+}
+func rmTileHSub(x1, y1, x2, y2, x3, y3, x4, y4, xtw, xbw, xts, xbs float32,
+	tl *[4]int32, rcx, r, g, b, a, pers float32) {
+	topdist := xtw + xts*float32((*tl)[0])
+	if Abs(topdist) >= 0.01 {
+		botdist := xbw + xbs*float32((*tl)[0])
+		db := (x4 - rcx) * (botdist - topdist) / Abs(topdist)
+		x1 += db
+		x2 += db
+		if (*tl)[2] == 1 {
+			x1d, x2d, x3d, x4d := x1, x2, x3, x4
+			for {
+				x2d = x1d - xbs*float32((*tl)[0])
+				x3d = x4d - xts*float32((*tl)[0])
+				x4d = x3d - xtw
+				x1d = x2d - xbw
+				if topdist < 0 {
+					if x1d >= float32(windowWidth) && x2d >= float32(windowWidth) &&
+						x3d >= float32(windowWidth) && x4d >= float32(windowWidth) {
+						break
+					}
+				} else if x1d <= 0 && x2d <= 0 && x3d <= 0 && x4d <= 0 {
+					break
+				}
+				if (0 < x1d || 0 < x2d) &&
+					(x1d < float32(windowWidth) || x2d < float32(windowWidth)) ||
+					(0 < x3d || 0 < x4d) &&
+						(x3d < float32(windowWidth) || x4d < float32(windowWidth)) {
+					drawQuads(x1d, y1, x2d, y2, x3d, y3, x4d, y4, r, g, b, a, pers)
+				}
+			}
+		}
+	}
+	n := (*tl)[2]
+	for {
+		if topdist > 0 {
+			if x1 >= float32(windowWidth) && x2 >= float32(windowWidth) &&
+				x3 >= float32(windowWidth) && x4 >= float32(windowWidth) {
+				break
+			}
+		} else if x1 <= 0 && x2 <= 0 && x3 <= 0 && x4 <= 0 {
+			break
+		}
+		if (0 < x1 || 0 < x2) &&
+			(x1 < float32(windowWidth) || x2 < float32(windowWidth)) ||
+			(0 < x3 || 0 < x4) &&
+				(x3 < float32(windowWidth) || x4 < float32(windowWidth)) {
+			drawQuads(x1, y1, x2, y2, x3, y3, x4, y4, r, g, b, a, pers)
+		}
+		if (*tl)[2] != 1 && n != 0 {
+			n--
+		}
+		if n == 0 || Abs(topdist) < 0.01 {
+			break
+		}
+		x4 = x3 + xts*float32((*tl)[0])
+		x1 = x2 + xbs*float32((*tl)[0])
+		x2 = x1 + xbw
+		x3 = x4 + xtw
+	}
+}
+func rmTileSub(w, h uint16, x, y float32, tl *[4]int32,
+	xts, xbs, ys, vs, rxadd, agl, rcx, rcy, r, g, b, a float32) {
+	x1, y1 := x+rxadd*ys*float32(h), rcy+((y-ys*float32(h))-rcy)*vs
+	x2, y2 := x1+xbs*float32(w), y1
+	x3, y3 := x+xts*float32(w), rcy+(y-rcy)*vs
+	x4, y4 := x, y3
+	var pers float32
+	if Abs(xts) < Abs(xbs) {
+		pers = Abs(xts) / Abs(xbs)
+	} else {
+		pers = Abs(xbs) / Abs(xts)
+	}
+	if agl != 0 {
+		kaiten(&x1, &y1, float64(agl), rcx, rcy, vs)
+		kaiten(&x2, &y2, float64(agl), rcx, rcy, vs)
+		kaiten(&x3, &y3, float64(agl), rcx, rcy, vs)
+		kaiten(&x4, &y4, float64(agl), rcx, rcy, vs)
+		drawQuads(x1, y1, x2, y2, x3, y3, x4, y4, r, g, b, a, pers)
+		return
+	}
+	if (*tl)[3] == 1 && xbs != 0 {
+		x1d, y1d, x2d, y2d, x3d, y3d, x4d, y4d := x1, y1, x2, y2, x3, y3, x4, y4
+		for {
+			x1d, y1d = x4d, y4d+ys*vs*float32((*tl)[1])
+			x2d, y2d = x3d, y1d
+			x3d = x4d - rxadd*ys*float32(h) + (xts/xbs)*(x3d-x4d)
+			y3d = y2d + ys*vs*float32(h)
+			x4d = x4d - rxadd*ys*float32(h)
+			if Abs(y3d-y4d) < 0.01 {
+				break
+			}
+			y4d = y3d
+			if ys*(float32(h)+float32((*tl)[1])) < 0 {
+				if y1d <= float32(-windowHeight) && y4d <= float32(-windowHeight) {
+					break
+				}
+			} else if y1d >= 0 && y4d >= 0 {
+				break
+			}
+			if (0 > y1d || 0 > y4d) &&
+				(y1d > float32(-windowHeight) || y4d > float32(-windowHeight)) {
+				rmTileHSub(x1d, y1d, x2d, y2d, x3d, y3d, x4d, y4d, x3d-x4d, x2d-x1d,
+					(x3d-x4d)/float32(w), (x2d-x1d)/float32(w), tl,
+					rcx, r, g, b, a, pers)
+			}
+		}
+	}
+	if (*tl)[3] == 0 || xts != 0 {
+		n := (*tl)[3]
+		for {
+			if ys*(float32(h)+float32((*tl)[1])) > 0 {
+				if y1 <= float32(-windowHeight) && y4 <= float32(-windowHeight) {
+					break
+				}
+			} else if y1 >= 0 && y4 >= 0 {
+				break
+			}
+			if (0 > y1 || 0 > y4) &&
+				(y1 > float32(-windowHeight) || y4 > float32(-windowHeight)) {
+				rmTileHSub(x1, y1, x2, y2, x3, y3, x4, y4, x3-x4, x2-x1,
+					(x3-x4)/float32(w), (x2-x1)/float32(w), tl, rcx, r, g, b, a, pers)
+			}
+			if (*tl)[3] != 1 && n != 0 {
+				n--
+			}
+			if n == 0 {
+				break
+			}
+			x4, y4 = x1, y1-ys*vs*float32((*tl)[1])
+			x3, y3 = x2, y4
+			x2 = x1 + rxadd*ys*float32(h) + (xbs/xts)*(x2-x1)
+			y2 = y3 - ys*vs*float32(h)
+			x1 = x1 + rxadd*ys*float32(h)
+			if Abs(y1-y2) < 0.01 {
+				break
+			}
+			y1 = y2
+		}
+	}
+}
+func rmMainSub(a int32, size [2]uint16, x, y float32, tl *[4]int32,
+	xts, xbs, ys, vs, rxadd, agl float32, trans int32, rcx, rcy float32) {
+	gl.MatrixMode(gl.PROJECTION)
+	gl.PushMatrix()
+	gl.LoadIdentity()
+	gl.Ortho(0, float64(windowWidth), 0, float64(windowHeight), -1, 1)
+	gl.MatrixMode(gl.MODELVIEW)
+	gl.PushMatrix()
+	gl.Translated(0, float64(windowHeight), 0)
+	switch {
+	case trans == -1:
+		gl.Uniform1fARB(a, 1)
+		gl.BlendFunc(gl.SRC_ALPHA, gl.ONE)
+		rmTileSub(size[0], size[1], x, y, tl, xts, xbs, ys, vs, rxadd,
+			agl, rcx, rcy, 1, 1, 1, 1)
+	case trans == -2:
+		gl.Uniform1fARB(a, 1)
+		gl.BlendFunc(gl.ZERO, gl.ONE_MINUS_SRC_COLOR)
+		rmTileSub(size[0], size[1], x, y, tl, xts, xbs, ys, vs, rxadd,
+			agl, rcx, rcy, 1, 1, 1, 1)
+	case trans <= 0:
+	case trans < 255:
+		gl.Uniform1fARB(a, float32(trans)/255)
+		gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
+		rmTileSub(size[0], size[1], x, y, tl, xts, xbs, ys, vs, rxadd,
+			agl, rcx, rcy, 1, 1, 1, float32(trans)/255)
+	case trans < 512:
+		gl.Uniform1fARB(a, 1)
+		gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
+		rmTileSub(size[0], size[1], x, y, tl, xts, xbs, ys, vs, rxadd,
+			agl, rcx, rcy, 1, 1, 1, 1)
+	default:
+		src, dst := trans&0xff, trans&0x3fc00>>10
+		if dst < 255 {
+			gl.Uniform1fARB(a, 1-float32(dst)/255)
+			gl.BlendFunc(gl.ZERO, gl.ONE_MINUS_SRC_ALPHA)
+			rmTileSub(size[0], size[1], x, y, tl, xts, xbs, ys, vs, rxadd,
+				agl, rcx, rcy, 1, 1, 1, 1-float32(trans)/255)
+		}
+		if src > 0 {
+			gl.Uniform1fARB(a, float32(src)/255)
+			gl.BlendFunc(gl.SRC_ALPHA, gl.ONE)
+			rmTileSub(size[0], size[1], x, y, tl, xts, xbs, ys, vs, rxadd,
+				agl, rcx, rcy, 1, 1, 1, float32(trans)/255)
+		}
+	}
+	gl.PopMatrix()
+	gl.MatrixMode(gl.PROJECTION)
+	gl.PopMatrix()
+}
+func rmInitSub(size [2]uint16, x, y *float32, tile *[4]int32, xts float32,
+	ys, vs, agl *float32, window *[4]int32, rcx float32, rcy *float32) (
+	tl [4]int32) {
+	if *vs < 0 {
+		*vs *= -1
+		*ys *= -1
+		*agl *= -1
+	}
+	tl = *tile
+	if tl[2] == 0 {
+		tl[0] = 0
+	} else if tl[0] > 0 {
+		tl[0] -= int32(size[0])
+	}
+	if tl[3] == 0 {
+		tl[1] = 0
+	} else if tl[1] > 0 {
+		tl[1] -= int32(size[1])
+	}
+	if xts >= 0 {
+		*x *= -1
+	}
+	*x += rcx
+	*rcy *= -1
+	if *ys < 0 {
+		*y *= -1
+	}
+	*y += *rcy
+	gl.Enable(gl.TEXTURE_2D)
+	gl.Disable(gl.DEPTH_TEST)
+	gl.Enable(gl.SCISSOR_TEST)
+	gl.Scissor((*window)[0], windowHeight-((*window)[1]+(*window)[3]),
+		(*window)[2], (*window)[3])
+	return
+}
+func RenderMugen(tex Texture, pal []uint32, mask int32, size [2]uint16,
+	x, y float32, tile *[4]int32, xts, xbs, ys, vs, rxadd, agl float32,
+	trans int32, window *[4]int32, rcx, rcy float32) {
+	if tex == 0 || !IsFinite(x+y+xts+xbs+ys+vs+rxadd+agl+rcx+rcy) {
+		return
+	}
+	tl := rmInitSub(size, &x, &y, tile, xts, &ys, &vs, &agl, window, rcx, &rcy)
+	gl.Enable(gl.TEXTURE_1D)
+	gl.UseProgramObjectARB(mugenShader)
+	gl.Uniform1iARB(uniformPal, 1)
+	gl.Uniform1iARB(uniformMsk, mask)
+	gl.ActiveTexture(gl.TEXTURE1)
+	var paltex uint32
+	gl.GenTextures(1, &paltex)
+	gl.BindTexture(gl.TEXTURE_1D, paltex)
+	gl.PixelStorei(gl.UNPACK_ALIGNMENT, 1)
+	gl.TexImage1D(gl.TEXTURE_1D, 0, gl.RGBA, 256, 0, gl.RGBA, gl.UNSIGNED_BYTE,
+		unsafe.Pointer(&pal[0]))
+	gl.TexParameteri(gl.TEXTURE_1D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
+	gl.TexParameteri(gl.TEXTURE_1D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
+	gl.ActiveTexture(gl.TEXTURE0)
+	gl.BindTexture(gl.TEXTURE_2D, uint32(tex))
+	rmMainSub(uniformA, size, x, y, &tl, xts, xbs, ys, vs, rxadd, agl,
+		trans, rcx, rcy)
+	gl.DeleteTextures(1, &paltex)
+	gl.UseProgramObjectARB(0)
+	gl.Disable(gl.TEXTURE_1D)
+	gl.Disable(gl.SCISSOR_TEST)
+	gl.Disable(gl.TEXTURE_2D)
+}
+func RenderMugenFc(tex Texture, size [2]uint16, x, y float32,
+	tile *[4]int32, xts, xbs, ys, vs, rxadd, agl float32, trans int32,
+	window *[4]int32, rcx, rcy float32, neg bool, color float32,
+	padd, pmul *[3]float32) {
+	if tex == 0 || !IsFinite(x+y+xts+xbs+ys+vs+rxadd+agl+rcx+rcy) {
+		return
+	}
+	tl := rmInitSub(size, &x, &y, tile, xts, &ys, &vs, &agl, window, rcx, &rcy)
+	gl.UseProgramObjectARB(mugenShaderFc)
+	ineg := int32(0)
+	if neg {
+		ineg = 1
+	}
+	gl.Uniform1iARB(uniformNeg, ineg)
+	gl.Uniform1fARB(uniformGray, 1-color)
+	gl.Uniform3fARB(uniformAdd, (*padd)[0], (*padd)[1], (*padd)[2])
+	gl.Uniform3fARB(uniformMul, (*pmul)[0], (*pmul)[1], (*pmul)[2])
+	gl.BindTexture(gl.TEXTURE_2D, uint32(tex))
+	rmMainSub(uniformFcA, size, x, y, &tl, xts, xbs, ys, vs, rxadd, agl,
+		trans, rcx, rcy)
+	gl.UseProgramObjectARB(0)
+	gl.Disable(gl.SCISSOR_TEST)
+	gl.Disable(gl.TEXTURE_2D)
+}