Poly3D QML Type

The fill color of the polygon.

Defaults to the Clayground teal, #0f9d9a.

Which side of the polygon is drawn.

A flat polygon is a single-sided surface: with the default Material.BackFaceCulling it disappears when seen from behind, which is what a ground plane wants. Set Material.NoCulling for one meant to be read from both sides - the lighting then still uses the front normal.

An extruded one is a closed solid with every face turned outwards, so the default is what it wants and Material.NoCulling only costs the fragments of the far side.

The edge color, as an absolute color rather than a factor.

Wins over edgeColorFactor as soon as it has a visible alpha, which is what counts as set here - a fully transparent edge has no meaning, so it serves as the unset sentinel and leaves opaque black reachable.

On a light fill this is the difference between edges that read and edges that barely exist: edgeColorFactor can only ever darken the fill towards black by a fraction of itself.

Darkening factor for edges (0-1).

Lower values give darker edges. Ignored once edgeColor is set. Defaults to 0.4.

Which lines showEdges draws.

Switching between the two costs nothing - both read the same channel.

Poly3D {
    vertices: ring
    showEdges: true
    edgeMode: Poly3D.Triangles
    edgeColor: "#2f3437"
}

Thickness of the edge lines, in pixels.

Screen-space, so a line keeps its weight as the camera moves or the polygon tilts away. The same unit Box3D::edgeThickness and VoxelMap::edgeThickness use. Defaults to 1.0.

A line every surface on either side of it draws is laid down at half width from each, so it comes out at edgeThickness either way. A rim with nothing on the other side is drawn at full width for the same reason - which is why a flat polygon's outline, an extruded one's face borders and a Box3D border all read the same.

How far the polygon rises along its plane normal.

0, the default, is the flat area. Anything above it turns the same ring into a prism: the ring is the base, side walls rise along the plane normal and a cap closes the top. Holes are extruded too, so a ring with a courtyard becomes a building with a courtyard rather than a solid block.

Direction and origin follow Box3D: the ring sits at the node's own origin plane and the solid grows from there - +Y for Poly3D.XZ, +Z for Poly3D.XY, +X for Poly3D.YZ.

Side walls are faceted, not smoothed: each wall carries its own normal, so a hexagonal column reads as six flat faces rather than as a cylinder, which is what useToonShading wants.

Changing extrude rebuilds the mesh. To animate the height, scale the node along the extrusion axis instead - the geometry is untouched, and because the edge lines are measured in screen space they keep their weight while it moves:

Poly3D {
    vertices: footprint
    extrude: 100
    showEdges: true
    NumberAnimation on scale.y {
        from: 0.2; to: 1.0; duration: 1200; loops: Animation.Infinite
    }
}

See also plane.

Inner rings cut out of the polygon.

Each entry is a ring in the same format as vertices. A hole that encloses no area is ignored with a warning; holes that stray outside the outer ring or overlap each other are not repaired.

Defaults to an empty list.

Which world plane the 2D points map to.

Anything not axis-aligned is the node's own eulerRotation.

See also Poly3DGeometry::plane.

Whether the polygon draws its own edges.

Defaults to false, unlike Box3D, where it defaults to true: a box's borders are its look, while a polygon's edges are a deliberate choice - an area on the ground usually wants to be an area, not a diagram of one.

The mesh a polygon needs in order to draw edges is wider than the one it needs to be filled, so setting this true for the first time rebuilds it. That wider mesh is then kept, which is what makes showEdges: hoverHandler.hovered a reasonable thing to write: one rebuild for the object's lifetime, and a uniform write per toggle after that.

See also edgeMode.

How far the polygon is lifted off its own plane.

A lift, not a depth trick: it slides the geometry along the plane normal - +Y for Poly3D.XZ, +Z for Poly3D.XY, +X for Poly3D.YZ - by surfaceOffset units. Negative values push it the other way, under whatever it shares the plane with.

This is the answer to z-fighting with a coplanar surface, and the only one that works; depthBias is not, for the reason given above. Something on the order of a thousandth of the scene's extent is enough - 0.5 in a world measured in hundreds of units.

It leaves the node's own position alone, which is the point of doing it here rather than by moving the node: position stays free for placing the polygon, and for animating it without touching the mesh.

0, the default, is not a translation of zero but no translation at all - the mesh comes out of the builder exactly as it did before the property existed.

extrude is measured from the ring's own plane, not from the offset one, so lifting a prism moves it rather than making it taller or shorter. Changing surfaceOffset rebuilds the mesh, as extrude does; to animate a polygon's height off the ground, animate the node's position instead.

Poly3D {
    vertices: lakeRing
    color: "#00d9ff"
    surfaceOffset: 0.5   // above the ground it would otherwise fight
}

See also plane and extrude.

Enables cartoon-style rendering.

The same knob Box3D has, running the same half-lambert lighting, so a Poly3D ground and the Box3D objects on it match. Defaults to false.

The outer ring of the polygon, in plane coordinates.

Qt.vector2d(u, v) is the canonical spelling; a plain {x, y} object, Qt.point() and a two-element [u, v] array are accepted too, because a point that has been through JSON or a spread arrives as one of those.

The ring closes implicitly - a repeated last point is dropped - and is wound the right way round automatically.

Defaults to an empty list, which draws nothing.