Essentials
Getting Started
Artist Guides
Project Setup and Artist Tools
The fx(hash) API
Generative Art with fx(params)
Browser Based Generative Art
Releasing your Project
An overview of code driven parameters, a special kind of interactive parameters.
So far, we’ve seen fx(params) as collector tweak-able variables that control certain aspects of the generated artwork. What’s more, is that fx(hash) also gives the artists control over how these parameters are updated - they don’t have to necessarily be updated from the control panel, but can also be modulated via the code itself.
The parameter definitions have a special property called ‘update’ which allows the artist to control how this parameter is updated.
The default update mode is page-reload and describes the known behaviour of updating the parameter by performing a full page-reload of the project. Meaning that the entire code of the generative artwork needs to be re-run to apply this parameter change. The are other options for update property, that behave differently and don’t require a full refresh of the project page.
For instance, when setting the update mode of a parameter to sync, the change of this parameter via its respective controller would not trigger a full page reload and update the parameter value in real-time:
{
id: "number_id",
name: "A number/float64",
type: "number",
update: "sync", // <-- new update property
},
Updates on parameters with update: "sync" are received in the background in real-time. Naturally this also requires the artist to structure their code differently for this parameter change to be applied. When using the sync update mode, the artwork code needs to be actively redrawn inside of a loop that can respond when such a synced parameter is changed, (e.g. via requestAnimationFrame), in that manner the code can receive those changes during the runtime of this loop.
For even more advanced use cases, e.g. if you want to only re-render your artwork when the values of your parameters are changing, you can use the new event listeners described in the section on $fx.on, which is detailed in the fx(params) API reference.
<aside> <img src="https://prod-files-secure.s3.us-west-2.amazonaws.com/f9d1e984-50ed-4650-a543-95d2b6c0ba90/44ec34d5-e950-4f4d-b267-55c71f50d545/fx_doc-icon_info_001.png" alt="https://prod-files-secure.s3.us-west-2.amazonaws.com/f9d1e984-50ed-4650-a543-95d2b6c0ba90/44ec34d5-e950-4f4d-b267-55c71f50d545/fx_doc-icon_info_001.png" width="40px" /> What are Code Driven Parameters?
Code driven parameters are special interactive parameters that are controlled via the artists’ code rather than controllers in the interface. Similarly to the sync update mode, the parameters are also updated in real time without reloading the artwork, with the difference that they’re updated from within the code rather than the controller interface.
This allows for much more intricate ways of collector collaboration, where in some instances they can directly interact with the artwork, can get hands on for customisation purposes, and artists can even set up custom minting interfaces.
</aside>
Besides the sync update mode, another mode is code-driven, which is by far the most interesting and versatile one. page-reload and sync both rely on a signal and change in the external UI to update the parameter value. The code-driven update mode breaks this principle, and gives artists the ability to change the value of a parameter from the code, enabling completely customised minting experiences.
code-driven parameters can’t be updated from the UI and have to be controlled via the $fx.on() and $fx.emit() functions. Additionally we also need to make use of the $fx.context property to detect if the code is executed during mint time, in which we would execute additional code that accounts for the update of the code-driven parameter, or in the other contexts where this behaviour is not needed.
The following code snippt exemplifies a code-driven approach:
// defining parameters two code-driven parameters
// that are uneditable from ui, and will be controlled by the code!!
$fx.params([
{
id: "size",
name: "Size",
type: "number",
update: "code-driven",
},
{
id: "x_pos",
name: "X position",
type: "number",
update: "code-driven",
},
])
// this is the draw loop in which we render the graphics
// and listen for changes of the code-driven parameters
function draw() {
// resetting the fx.rand function is important to ensure every time it's
// called, the same values will be generated
$fx.rand.reset()
// GRAHPICS ARE DRAWN HERE
}
// this renders an interactive UI in the minting context
function drawUI() {
// draw UI here
}
// depending on the execution context, 2 different codes are executed
// when the code is executed in a "minting" context
// we run the first clause of the condition
if ($fx.context === "minting") {
// we draw the piece, and the UI on top
draw()
drawUI()
// updating the parameter from the code - this would be called when some input
// is registered, such as clicking the mouse for example
window.addEventListener("click", () => {
$fx.emit("params:update", {
size: Math.random(), // anything here, it will update the parameter value
})
})
// when the params are updated we re-draw the graphics and the UI
$fx.on(
"params:update",
// we do nothing when the event is received
() => {},
// once the params are updated and available, we trigger a re-draw
() => {
draw()
drawUI()
}
)
}
// the piece is ran by itself, for the final output or for the capture
else {
// we just draw
draw()
}
This is an example of an implementation. You are free to follow the patterns of your choice.
← Previous
Next →