Struct pxs_PixelObject 

pub struct pxs_PixelObject {
    pub type_name: String,
    pub ptr: *mut c_void,
    pub lang_ptr: Mutex<*mut c_void>,
    pub free_lang_ptr: Mutex<bool>,
    pub free_method: FreeMethod,
    pub callbacks: Vec<ModuleCallback>,
}

A PixelScript Object.

The way this works is via the host, a Pseudo type can be created. So when the scripting language interacts with the object, it calls it’s pseudo methods.

example:

struct Person {
    const char* name;
    int age;

    Person(const char* name, int age) {
        this->name = name;
        this->age = age;
    }

    void set_name(const char* name) {
        this->name = name;
    }

    void set_age(int age) {
        this->age = age;
    }

    int get_age() {
        return this->age;
    }

    const char* get_name() {
        return this->name;
    }
};

void free_person(void* p) {
    // TODO
}
Var* person_set_name(int argc, Var** argv, void* opaque) {
    Var* object = argv[0];
    Person* p = object.value.object_val as Person;
    Var* name = argv[1];
    p->set_name(name.value.string_val);
    return NULL;
}
Var* new_person(int argc, Var** argv, void* opaque) {
    Person* p = malloc();
    PixelObject* object_ptr = pixelscript_new_object(p, free_person);
    pixelscript_object_add_callback(object_ptr, "set_name", person_set_name);
    return pixelscript_var_object(object_ptr);
}

// OOP base
pixelscript_add_object("Person", new_person);

// Or functional
pixelscript_add_callback("new_person", new_person);

In a JS example:

let p = new Person("Jordan");
p.set_name("James");

This is why a Objects are more like Pseudo types than actual class/objects.

Fields

type_name: String

Type name (this is a hash)

ptr: *mut c_void

The Host pointer

lang_ptr: Mutex<*mut c_void>

The language object pointer.

free_lang_ptr: Mutex<bool>

Should the lang_ptr be freed by PixelScript?

free_method: FreeMethod

The Method for freeing

callbacks: Vec<ModuleCallback>

Callbacks with names.

Important to note that a PixelObject can not have static callbacks.

The first Var will always be the ptr.

Implementations

impl pxs_PixelObject

pub fn new(ptr: *mut c_void, free_method: FreeMethod, type_name: &str) -> Self

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

pub fn update_lang_ptr(&self, n_ptr: *mut c_void)

pub fn update_free_lang_ptr(&self, val: bool)

Trait Implementations

impl Drop for pxs_PixelObject

fn drop(&mut self)

Executes the destructor for this type.

impl PtrMagic for pxs_PixelObject

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_PixelObject

impl Sync for pxs_PixelObject