mill_on_host()

MAYAFLUX_API Kakshya::VertexLayout MayaFlux::Portal::Graphics::mill_on_host	(	std::span< const uint8_t >	src,
		const Kakshya::VertexLayout &	layout,
		std::span< const DrawRun >	runs,
		const MillSpec &	spec,
		const MillView &	view,
		std::vector< uint8_t > &	dst
	)

Host equivalent of PrimitiveMill::mill, over raw bytes.

Parameters

src	Source vertex bytes. Must be four byte aligned.
layout	Describes src. The result carries the same attributes.
runs	Spans to mill, in output order.
spec	Shaping parameters, as for the device path.
view	Viewpoint, as for the device path.
dst	Resized to hold the result.

Returns

Layout describing dst, which is layout with a new vertex_count.

Exists so the kernel has an oracle: identical spans, spec and view must produce identical bytes on both paths. Secondarily a route for a caller with no compute queue available. Not a general geometry utility, and not intended for per-frame use at scale.

Definition at line 864 of file PrimitiveMill.cpp.

{
    auto result = layout;
    result.vertex_count = 0;
    dst.clear();
 
    MillOffsets off;
    if (!offsets_from(layout, off)) {
        return result;
    }
 
    std::vector<uint32_t> prefix;
    build_prefix(runs, prefix);
    const uint32_t total = prefix.empty() ? 0U : prefix.back();
    if (total == 0) {
        return result;
    }
 
    dst.assign(static_cast<size_t>(total) * layout.stride_bytes, 0);
    result.vertex_count = total;
 
    const HostRecords rec {
        .src = reinterpret_cast<const uint32_t*>(src.data()),
        .dst = reinterpret_cast<uint32_t*>(dst.data()),
        .stride_words = off.stride_words
    };
 
    const bool world_plane = spec.ribbon == MillSpec::Ribbon::WorldPlane;
    const uint32_t scalar_offset = spec.use_vertex_extent ? off.scalar : ABSENT;
 
    for (size_t r = 0; r < runs.size(); ++r) {
        const auto& run = runs[r];
        const uint32_t emitted = prefix[r + 1] - prefix[r];
        const uint32_t base = prefix[r];
        const uint32_t voff = run.vertex_offset;
 
        for (uint32_t local = 0; local < emitted; ++local) {
            const uint32_t out = base + local;
 
            if (run.topology == PrimitiveTopology::TRIANGLE_LIST) {
                rec.copy_vertex(out, voff + local);
                continue;
            }
 
            if (run.topology == PrimitiveTopology::TRIANGLE_STRIP
                || run.topology == PrimitiveTopology::TRIANGLE_FAN) {
                const uint32_t tri = local / 3U;
                const uint32_t c = local - tri * 3U;
                uint32_t a = 0;
                uint32_t b1 = tri + 1U;
                uint32_t b2 = tri + 2U;
                if (run.topology == PrimitiveTopology::TRIANGLE_STRIP) {
                    a = tri;
                    if ((tri & 1U) == 1U) {
                        std::swap(a, b1);
                    }
                }
                const uint32_t pick = c == 0U ? a : (c == 1U ? b1 : b2);
                rec.copy_vertex(out, voff + pick);
                continue;
            }
 
            const uint32_t corner = local % 6U;
            const uint32_t quad = local / 6U;
 
            if (run.topology == PrimitiveTopology::POINT_LIST) {
                const uint32_t s = voff + quad;
                const glm::vec3 p = rec.read_pos(s, off.position);
                const float h = rec.read_extent(s, scalar_offset, spec.fallback_extent)
                    * spec.point_scale * 0.5F;
 
                glm::vec3 rx;
                glm::vec3 ry;
                if (world_plane) {
                    rx = glm::vec3(h, 0.0F, 0.0F);
                    ry = glm::vec3(0.0F, h, 0.0F);
                } else {
                    const glm::vec3 n = host_view_normal(p, view.eye);
                    const glm::vec3 up = std::abs(n.y) < 0.99F
                        ? glm::vec3(0.0F, 1.0F, 0.0F)
                        : glm::vec3(1.0F, 0.0F, 0.0F);
                    rx = glm::normalize(glm::cross(up, n)) * h;
                    ry = glm::normalize(glm::cross(n, rx)) * h;
                }
 
                glm::vec3 o;
                glm::vec2 uv;
                switch (corner) {
                case 1:
                    o = rx - ry;
                    uv = { 1.0F, 0.0F };
                    break;
                case 2:
                case 4:
                    o = rx + ry;
                    uv = { 1.0F, 1.0F };
                    break;
                case 5:
                    o = -rx + ry;
                    uv = { 0.0F, 1.0F };
                    break;
                default:
                    o = -rx - ry;
                    uv = { 0.0F, 0.0F };
                    break;
                }
 
                rec.copy_vertex(out, s);
                rec.write_pos(out, off.position, p + o);
                if (spec.synthesize_uv) {
                    rec.write_uv(out, off.uv, uv);
                }
                continue;
            }
 
            const uint32_t s0 = run.topology == PrimitiveTopology::LINE_LIST
                ? voff + quad * 2U
                : voff + quad;
            const uint32_t s1 = s0 + 1U;
 
            const glm::vec3 p0 = rec.read_pos(s0, off.position);
            const glm::vec3 p1 = rec.read_pos(s1, off.position);
            const glm::vec3 d = p1 - p0;
 
            if (glm::length(d) < 1e-6F) {
                rec.write_pos(out, off.position, p0);
                continue;
            }
 
            const float h0 = rec.read_extent(s0, scalar_offset, spec.fallback_extent)
                * spec.width_scale * 0.5F;
            const float h1 = rec.read_extent(s1, scalar_offset, spec.fallback_extent)
                * spec.width_scale * 0.5F;
 
            const glm::vec3 e0 = host_side_at(
                p0, d, view.eye, h0, world_plane);
            const glm::vec3 e1 = host_side_at(
                p1, d, view.eye, h1, world_plane);
 
            glm::vec3 pos;
            uint32_t pick = s0;
            glm::vec2 uv;
            switch (corner) {
            case 1:
                pos = p0 + e0;
                uv = { 0.0F, 0.0F };
                break;
            case 2:
            case 4:
                pos = p1 + e1;
                pick = s1;
                uv = { 1.0F, 0.0F };
                break;
            case 5:
                pos = p1 - e1;
                pick = s1;
                uv = { 1.0F, 1.0F };
                break;
            default:
                pos = p0 - e0;
                uv = { 0.0F, 1.0F };
                break;
            }
 
            rec.copy_vertex(out, pick);
            rec.write_pos(out, off.position, pos);
            if (spec.synthesize_uv) {
                rec.write_uv(out, off.uv, uv);
            }
        }
    }
 
    return result;
}

References a, dst, MayaFlux::Portal::Graphics::MillView::eye, MayaFlux::Portal::Graphics::MillSpec::fallback_extent, h, LINE_LIST, out, POINT_LIST, MayaFlux::Portal::Graphics::MillSpec::point_scale, MayaFlux::Portal::Graphics::MillSpec::ribbon, run(), scalar_offset, src, MayaFlux::Kakshya::VertexLayout::stride_bytes, stride_words, MayaFlux::Portal::Graphics::MillSpec::synthesize_uv, total, TRIANGLE_FAN, TRIANGLE_LIST, TRIANGLE_STRIP, MayaFlux::Portal::Graphics::MillSpec::use_vertex_extent, uv, MayaFlux::Kakshya::VertexLayout::vertex_count, MayaFlux::Portal::Graphics::MillSpec::width_scale, and MayaFlux::Portal::Graphics::MillSpec::WorldPlane.

Here is the call graph for this function: