fill3 — Create MATLAB-compatible filled polygon patches in 3-D space.

fill3 creates filled polygon graphics objects from X, Y, and Z coordinate data. RunMat implements it as a thin wrapper over the shared patch machinery, so returned handles are patch graphics handles and common patch name-value properties apply.

How fill3 works

• fill3(X, Y, Z, C) creates one or more 3-D filled polygons from matching coordinate arrays.
• Vector coordinate inputs create one polygon.
• Matrix coordinate inputs create one polygon per column through the underlying patch parser.
• Multiple X,Y,Z,C groups in one call create multiple patch objects and return a row vector of patch handles.
• A single polygon group returns a scalar patch handle.
• fill3 initializes the target axes with the standard 3-D view, so even polygons in the z=0 plane render as 3-D patch content.
• Trailing patch property name-value pairs are applied to every polygon group in the call.
• The returned patch handles work with get, set, ishandle, and isgraphics.
• Color strings and RGB triples are supported through the shared patch color parser.
• Indexed or interpolated CData behavior is currently limited by the underlying patch implementation; concrete color strings, RGB triples, and common patch properties are the supported color path.

Options

• FaceColor accepts color names, RGB triples, flat, or none through patch.
• EdgeColor accepts color names, RGB triples, or none.
• FaceAlpha and EdgeAlpha accept numeric values from 0 to 1.
• LineWidth, DisplayName, and Visible use the shared plotting property model.
• Explicit axes handles are accepted as the leading argument, matching other RunMat plotting builtins.

How RunMat runs fill3 on the GPU

fill3 shares patch rendering behavior, so host and gathered-GPU coordinate inputs produce the same patch objects and graphics handles.

Rendered geometry flows through the shared GPU plotting renderer after the patch objects are built.

A future direct GPU path should preserve the same X,Y,Z,C grouping and patch property semantics while replacing only the coordinate gathering and geometry packing stage.

GPU memory and residency

fill3 is a plotting sink and fusion barrier. GPU-resident coordinate inputs are gathered before patch construction because MATLAB-compatible parsing requires shape validation and polygon assembly.

Examples

Create a red square in the z=0 plane

x = [0 1 1 0];
y = [0 0 1 1];
z = [0 0 0 0];
h = fill3(x, y, z, 'r');
get(h, 'Type')

Expected output:

ans =
    'patch'

Create two filled polygons in one call

x1 = [0 1 0];
y1 = [0 0 1];
z1 = [0 0 0];
x2 = [2 3 3 2];
y2 = [0 0 1 1];
z2 = [1 1 1 1];
h = fill3(x1, y1, z1, 'g', x2, y2, z2, [0 0 1]);

Apply patch properties to a fill3 polygon

x = [0 1 0];
y = [0 0 1];
z = [0.25 0.5 0.75];
h = fill3(x, y, z, [0.25 0.5 0.75], 'EdgeColor', 'none', 'FaceAlpha', 0.5);

Create one patch per matrix column

X = [0 2; 1 3; 1 3; 0 2];
Y = [0 0; 0 0; 1 1; 1 1];
Z = [0 1; 0 1; 0 1; 0 1];
fill3(X, Y, Z, 'cyan');
view(3);

FAQ

Related Plotting functions

More plotting resources

• Graphics Handles
• Plot replay and export

Open-source implementation

Unlike proprietary runtimes, every RunMat function is open-source. Read exactly how fill3 works, line by line, in Rust.

• View fill3.rs on GitHub
• Learn how the runtime works
• Found a bug? Open an issue with a minimal reproduction.

About RunMat

RunMat is an open-source runtime that executes MATLAB-syntax code — faster, on any GPU, with no license required.

• Simulations that took hours now take minutes. RunMat automatically optimizes your math for GPU execution on Apple, Nvidia, and AMD hardware. No code changes needed.
• Start running code in seconds. Open the browser sandbox or download a single binary. No license server, no IT ticket, no setup.
• A full development environment. GPU-accelerated 2D and 3D plotting, automatic versioning on every save, and a browser IDE you can share with a link.

Getting started · Benchmarks · Pricing