SignatureHelper: reduce your signature boilerplate

[anna-is-cute]

Plugin developers!

Are you tired of working with boilerplate code when dealing with memory signatures? Do you wish setting up hooks or scanning for function pointers could just be two lines of code? Look no further than Siggingway SignatureHelper, now a built-in component of Dalamud!

Turn drab:

class DrabAf {
    [PluginService]
    private SigScanner SigScanner { get; init; }

    private delegate void MyDelegate(IntPtr a1);
    private Hook<MyDelegate>? Hook { get; }

    public DrabAf() {
        if (this.SigScanner.TryScanText("DE AD ?? EF", out var ptr)) {
            this.Hook = new Hook<MyDelegate>(ptr, this.MyDetour);
        }

        this.Hook?.Enable();
   }

   public void Dispose() {
       this.Hook?.Dispose();
   }

   private void MyDetour(IntPtr a1) {
       this.Hook!.Original(a1);
   }
}

Into fab!

class FabAf {
    private delegate void MyDelegate(IntPtr a1);

    [Signature("DE AD ?? EF", DetourName = nameof(MyDetour))]
    private Hook<MyDelegate>? Hook { get; init; }

    public FabAf() {
        SignatureHelper.Initialise(this);
        this.Hook?.Enable();
    }

   public void Dispose() {
       this.Hook?.Dispose();
   }

   private void MyDetour(IntPtr a1) {
       this.Hook!.Original(a1);
   }
}

SignatureHelper works with function pointers, delegates, hooks, instruction offsets, and more!

Available now on Dalamud staging, terms and conditions apply, Anna is not responsible for any negative effects such as your computer exploding or becoming irresistably attracted to her.

---

    /// <summary>
    /// The main way to use SignatureHelper. Apply this attribute to any field/property
    /// that should make use of a signature. See the field documentation for more
    /// information.
    /// </summary>
    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
    [MeansImplicitUse(ImplicitUseKindFlags.Assign, ImplicitUseTargetFlags.Itself)]
    public sealed class SignatureAttribute : Attribute
    {
        /// <summary>
        /// The memory signature for this field/property.
        /// </summary>
        public readonly string Signature;

        /// <summary>
        /// The way this signature should be used. By default, this is guessed using
        /// simple heuristics, but it can be manually specified if SignatureHelper can't
        /// figure it out.
        ///
        /// <seealso cref="SignatureUseFlags"/>
        /// </summary>
        public SignatureUseFlags UseFlags = SignatureUseFlags.Auto;

        /// <summary>
        /// The type of scan to perform. By default, this scans the text section of
        /// the executable, but this should be set to StaticAddress for static
        /// addresses.
        /// </summary>
        public ScanType ScanType = ScanType.Text;

        /// <summary>
        /// The detour name if this signature is for a hook. SignatureHelper will search
        /// the type containing this field/property for a method that matches the
        /// hook's delegate type, but if it doesn't find one or finds more than one,
        /// it will fail. You can specify the name of the method here to avoid this.
        /// </summary>
        public string? DetourName;

        /// <summary>
        /// When <see cref="UseFlags"/> is set to Offset, this is the offset from
        /// the signature to read memory from.
        /// </summary>
        public int Offset;

        /// <summary>
        /// When a signature is fallible, any errors while resolving it will be
        /// logged in the Dalamud log and the field/property will not have its value
        /// set. When a signature is not fallible, any errors will be thrown as
        /// exceptions instead. If fallibility is not specified, it is inferred
        /// based on if the field/property is nullable.
        /// </summary>
        public Fallibility Fallibility = Fallibility.Auto;

        /// <summary>
        /// Initializes a new instance of the <see cref="SignatureAttribute"/> class.
        /// </summary>
        /// <param name="signature">signature to scan for, see <see cref="Signature"/></param>
        public SignatureAttribute(string signature)
        {
            this.Signature = signature;
        }
    }