devlog

[spinnylights]

Yeaaaa I love to swizzle! It’s so fun honestly that I feel like it’s worth adding in to vector types in languages that don’t have it if you can.

A couple years ago I wrote a mixin to facilitate this in Ruby, if anyone has use for that:

module Swizzleable
  module ClassMethods
    def swizz_masks
      [
        [:r, :g, :b, :a],
        [:x, :y, :z, :w],
        [:s, :t, :p, :q],
      ]
    end
  end

  def self.included(klass)
    klass.extend(ClassMethods)

    min_max_swizz_len = 4
    max_swizz_len = klass.swizz_masks.map(&:length).max
    max_swizz_len = min_max_swizz_len if max_swizz_len < min_max_swizz_len

    klass.swizz_masks.each do |comp_set|
      1.upto(max_swizz_len) do |n|
        comp_set.repeated_permutation(n).each do |comps|
          klass.define_method(comps.join.to_sym) do
            out = comp_set.zip(swizz_vals).to_h.fetch_values(*comps)
            if klass.public_method_defined? :post_swizz
              post_swizz(out)
            else
              out
            end
          end
        end

        comp_set.permutation(n).each do |comps|
          klass.define_method((comps.join + '=').to_sym) do |args|
            comps.map(&comp_set.method(:index)).zip(args).each do |ndx, arg|
              if klass.public_method_defined? :swizz_assign
                swizz_assign(ndx, arg)
              else
                send(:[]=, ndx, arg)
              end
            end
          end
        end
      end
    end
  end
end

The code might look a little crazy but it’s easy to use—you just include the module in your class and define a method swizz_vals that returns an array with the components in xyzw order (up to the dimension of the vector, it’s okay if it’s less than 4). By default swizzling returns the components in a plain array, but you can also define post_swizz if you like, which will receive this array and can transform it before it gets passed back to the user. Likewise, by default assigning new values to components via swizzle assumes that the class supports normal array subscripting assignment for the object’s components ([]=), but if that doesn’t work well for your class, you can define swizz_assign, which receives the component index and new value and can do whatever is appropriate with it.

If you’re feeling saucy, you can monkey-patch the stdlib Vector with this:

require 'matrix'

class Vector
  include Swizzleable

  def swizz_vals
    (0...[4, size].min).map { self[_1] }
  end

  def post_swizz(arr)
    self.class[*arr]
  end
end

v = Vector[1, 2, 3, 4]

v.xy
#=> Vector[1, 2]

v.argb
#=> Vector[4, 1, 2, 3]

v.ptq
#=> Vector[3, 2, 4]

v.yz = [10, 12]
v.wzyx
#=> Vector[4, 12, 10, 1]

I feel like this is a nice demonstration of ZA POWAH of Ruby, and kind of underscores why I feel like it’s a bit underrated for game development maybe.

Also, if you’d rather swazzle than swizzle, this video might help.

How to swazzle