kistaro/apgbpal
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: kistaro:9318a0f46cb1c8549b602bddc7bc9578694ba72c
Branches Tags
kistaro:main
..
compare: kistaro:e3443d57f51af0aca96e943665e645bc87e1b63d
Branches Tags
kistaro:main

No commits in common. "9318a0f46cb1c8549b602bddc7bc9578694ba72c" and "e3443d57f51af0aca96e943665e645bc87e1b63d" have entirely different histories.
9318a0f46c ... e3443d57f5

2 changed files with 19 additions and 74 deletions
Show Stats Expand all files Collapse all files

89
apgbpal.go
View File

@ -1,32 +1,9 @@
package main package main
// Binary apgbpal creates a 56-byte file named "test.pal" in the current working
// directory. I hope it might be an Analogue Pocket GB Palette file, but I don't
// know that for sure yet.
// apgbpal is licensed under 0BSD.
//
// Zero-Clause BSD
// =============
//
// Permission to use, copy, modify, and/or distribute this software for
// any purpose with or without fee is hereby granted.
//
// THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL
// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE
// FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY
// DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
// AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
// OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
import ( import (
"fmt" "fmt"
"log"
"os"
"strconv"
"strings" "strings"
"log"
) )
type RGBA struct { type RGBA struct {
@ -37,11 +14,11 @@ type RGBA struct {
} }
func (c RGBA) Bytes() [4]byte { func (c RGBA) Bytes() [4]byte {
return [4]byte{c.R, c.G, c.B, c.A} return [4]byte {c.R, c.G, cB, c.A}
} }
func HexByteAt(str string, index int) (byte, error) { func HexByteAt(str string, index int) (byte, error) {
if len(str) < index+2 { if len(string) < index + 2 {
return 0, fmt.Errorf("no hex byte at %d in too short string %q", index, str) return 0, fmt.Errorf("no hex byte at %d in too short string %q", index, str)
} }
big, err := strconv.ParseUint(str[index:index+1], 16, 8) big, err := strconv.ParseUint(str[index:index+1], 16, 8)
@ -51,7 +28,7 @@ func HexByteAt(str string, index int) (byte, error) {
return byte(big), nil return byte(big), nil
} }
func ParseRGBA(str string) (RGBA, error) { func MustParseRGBA(str string) RGBA {
s := strings.TrimSpace(str) s := strings.TrimSpace(str)
s = strings.ToLower(s) s = strings.ToLower(s)
s, _ = strings.CutPrefix(s, "#") s, _ = strings.CutPrefix(s, "#")
@ -63,22 +40,20 @@ func ParseRGBA(str string) (RGBA, error) {
var err error var err error
ret.A, err = HexByteAt(s, 6) ret.A, err = HexByteAt(s, 6)
if err != nil { if err != nil {
return RGBA{}, fmt.Errorf("can't parse alpha channel: %v", err) log.Fatalf("can't parse alpha channel: %v", err)
} }
default: default:
return RGBA{}, fmt.Errorf("%q is not an RGBA value: wrong length after trimming", str) log.Fatalf("%q is not an RGBA value: wrong length after trimming", str)
} }
var err error if ret.R, err := HexByteAt(s, 0); err != nil {
if ret.R, err = HexByteAt(s, 0); err != nil { log.Fatalf("can't parse red channel: %v", err)
return RGBA{}, fmt.Errorf("can't parse red channel: %v", err)
} }
if ret.G, err = HexByteAt(s, 2); err != nil { if ret.G, err := HexByteAt(s, 2); err != nil {
return RGBA{}, fmt.Errorf("can't parse green channel: %v", err) log.Fatalf("can't parse green channel: %v", err)
} }
if ret.B, err = HexByteAt(s, 4); err != nil { if ret.B, err := HexByteAt(s, 4); err != nil {
return RGBA{}, fmt.Errorf("can't parse blue channel: %v", err) log.Fatalf("can't parse blue channel: %v", err)
} }
return ret, nil
} }
type BGPal [4]RGBA type BGPal [4]RGBA
@ -91,7 +66,7 @@ func (b BGPal) Bytes() [20]byte {
for c := 0; c < 4; c++ { for c := 0; c < 4; c++ {
bb := b[c].Bytes() bb := b[c].Bytes()
for i := 0; i < 4; i++ { for i := 0; i < 4; i++ {
ret[3+i+4*c] = bb[i] ret[3+i+4*c]=bb[i]
} }
} }
ret[19] = '\n' ret[19] = '\n'
@ -104,8 +79,7 @@ func MustParseBGPal(strs []string) BGPal {
} }
var ret BGPal var ret BGPal
for i := 0; i < 4; i++ { for i := 0; i < 4; i++ {
var err error ret[i], err := MustParseRGBA(strs[i])
ret[i], err = ParseRGBA(strs[i])
if err != nil { if err != nil {
log.Fatalf("MustParseBGPal can't parse at %d: %v", i, err) log.Fatalf("MustParseBGPal can't parse at %d: %v", i, err)
} }
@ -125,25 +99,20 @@ func (o OBJPal) Bytes(indexchar byte) [18]byte {
for c := 0; c < 3; c++ { for c := 0; c < 3; c++ {
oo := o[c].Bytes() oo := o[c].Bytes()
for i := 0; i < 4; i++ { for i := 0; i < 4; i++ {
ret[5+i+4*c] = oo[i] ret[5+i+4*c]=oo[i]
} }
} }
ret[17] = '\n' ret[17] = '\n'
return ret return ret
} }
func MustParseOBJPal(strs []string) OBJPal { func MustParseOBJPal {
if len(strs) == 4 {
log.Println("Discarding index 0 of OBJ pal")
strs = strs[1:]
}
if len(strs) != 3 { if len(strs) != 3 {
log.Fatalf("MustParseObjPal requires length 3, got %d", len(strs)) log.Fatalf("MustParseObjPal requires length 3, got %d", len(strs))
} }
var ret OBJPal var ret OBJPal
for i := 0; i < 3; i++ { for i := 0; i < 3; i++ {
var err error ret[i], err := MustParseRGBA(strs[i])
ret[i], err = ParseRGBA(strs[i])
if err != nil { if err != nil {
log.Fatalf("MustParseOBJPal can't parse at %d: %v", i, err) log.Fatalf("MustParseOBJPal can't parse at %d: %v", i, err)
} }
@ -171,27 +140,3 @@ func (a APGBPal) Bytes() [56]byte {
return ret return ret
} }
func main() {
f, err := os.OpenFile(
"test.pal",
os.O_WRONLY|os.O_CREATE|os.O_EXCL,
0644)
if err != nil {
log.Fatalf("can't create test.pal: %v", err)
}
aUpPal := APGBPal{
BG: MustParseBGPal([]string{"ffffff", "ff8484", "943a3a", "000000"}),
OBJ0: MustParseOBJPal([]string{"7bff31", "008400", "000000"}),
OBJ1: MustParseOBJPal([]string{"63a5ff", "0000ff", "000000"}),
}
palb := aUpPal.Bytes()
n, err := f.Write(palb[:])
if err != nil {
log.Fatalf("can't save test.pal: %v", err)
}
if n != 56 {
log.Fatalf("unexpected write length: %d", n)
}
f.Close()
os.Exit(0)
}

BIN
test.pal
View File

Binary file not shown.