Blender V5.3
fbx_import_material.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2025 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BKE_image.hh"
10#include "BKE_lib_id.hh"
11#include "BKE_material.hh"
13#include "BKE_node_runtime.hh"
15
16#include "BLI_math_vector.hh"
17#include "BLI_path_utils.hh"
18#include "BLI_string.hh"
19#include "BLI_string_utf8.hh"
20
21#include "DNA_material_types.h"
22
23#include "NOD_shader.h"
24
26#include "IMB_imbuf_types.hh"
27
29
30#include "ufbx.h"
31
32namespace blender::io::fbx {
33
34/* Nodes are arranged in columns by type, with manually placed x coordinates
35 * based on node widths. */
36static constexpr float node_locx_texcoord = -880.0f;
37static constexpr float node_locx_mapping = -680.0f;
38static constexpr float node_locx_image = -480.0f;
39static constexpr float node_locx_normalmap = -200.0f;
40static constexpr float node_locx_bsdf = 0.0f;
41static constexpr float node_locx_output = 280.0f;
42
43/* Nodes are arranged in rows; one row for each image being used. */
44static constexpr float node_locy_top = 300.0f;
45static constexpr float node_locy_step = 300.0f;
46
47/* Add a node of the given type at the given location. */
48static bNode *add_node(bNodeTree *ntree, int type, float x, float y)
49{
50 bNode *node = bke::node_add_static_node(nullptr, *ntree, type);
51 node->location[0] = x;
52 node->location[1] = y;
53 return node;
54}
55
56static void link_sockets(bNodeTree *ntree,
57 bNode *from_node,
58 const char *from_node_id,
59 bNode *to_node,
60 const char *to_node_id)
61{
62 bNodeSocket *from_sock{bke::node_find_socket(*from_node, SOCK_OUT, UString(from_node_id))};
63 bNodeSocket *to_sock{bke::node_find_socket(*to_node, SOCK_IN, UString(to_node_id))};
64 BLI_assert(from_sock && to_sock);
65 bke::node_add_link(*ntree, *from_node, *from_sock, *to_node, *to_sock);
66}
67
68static void set_socket_float(const char *socket_id, const float value, bNode *node)
69{
71 BLI_assert(socket && socket->type == SOCK_FLOAT);
72 bNodeSocketValueFloat *dst = socket->default_value_typed<bNodeSocketValueFloat>();
73 dst->value = value;
74}
75
76static void set_socket_rgb(const char *socket_id, float vr, float vg, float vb, bNode *node)
77{
79 BLI_assert(socket && socket->type == SOCK_RGBA);
80 bNodeSocketValueRGBA *dst = socket->default_value_typed<bNodeSocketValueRGBA>();
81 dst->value[0] = vr;
82 dst->value[1] = vg;
83 dst->value[2] = vb;
84 dst->value[3] = 1.0f;
85}
86
87static void set_socket_vector(const char *socket_id, float vx, float vy, float vz, bNode *node)
88{
90 BLI_assert(socket && socket->type == SOCK_VECTOR);
91 bNodeSocketValueVector *dst = socket->default_value_typed<bNodeSocketValueVector>();
92 dst->value[0] = vx;
93 dst->value[1] = vy;
94 dst->value[2] = vz;
95}
96
97static float set_bsdf_float_param(bNode *bsdf,
98 const ufbx_material_map &umap,
99 const char *socket,
100 float def,
101 float min = 0.0f,
102 float max = 1.0f,
103 float multiplier = 1.0f)
104{
105 if (!umap.has_value) {
106 return def * multiplier;
107 }
108 float value = umap.value_real * multiplier;
109 value = math::clamp(value, min, max);
110 set_socket_float(socket, value, bsdf);
111 return value;
112}
113
115 const ufbx_material_map &umap,
116 const char *socket,
117 float3 def,
118 float3 min = float3(0.0f),
119 float3 max = float3(1.0f))
120{
121 if (!umap.has_value || umap.value_components < 3) {
122 return def;
123 }
124 float3 value = float3(umap.value_vec3.x, umap.value_vec3.y, umap.value_vec3.z);
125 value = math::clamp(value, min, max);
126 set_socket_rgb(socket, value.x, value.y, value.z, bsdf);
127 return value;
128}
129
130static void set_bsdf_socket_values(bNode *bsdf, Material *mat, const ufbx_material &fmat)
131{
132 float3 base_color = set_bsdf_color_param(bsdf, fmat.pbr.base_color, "Base Color", float3(0.8f));
133 mat->r = base_color.x;
134 mat->g = base_color.y;
135 mat->b = base_color.z;
136
137 float roughness = set_bsdf_float_param(bsdf, fmat.pbr.roughness, "Roughness", 0.5f);
138 mat->roughness = roughness;
139
140 float metallic = set_bsdf_float_param(bsdf, fmat.pbr.metalness, "Metallic", 0.0f);
141 mat->metallic = metallic;
142
143 set_bsdf_float_param(bsdf, fmat.pbr.specular_ior, "IOR", 1.5f, 1.0f, 1000.0f);
144
145 set_bsdf_float_param(bsdf, fmat.pbr.opacity, "Alpha", 1.0f);
146
147 set_bsdf_float_param(bsdf, fmat.pbr.diffuse_roughness, "Diffuse Roughness", 0.0f);
148
149 set_bsdf_float_param(bsdf, fmat.pbr.subsurface_factor, "Subsurface Weight", 0.0f);
150 set_bsdf_float_param(bsdf, fmat.pbr.subsurface_scale, "Subsurface Scale", 0.05f);
151 set_bsdf_float_param(bsdf, fmat.pbr.subsurface_anisotropy, "Subsurface Anisotropy", 0.0f);
152
153 if (fmat.features.specular.enabled) {
154 float spec = set_bsdf_float_param(
155 bsdf, fmat.pbr.specular_factor, "Specular IOR Level", 0.25f, 0.0f, 1.0f, 2.0f);
156 mat->spec = spec;
157 set_bsdf_color_param(bsdf, fmat.pbr.specular_color, "Specular Tint", float3(1.0f));
158 set_bsdf_float_param(bsdf, fmat.pbr.specular_anisotropy, "Anisotropic", 0.0f);
159 set_bsdf_float_param(bsdf, fmat.pbr.specular_rotation, "Anisotropic Rotation", 0.0f);
160 }
161
162 if (ELEM(fmat.shader_type,
163 UFBX_SHADER_OSL_STANDARD_SURFACE,
164 UFBX_SHADER_ARNOLD_STANDARD_SURFACE,
165 UFBX_SHADER_3DS_MAX_PHYSICAL_MATERIAL,
166 UFBX_SHADER_3DS_MAX_PBR_METAL_ROUGH,
167 UFBX_SHADER_3DS_MAX_PBR_SPEC_GLOSS,
168 UFBX_SHADER_GLTF_MATERIAL,
169 UFBX_SHADER_BLENDER_PHONG) &&
170 fmat.features.transmission.enabled)
171 {
172 set_bsdf_float_param(bsdf, fmat.pbr.transmission_factor, "Transmission Weight", 0.0f);
173 }
174
175 if (fmat.features.coat.enabled) {
176 set_bsdf_float_param(bsdf, fmat.pbr.coat_factor, "Coat Weight", 0.0f);
177 set_bsdf_float_param(bsdf, fmat.pbr.coat_roughness, "Coat Roughness", 0.03f);
178 set_bsdf_float_param(bsdf, fmat.pbr.coat_ior, "Coat IOR", 1.5f, 1.0f, 4.0f);
179 set_bsdf_color_param(bsdf, fmat.pbr.coat_color, "Coat Tint", float3(1.0f));
180 }
181
182 if (fmat.features.sheen.enabled) {
183 set_bsdf_float_param(bsdf, fmat.pbr.sheen_factor, "Sheen Weight", 0.0f);
184 set_bsdf_float_param(bsdf, fmat.pbr.sheen_roughness, "Sheen Roughness", 0.5f);
185 set_bsdf_color_param(bsdf, fmat.pbr.sheen_color, "Sheen Tint", float3(1.0f));
186 }
187
189 bsdf, fmat.pbr.emission_factor, "Emission Strength", 0.0f, 0.0f, 1000000.0f);
191 fmat.pbr.emission_color,
192 "Emission Color",
193 float3(0.0f),
194 float3(0.0f),
195 float3(1000000.0f));
196
198 bsdf, fmat.pbr.thin_film_thickness, "Thin Film Thickness", 0.0f, 0.0f, 100000.0f);
199 set_bsdf_float_param(bsdf, fmat.pbr.thin_film_ior, "Thin Film IOR", 1.33f, 1.0f, 1000.0f);
200}
201
202static Image *create_placeholder_image(Main *bmain, const std::string &path)
203{
204 /* Create image without checking if it can be opened. */
205 return BKE_image_load_exists(bmain, path.c_str(), false);
206}
207
208static Image *load_texture_image(Main *bmain, const std::string &file_dir, const ufbx_texture &tex)
209{
210 /* Check with filename directly. */
211 Image *image = BKE_image_load_exists(bmain, tex.filename.data);
212 /* Try loading as a relative path. */
213 if (image == nullptr) {
214 std::string path = file_dir + "/" + tex.filename.data;
215 image = BKE_image_load_exists(bmain, path.c_str());
216 }
217 /* Try loading with absolute path from FBX. */
218 if (image == nullptr) {
219 image = BKE_image_load_exists(bmain, tex.absolute_filename.data);
220 }
221
222 /* If still not found, try taking progressively longer parts of the absolute path,
223 * as relative to the file. */
224 if (image == nullptr) {
225 size_t pos = tex.absolute_filename.length;
226 do {
227 const char *parent_path = BLI_path_parent_dir_end(tex.absolute_filename.data, pos);
228 if (parent_path == nullptr) {
229 break;
230 }
231 char path[FILE_MAX];
232 BLI_path_join(path, sizeof(path), file_dir.c_str(), parent_path);
233 BLI_path_normalize(path);
234 image = BKE_image_load_exists(bmain, path);
235 pos = parent_path - tex.absolute_filename.data;
236 } while (image == nullptr);
237 }
238
239 /* Create dummy/placeholder image. */
240 if (image == nullptr) {
241 image = create_placeholder_image(bmain, tex.filename.data);
242 }
243
244 /* Use embedded data for this image, if we haven't done that yet. */
245 if (tex.content.size > 0 && (image == nullptr || !BKE_image_has_packedfile(image))) {
246 BKE_image_free_buffers(image); /* Free cached placeholder images. */
247 char *data_dup = MEM_new_array_uninitialized<char>(tex.content.size, __func__);
248 memcpy(data_dup, tex.content.data, tex.content.size);
249 BKE_image_packfiles_from_mem(nullptr, image, data_dup, tex.content.size);
250
251 /* Make sure the image is not marked as "generated". */
252 image->source = IMA_SRC_FILE;
253 image->type = IMA_TYPE_IMAGE;
254 }
255
256 return image;
257}
258
260 ufbx_material_pbr_map slot;
261 const char *socket;
262};
264 {UFBX_MATERIAL_PBR_BASE_COLOR, "Base Color"},
265 {UFBX_MATERIAL_PBR_ROUGHNESS, "Roughness"},
266 {UFBX_MATERIAL_PBR_METALNESS, "Metallic"},
267 {UFBX_MATERIAL_PBR_DIFFUSE_ROUGHNESS, "Diffuse Roughness"},
268 {UFBX_MATERIAL_PBR_SPECULAR_FACTOR, "Specular IOR Level"},
269 {UFBX_MATERIAL_PBR_SPECULAR_COLOR, "Specular Tint"},
270 {UFBX_MATERIAL_PBR_SPECULAR_IOR, "IOR"},
271 {UFBX_MATERIAL_PBR_SPECULAR_ANISOTROPY, "Anisotropic"},
272 {UFBX_MATERIAL_PBR_SPECULAR_ROTATION, "Anisotropic Rotation"},
273 {UFBX_MATERIAL_PBR_TRANSMISSION_FACTOR, "Transmission Weight"},
274 {UFBX_MATERIAL_PBR_SUBSURFACE_FACTOR, "Subsurface Weight"},
275 {UFBX_MATERIAL_PBR_SUBSURFACE_SCALE, "Subsurface Scale"},
276 {UFBX_MATERIAL_PBR_SUBSURFACE_ANISOTROPY, "Subsurface Anisotropy"},
277 {UFBX_MATERIAL_PBR_SHEEN_FACTOR, "Sheen Weight"},
278 {UFBX_MATERIAL_PBR_SHEEN_COLOR, "Sheen Tint"},
279 {UFBX_MATERIAL_PBR_SHEEN_ROUGHNESS, "Sheen Roughness"},
280 {UFBX_MATERIAL_PBR_COAT_FACTOR, "Coat Weight"},
281 {UFBX_MATERIAL_PBR_COAT_COLOR, "Coat Tint"},
282 {UFBX_MATERIAL_PBR_COAT_ROUGHNESS, "Coat Roughness"},
283 {UFBX_MATERIAL_PBR_COAT_IOR, "Coat IOR"},
284 {UFBX_MATERIAL_PBR_COAT_NORMAL, "Coat Normal"},
285 {UFBX_MATERIAL_PBR_THIN_FILM_THICKNESS, "Thin Film Thickness"},
286 {UFBX_MATERIAL_PBR_THIN_FILM_IOR, "Thin Film IOR"},
287 {UFBX_MATERIAL_PBR_EMISSION_FACTOR, "Emission Strength"},
288 {UFBX_MATERIAL_PBR_EMISSION_COLOR, "Emission Color"},
289 {UFBX_MATERIAL_PBR_OPACITY, "Alpha"},
290 {UFBX_MATERIAL_PBR_NORMAL_MAP, "Normal"},
291 {UFBX_MATERIAL_PBR_TANGENT_MAP, "Tangent"},
292};
293
295 ufbx_material_fbx_map slot;
296 const char *socket;
297};
299 {UFBX_MATERIAL_FBX_TRANSPARENCY_FACTOR, "Alpha"},
300 {UFBX_MATERIAL_FBX_TRANSPARENCY_COLOR, "Alpha"},
301 {UFBX_MATERIAL_FBX_BUMP, "Normal"},
302 {UFBX_MATERIAL_FBX_REFLECTION_FACTOR, "Metallic"},
303};
304
305static void add_image_texture(Main *bmain,
306 const std::string &file_dir,
307 bNodeTree *ntree,
308 bNode *bsdf,
309 const ufbx_material &fmat,
310 const ufbx_texture *ftex,
311 const char *socket_name,
312 float node_locy,
313 Set<StringRefNull> &done_bsdf_inputs)
314{
315 Image *image = load_texture_image(bmain, file_dir, *ftex);
316 BLI_assert(image != nullptr);
317
318 /* Set "non-color" color space for all "data" textures. */
319 if (!STR_ELEM(
320 socket_name, "Base Color", "Specular Tint", "Sheen Tint", "Coat Tint", "Emission Color"))
321 {
323 &image->colorspace_settings,
325 }
326
327 /* Add texture node and any UV transformations if needed. */
328 bNode *image_node = add_node(ntree, SH_NODE_TEX_IMAGE, node_locx_image, node_locy);
329 BLI_assert(image_node);
330 image_node->id = &image->id;
331 NodeTexImage *tex_image = static_cast<NodeTexImage *>(image_node->storage);
332
333 /* Wrap mode. */
335 if (ftex->wrap_u == UFBX_WRAP_CLAMP || ftex->wrap_v == UFBX_WRAP_CLAMP) {
337 }
338
339 /* UV transform. */
340 if (ftex->has_uv_transform) {
341 /* TODO: which UV set to use. */
342 bNode *uvmap = add_node(ntree, SH_NODE_UVMAP, node_locx_texcoord, node_locy);
343 bNode *mapping = add_node(ntree, SH_NODE_MAPPING, node_locx_mapping, node_locy);
344 mapping->custom1 = TEXMAP_TYPE_TEXTURE;
345 set_socket_vector("Location",
346 ftex->uv_transform.translation.x,
347 ftex->uv_transform.translation.y,
348 ftex->uv_transform.translation.z,
349 mapping);
350 ufbx_vec3 rot = ufbx_quat_to_euler(ftex->uv_transform.rotation, UFBX_ROTATION_ORDER_XYZ);
351 set_socket_vector("Rotation", -rot.x, -rot.y, -rot.z, mapping);
352 set_socket_vector("Scale",
353 1.0f / ftex->uv_transform.scale.x,
354 1.0f / ftex->uv_transform.scale.y,
355 1.0f / ftex->uv_transform.scale.z,
356 mapping);
357
358 link_sockets(ntree, uvmap, "UV", mapping, "Vector");
359 link_sockets(ntree, mapping, "Vector", image_node, "Vector");
360 }
361
362 done_bsdf_inputs.add(socket_name);
363 if (STREQ(socket_name, "Normal")) {
364 bNode *normal_node = add_node(ntree, SH_NODE_NORMAL_MAP, node_locx_normalmap, node_locy);
365 link_sockets(ntree, image_node, "Color", normal_node, "Color");
366 link_sockets(ntree, normal_node, "Normal", bsdf, "Normal");
367
368 /* Normal strength: Blender exports it as BumpFactor in FBX built-in properties. */
369 float normal_strength = 1.0f;
370 if (fmat.fbx.bump_factor.has_value) {
371 normal_strength = fmat.fbx.bump_factor.value_real;
372 }
373 set_socket_float("Strength", normal_strength, normal_node);
374 }
375 else {
376 link_sockets(ntree, image_node, "Color", bsdf, socket_name);
377
378 if (STREQ(socket_name, "Base Color") && !done_bsdf_inputs.contains("Alpha")) {
379 /* Link base color alpha (if we have one) to output alpha. */
380 void *lock;
381 ImBuf *ibuf = BKE_image_acquire_ibuf(image, nullptr, &lock);
382 bool has_alpha = ibuf != nullptr && ibuf->can_contain_alpha();
384
385 if (has_alpha) {
386 link_sockets(ntree, image_node, "Alpha", bsdf, "Alpha");
387 done_bsdf_inputs.add("Alpha");
388 }
389 }
390 }
391}
392
393static void add_image_textures(Main *bmain,
394 const std::string &file_dir,
395 bNodeTree *ntree,
396 bNode *bsdf,
397 const ufbx_material &fmat)
398{
399 float node_locy = node_locy_top;
400 Set<StringRefNull> done_bsdf_inputs;
401
402 /* We primarily use images from "PBR" FBX mapping. */
403 for (const FbxPbrTextureToSocket &entry : fbx_pbr_to_socket) {
404 BLI_assert(entry.socket != nullptr);
405 if (done_bsdf_inputs.contains(entry.socket)) {
406 continue; /* Already connected. */
407 }
408
409 const ufbx_texture *ftex = fmat.pbr.maps[entry.slot].texture;
410 if (ftex == nullptr || !fmat.pbr.maps[entry.slot].texture_enabled) {
411 /* No texture used for this slot. */
412 continue;
413 }
414
416 bmain, file_dir, ntree, bsdf, fmat, ftex, entry.socket, node_locy, done_bsdf_inputs);
417 node_locy -= node_locy_step;
418 }
419
420 /* But also support several from the legacy/standard "FBX" material model,
421 * mostly to match behavior of python importer. */
422 for (const FbxStdTextureToSocket &entry : fbx_std_to_socket) {
423 BLI_assert(entry.socket != nullptr);
424 if (done_bsdf_inputs.contains(entry.socket)) {
425 continue; /* Already connected. */
426 }
427
428 const ufbx_texture *ftex = fmat.fbx.maps[entry.slot].texture;
429 if (ftex == nullptr || !fmat.fbx.maps[entry.slot].texture_enabled) {
430 /* No texture used for this slot. */
431 continue;
432 }
433
435 bmain, file_dir, ntree, bsdf, fmat, ftex, entry.socket, node_locy, done_bsdf_inputs);
436 node_locy -= node_locy_step;
437 }
438}
439
440Material *import_material(Main *bmain, const std::string &base_dir, const ufbx_material &fmat)
441{
442 Material *mat = BKE_material_add(bmain, fmat.name.data);
443 id_us_min(&mat->id);
444
445 bNodeTree *ntree = mat->nodetree;
448 set_bsdf_socket_values(bsdf, mat, fmat);
449 add_image_textures(bmain, base_dir, ntree, bsdf, fmat);
450 link_sockets(ntree, bsdf, "BSDF", output, "Surface");
452
453 mat->nodetree = ntree;
454
455 BKE_ntree_update_after_single_tree_change(*bmain, *mat->nodetree);
456
457 return mat;
458}
459
460} // namespace blender::io::fbx
General operations, lookup, etc. for materials.
#define SH_NODE_UVMAP
#define SH_NODE_TEX_IMAGE
#define SH_NODE_BSDF_PRINCIPLED
#define SH_NODE_NORMAL_MAP
#define SH_NODE_OUTPUT_MATERIAL
#define SH_NODE_MAPPING
#define FILE_MAX
#define BLI_path_join(...)
#define STR_ELEM(...)
volatile int lock
#define ELEM(...)
#define STREQ(a, b)
btScalar max
#define output
bool contains(const Key &key) const
Definition BLI_set.hh:310
bool add(const Key &key)
Definition BLI_set.hh:248
UString()=default
#define rot(x, k)
bNode * node_add_static_node(const bContext *C, bNodeTree &ntree, int type)
Definition node.cc:4283
bNodeLink & node_add_link(bNodeTree &ntree, bNode &fromnode, bNodeSocket &fromsock, bNode &tonode, bNodeSocket &tosock)
Definition node.cc:4638
bNodeSocket * node_find_socket(bNode &node, eNodeSocketInOut in_out, UString identifier)
Definition node.cc:3036
void node_set_active(bNodeTree &ntree, bNode &node)
Definition node.cc:5484
static void add_image_texture(Main *bmain, const std::string &file_dir, bNodeTree *ntree, bNode *bsdf, const ufbx_material &fmat, const ufbx_texture *ftex, const char *socket_name, float node_locy, Set< StringRefNull > &done_bsdf_inputs)
static constexpr float node_locx_bsdf
Material * import_material(Main *bmain, const std::string &base_dir, const ufbx_material &fmat)
static constexpr float node_locy_top
static float set_bsdf_float_param(bNode *bsdf, const ufbx_material_map &umap, const char *socket, float def, float min=0.0f, float max=1.0f, float multiplier=1.0f)
static void link_sockets(bNodeTree *ntree, bNode *from_node, const char *from_node_id, bNode *to_node, const char *to_node_id)
static constexpr float node_locx_image
static bNode * add_node(bNodeTree *ntree, int type, float x, float y)
static const FbxPbrTextureToSocket fbx_pbr_to_socket[]
static const FbxStdTextureToSocket fbx_std_to_socket[]
static void set_bsdf_socket_values(bNode *bsdf, Material *mat, const ufbx_material &fmat)
static Image * create_placeholder_image(Main *bmain, const std::string &path)
static float3 set_bsdf_color_param(bNode *bsdf, const ufbx_material_map &umap, const char *socket, float3 def, float3 min=float3(0.0f), float3 max=float3(1.0f))
static constexpr float node_locx_mapping
static void set_socket_rgb(const char *socket_id, float vr, float vg, float vb, bNode *node)
static void add_image_textures(Main *bmain, const std::string &file_dir, bNodeTree *ntree, bNode *bsdf, const ufbx_material &fmat)
static constexpr float node_locx_output
static void set_socket_vector(const char *socket_id, float vx, float vy, float vz, bNode *node)
static Image * load_texture_image(Main *bmain, const std::string &file_dir, const ufbx_texture &tex)
static void set_socket_float(const char *socket_id, const float value, bNode *node)
static constexpr float node_locy_step
static constexpr float node_locx_texcoord
static constexpr float node_locx_normalmap
T clamp(const T &a, const T &min, const T &max)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
const char * BLI_path_parent_dir_end(const char *path, size_t path_len) ATTR_NONNULL(1) ATTR_WARN_UNUSED_RESULT
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
@ SHD_IMAGE_EXTENSION_EXTEND
@ SHD_IMAGE_EXTENSION_REPEAT
void BKE_image_packfiles_from_mem(ReportList *reports, Image *ima, char *data, size_t data_len)
Image * BKE_image_load_exists(Main *bmain, const char *filepath, bool check_open=true, bool *r_exists=nullptr)
const char * IMB_colormanagement_role_colorspace_name_get(int role)
void IMB_colormanagement_colorspace_settings_set(ColorManagedColorspaceSettings *settings, const char *name)
void BKE_ntree_update_after_single_tree_change(Main &bmain, bNodeTree &modified_tree, const NodeTreeUpdateExtraParams &params={})
int BLI_path_normalize(char *path) ATTR_NONNULL(1)
ImBuf * BKE_image_acquire_ibuf(Image *ima, ImageUser *iuser, void **r_lock)
Material * BKE_material_add(Main *bmain, const char *name)
VecBase< float, 3 > float3
bool BKE_image_has_packedfile(const Image *image)
void BKE_image_free_buffers(Image *image)
void id_us_min(ID *id)
Definition lib_id.cc:441
void BKE_image_release_ibuf(Image *ima, ImBuf *ibuf, void *lock)
#define min(a, b)
Definition sort.cc:38
bool can_contain_alpha() const
eNodeSocketDatatype type