Struct RawPtr 

pub struct RawPtr<P>
where
    P: FfiRawPointer,
{ /* private fields */ }

Wrapper around a raw pointer, providing ToGodot/FromGodot for FFI passing.

This type allows raw pointers to be passed through the Godot FFI boundary. The pointer is converted to its memory address (as i64) for FFI purposes.

You might need this in #[func], in dynamic calls (Object.call) or other scenarios where you have to interface with Godot’s low-level pointer APIs. These pointers typically refer to GDExtension native structures, but there are a few other cases (e.g. *const u8 for C char arrays).

Example

use godot::meta::{RawPtr, ToGodot};
use godot::classes::native::AudioFrame;

let frame = AudioFrame { left: 0.0, right: 1.0 };
let ptr: *const AudioFrame = &raw const frame;

// SAFETY: we keep `frame` alive while using `wrapped`.
let wrapped = unsafe { RawPtr::new(ptr) };

let variant = wrapped.to_variant();

Implementations

impl<P> RawPtr<P>

where P: FfiRawPointer,

pub unsafe fn new(ptr: P) -> RawPtr<P>

Constructs a new RawPtr from a raw pointer.

Safety

The pointer must remain valid as long as a Godot API accesses its value. Special care is necessary in #[func] and I* virtual function return types: if the pointer refers to a local variable, it will become immediately dangling, causing undefined behavior.

pub unsafe fn null() -> RawPtr<P>

Constructs a new RawPtr wrapping a null pointer.

Safety

You must ensure that Godot can handle null pointers in the specific Godot API where this value will be used.

pub fn ptr(self) -> P

Returns the wrapped raw pointer.

Trait Implementations

impl<P> Clone for RawPtr<P>

where P: Clone + FfiRawPointer,

fn clone(&self) -> RawPtr<P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P> Debug for RawPtr<P>

where P: Debug + FfiRawPointer,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<P> FromGodot for RawPtr<P>

where P: FfiRawPointer + 'static,

fn try_from_godot( via: <RawPtr<P> as GodotConvert>::Via, ) -> Result<RawPtr<P>, ConvertError>

Converts the Godot representation to this type, returning Err on failure.

fn from_godot(via: Self::Via) -> Self

⚠️ Converts the Godot representation to this type.

fn try_from_variant(variant: &Variant) -> Result<Self, ConvertError>

Performs the conversion from a Variant, returning Err on failure.

fn from_variant(variant: &Variant) -> Self

⚠️ Performs the conversion from a Variant.

impl<P> GodotConvert for RawPtr<P>

where P: FfiRawPointer + 'static,

type Via = RawPtr<P>

The type through which Self is represented in Godot.

impl<P> PartialEq for RawPtr<P>

where P: PartialEq + FfiRawPointer,

fn eq(&self, other: &RawPtr<P>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<P> ToGodot for RawPtr<P>

where P: FfiRawPointer + 'static,

type Pass = ByValue

Whether arguments of this type are passed by value or by reference.

fn to_godot(&self) -> <RawPtr<P> as GodotConvert>::Via

Converts this type to Godot representation, optimizing for zero-copy when possible.

fn to_godot_owned(&self) -> Self::Via

where Self::Via: Clone,

Converts this type to owned Godot representation.

fn to_variant(&self) -> Variant

Converts this type to a Variant.

impl<P> Copy for RawPtr<P>

where P: Copy + FfiRawPointer,

impl<P> Eq for RawPtr<P>

where P: Eq + FfiRawPointer,

impl<P> GodotType for RawPtr<P>

where P: FfiRawPointer + 'static,

impl<P> StructuralPartialEq for RawPtr<P>

where P: FfiRawPointer,