snes_utils 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f246381ab8ed69066585483ece562451ceca114af637eae26480ae617560738
-  data.tar.gz: f63b5921657411c56261f4130e943c0e9cb01d6c0bd9a81ffeb32b588ee0796d
+  metadata.gz: 9bce5ff7aea0b674c5c19db5c83979f66b4993e9b0de36a19c432cc7bcb09745
+  data.tar.gz: 78b040ccc9a686496535c135e3908ab63bfcd9c2c4fece2761a77f5588f49a9d
 SHA512:
-  metadata.gz: 133a82e1e257c37cf735b74fc9d727567b3d61d907bb51b7db5eb1f575d6bc579170dabae4abc9d9aaae9e5a2198a03c6ea65a5a504311f1750699f541b68aae
-  data.tar.gz: 3ffb2de928787bdd9f56ff87b1cd6b3dd45ab5c4737e54800c00d4c417a44d34d397de025d27fdfb4116ff9c0a3eac58238683b5c9431394b9dc98cfe16b67a4
+  metadata.gz: dfd37be40699f3a075c5b5c1e1779bb8fe4aed85da84d1f64be3a325d427416c070df8677d3f054d63edc63339080c467211feb903006878726fc8d66c84fee8
+  data.tar.gz: 44d97b051f1b75b94e3f823ec41efdbd08100a24674fb0255e3e40130bf2418506b6bd31035813ae31ff0253c2874155ed5fa40caf10806bd21ff4f745f32e4d

data/bin/png2snes

@@ -8,6 +8,8 @@ OptionParser.new do |opts|
   opts.on('-f', '--file FILENAME', 'PNG source file') { |o| options[:filename] = o }
   opts.on('-b', '--bpp BPP', 'BPP') { |o| options[:bpp] = o }
   opts.on('-a', '--alpha ALPHA', 'ALPHA') { |o| options[:alpha] = o }
+  opts.on('-m', '--mode7', 'mode 7') { |o| options[:mode7] = o }
+  opts.on('-o', '--offset OFFSET', 'mode 7 palette offset') { |o| options[:m7_palette_offset] = o }
 end.parse!
 
 raise OptionParser::MissingArgument, 'Must specify PNG source file' if options[:filename].nil?
@@ -18,6 +20,15 @@ else
   alpha = nil
 end
 
-c = SnesUtils::Png2Snes.new options[:filename], bpp: options[:bpp].to_i, alpha: alpha
+if options[:m7_palette_offset]
+  m7_palette_offset = options[:m7_palette_offset].to_i
+else
+  m7_palette_offset = nil
+end
+
+c = SnesUtils::Png2Snes.new(options[:filename], bpp: options[:bpp].to_i,
+                                                alpha: alpha,
+                                                mode7: options[:mode7],
+                                                m7_palette_offset: m7_palette_offset)
 c.write_palette
 c.write_image

data/bin/vas

@@ -11,6 +11,7 @@ OptionParser.new do |opts|
   end
 
   opts.on('-f', '--file FILENAME', 'ASM file') { |o| options[:filename] = o }
+  opts.on("-o", "--out FILENAME", "output file") { |o| options[:outfile] = o }
 end.parse!
 
-SnesUtils::Vas.new(options[:filename]).assemble
+SnesUtils::Vas.new(options[:filename], options[:outfile]).assemble

data/lib/mini_assembler/superfx/definitions.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module SnesUtils
+  module Superfx
+    class Definitions
+      HEX_DIGIT = '[0-9a-f]'
+      REG   = "[rR](\\d{1,2})"
+      LNK   = "([1-4])"
+      HEX   = "\\$?(#{HEX_DIGIT})"
+      HEX8  = "\\$?(#{HEX_DIGIT}{1,2})"
+      HEX16 = "\\$?(#{HEX_DIGIT}{1,4})"
+
+      SINGLE_OPERAND_INSTRUCTIONS = %i[imp imm4 rn rm rel lnk].freeze
+      DOUBLE_OPERAND_INSTRUCTIONS = %i[rn_rn rn_imm8 rn_imm16 rn_addr rn_addrl addr_rn addrl_rn].freeze
+      REL_INSTRUCTIONS = %i[rel].freeze
+      BIT_INSTRUCTIONS = %i[].freeze
+      SFX_INSTRUCTIONS = %i[imm4 rn rm rn_rn rn_imm8 rn_imm16 rn_addr rn_addrl addr_rn addrl_rn].freeze
+      MOV_INSTRUCTIONS = %i[rn_rn]
+      SHORT_ADDR_INSTRUCTIONS = %i[rn_addr addr_rn]
+      INV_DEST_INSTRUCTIONS = %i[addr_rn addrl_rn]
+
+      MODES_REGEXES = {
+        imp: /^$/,             # nothing
+        imm4: /^##{HEX}$/,     # #0-f
+        lnk: /^##{LNK}$/,      # #1-4
+        rn: /^#{REG}$/,        # R1
+        rm: /^\(#{REG}\)$/,    # (R1)
+        rel: /^#{HEX16}$/i,    # label / 1234
+        rn_rn: /^#{REG},#{REG}$/,          # R1, R2
+        rn_imm8: /^#{REG},##{HEX8}$/,      # R1, #12
+        rn_imm16: /^#{REG},##{HEX16}$/,    # R1, #1234
+        rn_addr: /^#{REG},\(#{HEX16}\)$/,   # R1, (1234) ; -> actual data is 1234 / 2
+        rn_addrl: /^#{REG},\(#{HEX16}\)$/, # R1, (1234) ; label
+        addr_rn: /^\(#{HEX16}\),#{REG}$/,   # (1234), R1 ; -> actual data is 1234 / 2
+        addrl_rn: /^\(#{HEX16}\),#{REG}$/, # (1234), R1 ; label
+      }.freeze
+
+      OPCODES_DATA = [
+                      # From game pak ROM to register
+                      { opcode: 0xef, mnemonic: 'GETB',  mode: :imp, length: 1, alt: nil },
+                      { opcode: 0xef, mnemonic: 'GETBH', mode: :imp, length: 2, alt: 0x3d },
+                      { opcode: 0xef, mnemonic: 'GETBL', mode: :imp, length: 2, alt: 0x3e },
+                      { opcode: 0xef, mnemonic: 'GETBS', mode: :imp, length: 2, alt: 0x3f },
+                      { opcode: 0xdf, mnemonic: 'GETC',  mode: :imp, length: 1, alt: nil },
+
+                      # From game pak RAM to register
+                      { opcode: 0x4,  mnemonic: 'LDW',   mode: :rm, length: 1, alt: nil },
+                      { opcode: 0x4,  mnemonic: 'LDB',   mode: :rm, length: 1, alt: 0x3d },
+                      { opcode: 0xf,  mnemonic: 'LM',    mode: :rn_addrl, length: 4, alt: 0x3d },
+                      { opcode: 0xa,  mnemonic: 'LMS',   mode: :rn_addr, length: 3, alt: 0x3d },
+
+                      # From register to game pak RAM
+                      { opcode: 0x3,  mnemonic: 'STW',   mode: :rm, length: 1, alt: nil },
+                      { opcode: 0x3,  mnemonic: 'STB',   mode: :rm, length: 2, alt: 0x3d },
+                      { opcode: 0xf,  mnemonic: 'SM',    mode: :addrl_rn, length: 4, alt: 0x3e },
+                      { opcode: 0xa,  mnemonic: 'SMS',   mode: :addr_rn, length: 3, alt: 0x3e },
+                      { opcode: 0x90, mnemonic: 'SBK',   mode: :imp, length: 1, alt: nil },
+
+                      # From register to register
+                      { opcode: 0x2010, mnemonic: 'MOVE', mode: :rn_rn, length: 2, alt: nil },
+                      { opcode: 0x20b0, mnemonic: 'MOVES', mode: :rn_rn, length: 2, alt: nil },
+
+                      # Immediate data to register
+                      { opcode: 0xf,  mnemonic: 'IWT',   mode: :rn_imm16, length: 3, alt: nil },
+                      { opcode: 0xa,  mnemonic: 'IBT',   mode: :rn_imm8, length: 2, alt: nil },
+
+                      # Arithmetic operations
+                      { opcode: 0x5,  mnemonic: 'ADD',   mode: :rn, length: 1, alt: nil },
+                      { opcode: 0x5,  mnemonic: 'ADD',   mode: :imm4, length: 2, alt: 0x3e },
+                      { opcode: 0x5,  mnemonic: 'ADC',   mode: :rn, length: 2, alt: 0x3d },
+                      { opcode: 0x5,  mnemonic: 'ADC',   mode: :imm4, length: 2, alt: 0x3f },
+
+                      { opcode: 0x6,  mnemonic: 'SUB',   mode: :rn, length: 1, alt: nil },
+                      { opcode: 0x6,  mnemonic: 'SUB',   mode: :imm4, length: 2, alt: 0x3e },
+                      { opcode: 0x6,  mnemonic: 'SBC',   mode: :rn, length: 2, alt: 0x3d },
+
+                      { opcode: 0x6,  mnemonic: 'CMP',   mode: :rn, length: 2, alt: 0x3f },
+
+                      { opcode: 0x8,  mnemonic: 'MULT',  mode: :rn, length: 1, alt: nil },
+                      { opcode: 0x8,  mnemonic: 'MULT',  mode: :imm4, length: 2, alt: 0x3e },
+                      { opcode: 0x8,  mnemonic: 'UMULT', mode: :rn, length: 2, alt: 0x3d },
+                      { opcode: 0x8,  mnemonic: 'UMULT', mode: :imm4, length: 2, alt: 0x3f },
+                      { opcode: 0x9f, mnemonic: 'FMULT', mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x9f, mnemonic: 'LMULT', mode: :imp, length: 2, alt: 0x3d },
+
+                      { opcode: 0x96, mnemonic: 'DIV2',  mode: :imp, length: 2, alt: 0x3d },
+
+                      { opcode: 0xd,  mnemonic: 'INC',   mode: :rn, length: 1, alt: nil },
+                      { opcode: 0xe,  mnemonic: 'DEC',   mode: :rn, length: 1, alt: nil },
+
+                      # Logical operations
+                      { opcode: 0x7,  mnemonic: 'AND',   mode: :rn, length: 1, alt: nil },
+                      { opcode: 0x7,  mnemonic: 'AND',   mode: :imm4, length: 2, alt: 0x3e },
+                      { opcode: 0xc,  mnemonic: 'OR',    mode: :rn, length: 1, alt: nil },
+                      { opcode: 0xc,  mnemonic: 'OR',    mode: :imm4, length: 2, alt: 0x3e },
+                      { opcode: 0x4f, mnemonic: 'NOT',   mode: :imp, length: 1, alt: nil },
+                      { opcode: 0xc,  mnemonic: 'XOR',   mode: :rn, length: 2, alt: 0x3d },
+                      { opcode: 0xc,  mnemonic: 'XOR',   mode: :imm4, length: 2, alt: 0x3f },
+                      { opcode: 0x7,  mnemonic: 'BIC',   mode: :rn, length: 2, alt: 0x3d },
+                      { opcode: 0x7,  mnemonic: 'BIC',   mode: :imm4, length: 2, alt: 0x3f },
+
+                      # Shift
+                      { opcode: 0x96, mnemonic: 'ASR',   mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x03, mnemonic: 'LSR',   mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x04, mnemonic: 'ROL',   mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x97, mnemonic: 'ROR',   mode: :imp, length: 1, alt: nil },
+
+                      # Byte transfer
+                      { opcode: 0xc0, mnemonic: 'HIB',   mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x9e, mnemonic: 'LOB',   mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x70, mnemonic: 'MERGE', mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x95, mnemonic: 'SEX',   mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x4d, mnemonic: 'SWAP',  mode: :imp, length: 1, alt: nil },
+
+                      # Jump, branch and loop
+                      { opcode: 0x9,  mnemonic: 'JMP',   mode: :rn, length: 1, alt: nil },
+                      { opcode: 0x9,  mnemonic: 'LJMP',  mode: :rn, length: 2, alt: 0x3d },
+                      { opcode: 0x05, mnemonic: 'BRA',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x06, mnemonic: 'BGE',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x07, mnemonic: 'BLT',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x08, mnemonic: 'BNE',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x09, mnemonic: 'BEQ',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x0a, mnemonic: 'BPL',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x0b, mnemonic: 'BMI',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x0c, mnemonic: 'BCC',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x0d, mnemonic: 'BCS',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x0e, mnemonic: 'BVC',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x0f, mnemonic: 'BVS',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x3c, mnemonic: 'LOOP',  mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x9,  mnemonic: 'LINK',  mode: :imm4, length: 1, alt: nil },
+
+                      # Bank set-up
+                      { opcode: 0xdf, mnemonic: 'ROMB',  mode: :imp, length: 2, alt: 0x3f },
+                      { opcode: 0xdf, mnemonic: 'RAMB',  mode: :imp, length: 2, alt: 0x3e },
+
+                      # Plot related
+                      { opcode: 0x4e, mnemonic: 'CMODE', mode: :imp, length: 2, alt: 0x3d },
+                      { opcode: 0x4e, mnemonic: 'COLOR', mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x4c, mnemonic: 'PLOT',  mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x4c, mnemonic: 'RPIX',  mode: :imp, length: 2, alt: 0x3d },
+
+                      # Prefix flag
+                      { opcode: 0x3d, mnemonic: 'ALT1',  mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x3e, mnemonic: 'ALT2',  mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x3f, mnemonic: 'ALT3',  mode: :imp, length: 1, alt: nil },
+
+                      # Prefix register
+                      { opcode: 0xb,  mnemonic: 'FROM',  mode: :rn, length: 1, alt: nil },
+                      { opcode: 0x1,  mnemonic: 'TO',    mode: :rn, length: 1, alt: nil },
+                      { opcode: 0x2,  mnemonic: 'WITH',  mode: :rn, length: 1, alt: nil },
+
+                      # GSU Control
+                      { opcode: 0x02, mnemonic: 'CACHE', mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x01, mnemonic: 'NOP',   mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x00, mnemonic: 'STOP',  mode: :imp, length: 1, alt: nil }].freeze
+    end
+  end
+end

data/lib/png2snes/png2snes.rb

@@ -1,22 +1,34 @@
 module SnesUtils
   class Png2Snes
-    def initialize(file_path, bpp:4, alpha:nil)
+    CHAR_SIZE = 8
+
+    def initialize(file_path, bpp:4, alpha:nil, mode7: false, m7_palette_offset: nil)
       @file_path = file_path
       @file_dir = File.dirname(@file_path)
       @file_name = File.basename(@file_path, File.extname(@file_path))
       @image = ChunkyPNG::Image.from_file(@file_path)
-      @pixels = pixels_to_bgr5
 
+      @mode7 = mode7
+
+      raise ArgumentError, 'Image width and height must be a multiple of sprite size' if (@image.width % CHAR_SIZE != 0) or (@image.height % CHAR_SIZE != 0)
+
+      @pixels = pixels_to_bgr5
       @palette = @pixels.uniq
-      @char_size = 8
 
-      raise ArgumentError, 'BPP must be 2, 4, or 8' unless [2, 4, 8].include? bpp
-      @bpp = bpp
+      if @mode7
+        raise ArgumentError, 'mode 7 palette offset must be multiple of 16' if m7_palette_offset % 16 != 0
+        raise ArgumentError, 'mode 7 palette offset must be less than 112' if m7_palette_offset > 112
+        @m7_palette_offset = m7_palette_offset
 
-      raise ArgumentError, 'Image width and height must be a multiple of sprite size' if (@image.width % @char_size != 0) or (@image.height % @char_size != 0)
+        unshift_alpha(alpha) if alpha
+        fill_palette
+      else
+        raise ArgumentError, 'BPP must be 2, 4, or 8' unless [2, 4, 8].include? bpp
+        @bpp = bpp
 
-      unshift_alpha(alpha) if alpha
-      fill_palette
+        unshift_alpha(alpha) if alpha
+        fill_palette
+      end
     end
 
     def pixels_to_bgr5
@@ -34,13 +46,17 @@ module SnesUtils
     end
 
     def fill_palette
-      target_size = 2**@bpp
+      target_size = @mode7 ? mode_7_pal_size : 2**@bpp
       missing_colors = target_size - @palette.count
       raise ArgumentError, "Palette size too large for target BPP (#{@palette.count})" if missing_colors < 0
 
       @palette += [0] * missing_colors
     end
 
+    def mode_7_pal_size
+      128 - @m7_palette_offset
+    end
+
     def write hex, file_path
       File.open(file_path, 'w+b') do |file|
         file.write([hex.join].pack('H*'))
@@ -49,7 +65,7 @@ module SnesUtils
 
     def write_palette
       palette_hex = @palette.map { |c| ('%04x' % c).scan(/.{2}/).reverse.join }
-      write palette_hex, File.expand_path("#{@file_name}-pal.bin", @file_dir)
+      write palette_hex, File.expand_path("#{@file_name}.pal", @file_dir)
     end
 
     def pixel_indices
@@ -61,16 +77,20 @@ module SnesUtils
     def extract_sprites
       pixel_idx = pixel_indices
 
-      sprite_per_row = @image.width / @char_size
-      sprite_per_col = @image.height / @char_size
+      sprite_per_row = @image.width / CHAR_SIZE
+      sprite_per_col = @image.height / CHAR_SIZE
       sprite_per_sheet =  sprite_per_row * sprite_per_col
 
       sprites = []
       (0..sprite_per_sheet-1).each do |s|
         sprite = []
-        (0..@char_size-1).each do |r|
-          offset = (s/sprite_per_row)*sprite_per_row * @char_size**2 + s % sprite_per_row * @char_size
-          sprite += pixel_idx[offset + r*sprite_per_row*@char_size, @char_size]
+        (0..CHAR_SIZE-1).each do |r|
+          offset = (s/sprite_per_row)*sprite_per_row * CHAR_SIZE**2 + s % sprite_per_row * CHAR_SIZE
+          if @mode7
+            sprite += @pixels[offset + r*sprite_per_row*CHAR_SIZE, CHAR_SIZE]
+          else
+            sprite += pixel_idx[offset + r*sprite_per_row*CHAR_SIZE, CHAR_SIZE]
+          end
         end
         sprites.push(sprite)
       end
@@ -88,7 +108,11 @@ module SnesUtils
     end
 
     def write_image
-      sprite_per_row = @image.width / @char_size
+      @mode7 ? write_image_m7 : write_image_m06
+    end
+
+    def write_image_m06
+      sprite_per_row = @image.width / CHAR_SIZE
       sprites = extract_sprites
       sprites_bitplanes = sprites.map { |s| extract_bitplanes s }
 
@@ -98,9 +122,9 @@ module SnesUtils
 
         bitplane_bits = ""
         sprite_bitplane_pairs.each do |bitplane|
-          (0..@char_size-1).each do |r|
-            offset = r*@char_size
-            bitplane_bits += bitplane[0][offset, @char_size].join + bitplane[1][offset, @char_size].join
+          (0..CHAR_SIZE-1).each do |r|
+            offset = r*CHAR_SIZE
+            bitplane_bits += bitplane[0][offset, CHAR_SIZE].join + bitplane[1][offset, CHAR_SIZE].join
           end
         end
         image_bits += bitplane_bits
@@ -108,8 +132,15 @@ module SnesUtils
       end
 
       image_hex = image_bits.scan(/.{8}/).map { |b| "%02x" % b.to_i(2) }
-      write image_hex, File.expand_path("#{@file_name}.bin", @file_dir)
+      write image_hex, File.expand_path("#{@file_name}.tiles", @file_dir)
     end
 
+    def write_image_m7
+      sprites = extract_sprites
+
+      indices = sprites.flatten.map { |color| "%02x" % (@palette.index(color) + @m7_palette_offset) }
+
+      write indices, File.expand_path("#{@file_name}.tiles", @file_dir)
+    end
   end
 end

data/lib/snes_utils.rb

@@ -1,13 +1,12 @@
 require 'readline'
 require 'chunky_png'
-require 'matrix'
 require 'csv'
-require 'byebug'
 
 require 'mini_assembler/mini_assembler'
 require 'mini_assembler/definitions'
 require 'mini_assembler/wdc65816/definitions'
 require 'mini_assembler/spc700/definitions'
+require 'mini_assembler/superfx/definitions'
 require 'png2snes/png2snes'
 require 'tmx2snes/tmx2snes'