mirrors/Graphite
1
0
Fork 0
mirror of https://github.com/GraphiteEditor/Graphite.git synced 2025-12-23 10:11:54 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Update terminology in the docs

Browse source
This commit is contained in:
Keavon Chambers 2021-08-12 00:39:29 -07:00
parent 483f7d5893
commit ef93bed0ec
3 changed files with 52 additions and 226 deletions
Download patch file Download diff file Expand all files Collapse all files

16
docs/codebase/README.md
View file

@ -16,19 +16,15 @@ Each depends on its successor in the list. These are used internally but also in
The main modules of the project architecture are outlined below. Some parts describe future features and the directories don't exist yet. **Bold** modules are required for Graphite 0.1 which is purely an SVG editor.
- **Web frontend**: `/frontend/`
Initial GUI for Graphite that will eventually be replaced by a native GUI implementation
- **Graphite Editor (Frontend)**: `/frontend/`
Prototype web-based GUI for Graphite that will eventually be replaced by a native GUI frontend implementation
- **Vue web app**: `src/`
Imports the WASM code and uses Vue props to customize and reuse most GUI components
- **Rust WebAssembly translation layer**: `wasm/`
Wraps the editor client backend and provides an API for the web app to use unburdened by Rust's complex data types that are not supported by JS
- **Editor Client Backend**: `/editor/`
- **Graphite Editor (Backend)**: `/editor/`
Used by a frontend editor client to maintain GUI state and dispatch user events. The official Graphite editor is the primary user, but others software like game engines could embed their own customized editor implementations. Depends on Graphene.
- **Graphene Document Graph Engine**: `/graphene/`
- **Graphene (Document Graph Engine)**: `/graphene/`
A stateless library for updating Graphite design document (GDD) files. The official Graphite CLI and editor client backend are the primary users, but this library is intended to be useful to any application that wants to link the library for the purpose of updating GDD files by sending edit operations. Optionally depends on Charcoal if rendering is required.
- **Charcoal Asset Render Engine**: `/charcoal/`
A stateless library (with the help of in-memory and/or on-disk caches for performance) for rendering Graphite's render graph (GRD) files. The official Graphite CLI and Graphene are the primary users, but this library is intended to be useful to any application that wants to link the library for the purpose of rendering Graphite's render graphs. For example, games can link the library and render procedural textures with customizable parametric input values.
## Architecture diagram
Take this [Architecture Overview](architecture-overview.nomnoml) diagram and paste it into the [Nomnoml](https://nomnoml.com/) diagram editor. We'll set up a better way to render Nomnoml diagrams when we have a proper home for this documentation.
- **Charcoal (Asset Render Engine)**: `/charcoal/`
A stateless library (with the help of in-memory and/or on-disk caches for performance) for rendering Graphite's asset graph (GDA) files. The official Graphite CLI and Graphene are the primary users, but this library is intended to be useful to any application that wants to link the library for the purpose of rendering Graphite's asset graphs. For example, games can link the library and render procedural textures with customizable parametric input values.

169
docs/codebase/architecture-overview.nomnoml
View file

@ -1,169 +0,0 @@
#spacing: 120
#arrowSize: 0.5
#leading: 1.5
#gravity: 1
#direction: down
#bendSize: 0.2
#.hdiagram: visual=note direction=right title=bold
#.vdiagram: visual=note direction=down title=bold
#.client: visual=roundrect fill=lightgreen title=bold
#.editor: fill=lightblue title=bold
#.document: fill=darkorange title=bold
#.renderer: fill=gold title=bold
// Clients and Core Libraries
[<hdiagram> Clients and Core Libraries - Usage Overview|
[<client> Frontend Editor Client]
[<client> Headless Editor Client]
[<client> Application Client
(like a game engine or game that renders .grd graphs at runtime)]
[<editor> Editor Core Library]
[<document> Document Core Library]
[<renderer> Renderer Core Library]
[Frontend Editor Client] Depends On -> [Editor Core Library]
[Editor Core Library] Depends On -> [Document Core Library]
[Headless Editor Client] Depends On -> [Document Core Library]
[Document Core Library] Depends On -> [Renderer Core Library]
[Application Client] Depends On -> [Renderer Core Library]
]
[<vdiagram> Clients and Core Libraries - Major Modules|
// Client
[<client> Frontend Implementation|
One of many possible frontend implementations,
such as the native or web client.
]
[<client> CLI Implementation|
A possible text-based CLI program that
wraps Graphite Document. Users can
pass a .gdd document and operation to
add to the document history by saving
to the supplied .gdd file. Users can also
pass a .gdd document and request a
render. Caches are saved to disk.
]
// Editor
[<editor> Dispatcher|
Convert all events from the frontend into Actions
and Operations. Actions are diffs to update state
stores. Operations are history events in a .gdd
file. Operations and document-specific Actions
include the document ID in the call.
]
[Dispatcher] --> Set New Bounds [<renderer> (Backchannel) To: Scheduler]
[Dispatcher] Send Responses <-> Operations [Design Document Maintainer]
[CLI Implementation] -> Send CLI Arguments [Design Document Maintainer]
[<editor> State Stores|
[<editor> Open Documents State Store|
For each open document:|
[<state> Pan and zoom canvas bounds]|
[<state> Selected layers]
]
[<editor> Editor State Store|
[<state> Panel Layout]|
[<state> Working Colors]|
[<state> Active Tool]|
[<state> Tool Options]|
[<state> Modifier Key Input]|
[<state> Currently Hovered Panel]
]
]
[<editor> Tool State Machine|
List the possible operations in current context
]
[Tool State Machine] <:- [State Stores]
[Tool State Machine] -> Send Responses & Operations [Dispatcher]
[Frontend Implementation] Send Responses <-> Send Events [Dispatcher]
[Dispatcher] <:-> Send Actions [State Stores]
[<renderer> (Backchannel) From: Final Render Assembler] --> Send Responses with Rendered Viewport [Dispatcher]
// Document
[<document> Design Document Maintainer|
Process each operation and apply changes to the given document's
operation chain. Consolidate changes where possible by modifying
the previous operation if it's the same as this one and append partial
updates to operations from in-progress interactive tools.
]
[Design Document Maintainer] -> Send Design Document Diff [Render Graph Maintainer]
[Design Document Maintainer] <:-> Write Updated GDD [Open Documents File Store]
[<document> Render Graph Maintainer|
Bake operations into a complete graph including history references.
Starting from the beginning of document history, each operation
modifies the graph in a specific way. If an operation creates a node
that references this point in history, duplicate the current graph pieces
between the live graph and each additional history reference so
changed nodes in history are "ghost variants" living in the live graph.
]
[Render Graph Maintainer] <:-> Write Updated GRD [Open Documents File Store]
[Render Graph Maintainer] -> Send Render Graph [Scheduler]
[<document>Open Documents File Store|
Kept in-memory or written to disk.|
For each open document:|
[<state> Design Document (.gdd)]|
[<state> Render Graph (.grd)]
]
// Renderer
[<renderer> Scheduler|
Manage a thread pool and GPU time. Perform progressive enhancement
and speculative tile rendering. Request re-render of dirtied document within
bounds and stitch them over dirty raster cache tiles. Maintain interactive
responsiveness by targeting a minimum framerate and picking a requisite
render quality level at all times. Precompute nodes downstream of changes
when there is spare CPU thread pool and GPU time. Primary purpose is to
keep the Precompute and Raster Tile caches up-to-date with minimal
onscreen latency. Also notifies the Final Render Assembler when the cache
tiles for the root document visible in bounds have finished being updated.
]
[Scheduler] Set New Bounds <-- [<editor> (Backchannel) From: Dispatcher]
[Scheduler] -> Rasterize Tiles [Node Rasterizer]
[Scheduler] <:-> Write Dirty Status [Node Cache Manager]
[Scheduler] -> Invoke [Final Render Assembler]
[<renderer> Node Cache Manager|
Purges old or less useful cached data
as necessary.|
[<state> Precompute Node Cache|
Prepare data for rasterization step.
Evaluate algorithms (CPU or GPU).
Changes when upstream changes.
]|
[<state> Raster Tile Node Cache|
Must be fast, fragment shader only.
Only reevaluate downstream.
Reuse when panning.
]
]
[Node Cache Manager] -:> [Final Render Assembler]
[<renderer> Node Rasterizer|
Rasterize and update the cache for a specified node
given a preferred bounds (but it can give a different
sized output), resolution, and quality level.
]
[Node Rasterizer] <:-> Write Tiles [Node Cache Manager]
[<renderer> Final Render Assembler|
Look up the rasterized cached tiles from
the document root and assemble them into
an image for live display by the frontend.
Operates when woken up by the scheduler
when root tiles or render bounds are updated.
]
[Final Render Assembler] --> Send Rendered Viewport to Client [<client> (Backchannel) To: Frontend Implementation]
]