### on_stage_init() Logic Example

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/06-initialization.md

Provides an example of custom logic to execute when different initialization stages are loaded. This includes registering classes and setting up autoloads.

```rust
fn on_stage_init(stage: InitStage) {
    match stage {
        InitStage::Core => {
            godot_print!("Core stage initialized");
        }
        InitStage::Servers => {
            godot_print!("Servers stage initialized");
        }
        InitStage::Scene => {
            godot_print!("Scene stage initialized");
            // Register classes, setup autoloads, etc.
        }
        InitStage::Editor => {
            godot_print!("Editor stage initialized");
        }
        #[cfg(since_api = "4.5")]
        InitStage::MainLoop => {
            godot_print!("MainLoop stage initialized - fully ready");
        }
    }
}
```

--------------------------------

### Example: Custom GameConfig Resource

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/10-virtual-methods-callbacks.md

Example of a custom `Resource` named `GameConfig` implementing the `IResource` trait. The `setup` method is overridden to print a message.

```rust
#[derive(GodotClass)]
#[class(init, base=Resource)]
struct GameConfig {
    base: Base<Resource>,
    
    #[export]
    level_count: i32,
}

#[godot_api]
impl IResource for GameConfig {
    fn setup(&mut self) {
        godot_print!("Initializing config");
    }
}
```

--------------------------------

### Minimal Setup for a Simple Class

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/09-prelude-and-common-imports.md

Use this minimal setup for defining a simple class with basic functionality. It imports the prelude and derives `GodotClass`.

```rust
use godot::prelude::*;

#[derive(GodotClass)]
#[class(init)]
struct MyClass {
    base: Base<RefCounted>,
}

#[godot_api]
impl MyClass {
    #[func]
    fn my_method(&self) {
        godot_print!("Hello!");
    }
}
```

--------------------------------

### Full ExtensionLibrary Implementation Example

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/06-initialization.md

A complete example demonstrating how to implement the `ExtensionLibrary` trait for a custom GDExtension. It shows how to set initialization levels, editor behavior, and stage-specific callbacks.

```rust
use godot::init::*

struct MyExtension;

#[gdextension]
unsafe impl ExtensionLibrary for MyExtension {
    fn min_level() -> InitLevel {
        InitLevel::Scene
    }
    
    fn editor_run_behavior() -> EditorRunBehavior {
        EditorRunBehavior::ToolClassesOnly
    }
    
    fn on_stage_init(stage: InitStage) {
        match stage {
            InitStage::Scene => {
                godot_print!("Initializing game extension");
                // Setup singletons, cache frequently-used nodes, etc.
            }
            InitStage::Editor => {
                godot_print!("Editor tools ready");
            }
            _ => {}
        }
    }
    
    fn on_stage_deinit(stage: InitStage) {
        if stage == InitStage::Scene {
            godot_print!("Cleaning up");
        }
    }
    
    #[cfg(since_api = "4.5")]
    fn on_main_loop_frame() {
        // Per-frame update logic
    }
}
```

--------------------------------

### Complete Player Class Example

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/04-registration-macros.md

A comprehensive example demonstrating the registration of a `Player` struct, including initialization, exported properties with ranges, and on-ready fields.

```rust
#[derive(GodotClass)]
#[class(init, base=Node2D)]
struct Player {
    base: Base<Node2D>,
    
    #[init(val = 100)]
    health: i32,
    
    #[var]
    name: GString,
    
    #[export]
    #[export(range = (0.0, 500.0))]
    speed: f32,
    
    #[init(node = "HealthBar")]
    health_bar: OnReady<Gd<ProgressBar>>,
}
```

--------------------------------

### on_stage_deinit() Logic Example

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/06-initialization.md

Provides an example of custom logic to execute when different initialization stages are unloaded. This includes cleaning up resources.

```rust
fn on_stage_deinit(stage: InitStage) {
    match stage {
        InitStage::Editor => {
            godot_print!("Cleaning up editor resources");
        }
        InitStage::Scene => {
            godot_print!("Cleaning up scene resources");
        }
        // ...
    }
}
```

--------------------------------

### Async Signal Reception Example

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/05-signals.md

Demonstrates how to use SignalReceiver to asynchronously wait for and process signals in a loop.

```rust
async fn wait_for_event() {
    let obj: Gd<MyClass> = MyClass::new_gd();
    
    while let Some(value) = obj.signals().value_changed().recv().await {
        godot_print!("Value: {}", value);
    }
}
```

--------------------------------

### on_main_loop_frame() Example (Godot 4.5+)

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/06-initialization.md

An example of a function called every frame after initialization is complete, for Godot versions 4.5 and later. It runs after all `Node::process()` calls.

```rust
#[cfg(since_api = "4.5")]
fn on_main_loop_frame() {
    // Per-frame logic, called after all process() methods
}
```

--------------------------------

### Color Example: HSV Conversion and Darkening

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/03-builtin-types.md

Demonstrates creating a color from HSV values and then darkening it.

```rust
let color = Color::from_hsv(0.5, 0.8, 1.0, 1.0); // Cyan
let darkened = color.darkened(0.2);
```

--------------------------------

### Player Node Implementation with Callbacks

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/10-virtual-methods-callbacks.md

Example of implementing Node lifecycle callbacks for a Player node, including ready, process, and input handling.

```rust
#[derive(GodotClass)]
#[class(init, base=Node2D)]
struct Player {
    base: Base<Node2D>,
    speed: f32,
}

#[godot_api]
impl INode2D for Player {
    fn ready(&mut self) {
        godot_print!("Player ready! Setting up...");
    }
    
    fn process(&mut self, delta: f64) {
        // Called every frame
        let velocity = Vector2::new(0.0, 0.0);
        // Update position based on input...
        self.base_mut().set_position(
            self.base().get_position() + velocity * delta as f32
        );
    }
    
    fn physics_process(&mut self, delta: f64) {
        // Physics updates (0.016s interval)
    }
    
    fn input(&mut self, event: Gd<InputEvent>) {
        // Handle input
        if let Some(key_event) = event.clone().try_cast::<InputEventKey>() {
            let key = key_event.bind().get_keycode();
            godot_print!("Key pressed: {:?}", key);
        }
    }
}
```

--------------------------------

### Connecting to Node Tree Signals

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/05-signals.md

Example of connecting to 'tree_entered' and 'tree_exited' signals on a Node using Callable::from_fn.

```rust
impl INode for MyNode {
    fn ready(&mut self) {
        let base = self.base_mut();
        
        // tree_entered: emitted when node enters scene tree
        base.connect("tree_entered".into(), Callable::from_fn(|| {
            godot_print!("In tree!");
        }));
        
        // tree_exited: emitted when node leaves scene tree
        base.connect("tree_exited".into(), Callable::from_fn(|| {
            godot_print!("Out of tree!");
        }));
    }
}
```

--------------------------------

### FromGodot Type Conversion Example

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/07-type-conversions.md

Demonstrates converting Godot integer and string types to their Rust equivalents using the `from_godot` method.

```rust
let godot_int: i32 = 42;
let rust_int: i32 = i32::from_godot(godot_int);

let godot_str: GString = GString::from("hello");
let rust_str: String = String::from_godot(godot_str);
```

--------------------------------

### Get Frame Setup Time CPU

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Retrieves the CPU time taken for the current frame's setup. This method is part of the RenderingServer module.

```rust
pub fn get_frame_setup_time_cpu (& self ,) -> f64 {
unsafe {
let __class_name = StringName :: from ("RenderingServer") ;
let __method_name = StringName :: from ("get_frame_setup_time_cpu") ;
let __method_bind = sys :: interface_fn ! (classdb_get_method_bind) (__class_name . string_sys () , __method_name . string_sys () , 1740695150i64) ;
assert ! (! __method_bind . is_null () , "failed to load method {}::{} (hash {}) -- possible Godot/gdext version mismatch" , "RenderingServer" , "get_frame_setup_time_cpu" , 1740695150i64) ;
let __call_fn = sys :: interface_fn ! (object_method_bind_ptrcall) ;
let __args = [] ;
let __args_ptr = __args . as_ptr () ;
< f64 as sys :: GodotFfi > :: from_sys_init_default (| return_ptr |
{
__call_fn (__method_bind , self . object_ptr , __args_ptr , return_ptr)
}
)
}
}
```

--------------------------------

### Get CPU Frame Setup Time

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Retrieves the time taken on the CPU to set up the current frame. This metric is valuable for performance analysis and identifying rendering bottlenecks.

```rust
pub fn get_frame_setup_time_cpu (& self ,) -> f64 {
    unsafe {
        let __class_name = StringName :: from ("RenderingServer") ;
        let __method_name = StringName :: from ("get_frame_setup_time_cpu") ;
        let __method_bind = sys :: interface_fn ! (classdb_get_method_bind) (__class_name . string_sys () , __method_name . string_sys () , 1740695150i64) ;
        assert ! (! __method_bind . is_null () , "failed to load method {}::{} (hash {}) -- possible Godot/gdext version mismatch" , "RenderingServer" , "get_frame_setup_time_cpu" , 1740695150i64) ;
        let __call_fn = sys :: interface_fn ! (object_method_bind_ptrcall) ;
        let __args = [] ;
        let __args_ptr = __args . as_ptr () ;
        < f64 as sys :: GodotFfi > :: from_sys_init_default (| return_ptr | {
            __call_fn (__method_bind , self . object_ptr , __args_ptr , return_ptr)
        })
    }
}
```

--------------------------------

### Implement IButton Lifecycle

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/10-virtual-methods-callbacks.md

Implement the `ready` method for a custom Button node.

```rust
#[derive(GodotClass)]
#[class(init, base=Button)]
struct MyButton {
    base: Base<Button>,
}

#[godot_api]
impl IButton for MyButton {
    fn ready(&mut self) {
        // Button ready
    }
}
```

--------------------------------

### Get ClassId for Type Identification

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/07-type-conversions.md

Retrieves a lightweight identifier for a Godot class. Use this to get the class name as a StringName or GString.

```rust
pub fn class_id<T: GodotClass>() -> ClassId {
    T::class_id()
}
```

```rust
let id = Node::class_id();
let name: StringName = id.to_string_name();
assert_eq!(name, StringName::from("Node"));
```

--------------------------------

### Hybrid Import Approach Example

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/09-prelude-and-common-imports.md

Illustrates a hybrid import strategy, re-exporting prelude and specific tools from the crate root and using specific imports within modules. This balances conciseness and clarity.

```rust
// In crate root: lib.rs or main.rs
pub use godot::prelude::*;
pub use godot::tools::{load, save};

// In modules
use crate::*;

// Plus specific imports as needed
use godot::task::spawned;
```

--------------------------------

### OnReady<T>

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/02-core-types.md

Defers the initialization and access of child nodes until the `_ready()` function is called, ensuring the scene tree is fully set up. It is declared using `#[init(node = "path/to/node")]` and panics if accessed before `_ready()`.

```APIDOC
## OnReady<T>

### Description
Defers accessing child nodes until `_ready()` is called, when the scene tree is fully set up. Panics if accessed before `_ready()`.

### Usage
Declared with `#[init(node = "path/to/node")]` where the path is relative to the node's parent in the scene tree.

### Example
```rust
#[derive(GodotClass)]
#[class(init, base=Node)]
struct MyNode {
    #[init(node = "ChildNode")]
    child: OnReady<Gd<Node>>,
}

#[godot_api]
impl INode for MyNode {
    fn ready(&mut self) {
        // After _ready(), access via Deref
        self.child.set_visible(true);
    }
}
```
```

--------------------------------

### Light Configuration Methods

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

These methods allow for the configuration of existing lights, including setting their color, parameters, and shadow properties.

```APIDOC
## Light Color Setting

### Description
Sets the color of a light source.

### Method
`light_set_color(light: Rid, color: Color)`

### Parameters
#### Path Parameters
- `light` (Rid) - Required - The Resource ID of the light to configure.
- `color` (Color) - Required - The new color for the light.
```

```APIDOC
## Light Parameter Setting

### Description
Sets a specific parameter for a light source. The available parameters depend on the type of light.

### Method
`light_set_param(light: Rid, param: LightParam, value: f64)`

### Parameters
#### Path Parameters
- `light` (Rid) - Required - The Resource ID of the light to configure.
- `param` (LightParam) - Required - The specific light parameter to set (e.g., energy, range, spot angle).
- `value` (f64) - Required - The new value for the specified parameter.
```

```APIDOC
## Light Shadow Setting

### Description
Enables or disables shadow casting for a light source.

### Method
`light_set_shadow(light: Rid, enabled: bool)`

### Parameters
#### Path Parameters
- `light` (Rid) - Required - The Resource ID of the light to configure.
- `enabled` (bool) - Required - `true` to enable shadows, `false` to disable.
```

--------------------------------

### Set GDExtension Entry Point

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/04-registration-macros.md

Mark your ExtensionLibrary implementation with #[gdextension] to designate it as the GDExtension entry point. Specify initialization levels and stages.

```rust
struct MyExtension;

#[gdextension]
unsafe impl ExtensionLibrary for MyExtension {
    fn min_level() -> InitLevel {
        InitLevel::Scene
    }
    
    fn on_stage_init(stage: InitStage) {
        if stage == InitStage::Scene {
            // Initialization code
        }
    }
}
```

--------------------------------

### Transform3D Construction

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/QUICK-REFERENCE.md

Get the identity Transform3D.

```rust
Transform3D::IDENTITY
```

--------------------------------

### instance_create

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Creates a new rendering instance. This is a simpler version of `instance_create2` that uses default scenario settings.

```APIDOC
## instance_create

### Description
Creates a new rendering instance. This is a simpler version of `instance_create2` that uses default scenario settings.

### Method
N/A (Rust function call)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
None

### Response
#### Success Response (Rid)
- Returns a `Rid` which is a unique identifier for the newly created rendering instance.

### Request Example
```rust
// Assuming 'rs' is an instance of RenderingServer
let instance_rid = rs.instance_create();
```

### Response Example
```json
{
  "example": "Rid(some_value)"
}
```
```

--------------------------------

### Transform2D Construction

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/QUICK-REFERENCE.md

Get the identity Transform2D.

```rust
Transform2D::IDENTITY
```

--------------------------------

### Configure Signal Connections with ConnectBuilder

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/05-signals.md

Demonstrates basic signal connection using the `connect` method, suitable for deferred execution.

```rust
let obj: Gd<MyClass> = MyClass::new_gd();

// Deferred connection - callback runs next frame
obj.connect("my_signal".into(), Callable::from_fn(|| {
    godot_print!("Next frame!");
}))
```

--------------------------------

### Multimesh Functions

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Methods for setting and getting the buffer data for a multimesh.

```APIDOC
## multimesh_set_buffer

### Description
Sets the buffer data for a given multimesh.

### Method
`multimesh_set_buffer`

### Parameters
#### Path Parameters
- `multimesh` (Rid) - The multimesh to modify.
- `buffer` (PackedFloat32Array) - The new buffer data.

### Response
No explicit return value documented.
```

```APIDOC
## multimesh_get_buffer

### Description
Retrieves the buffer data for a given multimesh.

### Method
`multimesh_get_buffer`

### Parameters
#### Path Parameters
- `multimesh` (Rid) - The multimesh to query.

### Response
- `PackedFloat32Array` - The buffer data of the multimesh.
```

--------------------------------

### Vector2 Example: Distance Calculation

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/03-builtin-types.md

Demonstrates calculating the distance between two Vector2 points.

```rust
let v1 = Vector2::new(1.0, 2.0);
let v2 = Vector2::new(3.0, 4.0);
let dist = v1.distance_to(v2);
```

--------------------------------

### Constructing a Dictionary with Literal Syntax

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/03-builtin-types.md

Demonstrates creating a dictionary using the `dict!` macro for a more concise syntax.

```rust
let dict = dict! {
    "name" => "Player",
    "health" => 100
};
```

--------------------------------

### Get Lightmap Probe Capture Points

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Retrieves the capture points for a lightmap probe.

```rust
pub fn lightmap_get_probe_capture_points (& self , lightmap : Rid ,) -> PackedVector3Array {
    unsafe {
        let __class_name = StringName :: from ("RenderingServer") ;
        let __method_name = StringName :: from ("lightmap_get_probe_capture_points") ;
        let __method_bind = sys :: interface_fn ! (classdb_get_method_bind) (__class_name . string_sys () , __method_name . string_sys () , 808965560i64) ;
        assert ! (! __method_bind . is_null () , "failed to load method {}::{} (hash {}) -- possible Godot/gdext version mismatch" , "RenderingServer" , "lightmap_get_probe_capture_points" , 808965560i64) ;
        let __call_fn = sys :: interface_fn ! (object_method_bind_ptrcall) ;
        let __args = [< Rid as sys :: GodotFfi > :: sys_const (& lightmap)] ;
        let __args_ptr = __args . as_ptr () ;
        let return_ptr = std :: ptr :: null_mut () ;
        __call_fn (__method_bind , self . object_ptr , __args_ptr , return_ptr)
    }
}
```

--------------------------------

### Set Boot Image

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Configures the initial image displayed when the Godot project starts. Allows specifying an image, background color, scale, and filter.

```rust
pub fn set_boot_image(&mut self, image: Gd<crate::engine::Image>, color: Color, scale: bool, use_filter: bool) {
        unsafe {
            let __class_name = StringName::from("RenderingServer");
            let __method_name = StringName::from("set_boot_image");
            let __method_bind = sys::interface_fn!(classdb_get_method_bind)(__class_name.string_sys(), __method_name.string_sys(), 2244367877i64);
            assert!(!(__method_bind.is_null()), "failed to load method {}::{} (hash {})", "RenderingServer", "set_boot_image", 2244367877i64);
            let __call_fn = sys::interface_fn!(object_method_bind_ptrcall);
            let __args = [<Gd<crate::engine::Image> as AsArg>::as_arg_ptr(&image), <Color as sys::GodotFfi>::sys_const(&color), <bool as sys::GodotFfi>::sys_const(&scale), <bool as sys::GodotFfi>::sys_const(&use_filter)];
            let __args_ptr = __args.as_ptr();
            let return_ptr = std::ptr::null_mut();
            __call_fn(__method_bind, self.object_ptr, __args_ptr, return_ptr);
        }
    }
```

--------------------------------

### Get Multimesh Buffer in Rust

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Retrieves the buffer data for a given multimesh. Returns a `PackedFloat32Array`.

```rust
pub fn multimesh_get_buffer (& self , multimesh : Rid ,) -> PackedFloat32Array {
    unsafe {
        let __class_name = StringName :: from ("RenderingServer") ;
        let __method_name = StringName :: from ("multimesh_get_buffer") ;
        let __method_bind = sys :: interface_fn ! (classdb_get_method_bind) (__class_name . string_sys () , __method_name . string_sys () , 3964669176i64) ;
        assert ! (! __method_bind . is_null () , "failed to load method {}::{} (hash {}) -- possible Godot/gdext version mismatch" , "RenderingServer" , "multimesh_get_buffer" , 3964669176i64) ;
        let __call_fn = sys :: interface_fn ! (object_method_bind_ptrcall) ;
        let __args = [< Rid as sys :: GodotFfi > :: sys_const (& multimesh)] ;
        let __args_ptr = __args . as_ptr () ;
        < PackedFloat32Array as sys :: GodotFfi > :: from_sys_init_default (| return_ptr | {
            __call_fn (__method_bind , self . object_ptr , __args_ptr , return_ptr) ;
        })
    }
}
```

--------------------------------

### Implement INode3D Lifecycle

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/10-virtual-methods-callbacks.md

Implement the `ready` method for Node3D specific lifecycle events.

```rust
#[godot_api]
impl INode3D for My3DObject {
    fn ready(&mut self) {
        // Node3D lifecycle
    }
}
```

--------------------------------

### Constructing Callable References

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/03-builtin-types.md

Shows how to create Callable instances from object methods and standalone functions.

```rust
// From object method
let obj: Gd<Node> = Node::new_gd();
let callable = obj.callable("my_method");

// From function
let callable = Callable::from_fn(|| {
    godot_print!("Called!");
});
```

--------------------------------

### Get Rendering Device

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Retrieves the current RenderingDevice. Returns an Option containing a Gd<RenderingDevice> if available.

```rust
pub fn get_rendering_device (& self ,) -> Option < Gd < crate :: engine :: RenderingDevice > > {
unsafe {
let __class_name = StringName :: from ("RenderingServer") ;
let __method_name = StringName :: from ("get_rendering_device") ;
let __method_bind = sys :: interface_fn ! (classdb_get_method_bind) (__class_name . string_sys () , __method_name . string_sys () , 1405107940i64) ;
assert ! (! __method_bind . is_null () , "failed to load method {}::{} (hash {}) -- possible Godot/gdext version mismatch" , "RenderingServer" , "get_rendering_device" , 1405107940i64) ;
let __call_fn = sys :: interface_fn ! (object_method_bind_ptrcall) ;
let __args = [] ;
let __args_ptr = __args . as_ptr () ;
< Gd < crate :: engine :: RenderingDevice > > :: from_sys_init_opt (| return_ptr |
{
__call_fn (__method_bind , self . object_ptr , __args_ptr , return_ptr)
}
)
}
}
```

--------------------------------

### GDExtension Entry Point Template

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/QUICK-REFERENCE.md

A template for setting up the entry point of a GDExtension library in Rust. It defines the minimum initialization level and handles initialization stages.

```rust
use godot::init::*;

struct MyExtension;

#[gdextension]
unsafe impl ExtensionLibrary for MyExtension {
    fn min_level() -> InitLevel {
        InitLevel::Scene
    }
    
    fn on_stage_init(stage: InitStage) {
        match stage {
            InitStage::Scene => {
                // Setup
            }
            _ => {}
        }
    }
}
```

--------------------------------

### Get Texture Path

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Retrieves the file path associated with a texture. Returns a GString representing the path.

```rust
pub fn texture_get_path (& self , texture : Rid ,) -> GString {
unsafe {
let __class_name = StringName :: from ("RenderingServer") ;
let __method_name = StringName :: from ("texture_get_path") ;
let __method_bind = sys :: interface_fn ! (classdb_get_method_bind) (__class_name . string_sys () , __method_name . string_sys () , 642473191i64) ;
assert ! (! __method_bind . is_null () , "failed to load method {}::{} (hash {}) -- possible Godot/gdext version mismatch" ,
"RenderingServer" ,
"texture_get_path" ,
642473191i64
) ;
let __call_fn = sys :: interface_fn ! (object_method_bind_ptrcall) ;
let __args = [< Rid as sys :: GodotFfi > :: sys_const (& texture)] ;
let __args_ptr = __args . as_ptr () ;
< GString as sys :: GodotFfi > :: from_sys_init_default (| return_ptr | {
__call_fn (__method_bind , self . object_ptr , __args_ptr , return_ptr)
})
}
}
```

--------------------------------

### Reading Text and Binary Files with GFile

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/QUICK-REFERENCE.md

Demonstrates how to read the content of a text file or binary data from a specified path using `GFile`. Ensure the file paths are correct and accessible.

```rust
use godot::tools::GFile;

// Read
let content = GFile::read_text("res://file.txt")?;
let bytes = GFile::read_binary("user://data.bin")?;
```

--------------------------------

### Constructing GString

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/03-builtin-types.md

Demonstrates various ways to create a GString instance, including from Rust string literals, using the `into()` method, and with the `gformat!` macro.

```rust
let s1 = GString::from("Hello, World!");
let s2: GString = "Hello".into();
let s3 = gformat!("Value: {}", 42);
```

--------------------------------

### Get Video Adapter Type

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Retrieves the type of the current video adapter. This function is part of the RenderingServer module.

```rust
pub fn get_video_adapter_type (& self ,) -> crate :: engine :: rendering_device :: DeviceType {
    unsafe {
        let __class_name = StringName :: from ("RenderingServer") ;
        let __method_name = StringName :: from ("get_video_adapter_type") ;
        let __method_bind = sys :: interface_fn ! (classdb_get_method_bind) (__class_name . string_sys () , __method_name . string_sys () , 3099547011i64) ;
        assert ! (! __method_bind . is_null () , "failed to load method {}::{} (hash {}) -- possible Godot/gdext version mismatch" ,
            "RenderingServer" ,
            "get_video_adapter_type" ,
            3099547011i64
        ) ;
        let __call_fn = sys :: interface_fn ! (object_method_bind_ptrcall) ;
        let __args = [] ;
        let __args_ptr = __args . as_ptr () ;
        < crate :: engine :: rendering_device :: DeviceType as sys :: GodotFfi > :: from_sys_init_default (| return_ptr |
            {
                __call_fn (__method_bind , self . object_ptr , __args_ptr , return_ptr) ;
            }
        )
    }
}
```

--------------------------------

### Get Video Adapter Vendor

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Retrieves the vendor of the current video adapter. This function is part of the RenderingServer module.

```rust
pub fn get_video_adapter_vendor (& self ,) -> GString {
    unsafe {
        let __class_name = StringName :: from ("RenderingServer") ;
        let __method_name = StringName :: from ("get_video_adapter_vendor") ;
        let __method_bind = sys :: interface_fn ! (classdb_get_method_bind) (__class_name . string_sys () , __method_name . string_sys () , 201670096i64) ;
        assert ! (! __method_bind . is_null () , "failed to load method {}::{} (hash {}) -- possible Godot/gdext version mismatch" ,
            "RenderingServer" ,
            "get_video_adapter_vendor" ,
            201670096i64
        ) ;
        let __call_fn = sys :: interface_fn ! (object_method_bind_ptrcall) ;
        let __args = [] ;
        let __args_ptr = __args . as_ptr () ;
        < GString as sys :: GodotFfi > :: from_sys_init_default (| return_ptr |
            {
                __call_fn (__method_bind , self . object_ptr , __args_ptr , return_ptr) ;
            }
        )
    }
}
```

--------------------------------

### Constructing Variants

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/03-builtin-types.md

Demonstrates creating Variant instances from various Rust types.

```rust
let v: Variant = 42i32.to_variant();
let v: Variant = "hello".to_variant();
let v: Variant = Vector3::new(1.0, 2.0, 3.0).to_variant();
```

--------------------------------

### instance_create2

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Creates a new rendering instance with a specified base and scenario. This is used for instancing complex scenes or objects.

```APIDOC
## instance_create2

### Description
Creates a new rendering instance with a specified base and scenario. This is used for instancing complex scenes or objects.

### Method
N/A (Rust function call)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **base** (Rid) - The base Rid for the instance.
- **scenario** (Rid) - The scenario to which the instance belongs.

### Response
#### Success Response (Rid)
- Returns a `Rid` which is a unique identifier for the newly created rendering instance.

### Request Example
```rust
// Assuming 'rs' is an instance of RenderingServer and base_rid, scenario_rid are valid Rid values
let instance_rid = rs.instance_create2(base_rid, scenario_rid);
```

### Response Example
```json
{
  "example": "Rid(some_value)"
}
```
```

--------------------------------

### Get Video Adapter Name

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Retrieves the name of the current video adapter. This function is part of the RenderingServer module.

```rust
pub fn get_video_adapter_name (& self ,) -> GString {
    unsafe {
        let __class_name = StringName :: from ("RenderingServer") ;
        let __method_name = StringName :: from ("get_video_adapter_name") ;
        let __method_bind = sys :: interface_fn ! (classdb_get_method_bind) (__class_name . string_sys () , __method_name . string_sys () , 201670096i64) ;
        assert ! (! __method_bind . is_null () , "failed to load method {}::{} (hash {}) -- possible Godot/gdext version mismatch" ,
            "RenderingServer" ,
            "get_video_adapter_name" ,
            201670096i64
        ) ;
        let __call_fn = sys :: interface_fn ! (object_method_bind_ptrcall) ;
        let __args = [] ;
        let __args_ptr = __args . as_ptr () ;
        < GString as sys :: GodotFfi > :: from_sys_init_default (| return_ptr |
            {
                __call_fn (__method_bind , self . object_ptr , __args_ptr , return_ptr) ;
            }
        )
    }
}
```

--------------------------------

### Get Global Shader Parameter

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Retrieves the current value of a global shader parameter by its name. Returns a Variant.

```rust
pub fn global_shader_parameter_get(&self, name: StringName) -> Variant {
    unsafe {
        let __class_name = StringName::from("RenderingServer");
        let __method_name = StringName::from("global_shader_parameter_get");
        let __method_bind = sys::interface_fn!(
            classdb_get_method_bind
        )(
            __class_name.string_sys(),
            __method_name.string_sys(),
            2760726917i64,
        );
        assert!(
            !__method_bind.is_null(),
            "failed to load method {}::{} (hash {})
            -- possible Godot/gdext version mismatch",
            "RenderingServer",
            "global_shader_parameter_get",
            2760726917i64
        );
        let __call_fn = sys::interface_fn!(object_method_bind_ptrcall);
        let __args = [<StringName as sys::GodotFfi>::sys_const(&name)];
        let __args_ptr = __args.as_ptr();
        <Variant as sys::GodotFfi>::from_sys_init_default(|return_ptr| {
            __call_fn(__method_bind, self.object_ptr, __args_ptr, return_ptr);
        })
    }
}
```

--------------------------------

### create_local_rendering_device

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Creates a new local RenderingDevice instance.

```APIDOC
## create_local_rendering_device

### Description
Creates a new local RenderingDevice instance.

### Method
N/A (This is an SDK method)

### Parameters
None

### Response
#### Success Response
- **rendering_device** (Option<Gd<crate::engine::RenderingDevice>>) - The newly created local RenderingDevice instance, or None if creation failed.
```

--------------------------------

### Get Shader Parameter List

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Retrieves a list of all shader parameters for a given instance. Each parameter is represented as a Dictionary.

```rust
pub fn instance_geometry_get_shader_parameter_list (& self , instance : Rid ,) -> Array < Dictionary > {
    unsafe {
        let __class_name = StringName :: from ("RenderingServer") ;
        let __method_name = StringName :: from ("instance_geometry_get_shader_parameter_list") ;
        let __method_bind = sys :: interface_fn ! (classdb_get_method_bind) (__class_name . string_sys () , __method_name . string_sys () , 2684255073i64) ;
        assert ! (! __method_bind . is_null () , "failed to load method {}::{} (hash {}) -- possible Godot/gdext version mismatch"
            , "RenderingServer"
            , "instance_geometry_get_shader_parameter_list"
            , 2684255073i64
        ) ;
        let __call_fn = sys :: interface_fn ! (object_method_bind_ptrcall) ;
        let __args = [< Rid as sys :: GodotFfi > :: sys_const (& instance)] ;
        let __args_ptr = __args . as_ptr () ;
        < Array < Dictionary > as sys :: GodotFfi > :: from_sys_init_default (| return_ptr | {
            __call_fn (__method_bind , self . object_ptr , __args_ptr , return_ptr) ;
        })
    }
}
```

--------------------------------

### Get Mesh Surface Count

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Retrieves the number of surfaces on a given mesh. Requires a `Rid` representing the mesh.

```rust
pub fn mesh_get_surface_count (& self , mesh : Rid ,) -> i64 {
    unsafe {
        let __class_name = StringName :: from ("RenderingServer") ;
        let __method_name = StringName :: from ("mesh_get_surface_count") ;
        let __method_bind = sys :: interface_fn ! (classdb_get_method_bind) (__class_name . string_sys () , __method_name . string_sys () , 2198884583i64) ;
        assert ! (! __method_bind . is_null () , "failed to load method {}::{} (hash {}) -- possible Godot/gdext version mismatch" , "RenderingServer" , "mesh_get_surface_count" , 2198884583i64) ;
        let __call_fn = sys :: interface_fn ! (object_method_bind_ptrcall) ;
        let __args = [< Rid as sys :: GodotFfi > :: sys_const (& mesh)] ;
        let __args_ptr = __args . as_ptr () ;
        < i64 as sys :: GodotFfi > :: from_sys_init_default (| return_ptr | {
            __call_fn (__method_bind , self . object_ptr , __args_ptr , return_ptr) ;
        })
    }
}
```

--------------------------------

### Create RenderingServer Instance with Scenario

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Creates a rendering instance with a specified base and scenario. This is used for rendering 3D objects.

```rust
pub fn instance_create2(&mut self, base: Rid, scenario: Rid) -> Rid {
    unsafe {
        let __class_name = StringName::from("RenderingServer");
        let __method_name = StringName::from("instance_create2");
        let __method_bind = sys::interface_fn!(classdb_get_method_bind)(
            __class_name.string_sys(),
            __method_name.string_sys(),
            746547085i64,
        );
        assert!(
            !__method_bind.is_null(),
            "failed to load method {}::{} (hash {}) -- possible Godot/gdext version mismatch",
            "RenderingServer",
            "instance_create2",
            746547085i64
        );
        let __call_fn = sys::interface_fn!(object_method_bind_ptrcall);
        let __args = [
            <Rid as sys::GodotFfi>::sys_const(&base),
            <Rid as sys::GodotFfi>::sys_const(&scenario),
        ];
        let __args_ptr = __args.as_ptr();
        <Rid as sys::GodotFfi>::from_sys_init_default(|return_ptr| {
            __call_fn(__method_bind, self.object_ptr, __args_ptr, return_ptr)
        })
    }
}
```

--------------------------------

### Checking File Existence and Listing Directory Contents with GFile

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/QUICK-REFERENCE.md

Illustrates how to check if a file exists at a given path and how to list all files within a directory using `GFile`. These operations are useful for managing project assets.

```rust
use godot::tools::GFile;

// Check
if GFile::exists("res://scene.tscn") { }

// List
let files = GFile::list_dir("res://scenes/")?;
```

--------------------------------

### Get Material for Mesh Surface

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Retrieves the material assigned to a specific surface of a mesh. Returns the material RID.

```rust
pub fn mesh_surface_get_material (& self , mesh : Rid , surface : i64 ,) -> Rid {
    unsafe {
        let __class_name = StringName :: from ("RenderingServer") ;
        let __method_name = StringName :: from ("mesh_surface_get_material") ;
        let __method_bind = sys :: interface_fn ! (classdb_get_method_bind) (__class_name . string_sys () , __method_name . string_sys () , 1066463050i64) ;
        assert ! (! __method_bind . is_null () , "failed to load method {}::{} (hash {}) -- possible Godot/gdext version mismatch" ,
            "RenderingServer" ,
            "mesh_surface_get_material" ,
            1066463050i64
        ) ;
        let __call_fn = sys :: interface_fn ! (object_method_bind_ptrcall) ;
        let __args = [< Rid as sys :: GodotFfi > :: sys_const (& mesh) , < i64 as sys :: GodotFfi > :: sys_const (& surface)] ;
        let __args_ptr = __args . as_ptr () ;
        < Rid as sys :: GodotFfi > :: from_sys_init_default (| return_ptr | {
            __call_fn (__method_bind , self . object_ptr , __args_ptr , return_ptr) ;
        })
    }
}
```

--------------------------------

### Get Material Parameter

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Retrieves the value of a specific parameter from a material. Requires a `Rid` for the material and a `StringName` for the parameter.

```rust
pub fn material_get_param (& self , material : Rid , parameter : StringName ,) -> Variant {
    unsafe {
        let __class_name = StringName :: from ("RenderingServer") ;
        let __method_name = StringName :: from ("material_get_param") ;
        let __method_bind = sys :: interface_fn ! (classdb_get_method_bind) (__class_name . string_sys () , __method_name . string_sys () , 2621281810i64) ;
        assert ! (! __method_bind . is_null () , "failed to load method {}::{} (hash {}) -- possible Godot/gdext version mismatch" , "RenderingServer" , "material_get_param" , 2621281810i64) ;
        let __call_fn = sys :: interface_fn ! (object_method_bind_ptrcall) ;
        let __args = [< Rid as sys :: GodotFfi > :: sys_const (& material) , < StringName as sys :: GodotFfi > :: sys_const (& parameter)] ;
        let __args_ptr = __args . as_ptr () ;
        < Variant as sys :: GodotFfi > :: from_sys_init_default (| return_ptr | {
            __call_fn (__method_bind , self . object_ptr , __args_ptr , return_ptr) ;
        })
    }
}
```

--------------------------------

### Get RenderDevice Texture

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Retrieves the RenderDevice texture associated with a given texture. Optionally specifies if the texture is sRGB.

```rust
pub fn texture_get_rd_texture (& self , texture : Rid , srgb : bool ,) -> Rid {
unsafe {
let __class_name = StringName :: from ("RenderingServer") ;
let __method_name = StringName :: from ("texture_get_rd_texture") ;
let __method_bind = sys :: interface_fn ! (classdb_get_method_bind) (__class_name . string_sys () , __method_name . string_sys () , 2790148051i64) ;
assert ! (! __method_bind . is_null () , "failed to load method {}::{} (hash {}) -- possible Godot/gdext version mismatch" ,
"RenderingServer" ,
"texture_get_rd_texture" ,
2790148051i64
) ;
let __call_fn = sys :: interface_fn ! (object_method_bind_ptrcall) ;
let __args = [< Rid as sys :: GodotFfi > :: sys_const (& texture) , < bool as sys :: GodotFfi > :: sys_const (& srgb)] ;
let __args_ptr = __args . as_ptr () ;
< Rid as sys :: GodotFfi > :: from_sys_init_default (| return_ptr | {
__call_fn (__method_bind , self . object_ptr , __args_ptr , return_ptr)
})
}
}
```

--------------------------------

### Implement INode2D Lifecycle

Source: https://github.com/godot-rust/gdext/blob/master/_autodocs/10-virtual-methods-callbacks.md

Implement the `ready` method for Node2D specific lifecycle events.

```rust
#[godot_api]
impl INode2D for MySprite {
    fn ready(&mut self) {
        // Node2D lifecycle
    }
}
```

--------------------------------

### RenderingServer Methods

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Provides documentation for various methods of the RenderingServer class, allowing users to query features, control rendering behavior, and retrieve performance metrics.

```APIDOC
## has_feature

### Description
Checks if the rendering server supports a specific feature.

### Method
GET (conceptual)

### Endpoint
N/A (SDK method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **feature** (crate::engine::rendering_server::Features) - Required - The feature to check for.

### Response
#### Success Response (bool)
- Returns `true` if the feature is supported, `false` otherwise.

### Response Example
```json
{
  "example": true
}
```

## has_os_feature

### Description
Checks if the operating system supports a specific rendering feature.

### Method
GET (conceptual)

### Endpoint
N/A (SDK method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **feature** (GString) - Required - The OS-specific feature to check for.

### Response
#### Success Response (bool)
- Returns `true` if the OS supports the feature, `false` otherwise.

### Response Example
```json
{
  "example": true
}
```

## set_debug_generate_wireframes

### Description
Enables or disables the generation of wireframes for debugging purposes.

### Method
POST (conceptual)

### Endpoint
N/A (SDK method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **generate** (bool) - Required - `true` to enable wireframe generation, `false` to disable.

### Response
#### Success Response (void)
- No content is returned upon success.

## is_render_loop_enabled

### Description
Checks if the rendering loop is currently enabled.

### Method
GET (conceptual)

### Endpoint
N/A (SDK method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Response
#### Success Response (bool)
- Returns `true` if the render loop is enabled, `false` otherwise.

### Response Example
```json
{
  "example": true
}
```

## set_render_loop_enabled

### Description
Enables or disables the rendering loop.

### Method
POST (conceptual)

### Endpoint
N/A (SDK method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **enabled** (bool) - Required - `true` to enable the render loop, `false` to disable.

### Response
#### Success Response (void)
- No content is returned upon success.

## get_frame_setup_time_cpu

### Description
Retrieves the CPU time taken to set up the current frame.

### Method
GET (conceptual)

### Endpoint
N/A (SDK method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Response
#### Success Response (f64)
- Returns the CPU time in seconds as a floating-point number.

### Response Example
```json
{
  "example": 0.015
}
```
```

--------------------------------

### Get Lightmap Probe Capture Points

Source: https://github.com/godot-rust/gdext/blob/master/godot-codegen/src/formatter/test-cases/rendering_server.rs.txt

Retrieves the capture points for a lightmap probe. Requires a `Rid` representing the lightmap.

```rust
pub fn lightmap_get_probe_capture_points (& self , lightmap : Rid ,) -> PackedVector3Array {
unsafe {
let __class_name = StringName :: from ("RenderingServer") ;
let __method_name = StringName :: from ("lightmap_get_probe_capture_points") ;
let __method_bind = sys :: interface_fn ! (classdb_get_method_bind) (__class_name . string_sys () , __method_name . string_sys () , 808965560i64) ;
assert ! (! __method_bind . is_null () , "failed to load method {}::{} (hash {}) -- possible Godot/gdext version mismatch" , "RenderingServer" , "lightmap_get_probe_capture_points" , 808965560i64) ;
let __call_fn = sys :: interface_fn ! (object_method_bind_ptrcall) ;
let __args = [< Rid as sys :: GodotFfi > :: sys_const (& lightmap)] ;
let __args_ptr = __args . as_ptr () ;
< PackedVector3Array as sys :: GodotFfi > :: from_sys_init_default (| return_ptr |
{
__call_fn (__method_bind , self . object_ptr , __args_ptr , return_ptr) ;
}
)
}
}
```