mirror of https://github.com/liamg/aminal.git
113 lines
2.4 KiB
Go
113 lines
2.4 KiB
Go
// Copyright 2012 The go-gl Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package gltext
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"image"
|
|
"image/color"
|
|
"os"
|
|
)
|
|
|
|
// Pow2 returns the first power-of-two value >= to n.
|
|
// This can be used to create suitable texture dimensions.
|
|
func Pow2(x uint32) uint32 {
|
|
x--
|
|
x |= x >> 1
|
|
x |= x >> 2
|
|
x |= x >> 4
|
|
x |= x >> 8
|
|
x |= x >> 16
|
|
return x + 1
|
|
}
|
|
|
|
// IsPow2 returns true if the given value is a power-of-two.
|
|
func IsPow2(x uint32) bool { return (x & (x - 1)) == 0 }
|
|
|
|
// Pow2Image returns the given image, scaled to the smallest power-of-two
|
|
// dimensions larger or equal to the input dimensions.
|
|
// It preserves the image format and contents.
|
|
//
|
|
// This is useful if an image is to be used as an OpenGL texture.
|
|
// These often require image data to have power-of-two dimensions.
|
|
func Pow2Image(src image.Image) image.Image {
|
|
sb := src.Bounds()
|
|
w, h := uint32(sb.Dx()), uint32(sb.Dy())
|
|
|
|
if IsPow2(w) && IsPow2(h) {
|
|
return src // Nothing to do.
|
|
}
|
|
|
|
rect := image.Rect(0, 0, int(Pow2(w)), int(Pow2(h)))
|
|
|
|
switch src := src.(type) {
|
|
case *image.Alpha:
|
|
return copyImg(src, image.NewAlpha(rect))
|
|
|
|
case *image.Alpha16:
|
|
return copyImg(src, image.NewAlpha16(rect))
|
|
|
|
case *image.Gray:
|
|
return copyImg(src, image.NewGray(rect))
|
|
|
|
case *image.Gray16:
|
|
return copyImg(src, image.NewGray16(rect))
|
|
|
|
case *image.NRGBA:
|
|
return copyImg(src, image.NewNRGBA(rect))
|
|
|
|
case *image.NRGBA64:
|
|
return copyImg(src, image.NewNRGBA64(rect))
|
|
|
|
case *image.Paletted:
|
|
return copyImg(src, image.NewPaletted(rect, src.Palette))
|
|
|
|
case *image.RGBA:
|
|
return copyImg(src, image.NewRGBA(rect))
|
|
|
|
case *image.RGBA64:
|
|
return copyImg(src, image.NewRGBA64(rect))
|
|
}
|
|
|
|
panic(fmt.Sprintf("Unsupported image format: %T", src))
|
|
}
|
|
|
|
// Why the image.Image interface does not support this,
|
|
// I can never understand.
|
|
type copyable interface {
|
|
image.Image
|
|
Set(x, y int, clr color.Color)
|
|
}
|
|
|
|
func copyImg(src, dst copyable) image.Image {
|
|
var x, y int
|
|
sb := src.Bounds()
|
|
|
|
for y = 0; y < sb.Dy(); y++ {
|
|
for x = 0; x < sb.Dx(); x++ {
|
|
dst.Set(x, y, src.At(x, y))
|
|
}
|
|
}
|
|
|
|
return dst
|
|
}
|
|
|
|
func LoadImage(path string) (*image.NRGBA, error) {
|
|
img, err := os.Open(path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
pix, _, err := image.Decode(img)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
p, ok := pix.(*image.NRGBA)
|
|
if ok {
|
|
return p, nil
|
|
}
|
|
return nil, errors.New("Not a NRGBA image.")
|
|
}
|