Import Functions

Import Synthetic Modules

To import functions from another plugin, use Plugify's import system to load the synthetic module for the target plugin.

import { Plugin, Vector2, Vector3, Vector4, Matrix4x4 } from 'plugify';
import * as master from ':plugin_from_another_language';

• plugify: The core Plugify module, providing utility classes like Vector2, Vector3, etc.
• plugin_from_another_language: The synthetic module for the target plugin. Replace this with the name of the plugin you want to import functions from.

Call the Imported Functions

Once the synthetic module is imported, you can call its functions directly.

Example 1: Calling a Simple Function

export const func = () => {
    master.ParamCallback(
        111, 
        2.2, 
        5.1234, 
        new Vector4(-125.1, -225.2, -325.3, -425.4), 
        [60000000, -700000000, 80000000000], 
        'D', 
        'pink metal', 
        'Y', 
        -100
    );
};

• ParamCallback: This is an example function exported by the target plugin. Replace it with the actual function name.
• Parameters: Pass the required parameters as defined by the function signature.

Example 2: Calling a Function with a Callback Parameter

If the imported function requires a callback as a parameter, you can define the callback in JavaScript and pass it to the function. Here’s an example:

export class CallbackHolder {
    static mockFunc(u32, v3, u_vec) {
        // Modify the parameters (passed by reference)
        u32 = 42;
        v3 = new Vector3(1.0, 2.0, 3.0);
        u_vec = [1, 2, 3];
        // Return the modified values in an array
        return [null, u32, v3, u_vec];
    }
}

export const func_call = () => {
    const result = master.CallFuncCallback(CallbackHolder.mockFunc);
    return result;
};

• CallFuncCallback: This is an example function that accepts a callback as a parameter.
• mockFunc: This is the callback function defined in JavaScript. It modifies the parameters passed by reference and returns them in an array.
• Return Values: The callback function returns null (for the void return type) and the modified parameters.

Locate the Generator Script:

• The generator.py script is located in the generator folder of the JavaScript language module.

Run the Generator Script:

• Open a terminal or command prompt and navigate to the folder containing generator.js.
• Run the script with the following command:
  node generator.js "path_to_plugin.pplugin" "output_folder"
  

  • path_to_plugin.pplugin: The path to the plugin manifest file (.pplugin) of the plugin you want to import functions from.
  • output_folder: The directory where the generated type file will be saved.

Example:

python generator.py ./plugins/MyPlugin/MyPlugin.pplugin ./types/

Generated Type File:

• The script will generate a type file (e.g., MyPlugin.d.ts) in the specified output folder.
• Example type file content:
  MyPlugin.d.ts

  import { Vector2, Vector3, Vector4, Matrix4x4 } from 'plugify';
  
  declare module ':cross_call_master' {
      export function ParamCallback(
          a: number, 
          b: number, 
          c: number, 
          d: Vector4, 
          e: number[], 
          f: string, 
          g: string, 
          h: string, 
          k: number
      ): void;
  
      export type Func = (u32: number, vec3: Vector3, vecU32: number[]) => [void,number,Vector3,number[]];
      export function CallFuncCallback(callback: Func): string;
  }
  

Using Type Files in Your IDE:

• Place the generated type file (.d.ts) in your project directory (but not in the plugins folder).
• IDEs like VSCode will use the type file to provide type hints and autocompletion.

VSCode Support:

• VSCode automatically detects type files in your project. Ensure the types folder (or the folder containing your .d.ts files) is included in your tsconfig.json or jsconfig.json file.
• Example tsconfig.json configuration:
  {
      "compilerOptions": {
          "typeRoots": ["./types"]
      }
  }