kinogaki-network

What it is

Depends on

For its tests alone

Third-party

Used by

Modules

• animated (private)Animated nodes' parameters at a time.87 lines
• arrangeLaying a network level out top to bottom on the grow grid (Layout), for scene code building networks and for a command to tidy one:102 lines
• assetAssets: a subnet saved as a reusable definition, Houdini's digital asset, the same for every network kind.426 lines
• boundaries (private)A subnet's body edited as a level of its own, and its boundaries: the Input and Output frames that are its ports, renumbered without gaps after every edit inside it, the subnet's wires following them.116 lines
• budgetThe node-cache memory budget: one ceiling over what the scene cook's caches keep (every object's NetCache, with the caches of the walked networks its holders keep), measured by the values' own sizes.414 lines
• check (private)The checks of core nodes and networks beyond those every network passes (Network::validate): types installed and offered in the network's context, a value of each parameter's kind, no choice its type doesn't declare, the type's ...179 lines
• collapseCollapse and Extract: a selection on one level becomes a subnet, and a subnet's contents come back out.353 lines
• compiledCompiled: a core network's topology up to its targets, as the walker cooks it: built once per topology revision, read on every cook without allocating.457 lines
• cookedWhat an object's cook left of its nodes, read through the SDK: each node's outputs as last cooked with the stamp it cooked at (Cooked, taken from the walk's cache and shared with it, never copied), and a core network read with them (CookedNetwork), so ...262 lines
• core (private)CoreNetwork: a network of core's one node shape (Node), of one context (NetworkContext), as an object holds it.544 lines
• edit (private)A core network as the SDK reads and edits it (NetworkRead, NetworkEdit): the host lends a copy of an object's network to a package's edit (LentNetwork, which knows the document's unit and the host's grid) and commits it as one undo step.234 lines
• flattenThe network as cooks read it: every node of every body in one network, each wire resolved through the boundaries to the node it reads.195 lines
• formatsFormats: the file formats installed packages registered (the registry keeps one, registry::formats), and the one place Import, Export and File nodes look a reader or a writer up: by what it reads into (data types), then by a ...231 lines
• framesFrames: what every context's network holds beside its own nodes.143 lines
• growHow a network grows from the viewport and Tab: one rule for every context that has a Merge:244 lines
• held_edits (private)A core network's held and kept results: held nodes' deltas set, rebased, cleared and captured again; nodes frozen with their outputs; Stashes keeping a value.174 lines
• keys (private)A core network's animated parameters: keys set and removed on a row, a row's channel cleared, and parameter edits at a time (an animated row's edit is its key there).110 lines
• namesWhat nodes may be named: a name is one step of a node path, so name_problem says why one can't be, and next_free numbers a copy as Houdini does (FreeNames for many names in one place).140 lines
• net_cache (private)NetCache: one network's cooking state, kept across walks: its compiled topologies, the node cache of its cooks and one NodeState per node, which a walk reads and writes by the node's order slot.504 lines
• network (private)Network: one context's network of core Nodes (nodes with identities, names, positions and input wires, frames and a display flag) and the edits and checks that do not depend on what the nodes compute: adding with fresh identities and names, pasting ...617 lines
• nodeNode: core's one node shape, the same in every context whose networks are core's (CoreNetwork).755 lines
• node_path (private)NodePath: a node of an object's networks, by the holders from the object's own network down to the network it is in, then the node.186 lines
• operandBranch picks on any network (one rule in every context): while a tool's node is live, a templated branch picked in the viewport wires into the node's operand input (a Boolean's Tools), and picked again with ⌘ comes off.91 lines
• passes (private)A loop: a holder cooking the network it holds once per pass (Reads::passes), on core's one walker.256 lines
• paste (private)Pasting and duplicating items on a level: copies with new identities (a subnet's body renumbered through and through), named as nothing there is, their wires among them kept and the others cut.155 lines
• plansCompiled contexts' plans: a network of a context declared Evaluation::Compile (Comp) isn't walked.376 lines
• portsWhat a wire may join, the same in every context: an output into an input with a data type in common (fits, the one rule the network view's drag, a branch pick and the network's checks all read).30 lines
• projectProjectCx: the project a scene's nodes cook in, owned by the request, with a stamp of its content.287 lines
• promoteA subnet's parameter interface, the same for every network kind: parameters promoted from the nodes inside, Houdini's promoted parms.479 lines
• reachWhat a wire carries and what a port takes, through subnets and their boundaries, read from the nodes' ports: the check of a wire against an input every context's network view makes while a wire is dragged (Network::accepts), by the one rule ...45 lines
• readingWhat a node of a core network reads, as every evaluation sees it: the walker (crate::walk) and a compiled context's flattening alike.86 lines
• registryWhat core networks need of the installed packages: their network contexts, the node types those networks hold, the held edits a held node applies and the data types their wires, deltas and kept outputs are values of.466 lines
• revision (private)Revision: the number of a network's topology, which compiled topologies and plans are kept by.18 lines
• seed (private)A NetworkSeed made in a network: what an engine's preset starts a Material with and what an object adopting an imported value starts its network as.118 lines
• slots (private)A walk's per-node code, shared by a cook (crate::cook) and a stamp-only pass (stamps): each node's stamp and what it was made from (its memo, its external stamp as last looked, what its path rows resolved to), a holder's inside cooked or stamped, and ...575 lines
• stackingA level's stacking: the order its items are drawn in, back to front, where they overlap in the network view.84 lines
• stampStamps: what made a node's result, as one hash, made here and only by the walker (crate::walk): a cook (crate::cook) and a stamp-only pass (crate::stamps) run the same code per node, so a stamp means the same wherever it is read, and it is the one ...321 lines
• stashThe Stash node (kinogaki.core.stash): a value kept in a network, like Houdini's Stash SOP.61 lines
• validate (private)The checks every network passes (Network::validate), and the same checks of a network edited from one that passed them (Network::validate_local), which read only what the edit changed.290 lines
• verbatimVerbatim: part of a project file that no installed package reads, kept as it was read and written back unchanged (a node of a type whose plugin is missing, an object of a kind no package declares, a stored value of a package that isn't installed).335 lines
• walkThe walker: cooks a core network up to its targets on core's cooking engine (kinogaki_cook), node by node in its compiled order.576 lines
• wiringWiring a level: connecting into an input (in place of its wire, or at a place among a multi-input's), disconnecting, reordering a multi-input's wires and moving a wire, with cycles refused.156 lines

Public types and traits

At the crate root

Traits Resolve

Structs AddCxAssetInfoAssetLinkBindingCompiledCoreNetworkDefinitionFailedFormatsFrameGrownHeldNodeKeptLayoutLentNetworkNetCacheNetworkNodeNodeIdNodePathNodeViewObjectIdOpenFailedOutWireParameterPlaceholderRevisionRunPassStackingSubnetUnresolvedVerbatimWalkCxWalked

Enums AssetRoleFrameRoleItemRefResolutionRunWireEdit

Besides these, 62 public functions at module level.