Struct pxs_Module 

pub struct pxs_Module {
    pub name: String,
    pub callbacks: Vec<ModuleCallback>,
    pub variables: Vec<ModuleVariable>,
    pub modules: Vec<Arc<pxs_Module>>,
}

A Module is a C representation of data that needs to be (imported,required, etc)

The process is you add callbacks, variables, etc.

And THEN add the module.

So you first need to call

pixelmods_create_module() Which will create a new module struct with a name.

Here is a simple example.

Module* m = pixelmods_new_module("math");

pixelmods_module_add_callback(m, ...);
pixelmods_module_add_variable(m, ...);

pixelmods_add_module(m);

You never free the module pointer because the runtime takes ownership.

Callbacks within modules use the same FUNCTION_LOOKUP global static variable.

Fields

name: String

Name of the module.

callbacks: Vec<ModuleCallback>

Callbacks that need to be added.

variables: Vec<ModuleVariable>

Variables that need to be added.

modules: Vec<Arc<pxs_Module>>

Internal modules

Implementations

impl pxs_Module

pub fn new(name: String) -> Self

Create a new module.

pub fn add_callback(&mut self, name: &str, full_name: &str, idx: i32)

Add a callback to current module.

pub fn add_variable(&mut self, name: &str, var: *mut pxs_Var)

Add a variable to current module.

pub fn add_module(&mut self, child: Arc<pxs_Module>)

Add a internal module.

pub fn get_name(&self) -> String

Get name without package

pub fn get_pkg(&self) -> String

Get package name

Trait Implementations

impl Clone for pxs_Module

fn clone(&self) -> pxs_Module

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Drop for pxs_Module

fn drop(&mut self)

Executes the destructor for this type.

impl PtrMagic for pxs_Module

fn into_raw(self) -> *mut Self

Moves the object to the heap and returns a raw pointer. Caller owns this memory but don’t worry about freeing it. The library frees it somewhere.

fn from_raw(ptr: *mut Self) -> Self

Safety: Only call this on a pointer created via into_raw.

unsafe fn from_borrow<'a>(ptr: *mut Self) -> &'a mut Self

Build from a Ptr but only get a reference, this means that the caller will still own the memory

impl Send for pxs_Module

impl Sync for pxs_Module