Gamma Table Macros

A Rust procedural macro crate for generating compile-time gamma lookup tables with support for both gamma encoding and gamma correction/decoding.

Overview

This crate provides a proc macro that generates efficient lookup tables for gamma processing at compile time. By default, it uses gamma encoding (input^{gamma). It also supports gamma correction/decoding (input}(1/gamma)) when the decoding parameter is set to true. This is particularly useful for graphics applications, LED control, and any scenario where you need fast gamma processing without runtime computation.

Features

Compile-time generation: Tables are computed at compile time, resulting in zero runtime overhead
Dual gamma modes: Gamma encoding (default) and gamma correction/decoding
Flexible parameters: Configurable gamma values, table sizes, entry types, and brightness limits
Multiple data types: Support for u8, u16, u32, and u64 entry types
Brightness limiting: Optional max_value parameter to cap output brightness

Usage

Add this to your Cargo.toml:

[dependencies]
gamma-table-macros = "0.1.0"

Gamma Encoding Example (Default)

use gamma_table_macros::gamma_table;

// Generate a gamma encoding table (default behavior)
gamma_table! {
    name: GAMMA_ENCODED_TABLE,
    entry_type: u8,
    gamma: 2.2,
    size: 256
}

fn main() {
    let input = 128u8;  // 50% brightness
    let encoded = GAMMA_ENCODED_TABLE[input as usize];
    println!("Input: {}, Gamma encoded: {}", input, encoded);  // Will be darker
}

Gamma Correction/Decoding Example

use gamma_table_macros::gamma_table;

// Generate a gamma correction/decoding table
gamma_table! {
    name: GAMMA_DECODED_TABLE,
    entry_type: u8,
    gamma: 2.2,
    size: 256,
    decoding: true
}

fn main() {
    let input = 128u8;  // 50% brightness
    let corrected = GAMMA_DECODED_TABLE[input as usize];
    println!("Input: {}, Gamma corrected: {}", input, corrected);  // Will be brighter
}

LED Control Example

For LED control where you want to limit maximum brightness:

gamma_table! {
    name: LED_GAMMA_TABLE,
    entry_type: u8,
    gamma: 2.5,
    size: 256,
    max_value: 128  // Limit to 50% max brightness
}

Parameters

name (required): The name of the const table to be generated
entry_type (required): The unsigned integer type for each entry (u8, u16, u32, u64)
gamma (required): The gamma value (positive float)
size (required): Number of table entries (minimum 3)
max_value (optional): Maximum output value to limit brightness (defaults to size-1)
decoding (optional): Use gamma correction/decoding instead of encoding (defaults to false)

Mathematics

Gamma Encoding (Default)

output = (input / max_input)^gamma * max_value

Gamma Correction/Decoding (`decoding: true`)

output = (input / max_input)^(1/gamma) * max_value

Performance

Since tables are generated at compile time, runtime performance is simply a single array lookup operation - O(1) with no floating-point computation needed.

Examples

Run the examples to see the macro in action:

cargo run --example basic_usage

Testing

Run the test suite:

cargo test

License

Licensed under either of

Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.

gamma-table-macros 0.1.0