Rakugaki

https://docs.rs/rakugaki
Admin
Rakugaki is a Rust crate that renders Unicode characters as ASCII art with configurable character...
Tokens:7,037
Snippets:89
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### CloneToUninit Implementation (Nightly)

Source: https://docs.rs/rakugaki/latest/rakugaki/struct.RenderMode.html

Nightly-only experimental API for performing copy-assignment from self to uninitialized memory.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

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

### Test Bitmap to ASCII Conversion (Simple Pattern)

Source: https://docs.rs/rakugaki/latest/src/rakugaki/lib.rs.html

Tests the bitmap to ASCII conversion with a simple 2x2 bitmap containing maximum and minimum brightness values. Asserts that these map correctly to the lightest and darkest characters.

```rust
let bitmap = vec![255, 0, 0, 255];
        let result = bitmap_to_ascii(&bitmap, 2, 2, 2, 2, RenderMode::default()).unwrap();
        assert_eq!(result.len(), 2);
        // 255 maps to darkest char ('$'), 0 maps to lightest (' ')
        assert_eq!(result[0].chars().next().unwrap(), '$');
        assert_eq!(result[0].chars().nth(1).unwrap(), ' ');
        assert_eq!(result[1].chars().next().unwrap(), ' ');
        assert_eq!(result[1].chars().nth(1).unwrap(), '$');
```

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

### Test Bitmap to ASCII Conversion (Empty)

Source: https://docs.rs/rakugaki/latest/src/rakugaki/lib.rs.html

Tests the bitmap to ASCII conversion with an empty bitmap and zero dimensions, asserting the expected output structure.

```rust
let result = bitmap_to_ascii(&[], 0, 0, 5, 3, RenderMode::default()).unwrap();
        assert_eq!(result.len(), 3);
        assert_eq!(result[0], "     ");
```

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

### RenderMode::new

Source: https://docs.rs/rakugaki/latest/rakugaki/struct.RenderMode.html

Creates a custom rendering mode by specifying the character set and color mode.

```APIDOC
## `RenderMode::new`

### Description

Create a custom rendering mode by specifying the character set and color mode.

### Signature

```rust
pub const fn new(characters: CharacterSet, colors: ColorMode) -> Self
```

### Parameters

- `characters` (CharacterSet): The character set to use for rendering.
- `colors` (ColorMode): The color mode to use for rendering.
```

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

### Custom RenderMode Constructor

Source: https://docs.rs/rakugaki/latest/src/rakugaki/lib.rs.html

Creates a custom rendering mode by specifying the character set and color mode. Use this for non-standard rendering configurations.

```rust
pub const fn new(characters: CharacterSet, colors: ColorMode) -> Self {
    Self { characters, colors }
}
```

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

### RenderMode Constants

Source: https://docs.rs/rakugaki/latest/rakugaki/struct.RenderMode.html

Predefined RenderMode constants for different display capabilities.

```APIDOC
## RenderMode Constants

### `RenderMode::ASCII`

ASCII mode: density characters, no colors (default, most compatible).

### `RenderMode::ANSI256`

ANSI 256-color mode: blocks with 256-color grayscale.

### `RenderMode::ANSI_TRUECOLOR`

ANSI truecolor mode: blocks with 24-bit grayscale.
```

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

### From Implementation

Source: https://docs.rs/rakugaki/latest/rakugaki/struct.RenderMode.html

Converts a value into the same type, returning the argument unchanged.

```rust
fn from(t: T) -> T
```

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

### Test Rendering Katakana 'カ'

Source: https://docs.rs/rakugaki/latest/src/rakugaki/lib.rs.html

Tests the rendering of the katakana character 'カ' (ka) to a 15x15 grid. It verifies successful rendering and checks the number of output lines. The test skips if the required font file is not found.

```rust
    #[test]
    fn test_render_katakana_ka() {
        // Test rendering katakana 'カ' (ka)
        let font_path = "fonts/noto_sans_jp/NotoSansJP-VariableFont_wght.ttf";

        if !std::path::Path::new(font_path).exists() {
            eprintln!("Skipping test - font not found at {}", font_path);
            return;
        }

        let result = render_char(font_path, 'カ', 15, 15);
        assert!(result.is_ok());

        let lines = result.unwrap();
        assert_eq!(lines.len(), 15);

        println!("\nRendered 'カ' (katakana ka) at 15x15:");
        for line in &lines {
            println!("{}", line);
        }
    }
```

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

### Equivalent Implementation

Source: https://docs.rs/rakugaki/latest/rakugaki/struct.RenderMode.html

Compares self to a key and returns true if they are equal.

```rust
fn equivalent(&self, key: &K) -> bool
```

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

### TryFrom Implementation

Source: https://docs.rs/rakugaki/latest/rakugaki/struct.RenderMode.html

Attempts to convert a value into another type, returning a Result.

```rust
type Error = Infallible
```

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

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

### PartialEq Implementation for RenderMode

Source: https://docs.rs/rakugaki/latest/rakugaki/struct.RenderMode.html

Enables equality comparison between RenderMode values.

```rust
fn eq(&self, other: &RenderMode) -> bool
```

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

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

### Create Custom Render Mode

Source: https://docs.rs/rakugaki/latest/rakugaki/struct.RenderMode.html

Function to create a custom rendering mode by specifying the character set and color mode.

```rust
pub fn new(characters: CharacterSet, colors: ColorMode) -> Self
```

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

### Test Rendering Hiragana 'あ'

Source: https://docs.rs/rakugaki/latest/src/rakugaki/lib.rs.html

Tests the rendering of the hiragana character 'あ' (a) to a 20x20 grid. It checks for successful rendering, correct output dimensions, and the presence of visible character data. The test skips if the required font file is not found.

```rust
    #[test]
    fn test_render_hiragana_a() {
        // Test rendering hiragana 'あ' (a)
        let font_path = "fonts/noto_sans_jp/NotoSansJP-VariableFont_wght.ttf";

        // Skip test if font file doesn't exist
        if !std::path::Path::new(font_path).exists() {
            eprintln!("Skipping test - font not found at {}", font_path);
            return;
        }

        let result = render_char(font_path, 'あ', 20, 20);
        assert!(result.is_ok(), "Failed to render: {:?}", result.err());

        let lines = result.unwrap();
        assert_eq!(lines.len(), 20, "Expected 20 lines of output");

        // Each line should be 20 characters wide
        for line in &lines {
            assert_eq!(line.len(), 20, "Line width should be 20 chars");
        }

        // The output should contain some non-space characters (the glyph)
        let total_chars: String = lines.join("");
        let non_space_count = total_chars.chars().filter(|c| *c != ' ').count();
        assert!(
            non_space_count > 0,
            "Should have some visible character data"
        );

        // Print the result for visual inspection
        println!("\nRendered 'あ' (hiragana a) at 20x20:");
        for line in &lines {
            println!("{}", line);
        }
    }
```

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

### Default Render Mode Implementation

Source: https://docs.rs/rakugaki/latest/rakugaki/struct.RenderMode.html

Provides the default value for the RenderMode type.

```rust
fn default() -> RenderMode
```

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

### Into Implementation

Source: https://docs.rs/rakugaki/latest/rakugaki/struct.RenderMode.html

Converts a value into another type using the From trait.

```rust
fn into(self) -> U
```

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

### ASCII Render Mode

Source: https://docs.rs/rakugaki/latest/rakugaki/struct.RenderMode.html

Represents the ASCII rendering mode, which uses density characters and no colors. This is the default and most compatible mode.

```rust
pub const ASCII: Self
```

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

### render_char_with_mode

Source: https://docs.rs/rakugaki/latest/rakugaki/fn.render_char_with_mode.html

Renders a single Unicode character as ASCII art with configurable rendering mode.

```APIDOC
## Function render_char_with_mode

### Description
Renders a single Unicode character as ASCII art with configurable rendering mode.

### Signature
```rust
pub fn render_char_with_mode(
    font_path: impl AsRef<Path>,
    codepoint: char,
    width: usize,
    height: usize,
    mode: RenderMode,
) -> Result<Vec<String>, String>
```

### Arguments
* `font_path` - Path to the TTF/OTF font file
* `codepoint` - The Unicode character to render
* `width` - Target width in terminal characters
* `height` - Target height in terminal characters
* `mode` - Rendering mode (Ascii, Ansi256, or AnsiTruecolor)

### Returns
A vector of strings, one per line, representing the ASCII art
```

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

### render_char_with_mode

Source: https://docs.rs/rakugaki/latest/rakugaki

Renders a single Unicode character as ASCII art with configurable rendering mode.

```APIDOC
## Function: render_char_with_mode

### Description
Renders a single Unicode character as ASCII art with configurable rendering mode.

### Signature
```rust
fn render_char_with_mode(c: char, width: usize, height: usize, mode: &RenderMode) -> String
```

### Parameters
* `c` (char) - The Unicode character to render.
* `width` (usize) - The desired width of the ASCII art.
* `height` (usize) - The desired height of the ASCII art.
* `mode` (&RenderMode) - The rendering mode to use, combining character set and color mode.

### Returns
* `String` - The ASCII art representation of the character.
```

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

### render_char_with_mode

Source: https://docs.rs/rakugaki/latest/rakugaki/index.html

Renders a single Unicode character as ASCII art with configurable rendering mode.

```APIDOC
## render_char_with_mode

### Description
Renders a single Unicode character as ASCII art with configurable rendering mode.

### Function Signature
```rust
fn render_char_with_mode(c: char, width: usize, height: usize, mode: &RenderMode) -> String
```

### Parameters
#### Path Parameters
- **c** (char) - The Unicode character to render.
- **width** (usize) - The desired width of the ASCII art.
- **height** (usize) - The desired height of the ASCII art.
- **mode** (&RenderMode) - The rendering mode to use, combining character set and color mode.

### Returns
- **String** - The ASCII art representation of the character.
```

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

### render_char_with_mode

Source: https://docs.rs/rakugaki/latest/index.html

Renders a single Unicode character as ASCII art with configurable rendering mode.

```APIDOC
## Function render_char_with_mode

### Description
Renders a single Unicode character as ASCII art with configurable rendering mode.

### Signature
```rust
fn render_char_with_mode(c: char, width: u32, height: u32, mode: &RenderMode) -> String
```

### Parameters
* `c` (char) - The Unicode character to render.
* `width` (u32) - The desired width of the ASCII art.
* `height` (u32) - The desired height of the ASCII art.
* `mode` (&RenderMode) - The rendering mode to use, combining character set and color mode.

### Returns
* `String` - The ASCII art representation of the character with the specified mode.
```

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

### Render Character with Default Mode

Source: https://docs.rs/rakugaki/latest/src/rakugaki/lib.rs.html

Renders a single Unicode character as ASCII art using the default rendering mode (density characters, no colors). Specify the font path, codepoint, and target dimensions. Adjust dimensions for terminal aspect ratio.

```rust
pub fn render_char(
    font_path: impl AsRef<Path>,
    codepoint: char,
    width: usize,
    height: usize,
) -> Result<Vec<String>, String> {
    render_char_with_mode(font_path, codepoint, width, height, RenderMode::default())
}
```

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

### TryInto Implementation

Source: https://docs.rs/rakugaki/latest/rakugaki/struct.RenderMode.html

Attempts to convert a value into another type using the TryFrom trait, returning a Result.

```rust
type Error = <U as TryFrom<T>>::Error
```

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

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

### Render Character with Specific Mode

Source: https://docs.rs/rakugaki/latest/src/rakugaki/lib.rs.html

Renders a single Unicode character as ASCII art with a configurable rendering mode. Supports ASCII, Ansi256, or AnsiTruecolor modes. Requires font path, codepoint, dimensions, and the desired RenderMode.

```rust
pub fn render_char_with_mode(
    font_path: impl AsRef<Path>,
    codepoint: char,
    width: usize,
    height: usize,
    mode: RenderMode,
) -> Result<Vec<String>, String> {
    // Load font file
    let font_data = std::fs::read(font_path).map_err(|e| format!("Failed to read font: {}", e))?;
    let font = Font::from_bytes(font_data.as_slice(), fontdue::FontSettings::default())
        .map_err(|e| format!("Failed to parse font: {}", e))?;

    // Render to fill the visual space defined by width × height.
    // We treat the dimensions as defining a square-pixel space and let the user
    // choose dimensions that look right for their terminal.

    // Use the larger dimension to render at good quality
    let font_size = (width.max(height) as f32) * 1.2;

    // Rasterize the glyph
    let (metrics, bitmap) = font.rasterize(codepoint, font_size);

    // Convert bitmap to ASCII using the specified rendering mode
    bitmap_to_ascii(&bitmap, metrics.width, metrics.height, width, height, mode)
}
```

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

### Bitmap to ASCII Conversion

Source: https://docs.rs/rakugaki/latest/src/rakugaki/lib.rs.html

Converts a grayscale bitmap to ASCII art, supporting different rendering modes. Handles empty bitmaps by returning a grid of spaces. The character ramp is ordered by visual density.

```rust
fn bitmap_to_ascii(
    bitmap: &[u8],
    bitmap_width: usize,
    bitmap_height: usize,
    target_width: usize,
    target_height: usize,
    mode: RenderMode,
) -> Result<Vec<String>, String> {
    if bitmap.is_empty() {
        return Ok(vec![" ".repeat(target_width); target_height]);
    }

    // Grayscale character ramp ordered by visual density (lightest to darkest)

```

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

### Clone Implementation for RenderMode

Source: https://docs.rs/rakugaki/latest/rakugaki/struct.RenderMode.html

Enables duplication of RenderMode values.

```rust
fn clone(&self) -> RenderMode
```

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

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

### render_char

Source: https://docs.rs/rakugaki/latest/rakugaki/fn.render_char.html

Renders a single Unicode character as ASCII art within the given dimensions. Uses ASCII character density for grayscale rendering. For ANSI color support, use `render_char_with_mode`.

```APIDOC
## Function render_char

### Summary
```
pub fn render_char(
    font_path: impl AsRef<Path>,
    codepoint: char,
    width: usize,
    height: usize,
) -> Result<Vec<String>, String>
```

### Arguments
* `font_path` - Path to the TTF/OTF font file
* `codepoint` - The Unicode character to render
* `width` - Target width in terminal characters
* `height` - Target height in terminal characters

### Returns
A vector of strings, one per line, representing the ASCII art.

### Note
The width and height define the visual space for rendering. Users should adjust these dimensions to account for their terminal’s character cell aspect ratio. For example, if terminal cells are 2:1 (height:width), a visually square character would use dimensions like 40×20.
```

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

### Debug Implementation for RenderMode

Source: https://docs.rs/rakugaki/latest/rakugaki/struct.RenderMode.html

Allows RenderMode values to be formatted for debugging purposes.

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

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

### RenderMode Constants

Source: https://docs.rs/rakugaki/latest/src/rakugaki/lib.rs.html

Defines constants for common rendering modes: ASCII (default, most compatible), ANSI256 (blocks with 256-color grayscale), and ANSI_TRUECOLOR (blocks with 24-bit grayscale).

```rust
pub const ASCII: Self = Self {
    characters: CharacterSet::Density,
    colors: ColorMode::None,
};

/// ANSI 256-color mode: blocks with 256-color grayscale
pub const ANSI256: Self = Self {
    characters: CharacterSet::Blocks,
    colors: ColorMode::Ansi256,
};

/// ANSI truecolor mode: blocks with 24-bit grayscale
pub const ANSI_TRUECOLOR: Self = Self {
    characters: CharacterSet::Blocks,
    colors: ColorMode::AnsiTruecolor,
};
```

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

### render_char

Source: https://docs.rs/rakugaki/latest/index.html

Renders a single Unicode character as ASCII art within the given dimensions.

```APIDOC
## Function render_char

### Description
Renders a single Unicode character as ASCII art within the given dimensions.

### Signature
```rust
fn render_char(c: char, width: u32, height: u32) -> String
```

### Parameters
* `c` (char) - The Unicode character to render.
* `width` (u32) - The desired width of the ASCII art.
* `height` (u32) - The desired height of the ASCII art.

### Returns
* `String` - The ASCII art representation of the character.
```

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

### render_char

Source: https://docs.rs/rakugaki/latest/rakugaki

Renders a single Unicode character as ASCII art within the given dimensions.

```APIDOC
## Function: render_char

### Description
Renders a single Unicode character as ASCII art within the given dimensions.

### Signature
```rust
fn render_char(c: char, width: usize, height: usize) -> String
```

### Parameters
* `c` (char) - The Unicode character to render.
* `width` (usize) - The desired width of the ASCII art.
* `height` (usize) - The desired height of the ASCII art.

### Returns
* `String` - The ASCII art representation of the character.
```

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

### render_char

Source: https://docs.rs/rakugaki/latest/rakugaki/index.html

Renders a single Unicode character as ASCII art within the given dimensions.

```APIDOC
## render_char

### Description
Renders a single Unicode character as ASCII art within the given dimensions.

### Function Signature
```rust
fn render_char(c: char, width: usize, height: usize) -> String
```

### Parameters
#### Path Parameters
- **c** (char) - The Unicode character to render.
- **width** (usize) - The desired width of the ASCII art.
- **height** (usize) - The desired height of the ASCII art.

### Returns
- **String** - The ASCII art representation of the character.
```

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

### render_char

Source: https://docs.rs/rakugaki/latest/src/rakugaki/lib.rs.html

Renders a single Unicode character as ASCII art within the given dimensions using the default rendering mode (density characters, no colors).

```APIDOC
## render_char

### Description
Renders a single Unicode character as ASCII art within the given dimensions.

Uses ASCII character density for grayscale rendering (most compatible).
For ANSI color support, use `render_char_with_mode`.

### Arguments
* `font_path` - Path to the TTF/OTF font file
* `codepoint` - The Unicode character to render
* `width` - Target width in terminal characters
* `height` - Target height in terminal characters

### Returns
A vector of strings, one per line, representing the ASCII art

### Note
The width and height define the visual space for rendering. Users should
adjust these dimensions to account for their terminal's character cell
aspect ratio. For example, if terminal cells are 2:1 (height:width),
a visually square character would use dimensions like 40×20.

### Signature
```rust
pub fn render_char(
    font_path: impl AsRef<Path>,
    codepoint: char,
    width: usize,
    height: usize,
) -> Result<Vec<String>, String>
```
```

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

### Borrow Implementation

Source: https://docs.rs/rakugaki/latest/rakugaki/struct.RenderMode.html

Provides immutable borrowing capabilities for a type.

```rust
fn borrow(&self) -> &T
```

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

### Convert Bitmap to ASCII Art

Source: https://docs.rs/rakugaki/latest/src/rakugaki/lib.rs.html

Converts a bitmap image into ASCII art. Supports different character sets (density or blocks) and color modes (none, ANSI 256-color, or truecolor). Maps pixel intensity to characters and applies color codes.

```rust
const DENSITY_RAMP: &[char] = &[
        ' ', '.', '\'', '`', '^', '"', ',', ':', ';', 'I', 'l', '!', 'i', '>', '<', '~', '+', '_',
        '-', '?', ']', '[', '}', '{', '1', ')', '(', '|', '\\', '/', 't', 'f', 'j', 'r', 'x', 'n',
        'u', 'v', 'c', 'z', 'X', 'Y', 'U', 'J', 'C', 'L', 'Q', '0', 'O', 'Z', 'm', 'w', 'q', 'p',
        'd', 'b', 'k', 'h', 'a', 'o', '*', '#', 'M', 'W', '&', '8', '%', 'B', '@', '$',
    ];

    let mut result = Vec::with_capacity(target_height);

    // Simple nearest-neighbor sampling from bitmap to target dimensions
    for row in 0..target_height {
        let mut line = String::new();

        for col in 0..target_width {
            // Map target position to bitmap position
            let bmp_x = (col * bitmap_width) / target_width.max(1);
            let bmp_y = (row * bitmap_height) / target_height.max(1);

            let idx = bmp_y * bitmap_width + bmp_x;
            let pixel = if idx < bitmap.len() { bitmap[idx] } else { 0 };

            // Unicode block characters ordered by visual density (lightest to darkest)
            // Using vertical eighth blocks for smooth gradations
            const BLOCK_RAMP: &[char] = &[
                ' ', // Empty
                '░', // Light shade
                '▒', // Medium shade
                '▓', // Dark shade
                '█', // Full block
            ];

            // Choose character based on character set
            let ch = match mode.characters {
                CharacterSet::Density => {
                    // Map pixel intensity (0-255) to character density
                    // Higher pixel values = denser characters
                    let density_idx = ((pixel as usize) * (DENSITY_RAMP.len() - 1)) / 255;
                    DENSITY_RAMP[density_idx]
                }
                CharacterSet::Blocks => {
                    // Map pixel intensity to block density
                    let block_idx = ((pixel as usize) * (BLOCK_RAMP.len() - 1)) / 255;
                    BLOCK_RAMP[block_idx]
                }
            };

            // Apply color based on color mode
            match mode.colors {
                ColorMode::None => {
                    // No color, just push the character
                    line.push(ch);
                }
                ColorMode::Ansi256 => {
                    // ANSI 256-color grayscale (colors 232-255 are grayscale)
                    // Use foreground color for both character sets
                    let gray_idx = if pixel == 0 {
                        232 // Pure black for background/empty pixels
                    } else {
                        // Map 1-255 to a compressed range: ~235-250 (dimmer to moderately bright)
                        235 + ((pixel as usize * 15) / 255)
                    };
                    line.push_str(&format!("\x1b[38;5;{}m{}\x1b[0m", gray_idx, ch));
                }
                ColorMode::AnsiTruecolor => {
                    // ANSI truecolor (24-bit) for smoothest grayscale
                    // Use foreground color for both character sets
                    let adjusted_brightness = if pixel == 0 {
                        0 // Pure black for background/empty pixels
                    } else {
                        // Map 1-255 to a compressed range: ~60-200 (dimmer to moderately bright)
                        60 + ((pixel as usize * 140) / 255)
                    };
                    line.push_str(&format!(
                        "\x1b[38;2;{};{};{}m{}\x1b[0m",
                        adjusted_brightness, adjusted_brightness, adjusted_brightness, ch
                    ));
                }
            }
        }

        result.push(line);
    }

    Ok(result)
}
```

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

### RenderMode Struct Definition

Source: https://docs.rs/rakugaki/latest/rakugaki/struct.RenderMode.html

Defines the structure for rendering modes, combining character sets and color modes.

```rust
pub struct RenderMode {
    pub characters: CharacterSet,
    pub colors: ColorMode,
}
```

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

### BorrowMut Implementation

Source: https://docs.rs/rakugaki/latest/rakugaki/struct.RenderMode.html

Provides mutable borrowing capabilities for a type.

```rust
fn borrow_mut(&mut self) -> &mut T
```

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

### CharacterSet Enum Definition

Source: https://docs.rs/rakugaki/latest/rakugaki/enum.CharacterSet.html

Defines the available character sets for rendering. 'Density' provides more detail, while 'Blocks' is simpler and works well with colors.

```APIDOC
## Enum CharacterSet

### Summary
```
pub enum CharacterSet {
    Density,
    Blocks,
}
```

### Description
Character set to use for rendering

### Variants
#### Density
70-character density ramp (most detail)

#### Blocks
Simple block/space (minimal, works best with colors)
```

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

### ColorMode Enum Definition

Source: https://docs.rs/rakugaki/latest/rakugaki/enum.ColorMode.html

Defines the available color modes for rendering. Use 'None' for maximum compatibility, 'Ansi256' for 256-color grayscale if supported, or 'AnsiTruecolor' for 256-shade grayscale with truecolor support.

```rust
pub enum ColorMode {
    None,
    Ansi256,
    AnsiTruecolor,
}
```

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

### ANSI Truecolor Render Mode

Source: https://docs.rs/rakugaki/latest/rakugaki/struct.RenderMode.html

Represents the ANSI truecolor rendering mode, using blocks with 24-bit grayscale.

```rust
pub const ANSI_TRUECOLOR: Self
```

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

### ToOwned Implementation

Source: https://docs.rs/rakugaki/latest/rakugaki/struct.RenderMode.html

Creates owned data from borrowed data, usually by cloning.

```rust
type Owned = T
```

```rust
fn to_owned(&self) -> T
```

```rust
fn clone_into(&self, target: &mut T)
```

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

### ANSI256 Color Render Mode

Source: https://docs.rs/rakugaki/latest/rakugaki/struct.RenderMode.html

Represents the ANSI 256-color rendering mode, using blocks with 256-color grayscale.

```rust
pub const ANSI256: Self
```

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

### ColorMode Enum Definition

Source: https://docs.rs/rakugaki/latest/rakugaki/enum.ColorMode.html

Defines the available color modes for rendering. Each variant has a specific purpose and compatibility.

```APIDOC
## Enum ColorMode

### Summary
```
pub enum ColorMode {
    None,
    Ansi256,
    AnsiTruecolor,
}
```

### Description
Color mode for rendering

### Variants

#### None
No colors, monochrome (most compatible)

#### Ansi256
ANSI 256-color grayscale (24 shades, requires terminal support)

#### AnsiTruecolor
ANSI truecolor grayscale (256 shades, requires terminal support)
```

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

### Define CharacterSet Enum

Source: https://docs.rs/rakugaki/latest/rakugaki/enum.CharacterSet.html

Defines the CharacterSet enum with two variants: Density for high detail and Blocks for minimal rendering. Use this enum to specify the desired character set for rendering operations.

```rust
pub enum CharacterSet {
    Density,
    Blocks,
}
```

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

### GetTypeId Implementation

Source: https://docs.rs/rakugaki/latest/rakugaki/struct.RenderMode.html

Retrieves the TypeId of a type, useful for runtime type identification.

```rust
fn type_id(&self) -> TypeId
```
Tokens:
Raw