e34e6373b6
This patch replaces the Composite node with the Group Output node as the primary compositor output. The old node was removed and versioned. This was done for consistency with Geometry Nodes and in preparation for more generic use of the compositor in VSE modifiers, layered compositing, NPR multi-stage compositing, and more. The Group Output node relies on the node tree interface, so we now have a default interface of a single input and a single output. For now, only the first input is considered while the rest are ignored, just like the Geometry Nodes design. Furthermore, the input is required to be of type color. Warnings and errors are issues if any of those are not met, also similar to Geometry Nodes. This introduces a new limitation: Composite outputs can no longer exist in node groups, since they obviously then act as their respective group outputs. A refactor for the compositor scheduler is needed to simplify the logic after this change, but this will be done in a separate patch. Pull Request: https://projects.blender.org/blender/blender/pulls/142232
263 lines
10 KiB
C++
263 lines
10 KiB
C++
/* SPDX-FileCopyrightText: 2023 Blender Authors
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0-or-later */
|
|
|
|
/** \file
|
|
* \ingroup blenloader
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "BLI_function_ref.hh"
|
|
#include "BLI_map.hh"
|
|
#include "BLI_string_ref.hh"
|
|
|
|
#include "BKE_fcurve.hh"
|
|
|
|
#include "RNA_define.hh"
|
|
|
|
#include "DNA_anim_types.h"
|
|
#include "DNA_node_types.h"
|
|
|
|
struct ARegion;
|
|
struct bNode;
|
|
struct bNodeSocket;
|
|
struct bNodeTree;
|
|
struct ID;
|
|
struct IDProperty;
|
|
struct ListBase;
|
|
struct Main;
|
|
struct ViewLayer;
|
|
struct SceneRenderLayer;
|
|
|
|
using blender::FunctionRef;
|
|
|
|
/**
|
|
* Mapping from new ID types to old converted ID types.
|
|
*
|
|
* This is used by linking code, when a directly linked data comes from a library where it exists
|
|
* as an older, different type of ID.
|
|
*
|
|
* Since the current blend-file will convert that older ID type to the new one as part of its
|
|
* versioning process, when saved, it will store a reference to that linked ID using the _new_ ID
|
|
* type, which will not be found on next blend-file opening/reloading when searching for that ID in
|
|
* the library blend-file.
|
|
*
|
|
* \returns The old, deprecated ID type code if any matches the given `id_code_new` one, otherwise
|
|
* `ID_LINK_PLACEHOLDER`.
|
|
*/
|
|
short do_versions_new_to_old_idcode_get(short id_code_new);
|
|
|
|
/**
|
|
* Check if a region of type \a region_type exists in \a regionbase. Otherwise add it after the
|
|
* first region of type \a link_after_region_type.
|
|
* \returns null if a region of the given type already existed, otherwise the newly added region.
|
|
*/
|
|
ARegion *do_versions_add_region_if_not_found(ListBase *regionbase,
|
|
int region_type,
|
|
const char *allocname,
|
|
int link_after_region_type);
|
|
/**
|
|
* Check if a region of type \a region_type exists in \a regionbase. Otherwise add it after the
|
|
* first region of type \a link_after_region_type.
|
|
* \returns either a new, or already existing region.
|
|
*/
|
|
ARegion *do_versions_ensure_region(ListBase *regionbase,
|
|
int region_type,
|
|
const char *allocname,
|
|
int link_after_region_type);
|
|
|
|
/**
|
|
* Rename if the ID doesn't exist.
|
|
*
|
|
* \return the ID (if found).
|
|
*/
|
|
ID *do_versions_rename_id(Main *bmain, short id_type, const char *name_src, const char *name_dst);
|
|
|
|
bool version_node_socket_is_used(bNodeSocket *sock);
|
|
|
|
void version_node_socket_name(bNodeTree *ntree,
|
|
int node_type,
|
|
const char *old_name,
|
|
const char *new_name);
|
|
void version_node_input_socket_name(bNodeTree *ntree,
|
|
int node_type,
|
|
const char *old_name,
|
|
const char *new_name);
|
|
void version_node_output_socket_name(bNodeTree *ntree,
|
|
int node_type,
|
|
const char *old_name,
|
|
const char *new_name);
|
|
|
|
/**
|
|
* Find the base socket name for an idname that may include a subtype.
|
|
*/
|
|
blender::StringRef legacy_socket_idname_to_socket_type(blender::StringRef idname);
|
|
|
|
/**
|
|
* Adds a new node for versioning purposes. This is intended to be used to create raw DNA that
|
|
* might have been read from a file. The created node does not have storage or sockets. Both have
|
|
* to be added manually afterwards.
|
|
*
|
|
* This may seem redundant because the set of sockets is already part of the node declaration.
|
|
* However, the declaration should not be used here, because it changes over time. The versioning
|
|
* code generally expects to get the sockets that the node had at the time of writing the
|
|
* versioning code. Changing the declaration later can break the versioning code in ways that are
|
|
* hard to detect.
|
|
*/
|
|
bNode &version_node_add_empty(bNodeTree &ntree, const char *idname);
|
|
|
|
/**
|
|
* Removes a node for versioning purposes:
|
|
* - Animation data (#AnimData) are not removed, because they might be using #bAction.id which
|
|
* is not be available before linking.
|
|
* - User count is not updated. This is ensured after blend file reading is done.
|
|
*/
|
|
void version_node_remove(bNodeTree &ntree, bNode &node);
|
|
bNodeSocket &version_node_add_socket(bNodeTree &ntree,
|
|
bNode &node,
|
|
eNodeSocketInOut in_out,
|
|
const char *idname,
|
|
const char *identifier);
|
|
bNodeLink &version_node_add_link(
|
|
bNodeTree &ntree, bNode &node_a, bNodeSocket &socket_a, bNode &node_b, bNodeSocket &socket_b);
|
|
|
|
/**
|
|
* Adjust animation data for newly added node sockets.
|
|
*
|
|
* Node sockets are addressed by their index (in their RNA path, and thus FCurves/drivers), and
|
|
* thus when a new node is added in the middle of the list, existing animation data needs to be
|
|
* adjusted.
|
|
*
|
|
* Since this is about animation data, it only concerns input sockets.
|
|
*
|
|
* \param node_tree_type: Node tree type that has these nodes, for example #NTREE_SHADER.
|
|
* \param node_type: Node type to adjust, for example #SH_NODE_BSDF_PRINCIPLED.
|
|
* \param socket_index_orig: The original index of the moved socket; when socket 4 moved to 6,
|
|
* pass 4 here.
|
|
* \param socket_index_offset: The offset of the nodes, so when socket 4 moved to 6,
|
|
* pass 2 here.
|
|
* \param total_number_of_sockets: The total number of sockets in the node.
|
|
*/
|
|
void version_node_socket_index_animdata(
|
|
Main *bmain,
|
|
int node_tree_type, /* NTREE_....., e.g. NTREE_SHADER */
|
|
int node_type, /* SH_NODE_..., e.g. SH_NODE_BSDF_PRINCIPLED */
|
|
int socket_index_orig,
|
|
int socket_index_offset,
|
|
int total_number_of_sockets);
|
|
|
|
/**
|
|
* Replace the ID name of all nodes in the tree with the given type with the new name.
|
|
*/
|
|
void version_node_id(bNodeTree *ntree, int node_type, const char *new_name);
|
|
|
|
/**
|
|
* Convert `SocketName.001` unique name format to `SocketName_001`. Previously both were used.
|
|
*/
|
|
void version_node_socket_id_delim(bNodeSocket *socket);
|
|
|
|
bNodeSocket *version_node_add_socket_if_not_exist(bNodeTree *ntree,
|
|
bNode *node,
|
|
int in_out,
|
|
int type,
|
|
int subtype,
|
|
const char *identifier,
|
|
const char *name);
|
|
|
|
/**
|
|
* The versioning code generally expects `SOCK_IS_LINKED` to be set correctly. This function
|
|
* updates the flag on all sockets after changes to the node tree.
|
|
*/
|
|
void version_socket_update_is_used(bNodeTree *ntree);
|
|
ARegion *do_versions_add_region(int regiontype, const char *name);
|
|
|
|
void sequencer_init_preview_region(ARegion *region);
|
|
|
|
void add_realize_instances_before_socket(bNodeTree *ntree,
|
|
bNode *node,
|
|
bNodeSocket *geometry_socket);
|
|
|
|
float *version_cycles_node_socket_float_value(bNodeSocket *socket);
|
|
float *version_cycles_node_socket_rgba_value(bNodeSocket *socket);
|
|
float *version_cycles_node_socket_vector_value(bNodeSocket *socket);
|
|
|
|
IDProperty *version_cycles_properties_from_ID(ID *id);
|
|
IDProperty *version_cycles_properties_from_view_layer(ViewLayer *view_layer);
|
|
IDProperty *version_cycles_properties_from_render_layer(SceneRenderLayer *render_layer);
|
|
IDProperty *version_cycles_visibility_properties_from_ID(ID *id);
|
|
|
|
float version_cycles_property_float(IDProperty *idprop, const char *name, float default_value);
|
|
int version_cycles_property_int(IDProperty *idprop, const char *name, int default_value);
|
|
void version_cycles_property_int_set(IDProperty *idprop, const char *name, int value);
|
|
bool version_cycles_property_boolean(IDProperty *idprop, const char *name, bool default_value);
|
|
void version_cycles_property_boolean_set(IDProperty *idprop, const char *name, bool value);
|
|
|
|
void node_tree_relink_with_socket_id_map(bNodeTree &ntree,
|
|
bNode &old_node,
|
|
bNode &new_node,
|
|
const blender::Map<std::string, std::string> &map);
|
|
void version_update_node_input(
|
|
bNodeTree *ntree,
|
|
FunctionRef<bool(bNode *)> check_node,
|
|
const char *socket_identifier,
|
|
FunctionRef<void(bNode *, bNodeSocket *)> update_input,
|
|
FunctionRef<void(bNode *, bNodeSocket *, bNode *, bNodeSocket *)> update_input_link);
|
|
|
|
bNode *version_eevee_output_node_get(bNodeTree *ntree, int16_t node_type);
|
|
|
|
/**
|
|
* Allow 5.0+ to 'convert' older blendfiles' system properties storage.
|
|
*/
|
|
void version_system_idprops_generate(Main *bmain);
|
|
|
|
bool all_scenes_use(Main *bmain, const blender::Span<const char *> engines);
|
|
|
|
/**
|
|
* Adjust the values of the given FCurve key frames by applying the given function. The function is
|
|
* expected to get and return a float representing the value of the key frame. The FCurve is
|
|
* potentially changed to have the given property type, if not already the case.
|
|
*/
|
|
template<typename Function>
|
|
static void adjust_fcurve_key_frame_values(FCurve *fcurve,
|
|
const PropertyType property_type,
|
|
const Function &function)
|
|
{
|
|
/* Adjust key frames. */
|
|
if (fcurve->bezt) {
|
|
for (int i = 0; i < fcurve->totvert; i++) {
|
|
fcurve->bezt[i].vec[0][1] = function(fcurve->bezt[i].vec[0][1]);
|
|
fcurve->bezt[i].vec[1][1] = function(fcurve->bezt[i].vec[1][1]);
|
|
fcurve->bezt[i].vec[2][1] = function(fcurve->bezt[i].vec[2][1]);
|
|
}
|
|
}
|
|
|
|
/* Adjust baked key frames. */
|
|
if (fcurve->fpt) {
|
|
for (int i = 0; i < fcurve->totvert; i++) {
|
|
fcurve->fpt[i].vec[1] = function(fcurve->fpt[i].vec[1]);
|
|
}
|
|
}
|
|
|
|
/* Setup the flags based on the property type. */
|
|
fcurve->flag &= ~(FCURVE_INT_VALUES | FCURVE_DISCRETE_VALUES);
|
|
switch (property_type) {
|
|
case PROP_FLOAT:
|
|
break;
|
|
case PROP_INT:
|
|
fcurve->flag |= FCURVE_INT_VALUES;
|
|
break;
|
|
default:
|
|
fcurve->flag |= (FCURVE_DISCRETE_VALUES | FCURVE_INT_VALUES);
|
|
break;
|
|
}
|
|
|
|
/* Recalculate the automatic handles of the FCurve after adjustments. */
|
|
BKE_fcurve_handles_recalc(fcurve);
|
|
}
|
|
|
|
/* Gets the compositing node tree of the given scene. The deprecated nodetree member is returned
|
|
* for older versions before reusable node trees were introduced in bd61e69be5, while the new
|
|
* compositing_node_group is returned otherwise. */
|
|
bNodeTree *version_get_scene_compositor_node_tree(Main *bmain, Scene *scene);
|