Malt Rendering Framework

Malt is a real-time rendering framework designed for animation and illustration, specifically optimized for stylized non-photorealistic rendering (NPR).

Key capabilities include:

• Blender Integration: Complete integration within the Blender ecosystem.
• Code-Centric Workflow:
  • Automatic reloading of code.
  • VSCode integration with GLSL autocompletion.
  • Automatic generation of nodes from GLSL functions.
  • Automatic UI generation for Shader and Pipeline parameters.
  • 100% customizable Python Render Pipelines.

Malt is a fully customizable real-time rendering framework designed for animation and illustration. It is specifically optimized for stylized non-photorealistic rendering (NPR) and provides a workflow similar to 'Shadertoy' but integrated directly within Blender.

Key capabilities include:

• Stylized NPR Pipeline: Includes built-in support for stylized shading models, light groups, and line rendering.
• Node-Based Customization: Users can customize materials, light shaders, screen shaders, and the render pipeline itself using nodes.
• Code-Centric Workflow: Supports auto-reloading for code, VSCode integration (with GLSL intellisense), and Renderdoc integration.
• Extensibility: Allows for automatic generation of nodes from plain GLSL functions and provides 100% customizable Python render pipelines.

The Render Library provides pipeline-agnostic rendering utilities that require logic beyond pure GLSL. It contains a variety of tools ranging from simple data structures to complex lighting systems.

Key components include:

• Uniform Buffer Objects: Managed via Common.py.
• Python Utilities: Such as Sampling.py for pure Python-based logic.
• Lighting and Shadowmaps: Complex features implemented in Lighting.py.

Note that Render modules do not follow a single strict API; while similar features often share similar interfaces, each module is free to implement the interface most appropriate for its specific requirements.

Decide between Malt and BEER based on your target workflow and technical requirements:

• Choose Malt if: You are an advanced user who prefers a workflow combining Code & Nodes and requires an OpenGL backend. It is optimized for animation and illustration, prioritizing flexibility and image quality.
• Choose BEER if: You want a tool accessible to everyone using a Layers/Stacks workflow.

The MaltRenderEngine.py module implements the standard Blender RenderEngine interface. It automates the following workflow:

1. Generates a Malt Scene from the Blender DepsGraph.
2. Sends the scene to the Bridge for rendering.
3. Passes the resulting render back to Blender.

BlenderMalt provides optimized synchronization for geometry and image data:

• Meshes: MaltMeshes.py retrieves Blender geometry as vertex and index buffers to send to the Bridge. It is optimized for real-time editing and can retrieve vertex data directly from Blender's internal C data using the CBlenderMalt library.
• Textures: MaltTextures.py handles the transmission of 1D and 2D texture pixel data to the Bridge.

Malt allows you to customize render pipelines using plugins. Plugins can extend the system in three ways:

1. Add new node libraries to Pipeline Graphs.
2. Add new Pipeline Parameters.
3. Add new PipelineGraph types.

Plugins can be installed either globally via the Addon Settings or specifically for a single world via the World Panel.

Variables in GLSL are declared with a type, a name, and an optional value. Common types used in Malt include:

• float: Single-precision floating-point numbers (e.g., 1.0, -0.5).
• vec2, vec3, vec4: Vectors containing 2, 3, or 4 floats. Used for positions (vec3), UVs (vec2), and colors (vec3 or vec4).

Accessing Vector Components: You can access individual components using dot notation. For colors, you can use .r, .g, .b, .a. For spatial coordinates, you can use .x, .y, .z, .w. These are interchangeable (e.g., .x is the same as .r).

float x_pos = position_3d.x;
float red_channel = color.r;
// Swizzling: selecting multiple components
vec2 uv = position_3d.xy;
vec3 rgb = semi_transparent_red.rgb;

Functions are blocks of code that perform tasks and return values. They are similar to nodes in a node-based editor.

• Return Values: Declare the return type before the function name. Use the return keyword to output a value.
• Void Functions: If a function returns nothing, use the void type.
• Input Parameters: Defined inside parentheses with their types.
• Output Parameters (inout): Use the inout keyword to allow a function to modify a variable passed to it.

// Function with return value
float add(float a, float b) {
    return a + b;
}

// Function with output parameter
void get_colors(inout vec3 color1, inout vec3 color2) {
    color1 = vec3(1,0,0);
    color2 = vec3(0,1,0);
}