func uploadTexture_NRGBA32(img *image.NRGBA) gl.Texture {
b := img.Bounds()
data := make([]uint8, b.Max.X*b.Max.Y*4)
for y := 0; y < b.Max.Y; y++ {
for x := 0; x < b.Max.X; x++ {
p := img.At(x, y)
offset := y*b.Max.X*4 + x*4
r, g, b, a := p.RGBA()
data[offset+0] = uint8(r)
data[offset+1] = uint8(g)
data[offset+2] = uint8(b)
data[offset+3] = uint8(a)
}
}
id := gl.GenTexture()
id.Bind(gl.TEXTURE_2D)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_R, gl.CLAMP_TO_EDGE)
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, b.Max.X, b.Max.Y, 0, gl.RGBA, gl.UNSIGNED_BYTE, data)
if gl.GetError() != gl.NO_ERROR {
id.Delete()
panic(errors.New("Failed to load a texture"))
return 0
}
return id
}
func (v *Video) Init(t <-chan []uint32, d <-chan []uint32, n string) {
v.tick = t
v.debug = d
if err := glfw.Init(); err != nil {
fmt.Fprintf(os.Stderr, "[e] %v\n", err)
return
}
if err := glfw.OpenWindow(512, 480, 0, 0, 0, 0, 0, 0, glfw.Windowed); err != nil {
fmt.Fprintf(os.Stderr, "[e] %v\n", err)
return
}
if gl.Init() != 0 {
panic("gl error")
}
gl.Enable(gl.TEXTURE_2D)
glfw.SetWindowTitle(fmt.Sprintf("Fergulator - %s", n))
glfw.SetWindowSizeCallback(reshape)
glfw.SetWindowCloseCallback(quit_event)
glfw.SetKeyCallback(KeyListener)
reshape(512, 480)
v.tex = gl.GenTexture()
v.fpsmanager = gfx.NewFramerate()
v.fpsmanager.SetFramerate(70)
}
func loadTexture(path string) (*gl.Texture, error) {
file, err := os.Open(path)
if err != nil {
}
defer file.Close()
srcimg, _, err := image.Decode(file)
if err != nil {
return nil, err
}
// convert to RGBA if not already
b := srcimg.Bounds()
var dstimg *image.RGBA
if srcimg.ColorModel() != color.RGBAModel {
dstimg = image.NewRGBA(b)
draw.Draw(dstimg, b, srcimg, b.Min, draw.Src)
} else {
dstimg = srcimg.(*image.RGBA)
}
tex := gl.GenTexture()
tex.Bind(gl.TEXTURE_2D)
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, b.Dx(), b.Dy(), 0, gl.RGBA, gl.UNSIGNED_BYTE, dstimg.Pix)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
return &tex, nil
}
func NewTextureData(path string) *TextureData {
id := gl.GenTexture()
tb := &TextureData{id, path, nil, make([]*PixelGrid, 0)}
tb.Pix = NewPixelGridFromFile(tb.path)
tb.CreateMipmaps()
tb.LoadIntoGL()
return tb
}
// Load bitmap from path as GL texture
func LoadGLTexture(path string) {
image := sdl.Load(path)
if image == nil {
panic(sdl.GetError())
}
// Check that the image's width is a power of 2
if image.W&(image.W-1) != 0 {
fmt.Println("warning:", path, "has a width that is not a power of 2")
}
// Also check if the height is a power of 2
if image.H&(image.H-1) != 0 {
fmt.Println("warning:", path, "has an height that is not a power of 2")
}
// get the number of channels in the SDL surface
nOfColors := image.Format.BytesPerPixel
var textureFormat gl.GLenum
if nOfColors == 4 { // contains alpha channel
if image.Format.Rmask == 0x000000ff {
textureFormat = gl.RGBA
} else {
textureFormat = gl.BGRA
}
} else if nOfColors == 3 { // no alpha channel
if image.Format.Rmask == 0x000000ff {
textureFormat = gl.RGB
} else {
textureFormat = gl.BGR
}
} else {
fmt.Println("warning:", path, "is not truecolor, this will probably break")
}
texture = gl.GenTexture()
// Typical texture generation using data from the bitmap
gl.BindTexture(gl.TEXTURE_2D, uint(texture))
// Generate the texture
gl.TexImage2D(gl.TEXTURE_2D, 0, int(image.Format.BytesPerPixel),
int(image.W), int(image.H),
0, textureFormat, gl.UNSIGNED_BYTE, image.Pixels,
)
// linear filtering
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
// free up memory we have used.
image.Free()
}
func uploadTexture(img *image.RGBA) gl.Texture {
gl.Enable(gl.TEXTURE_2D)
tex := gl.GenTexture()
tex.Bind(gl.TEXTURE_2D)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
gl.TexImage2D(gl.TEXTURE_2D, 0, 4, img.Bounds().Max.X, img.Bounds().Max.Y,
0, gl.RGBA, gl.UNSIGNED_BYTE, img.Pix)
gl.Disable(gl.TEXTURE_2D)
return tex
}
// MakeImage makes an image from an image.NRGBA.
func MakeImage(i *image.NRGBA) (img Image) {
img.Width, img.Height = i.Bounds().Dx(), i.Bounds().Dy()
img.tex = gl.GenTexture()
img.tex.Bind(gl.TEXTURE_2D)
gl.TexParameterf(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
gl.TexParameterf(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
gl.TexImage2D(gl.TEXTURE_2D, 0, 4, img.Width, img.Height,
0, gl.RGBA, gl.UNSIGNED_BYTE, i.Pix)
return
}
func (v *Video) Init(t <-chan []uint32, n string) chan [2]int {
v.tick = t
v.resize = make(chan [2]int)
if sdl.Init(sdl.INIT_VIDEO|sdl.INIT_JOYSTICK|sdl.INIT_AUDIO) != 0 {
log.Fatal(sdl.GetError())
}
v.screen = sdl.SetVideoMode(512, 480, 32, sdl.OPENGL|sdl.RESIZABLE)
if v.screen == nil {
log.Fatal(sdl.GetError())
}
sdl.WM_SetCaption(fmt.Sprintf("Fergulator - %s", n), "")
if gl.Init() != 0 {
panic(sdl.GetError())
}
gl.Enable(gl.TEXTURE_2D)
v.Reshape(int(v.screen.W), int(v.screen.H))
v.tex = gl.GenTexture()
v.fpsmanager = gfx.NewFramerate()
v.fpsmanager.SetFramerate(70)
joy = make([]*sdl.Joystick, sdl.NumJoysticks())
for i := 0; i < sdl.NumJoysticks(); i++ {
joy[i] = sdl.JoystickOpen(i)
fmt.Println("-----------------")
if joy[i] != nil {
fmt.Printf("Joystick %d\n", i)
fmt.Println(" Name: ", sdl.JoystickName(0))
fmt.Println(" Number of Axes: ", joy[i].NumAxes())
fmt.Println(" Number of Buttons: ", joy[i].NumButtons())
fmt.Println(" Number of Balls: ", joy[i].NumBalls())
} else {
fmt.Println(" Couldn't open Joystick!")
}
}
return v.resize
}
func NewFont(filename string, size int, c color.Color) *Font {
var font Font
font.textures = make(map[rune]gl.Texture)
font.widths = make(map[rune]int)
extfont := ttf.OpenFont(filename, size)
if extfont == nil {
panic("Could not load font")
}
defer extfont.Close()
font.height = extfont.LineSkip()
for _, ch := range "abcdefghijklmnopqrdstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 :;@'<>,.?/~#{}[]!£$%^&*()_-+=\"\\|" {
_, _, _, _, advance, err := extfont.GlyphMetrics(uint16(ch))
if err != 0 {
panic("Could not get glyph metrics")
}
// Create a bitmap with width=advance, height=font.height
surface := sdl.CreateRGBSurface(sdl.SWSURFACE|sdl.SRCALPHA, advance, font.height, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000)
//surface.FillRect(&sdl.Rect{0,0, uint16(advance), uint16(font.height)}, 0x0)
// rect := sdl.Rect{0,0, uint16(advance), uint16(ascent)}
// rect := sdl.Rect{int16(minx), int16(ascent)-int16(maxy), 0, 0}
fontSurface := ttf.RenderText_Blended(extfont, string(ch), sdl.ColorFromGoColor(c))
fontSurface.Blit(nil, surface, nil)
rgba := image.NewRGBA(image.Rect(0, 0, advance, font.height))
for x := 0; x < advance; x++ {
for y := 0; y < font.height; y++ {
rgba.Set(x, y, fontSurface.At(x, font.height-y))
}
}
font.widths[ch] = advance
font.textures[ch] = gl.GenTexture()
font.textures[ch].Bind(gl.TEXTURE_2D)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, advance, font.height, 0, gl.RGBA, gl.UNSIGNED_BYTE, &rgba.Pix[0])
font.textures[ch].Unbind(gl.TEXTURE_2D)
}
return &font
}
func uploadTexture_RGBA32(w, h int, data []byte) gl.Texture {
id := gl.GenTexture()
id.Bind(gl.TEXTURE_2D)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_R, gl.CLAMP_TO_EDGE)
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int(w), int(h), 0, gl.RGBA, gl.UNSIGNED_BYTE, data)
if gl.GetError() != gl.NO_ERROR {
id.Delete()
panic("Failed to load a texture")
return 0
}
return id
}
func (t *TextureData) GenTexture() {
t.id = gl.GenTexture()
if t.id == 0 {
panic("0 id generated by gl.GenTexture()")
}
}
