Loading...
Searching...
No Matches
MayaFlux::Nodes::GpuSync::GlyphGeometryNode Class Reference
GeometryWriterNode that emits glyph vector outlines as LINE_LIST geometry. More...
#include <GlyphGeometryNode.hpp>
Inheritance diagram for MayaFlux::Nodes::GpuSync::GlyphGeometryNode: Collaboration diagram for MayaFlux::Nodes::GpuSync::GlyphGeometryNode:Public Member Functions | |
| void | compute_frame () override |
| Upload cached vertex data if dirty. | |
| Portal::Graphics::PrimitiveTopology | get_primitive_topology () const override |
| Get primitive topology for rendering. | |
| GlyphGeometryNode (Portal::Text::FontFace &face, uint32_t pixel_size, std::string text, float pen_x=0.F, float pen_y=0.F, float tolerance=0.5F) | |
| Construct from a UTF-8 string with an explicit FontFace. | |
| GlyphGeometryNode (std::string text, float pen_x=0.F, float pen_y=0.F, float tolerance=0.5F) | |
| Construct from a UTF-8 string using the default font. | |
| const std::vector< Portal::Text::GlyphOutline > & | outlines () const |
| Access the per-glyph outline data produced by the last rebuild. | |
| const std::vector< glm::vec2 > & | pen_offsets () const |
| Pen-advance offsets for each glyph, in pixels. | |
| void | rebuild_outlines () |
| Rebuild outline geometry from the current text and pen settings. | |
| void | set_center (std::optional< glm::vec2 > center) |
Place the text block so its bounding box center falls on center. | |
| void | set_color (glm::vec3 color) |
| Set uniform color for all glyph contours. | |
| void | set_pen (float pen_x, float pen_y) |
| Set pen origin for layout. | |
| void | set_pen_offsets (std::vector< glm::vec2 > offsets) |
| Override pen offsets for all glyphs. | |
| void | set_text (std::string text) |
| Replace the text string and rebuild outlines. | |
| void | set_thickness (float thickness) |
| Set uniform line thickness for all glyph contours. | |
| ~GlyphGeometryNode () override=default | |
| Public Member Functions inherited from MayaFlux::Nodes::GpuSync::GeometryWriterNode | |
| void | clear () |
| Clear vertex buffer and reset count. | |
| void | clear_and_resize (uint32_t vertex_count) |
| Clear vertex buffer and resize to specified count. | |
| void | clear_gpu_update_flag () override |
| Clear the dirty flag after GPU upload completes. | |
| void | clear_layout_update_flag () |
| Clear layout update flag. | |
| GeometryWriterNode (uint32_t initial_capacity=1024) | |
| Constructor. | |
| uint32_t | get_index_count () const |
| Get number of indices in index buffer. | |
| std::span< const uint32_t > | get_index_data () const |
| Get raw index buffer data. | |
| NodeContext & | get_last_context () override |
| Retrieves the last created context object. | |
| std::span< const uint8_t > | get_vertex (uint32_t vertex_index) const |
| Get a single vertex by index. | |
| size_t | get_vertex_buffer_size_bytes () const |
| Get vertex buffer size in bytes. | |
| uint32_t | get_vertex_count () const |
| Get number of vertices. | |
| std::span< const uint8_t > | get_vertex_data () const |
| Get raw vertex buffer data. | |
| std::optional< Kakshya::VertexLayout > | get_vertex_layout () const |
| Get cached vertex layout. | |
| size_t | get_vertex_stride () const |
| Get stride (bytes per vertex) | |
| template<typename T > | |
| T | get_vertex_typed (uint32_t index) const |
| Get a single vertex by index as typed data. | |
| bool | has_indices () const |
| Check if index buffer has been set. | |
| void | mark_vertex_data_dirty (bool state) |
| Set vertex data dirty flag. | |
| bool | needs_gpu_update () const override |
| Check if vertex data or layout changed since last GPU sync. | |
| bool | needs_layout_update () const |
| Check if layout needs update. | |
| bool | needs_vertex_data_update () const |
| Check if vertex data has changed since last GPU sync. | |
| std::vector< double > | process_batch (unsigned int num_samples) override |
| Process batch for geometry generation. | |
| void | resize_vertex_buffer (uint32_t vertex_count, bool preserve_data=false) |
| Resize vertex buffer to hold specified number of vertices. | |
| void | restore_state () override |
| Restore saved geometry state. | |
| void | save_state () override |
| Save current geometry state. | |
| void | set_indices (std::span< const uint32_t > indices) |
| Set index buffer for indexed drawing. | |
| void | set_vertex (uint32_t vertex_index, const void *data, size_t size_bytes) |
| Set a single vertex by index. | |
| void | set_vertex_data (const void *data, size_t size_bytes) |
| Copy raw vertex data into buffer. | |
| void | set_vertex_layout (const Kakshya::VertexLayout &layout) |
| Set cached vertex layout. | |
| void | set_vertex_stride (size_t stride) |
| Set vertex stride (bytes per vertex) | |
| template<typename T > | |
| void | set_vertex_typed (uint32_t index, const T &vertex) |
| Set a single vertex by index from typed data. | |
| template<typename T > | |
| void | set_vertices (std::span< const T > vertices) |
| Set multiple vertices from typed array. | |
| void | update_context (double value) override |
| Updates the context object with the current node state. | |
| ~GeometryWriterNode () override=default | |
| Public Member Functions inherited from MayaFlux::Nodes::GpuSync::GpuSync | |
| std::vector< double > | process_batch (unsigned int num_samples) override |
| Batch processing for GPU nodes. | |
| double | process_sample (double) override |
| Single sample processing hook. | |
| ~GpuSync () override=default | |
| Public Member Functions inherited from MayaFlux::Nodes::Node | |
| void | add_buffer_reference () |
| Increments the buffer reference count This method is called when a new buffer starts using this node to ensure proper lifecycle management. | |
| uint64_t | get_active_snapshot_context () const |
| Get the active snapshot context ID. | |
| const std::atomic< uint32_t > & | get_channel_mask () const |
| Retrieves the current bitmask of active channels using this node. | |
| uint32_t | get_frame_rate () const |
| std::span< const float > | get_gpu_data_buffer () const |
| Provides access to the GPU data buffer. | |
| virtual double | get_last_output () |
| Retrieves the most recent output value produced by the node. | |
| std::vector< ModulatorTree > | get_modulator_tree () const |
| Returns the full modulator tree rooted at this node. | |
| virtual std::vector< std::pair< ModulatorRole, std::shared_ptr< Node > > > | get_modulators () const |
| Returns direct modulator nodes and their roles. | |
| RoutingState & | get_routing_state () |
| Retrieves the current routing state of the network (non-const) | |
| const RoutingState & | get_routing_state () const |
| Retrieves the current routing state of the network. | |
| uint32_t | get_sample_rate () const |
| bool | has_active_snapshot () const |
| Check if node is currently being snapshotted by any context. | |
| bool | has_capability (NodeCapability cap) const |
| Query a single capability. | |
| bool | is_buffer_processed () const |
| Checks if the buffer has been processed. | |
| bool | is_gpu_compatible () const |
| Checks if the node supports GPU processing. | |
| bool | is_in_network () const |
| Sets whether the node is part of a NodeNetwork. | |
| bool | is_in_snapshot_context (uint64_t context_id) const |
| Check if currently in a snapshot context. | |
| bool | is_used_by_channel (uint32_t channel_id) const |
| Checks if the node is currently used by a specific channel. | |
| bool | mark_buffer_processed () |
| Marks the node as having been processed by a buffer. | |
| bool | needs_channel_routing () const |
| Checks if the network is currently in a routing transition phase. | |
| virtual uint8_t | node_capabilities () const |
| Declare which data shapes this node's context can produce. | |
| virtual void | on_tick (const NodeHook &callback) |
| Registers a callback to be called on each tick. | |
| virtual void | on_tick_if (const NodeCondition &condition, const NodeHook &callback) |
| Registers a conditional callback. | |
| void | register_channel_usage (uint32_t channel_id) |
| Mark the specificed channel as a processor/user. | |
| void | release_snapshot_context (uint64_t context_id) |
| Release snapshot context. | |
| virtual void | remove_all_hooks () |
| Removes all registered callbacks. | |
| void | remove_buffer_reference () |
| Decrements the buffer reference count This method is called when a buffer stops using this node to ensure proper lifecycle management. | |
| virtual bool | remove_conditional_hook (const NodeCondition &callback) |
| Removes a previously registered conditional callback. | |
| virtual bool | remove_hook (const NodeHook &callback) |
| Removes a previously registered callback. | |
| void | request_buffer_reset () |
| Requests a reset of the buffer state. | |
| void | request_reset_from_channel (uint32_t channel_id) |
| Requests a reset of the processed state from a specific channel. | |
| virtual void | reset_processed_state () |
| Resets the processed state of the node and any attached input nodes. | |
| void | set_frame_rate (uint32_t frame_rate) |
| virtual void | set_gpu_compatible (bool compatible) |
| Sets whether the node is compatible with GPU processing. | |
| void | set_in_network (bool networked) |
| Marks the node as being part of a NodeNetwork. | |
| void | set_sample_rate (uint32_t sample_rate) |
| bool | try_claim_snapshot_context (uint64_t context_id) |
| Attempt to claim snapshot context for this processing cycle. | |
| void | unregister_channel_usage (uint32_t channel_id) |
| Removes the specified channel from the usage tracking. | |
| virtual | ~Node ()=default |
| Virtual destructor for proper cleanup of derived classes. | |
Private Member Functions | |
| void | write_vertices () |
Private Attributes | |
| std::optional< glm::vec2 > | m_center |
| glm::vec3 | m_color { 1.F, 1.F, 1.F } |
| bool | m_dirty {} |
| Portal::Text::FontFace * | m_face {} |
| float | m_line_height {} |
| std::vector< Portal::Text::GlyphOutline > | m_outlines |
| std::vector< glm::vec2 > | m_pen_offsets |
| float | m_pen_x {} |
| float | m_pen_y {} |
| uint32_t | m_pixel_size {} |
| std::string | m_text |
| float | m_thickness { 1.F } |
| float | m_tolerance { 0.5F } |
| float | m_total_advance {} |
Additional Inherited Members | |
| Public Attributes inherited from MayaFlux::Nodes::Node | |
| bool | m_fire_events_during_snapshot = false |
| Internal flag controlling whether notify_tick fires during state snapshots Default: false (events don't fire during isolated buffer processing) Can be exposed in future if needed via concrete implementation in parent. | |
| std::atomic< uint32_t > | m_modulator_count { 0 } |
| Counter tracking how many other nodes are using this node as a modulator. | |
| std::atomic< NodeState > | m_state { NodeState::INACTIVE } |
| Atomic state flag tracking the node's processing status. | |
| Protected Member Functions inherited from MayaFlux::Nodes::GpuSync::GpuSync | |
| void | notify_tick (double) override |
| GPU sync nodes don't emit tick callbacks. | |
| Protected Member Functions inherited from MayaFlux::Nodes::Node | |
| virtual void | reset_processed_state_internal () |
| Resets the processed state of the node directly. | |
| Protected Attributes inherited from MayaFlux::Nodes::GpuSync::GeometryWriterNode | |
| GeometryContext | m_context { 0.0, {}, 0, 0 } |
| std::vector< uint32_t > | m_index_buffer |
| Optional index buffer for indexed drawing (not used by default) | |
| bool | m_needs_layout_update {} |
| Flag indicating if layout needs update. | |
| std::vector< uint8_t > | m_vertex_buffer |
| Vertex data buffer (flat array of bytes) | |
| uint32_t | m_vertex_count {} |
| Number of vertices in buffer. | |
| bool | m_vertex_data_dirty { true } |
| Flag: vertex data or layout changed since last GPU upload. | |
| std::optional< Kakshya::VertexLayout > | m_vertex_layout |
| Cached vertex layout for descriptor binding. | |
| size_t | m_vertex_stride {} |
| Bytes per vertex (stride for vertex buffer binding) | |
| Protected Attributes inherited from MayaFlux::Nodes::Node | |
| std::vector< NodeHook > | m_callbacks |
| Collection of standard callback functions. | |
| std::vector< std::pair< NodeHook, NodeCondition > > | m_conditional_callbacks |
| Collection of conditional callback functions with their predicates. | |
| uint32_t | m_frame_rate { 60 } |
| Frame rate for time-based processing, used for normalization. | |
| bool | m_gpu_compatible {} |
| Flag indicating if the node supports GPU processing This flag is set by derived classes to indicate whether the node can be processed on the GPU. | |
| std::vector< float > | m_gpu_data_buffer |
| GPU data buffer for context objects. | |
| double | m_last_output { 0 } |
| The most recent sample value generated by this oscillator. | |
| bool | m_networked_node {} |
| Flag indicating if the node is part of a NodeNetwork This flag is used to disable event firing when the node is managed within a NodeNetwork, preventing redundant or conflicting event notifications. | |
| uint8_t | m_node_capability { NodeCapability::SCALAR } |
| Bitmask of capabilities declared by this node. | |
| uint32_t | m_sample_rate { 48000 } |
| Sample rate for audio processing, used for normalization. | |
| bool | m_state_saved {} |
| tracks if the node's state has been saved by a snapshot operation | |
| uint32_t | m_timing_rate { m_sample_rate } |
| Current timing rate for the node, used for timing calculations (can be sample rate or frame rate) | |
Detailed Description
GeometryWriterNode that emits glyph vector outlines as LINE_LIST geometry.
Decomposes a UTF-8 string into per-glyph polyline outlines via Portal::Text::decompose_glyph(), lays them out using the same pen-advance model as lay_out(), and writes all contours as LINE_LIST vertex pairs into the inherited vertex buffer.
Each contour segment becomes two LineVertex entries (one per endpoint), carrying the per-glyph color and thickness set on this node. The caller drives per-character transforms by subclassing and overriding compute_frame(), or by mutating the outline data between calls to rebuild_outlines().
The outline geometry is static after set_text() / rebuild_outlines() until either is called again. compute_frame() is a no-op unless m_dirty is set, so this node is RT-safe to tick at VISUAL_RATE once built.
Coordinate space: pixel-space with Y downward, pen origin at (pen_x, pen_y). Matches GlyphQuad convention. The caller applies NDC transform via the view transform on the buffer's RenderProcessor.
Usage:
auto node = std::make_shared<GlyphGeometryNode>("hello");
node->set_color({ 1.0F, 1.0F, 1.0F });
node->set_thickness(1.5F);
buf->setup_rendering({
.target_window = window,
.topology = Portal::Graphics::PrimitiveTopology::LINE_LIST,
});
auto GeometryBuffer(Args &&... args) -> std::shared_ptr< MayaFlux::Buffers::GeometryBuffer >
Definition Creator.hpp:139
bool set_default_font(std::string_view family, std::string_view style, uint32_t pixel_size, uint32_t atlas_size)
Locate a system font by family and style, then load it as the default.
Definition Text.cpp:82
Definition at line 50 of file GlyphGeometryNode.hpp.
The documentation for this class was generated from the following files:
