drawable_canvas()

MAYAFLUX_API Form< std::vector< float > > MayaFlux::Portal::Forma::Geometry::drawable_canvas	(	Kinesis::AABB2D	bounds,
		glm::vec3	color = glm::vec3(0.8F),
		float	thickness = 1.5F,
		const std::function< glm::vec2()> &	live_offset = {},
		size_t	samples = 0
	)

Geometry function for a drawable curve canvas in NDC space.

Renders the sample vector as a LINE_LIST polyline. Each adjacent sample pair becomes one segment. The hit region covers the full canvas bounds.

Parameters

bounds	Canvas extent in NDC.
color	Line color.
thickness	LineVertex thickness value.
live_offset	Optional. Current translation of the drawn canvas - geometry only. paint_over()/wire_canvas_drag() do their own inline cursor math, not routed through Kinesis::Projection, and are not offset-aware here.
samples	Sample count the canvas will hold. Sizes the buffer so the first draw does not reallocate. Zero keeps the default capacity.

Definition at line 386 of file FormFactory.cpp.

{
    GeometryFn<std::vector<float>> fn = [bounds, color, thickness, live_offset](
                                            const std::vector<float>& v, std::vector<uint8_t>& out, Element& el) {
        const glm::vec2 shift = live_offset ? live_offset() : glm::vec2(0.F);
        const Kinesis::AABB2D live = bounds.translated(shift);
 
        if (v.size() < 2) {
            out.clear();
            el.bounds_hint = live;
            el.contains = Kinesis::polygon_bounds(std::span<const glm::vec2> {
                std::array<glm::vec2, 4> {
                    live.min,
                    glm::vec2(live.max.x, live.min.y),
                    live.max,
                    glm::vec2(live.min.x, live.max.y) } });
            return;
        }
 
        const auto n = v.size();
        const float x_step = live.width() / static_cast<float>(n - 1);
 
        std::vector<Kakshya::LineVertex> verts;
        verts.reserve((n - 1) * 2);
 
        for (size_t i = 0; i + 1 < n; ++i) {
            const float xa = live.min.x + static_cast<float>(i) * x_step;
            const float xb = live.min.x + static_cast<float>(i + 1) * x_step;
            const float ya = live.min.y + std::clamp(v[i], 0.F, 1.F) * live.height();
            const float yb = live.min.y + std::clamp(v[i + 1], 0.F, 1.F) * live.height();
 
            verts.push_back({ .position = { xa, ya, 0.F }, .color = color, .thickness = thickness });
            verts.push_back({ .position = { xb, yb, 0.F }, .color = color, .thickness = thickness });
        }
 
        write_verts(out, verts);
 
        el.bounds_hint = live;
        el.contains = Kinesis::polygon_bounds(std::span<const glm::vec2> {
            std::array<glm::vec2, 4> {
                live.min,
                glm::vec2(live.max.x, live.min.y),
                live.max,
                glm::vec2(live.min.x, live.max.y) } });
    };
 
    Form<std::vector<float>> form { std::move(fn) };
    form.topology = Graphics::PrimitiveTopology::LINE_LIST;
    if (samples > 1)
        form.capacity = (samples - 1) * 2 * sizeof(Kakshya::LineVertex);
    form.wire = paint_over(bounds);
    return form;
}

References color, MayaFlux::Kinesis::AABB2D::contains(), MayaFlux::Kinesis::AABB2D::height(), MayaFlux::Portal::Graphics::LINE_LIST, MayaFlux::Kinesis::AABB2D::max, MayaFlux::Kinesis::AABB2D::min, out, paint_over(), MayaFlux::Kinesis::polygon_bounds(), MayaFlux::Portal::Forma::Geometry::Form< T >::topology, MayaFlux::Kinesis::AABB2D::translated(), MayaFlux::Kinesis::AABB2D::width(), and write_verts().

Here is the call graph for this function: