LCOV - code coverage report
Current view: top level - cmd - cutsprite.go Coverage Total Hit
Test: coverage.lcov Lines: 93.3 % 45 42
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package cmd
       2              : 
       3              : import (
       4              :         "context"
       5              :         "errors"
       6              :         "fmt"
       7              :         "image"
       8              :         "image/draw"
       9              :         "image/png"
      10              :         "os"
      11              :         "path/filepath"
      12              : 
      13              :         "github.com/urfave/cli/v3"
      14              : )
      15              : 
      16              : // spriteCellSize はスプライトシートの1マスの辺の長さ
      17              : const spriteCellSize = 32
      18              : 
      19              : // outFlag は書き出し先を受け取るフラグの名前
      20              : const outFlag = "out"
      21              : 
      22              : // errNoImageArg は切り出す画像のパスが渡されないときに返す
      23              : var errNoImageArg = errors.New("image path is required")
      24              : 
      25              : // CmdCutSprite は画像を32ピクセル角のマスに切り、単体のスプライトとして書き出すサブコマンド
      26              : var CmdCutSprite = &cli.Command{
      27              :         Name:      "cutsprite",
      28              :         Usage:     "cut an image into 32x32 sprites",
      29              :         ArgsUsage: "<image.png>",
      30              :         Flags: []cli.Flag{
      31              :                 &cli.StringFlag{Name: "prefix", Usage: "file name prefix of the sprites", Required: true},
      32              :                 &cli.StringFlag{Name: outFlag, Usage: "output directory", Value: "assets/file/textures/single"},
      33              :         },
      34              :         Action: runCutSprite,
      35              : }
      36              : 
      37              : func runCutSprite(_ context.Context, cmd *cli.Command) error {
      38            1 :         if !cmd.Args().Present() {
      39            1 :                 return errNoImageArg
      40            1 :         }
      41            1 :         f, err := os.Open(cmd.Args().First())
      42            1 :         if err != nil {
      43            1 :                 return err
      44            1 :         }
      45            2 :         defer func() { _ = f.Close() }()
      46            1 :         img, err := png.Decode(f)
      47            1 :         if err != nil {
      48            1 :                 return fmt.Errorf("failed to decode png: %w", err)
      49            1 :         }
      50            1 :         cells := cutCells(img, spriteCellSize)
      51            1 :         for _, c := range cells {
      52            1 :                 name := fmt.Sprintf("%s_%d_%d_.png", cmd.String("prefix"), c.row, c.col)
      53            1 :                 if err := writePNG(filepath.Join(cmd.String(outFlag), name), c.img); err != nil {
      54            1 :                         return err
      55            1 :                 }
      56              :         }
      57            1 :         _, err = fmt.Fprintf(cmd.Writer, "wrote %d sprites\n", len(cells))
      58            1 :         return err
      59              : }
      60              : 
      61              : // spriteCell は切り出した1マス
      62              : type spriteCell struct {
      63              :         row, col int
      64              :         img      *image.NRGBA
      65              : }
      66              : 
      67              : // cutCells は img を size ピクセル角のマスに切り、すべての画素が透明なマスを除いて行と列の順に返す。
      68              : // 端に余った size に満たない部分は捨てる。
      69              : func cutCells(img image.Image, size int) []spriteCell {
      70            1 :         b := img.Bounds()
      71            1 :         var out []spriteCell
      72            1 :         for row := range b.Dy() / size {
      73            1 :                 for col := range b.Dx() / size {
      74            1 :                         r := image.Rect(b.Min.X+col*size, b.Min.Y+row*size, b.Min.X+(col+1)*size, b.Min.Y+(row+1)*size)
      75            1 :                         cell := image.NewNRGBA(image.Rect(0, 0, size, size))
      76            1 :                         draw.Draw(cell, cell.Bounds(), img, r.Min, draw.Src)
      77            1 :                         if transparent(cell) {
      78            1 :                                 continue
      79              :                         }
      80            1 :                         out = append(out, spriteCell{row: row, col: col, img: cell})
      81              :                 }
      82              :         }
      83            1 :         return out
      84              : }
      85              : 
      86              : func transparent(img *image.NRGBA) bool {
      87            1 :         for i := 3; i < len(img.Pix); i += 4 {
      88            1 :                 if img.Pix[i] != 0 {
      89            1 :                         return false
      90            1 :                 }
      91              :         }
      92            1 :         return true
      93              : }
      94              : 
      95              : func writePNG(path string, img image.Image) error {
      96            1 :         f, err := os.Create(path)
      97            1 :         if err != nil {
      98            1 :                 return err
      99            1 :         }
     100            1 :         if err := png.Encode(f, img); err != nil {
     101            0 :                 _ = f.Close()
     102            0 :                 return err
     103            0 :         }
     104            1 :         return f.Close()
     105              : }
        

Generated by: LCOV version 2.0-1