griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Compositor: Remove deprecated compositor properties

Browse Source 
This patch removes the properties that were marked as deprecated in the
4.x series and was planned for removal in 5.0. Some DNA members were
marked as deprecated or removed in correspondence with this change.

Pull Request: https://projects.blender.org/blender/blender/pulls/140355
This commit is contained in:
Omar Emara
2025-06-16 08:12:26 +02:00
committed by Omar Emara
parent ed86b1fcf7
commit 498a2e5bcd
4 changed files with 70 additions and 3096 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
source/blender/blenloader/intern/versioning_260.cc
View File

@@ -2145,24 +2145,6 @@ void blo_do_versions_260(FileData *fd, Library * /*lib*/, Main *bmain)
}
}
}
FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
if (ntree->type == NTREE_COMPOSIT) {
LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
if (node->type_legacy == CMP_NODE_IMAGE) {
Image *image = static_cast<Image *>(
blo_do_versions_newlibadr(fd, &ntree->id, ID_IS_LINKED(ntree), node->id));
if (image) {
if ((image->flag & IMA_DO_PREMUL) == 0 && image->alpha_mode == IMA_ALPHA_STRAIGHT) {
node->custom1 |= CMP_NODE_IMAGE_USE_STRAIGHT_OUTPUT;
}
}
}
}
}
}
FOREACH_NODETREE_END;
}
else if (!MAIN_VERSION_FILE_ATLEAST(bmain, 266, 1)) {
/* texture use alpha was removed for 2.66 but added back again for 2.66a,

61
source/blender/makesdna/DNA_node_types.h
View File

@@ -1169,14 +1169,20 @@ typedef struct NodeImageLayer {
} NodeImageLayer;
typedef struct NodeBlurData {
short sizex, sizey;
short samples, maxspeed, minspeed, relative, aspect;
short curved;
float fac, percentx, percenty;
short sizex DNA_DEPRECATED;
short sizey DNA_DEPRECATED;
short samples DNA_DEPRECATED;
short maxspeed DNA_DEPRECATED;
short minspeed DNA_DEPRECATED;
short relative DNA_DEPRECATED;
short aspect DNA_DEPRECATED;
short curved DNA_DEPRECATED;
float fac DNA_DEPRECATED;
float percentx DNA_DEPRECATED;
float percenty DNA_DEPRECATED;
short filtertype;
char bokeh, gamma;
/** Needed for absolute/relative conversions. */
int image_in_width, image_in_height;
char bokeh DNA_DEPRECATED;
char gamma DNA_DEPRECATED;
} NodeBlurData;
typedef struct NodeDBlurData {
@@ -1215,7 +1221,9 @@ typedef struct NodeAntiAliasingData {
/** \note Only for do-version code. */
typedef struct NodeHueSat {
float hue, sat, val;
float hue DNA_DEPRECATED;
float sat DNA_DEPRECATED;
float val DNA_DEPRECATED;
} NodeHueSat;
typedef struct NodeImageFile {
@@ -1266,18 +1274,19 @@ typedef struct NodeChroma {
} NodeChroma;
typedef struct NodeTwoXYs {
short x1;
short x2;
short y1;
short y2;
float fac_x1;
float fac_x2;
float fac_y1;
float fac_y2;
short x1 DNA_DEPRECATED;
short x2 DNA_DEPRECATED;
short y1 DNA_DEPRECATED;
short y2 DNA_DEPRECATED;
float fac_x1 DNA_DEPRECATED;
float fac_x2 DNA_DEPRECATED;
float fac_y1 DNA_DEPRECATED;
float fac_y2 DNA_DEPRECATED;
} NodeTwoXYs;
typedef struct NodeTwoFloats {
float x, y;
float x DNA_DEPRECATED;
float y DNA_DEPRECATED;
} NodeTwoFloats;
typedef struct NodeVertexCol {
@@ -1292,11 +1301,14 @@ typedef struct NodeCMPCombSepColor {
/** Defocus blur node. */
typedef struct NodeDefocus {
char bktype, _pad0, preview, gamco;
short samples, no_zbuf;
float fstop, maxblur, bthresh, scale;
char bktype;
char gamco DNA_DEPRECATED;
char no_zbuf;
char _pad0;
float fstop;
float maxblur;
float scale;
float rotation;
char _pad1[4];
} NodeDefocus;
typedef struct NodeScriptDict {
@@ -1569,7 +1581,7 @@ typedef struct NodeTrackPosData {
typedef struct NodeTranslateData {
char wrap_axis;
char relative;
char relative DNA_DEPRECATED;
short interpolation;
} NodeTranslateData;
@@ -2893,11 +2905,6 @@ typedef enum CMPNodeTranslateRepeatAxis {
#define CMP_NODE_MASK_MBLUR_SAMPLES_MAX 64
/* image */
enum {
CMP_NODE_IMAGE_USE_STRAIGHT_OUTPUT = 1,
};
/* viewer and composite output. */
enum {
CMP_NODE_OUTPUT_IGNORE_ALPHA = 1,

3085
source/blender/makesrna/intern/rna_nodetree.cc
View File

@@ -3536,811 +3536,6 @@ static PointerRNA rna_NodeOutputFile_slot_file_get(CollectionPropertyIterator *i
return ptr;
}
/* --------------------------------------------------------------------
* Glare Node Compatibility Setters/Getters.
*
* The Glare node properties are now deprecated and replaced corresponding inputs. So we provide
* setters/getters for compatibility until those are removed in 5.0. See the
* do_version_glare_node_options_to_inputs function for conversion
*/
static float rna_NodeGlare_threshold_get(PointerRNA *ptr)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Threshold");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
return RNA_float_get(&input_rna_pointer, "default_value");
}
static void rna_NodeGlare_threshold_set(PointerRNA *ptr, const float value)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Threshold");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
RNA_float_set(&input_rna_pointer, "default_value", value);
}
static float rna_NodeGlare_mix_get(PointerRNA *ptr)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Strength");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
return RNA_float_get(&input_rna_pointer, "default_value") - 1;
}
static void rna_NodeGlare_mix_set(PointerRNA *ptr, const float value)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Strength");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
const float mix_value = 1.0f - blender::math::clamp(-value, 0.0f, 1.0f);
RNA_float_set(&input_rna_pointer, "default_value", mix_value);
}
static int rna_NodeGlare_size_get(PointerRNA *ptr)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Size");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
const float size_value = RNA_float_get(&input_rna_pointer, "default_value");
if (size_value == 0.0f) {
return 1;
}
return blender::math::max(1, 9 - int(-std::log2(size_value)));
}
static void rna_NodeGlare_size_set(PointerRNA *ptr, const int value)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Size");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
const float size_value = blender::math::pow(2.0f, float(value - 9));
RNA_float_set(&input_rna_pointer, "default_value", size_value);
}
static int rna_NodeGlare_streaks_get(PointerRNA *ptr)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Streaks");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
return blender::math::clamp(RNA_int_get(&input_rna_pointer, "default_value"), 1, 16);
}
static void rna_NodeGlare_streaks_set(PointerRNA *ptr, const int value)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Streaks");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
RNA_int_set(&input_rna_pointer, "default_value", blender::math::clamp(value, 1, 16));
}
static float rna_NodeGlare_angle_offset_get(PointerRNA *ptr)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Streaks Angle");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
return RNA_float_get(&input_rna_pointer, "default_value");
}
static void rna_NodeGlare_angle_offset_set(PointerRNA *ptr, const float value)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Streaks Angle");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
RNA_float_set(&input_rna_pointer, "default_value", value);
}
static int rna_NodeGlare_iterations_get(PointerRNA *ptr)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Iterations");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
return blender::math::clamp(RNA_int_get(&input_rna_pointer, "default_value"), 2, 5);
}
static void rna_NodeGlare_iterations_set(PointerRNA *ptr, const int value)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Iterations");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
RNA_int_set(&input_rna_pointer, "default_value", blender::math::clamp(value, 2, 5));
}
static float rna_NodeGlare_fade_get(PointerRNA *ptr)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Fade");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
return blender::math::clamp(RNA_float_get(&input_rna_pointer, "default_value"), 0.75f, 1.0f);
}
static void rna_NodeGlare_fade_set(PointerRNA *ptr, const float value)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Fade");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
RNA_float_set(&input_rna_pointer, "default_value", blender::math::clamp(value, 0.75f, 1.0f));
}
static float rna_NodeGlare_color_modulation_get(PointerRNA *ptr)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Color Modulation");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
return blender::math::clamp(RNA_float_get(&input_rna_pointer, "default_value"), 0.0f, 1.0f);
}
static void rna_NodeGlare_color_modulation_set(PointerRNA *ptr, const float value)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Color Modulation");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
RNA_float_set(&input_rna_pointer, "default_value", blender::math::clamp(value, 0.0f, 1.0f));
}
static int rna_NodeSplit_factor_get(PointerRNA *ptr)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Factor");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
return int(blender::math::clamp(RNA_float_get(&input_rna_pointer, "default_value"), 0.0f, 1.0f) *
100.0f);
}
static void rna_NodeSplit_factor_set(PointerRNA *ptr, const int value)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Factor");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
RNA_float_set(
&input_rna_pointer, "default_value", blender::math::clamp(value / 100.0f, 0.0f, 1.0f));
}
static float rna_NodeAntiAlias_contrast_limit_get(PointerRNA *ptr)
{
bNode *node = static_cast<bNode *>(ptr->data);
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Contrast Limit");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
/* Contrast limit was previously divided by 10. */
return blender::math::clamp(
RNA_float_get(&input_rna_pointer, "default_value") / 10.0f, 0.0f, 1.0f);
}
static void rna_NodeAntiAlias_contrast_limit_set(PointerRNA *ptr, const float value)
{
bNode *node = static_cast<bNode *>(ptr->data);
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Contrast Limit");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
/* Contrast limit was previously divided by 10. */
RNA_float_set(&input_rna_pointer, "default_value", value * 10.0f);
}
static float rna_NodeVectorBlur_shutter_get(PointerRNA *ptr)
{
bNode *node = static_cast<bNode *>(ptr->data);
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Shutter");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
/* Shutter was previously divided by 2. */
return RNA_float_get(&input_rna_pointer, "default_value") / 2.0f;
}
static void rna_NodeVectorBlur_shutter_set(PointerRNA *ptr, const float value)
{
bNode *node = static_cast<bNode *>(ptr->data);
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Shutter");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
/* Shutter was previously divided by 2. */
RNA_float_set(&input_rna_pointer, "default_value", value * 2.0f);
}
static float rna_NodeColorSpill_unspill_red_get(PointerRNA *ptr)
{
bNode *node = static_cast<bNode *>(ptr->data);
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Spill Strength");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
float spill_strength[4];
RNA_float_get_array(&input_rna_pointer, "default_value", spill_strength);
return spill_strength[0];
}
static void rna_NodeColorSpill_unspill_red_set(PointerRNA *ptr, const float value)
{
bNode *node = static_cast<bNode *>(ptr->data);
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Spill Strength");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
float spill_strength[4];
RNA_float_get_array(&input_rna_pointer, "default_value", spill_strength);
spill_strength[0] = value;
RNA_float_set_array(&input_rna_pointer, "default_value", spill_strength);
}
static float rna_NodeColorSpill_unspill_green_get(PointerRNA *ptr)
{
bNode *node = static_cast<bNode *>(ptr->data);
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Spill Strength");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
float spill_strength[4];
RNA_float_get_array(&input_rna_pointer, "default_value", spill_strength);
return spill_strength[1];
}
static void rna_NodeColorSpill_unspill_green_set(PointerRNA *ptr, const float value)
{
bNode *node = static_cast<bNode *>(ptr->data);
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Spill Strength");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
float spill_strength[4];
RNA_float_get_array(&input_rna_pointer, "default_value", spill_strength);
spill_strength[1] = value;
RNA_float_set_array(&input_rna_pointer, "default_value", spill_strength);
}
static float rna_NodeColorSpill_unspill_blue_get(PointerRNA *ptr)
{
bNode *node = static_cast<bNode *>(ptr->data);
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Spill Strength");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
float spill_strength[4];
RNA_float_get_array(&input_rna_pointer, "default_value", spill_strength);
return spill_strength[2];
}
static void rna_NodeColorSpill_unspill_blue_set(PointerRNA *ptr, const float value)
{
bNode *node = static_cast<bNode *>(ptr->data);
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Spill Strength");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
float spill_strength[4];
RNA_float_get_array(&input_rna_pointer, "default_value", spill_strength);
spill_strength[2] = value;
RNA_float_set_array(&input_rna_pointer, "default_value", spill_strength);
}
static bool rna_NodeLensDistortion_projector_get(PointerRNA *ptr)
{
return RNA_enum_get(ptr, "distortion_type") == CMP_NODE_LENS_DISTORTION_HORIZONTAL;
}
static void rna_NodeLensDistortion_projector_set(PointerRNA *ptr, const bool value)
{
RNA_enum_set(ptr,
"distortion_type",
value ? CMP_NODE_LENS_DISTORTION_HORIZONTAL : CMP_NODE_LENS_DISTORTION_RADIAL);
}
static float rna_NodeDirectionalBlur_scale_get(PointerRNA *ptr)
{
bNode *node = static_cast<bNode *>(ptr->data);
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Scale");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
/* Scale was previously minus 1. */
return RNA_float_get(&input_rna_pointer, "default_value") - 1.0f;
}
static void rna_NodeDirectionalBlur_scale_set(PointerRNA *ptr, const float value)
{
bNode *node = static_cast<bNode *>(ptr->data);
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Scale");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
/* Scale was previously minus 1. */
RNA_float_set(&input_rna_pointer, "default_value", value + 1.0f);
}
static float rna_NodeBilateralBlur_threshold_get(PointerRNA *ptr)
{
bNode *node = static_cast<bNode *>(ptr->data);
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Threshold");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
/* Threshold was previously multiplied by 3. */
return RNA_float_get(&input_rna_pointer, "default_value") * 3.0f;
}
static void rna_NodeBilateralBlur_threshold_set(PointerRNA *ptr, const float value)
{
bNode *node = static_cast<bNode *>(ptr->data);
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Threshold");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
/* Threshold was previously multiplied by 3. */
RNA_float_set(&input_rna_pointer, "default_value", value / 3.0f);
}
static float rna_NodeBilateralBlur_sigma_space_get(PointerRNA * /*ptr*/)
{
/* Sigma Space no longer exists. */
return 0.0f;
}
static void rna_NodeBilateralBlur_sigma_space_set(PointerRNA *ptr, const float value)
{
bNode *node = static_cast<bNode *>(ptr->data);
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Size");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
const int size = input->default_value_typed<bNodeSocketValueInt>()->value;
/* The size input is ceil(iterations + sigma_space). */
RNA_int_set(&input_rna_pointer, "default_value", size + int(std::ceil(value)));
}
static bool rna_NodeCrop_use_crop_size_get(PointerRNA *ptr)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Alpha Crop");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
return !RNA_boolean_get(&input_rna_pointer, "default_value");
}
static void rna_NodeCrop_use_crop_size_set(PointerRNA *ptr, const bool value)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Alpha Crop");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
RNA_boolean_set(&input_rna_pointer, "default_value", !value);
}
static int rna_NodeCrop_max_x_get(PointerRNA *ptr)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *x_input = blender::bke::node_find_socket(*node, SOCK_IN, "X");
bNodeSocket *width_input = blender::bke::node_find_socket(*node, SOCK_IN, "Width");
PointerRNA x_input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, x_input);
PointerRNA width_input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, width_input);
return RNA_int_get(&x_input_rna_pointer, "default_value") +
RNA_int_get(&width_input_rna_pointer, "default_value");
}
static void rna_NodeCrop_max_x_set(PointerRNA *ptr, const int value)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *x_input = blender::bke::node_find_socket(*node, SOCK_IN, "X");
bNodeSocket *width_input = blender::bke::node_find_socket(*node, SOCK_IN, "Width");
PointerRNA x_input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, x_input);
PointerRNA width_input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, width_input);
RNA_int_set(&width_input_rna_pointer,
"default_value",
value - RNA_int_get(&x_input_rna_pointer, "default_value"));
}
static int rna_NodeCrop_min_y_get(PointerRNA *ptr)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *y_input = blender::bke::node_find_socket(*node, SOCK_IN, "Y");
bNodeSocket *height_input = blender::bke::node_find_socket(*node, SOCK_IN, "Height");
PointerRNA y_input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, y_input);
PointerRNA height_input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, height_input);
return RNA_int_get(&y_input_rna_pointer, "default_value") +
RNA_int_get(&height_input_rna_pointer, "default_value");
}
static void rna_NodeCrop_min_y_set(PointerRNA *ptr, const int value)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *y_input = blender::bke::node_find_socket(*node, SOCK_IN, "Y");
bNodeSocket *height_input = blender::bke::node_find_socket(*node, SOCK_IN, "Height");
PointerRNA y_input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, y_input);
PointerRNA height_input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, height_input);
RNA_int_set(&height_input_rna_pointer,
"default_value",
value - RNA_int_get(&y_input_rna_pointer, "default_value"));
}
static bool rna_NodeBlur_use_bokeh_get(PointerRNA *ptr)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Separable");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
return !RNA_boolean_get(&input_rna_pointer, "default_value");
}
static void rna_NodeCrop_use_bokeh_set(PointerRNA *ptr, const bool value)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Separable");
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
RNA_boolean_set(&input_rna_pointer, "default_value", !value);
}
static int rna_NodeBlur_size_x_get(PointerRNA *ptr)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Size");
return int(input->default_value_typed<bNodeSocketValueVector>()->value[0]);
}
static void rna_NodeCrop_size_x_set(PointerRNA *ptr, const int value)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Size");
input->default_value_typed<bNodeSocketValueVector>()->value[0] = float(value);
}
static int rna_NodeBlur_size_y_get(PointerRNA *ptr)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Size");
return int(input->default_value_typed<bNodeSocketValueVector>()->value[1]);
}
static void rna_NodeCrop_size_y_set(PointerRNA *ptr, const int value)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, "Size");
input->default_value_typed<bNodeSocketValueVector>()->value[1] = float(value);
}
static int rna_NodeFlip_axis_get(PointerRNA *ptr)
{
bNode *node = ptr->data_as<bNode>();
const bNodeSocket *x_input = blender::bke::node_find_socket(*node, SOCK_IN, "Flip X");
const bNodeSocket *y_input = blender::bke::node_find_socket(*node, SOCK_IN, "Flip Y");
const bool flip_x = x_input->default_value_typed<bNodeSocketValueBoolean>()->value;
const bool flip_y = y_input->default_value_typed<bNodeSocketValueBoolean>()->value;
if (flip_x && flip_y) {
return 2;
}
if (flip_y) {
return 1;
}
return 0;
}
static void rna_NodeFlip_axis_set(PointerRNA *ptr, const int value)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *x_input = blender::bke::node_find_socket(*node, SOCK_IN, "Flip X");
bNodeSocket *y_input = blender::bke::node_find_socket(*node, SOCK_IN, "Flip Y");
x_input->default_value_typed<bNodeSocketValueBoolean>()->value = value != 1;
y_input->default_value_typed<bNodeSocketValueBoolean>()->value = value != 0;
}
/* A getter that returns the value of the input socket with the given template identifier and type.
* The RNA pointer is assumed to represent a node. */
template<typename T, const char *identifier>
static T rna_node_property_to_input_getter(PointerRNA *ptr)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, identifier);
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
if constexpr (std::is_same_v<T, bool>) {
return RNA_boolean_get(&input_rna_pointer, "default_value");
}
else if constexpr (std::is_same_v<T, int>) {
return RNA_int_get(&input_rna_pointer, "default_value");
}
else if constexpr (std::is_same_v<T, float>) {
return RNA_float_get(&input_rna_pointer, "default_value");
}
else {
BLI_assert_unreachable();
return T(0);
}
}
/* A setter that sets the given value to the input socket with the given template identifier and
* type. The RNA pointer is assumed to represent a node. */
template<typename T, const char *identifier>
static void rna_node_property_to_input_setter(PointerRNA *ptr, const T value)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, identifier);
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
if constexpr (std::is_same_v<T, bool>) {
RNA_boolean_set(&input_rna_pointer, "default_value", value);
}
else if constexpr (std::is_same_v<T, int>) {
RNA_int_set(&input_rna_pointer, "default_value", value);
}
else if constexpr (std::is_same_v<T, float>) {
RNA_float_set(&input_rna_pointer, "default_value", value);
}
else {
BLI_assert_unreachable();
}
}
/* A getter that returns the value of the array input socket with the given template identifier and
* type. The RNA pointer is assumed to represent a node. */
template<typename T, const char *identifier>
static void rna_node_array_property_to_input_getter(PointerRNA *ptr, T *value)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, identifier);
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
if constexpr (std::is_same_v<T, bool>) {
return RNA_boolean_get_array(&input_rna_pointer, "default_value", value);
}
else if constexpr (std::is_same_v<T, int>) {
return RNA_int_get_array(&input_rna_pointer, "default_value", value);
}
else if constexpr (std::is_same_v<T, float>) {
return RNA_float_get_array(&input_rna_pointer, "default_value", value);
}
else {
BLI_assert_unreachable();
return T(0);
}
}
/* A setter that sets the given value to the array input socket with the given template identifier
* and type. The RNA pointer is assumed to represent a node. */
template<typename T, const char *identifier>
static void rna_node_array_property_to_input_setter(PointerRNA *ptr, const T *value)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, identifier);
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
if constexpr (std::is_same_v<T, bool>) {
RNA_boolean_set_array(&input_rna_pointer, "default_value", value);
}
else if constexpr (std::is_same_v<T, int>) {
RNA_int_set_array(&input_rna_pointer, "default_value", value);
}
else if constexpr (std::is_same_v<T, float>) {
RNA_float_set_array(&input_rna_pointer, "default_value", value);
}
else {
BLI_assert_unreachable();
}
}
/* A getter that returns the value of the component of the vector input socket with the given
* template identifier and component index. The RNA pointer is assumed to represent a node. */
template<const char *identifier, int index>
static float rna_node_property_to_vector_input_getter(PointerRNA *ptr)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, identifier);
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
float vector[4];
RNA_float_get_array(&input_rna_pointer, "default_value", vector);
return vector[index];
}
/* A setter that sets the given value to the component of the input vector socket with the given
* template identifier and component index. The RNA pointer is assumed to represent a node. */
template<const char *identifier, int index>
static void rna_node_property_to_vector_input_setter(PointerRNA *ptr, const float value)
{
bNode *node = ptr->data_as<bNode>();
bNodeSocket *input = blender::bke::node_find_socket(*node, SOCK_IN, identifier);
PointerRNA input_rna_pointer = RNA_pointer_create_discrete(
ptr->owner_id, &RNA_NodeSocket, input);
float vector[4];
RNA_float_get_array(&input_rna_pointer, "default_value", vector);
vector[index] = value;
RNA_float_set_array(&input_rna_pointer, "default_value", vector);
}
/* The following are global static strings used as template arguments to
* rna_node_property_to_input_getter and rna_node_property_to_input_setter. */
/* Glare node. */
static const char node_input_diagonal_star[] = "Diagonal Star";
/* Bokeh Image node. */
static const char node_input_flaps[] = "Flaps";
static const char node_input_angle[] = "Angle";
static const char node_input_roundness[] = "Roundness";
static const char node_input_catadioptric_size[] = "Catadioptric Size";
static const char node_input_color_shift[] = "Color Shift";
/* Time node. */
static const char node_input_start_frame[] = "Start Frame";
static const char node_input_end_frame[] = "End Frame";
/* Mask node. */
static const char node_input_size_x[] = "Size X";
static const char node_input_size_y[] = "Size Y";
static const char node_input_feather[] = "Feather";
static const char node_input_motion_blur[] = "Motion Blur";
static const char node_input_motion_blur_samples[] = "Motion Blur Samples";
static const char node_input_motion_blur_shutter[] = "Motion Blur Shutter";
/* Switch node. */
static const char node_input_switch[] = "Switch";
/* Invert node. */
static const char node_input_invert_color[] = "Invert Color";
static const char node_input_invert_alpha[] = "Invert Alpha";
/* Z Combine node. */
static const char node_input_use_alpha[] = "Use Alpha";
static const char node_input_anti_alias[] = "Anti-Alias";
/* Tone Map node. */
static const char node_input_key[] = "Key";
static const char node_input_balance[] = "Balance";
static const char node_input_gamma[] = "Gamma";
static const char node_input_intensity[] = "Intensity";
static const char node_input_contrast[] = "Contrast";
static const char node_input_light_adaptation[] = "Light Adaptation";
static const char node_input_chromatic_adaptation[] = "Chromatic Adaptation";
/* Dilate/Erode node. */
static const char node_input_size[] = "Size";
static const char node_input_falloff_size[] = "Falloff Size";
/* Kuwahara node. */
static const char node_input_high_precision[] = "High Precision";
static const char node_input_uniformity[] = "Uniformity";
static const char node_input_sharpness[] = "Sharpness";
static const char node_input_eccentricity[] = "Eccentricity";
/* Despeckle node. */
static const char node_input_color_threshold[] = "Color Threshold";
static const char node_input_neighbor_threshold[] = "Neighbor Threshold";
/* Denoise node. */
static const char node_input_hdr[] = "HDR";
/* Anti-Alias node. */
static const char node_input_threshold[] = "Threshold";
static const char node_input_corner_rounding[] = "Corner Rounding";
/* Vector Blur node. */
static const char node_input_samples[] = "Samples";
/* Channel Key node. */
static const char node_input_minimum[] = "Minimum";
static const char node_input_maximum[] = "Maximum";
/* Chroma Key node. */
static const char node_input_falloff[] = "Falloff";
/* Color Key node. */
static const char node_input_hue[] = "Hue";
static const char node_input_saturation[] = "Saturation";
static const char node_input_value[] = "Value";
/* Difference Key node. */
static const char node_input_tolerance[] = "Tolerance";
/* Color Spill node. */
static const char node_input_limit_strength[] = "Limit Strength";
static const char node_input_use_spill_strength[] = "Use Spill Strength";
static const char node_input_spill_strength[] = "Spill Strength";
/* Keying Screen node. */
static const char node_input_smoothness[] = "Smoothness";
/* Keying node. */
static const char node_input_preprocess_blur_size[] = "Preprocess Blur Size";
static const char node_input_key_balance[] = "Key Balance";
static const char node_input_edge_search_size[] = "Edge Search Size";
static const char node_input_edge_tolerance[] = "Edge Tolerance";
static const char node_input_black_level[] = "Black Level";
static const char node_input_white_level[] = "White Level";
static const char node_input_postprocess_blur_size[] = "Postprocess Blur Size";
static const char node_input_postprocess_dilate_size[] = "Postprocess Dilate Size";
static const char node_input_postprocess_feather_size[] = "Postprocess Feather Size";
static const char node_input_despill_strength[] = "Despill Strength";
static const char node_input_despill_balance[] = "Despill Balance";
/* ID Key node. */
static const char node_input_index[] = "Index";
/* Stabilize 2D node. */
static const char node_input_invert[] = "Invert";
/* Color Correction node. */
static const char node_input_master_saturation[] = "Master Saturation";
static const char node_input_master_contrast[] = "Master Contrast";
static const char node_input_master_gamma[] = "Master Gamma";
static const char node_input_master_gain[] = "Master Gain";
static const char node_input_master_lift[] = "Master Lift";
static const char node_input_highlights_saturation[] = "Highlights Saturation";
static const char node_input_highlights_contrast[] = "Highlights Contrast";
static const char node_input_highlights_gamma[] = "Highlights Gamma";
static const char node_input_highlights_gain[] = "Highlights Gain";
static const char node_input_highlights_lift[] = "Highlights Lift";
static const char node_input_midtones_saturation[] = "Midtones Saturation";
static const char node_input_midtones_contrast[] = "Midtones Contrast";
static const char node_input_midtones_gamma[] = "Midtones Gamma";
static const char node_input_midtones_gain[] = "Midtones Gain";
static const char node_input_midtones_lift[] = "Midtones Lift";
static const char node_input_shadows_saturation[] = "Shadows Saturation";
static const char node_input_shadows_contrast[] = "Shadows Contrast";
static const char node_input_shadows_gamma[] = "Shadows Gamma";
static const char node_input_shadows_gain[] = "Shadows Gain";
static const char node_input_shadows_lift[] = "Shadows Lift";
static const char node_input_midtones_start[] = "Midtones Start";
static const char node_input_midtones_end[] = "Midtones End";
static const char node_input_apply_on_red[] = "Apply On Red";
static const char node_input_apply_on_green[] = "Apply On Green";
static const char node_input_apply_on_blue[] = "Apply On Blue";
/* Lens Distortion node. */
static const char node_input_fit[] = "Fit";
static const char node_input_jitter[] = "Jitter";
/* Box Mask node. */
static const char node_input_position[] = "Position";
static const char node_input_rotation[] = "Rotation";
/* Sun Beams node. */
static const char node_input_source[] = "Source";
static const char node_input_length[] = "Length";
/* Directional Blur node. */
static const char node_input_center[] = "Center";
static const char node_input_translation_amount[] = "Translation Amount";
static const char node_input_translation_direction[] = "Translation Direction";
/* Alpha Over node. */
static const char node_input_straight_alpha[] = "Straight Alpha";
/* Bokeh Blur node. */
static const char node_input_extend_bounds[] = "Extend Bounds";
/* Crop node. */
static const char node_input_x[] = "X";
static const char node_input_y[] = "Y";
/* Color Balance node. */
static const char node_input_color_lift[] = "Color Lift";
static const char node_input_color_gamma[] = "Color Gamma";
static const char node_input_color_gain[] = "Color Gain";
static const char node_input_color_offset[] = "Color Offset";
static const char node_input_color_power[] = "Color Power";
static const char node_input_color_slope[] = "Color Slope";
static const char node_input_base_offset[] = "Base Offset";
static const char node_input_input_temperature[] = "Input Temperature";
static const char node_input_input_tint[] = "Input Tint";
static const char node_input_output_temperature[] = "Output Temperature";
static const char node_input_output_tint[] = "Output Tint";
/* --------------------------------------------------------------------
* White Balance Node.
*/
@@ -5288,13 +4483,6 @@ static const EnumPropertyItem prop_tri_channel_items[] = {
{0, nullptr, 0, nullptr, nullptr},
};
static const EnumPropertyItem node_flip_items[] = {
{0, "X", 0, "Flip X", ""},
{1, "Y", 0, "Flip Y", ""},
{2, "XY", 0, "Flip X & Y", ""},
{0, nullptr, 0, nullptr, nullptr},
};
static const EnumPropertyItem node_ycc_items[] = {
{0, "ITUBT601", 0, "ITU 601", ""},
{1, "ITUBT709", 0, "ITU 709", ""},
@@ -5772,22 +4960,6 @@ static void def_time(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_property_struct_type(prop, "CurveMapping");
RNA_def_property_ui_text(prop, "Curve", "");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop,
"rna_node_property_to_input_getter<int, node_input_start_frame>",
"rna_node_property_to_input_setter<int, node_input_start_frame>",
nullptr);
RNA_def_property_ui_text(prop, "Start Frame", "");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "frame_end", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop,
"rna_node_property_to_input_getter<int, node_input_end_frame>",
"rna_node_property_to_input_setter<int, node_input_end_frame>",
nullptr);
RNA_def_property_ui_text(prop, "End Frame", "");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_colorramp(BlenderRNA * /*brna*/, StructRNA *srna)
@@ -7430,30 +6602,8 @@ static void def_sh_script(BlenderRNA * /*brna*/, StructRNA *srna)
/* -- Compositor Nodes ------------------------------------------------------ */
static void def_cmp_alpha_over(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "use_premultiply", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(
prop,
"rna_node_property_to_input_getter<bool, node_input_straight_alpha>",
"rna_node_property_to_input_setter<bool, node_input_straight_alpha>");
RNA_def_property_ui_text(
prop, "Convert Premultiplied", "(Deprecated: Use Straight Alpha input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "premul", PROP_FLOAT, PROP_FACTOR);
RNA_def_property_float_sdna(prop, nullptr, "custom3");
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop, "Premultiplied", "Mix Factor. (Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_blur(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
static const EnumPropertyItem filter_type_items[] = {
{R_FILTER_BOX, "FLAT", 0, "Flat", ""},
{R_FILTER_TENT, "TENT", 0, "Tent", ""},
@@ -7466,100 +6616,14 @@ static void def_cmp_blur(BlenderRNA * /*brna*/, StructRNA *srna)
{0, nullptr, 0, nullptr, nullptr},
};
static const EnumPropertyItem aspect_correction_type_items[] = {
{CMP_NODE_BLUR_ASPECT_NONE, "NONE", 0, "None", ""},
{CMP_NODE_BLUR_ASPECT_Y, "Y", 0, "Y", ""},
{CMP_NODE_BLUR_ASPECT_X, "X", 0, "X", ""},
{0, nullptr, 0, nullptr, nullptr},
};
/* duplicated in def_cmp_bokehblur */
prop = RNA_def_property(srna, "use_variable_size", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, nullptr, "custom1", 1);
RNA_def_property_ui_text(
prop,
"Variable Size",
"Support variable blur per pixel when using an image for size input. (Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "use_extended_bounds", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(
prop,
"rna_node_property_to_input_getter<bool, node_input_extend_bounds>",
"rna_node_property_to_input_setter<bool, node_input_extend_bounds>");
RNA_def_property_ui_text(prop,
"Extend Bounds",
"Extend bounds of the input image to fully fit blurred image. "
"(Deprecated: Use Extend Bounds input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
RNA_def_struct_sdna_from(srna, "NodeBlurData", "storage");
prop = RNA_def_property(srna, "size_x", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop, "rna_NodeBlur_size_x_get", "rna_NodeCrop_size_x_set", nullptr);
RNA_def_property_range(prop, 0, 2048);
RNA_def_property_ui_text(prop, "Size X", "(Deprecated: Use Size input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "size_y", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop, "rna_NodeBlur_size_y_get", "rna_NodeCrop_size_y_set", nullptr);
RNA_def_property_range(prop, 0, 2048);
RNA_def_property_ui_text(prop, "Size Y", "(Deprecated: Use Size input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "use_relative", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, nullptr, "relative", 1);
RNA_def_property_ui_text(
prop,
"Relative",
"Use relative (percent) values to define blur radius. (Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "aspect_correction", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, nullptr, "aspect");
RNA_def_property_enum_items(prop, aspect_correction_type_items);
RNA_def_property_ui_text(
prop, "Aspect Correction", "Type of aspect correction to use. (Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, nullptr, "fac");
RNA_def_property_range(prop, 0.0f, 2.0f);
RNA_def_property_ui_text(prop, "Factor", "(Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "factor_x", PROP_FLOAT, PROP_PERCENTAGE);
RNA_def_property_float_sdna(prop, nullptr, "percentx");
RNA_def_property_range(prop, 0.0f, 100.0f);
RNA_def_property_ui_text(prop, "Relative Size X", "(Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "factor_y", PROP_FLOAT, PROP_PERCENTAGE);
RNA_def_property_float_sdna(prop, nullptr, "percenty");
RNA_def_property_range(prop, 0.0f, 100.0f);
RNA_def_property_ui_text(prop, "Relative Size Y", "(Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
PropertyRNA *prop = RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, nullptr, "filtertype");
RNA_def_property_enum_items(prop, filter_type_items);
RNA_def_property_ui_text(prop, "Filter Type", "");
RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_NODETREE);
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "use_bokeh", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(prop, "rna_NodeBlur_use_bokeh_get", "rna_NodeCrop_use_bokeh_set");
RNA_def_property_ui_text(
prop, "Bokeh", "Use circular filter (slower). (Deprecated: Use Separable input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "use_gamma_correction", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, nullptr, "gamma", 1);
RNA_def_property_ui_text(
prop,
"Gamma",
"Apply filter on gamma corrected values. (Deprecated: Unused. Use Gamma node instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_filter(BlenderRNA * /*brna*/, StructRNA *srna)
@@ -7628,56 +6692,6 @@ static void def_cmp_map_range(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_vector_blur(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
RNA_def_struct_sdna_from(srna, "NodeBlurData", "storage");
prop = RNA_def_property(srna, "samples", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop,
"rna_node_property_to_input_getter<int, node_input_samples>",
"rna_node_property_to_input_setter<int, node_input_samples>",
nullptr);
RNA_def_property_range(prop, 1, 256);
RNA_def_property_ui_text(prop, "Samples", "(Deprecated: Use Samples input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "speed_min", PROP_INT, PROP_NONE);
RNA_def_property_int_sdna(prop, nullptr, "minspeed");
RNA_def_property_range(prop, 0, 1024);
RNA_def_property_ui_text(prop,
"Min Speed",
"Minimum speed for a pixel to be blurred (used to separate background "
"from foreground). (Deprecated.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "speed_max", PROP_INT, PROP_NONE);
RNA_def_property_int_sdna(prop, nullptr, "maxspeed");
RNA_def_property_range(prop, 0, 1024);
RNA_def_property_ui_text(prop, "Max Speed", "Maximum speed, or zero for none. (Deprecated.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop, "rna_NodeVectorBlur_shutter_get", "rna_NodeVectorBlur_shutter_set", nullptr);
RNA_def_property_range(prop, 0.0, 20.0);
RNA_def_property_ui_range(prop, 0.0, 2.0, 1.0, 2);
RNA_def_property_ui_text(prop,
"Blur Factor",
"Scaling factor for motion vectors (actually, 'shutter speed', in "
"frames). (Deprecated: Use Shutter input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "use_curved", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, nullptr, "curved", 1);
RNA_def_property_ui_text(
prop,
"Curved",
"Interpolate between frames in a Bézier curve, rather than linearly. (Deprecated.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_set_alpha(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
@@ -7794,19 +6808,7 @@ static void def_node_image_user(BlenderRNA * /*brna*/, StructRNA *srna)
static void def_cmp_image(BlenderRNA *brna, StructRNA *srna)
{
PropertyRNA *prop;
# if 0
static const EnumPropertyItem type_items[] = {
{IMA_SRC_FILE, "IMAGE", 0, "Image", ""},
{IMA_SRC_MOVIE, "MOVIE", "Movie", ""},
{IMA_SRC_SEQUENCE, "SEQUENCE", "Sequence", ""},
{IMA_SRC_GENERATED, "GENERATED", "Generated", ""},
{0, nullptr, 0, nullptr, nullptr},
};
# endif
prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
PropertyRNA *prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
RNA_def_property_pointer_sdna(prop, nullptr, "id");
RNA_def_property_struct_type(prop, "Image");
RNA_def_property_flag(prop, PROP_EDITABLE);
@@ -7814,13 +6816,6 @@ static void def_cmp_image(BlenderRNA *brna, StructRNA *srna)
RNA_def_property_ui_text(prop, "Image", "");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Image_Node_update_id");
prop = RNA_def_property(srna, "use_straight_alpha_output", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, nullptr, "custom1", CMP_NODE_IMAGE_USE_STRAIGHT_OUTPUT);
RNA_def_property_ui_text(prop,
"Straight Alpha Output",
"Put node output buffer to straight alpha instead of premultiplied");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
/* NOTE: Image user properties used in the UI are redefined in def_node_image_user,
* to trigger correct updates of the node editor. RNA design problem that prevents
* updates from nested structs. */
@@ -8028,31 +7023,6 @@ static void def_cmp_dilate_erode(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_property_ui_text(prop, "Mode", "Growing/shrinking mode");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "distance", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop,
"rna_node_property_to_input_getter<int, node_input_size>",
"rna_node_property_to_input_setter<int, node_input_size>",
nullptr);
RNA_def_property_range(prop, -5000, 5000);
RNA_def_property_ui_range(prop, -100, 100, 1, -1);
RNA_def_property_ui_text(
prop,
"Distance",
"Distance to grow/shrink (number of iterations). (Deprecated: Use Size input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
/* CMP_NODE_DILATE_ERODE_DISTANCE_THRESH only */
prop = RNA_def_property(srna, "edge", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_falloff_size>",
"rna_node_property_to_input_setter<float, node_input_falloff_size>",
nullptr);
RNA_def_property_range(prop, -100, 100);
RNA_def_property_ui_text(
prop, "Edge", "Edge to inset. (Deprecated: Use Falloff Size input instead.)");
RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_IMAGE);
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
RNA_def_struct_sdna_from(srna, "NodeDilateErode", "storage");
/* CMP_NODE_DILATE_ERODE_DISTANCE_FEATHER only */
@@ -8078,63 +7048,6 @@ static void def_cmp_displace(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_inpaint(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
# if 0
prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, nullptr, "custom1");
RNA_def_property_enum_items(prop, type_items);
RNA_def_property_ui_text(prop, "Type", "Type of inpaint algorithm");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
# endif
prop = RNA_def_property(srna, "distance", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop,
"rna_node_property_to_input_getter<int, node_input_size>",
"rna_node_property_to_input_setter<int, node_input_size>",
nullptr);
RNA_def_property_range(prop, 0, 10000);
RNA_def_property_ui_text(
prop,
"Distance",
"Distance to inpaint (number of iterations). (Deprecated: Use Size input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_despeckle(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_color_threshold>",
"rna_node_property_to_input_setter<float, node_input_color_threshold>",
nullptr);
RNA_def_property_range(prop, 0.0, 1.0f);
RNA_def_property_ui_text(prop,
"Threshold",
"Threshold for detecting pixels to despeckle. (Deprecated: Use Color "
"Threshold input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "threshold_neighbor", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_neighbor_threshold>",
"rna_node_property_to_input_setter<float, node_input_neighbor_threshold>",
nullptr);
RNA_def_property_range(prop, 0.0, 1.0f);
RNA_def_property_ui_text(prop,
"Neighbor",
"Threshold for the number of neighbor pixels that must match. "
"(Deprecated: Use Neighbor Threshold instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_scale(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
@@ -8168,22 +7081,6 @@ static void def_cmp_scale(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_property_ui_text(prop, "Frame Method", "How the image fits in the camera frame");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "offset_x", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, nullptr, "custom3");
RNA_def_property_ui_text(prop,
"X Offset",
"Offset image horizontally (factor of image size). (Deprecated: Use a "
"Translate node instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "offset_y", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, nullptr, "custom4");
RNA_def_property_ui_text(
prop,
"Y Offset",
"Offset image vertically (factor of image size). (Deprecated: Use Translate node instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
RNA_def_struct_sdna_from(srna, "NodeScaleData", "storage");
prop = RNA_def_property(srna, "interpolation", PROP_ENUM, PROP_NONE);
@@ -8204,78 +7101,8 @@ static void def_cmp_rotate(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_diff_matte(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "tolerance", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_tolerance>",
"rna_node_property_to_input_setter<float, node_input_tolerance>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop,
"Tolerance",
"Color distances below this threshold are keyed. (Deprecated: Use "
"Tolerance input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "falloff", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_falloff>",
"rna_node_property_to_input_setter<float, node_input_falloff>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop,
"Falloff",
"Color distances below this additional threshold are partially keyed. "
"(Deprecated: Use Falloff input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_color_matte(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "color_hue", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_hue>",
"rna_node_property_to_input_setter<float, node_input_hue>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop,
"H",
"Hue tolerance for colors to be considered a keying color. "
"(Deprecated: Use Hue input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "color_saturation", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_saturation>",
"rna_node_property_to_input_setter<float, node_input_saturation>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(
prop,
"S",
"Saturation tolerance for the color. (Deprecated: Use Saturation input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "color_value", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_value>",
"rna_node_property_to_input_setter<float, node_input_value>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(
prop, "V", "Value tolerance for the color. (Deprecated: Use Value input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_distance_matte(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
static const EnumPropertyItem color_space_items[] = {
{CMP_NODE_DISTANCE_MATTE_COLOR_SPACE_RGBA, "RGB", 0, "RGB", "RGB color space"},
{CMP_NODE_DISTANCE_MATTE_COLOR_SPACE_YCCA, "YCC", 0, "YCC", "YCbCr suppression"},
@@ -8284,35 +7111,11 @@ static void def_cmp_distance_matte(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
prop = RNA_def_property(srna, "channel", PROP_ENUM, PROP_NONE);
PropertyRNA *prop = RNA_def_property(srna, "channel", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, nullptr, "channel");
RNA_def_property_enum_items(prop, color_space_items);
RNA_def_property_ui_text(prop, "Channel", "");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "tolerance", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_tolerance>",
"rna_node_property_to_input_setter<float, node_input_tolerance>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop,
"Tolerance",
"Color distances below this threshold are keyed. (Deprecated: Use "
"Tolerance input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "falloff", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_falloff>",
"rna_node_property_to_input_setter<float, node_input_falloff>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop,
"Falloff",
"Color distances below this additional threshold are partially keyed. "
"(Deprecated: Use Falloff input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_convert_color_space(BlenderRNA * /*brna*/, StructRNA *srna)
@@ -8386,146 +7189,6 @@ static void def_cmp_color_spill(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_property_ui_text(prop, "Limit Channel", "");
RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_COLOR);
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "ratio", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_limit_strength>",
"rna_node_property_to_input_setter<float, node_input_limit_strength>",
nullptr);
RNA_def_property_range(prop, 0.5f, 1.5f);
RNA_def_property_ui_text(
prop, "Ratio", "Scale limit by value. (Deprecated: Use Limit Strength input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "use_unspill", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(
prop,
"rna_node_property_to_input_getter<bool, node_input_use_spill_strength>",
"rna_node_property_to_input_setter<bool, node_input_use_spill_strength>");
RNA_def_property_ui_text(prop,
"Unspill",
"Compensate all channels (differently) by hand. "
"(Deprecated: Use \"Use Spill Strength\" input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "unspill_red", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop, "rna_NodeColorSpill_unspill_red_get", "rna_NodeColorSpill_unspill_red_set", nullptr);
RNA_def_property_range(prop, 0.0f, 1.5f);
RNA_def_property_ui_text(
prop, "R", "Red spillmap scale. (Deprecated: Use Spill Strength input instead.)");
RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_COLOR);
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "unspill_green", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_NodeColorSpill_unspill_green_get",
"rna_NodeColorSpill_unspill_green_set",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.5f);
RNA_def_property_ui_text(
prop, "G", "Green spillmap scale. (Deprecated: Use Spill Strength input instead.)");
RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_COLOR);
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "unspill_blue", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop, "rna_NodeColorSpill_unspill_blue_get", "rna_NodeColorSpill_unspill_blue_set", nullptr);
RNA_def_property_range(prop, 0.0f, 1.5f);
RNA_def_property_ui_text(
prop, "B", "Blue spillmap scale. (Deprecated: Use Spill Strength input instead.)");
RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_COLOR);
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_luma_matte(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "limit_max", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_maximum>",
"rna_node_property_to_input_setter<float, node_input_maximum>",
nullptr);
RNA_def_property_ui_range(prop, 0, 1, 0.1f, 3);
RNA_def_property_ui_text(prop, "High", "Values higher than this setting are 100% opaque");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "limit_min", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_minimum>",
"rna_node_property_to_input_setter<float, node_input_minimum>",
nullptr);
RNA_def_property_ui_range(prop, 0, 1, 0.1f, 3);
RNA_def_property_ui_text(prop, "Low", "Values lower than this setting are 100% keyed");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_brightcontrast(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "use_premultiply", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, nullptr, "custom1", 1);
RNA_def_property_ui_text(prop,
"Convert Premultiplied",
"Keep output image premultiplied alpha. (Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_chroma_matte(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "tolerance", PROP_FLOAT, PROP_ANGLE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_maximum>",
"rna_node_property_to_input_setter<float, node_input_maximum>",
nullptr);
RNA_def_property_range(prop, DEG2RADF(1.0f), DEG2RADF(80.0f));
RNA_def_property_ui_text(prop,
"Acceptance",
"Tolerance for a color to be considered a keying color. (Deprecated: "
"Use Maximum input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_ANGLE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_minimum>",
"rna_node_property_to_input_setter<float, node_input_minimum>",
nullptr);
RNA_def_property_range(prop, 0.0f, DEG2RADF(30.0f));
RNA_def_property_ui_text(prop,
"Cutoff",
"Tolerance below which colors will be considered as exact matches. "
"(Deprecated: Use Minimum input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "lift", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, nullptr, "custom4");
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop, "Lift", "Alpha lift. (Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "gain", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_falloff>",
"rna_node_property_to_input_setter<float, node_input_falloff>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(
prop, "Falloff", "Alpha falloff. (Deprecated: Use Minimum input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "shadow_adjust", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, nullptr, "custom3");
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(
prop,
"Shadow Adjust",
"Adjusts the brightness of any shadows captured. (Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_channel_matte(BlenderRNA * /*brna*/, StructRNA *srna)
@@ -8578,41 +7241,6 @@ static void def_cmp_channel_matte(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_property_ui_text(prop, "Limit Channel", "Limit by this channel's value");
RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_COLOR);
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "limit_max", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_maximum>",
"rna_node_property_to_input_setter<float, node_input_maximum>",
nullptr);
RNA_def_property_ui_range(prop, 0, 1, 0.1f, 3);
RNA_def_property_ui_text(
prop,
"High",
"Values higher than this setting are 100% opaque. (Deprecated: Use Maximum input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "limit_min", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_minimum>",
"rna_node_property_to_input_setter<float, node_input_minimum>",
nullptr);
RNA_def_property_ui_range(prop, 0, 1, 0.1f, 3);
RNA_def_property_ui_text(
prop,
"Low",
"Values lower than this setting are 100% keyed. (Deprecated: Use Minimum input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_flip(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "axis", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_funcs(prop, "rna_NodeFlip_axis_get", "rna_NodeFlip_axis_set", nullptr);
RNA_def_property_enum_items(prop, node_flip_items);
RNA_def_property_ui_text(prop, "Axis", "(Deprecated: Use Flip X and Flip Y inputs instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_split(BlenderRNA * /*brna*/, StructRNA *srna)
@@ -8624,40 +7252,6 @@ static void def_cmp_split(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_property_enum_items(prop, rna_enum_axis_xy_items);
RNA_def_property_ui_text(prop, "Axis", "");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "factor", PROP_INT, PROP_FACTOR);
RNA_def_property_int_funcs(
prop, "rna_NodeSplit_factor_get", "rna_NodeSplit_factor_set", nullptr);
RNA_def_property_range(prop, 0, 100);
RNA_def_property_ui_text(prop, "Factor", "");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_id_mask(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "index", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop,
"rna_node_property_to_input_getter<int, node_input_index>",
"rna_node_property_to_input_setter<int, node_input_index>",
nullptr);
RNA_def_property_range(prop, 0, 32767);
RNA_def_property_ui_text(
prop,
"Index",
"Pass index number to convert to alpha. (Deprecated: Use Index input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "use_antialiasing", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(prop,
"rna_node_property_to_input_getter<bool, node_input_anti_alias>",
"rna_node_property_to_input_setter<bool, node_input_anti_alias>");
RNA_def_property_ui_text(
prop,
"Anti-Aliasing",
"Apply an anti-aliasing filter to the mask. (Deprecated: Use Anti-Aliasing input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_double_edge_mask(BlenderRNA * /*brna*/, StructRNA *srna)
@@ -8696,21 +7290,13 @@ static void def_cmp_double_edge_mask(BlenderRNA * /*brna*/, StructRNA *srna)
static void def_cmp_map_uv(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
static const EnumPropertyItem filter_type_items[] = {
{CMP_NODE_MAP_UV_FILTERING_NEAREST, "NEAREST", 0, "Nearest", ""},
{CMP_NODE_MAP_UV_FILTERING_ANISOTROPIC, "ANISOTROPIC", 0, "Anisotropic", ""},
{0, nullptr, 0, nullptr, nullptr},
};
prop = RNA_def_property(srna, "alpha", PROP_INT, PROP_FACTOR);
RNA_def_property_int_sdna(prop, nullptr, "custom1");
RNA_def_property_range(prop, 0, 100);
RNA_def_property_ui_text(prop, "Alpha", "(Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
PropertyRNA *prop = RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, nullptr, "custom2");
RNA_def_property_enum_items(prop, filter_type_items);
RNA_def_property_ui_text(prop, "Filter Type", "");
@@ -8757,15 +7343,6 @@ static void def_cmp_defocus(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_property_ui_text(prop, "Angle", "Bokeh shape rotation offset");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "use_gamma_correction", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, nullptr, "gamco", 1);
RNA_def_property_ui_text(prop,
"Gamma Correction",
"Enable gamma correction before and after main process. (Deprecated: "
"Unused. Use Gamma node instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
/* TODO */
prop = RNA_def_property(srna, "f_stop", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, nullptr, "fstop");
RNA_def_property_range(prop, 0.0f, 128.0f);
@@ -8782,21 +7359,6 @@ static void def_cmp_defocus(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_property_ui_text(prop, "Max Blur", "Blur limit, maximum CoC radius");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, nullptr, "bthresh");
RNA_def_property_range(prop, 0.0f, 100.0f);
RNA_def_property_ui_text(prop,
"Threshold",
"CoC radius threshold, prevents background bleed on in-focus "
"midground, 0 is disabled. (Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "use_preview", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, nullptr, "preview", 1);
RNA_def_property_ui_text(
prop, "Preview", "Enable low quality mode, useful for preview. (Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "use_zbuffer", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_negative_sdna(prop, nullptr, "no_zbuf", 1);
RNA_def_property_ui_text(prop,
@@ -8816,210 +7378,6 @@ static void def_cmp_defocus(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_invert(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "invert_rgb", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(
prop,
"rna_node_property_to_input_getter<bool, node_input_invert_color>",
"rna_node_property_to_input_setter<bool, node_input_invert_color>");
RNA_def_property_ui_text(prop, "RGB", "(Deprecated: Use Invert Color input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "invert_alpha", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(
prop,
"rna_node_property_to_input_getter<bool, node_input_invert_alpha>",
"rna_node_property_to_input_setter<bool, node_input_invert_alpha>");
RNA_def_property_ui_text(prop, "Alpha", "(Deprecated: Use Invert Alpha input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_crop(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "use_crop_size", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(
prop, "rna_NodeCrop_use_crop_size_get", "rna_NodeCrop_use_crop_size_set");
RNA_def_property_ui_text(prop, "Crop Image Size", "Whether to crop the size of the input image");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "relative", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, nullptr, "custom2", 1);
RNA_def_property_ui_text(
prop, "Relative", "Use relative values to crop image. (Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
RNA_def_struct_sdna_from(srna, "NodeTwoXYs", "storage");
prop = RNA_def_property(srna, "min_x", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop,
"rna_node_property_to_input_getter<int, node_input_x>",
"rna_node_property_to_input_setter<int, node_input_x>",
nullptr);
RNA_def_property_range(prop, 0, 10000);
RNA_def_property_ui_text(
prop, "X1", "Left edge of the cropping rectangle. (Deprecated: Use X input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "max_x", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop, "rna_NodeCrop_max_x_get", "rna_NodeCrop_max_x_set", nullptr);
RNA_def_property_range(prop, 0, 10000);
RNA_def_property_ui_text(
prop, "X2", "Right edge of the cropping rectangle. (Deprecated: Use Width input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "min_y", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop, "rna_NodeCrop_min_y_get", "rna_NodeCrop_min_y_set", nullptr);
RNA_def_property_range(prop, 0, 10000);
RNA_def_property_ui_text(
prop, "Y1", "Top edge of the cropping rectangle. (Deprecated: Use Y input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "max_y", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop,
"rna_node_property_to_input_getter<int, node_input_y>",
"rna_node_property_to_input_setter<int, node_input_y>",
nullptr);
RNA_def_property_range(prop, 0, 10000);
RNA_def_property_ui_text(
prop,
"Y2",
"Bottom edge of the cropping rectangle. (Deprecated: Use Height input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "rel_min_x", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, nullptr, "fac_x1");
RNA_def_property_range(prop, 0.0, 1.0);
RNA_def_property_ui_text(
prop, "X1", "Left edge of the cropping rectangle. (Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "rel_max_x", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, nullptr, "fac_x2");
RNA_def_property_range(prop, 0.0, 1.0);
RNA_def_property_ui_text(
prop, "X2", "Right edge of the cropping rectangle. (Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "rel_min_y", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, nullptr, "fac_y1");
RNA_def_property_range(prop, 0.0, 1.0);
RNA_def_property_ui_text(
prop, "Y1", "Top edge of the cropping rectangle. (Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "rel_max_y", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, nullptr, "fac_y2");
RNA_def_property_range(prop, 0.0, 1.0);
RNA_def_property_ui_text(
prop, "Y2", "Bottom edge of the cropping rectangle. (Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_dblur(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "iterations", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop,
"rna_node_property_to_input_getter<int, node_input_samples>",
"rna_node_property_to_input_setter<int, node_input_samples>",
nullptr);
RNA_def_property_range(prop, 1, 32);
RNA_def_property_ui_text(prop, "Iterations", "(Deprecated: Use Samples input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "center_x", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_vector_input_getter<node_input_center, 0>",
"rna_node_property_to_vector_input_setter<node_input_center, 0>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop, "Center X", "(Deprecated: Use Center input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "center_y", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_vector_input_getter<node_input_center, 1>",
"rna_node_property_to_vector_input_setter<node_input_center, 1>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop, "Center Y", "(Deprecated: Use Center input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "distance", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_translation_amount>",
"rna_node_property_to_input_setter<float, node_input_translation_amount>",
nullptr);
RNA_def_property_range(prop, -1.0f, 1.0f);
RNA_def_property_ui_text(
prop, "Distance", "(Deprecated: Use Translation Amount input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_translation_direction>",
"rna_node_property_to_input_setter<float, node_input_translation_direction>",
nullptr);
RNA_def_property_range(prop, 0.0f, DEG2RADF(360.0f));
RNA_def_property_ui_text(
prop, "Angle", "(Deprecated: Use Translation Direction input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "spin", PROP_FLOAT, PROP_ANGLE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_rotation>",
"rna_node_property_to_input_setter<float, node_input_rotation>",
nullptr);
RNA_def_property_range(prop, DEG2RADF(-360.0f), DEG2RADF(360.0f));
RNA_def_property_ui_text(prop, "Spin", "(Deprecated: Use Rotation input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "zoom", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop, "rna_NodeDirectionalBlur_scale_get", "rna_NodeDirectionalBlur_scale_set", nullptr);
RNA_def_property_range(prop, 0.0f, 100.0f);
RNA_def_property_ui_text(prop, "Zoom", "(Deprecated: Use Scale input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_bilateral_blur(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "iterations", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop,
"rna_node_property_to_input_getter<int, node_input_size>",
"rna_node_property_to_input_setter<int, node_input_size>",
nullptr);
RNA_def_property_range(prop, 1, 128);
RNA_def_property_ui_text(prop, "Iterations", "(Deprecated: Use Size input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "sigma_color", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop, "rna_NodeBilateralBlur_threshold_get", "rna_NodeBilateralBlur_threshold_set", nullptr);
RNA_def_property_range(prop, 0.01f, 3.0f);
RNA_def_property_ui_text(prop, "Color Sigma", "(Deprecated: Use Threshold input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "sigma_space", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_NodeBilateralBlur_sigma_space_get",
"rna_NodeBilateralBlur_sigma_space_set",
nullptr);
RNA_def_property_range(prop, 0.01f, 30.0f);
RNA_def_property_ui_text(prop, "Space Sigma", "(Deprecated: Use Size input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_premul_key(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
@@ -9075,84 +7433,10 @@ static void def_cmp_glare(BlenderRNA * /*brna*/, StructRNA *srna)
"If not set to high quality, the effect will be applied to a low-res copy "
"of the source image");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "iterations", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(
prop, "rna_NodeGlare_iterations_get", "rna_NodeGlare_iterations_set", nullptr);
RNA_def_property_range(prop, 2, 5);
RNA_def_property_ui_text(prop, "Iterations", "(Deprecated: Use Iterations input instead)");
prop = RNA_def_property(srna, "color_modulation", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop, "rna_NodeGlare_color_modulation_get", "rna_NodeGlare_color_modulation_set", nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(
prop,
"Color Modulation",
"Amount of Color Modulation, modulates colors of streaks and ghosts for "
"a spectral dispersion effect. (Deprecated: Use Color Modulation input instead)");
prop = RNA_def_property(srna, "mix", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop, "rna_NodeGlare_mix_get", "rna_NodeGlare_mix_set", nullptr);
RNA_def_property_range(prop, -1.0f, 1.0f);
RNA_def_property_ui_text(prop,
"Mix",
"1 is original image only, 0 is exact 50/50 mix, 1 is processed image "
"only. (Deprecated: Use Strength input instead)");
prop = RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop, "rna_NodeGlare_threshold_get", "rna_NodeGlare_threshold_set", nullptr);
RNA_def_property_range(prop, 0.0f, FLT_MAX);
RNA_def_property_ui_text(prop,
"Threshold",
"The glare filter will only be applied to pixels brighter than this "
"value. (Deprecated: Use Threshold input instead)");
prop = RNA_def_property(srna, "streaks", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(
prop, "rna_NodeGlare_streaks_get", "rna_NodeGlare_streaks_set", nullptr);
RNA_def_property_range(prop, 1, 16);
RNA_def_property_ui_text(
prop, "Streaks", "Total number of streaks. (Deprecated: Use Streaks input instead)");
prop = RNA_def_property(srna, "angle_offset", PROP_FLOAT, PROP_ANGLE);
RNA_def_property_float_funcs(
prop, "rna_NodeGlare_angle_offset_get", "rna_NodeGlare_angle_offset_set", nullptr);
RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
RNA_def_property_ui_text(
prop, "Angle Offset", "Streak angle offset. (Deprecated: Use Streaks Angle input instead)");
prop = RNA_def_property(srna, "fade", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop, "rna_NodeGlare_fade_get", "rna_NodeGlare_fade_set", nullptr);
RNA_def_property_range(prop, 0.75f, 1.0f);
RNA_def_property_ui_text(
prop, "Fade", "Streak fade-out factor. (Deprecated: Use Fade input instead)");
prop = RNA_def_property(srna, "use_rotate_45", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(
prop,
"rna_node_property_to_input_getter<bool, node_input_diagonal_star>",
"rna_node_property_to_input_setter<bool, node_input_diagonal_star>");
RNA_def_property_ui_text(prop,
"Rotate 45°",
"Simple star filter: add 45 degree rotation offset. (Deprecated: Use "
"Diagonal input instead)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "size", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop, "rna_NodeGlare_size_get", "rna_NodeGlare_size_set", nullptr);
RNA_def_property_range(prop, 1, 9);
RNA_def_property_ui_text(prop,
"Size",
"Glow/glare size (not actual size; relative to initial size of bright "
"area of pixels). (Deprecated: Use Size input instead)");
}
static void def_cmp_tonemap(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
static const EnumPropertyItem type_items[] = {
{1,
"RD_PHOTORECEPTOR",
@@ -9165,101 +7449,15 @@ static void def_cmp_tonemap(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_struct_sdna_from(srna, "NodeTonemap", "storage");
prop = RNA_def_property(srna, "tonemap_type", PROP_ENUM, PROP_NONE);
PropertyRNA *prop = RNA_def_property(srna, "tonemap_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, nullptr, "type");
RNA_def_property_enum_items(prop, type_items);
RNA_def_property_ui_text(prop, "Tonemap Type", "");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "key", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_key>",
"rna_node_property_to_input_setter<float, node_input_key>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(
prop,
"Key",
"The value the average luminance is mapped to. (Deprecated: Use Key input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_balance>",
"rna_node_property_to_input_setter<float, node_input_balance>",
nullptr);
RNA_def_property_range(prop, 0.001f, 10.0f);
RNA_def_property_ui_text(prop,
"Offset",
"Normally always 1, but can be used as an extra control to alter the "
"brightness curve. (Deprecated: Use Balance input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "gamma", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_gamma>",
"rna_node_property_to_input_setter<float, node_input_gamma>",
nullptr);
RNA_def_property_range(prop, 0.001f, 3.0f);
RNA_def_property_ui_text(
prop, "Gamma", "If not used, set to 1. (Deprecated: Use Gamma input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "intensity", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_intensity>",
"rna_node_property_to_input_setter<float, node_input_intensity>",
nullptr);
RNA_def_property_range(prop, -8.0f, 8.0f);
RNA_def_property_ui_text(prop,
"Intensity",
"If less than zero, darkens image; otherwise, makes it brighter. "
"(Deprecated: Use Intensity input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "contrast", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_contrast>",
"rna_node_property_to_input_setter<float, node_input_contrast>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(
prop,
"Contrast",
"Set to 0 to use estimate from input image. (Deprecated: Use Contrast input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "adaptation", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_light_adaptation>",
"rna_node_property_to_input_setter<float, node_input_light_adaptation>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop,
"Adaptation",
"If 0, global; if 1, based on pixel intensity. (Deprecated: Use Light "
"Adaptation input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "correction", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_chromatic_adaptation>",
"rna_node_property_to_input_setter<float, node_input_chromatic_adaptation>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop,
"Color Correction",
"If 0, same for all channels; if 1, each independent (Deprecated: Use "
"Chromatic Adaptation input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_lensdist(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
static const EnumPropertyItem type_items[] = {
{CMP_NODE_LENS_DISTORTION_RADIAL,
"RADIAL",
@@ -9276,47 +7474,16 @@ static void def_cmp_lensdist(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_struct_sdna_from(srna, "NodeLensDist", "storage");
prop = RNA_def_property(srna, "distortion_type", PROP_ENUM, PROP_NONE);
PropertyRNA *prop = RNA_def_property(srna, "distortion_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, nullptr, "distortion_type");
RNA_def_property_enum_items(prop, type_items);
RNA_def_property_ui_text(prop, "Type", "");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "use_projector", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(
prop, "rna_NodeLensDistortion_projector_get", "rna_NodeLensDistortion_projector_set");
RNA_def_property_ui_text(prop,
"Projector",
"Enable/disable projector mode (the effect is applied in horizontal "
"direction only). (Deprecated: Use distortion_type property instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "use_jitter", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(prop,
"rna_node_property_to_input_getter<bool, node_input_jitter>",
"rna_node_property_to_input_setter<bool, node_input_jitter>");
RNA_def_property_ui_text(prop,
"Jitter",
"Enable/disable jittering (faster, but also noisier). (Deprecated: Use "
"Jitter input instead.)");
RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_NODETREE);
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "use_fit", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(prop,
"rna_node_property_to_input_getter<bool, node_input_fit>",
"rna_node_property_to_input_setter<bool, node_input_fit>");
RNA_def_property_ui_text(prop,
"Fit",
"For positive distortion factor only: scale image such that black "
"areas are not visible. (Deprecated: Use Fit input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_colorbalance(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
static float default_1[3] = {1.0f, 1.0f, 1.0f};
static const EnumPropertyItem type_items[] = {
{CMP_NODE_COLOR_BALANCE_LGG, "LIFT_GAMMA_GAIN", 0, "Lift/Gamma/Gain", ""},
@@ -9339,132 +7506,6 @@ static void def_cmp_colorbalance(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_property_ui_text(prop, "Correction Formula", "");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
RNA_def_struct_sdna_from(srna, "NodeColorBalance", "storage");
prop = RNA_def_property(srna, "lift", PROP_FLOAT, PROP_COLOR_GAMMA);
RNA_def_property_float_funcs(
prop,
"rna_node_array_property_to_input_getter<float, node_input_color_lift>",
"rna_node_array_property_to_input_setter<float, node_input_color_lift>",
nullptr);
RNA_def_property_array(prop, 3);
RNA_def_property_float_array_default(prop, default_1);
RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
RNA_def_property_ui_text(
prop, "Lift", "Correction for shadows. (Deprecated: Use Lift input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "gamma", PROP_FLOAT, PROP_COLOR_GAMMA);
RNA_def_property_float_funcs(
prop,
"rna_node_array_property_to_input_getter<float, node_input_color_gamma>",
"rna_node_array_property_to_input_setter<float, node_input_color_gamma>",
nullptr);
RNA_def_property_array(prop, 3);
RNA_def_property_float_array_default(prop, default_1);
RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
RNA_def_property_ui_text(
prop, "Gamma", "Correction for midtones. (Deprecated: Use Gamma input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "gain", PROP_FLOAT, PROP_COLOR_GAMMA);
RNA_def_property_float_funcs(
prop,
"rna_node_array_property_to_input_getter<float, node_input_color_gain>",
"rna_node_array_property_to_input_setter<float, node_input_color_gain>",
nullptr);
RNA_def_property_array(prop, 3);
RNA_def_property_float_array_default(prop, default_1);
RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
RNA_def_property_ui_text(
prop, "Gain", "Correction for highlights. (Deprecated: Use Gain input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_COLOR_GAMMA);
RNA_def_property_float_funcs(
prop,
"rna_node_array_property_to_input_getter<float, node_input_color_offset>",
"rna_node_array_property_to_input_setter<float, node_input_color_offset>",
nullptr);
RNA_def_property_array(prop, 3);
RNA_def_property_ui_range(prop, 0, 1, 0.1, 3);
RNA_def_property_ui_text(
prop,
"Offset",
"Correction for entire tonal range. (Deprecated: Use Offset input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "power", PROP_FLOAT, PROP_COLOR_GAMMA);
RNA_def_property_float_funcs(
prop,
"rna_node_array_property_to_input_getter<float, node_input_color_power>",
"rna_node_array_property_to_input_setter<float, node_input_color_power>",
nullptr);
RNA_def_property_array(prop, 3);
RNA_def_property_float_array_default(prop, default_1);
RNA_def_property_range(prop, 0.0f, FLT_MAX);
RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
RNA_def_property_ui_text(
prop, "Power", "Correction for midtones. (Deprecated: Use Power input instead.)");
RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_MOVIECLIP);
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "slope", PROP_FLOAT, PROP_COLOR_GAMMA);
RNA_def_property_float_funcs(
prop,
"rna_node_array_property_to_input_getter<float, node_input_color_slope>",
"rna_node_array_property_to_input_setter<float, node_input_color_slope>",
nullptr);
RNA_def_property_array(prop, 3);
RNA_def_property_float_array_default(prop, default_1);
RNA_def_property_range(prop, 0.0f, FLT_MAX);
RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
RNA_def_property_ui_text(
prop, "Slope", "Correction for highlights. (Deprecated: Use Slope input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "offset_basis", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_base_offset>",
"rna_node_property_to_input_setter<float, node_input_base_offset>",
nullptr);
RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
RNA_def_property_ui_range(prop, -1.0, 1.0, 1.0, 2);
RNA_def_property_ui_text(prop,
"Basis",
"Support negative color by using this as the RGB basis. (Deprecated: "
"Use Offset Basis input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "input_temperature", PROP_FLOAT, PROP_COLOR_TEMPERATURE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_input_temperature>",
"rna_node_property_to_input_setter<float, node_input_input_temperature>",
nullptr);
RNA_def_property_float_default(prop, 6500.0f);
RNA_def_property_range(prop, 1800.0f, 100000.0f);
RNA_def_property_ui_range(prop, 2000.0f, 11000.0f, 100, 0);
RNA_def_property_ui_text(prop,
"Input Temperature",
"Color temperature of the input's white point. (Deprecated: Use Input "
"Temperature input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "input_tint", PROP_FLOAT, PROP_FACTOR);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_input_tint>",
"rna_node_property_to_input_setter<float, node_input_input_tint>",
nullptr);
RNA_def_property_float_default(prop, 10.0f);
RNA_def_property_range(prop, -500.0f, 500.0f);
RNA_def_property_ui_range(prop, -150.0f, 150.0f, 1, 1);
RNA_def_property_ui_text(prop,
"Input Tint",
"Color tint of the input's white point (the default of 10 matches "
"daylight). (Deprecated: Use Input Tint input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "input_whitepoint", PROP_FLOAT, PROP_COLOR);
RNA_def_property_array(prop, 3);
RNA_def_property_float_funcs(prop,
@@ -9477,35 +7518,6 @@ static void def_cmp_colorbalance(BlenderRNA * /*brna*/, StructRNA *srna)
"(automatically converted to/from temperature and tint)");
RNA_def_property_update(prop, NC_WINDOW, "rna_Node_update");
prop = RNA_def_property(srna, "output_temperature", PROP_FLOAT, PROP_COLOR_TEMPERATURE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_output_temperature>",
"rna_node_property_to_input_setter<float, node_input_output_temperature>",
nullptr);
RNA_def_property_float_default(prop, 6500.0f);
RNA_def_property_range(prop, 1800.0f, 100000.0f);
RNA_def_property_ui_range(prop, 2000.0f, 11000.0f, 100, 0);
RNA_def_property_ui_text(prop,
"Output Temperature",
"Color temperature of the output's white point. (Deprecated: Use "
"Output Temperature input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "output_tint", PROP_FLOAT, PROP_FACTOR);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_output_tint>",
"rna_node_property_to_input_setter<float, node_input_output_tint>",
nullptr);
RNA_def_property_float_default(prop, 10.0f);
RNA_def_property_range(prop, -500.0f, 500.0f);
RNA_def_property_ui_range(prop, -150.0f, 150.0f, 1, 1);
RNA_def_property_ui_text(prop,
"Output Tint",
"Color tint of the output's white point (the default of 10 matches "
"daylight). (Deprecated: Use Output Tint input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "output_whitepoint", PROP_FLOAT, PROP_COLOR);
RNA_def_property_array(prop, 3);
RNA_def_property_float_funcs(prop,
@@ -9530,31 +7542,6 @@ static void def_cmp_huecorrect(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_zcombine(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "use_alpha", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(prop,
"rna_node_property_to_input_getter<bool, node_input_use_alpha>",
"rna_node_property_to_input_setter<bool, node_input_use_alpha>");
RNA_def_property_ui_text(prop,
"Use Alpha",
"Take alpha channel into account when doing the Z operation. "
"(Deprecated: Use \"Use Alpha\" input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "use_antialias_z", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(prop,
"rna_node_property_to_input_getter<bool, node_input_anti_alias>",
"rna_node_property_to_input_setter<bool, node_input_anti_alias>");
RNA_def_property_ui_text(prop,
"Anti-Alias Z",
"Anti-alias the z-buffer to try to avoid artifacts, mostly useful for "
"Blender renders. (Deprecated: Use Anti-Alias input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_ycc(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
@@ -9645,16 +7632,6 @@ static void def_cmp_stabilize2d(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_property_enum_items(prop, cmp_interpolation_items);
RNA_def_property_ui_text(prop, "Filter", "Method to use to filter stabilization");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "invert", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(prop,
"rna_node_property_to_input_getter<bool, node_input_invert>",
"rna_node_property_to_input_setter<bool, node_input_invert>");
RNA_def_property_ui_text(prop,
"Invert",
"Invert stabilization to re-introduce motion to the frame. "
"(Deprecated: Use Invert input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_moviedistortion(BlenderRNA * /*brna*/, StructRNA *srna)
@@ -9705,77 +7682,12 @@ static void def_cmp_mask(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_property_ui_text(prop, "Mask", "");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update_relations");
prop = RNA_def_property(srna, "use_feather", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(prop,
"rna_node_property_to_input_getter<bool, node_input_feather>",
"rna_node_property_to_input_setter<bool, node_input_feather>");
RNA_def_property_ui_text(
prop,
"Feather",
"Use feather information from the mask. (Deprecated: Use Feather input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "use_motion_blur", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(
prop,
"rna_node_property_to_input_getter<bool, node_input_motion_blur>",
"rna_node_property_to_input_setter<bool, node_input_motion_blur>");
RNA_def_property_ui_text(
prop,
"Motion Blur",
"Use multi-sampled motion blur of the mask. (Deprecated: Use Motion Blur input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "motion_blur_samples", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(
prop,
"rna_node_property_to_input_getter<int, node_input_motion_blur_samples>",
"rna_node_property_to_input_setter<int, node_input_motion_blur_samples>",
nullptr);
RNA_def_property_range(prop, 1, CMP_NODE_MASK_MBLUR_SAMPLES_MAX);
RNA_def_property_ui_text(
prop,
"Samples",
"Number of motion blur samples. (Deprecated: Use Motion Blur Samples input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "motion_blur_shutter", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_motion_blur_shutter>",
"rna_node_property_to_input_setter<float, node_input_motion_blur_shutter>",
nullptr);
RNA_def_property_range(prop, 0.0, 1.0f);
RNA_def_property_ui_text(prop,
"Shutter",
"Exposure for motion blur as a factor of FPS. (Deprecated: Use Motion "
"Blur Shutter input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "size_source", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_bitflag_sdna(prop, nullptr, "custom1");
RNA_def_property_enum_items(prop, aspect_type_items);
RNA_def_property_ui_text(
prop, "Size Source", "Where to get the mask size from for aspect/size information");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "size_x", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop,
"rna_node_property_to_input_getter<int, node_input_size_x>",
"rna_node_property_to_input_setter<int, node_input_size_x>",
nullptr);
RNA_def_property_range(prop, 1.0f, 10000.0f);
RNA_def_property_ui_text(prop, "X", "(Deprecated: Use Size X input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "size_y", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop,
"rna_node_property_to_input_getter<int, node_input_size_y>",
"rna_node_property_to_input_setter<int, node_input_size_y>",
nullptr);
RNA_def_property_range(prop, 1.0f, 10000.0f);
RNA_def_property_ui_text(prop, "Y", "(Deprecated: Use Size Y input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void dev_cmd_transform(BlenderRNA * /*brna*/, StructRNA *srna)
@@ -9801,566 +7713,20 @@ static const EnumPropertyItem node_masktype_items[] = {
static void def_cmp_boxmask(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "mask_type", PROP_ENUM, PROP_NONE);
PropertyRNA *prop = RNA_def_property(srna, "mask_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, nullptr, "custom1");
RNA_def_property_enum_items(prop, node_masktype_items);
RNA_def_property_ui_text(prop, "Mask Type", "");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "x", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_vector_input_getter<node_input_position, 0>",
"rna_node_property_to_vector_input_setter<node_input_position, 0>",
nullptr);
RNA_def_property_float_default(prop, 0.5f);
RNA_def_property_range(prop, -1.0f, 2.0f);
RNA_def_property_ui_text(
prop, "X", "X position of the middle of the box. (Deprecated: Use Position input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "y", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_vector_input_getter<node_input_position, 1>",
"rna_node_property_to_vector_input_setter<node_input_position, 1>",
nullptr);
RNA_def_property_float_default(prop, 0.5f);
RNA_def_property_range(prop, -1.0f, 2.0f);
RNA_def_property_ui_text(
prop, "Y", "Y position of the middle of the box. (Deprecated: Use Position input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "mask_width", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_vector_input_getter<node_input_size, 0>",
"rna_node_property_to_vector_input_setter<node_input_size, 0>",
nullptr);
RNA_def_property_float_default(prop, 0.3f);
RNA_def_property_range(prop, 0.0f, 2.0f);
RNA_def_property_ui_text(
prop, "Width", "Width of the box. (Deprecated: Use Size input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "mask_height", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_vector_input_getter<node_input_size, 1>",
"rna_node_property_to_vector_input_setter<node_input_size, 1>",
nullptr);
RNA_def_property_float_default(prop, 0.2f);
RNA_def_property_range(prop, 0.0f, 2.0f);
RNA_def_property_ui_text(
prop, "Height", "Height of the box. (Deprecated: Use Size input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "rotation", PROP_FLOAT, PROP_ANGLE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_rotation>",
"rna_node_property_to_input_setter<float, node_input_rotation>",
nullptr);
RNA_def_property_float_default(prop, 0.0f);
RNA_def_property_range(prop, DEG2RADF(-1800.0f), DEG2RADF(1800.0f));
RNA_def_property_ui_text(
prop, "Rotation", "Rotation angle of the box. (Deprecated: Use Rotation input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_ellipsemask(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "mask_type", PROP_ENUM, PROP_NONE);
PropertyRNA *prop = RNA_def_property(srna, "mask_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, nullptr, "custom1");
RNA_def_property_enum_items(prop, node_masktype_items);
RNA_def_property_ui_text(prop, "Mask Type", "");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "x", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_vector_input_getter<node_input_position, 0>",
"rna_node_property_to_vector_input_setter<node_input_position, 0>",
nullptr);
RNA_def_property_float_default(prop, 0.5f);
RNA_def_property_range(prop, -1.0f, 2.0f);
RNA_def_property_ui_text(
prop,
"X",
"X position of the middle of the ellipse. (Deprecated: Use Position input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "y", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_vector_input_getter<node_input_position, 1>",
"rna_node_property_to_vector_input_setter<node_input_position, 1>",
nullptr);
RNA_def_property_float_default(prop, 0.5f);
RNA_def_property_range(prop, -1.0f, 2.0f);
RNA_def_property_ui_text(
prop,
"Y",
"Y position of the middle of the ellipse. (Deprecated: Use Position input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "mask_width", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_vector_input_getter<node_input_size, 0>",
"rna_node_property_to_vector_input_setter<node_input_size, 0>",
nullptr);
RNA_def_property_float_default(prop, 0.3f);
RNA_def_property_range(prop, 0.0f, 2.0f);
RNA_def_property_ui_text(
prop, "Width", "Width of the ellipse. (Deprecated: Use Size input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "mask_height", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_vector_input_getter<node_input_size, 1>",
"rna_node_property_to_vector_input_setter<node_input_size, 1>",
nullptr);
RNA_def_property_float_default(prop, 0.2f);
RNA_def_property_range(prop, 0.0f, 2.0f);
RNA_def_property_ui_text(
prop, "Height", "Height of the ellipse. (Deprecated: Use Size input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "rotation", PROP_FLOAT, PROP_ANGLE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_rotation>",
"rna_node_property_to_input_setter<float, node_input_rotation>",
nullptr);
RNA_def_property_float_default(prop, 0.0f);
RNA_def_property_range(prop, DEG2RADF(-1800.0f), DEG2RADF(1800.0f));
RNA_def_property_ui_text(
prop,
"Rotation",
"Rotation angle of the ellipse. (Deprecated: Use Rotation input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_bokehblur(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
/* duplicated in def_cmp_blur */
prop = RNA_def_property(srna, "use_variable_size", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, nullptr, "custom1", 1);
RNA_def_property_ui_text(
prop,
"Variable Size",
"Support variable blur per pixel when using an image for size input. (Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "use_extended_bounds", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(
prop,
"rna_node_property_to_input_getter<bool, node_input_extend_bounds>",
"rna_node_property_to_input_setter<bool, node_input_extend_bounds>");
RNA_def_property_ui_text(prop,
"Extend Bounds",
"Extend bounds of the input image to fully fit blurred image. "
"(Deprecated: Use Extend Bounds input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "blur_max", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, nullptr, "custom4");
RNA_def_property_range(prop, 0.0f, 10000.0f);
RNA_def_property_ui_text(
prop, "Max Blur", "Blur limit, maximum CoC radius. (Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_bokehimage(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_angle>",
"rna_node_property_to_input_setter<float, node_input_angle>",
nullptr);
RNA_def_property_float_default(prop, 0.0f);
RNA_def_property_range(prop, DEG2RADF(-720.0f), DEG2RADF(720.0f));
RNA_def_property_ui_text(
prop, "Angle", "Angle of the bokeh. (Deprecated: Use Angle input instead)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "flaps", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop,
"rna_node_property_to_input_getter<int, node_input_flaps>",
"rna_node_property_to_input_setter<int, node_input_flaps>",
nullptr);
RNA_def_property_int_default(prop, 5);
RNA_def_property_range(prop, 3, 24);
RNA_def_property_ui_text(
prop, "Flaps", "Number of flaps. (Deprecated: Use Flaps input instead)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "rounding", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_roundness>",
"rna_node_property_to_input_setter<float, node_input_roundness>",
nullptr);
RNA_def_property_float_default(prop, 0.0f);
RNA_def_property_range(prop, -0.0f, 1.0f);
RNA_def_property_ui_text(
prop,
"Rounding",
"Level of rounding of the bokeh. (Deprecated: Use Roundness input instead)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "catadioptric", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_catadioptric_size>",
"rna_node_property_to_input_setter<float, node_input_catadioptric_size>",
nullptr);
RNA_def_property_float_default(prop, 0.0f);
RNA_def_property_range(prop, -0.0f, 1.0f);
RNA_def_property_ui_text(
prop,
"Catadioptric",
"Level of catadioptric of the bokeh. (Deprecated: Use Catadioptric Size input instead)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "shift", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_color_shift>",
"rna_node_property_to_input_setter<float, node_input_color_shift>",
nullptr);
RNA_def_property_float_default(prop, 0.0f);
RNA_def_property_range(prop, -1.0f, 1.0f);
RNA_def_property_ui_text(
prop,
"Lens Shift",
"Shift of the lens components. (Deprecated: Use Color Shift input instead)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_switch(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "check", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(prop,
"rna_node_property_to_input_getter<bool, node_input_switch>",
"rna_node_property_to_input_setter<bool, node_input_switch>");
RNA_def_property_ui_text(
prop,
"Switch",
"Off: first socket, On: second socket. (Deprecated: Use Switch input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_switch_view(BlenderRNA * /*brna*/, StructRNA * /*srna*/) {}
static void def_cmp_colorcorrection(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "red", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(
prop,
"rna_node_property_to_input_getter<bool, node_input_apply_on_red>",
"rna_node_property_to_input_setter<bool, node_input_apply_on_red>");
RNA_def_property_boolean_default(prop, true);
RNA_def_property_ui_text(
prop, "Red", "Red channel active. (Deprecated: Use Apply On Red input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "green", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(
prop,
"rna_node_property_to_input_getter<bool, node_input_apply_on_green>",
"rna_node_property_to_input_setter<bool, node_input_apply_on_green>");
RNA_def_property_boolean_default(prop, true);
RNA_def_property_ui_text(
prop, "Green", "Green channel active. (Deprecated: Use Apply On Green input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "blue", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(
prop,
"rna_node_property_to_input_getter<bool, node_input_apply_on_blue>",
"rna_node_property_to_input_setter<bool, node_input_apply_on_blue>");
RNA_def_property_boolean_default(prop, true);
RNA_def_property_ui_text(
prop, "Blue", "Blue channel active. (Deprecated: Use Apply On Blue input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "midtones_start", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_midtones_start>",
"rna_node_property_to_input_setter<float, node_input_midtones_start>",
nullptr);
RNA_def_property_float_default(prop, 0.2f);
RNA_def_property_range(prop, 0, 1);
RNA_def_property_ui_text(prop,
"Midtones Start",
"Start of midtones. (Deprecated: Use Midtones Start input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "midtones_end", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_midtones_end>",
"rna_node_property_to_input_setter<float, node_input_midtones_end>",
nullptr);
RNA_def_property_float_default(prop, 0.7f);
RNA_def_property_range(prop, 0, 1);
RNA_def_property_ui_text(
prop, "Midtones End", "End of midtones. (Deprecated: Use Midtones End input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "master_saturation", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_master_saturation>",
"rna_node_property_to_input_setter<float, node_input_master_saturation>",
nullptr);
RNA_def_property_float_default(prop, 1.0f);
RNA_def_property_range(prop, 0, 4);
RNA_def_property_ui_text(
prop,
"Master Saturation",
"Master saturation. (Deprecated: Use Master Saturation input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "master_contrast", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_master_contrast>",
"rna_node_property_to_input_setter<float, node_input_master_contrast>",
nullptr);
RNA_def_property_float_default(prop, 1.0f);
RNA_def_property_range(prop, 0, 4);
RNA_def_property_ui_text(prop,
"Master Contrast",
"Master contrast. (Deprecated: Use Master Contrast input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "master_gamma", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_master_gamma>",
"rna_node_property_to_input_setter<float, node_input_master_gamma>",
nullptr);
RNA_def_property_float_default(prop, 1.0f);
RNA_def_property_range(prop, 0, 4);
RNA_def_property_ui_text(
prop, "Master Gamma", "Master gamma. (Deprecated: Use Master Gamma input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "master_gain", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_master_gain>",
"rna_node_property_to_input_setter<float, node_input_master_gain>",
nullptr);
RNA_def_property_float_default(prop, 1.0f);
RNA_def_property_range(prop, 0, 4);
RNA_def_property_ui_text(
prop, "Master Gain", "Master gain. (Deprecated: Use Master Gain input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "master_lift", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_master_lift>",
"rna_node_property_to_input_setter<float, node_input_master_lift>",
nullptr);
RNA_def_property_float_default(prop, 0.0f);
RNA_def_property_range(prop, -1, 1);
RNA_def_property_ui_text(
prop, "Master Lift", "Master lift. (Deprecated: Use Master Lift input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
//
prop = RNA_def_property(srna, "shadows_saturation", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_shadows_saturation>",
"rna_node_property_to_input_setter<float, node_input_shadows_saturation>",
nullptr);
RNA_def_property_float_default(prop, 1.0f);
RNA_def_property_range(prop, 0, 4);
RNA_def_property_ui_text(
prop,
"Shadows Saturation",
"Shadows saturation. (Deprecated: Use Shadows Saturation input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "shadows_contrast", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_shadows_contrast>",
"rna_node_property_to_input_setter<float, node_input_shadows_contrast>",
nullptr);
RNA_def_property_float_default(prop, 1.0f);
RNA_def_property_range(prop, 0, 4);
RNA_def_property_ui_text(prop,
"Shadows Contrast",
"Shadows contrast. (Deprecated: Use Shadows Contrast input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "shadows_gamma", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_shadows_gamma>",
"rna_node_property_to_input_setter<float, node_input_shadows_gamma>",
nullptr);
RNA_def_property_float_default(prop, 1.0f);
RNA_def_property_range(prop, 0, 4);
RNA_def_property_ui_text(
prop, "Shadows Gamma", "Shadows gamma. (Deprecated: Use Shadows Gamma input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "shadows_gain", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_shadows_gain>",
"rna_node_property_to_input_setter<float, node_input_shadows_gain>",
nullptr);
RNA_def_property_float_default(prop, 1.0f);
RNA_def_property_range(prop, 0, 4);
RNA_def_property_ui_text(
prop, "Shadows Gain", "Shadows gain. (Deprecated: Use Shadows Gain input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "shadows_lift", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_shadows_lift>",
"rna_node_property_to_input_setter<float, node_input_shadows_lift>",
nullptr);
RNA_def_property_float_default(prop, 0.0f);
RNA_def_property_range(prop, -1, 1);
RNA_def_property_ui_text(
prop, "Shadows Lift", "Shadows lift. (Deprecated: Use Shadows Lift input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
//
prop = RNA_def_property(srna, "midtones_saturation", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_midtones_saturation>",
"rna_node_property_to_input_setter<float, node_input_midtones_saturation>",
nullptr);
RNA_def_property_float_default(prop, 1.0f);
RNA_def_property_range(prop, 0, 4);
RNA_def_property_ui_text(
prop,
"Midtones Saturation",
"Midtones saturation. (Deprecated: Use Midtones Saturation input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "midtones_contrast", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_midtones_contrast>",
"rna_node_property_to_input_setter<float, node_input_midtones_contrast>",
nullptr);
RNA_def_property_float_default(prop, 1.0f);
RNA_def_property_range(prop, 0, 4);
RNA_def_property_ui_text(
prop,
"Midtones Contrast",
"Midtones contrast. (Deprecated: Use Midtones Contrast input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "midtones_gamma", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_midtones_gamma>",
"rna_node_property_to_input_setter<float, node_input_midtones_gamma>",
nullptr);
RNA_def_property_float_default(prop, 1.0f);
RNA_def_property_range(prop, 0, 4);
RNA_def_property_ui_text(
prop, "Midtones Gamma", "Midtones gamma. (Deprecated: Use Midtones Gamma input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "midtones_gain", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_midtones_gain>",
"rna_node_property_to_input_setter<float, node_input_midtones_gain>",
nullptr);
RNA_def_property_float_default(prop, 1.0f);
RNA_def_property_range(prop, 0, 4);
RNA_def_property_ui_text(
prop, "Midtones Gain", "Midtones gain. (Deprecated: Use Midtones Gain input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "midtones_lift", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_midtones_lift>",
"rna_node_property_to_input_setter<float, node_input_midtones_lift>",
nullptr);
RNA_def_property_float_default(prop, 0.0f);
RNA_def_property_range(prop, -1, 1);
RNA_def_property_ui_text(
prop, "Midtones Lift", "Midtones lift. (Deprecated: Use Midtones Lift input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
//
prop = RNA_def_property(srna, "highlights_saturation", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_highlights_saturation>",
"rna_node_property_to_input_setter<float, node_input_highlights_saturation>",
nullptr);
RNA_def_property_float_default(prop, 1.0f);
RNA_def_property_range(prop, 0, 4);
RNA_def_property_ui_text(
prop,
"Highlights Saturation",
"Highlights saturation. (Deprecated: Use Highlights Saturation input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "highlights_contrast", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_highlights_contrast>",
"rna_node_property_to_input_setter<float, node_input_highlights_contrast>",
nullptr);
RNA_def_property_float_default(prop, 1.0f);
RNA_def_property_range(prop, 0, 4);
RNA_def_property_ui_text(
prop,
"Highlights Contrast",
"Highlights contrast. (Deprecated: Use Highlights Contrast input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "highlights_gamma", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_highlights_gamma>",
"rna_node_property_to_input_setter<float, node_input_highlights_gamma>",
nullptr);
RNA_def_property_float_default(prop, 1.0f);
RNA_def_property_range(prop, 0, 4);
RNA_def_property_ui_text(prop,
"Highlights Gamma",
"Highlights gamma. (Deprecated: Use Highlights Gamma input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "highlights_gain", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_highlights_gain>",
"rna_node_property_to_input_setter<float, node_input_highlights_gain>",
nullptr);
RNA_def_property_float_default(prop, 1.0f);
RNA_def_property_range(prop, 0, 4);
RNA_def_property_ui_text(prop,
"Highlights Gain",
"Highlights gain. (Deprecated: Use Highlights Gain input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "highlights_lift", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_highlights_lift>",
"rna_node_property_to_input_setter<float, node_input_highlights_lift>",
nullptr);
RNA_def_property_float_default(prop, 0.0f);
RNA_def_property_range(prop, -1, 1);
RNA_def_property_ui_text(prop,
"Highlights Lift",
"Highlights lift. (Deprecated: Use Highlights Lift input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_cornerpin(BlenderRNA * /*brna*/, StructRNA *srna)
@@ -10377,17 +7743,7 @@ static void def_cmp_cornerpin(BlenderRNA * /*brna*/, StructRNA *srna)
static void def_cmp_viewer(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "use_alpha", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_negative_sdna(prop, nullptr, "custom2", CMP_NODE_OUTPUT_IGNORE_ALPHA);
RNA_def_property_ui_text(prop,
"Use Alpha",
"Colors are treated alpha premultiplied, or colors output straight "
"(alpha gets set to 1). (Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "ui_shortcut", PROP_INT, PROP_NONE);
PropertyRNA *prop = RNA_def_property(srna, "ui_shortcut", PROP_INT, PROP_NONE);
RNA_def_property_int_sdna(prop, nullptr, "custom1");
RNA_def_property_int_funcs(prop, nullptr, "rna_Node_Viewer_shortcut_node_set", nullptr);
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
@@ -10396,19 +7752,6 @@ static void def_cmp_viewer(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, nullptr);
}
static void def_cmp_composite(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "use_alpha", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_negative_sdna(prop, nullptr, "custom2", CMP_NODE_OUTPUT_IGNORE_ALPHA);
RNA_def_property_ui_text(prop,
"Use Alpha",
"Colors are treated alpha premultiplied, or colors output straight "
"(alpha gets set to 1). (Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_keyingscreen(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
@@ -10427,169 +7770,19 @@ static void def_cmp_keyingscreen(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_property_string_sdna(prop, nullptr, "tracking_object");
RNA_def_property_ui_text(prop, "Tracking Object", "");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "smoothness", PROP_FLOAT, PROP_FACTOR);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_smoothness>",
"rna_node_property_to_input_setter<float, node_input_smoothness>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop, "Smoothness", "(Deprecated: Use Smoothness input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_keying(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
RNA_def_struct_sdna_from(srna, "NodeKeyingData", "storage");
prop = RNA_def_property(srna, "screen_balance", PROP_FLOAT, PROP_FACTOR);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_key_balance>",
"rna_node_property_to_input_setter<float, node_input_key_balance>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop,
"Screen Balance",
"Balance between two non-primary channels primary channel is comparing "
"against. (Deprecated: Use Key Balance input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "despill_factor", PROP_FLOAT, PROP_FACTOR);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_despill_strength>",
"rna_node_property_to_input_setter<float, node_input_despill_strength>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop,
"Despill Factor",
"Factor of despilling screen color from image. (Deprecated: Use "
"Despill Strength input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "despill_balance", PROP_FLOAT, PROP_FACTOR);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_despill_balance>",
"rna_node_property_to_input_setter<float, node_input_despill_balance>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop,
"Despill Balance",
"Balance between non-key colors used to detect amount of key color to "
"be removed. (Deprecated: Use Despill Balance input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "clip_black", PROP_FLOAT, PROP_FACTOR);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_black_level>",
"rna_node_property_to_input_setter<float, node_input_black_level>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop,
"Clip Black",
"Value of non-scaled matte pixel which considers as fully background "
"pixel. (Deprecated: Use Black Level input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "clip_white", PROP_FLOAT, PROP_FACTOR);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_white_level>",
"rna_node_property_to_input_setter<float, node_input_white_level>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop,
"Clip White",
"Value of non-scaled matte pixel which considers as fully foreground "
"pixel. (Deprecated: Use White Level input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "blur_pre", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(
prop,
"rna_node_property_to_input_getter<int, node_input_preprocess_blur_size>",
"rna_node_property_to_input_setter<int, node_input_preprocess_blur_size>",
nullptr);
RNA_def_property_range(prop, 0, 2048);
RNA_def_property_ui_text(prop,
"Pre Blur",
"Chroma pre-blur size which applies before running keyer. (Deprecated: "
"Use Preprocess Blur Size input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "blur_post", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(
prop,
"rna_node_property_to_input_getter<int, node_input_postprocess_blur_size>",
"rna_node_property_to_input_setter<int, node_input_postprocess_blur_size>",
nullptr);
RNA_def_property_range(prop, 0, 2048);
RNA_def_property_ui_text(prop,
"Post Blur",
"Matte blur size which applies after clipping and dilate/eroding. "
"(Deprecated: Use Postprocess Blur Size input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "dilate_distance", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(
prop,
"rna_node_property_to_input_getter<int, node_input_postprocess_dilate_size>",
"rna_node_property_to_input_setter<int, node_input_postprocess_dilate_size>",
nullptr);
RNA_def_property_range(prop, -100, 100);
RNA_def_property_ui_text(prop,
"Dilate/Erode",
"Distance to grow/shrink the matte. (Deprecated: Use Postprocess "
"Dilate Size input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "edge_kernel_radius", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop,
"rna_node_property_to_input_getter<int, node_input_edge_search_size>",
"rna_node_property_to_input_setter<int, node_input_edge_search_size>",
nullptr);
RNA_def_property_range(prop, 0, 100);
RNA_def_property_ui_text(prop,
"Edge Kernel Radius",
"Radius of kernel used to detect whether pixel belongs to edge. "
"(Deprecated: Use Edge Search Size input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "edge_kernel_tolerance", PROP_FLOAT, PROP_FACTOR);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_edge_tolerance>",
"rna_node_property_to_input_setter<float, node_input_edge_tolerance>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop,
"Edge Kernel Tolerance",
"Tolerance to pixels inside kernel which are treating as belonging to "
"the same plane. (Deprecated: Use Edge Tolerance input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "feather_falloff", PROP_ENUM, PROP_NONE);
PropertyRNA *prop = RNA_def_property(srna, "feather_falloff", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, nullptr, "feather_falloff");
RNA_def_property_enum_items(prop, rna_enum_proportional_falloff_curve_only_items);
RNA_def_property_ui_text(prop, "Feather Falloff", "Falloff type of the feather");
RNA_def_property_translation_context(prop,
BLT_I18NCONTEXT_ID_CURVE_LEGACY); /* Abusing id_curve :/ */
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "feather_distance", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(
prop,
"rna_node_property_to_input_getter<int, node_input_postprocess_feather_size>",
"rna_node_property_to_input_setter<int, node_input_postprocess_feather_size>",
nullptr);
RNA_def_property_range(prop, -100, 100);
RNA_def_property_ui_text(prop,
"Feather Distance",
"Distance to grow/shrink the feather. (Deprecated: Use Postprocess "
"Feather Size input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_trackpos(BlenderRNA * /*brna*/, StructRNA *srna)
@@ -10653,25 +7846,6 @@ static void def_cmp_trackpos(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_pixelate(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
/* The range of the pixel size is chosen so that it is positive and above zero, and also does not
* exceed the underlying int16_t type. The size limit matches the maximum size used by blur
* nodes. */
prop = RNA_def_property(srna, "pixel_size", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop,
"rna_node_property_to_input_getter<int, node_input_size>",
"rna_node_property_to_input_setter<int, node_input_size>",
nullptr);
RNA_def_property_range(prop, 1, 2048);
RNA_def_property_int_default(prop, 1);
RNA_def_property_ui_text(
prop, "Pixel Size", "Pixel size of the output image. (Deprecated: Use Size input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_translate(BlenderRNA * /*brna*/, StructRNA *srna)
{
static const EnumPropertyItem translate_repeat_axis_items[] = {
@@ -10692,14 +7866,6 @@ static void def_cmp_translate(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_property_ui_text(prop, "", "");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "use_relative", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, nullptr, "relative", 1);
RNA_def_property_ui_text(prop,
"Relative",
"Use relative (fraction of input image size) values to define "
"translation. (Deprecated: Unused.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "wrap_axis", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, nullptr, "wrap_axis");
RNA_def_property_enum_items(prop, translate_repeat_axis_items);
@@ -10730,75 +7896,6 @@ static void def_cmp_planetrackdeform(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_property_string_sdna(prop, nullptr, "plane_track_name");
RNA_def_property_ui_text(prop, "Plane Track", "");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "use_motion_blur", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(
prop,
"rna_node_property_to_input_getter<bool, node_input_motion_blur>",
"rna_node_property_to_input_setter<bool, node_input_motion_blur>");
RNA_def_property_ui_text(
prop,
"Motion Blur",
"Use multi-sampled motion blur of the mask. (Deprecated: Use Motion Blur input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "motion_blur_samples", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(
prop,
"rna_node_property_to_input_getter<int, node_input_motion_blur_samples>",
"rna_node_property_to_input_setter<int, node_input_motion_blur_samples>",
nullptr);
RNA_def_property_range(prop, 1, 64);
RNA_def_property_ui_text(
prop,
"Samples",
"Number of motion blur samples. (Deprecated: Use Motion Blur Samples input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "motion_blur_shutter", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_motion_blur_shutter>",
"rna_node_property_to_input_setter<float, node_input_motion_blur_shutter>",
nullptr);
RNA_def_property_range(prop, 0.0, 1.0f);
RNA_def_property_ui_text(prop,
"Shutter",
"Exposure for motion blur as a factor of FPS. (Deprecated: Use Motion "
"Blur Shutter input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_sunbeams(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "source", PROP_FLOAT, PROP_NONE);
RNA_def_property_array(prop, 2);
RNA_def_property_float_funcs(prop,
"rna_node_array_property_to_input_getter<float, node_input_source>",
"rna_node_array_property_to_input_setter<float, node_input_source>",
nullptr);
RNA_def_property_range(prop, -100.0f, 100.0f);
RNA_def_property_ui_range(prop, -10.0f, 10.0f, 10, 3);
RNA_def_property_ui_text(prop,
"Source",
"Source point of rays as a factor of the image width and height. "
"(Deprecated: Use Source input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "ray_length", PROP_FLOAT, PROP_UNSIGNED);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_length>",
"rna_node_property_to_input_setter<float, node_input_length>",
nullptr);
RNA_def_property_range(prop, 0.0f, 100.0f);
RNA_def_property_ui_range(prop, 0.0f, 1.0f, 10, 3);
RNA_def_property_ui_text(
prop,
"Ray Length",
"Length of rays as a factor of the image size. (Deprecated: Use Length input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_cryptomatte_entry(BlenderRNA *brna)
@@ -10973,14 +8070,6 @@ static void def_cmp_denoise(BlenderRNA * /*brna*/, StructRNA *srna)
RNA_def_struct_sdna_from(srna, "NodeDenoise", "storage");
prop = RNA_def_property(srna, "use_hdr", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(prop,
"rna_node_property_to_input_getter<bool, node_input_hdr>",
"rna_node_property_to_input_setter<bool, node_input_hdr>");
RNA_def_property_boolean_default(prop, true);
RNA_def_property_ui_text(prop, "HDR", "Process HDR images");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "prefilter", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_items(prop, prefilter_items);
RNA_def_property_enum_default(prop, CMP_NODE_DENOISE_PREFILTER_ACCURATE);
@@ -10996,8 +8085,6 @@ static void def_cmp_denoise(BlenderRNA * /*brna*/, StructRNA *srna)
static void def_cmp_kuwahara(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
RNA_def_struct_sdna_from(srna, "NodeKuwaharaData", "storage");
static const EnumPropertyItem variation_items[] = {
@@ -11006,111 +8093,11 @@ static void def_cmp_kuwahara(BlenderRNA * /*brna*/, StructRNA *srna)
{0, nullptr, 0, nullptr, nullptr},
};
prop = RNA_def_property(srna, "variation", PROP_ENUM, PROP_NONE);
PropertyRNA *prop = RNA_def_property(srna, "variation", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, nullptr, "variation");
RNA_def_property_enum_items(prop, variation_items);
RNA_def_property_ui_text(prop, "", "Variation of Kuwahara filter to use");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "use_high_precision", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(
prop,
"rna_node_property_to_input_getter<bool, node_input_high_precision>",
"rna_node_property_to_input_setter<bool, node_input_high_precision>");
RNA_def_property_ui_text(prop,
"High Precision",
"Uses a more precise but slower method. Use if the output contains "
"undesirable noise. (Deprecated: Use High Precision input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "uniformity", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop,
"rna_node_property_to_input_getter<int, node_input_uniformity>",
"rna_node_property_to_input_setter<int, node_input_uniformity>",
nullptr);
RNA_def_property_range(prop, 0.0, 50.0);
RNA_def_property_ui_range(prop, 0, 50, 1, -1);
RNA_def_property_ui_text(
prop,
"Uniformity",
"Controls the uniformity of the direction of the filter. Higher values "
"produces more uniform directions. (Deprecated: Use Uniformity input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "sharpness", PROP_FLOAT, PROP_FACTOR);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_sharpness>",
"rna_node_property_to_input_setter<float, node_input_sharpness>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.1, 3);
RNA_def_property_ui_text(prop,
"Sharpness",
"Controls the sharpness of the filter. 0 means completely smooth while "
"1 means completely sharp. (Deprecated: Use Sharpness input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "eccentricity", PROP_FLOAT, PROP_FACTOR);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_eccentricity>",
"rna_node_property_to_input_setter<float, node_input_eccentricity>",
nullptr);
RNA_def_property_range(prop, 0.0f, 2.0f);
RNA_def_property_ui_range(prop, 0.0f, 2.0f, 0.1, 3);
RNA_def_property_ui_text(
prop,
"Eccentricity",
"Controls how directional the filter is. 0 means the filter is completely omnidirectional "
"while 2 means it is maximally directed along the edges of the image. (Deprecated: Use "
"Eccentricity input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
static void def_cmp_antialiasing(BlenderRNA * /*brna*/, StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_FACTOR);
RNA_def_property_float_funcs(prop,
"rna_node_property_to_input_getter<float, node_input_threshold>",
"rna_node_property_to_input_setter<float, node_input_threshold>",
nullptr);
RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.1, 3);
RNA_def_property_ui_text(prop,
"Threshold",
"Threshold to detect edges (smaller threshold makes more sensitive "
"detection). (Deprecated: Use Threshold input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "contrast_limit", PROP_FLOAT, PROP_FACTOR);
RNA_def_property_float_funcs(prop,
"rna_NodeAntiAlias_contrast_limit_get",
"rna_NodeAntiAlias_contrast_limit_set",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.1, 3);
RNA_def_property_ui_text(
prop,
"Contrast Limit",
"How much to eliminate spurious edges to avoid artifacts (the larger value makes less "
"active; the value 2.0, for example, means discard a detected edge if there is a "
"neighboring edge that has 2.0 times bigger contrast than the current one). (Deprecated: "
"Use Contrast Limit input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "corner_rounding", PROP_FLOAT, PROP_FACTOR);
RNA_def_property_float_funcs(
prop,
"rna_node_property_to_input_getter<float, node_input_corner_rounding>",
"rna_node_property_to_input_setter<float, node_input_corner_rounding>",
nullptr);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.1, 3);
RNA_def_property_ui_text(
prop,
"Corner Rounding",
"How much sharp corners will be rounded. (Deprecated: Use Corner Rounding input instead.)");
RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
}
/* -- Texture Nodes --------------------------------------------------------- */
@@ -13973,19 +10960,19 @@ static void rna_def_nodes(BlenderRNA *brna)
define("ShaderNode", "ShaderNodeWavelength");
define("ShaderNode", "ShaderNodeWireframe", def_sh_tex_wireframe);
define("CompositorNode", "CompositorNodeAlphaOver", def_cmp_alpha_over);
define("CompositorNode", "CompositorNodeAntiAliasing", def_cmp_antialiasing);
define("CompositorNode", "CompositorNodeBilateralblur", def_cmp_bilateral_blur);
define("CompositorNode", "CompositorNodeAlphaOver");
define("CompositorNode", "CompositorNodeAntiAliasing");
define("CompositorNode", "CompositorNodeBilateralblur");
define("CompositorNode", "CompositorNodeBlur", def_cmp_blur);
define("CompositorNode", "CompositorNodeBokehBlur", def_cmp_bokehblur);
define("CompositorNode", "CompositorNodeBokehImage", def_cmp_bokehimage);
define("CompositorNode", "CompositorNodeBokehBlur");
define("CompositorNode", "CompositorNodeBokehImage");
define("CompositorNode", "CompositorNodeBoxMask", def_cmp_boxmask);
define("CompositorNode", "CompositorNodeBrightContrast", def_cmp_brightcontrast);
define("CompositorNode", "CompositorNodeBrightContrast");
define("CompositorNode", "CompositorNodeChannelMatte", def_cmp_channel_matte);
define("CompositorNode", "CompositorNodeChromaMatte", def_cmp_chroma_matte);
define("CompositorNode", "CompositorNodeChromaMatte");
define("CompositorNode", "CompositorNodeColorBalance", def_cmp_colorbalance);
define("CompositorNode", "CompositorNodeColorCorrection", def_cmp_colorcorrection);
define("CompositorNode", "CompositorNodeColorMatte", def_cmp_color_matte);
define("CompositorNode", "CompositorNodeColorCorrection");
define("CompositorNode", "CompositorNodeColorMatte");
define("CompositorNode", "CompositorNodeColorSpill", def_cmp_color_spill);
define("CompositorNode", "CompositorNodeCombHSVA");
define("CompositorNode", "CompositorNodeCombineColor", def_cmp_combsep_color);
@@ -13993,19 +10980,19 @@ static void rna_def_nodes(BlenderRNA *brna)
define("CompositorNode", "CompositorNodeCombRGBA");
define("CompositorNode", "CompositorNodeCombYCCA", def_cmp_ycc);
define("CompositorNode", "CompositorNodeCombYUVA");
define("CompositorNode", "CompositorNodeComposite", def_cmp_composite);
define("CompositorNode", "CompositorNodeComposite");
define("CompositorNode", "CompositorNodeConvertColorSpace", def_cmp_convert_color_space);
define("CompositorNode", "CompositorNodeCornerPin", def_cmp_cornerpin);
define("CompositorNode", "CompositorNodeCrop", def_cmp_crop);
define("CompositorNode", "CompositorNodeCrop");
define("CompositorNode", "CompositorNodeCryptomatte", def_cmp_cryptomatte_legacy);
define("CompositorNode", "CompositorNodeCryptomatteV2", def_cmp_cryptomatte);
define("CompositorNode", "CompositorNodeCurveRGB", def_rgb_curve);
define("CompositorNode", "CompositorNodeCurveVec", def_vector_curve);
define("CompositorNode", "CompositorNodeDBlur", def_cmp_dblur);
define("CompositorNode", "CompositorNodeDBlur");
define("CompositorNode", "CompositorNodeDefocus", def_cmp_defocus);
define("CompositorNode", "CompositorNodeDenoise", def_cmp_denoise);
define("CompositorNode", "CompositorNodeDespeckle", def_cmp_despeckle);
define("CompositorNode", "CompositorNodeDiffMatte", def_cmp_diff_matte);
define("CompositorNode", "CompositorNodeDespeckle");
define("CompositorNode", "CompositorNodeDiffMatte");
define("CompositorNode", "CompositorNodeDilateErode", def_cmp_dilate_erode);
define("CompositorNode", "CompositorNodeDisplace", def_cmp_displace);
define("CompositorNode", "CompositorNodeDistanceMatte", def_cmp_distance_matte);
@@ -14013,23 +11000,23 @@ static void rna_def_nodes(BlenderRNA *brna)
define("CompositorNode", "CompositorNodeEllipseMask", def_cmp_ellipsemask);
define("CompositorNode", "CompositorNodeExposure");
define("CompositorNode", "CompositorNodeFilter", def_cmp_filter);
define("CompositorNode", "CompositorNodeFlip", def_cmp_flip);
define("CompositorNode", "CompositorNodeFlip");
define("CompositorNode", "CompositorNodeGamma");
define("CompositorNode", "CompositorNodeGlare", def_cmp_glare);
define("CompositorNode", "CompositorNodeHueCorrect", def_cmp_huecorrect);
define("CompositorNode", "CompositorNodeHueSat");
define("CompositorNode", "CompositorNodeIDMask", def_cmp_id_mask);
define("CompositorNode", "CompositorNodeIDMask");
define("CompositorNode", "CompositorNodeImage", def_cmp_image);
define("CompositorNode", "CompositorNodeImageCoordinates");
define("CompositorNode", "CompositorNodeImageInfo");
define("CompositorNode", "CompositorNodeInpaint", def_cmp_inpaint);
define("CompositorNode", "CompositorNodeInvert", def_cmp_invert);
define("CompositorNode", "CompositorNodeInpaint");
define("CompositorNode", "CompositorNodeInvert");
define("CompositorNode", "CompositorNodeKeying", def_cmp_keying);
define("CompositorNode", "CompositorNodeKeyingScreen", def_cmp_keyingscreen);
define("CompositorNode", "CompositorNodeKuwahara", def_cmp_kuwahara);
define("CompositorNode", "CompositorNodeLensdist", def_cmp_lensdist);
define("CompositorNode", "CompositorNodeLevels", def_cmp_levels);
define("CompositorNode", "CompositorNodeLumaMatte", def_cmp_luma_matte);
define("CompositorNode", "CompositorNodeLumaMatte");
define("CompositorNode", "CompositorNodeMapRange", def_cmp_map_range);
define("CompositorNode", "CompositorNodeMapUV", def_cmp_map_uv);
define("CompositorNode", "CompositorNodeMapValue", def_cmp_map_value);
@@ -14041,7 +11028,7 @@ static void rna_def_nodes(BlenderRNA *brna)
define("CompositorNode", "CompositorNodeNormal");
define("CompositorNode", "CompositorNodeNormalize");
define("CompositorNode", "CompositorNodeOutputFile", def_cmp_output_file);
define("CompositorNode", "CompositorNodePixelate", def_cmp_pixelate);
define("CompositorNode", "CompositorNodePixelate");
define("CompositorNode", "CompositorNodePlaneTrackDeform", def_cmp_planetrackdeform);
define("CompositorNode", "CompositorNodePosterize");
define("CompositorNode", "CompositorNodePremulKey", def_cmp_premul_key);
@@ -14061,9 +11048,9 @@ static void rna_def_nodes(BlenderRNA *brna)
define("CompositorNode", "CompositorNodeSetAlpha", def_cmp_set_alpha);
define("CompositorNode", "CompositorNodeSplit", def_cmp_split);
define("CompositorNode", "CompositorNodeStabilize", def_cmp_stabilize2d);
define("CompositorNode", "CompositorNodeSunBeams", def_cmp_sunbeams);
define("CompositorNode", "CompositorNodeSwitch", def_cmp_switch);
define("CompositorNode", "CompositorNodeSwitchView", def_cmp_switch_view);
define("CompositorNode", "CompositorNodeSunBeams");
define("CompositorNode", "CompositorNodeSwitch");
define("CompositorNode", "CompositorNodeSwitchView");
define("CompositorNode", "CompositorNodeTexture", def_texture);
define("CompositorNode", "CompositorNodeTime", def_time);
define("CompositorNode", "CompositorNodeTonemap", def_cmp_tonemap);
@@ -14072,9 +11059,9 @@ static void rna_def_nodes(BlenderRNA *brna)
define("CompositorNode", "CompositorNodeTranslate", def_cmp_translate);
define("CompositorNode", "CompositorNodeValToRGB", def_colorramp);
define("CompositorNode", "CompositorNodeValue");
define("CompositorNode", "CompositorNodeVecBlur", def_cmp_vector_blur);
define("CompositorNode", "CompositorNodeVecBlur");
define("CompositorNode", "CompositorNodeViewer", def_cmp_viewer);
define("CompositorNode", "CompositorNodeZcombine", def_cmp_zcombine);
define("CompositorNode", "CompositorNodeZcombine");
define("TextureNode", "TextureNodeAt");
define("TextureNode", "TextureNodeBricks", def_tex_bricks);

2
source/blender/nodes/composite/nodes/node_composite_defocus.cc
View File

@@ -49,8 +49,6 @@ static void node_composit_init_defocus(bNodeTree * /*ntree*/, bNode *node)
NodeDefocus *nbd = MEM_callocN<NodeDefocus>(__func__);
nbd->bktype = 0;
nbd->rotation = 0.0f;
nbd->gamco = 0;
nbd->samples = 16;
nbd->fstop = 128.0f;
nbd->maxblur = 16;
nbd->scale = 1.0f;