ludus::graphics::renderer::RenderGraph¶

Class

Renderer integration of one immutable cooked graph configuration. All calls use the RHI owner thread; Encode requires an acquired frame, metadata queries may inspect that encoding, and other operations are between frames. Device/surface must outlive this object. Setup/Update may allocate or create resources. Render performs no shader/pipeline creation and retains accepted resources through actual RHI completion. A failed/pending scene replacement preserves the last drawable scene. Resize/import changes require a separately initialized graph; no stale target is silently resized or reinterpreted. Ray passes retain bounded progressive history for the current drawable extraction; general raster history profiles are unsupported.

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

#include <ludus/graphics/renderer/render_graph.hpp>

class ludus::graphics::renderer::RenderGraph final

Members¶

internal::RenderGraphRayPass¶

friend class internal::RenderGraphRayPass

Allow the internal parity fixture to borrow completed pass history without a public readback API.

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

Methods¶

RenderGraph¶

ludus::graphics::renderer::RenderGraph::RenderGraph() noexcept

Construct an empty graph without GPU work.

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

~RenderGraph¶

ludus::graphics::renderer::RenderGraph::~RenderGraph() noexcept

Reset; see Reset's device/export lifetime preconditions.

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

RenderGraph¶

ludus::graphics::renderer::RenderGraph::RenderGraph(const RenderGraph &)=delete

Ownership is noncopyable.

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

operator=¶

RenderGraph & ludus::graphics::renderer::RenderGraph::operator=(const RenderGraph &)=delete

Ownership is nonassignable.

Related types: RenderGraph

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

Initialize¶

rhi::RasterStatus ludus::graphics::renderer::RenderGraph::Initialize(rhi::DeviceHandle device, const RenderGraphPlan &plan, const RenderGraphPrograms &programs, RenderGraphAttachmentPool *poolOrNull=nullptr, foundation::uint32 referenceWidth=0, foundation::uint32 referenceHeight=0, const LightTransformerModelDescription *modelOrNull=nullptr) noexcept

Copy/validate plan and cooked interfaces, prewarm all required contexts and allocate attachments. Ready/Pending owns setup. Failure of empty initialization leaves it empty; reinitialization rejects and preserves existing state. No open frame is permitted.

Parameter	Description
`device`	Ready owned device without an open frame; outlives this graph.
`plan`	Numeric plan; its records are copied before return.
`programs`	Cooked stages; artifact storage stays alive until Initialize/Poll reaches Ready.
`referenceWidth`	Drawable view width for relative resources; zero rejects unresolved relative sizes.
`referenceHeight`	Drawable view height, independent of any other graph instance.
`poolOrNull`	Optional RG4 attachment pool on the same device; transient backings are taken from it and returned on Reset. Null selects the serial control: every attachment is created here and destroyed on Reset. Both paths encode identical commands. An uninitialized pool, or one bound to a destroyed device, rejects with InvalidDescription. The pool must be bound to this device and outlive this graph.
`modelOrNull`	Required exactly for HasLightTransformer programs. Assets are copied; encoder artifact storage survives Poll. The model uses diffuse mesh-emitter inputs and fixed training scale; pending/failed scene encoding keeps the drawable generation.

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

Resize¶

rhi::RasterStatus ludus::graphics::renderer::RenderGraph::Resize(foundation::uint32 referenceWidth, foundation::uint32 referenceHeight) noexcept

Request new per-view drawable dimensions between frames, without shader/pipeline preparation. Fixed targets ignore the reference. Zero dimensions return NotReady and preserve any pending request. A new request supersedes an unactivated resize. Ready means unchanged; Pending requires Update with the current extraction (even at the same scene revision), then Poll. Attachments and scene publish together only when Ready. Failure preserves the drawable scene and output. Export/readback consumers must finish before this call and before Update/Poll may publish.

Related types: foundation::uint32 · rhi::RasterStatus

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

HasPendingResize¶

bool ludus::graphics::renderer::RenderGraph::HasPendingResize() const noexcept

Whether a resource replacement needs a fresh extraction or is preparing it.

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

GetResourceDescription¶

bool ludus::graphics::renderer::RenderGraph::GetResourceDescription(foundation::uint32 resource, content::render_graph_format::Resource &outResource) const noexcept

Copy a drawing resource's resolved dimensions and policy. False preserves outResource when uninitialized or the index is out of range; never reports a pending replacement.

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

GetPersistentBuffer¶

rhi::RasterStatus ludus::graphics::renderer::RenderGraph::GetPersistentBuffer(foundation::uint32 resource, rhi::BufferHandle &outBuffer, foundation::usize &outBytes) const noexcept

Borrow a stable persistent Buffer resource for an external prepared compute producer/consumer, using the same RHI device, graph hazards and submission ledger. The graph owns the allocation: never Destroy the returned handle. Reacquire after a pixel-buffer resize or graph replacement; retained bindings retire normally. Call between frames. Pending scene/resize work or an unfinished frame producer returns NotReady so callers cannot mutate the last drawable view's storage. A subsequent authored scene-compute pass consumes GPU results through its wired GraphBuffer slot. No readback, upload or ownership transfer occurs here. Model embedding buffers expose their actual prepared packet range, not the placeholder allocation in the source graph. Their contents are valid after the first completed Render.

Parameter	Description
`resource`	Numeric Buffer resource index in this graph's cooked plan.
`outBuffer`	Borrowed allocation, written only on Ready.
`outBytes`	Usable byte capacity, written only on Ready.

Returns

Ready; InvalidDescription for an invalid index; Unsupported for a texture; NotReady before preparation/while a replacement or GPU producer is outstanding.

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

GetAllocationReport¶

RenderGraphAllocationReport ludus::graphics::renderer::RenderGraph::GetAllocationReport() const noexcept

Copy attachment ownership counters; an empty graph reports zeros.

Related types: RenderGraphAllocationReport

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

Poll¶

rhi::RasterStatus ludus::graphics::renderer::RenderGraph::Poll() noexcept

Poll prewarming and pending replacement; publish only a complete Ready candidate. Returns a candidate failure once while preserving the prior drawable scene.

Related types: rhi::RasterStatus

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

Update¶

rhi::RasterStatus ludus::graphics::renderer::RenderGraph::Update(foundation::BorrowedView< const RenderGraphMesh > meshes, foundation::BorrowedView< const RenderGraphItem > items, foundation::BorrowedView< const ViewDescription > cameras, foundation::uint64 sceneRevision, RenderGraphCoveragePolicy policy, RenderGraphReport &outReport, const SceneShaderInputs *sceneInputsOrNull=nullptr, foundation::uint64 contentRevision=0, const RenderGraphSceneRevisions &revisions={}) noexcept

Copy current World extraction and all generation-local cameras. One full coverage scan precedes visibility culling. Pending/failed preparation preserves prior drawing. Rejection updates diagnostic report but preserves the current and pending scene. Source storage need only survive this call. Revision must be nonzero.

Parameter	Description
`meshes`	Borrowed static geometry table, copied during a full extraction.
`items`	Borrowed instances, transforms, material bindings and per-draw values.
`cameras`	Complete generation-local camera table; consumed before return.
`sceneRevision`	Nonzero identity for the requested drawable scene/view publication.
`policy`	Whether unsupported coverage rejects or receives diagnostic color.
`outReport`	Latest candidate diagnostics, independent of the retained drawable output. Preflight rejection preserves it; coverage/preparation results replace it.
`sceneInputsOrNull`	Optional borrowed material/light/environment inputs for a full extraction.
`contentRevision`	Optional nonzero identity for all non-camera inputs. Reusing it promises unchanged geometry, transforms, materials, lights, uniforms and coverage policy; only cameras and sceneRevision may change. This reuses scene/acceleration buffers and resets camera history. Mesh/item/shader inputs are ignored while reusing that identity; their original storage need not survive the original Update. Zero always prepares a complete extraction.
`revisions`	Optional domain revision promises. All-zero preserves contentRevision behavior. A fully nonzero record enables the same camera-only reuse when every domain and coverage policy match. Resize and new generations also prepare in full. At ray-history identity exhaustion, supplied geometry permits a full restart; camera-only inputs return IdentityExhausted and preserve the drawable view. A full Update with contentRevision zero can restart it.

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

GetCoverage¶

foundation::BorrowedView< const RenderGraphCoverageRecord > ludus::graphics::renderer::RenderGraph::GetCoverage() const noexcept

Borrow latest candidate coverage records until the next Update/Reset; no allocation.

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

GetReport¶

RenderGraphReport ludus::graphics::renderer::RenderGraph::GetReport() const noexcept

Copy the latest candidate report, independent of the drawable extraction.

Related types: RenderGraphReport

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

GetDrawableSceneRevision¶

foundation::uint64 ludus::graphics::renderer::RenderGraph::GetDrawableSceneRevision() const noexcept

Return the revision of the last Ready extraction, or zero when none exists.

Related types: foundation::uint64

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

HasPendingSamples¶

bool ludus::graphics::renderer::RenderGraph::HasPendingSamples() const noexcept

True when the last ray writer of any color target outputs individual samples or has an unfinished authored Accumulate sample limit. False for an empty/raster-only graph or when every final ray writer has reached its positive limit. Reservoir reuse does not average color. Accepted submissions count even while their producer is pending; finish producers and export consumers before rendering again. This owner-thread query never waits or submits. A published scene/camera/size replacement starts new progress; pending/failed candidates preserve the drawable scene's progress. Shader failures do not establish valid samples.

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

GetOutputSceneRevision¶

foundation::uint64 ludus::graphics::renderer::RenderGraph::GetOutputSceneRevision() const noexcept

Return the valid completed producer's scene revision, or zero while pending/invalid. This identifies exported pixels independently of candidate/drawable reports; platform presentation and external consumer completion remain caller-owned.

Related types: foundation::uint64

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

Render¶

rhi::RasterStatus ludus::graphics::renderer::RenderGraph::Render(rhi::SurfaceHandle surface, foundation::uint32 surfaceWidth, foundation::uint32 surfaceHeight, rhi::SubmissionToken &outCompletion) noexcept

Preflight caller-reported physical surface pixels, render the last Ready extraction in authored order, and publish actual producer completion. Null completion required. Before encoding, NotReady/resize/device rejection preserves the drawable scene and existing exports.

Parameter	Description
`surface`	Borrowed owned-device submission surface.
`outCompletion`	Empty token; receives accepted submission identity even on partial failure.
`surfaceWidth`	Current drawable width, supplied by the surface owner.
`surfaceHeight`	Current drawable height, supplied by the surface owner. Acquisition rechecks dimensions; a resize racing acquisition may clear/present the surface when ending that frame, but never publishes a new valid export. Partial accepted work may return a token even on failure; it never establishes image correctness.

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

PrepareEncoding¶

rhi::RasterStatus ludus::graphics::renderer::RenderGraph::PrepareEncoding() noexcept

Prepare per-frame ray dispatch graphs between frames, after the preceding producer completes. Render calls this automatically. Call before acquiring a frame when using Encode with ray passes; preparation allocates graph records but never shades or submits GPU commands. Pending/failed replacement scenes do not change the current drawable extraction.

Returns

Ready when encoding is prepared, NotReady for outstanding producer/setup work; allocation/device failures preserve drawable scene and existing output.

Related types: rhi::RasterStatus

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

Encode¶

rhi::RasterStatus ludus::graphics::renderer::RenderGraph::Encode(rhi::SurfaceHandle surface) noexcept

Encode into this device's already acquired frame without acquiring/presenting a surface. Setup is complete and no earlier producer/encoding may be pending. Ray passes require PrepareEncoding between frames before this call. After any attempted encoding, call ConfirmSubmission with the actual caller-owned EndFrame result, even after a partial failure. Update/Poll/Render reject until that submission is confirmed. No shader/pipeline creation. Camera surface extents use actual acquired pixels.

Related types: rhi::RasterStatus · rhi::SurfaceHandle

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

HasUnconfirmedEncoding¶

bool ludus::graphics::renderer::RenderGraph::HasUnconfirmedEncoding() const noexcept

Whether an Encode attempt still needs the caller's actual submission result. May be queried in the owned frame; this is not a GPU completion query.

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

ConfirmSubmission¶

rhi::RasterStatus ludus::graphics::renderer::RenderGraph::ConfirmSubmission(rhi::SubmissionToken completion) noexcept

Track the actual submission containing this Encode; call between frames.

Precondition

completion is the token returned by EndFrame for that encoding, not another frame. A null token reports failed/untracked submission and invalidates outputs. A foreign token rejects without clearing the pending encoding. Pending retains actual work, then GetExport polls completion. Surface presentation and consumer lifetime remain owned by the caller.

Related types: rhi::RasterStatus · rhi::SubmissionToken

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

GetExportAllocation¶

rhi::RasterStatus ludus::graphics::renderer::RenderGraph::GetExportAllocation(foundation::uint32 resource, rhi::TextureHandle &outTexture, rhi::TextureAspect &outAspect) const noexcept

Borrow a Ready exported allocation/aspect for immutable consumer preparation, without claiming initialized/completed pixels. Prepare sampled views/bindings before Encode; consumers draw only after the graph writes in the same frame or its producer completes. The graph owns the allocation; all uses finish before Reset. Outputs preserved on failure.

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

GetExport¶

rhi::RasterStatus ludus::graphics::renderer::RenderGraph::GetExport(foundation::uint32 resource, rhi::TextureHandle &outTexture, rhi::TextureAspect &outAspect) const noexcept

Borrow an exported allocation/aspect after producer completion. The graph owns it; callers must finish all consumers before the next Render or Reset. Outputs preserved on failure.

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

GetResourceAllocation¶

rhi::RasterStatus ludus::graphics::renderer::RenderGraph::GetResourceAllocation(foundation::uint32 resource, rhi::TextureHandle &outTexture, rhi::TextureAspect &outAspect) const noexcept

Borrow the allocation and aspect backing a logical texture that is not the presentation surface, after producer completion, for read-only diagnostic consumers such as a texture viewer. Persistent Buffer resources return Unsupported. Unlike GetExport this admits transient attachments. It reports what the backing allocation holds after the last completed frame: a backing shared by several logical resources (a depth resource always shares its colour resource's allocation) shows the last write, and a subresource discarded by its final pass is undefined (check it with rhi::GetTextureState before reading). Transient allocations may be pooled and reused by another graph after Reset, so callers must finish every use, including readbacks, before the next Render or Reset and must never write to the allocation.

Parameter	Description
`resource`	Logical resource index in the plan.
`outTexture`	Receives the borrowed backing allocation; unchanged on failure.
`outAspect`	Receives Color for colour resources and Depth for depth resources.

Returns

Ready after producer completion; NotReady while no completed output exists; InvalidDescription for an out-of-range resource; Unsupported for a resource backed by the presentation surface. Outputs are preserved on failure.

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

RequestRayPathCapture¶

rhi::RasterStatus ludus::graphics::renderer::RenderGraph::RequestRayPathCapture(const RayPathCaptureDescription &description) noexcept

Select the pixel and samples recorded by a graph initialized with RenderGraphPrograms::HasRayPathCapture. Call between frames after Initialize reaches Ready and before the first Update; each graph instance captures once. Allocates the capture buffer within the device's transfer budget and binds it into every ray pass prepared by later Updates. Run the capture in its own graph instance, so the live graph's drawable scene and output never change; render it from the frozen camera until the requested samples complete, then call PollRayPathCapture. See "Ray path inspection" in docs/architecture/render-graph-authoring.md.

Parameter	Description
`description`	Pixel, sample count and record capacity; copied before return.

Returns

Ready or Pending once the buffer is accepted; Unsupported when RayCompute is not the capture variant or two ray passes share one cooked callback set; InvalidState when uninitialized, not Ready, in a frame, already requested or after a scene was accepted; InvalidDescription for a sample count or record capacity outside its range; CapacityExceeded when the buffer exceeds TransferBytes. Failure leaves the graph unchanged.

Related types: rhi::RasterStatus · RayPathCaptureDescription

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

PollRayPathCapture¶

rhi::RasterStatus ludus::graphics::renderer::RenderGraph::PollRayPathCapture(RayPathCaptureReport &outReport) noexcept

Read back and decode the capture without waiting. The first call after the last producer completes starts a bounded readback and returns Pending; a later call returns Ready with the decoded events, sorted by pixel, sample, pass and sequence, and the per-invocation summaries. Calling again starts a new readback of the same buffer, so callers may poll while more samples render. Owner thread, between frames. Never changes drawable output.

Parameter	Description
`outReport`	Receives the decoded counters on Ready; unchanged otherwise.

Returns

Ready after decoding; Pending while the producer or readback is outstanding; InvalidState without a request or during an open/unconfirmed frame; a device or readback failure otherwise, which keeps the previously decoded capture.

Related types: rhi::RasterStatus · RayPathCaptureReport

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

SetAccumulationLimitOverride¶

rhi::RasterStatus ludus::graphics::renderer::RenderGraph::SetAccumulationLimitOverride(foundation::uint32 samples) noexcept

Replace every positive authored Accumulate sample limit with samples, for a graph instance that captures a frame rather than drawing the viewport. Passes that output individual samples keep doing so. Call between frames after Initialize reaches Ready and before the first Update; the override applies to every later scene of this instance. See docs/architecture/render-graph-frame-capture.md.

Parameter	Description
`samples`	New limit, from one to MAX_RENDER_GRAPH_CAPTURE_SAMPLES.

Returns

Ready when set; InvalidDescription for samples out of range; InvalidState when uninitialized, not Ready, in a frame or after a scene was accepted. Failure leaves the graph unchanged.

Related types: foundation::uint32 · rhi::RasterStatus

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

GetAccumulation¶

rhi::RasterStatus ludus::graphics::renderer::RenderGraph::GetAccumulation(foundation::uint32 pass, rhi::BufferHandle &outBuffer) const noexcept

Borrow the accumulation buffer of a ray pass after its producer completed, for a read-only consumer such as a frame capture's readback. The buffer holds RENDER_GRAPH_ACCUMULATION_WORDS float4 values per pixel of the pass's colour resource, in row-major order. The graph owns it; finish every use, including readbacks, before the next Render, Update or Reset, and never write to it. Ordinary accumulated callbacks store RGB sums; ResolveGraphRadiance callbacks store their latest resolved estimate times the invocation count. Divide either by the bit-preserved uint32 count in the first word's W to recover linear RGB.

Parameter	Description
`pass`	Plan pass index of a ray pass.
`outBuffer`	Receives the borrowed buffer; unchanged on failure.

Returns

Ready after producer completion; NotReady while no completed output exists; InvalidDescription for a pass that is not a ray pass. Outputs are preserved on failure.

Related types: foundation::uint32 · rhi::RasterStatus · rhi::BufferHandle

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

SetRayTileCount¶

rhi::RasterStatus ludus::graphics::renderer::RenderGraph::SetRayTileCount(foundation::uint32 tileCount) noexcept

Split every ray sample into tileCount row bands, rendering one band per Render, for a graph instance that captures a frame. Each band dispatches every ray pass over the same rows, with the pixel indices, sample streams and accumulation of an untiled sample, so only the submission boundaries change. HasPendingSamples and GetSubmittedRaySamples count a sample once its last band was submitted. Call between frames at a sample boundary; the count applies to later scenes of this instance too.

Parameter	Description
`tileCount`	Bands per sample, from one (whole-image dispatches) to MAX_RENDER_GRAPH_RAY_TILES.

Returns

Ready when set; InvalidDescription for a count out of range; Unsupported for more than one band when RenderGraphPrograms::HasRayTiles is false; InvalidState when uninitialized, not Ready, in a frame or between the bands of a sample. Failure leaves the graph unchanged.

Related types: foundation::uint32 · rhi::RasterStatus

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

GetSubmittedRaySamples¶

foundation::uint32 ludus::graphics::renderer::RenderGraph::GetSubmittedRaySamples() const noexcept

Ray samples submitted for every pixel of the drawable scene: whole frames, or complete rounds of bands after SetRayTileCount. Zero without a scene; a replaced scene or camera starts again from zero.

Related types: foundation::uint32

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

GetRayWorkload¶

rhi::RasterStatus ludus::graphics::renderer::RenderGraph::GetRayWorkload(RenderGraphRayWorkload &outWorkload) const noexcept

Describe the ray work of one sample of the drawable scene, for sizing tiles.

Parameter	Description
`outWorkload`	Receives the pixels and lights; unchanged on failure.

Returns

Ready; NotReady without a drawable scene or before its ray passes are prepared.

Related types: rhi::RasterStatus · RenderGraphRayWorkload

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

PollRayFailures¶

rhi::RasterStatus ludus::graphics::renderer::RenderGraph::PollRayFailures(foundation::uint32 pass, RenderGraphRayFailures &outFailures) noexcept

Read back, without waiting, how many pixels of a ray pass latched each failure reason (the graph's failure colour) since its camera or scene last changed. The first call requests a small read-back; a later call returns it, and the call after that requests a fresh one. Owner thread, between frames; never changes output.

Parameter	Description
`pass`	Plan pass index of a ray pass.
`outFailures`	Receives the counts on Ready; unchanged otherwise.

Returns

Ready with counts; Pending while the read-back or the producer is outstanding; NotReady without a drawable scene; Unsupported when the pass's kernel declares no failure summary (it was cooked before failure reasons; rebuild the graph); InvalidDescription for a pass that is not a ray pass; a read-back failure otherwise.

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

GetRayPathEvents¶

foundation::BorrowedView< const RayPathEvent > ludus::graphics::renderer::RenderGraph::GetRayPathEvents() const noexcept

Borrow the events of the last Ready PollRayPathCapture until the next poll, request or Reset.

Related types: foundation::BorrowedView · RayPathEvent

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

GetRayPathSummaries¶

foundation::BorrowedView< const RayPathSummary > ludus::graphics::renderer::RenderGraph::GetRayPathSummaries() const noexcept

Borrow the summaries of the last Ready PollRayPathCapture, sorted by pixel, sample and pass, until the next poll, request or Reset.

Related types: foundation::BorrowedView · RayPathSummary

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp

Reset¶

void ludus::graphics::renderer::RenderGraph::Reset() noexcept

Detach graph resources. Device stays alive, no open frame or foreign export consumer. GPU uses retire in RHI; does not wait or destroy another graph generation.

Declared in modules/graphics/renderer/include/ludus/graphics/renderer/render_graph.hpp