Initial release: RadiantWave v1.0
This commit is contained in:
NeilClack
+948
@@ -0,0 +1,948 @@
|
||||
package sdl
|
||||
|
||||
// #include "sdl_wrapper.h"
|
||||
//
|
||||
// #if !(SDL_VERSION_ATLEAST(2,0,5))
|
||||
//
|
||||
// enum
|
||||
// {
|
||||
// #if SDL_BYTEORDER == SDL_BIG_ENDIAN
|
||||
// SDL_PIXELFORMAT_RGBA32 = SDL_PIXELFORMAT_RGBA8888,
|
||||
// SDL_PIXELFORMAT_ARGB32 = SDL_PIXELFORMAT_ARGB8888,
|
||||
// SDL_PIXELFORMAT_BGRA32 = SDL_PIXELFORMAT_BGRA8888,
|
||||
// SDL_PIXELFORMAT_ABGR32 = SDL_PIXELFORMAT_ABGR8888
|
||||
// #else
|
||||
// SDL_PIXELFORMAT_RGBA32 = SDL_PIXELFORMAT_ABGR8888,
|
||||
// SDL_PIXELFORMAT_ARGB32 = SDL_PIXELFORMAT_BGRA8888,
|
||||
// SDL_PIXELFORMAT_BGRA32 = SDL_PIXELFORMAT_ARGB8888,
|
||||
// SDL_PIXELFORMAT_ABGR32 = SDL_PIXELFORMAT_RGBA8888
|
||||
// #endif
|
||||
// };
|
||||
//
|
||||
// #endif
|
||||
//
|
||||
// int bytesPerPixel(Uint32 format) {
|
||||
// return SDL_BYTESPERPIXEL(format);
|
||||
// }
|
||||
//
|
||||
// int bitsPerPixel(Uint32 format) {
|
||||
// return SDL_BITSPERPIXEL(format);
|
||||
// }
|
||||
import "C"
|
||||
import (
|
||||
"image/color"
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
// PixelFormat contains pixel format information.
|
||||
// (https://wiki.libsdl.org/SDL_PixelFormat)
|
||||
type PixelFormat struct {
|
||||
Format uint32 // one of the PIXELFORMAT values (https://wiki.libsdl.org/SDL_PixelFormatEnum)
|
||||
Palette *Palette // palette structure associated with this pixel format, or nil if the format doesn't have a palette (https://wiki.libsdl.org/SDL_Palette)
|
||||
BitsPerPixel uint8 // the number of significant bits in a pixel value, eg: 8, 15, 16, 24, 32
|
||||
BytesPerPixel uint8 // the number of bytes required to hold a pixel value, eg: 1, 2, 3, 4
|
||||
_ [2]uint8 // padding
|
||||
Rmask uint32 // a mask representing the location of the red component of the pixel
|
||||
Gmask uint32 // a mask representing the location of the green component of the pixel
|
||||
Bmask uint32 // a mask representing the location of the blue component of the pixel
|
||||
Amask uint32 // a mask representing the location of the alpha component of the pixel or 0 if the pixel format doesn't have any alpha information
|
||||
rLoss uint8 // (internal use)
|
||||
gLoss uint8 // (internal use)
|
||||
bLoss uint8 // (internal use)
|
||||
aLoss uint8 // (internal use)
|
||||
rShift uint8 // (internal use)
|
||||
gShift uint8 // (internal use)
|
||||
bShift uint8 // (internal use)
|
||||
aShift uint8 // (internal use)
|
||||
refCount int32 // (internal use)
|
||||
next *PixelFormat // (internal use)
|
||||
}
|
||||
type cPixelFormat C.SDL_PixelFormat
|
||||
|
||||
// Palette contains palette information.
|
||||
// (https://wiki.libsdl.org/SDL_Palette)
|
||||
type Palette struct {
|
||||
Ncolors int32 // the number of colors in the palette
|
||||
Colors *Color // an array of Color structures representing the palette (https://wiki.libsdl.org/SDL_Color)
|
||||
version uint32 // incrementally tracks changes to the palette (internal use)
|
||||
refCount int32 // reference count (internal use)
|
||||
}
|
||||
type cPalette C.SDL_Palette
|
||||
|
||||
// Color represents a color. This implements image/color.Color interface.
|
||||
// (https://wiki.libsdl.org/SDL_Color)
|
||||
type Color color.NRGBA
|
||||
|
||||
// Uint32 return uint32 representation of RGBA color.
|
||||
func (c Color) Uint32() uint32 {
|
||||
var v uint32
|
||||
v |= uint32(c.R) << 24
|
||||
v |= uint32(c.G) << 16
|
||||
v |= uint32(c.B) << 8
|
||||
v |= uint32(c.A)
|
||||
return v
|
||||
}
|
||||
|
||||
// Pixel types.
|
||||
const (
|
||||
PIXELTYPE_UNKNOWN = C.SDL_PIXELTYPE_UNKNOWN
|
||||
PIXELTYPE_INDEX1 = C.SDL_PIXELTYPE_INDEX1
|
||||
PIXELTYPE_INDEX4 = C.SDL_PIXELTYPE_INDEX4
|
||||
PIXELTYPE_INDEX8 = C.SDL_PIXELTYPE_INDEX8
|
||||
PIXELTYPE_PACKED8 = C.SDL_PIXELTYPE_PACKED8
|
||||
PIXELTYPE_PACKED16 = C.SDL_PIXELTYPE_PACKED16
|
||||
PIXELTYPE_PACKED32 = C.SDL_PIXELTYPE_PACKED32
|
||||
PIXELTYPE_ARRAYU8 = C.SDL_PIXELTYPE_ARRAYU8
|
||||
PIXELTYPE_ARRAYU16 = C.SDL_PIXELTYPE_ARRAYU16
|
||||
PIXELTYPE_ARRAYU32 = C.SDL_PIXELTYPE_ARRAYU32
|
||||
PIXELTYPE_ARRAYF16 = C.SDL_PIXELTYPE_ARRAYF16
|
||||
PIXELTYPE_ARRAYF32 = C.SDL_PIXELTYPE_ARRAYF32
|
||||
)
|
||||
|
||||
// Bitmap pixel order high bit -> low bit.
|
||||
const (
|
||||
BITMAPORDER_NONE = C.SDL_BITMAPORDER_NONE
|
||||
BITMAPORDER_4321 = C.SDL_BITMAPORDER_4321
|
||||
BITMAPORDER_1234 = C.SDL_BITMAPORDER_1234
|
||||
)
|
||||
|
||||
// Packed component order high bit -> low bit.
|
||||
const (
|
||||
PACKEDORDER_NONE = C.SDL_PACKEDORDER_NONE
|
||||
PACKEDORDER_XRGB = C.SDL_PACKEDORDER_XRGB
|
||||
PACKEDORDER_RGBX = C.SDL_PACKEDORDER_RGBX
|
||||
PACKEDORDER_ARGB = C.SDL_PACKEDORDER_ARGB
|
||||
PACKEDORDER_RGBA = C.SDL_PACKEDORDER_RGBA
|
||||
PACKEDORDER_XBGR = C.SDL_PACKEDORDER_XBGR
|
||||
PACKEDORDER_BGRX = C.SDL_PACKEDORDER_BGRX
|
||||
PACKEDORDER_ABGR = C.SDL_PACKEDORDER_ABGR
|
||||
PACKEDORDER_BGRA = C.SDL_PACKEDORDER_BGRA
|
||||
)
|
||||
|
||||
// Array component order low byte -> high byte.
|
||||
const (
|
||||
ARRAYORDER_NONE = C.SDL_ARRAYORDER_NONE
|
||||
ARRAYORDER_RGB = C.SDL_ARRAYORDER_RGB
|
||||
ARRAYORDER_RGBA = C.SDL_ARRAYORDER_RGBA
|
||||
ARRAYORDER_ARGB = C.SDL_ARRAYORDER_ARGB
|
||||
ARRAYORDER_BGR = C.SDL_ARRAYORDER_BGR
|
||||
ARRAYORDER_BGRA = C.SDL_ARRAYORDER_BGRA
|
||||
ARRAYORDER_ABGR = C.SDL_ARRAYORDER_ABGR
|
||||
)
|
||||
|
||||
// Packed component layout.
|
||||
const (
|
||||
PACKEDLAYOUT_NONE = C.SDL_PACKEDLAYOUT_NONE
|
||||
PACKEDLAYOUT_332 = C.SDL_PACKEDLAYOUT_332
|
||||
PACKEDLAYOUT_4444 = C.SDL_PACKEDLAYOUT_4444
|
||||
PACKEDLAYOUT_1555 = C.SDL_PACKEDLAYOUT_1555
|
||||
PACKEDLAYOUT_5551 = C.SDL_PACKEDLAYOUT_5551
|
||||
PACKEDLAYOUT_565 = C.SDL_PACKEDLAYOUT_565
|
||||
PACKEDLAYOUT_8888 = C.SDL_PACKEDLAYOUT_8888
|
||||
PACKEDLAYOUT_2101010 = C.SDL_PACKEDLAYOUT_2101010
|
||||
PACKEDLAYOUT_1010102 = C.SDL_PACKEDLAYOUT_1010102
|
||||
)
|
||||
|
||||
// Pixel format values.
|
||||
const (
|
||||
PIXELFORMAT_UNKNOWN = C.SDL_PIXELFORMAT_UNKNOWN
|
||||
PIXELFORMAT_INDEX1LSB = C.SDL_PIXELFORMAT_INDEX1LSB
|
||||
PIXELFORMAT_INDEX1MSB = C.SDL_PIXELFORMAT_INDEX1MSB
|
||||
PIXELFORMAT_INDEX4LSB = C.SDL_PIXELFORMAT_INDEX4LSB
|
||||
PIXELFORMAT_INDEX4MSB = C.SDL_PIXELFORMAT_INDEX4MSB
|
||||
PIXELFORMAT_INDEX8 = C.SDL_PIXELFORMAT_INDEX8
|
||||
PIXELFORMAT_RGB332 = C.SDL_PIXELFORMAT_RGB332
|
||||
PIXELFORMAT_RGB444 = C.SDL_PIXELFORMAT_RGB444
|
||||
PIXELFORMAT_RGB555 = C.SDL_PIXELFORMAT_RGB555
|
||||
PIXELFORMAT_BGR555 = C.SDL_PIXELFORMAT_BGR555
|
||||
PIXELFORMAT_ARGB4444 = C.SDL_PIXELFORMAT_ARGB4444
|
||||
PIXELFORMAT_RGBA4444 = C.SDL_PIXELFORMAT_RGBA4444
|
||||
PIXELFORMAT_ABGR4444 = C.SDL_PIXELFORMAT_ABGR4444
|
||||
PIXELFORMAT_BGRA4444 = C.SDL_PIXELFORMAT_BGRA4444
|
||||
PIXELFORMAT_ARGB1555 = C.SDL_PIXELFORMAT_ARGB1555
|
||||
PIXELFORMAT_RGBA5551 = C.SDL_PIXELFORMAT_RGBA5551
|
||||
PIXELFORMAT_ABGR1555 = C.SDL_PIXELFORMAT_ABGR1555
|
||||
PIXELFORMAT_BGRA5551 = C.SDL_PIXELFORMAT_BGRA5551
|
||||
PIXELFORMAT_RGB565 = C.SDL_PIXELFORMAT_RGB565
|
||||
PIXELFORMAT_BGR565 = C.SDL_PIXELFORMAT_BGR565
|
||||
PIXELFORMAT_RGB24 = C.SDL_PIXELFORMAT_RGB24
|
||||
PIXELFORMAT_BGR24 = C.SDL_PIXELFORMAT_BGR24
|
||||
PIXELFORMAT_RGB888 = C.SDL_PIXELFORMAT_RGB888
|
||||
PIXELFORMAT_RGBX8888 = C.SDL_PIXELFORMAT_RGBX8888
|
||||
PIXELFORMAT_BGR888 = C.SDL_PIXELFORMAT_BGR888
|
||||
PIXELFORMAT_BGRX8888 = C.SDL_PIXELFORMAT_BGRX8888
|
||||
PIXELFORMAT_ARGB8888 = C.SDL_PIXELFORMAT_ARGB8888
|
||||
PIXELFORMAT_RGBA8888 = C.SDL_PIXELFORMAT_RGBA8888
|
||||
PIXELFORMAT_ABGR8888 = C.SDL_PIXELFORMAT_ABGR8888
|
||||
PIXELFORMAT_BGRA8888 = C.SDL_PIXELFORMAT_BGRA8888
|
||||
PIXELFORMAT_ARGB2101010 = C.SDL_PIXELFORMAT_ARGB2101010
|
||||
PIXELFORMAT_YV12 = C.SDL_PIXELFORMAT_YV12
|
||||
PIXELFORMAT_IYUV = C.SDL_PIXELFORMAT_IYUV
|
||||
PIXELFORMAT_YUY2 = C.SDL_PIXELFORMAT_YUY2
|
||||
PIXELFORMAT_UYVY = C.SDL_PIXELFORMAT_UYVY
|
||||
PIXELFORMAT_YVYU = C.SDL_PIXELFORMAT_YVYU
|
||||
)
|
||||
|
||||
// Pixel format variables.
|
||||
var (
|
||||
PIXELFORMAT_RGBA32 = C.SDL_PIXELFORMAT_RGBA32
|
||||
PIXELFORMAT_ARGB32 = C.SDL_PIXELFORMAT_ARGB32
|
||||
PIXELFORMAT_BGRA32 = C.SDL_PIXELFORMAT_BGRA32
|
||||
PIXELFORMAT_ABGR32 = C.SDL_PIXELFORMAT_ABGR32
|
||||
)
|
||||
|
||||
// These define alpha as the opacity of a surface.
|
||||
const (
|
||||
ALPHA_OPAQUE = C.SDL_ALPHA_OPAQUE
|
||||
ALPHA_TRANSPARENT = C.SDL_ALPHA_TRANSPARENT
|
||||
)
|
||||
|
||||
func (format *PixelFormat) cptr() *C.SDL_PixelFormat {
|
||||
return (*C.SDL_PixelFormat)(unsafe.Pointer(format))
|
||||
}
|
||||
|
||||
func (palette *Palette) cptr() *C.SDL_Palette {
|
||||
return (*C.SDL_Palette)(unsafe.Pointer(palette))
|
||||
}
|
||||
|
||||
/*
|
||||
* the following code is modified version of the code from bitbucket.org/dooots/go-sdl2
|
||||
*/
|
||||
|
||||
// GetPixelFormatName returns the human readable name of a pixel format.
|
||||
// (https://wiki.libsdl.org/SDL_GetPixelFormatName)
|
||||
func GetPixelFormatName(format uint) string {
|
||||
return C.GoString(C.SDL_GetPixelFormatName(C.Uint32(format)))
|
||||
}
|
||||
|
||||
// PixelFormatEnumToMasks converts one of the enumerated pixel formats to a bpp value and RGBA masks.
|
||||
// (https://wiki.libsdl.org/SDL_PixelFormatEnumToMasks)
|
||||
func PixelFormatEnumToMasks(format uint) (bpp int, rmask, gmask, bmask, amask uint32, err error) {
|
||||
result := C.SDL_PixelFormatEnumToMasks(C.Uint32(format), (*C.int)(unsafe.Pointer(&bpp)),
|
||||
(*C.Uint32)(&rmask), (*C.Uint32)(&gmask), (*C.Uint32)(&bmask),
|
||||
(*C.Uint32)(&amask))
|
||||
if result == C.SDL_FALSE {
|
||||
err = GetError()
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// MasksToPixelFormatEnum converts a bpp value and RGBA masks to an enumerated pixel format.
|
||||
// (https://wiki.libsdl.org/SDL_MasksToPixelFormatEnum)
|
||||
func MasksToPixelFormatEnum(bpp int, rmask, gmask, bmask, amask uint32) uint {
|
||||
return uint(C.SDL_MasksToPixelFormatEnum(C.int(bpp), C.Uint32(rmask), C.Uint32(gmask),
|
||||
C.Uint32(bmask), C.Uint32(amask)))
|
||||
}
|
||||
|
||||
// AllocFormat creates a PixelFormat structure corresponding to a pixel format.
|
||||
// (https://wiki.libsdl.org/SDL_AllocFormat)
|
||||
func AllocFormat(format uint) (*PixelFormat, error) {
|
||||
r := (*PixelFormat)(unsafe.Pointer(C.SDL_AllocFormat(C.Uint32(format))))
|
||||
if r == nil {
|
||||
return nil, GetError()
|
||||
}
|
||||
return r, nil
|
||||
}
|
||||
|
||||
// Free frees the PixelFormat structure allocated by AllocFormat().
|
||||
// (https://wiki.libsdl.org/SDL_FreeFormat)
|
||||
func (format *PixelFormat) Free() {
|
||||
C.SDL_FreeFormat((*C.SDL_PixelFormat)(unsafe.Pointer(format)))
|
||||
}
|
||||
|
||||
// AllocPalette creates a palette structure with the specified number of color entries.
|
||||
// (https://wiki.libsdl.org/SDL_AllocPalette)
|
||||
func AllocPalette(ncolors int) (*Palette, error) {
|
||||
r := (*Palette)(unsafe.Pointer(C.SDL_AllocPalette(C.int(ncolors))))
|
||||
if r == nil {
|
||||
return nil, GetError()
|
||||
}
|
||||
return r, nil
|
||||
}
|
||||
|
||||
// SetPalette sets the palette for the pixel format structure.
|
||||
// (https://wiki.libsdl.org/SDL_SetPixelFormatPalette)
|
||||
func (format *PixelFormat) SetPalette(palette *Palette) error {
|
||||
r := C.SDL_SetPixelFormatPalette((*C.SDL_PixelFormat)(unsafe.Pointer(format)),
|
||||
(*C.SDL_Palette)(unsafe.Pointer(palette)))
|
||||
if r != 0 {
|
||||
return GetError()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// SetColors sets a range of colors in the palette.
|
||||
// (https://wiki.libsdl.org/SDL_SetPaletteColors)
|
||||
func (palette *Palette) SetColors(colors []Color) error {
|
||||
if colors == nil {
|
||||
return nil
|
||||
}
|
||||
var ptr *C.SDL_Color
|
||||
if len(colors) > 0 {
|
||||
ptr = (*C.SDL_Color)(unsafe.Pointer(&colors[0]))
|
||||
}
|
||||
|
||||
r := C.SDL_SetPaletteColors((*C.SDL_Palette)(unsafe.Pointer(palette)),
|
||||
ptr, 0, C.int(len(colors)))
|
||||
if r != 0 {
|
||||
return GetError()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Free frees the palette created with AllocPalette().
|
||||
// (https://wiki.libsdl.org/SDL_FreePalette)
|
||||
func (palette *Palette) Free() {
|
||||
C.SDL_FreePalette((*C.SDL_Palette)(unsafe.Pointer(palette)))
|
||||
}
|
||||
|
||||
// MapRGB maps an RGB triple to an opaque pixel value for a given pixel format.
|
||||
// (https://wiki.libsdl.org/SDL_MapRGB)
|
||||
func MapRGB(format *PixelFormat, r, g, b uint8) uint32 {
|
||||
return uint32(C.SDL_MapRGB((*C.SDL_PixelFormat)(unsafe.Pointer(format)),
|
||||
C.Uint8(r), C.Uint8(g), C.Uint8(b)))
|
||||
}
|
||||
|
||||
// MapRGBA maps an RGBA quadruple to a pixel value for a given pixel format.
|
||||
// (https://wiki.libsdl.org/SDL_MapRGBA)
|
||||
func MapRGBA(format *PixelFormat, r, g, b, a uint8) uint32 {
|
||||
return uint32(C.SDL_MapRGBA((*C.SDL_PixelFormat)(unsafe.Pointer(format)),
|
||||
C.Uint8(r), C.Uint8(g), C.Uint8(b), C.Uint8(a)))
|
||||
}
|
||||
|
||||
// GetRGB returns RGB values from a pixel in the specified format.
|
||||
// (https://wiki.libsdl.org/SDL_GetRGB)
|
||||
func GetRGB(pixel uint32, format *PixelFormat) (r, g, b uint8) {
|
||||
C.SDL_GetRGB(C.Uint32(pixel), (*C.SDL_PixelFormat)(unsafe.Pointer(format)),
|
||||
(*C.Uint8)(&r), (*C.Uint8)(&g), (*C.Uint8)(&b))
|
||||
return
|
||||
}
|
||||
|
||||
// GetRGBA returns RGBA values from a pixel in the specified format.
|
||||
// (https://wiki.libsdl.org/SDL_GetRGBA)
|
||||
func GetRGBA(pixel uint32, format *PixelFormat) (r, g, b, a uint8) {
|
||||
C.SDL_GetRGBA(C.Uint32(pixel), (*C.SDL_PixelFormat)(unsafe.Pointer(format)),
|
||||
(*C.Uint8)(&r), (*C.Uint8)(&g), (*C.Uint8)(&b), (*C.Uint8)(&a))
|
||||
return
|
||||
}
|
||||
|
||||
// CalculateGammaRamp calculates a 256 entry gamma ramp for a gamma value.
|
||||
// (https://wiki.libsdl.org/SDL_CalculateGammaRamp)
|
||||
func CalculateGammaRamp(gamma float32, ramp *[256]uint16) {
|
||||
C.SDL_CalculateGammaRamp(C.float(gamma), (*C.Uint16)(unsafe.Pointer(&ramp[0])))
|
||||
}
|
||||
|
||||
// BytesPerPixel returns the number of bytes per pixel for the given format
|
||||
func BytesPerPixel(format uint32) int {
|
||||
return int(C.bytesPerPixel(C.Uint32(format)))
|
||||
}
|
||||
|
||||
// BitsPerPixel returns the number of bits per pixel for the given format
|
||||
func BitsPerPixel(format uint32) int {
|
||||
return int(C.bitsPerPixel(C.Uint32(format)))
|
||||
}
|
||||
|
||||
var (
|
||||
RGB444Model color.Model = color.ModelFunc(rgb444Model)
|
||||
RGB332Model color.Model = color.ModelFunc(rgb332Model)
|
||||
RGB565Model color.Model = color.ModelFunc(rgb565Model)
|
||||
RGB555Model color.Model = color.ModelFunc(rgb555Model)
|
||||
BGR565Model color.Model = color.ModelFunc(bgr565Model)
|
||||
BGR555Model color.Model = color.ModelFunc(bgr555Model)
|
||||
ARGB4444Model color.Model = color.ModelFunc(argb4444Model)
|
||||
ABGR4444Model color.Model = color.ModelFunc(abgr4444Model)
|
||||
RGBA4444Model color.Model = color.ModelFunc(rgba4444Model)
|
||||
BGRA4444Model color.Model = color.ModelFunc(bgra4444Model)
|
||||
ARGB1555Model color.Model = color.ModelFunc(argb1555Model)
|
||||
RGBA5551Model color.Model = color.ModelFunc(rgba5551Model)
|
||||
ABGR1555Model color.Model = color.ModelFunc(abgr1555Model)
|
||||
BGRA5551Model color.Model = color.ModelFunc(bgra5551Model)
|
||||
RGBA8888Model color.Model = color.ModelFunc(rgba8888Model)
|
||||
BGRA8888Model color.Model = color.ModelFunc(bgra8888Model)
|
||||
)
|
||||
|
||||
type RGB444 struct {
|
||||
R, G, B byte
|
||||
}
|
||||
|
||||
func (c RGB444) RGBA() (r, g, b, a uint32) {
|
||||
nrgba := color.NRGBA{
|
||||
R: upscale4to8bit(c.R),
|
||||
G: upscale4to8bit(c.G),
|
||||
B: upscale4to8bit(c.B),
|
||||
A: 0xFF,
|
||||
}
|
||||
return nrgba.RGBA()
|
||||
}
|
||||
|
||||
func rgb444Model(c color.Color) color.Color {
|
||||
if _, ok := c.(RGB444); ok {
|
||||
return c
|
||||
}
|
||||
nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
|
||||
return RGB444{
|
||||
R: downscale8to4bit(nrgba.R),
|
||||
G: downscale8to4bit(nrgba.G),
|
||||
B: downscale8to4bit(nrgba.B),
|
||||
}
|
||||
}
|
||||
|
||||
type RGB332 struct {
|
||||
R, G, B byte
|
||||
}
|
||||
|
||||
func (c RGB332) RGBA() (r, g, b, a uint32) {
|
||||
nrgba := color.NRGBA{
|
||||
R: upscale3to8bit(c.R),
|
||||
G: upscale3to8bit(c.G),
|
||||
B: upscale2to8bit(c.B),
|
||||
A: 0xFF,
|
||||
}
|
||||
return nrgba.RGBA()
|
||||
}
|
||||
|
||||
func rgb332Model(c color.Color) color.Color {
|
||||
if _, ok := c.(RGB332); ok {
|
||||
return c
|
||||
}
|
||||
nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
|
||||
return RGB332{
|
||||
R: downscale8to3bit(nrgba.R),
|
||||
G: downscale8to3bit(nrgba.G),
|
||||
B: downscale8to2bit(nrgba.B),
|
||||
}
|
||||
}
|
||||
|
||||
type RGB565 struct {
|
||||
R, G, B byte
|
||||
}
|
||||
|
||||
func (c RGB565) RGBA() (r, g, b, a uint32) {
|
||||
nrgba := color.NRGBA{
|
||||
R: upscale5to8bit(c.R),
|
||||
G: upscale6to8bit(c.G),
|
||||
B: upscale5to8bit(c.B),
|
||||
A: 0xFF,
|
||||
}
|
||||
return nrgba.RGBA()
|
||||
}
|
||||
|
||||
func rgb565Model(c color.Color) color.Color {
|
||||
if _, ok := c.(RGB565); ok {
|
||||
return c
|
||||
}
|
||||
nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
|
||||
return RGB565{
|
||||
R: downscale8to5bit(nrgba.R),
|
||||
G: downscale8to6bit(nrgba.G),
|
||||
B: downscale8to5bit(nrgba.B),
|
||||
}
|
||||
}
|
||||
|
||||
type RGB555 struct {
|
||||
R, G, B byte
|
||||
}
|
||||
|
||||
func (c RGB555) RGBA() (r, g, b, a uint32) {
|
||||
nrgba := color.NRGBA{
|
||||
R: upscale5to8bit(c.R),
|
||||
G: upscale5to8bit(c.G),
|
||||
B: upscale5to8bit(c.B),
|
||||
A: 0xFF,
|
||||
}
|
||||
return nrgba.RGBA()
|
||||
}
|
||||
|
||||
func rgb555Model(c color.Color) color.Color {
|
||||
if _, ok := c.(RGB555); ok {
|
||||
return c
|
||||
}
|
||||
nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
|
||||
return RGB555{
|
||||
R: downscale8to5bit(nrgba.R),
|
||||
G: downscale8to5bit(nrgba.G),
|
||||
B: downscale8to5bit(nrgba.B),
|
||||
}
|
||||
}
|
||||
|
||||
type BGR565 struct {
|
||||
B, G, R byte
|
||||
}
|
||||
|
||||
func (c BGR565) RGBA() (r, g, b, a uint32) {
|
||||
nrgba := color.NRGBA{
|
||||
R: upscale5to8bit(c.R),
|
||||
G: upscale6to8bit(c.G),
|
||||
B: upscale5to8bit(c.B),
|
||||
A: 0xFF,
|
||||
}
|
||||
return nrgba.RGBA()
|
||||
}
|
||||
|
||||
func bgr565Model(c color.Color) color.Color {
|
||||
if _, ok := c.(BGR565); ok {
|
||||
return c
|
||||
}
|
||||
nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
|
||||
return BGR565{
|
||||
B: downscale8to5bit(nrgba.B),
|
||||
G: downscale8to6bit(nrgba.G),
|
||||
R: downscale8to5bit(nrgba.R),
|
||||
}
|
||||
}
|
||||
|
||||
type BGR555 struct {
|
||||
B, G, R byte
|
||||
}
|
||||
|
||||
func (c BGR555) RGBA() (r, g, b, a uint32) {
|
||||
nrgba := color.NRGBA{
|
||||
R: upscale5to8bit(c.R),
|
||||
G: upscale5to8bit(c.G),
|
||||
B: upscale5to8bit(c.B),
|
||||
A: 0xFF,
|
||||
}
|
||||
return nrgba.RGBA()
|
||||
}
|
||||
|
||||
func bgr555Model(c color.Color) color.Color {
|
||||
if _, ok := c.(BGR555); ok {
|
||||
return c
|
||||
}
|
||||
nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
|
||||
return BGR555{
|
||||
B: downscale8to5bit(nrgba.B),
|
||||
G: downscale8to5bit(nrgba.G),
|
||||
R: downscale8to5bit(nrgba.R),
|
||||
}
|
||||
}
|
||||
|
||||
type RGB888 struct {
|
||||
R, G, B byte
|
||||
}
|
||||
|
||||
func (c RGB888) RGBA() (r, g, b, a uint32) {
|
||||
nrgba := color.NRGBA{
|
||||
R: c.R,
|
||||
G: c.G,
|
||||
B: c.B,
|
||||
A: 0xFF,
|
||||
}
|
||||
return nrgba.RGBA()
|
||||
}
|
||||
|
||||
func rgb888Model(c color.Color) color.Color {
|
||||
if _, ok := c.(RGB888); ok {
|
||||
return c
|
||||
}
|
||||
nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
|
||||
return RGB888{
|
||||
R: nrgba.R,
|
||||
G: nrgba.G,
|
||||
B: nrgba.B,
|
||||
}
|
||||
}
|
||||
|
||||
type BGR888 struct {
|
||||
B, G, R byte
|
||||
}
|
||||
|
||||
func (c BGR888) RGBA() (r, g, b, a uint32) {
|
||||
nrgba := color.NRGBA{
|
||||
R: c.R,
|
||||
G: c.G,
|
||||
B: c.B,
|
||||
A: 0xFF,
|
||||
}
|
||||
return nrgba.RGBA()
|
||||
}
|
||||
|
||||
func bgr888Model(c color.Color) color.Color {
|
||||
if _, ok := c.(BGR888); ok {
|
||||
return c
|
||||
}
|
||||
nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
|
||||
return BGR888{
|
||||
B: nrgba.B,
|
||||
G: nrgba.G,
|
||||
R: nrgba.R,
|
||||
}
|
||||
}
|
||||
|
||||
type ARGB4444 struct {
|
||||
A, R, G, B byte
|
||||
}
|
||||
|
||||
func (c ARGB4444) RGBA() (r, g, b, a uint32) {
|
||||
nrgba := color.NRGBA{
|
||||
R: upscale4to8bit(c.R),
|
||||
G: upscale4to8bit(c.G),
|
||||
B: upscale4to8bit(c.B),
|
||||
A: upscale4to8bit(c.A),
|
||||
}
|
||||
return nrgba.RGBA()
|
||||
}
|
||||
|
||||
func argb4444Model(c color.Color) color.Color {
|
||||
if _, ok := c.(ARGB4444); ok {
|
||||
return c
|
||||
}
|
||||
nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
|
||||
return ARGB4444{
|
||||
A: downscale8to4bit(nrgba.A),
|
||||
R: downscale8to4bit(nrgba.R),
|
||||
G: downscale8to4bit(nrgba.G),
|
||||
B: downscale8to4bit(nrgba.B),
|
||||
}
|
||||
}
|
||||
|
||||
type ABGR4444 struct {
|
||||
A, B, G, R byte
|
||||
}
|
||||
|
||||
func (c ABGR4444) RGBA() (r, g, b, a uint32) {
|
||||
nrgba := color.NRGBA{
|
||||
R: upscale4to8bit(c.R),
|
||||
G: upscale4to8bit(c.G),
|
||||
B: upscale4to8bit(c.B),
|
||||
A: upscale4to8bit(c.A),
|
||||
}
|
||||
return nrgba.RGBA()
|
||||
}
|
||||
|
||||
func abgr4444Model(c color.Color) color.Color {
|
||||
if _, ok := c.(ABGR4444); ok {
|
||||
return c
|
||||
}
|
||||
nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
|
||||
return ABGR4444{
|
||||
A: downscale8to4bit(nrgba.A),
|
||||
B: downscale8to4bit(nrgba.B),
|
||||
G: downscale8to4bit(nrgba.G),
|
||||
R: downscale8to4bit(nrgba.R),
|
||||
}
|
||||
}
|
||||
|
||||
type RGBA4444 struct {
|
||||
R, G, B, A byte
|
||||
}
|
||||
|
||||
func (c RGBA4444) RGBA() (r, g, b, a uint32) {
|
||||
nrgba := color.NRGBA{
|
||||
R: upscale4to8bit(c.R),
|
||||
G: upscale4to8bit(c.G),
|
||||
B: upscale4to8bit(c.B),
|
||||
A: upscale4to8bit(c.A),
|
||||
}
|
||||
return nrgba.RGBA()
|
||||
}
|
||||
|
||||
func rgba4444Model(c color.Color) color.Color {
|
||||
if _, ok := c.(RGBA4444); ok {
|
||||
return c
|
||||
}
|
||||
nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
|
||||
return RGBA4444{
|
||||
R: downscale8to4bit(nrgba.R),
|
||||
G: downscale8to4bit(nrgba.G),
|
||||
B: downscale8to4bit(nrgba.B),
|
||||
A: downscale8to4bit(nrgba.A),
|
||||
}
|
||||
}
|
||||
|
||||
type BGRA4444 struct {
|
||||
B, G, R, A byte
|
||||
}
|
||||
|
||||
func (c BGRA4444) RGBA() (r, g, b, a uint32) {
|
||||
nrgba := color.NRGBA{
|
||||
R: upscale4to8bit(c.R),
|
||||
G: upscale4to8bit(c.G),
|
||||
B: upscale4to8bit(c.B),
|
||||
A: upscale4to8bit(c.A),
|
||||
}
|
||||
return nrgba.RGBA()
|
||||
}
|
||||
|
||||
func bgra4444Model(c color.Color) color.Color {
|
||||
if _, ok := c.(BGRA4444); ok {
|
||||
return c
|
||||
}
|
||||
nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
|
||||
return BGRA4444{
|
||||
B: downscale8to4bit(nrgba.B),
|
||||
G: downscale8to4bit(nrgba.G),
|
||||
R: downscale8to4bit(nrgba.R),
|
||||
A: downscale8to4bit(nrgba.A),
|
||||
}
|
||||
}
|
||||
|
||||
type ARGB1555 struct {
|
||||
A, R, G, B byte
|
||||
}
|
||||
|
||||
func (c ARGB1555) RGBA() (r, g, b, a uint32) {
|
||||
nrgba := color.NRGBA{
|
||||
R: upscale5to8bit(c.R),
|
||||
G: upscale5to8bit(c.G),
|
||||
B: upscale5to8bit(c.B),
|
||||
A: upscale1to8bit(c.A),
|
||||
}
|
||||
return nrgba.RGBA()
|
||||
}
|
||||
|
||||
func argb1555Model(c color.Color) color.Color {
|
||||
if _, ok := c.(ARGB1555); ok {
|
||||
return c
|
||||
}
|
||||
nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
|
||||
return ARGB1555{
|
||||
A: downscale8to1bit(nrgba.A),
|
||||
R: downscale8to5bit(nrgba.R),
|
||||
G: downscale8to5bit(nrgba.G),
|
||||
B: downscale8to5bit(nrgba.B),
|
||||
}
|
||||
}
|
||||
|
||||
type RGBA5551 struct {
|
||||
R, G, B, A byte
|
||||
}
|
||||
|
||||
func (c RGBA5551) RGBA() (r, g, b, a uint32) {
|
||||
nrgba := color.NRGBA{
|
||||
R: upscale5to8bit(c.R),
|
||||
G: upscale5to8bit(c.G),
|
||||
B: upscale5to8bit(c.B),
|
||||
A: upscale1to8bit(c.A),
|
||||
}
|
||||
return nrgba.RGBA()
|
||||
}
|
||||
|
||||
func rgba5551Model(c color.Color) color.Color {
|
||||
if _, ok := c.(RGBA5551); ok {
|
||||
return c
|
||||
}
|
||||
nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
|
||||
return RGBA5551{
|
||||
R: downscale8to5bit(nrgba.R),
|
||||
G: downscale8to5bit(nrgba.G),
|
||||
B: downscale8to5bit(nrgba.B),
|
||||
A: downscale8to1bit(nrgba.A),
|
||||
}
|
||||
}
|
||||
|
||||
type ABGR1555 struct {
|
||||
A, R, G, B byte
|
||||
}
|
||||
|
||||
func (c ABGR1555) RGBA() (r, g, b, a uint32) {
|
||||
nrgba := color.NRGBA{
|
||||
R: upscale5to8bit(c.R),
|
||||
G: upscale5to8bit(c.G),
|
||||
B: upscale5to8bit(c.B),
|
||||
A: upscale1to8bit(c.A),
|
||||
}
|
||||
return nrgba.RGBA()
|
||||
}
|
||||
|
||||
func abgr1555Model(c color.Color) color.Color {
|
||||
if _, ok := c.(ABGR1555); ok {
|
||||
return c
|
||||
}
|
||||
nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
|
||||
return ABGR1555{
|
||||
A: downscale8to1bit(nrgba.A),
|
||||
R: downscale8to5bit(nrgba.R),
|
||||
G: downscale8to5bit(nrgba.G),
|
||||
B: downscale8to5bit(nrgba.B),
|
||||
}
|
||||
}
|
||||
|
||||
type BGRA5551 struct {
|
||||
B, G, R, A byte
|
||||
}
|
||||
|
||||
func (c BGRA5551) RGBA() (r, g, b, a uint32) {
|
||||
nrgba := color.NRGBA{
|
||||
R: upscale5to8bit(c.R),
|
||||
G: upscale5to8bit(c.G),
|
||||
B: upscale5to8bit(c.B),
|
||||
A: upscale1to8bit(c.A),
|
||||
}
|
||||
return nrgba.RGBA()
|
||||
}
|
||||
|
||||
func bgra5551Model(c color.Color) color.Color {
|
||||
if _, ok := c.(BGRA5551); ok {
|
||||
return c
|
||||
}
|
||||
nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
|
||||
return BGRA5551{
|
||||
B: downscale8to5bit(nrgba.B),
|
||||
G: downscale8to5bit(nrgba.G),
|
||||
R: downscale8to5bit(nrgba.R),
|
||||
A: downscale8to1bit(nrgba.A),
|
||||
}
|
||||
}
|
||||
|
||||
type RGBA8888 struct {
|
||||
R, G, B, A byte
|
||||
}
|
||||
|
||||
func (c RGBA8888) RGBA() (r, g, b, a uint32) {
|
||||
nrgba := color.NRGBA{
|
||||
R: c.R,
|
||||
G: c.G,
|
||||
B: c.B,
|
||||
A: c.A,
|
||||
}
|
||||
return nrgba.RGBA()
|
||||
}
|
||||
|
||||
func rgba8888Model(c color.Color) color.Color {
|
||||
if _, ok := c.(RGBA8888); ok {
|
||||
return c
|
||||
}
|
||||
nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
|
||||
return RGBA8888{
|
||||
R: nrgba.R,
|
||||
G: nrgba.G,
|
||||
B: nrgba.B,
|
||||
A: nrgba.A,
|
||||
}
|
||||
}
|
||||
|
||||
type BGRA8888 struct {
|
||||
B, G, R, A byte
|
||||
}
|
||||
|
||||
func (c BGRA8888) RGBA() (r, g, b, a uint32) {
|
||||
nrgba := color.NRGBA{
|
||||
R: c.R,
|
||||
G: c.G,
|
||||
B: c.B,
|
||||
A: c.A,
|
||||
}
|
||||
return nrgba.RGBA()
|
||||
}
|
||||
|
||||
func bgra8888Model(c color.Color) color.Color {
|
||||
if _, ok := c.(BGRA8888); ok {
|
||||
return c
|
||||
}
|
||||
nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
|
||||
return BGRA8888{
|
||||
B: nrgba.B,
|
||||
G: nrgba.G,
|
||||
R: nrgba.R,
|
||||
A: nrgba.A,
|
||||
}
|
||||
}
|
||||
|
||||
type ARGB8888 struct {
|
||||
A, R, G, B byte
|
||||
}
|
||||
|
||||
func (c ARGB8888) RGBA() (r, g, b, a uint32) {
|
||||
nrgba := color.NRGBA{
|
||||
R: c.R,
|
||||
G: c.G,
|
||||
B: c.B,
|
||||
A: c.A,
|
||||
}
|
||||
return nrgba.RGBA()
|
||||
}
|
||||
|
||||
func argb8888Model(c color.Color) color.Color {
|
||||
if _, ok := c.(ARGB8888); ok {
|
||||
return c
|
||||
}
|
||||
nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
|
||||
return ARGB8888{
|
||||
A: nrgba.A,
|
||||
R: nrgba.R,
|
||||
G: nrgba.G,
|
||||
B: nrgba.B,
|
||||
}
|
||||
}
|
||||
|
||||
type ABGR8888 struct {
|
||||
A, B, G, R byte
|
||||
}
|
||||
|
||||
func (c ABGR8888) RGBA() (r, g, b, a uint32) {
|
||||
nrgba := color.NRGBA{
|
||||
R: c.R,
|
||||
G: c.G,
|
||||
B: c.B,
|
||||
A: c.A,
|
||||
}
|
||||
return nrgba.RGBA()
|
||||
}
|
||||
|
||||
func abgr8888Model(c color.Color) color.Color {
|
||||
if _, ok := c.(ABGR8888); ok {
|
||||
return c
|
||||
}
|
||||
nrgba := color.NRGBAModel.Convert(c).(color.NRGBA)
|
||||
return ABGR8888{
|
||||
A: nrgba.A,
|
||||
B: nrgba.B,
|
||||
G: nrgba.G,
|
||||
R: nrgba.R,
|
||||
}
|
||||
}
|
||||
|
||||
func downscale8to1bit(alpha byte) byte {
|
||||
if alpha == 0 {
|
||||
return 0
|
||||
}
|
||||
return 1
|
||||
}
|
||||
|
||||
func downscale8to2bit(in byte) byte {
|
||||
return in >> 6
|
||||
}
|
||||
|
||||
func downscale8to3bit(in byte) byte {
|
||||
return in >> 5
|
||||
}
|
||||
|
||||
func downscale8to4bit(in byte) byte {
|
||||
return in >> 4
|
||||
}
|
||||
|
||||
func downscale8to5bit(in byte) byte {
|
||||
return in >> 3
|
||||
}
|
||||
|
||||
func downscale8to6bit(in byte) byte {
|
||||
return in >> 2
|
||||
}
|
||||
|
||||
func upscale1to8bit(alphaBit byte) byte {
|
||||
if alphaBit == 0 {
|
||||
return 0
|
||||
}
|
||||
return 0xFF
|
||||
}
|
||||
|
||||
func upscale2to8bit(in byte) byte {
|
||||
return in<<6 | in<<4 | in<<2 | in
|
||||
}
|
||||
|
||||
func upscale3to8bit(in byte) byte {
|
||||
return in<<5 | in<<2 | (in>>1)&0b11
|
||||
}
|
||||
|
||||
func upscale4to8bit(in byte) byte {
|
||||
return in<<4 | in
|
||||
}
|
||||
|
||||
func upscale5to8bit(in byte) byte {
|
||||
return in<<3 | (in>>2)&0b111
|
||||
}
|
||||
|
||||
func upscale6to8bit(in byte) byte {
|
||||
return in<<2 | (in>>4)&0b11
|
||||
}
|
||||
Reference in New Issue
Block a user