Blender V5.3
shader_nodes.h
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#pragma once
6
7#include "graph/node.h"
9#include "kernel/svm/types.h"
10#include "scene/image.h"
11#include "scene/shader_graph.h"
12
13#include "util/array.h"
14#include "util/string.h"
15#include "util/unique_ptr.h"
16#include "util/vector.h"
17
19
20class ImageManager;
21class LightManager;
22class Scene;
23class Shader;
24
25/* Texture Mapping */
26
28 public:
31 bool skip();
32 void compile(SVMCompiler &compiler,
33 const SVMStackOffset offset_in,
34 const SVMStackOffset offset_out,
36 int compile(SVMCompiler &compiler, ShaderInput *vector_in);
37 void compile(OSLCompiler &compiler);
38
40 void compile_end(SVMCompiler &compiler,
41 ShaderInput *vector_in,
42 const SVMStackOffset vector_offset);
43
47
50
51 enum Type { POINT = 0, TEXTURE = 1, VECTOR = 2, NORMAL = 3 };
53
54 enum Mapping { NONE = 0, X = 1, Y = 2, Z = 3 };
56
59};
60
61/* Nodes */
62
79
80/* Any node which uses image manager's slot should be a subclass of this one. */
82 public:
83 explicit ImageSlotTextureNode(const NodeType *node_type) : TextureNode(node_type)
84 {
86 }
87
88 bool equals(const ShaderNode &other) override
89 {
90 const ImageSlotTextureNode &other_node = (const ImageSlotTextureNode &)other;
91 return TextureNode::equals(other) && handle == other_node.handle;
92 }
93
94 virtual void update_images(const SVMCompiler &compiler) = 0;
95
97 {
98 update_images(compiler);
99 return need_derivatives();
100 }
101
103};
104
106 public:
108 ShaderNode *clone(ShaderGraph *graph) const override;
109 void attributes(Shader *shader, AttributeRequestSet *attributes) override;
111 {
112 return true;
113 }
114
115 bool equals(const ShaderNode &other) override
116 {
117 const ImageTextureNode &other_node = (const ImageTextureNode &)other;
118 return ImageSlotTextureNode::equals(other) && animated == other_node.animated;
119 }
120
122
123 void update_images(const SVMCompiler &compiler) override;
124
125 ShaderNodeType shader_node_type() const override;
126
127 /* Parameters. */
128 NODE_SOCKET_API(ustring, filename)
132 NODE_SOCKET_API(InterpolationType, interpolation)
134 NODE_SOCKET_API(float, projection_blend)
135 NODE_SOCKET_API(bool, animated)
137 NODE_SOCKET_API(float3, missing)
138 NODE_SOCKET_API(float, missing_alpha)
140
141 protected:
142 void cull_tiles(Scene *scene, ShaderGraph *graph);
143};
144
146 public:
148 ShaderNode *clone(ShaderGraph *graph) const override;
149 void attributes(Shader *shader, AttributeRequestSet *attributes) override;
151 {
152 return true;
153 }
154
155 bool equals(const ShaderNode &other) override
156 {
157 const EnvironmentTextureNode &other_node = (const EnvironmentTextureNode &)other;
158 return ImageSlotTextureNode::equals(other) && animated == other_node.animated;
159 }
160
162
163 void update_images(const SVMCompiler &compiler) override;
164
166 {
167 return NODE_TEX_ENVIRONMENT;
168 }
169
170 /* Parameters. */
171 NODE_SOCKET_API(ustring, filename)
175 NODE_SOCKET_API(InterpolationType, interpolation)
176 NODE_SOCKET_API(bool, animated)
178 NODE_SOCKET_API(float3, missing)
179 NODE_SOCKET_API(float, missing_alpha)
180};
181
183 public:
185
188 NODE_SOCKET_API(float, turbidity)
189 NODE_SOCKET_API(float, ground_albedo)
190 NODE_SOCKET_API(bool, sun_disc)
191 NODE_SOCKET_API(float, sun_size)
192 NODE_SOCKET_API(float, sun_intensity)
193 NODE_SOCKET_API(float, sun_elevation)
194 NODE_SOCKET_API(float, sun_rotation)
195 NODE_SOCKET_API(float, altitude)
196 NODE_SOCKET_API(float, air_density)
197 NODE_SOCKET_API(float, aerosol_density)
198 NODE_SOCKET_API(float, ozone_density)
201
202 void simplify_settings(Scene *scene) override;
203
205 {
206 /* Clamping for numerical precision. */
207 return fmaxf(sun_size, 0.0005f);
208 }
209
211};
212
213class OutputNode : public ShaderNode {
214 public:
216
217 NODE_SOCKET_API(Node *, surface)
218 NODE_SOCKET_API(Node *, volume)
219 NODE_SOCKET_API(float3, displacement)
220 NODE_SOCKET_API(float3, normal)
221
222 /* Don't allow output node de-duplication. */
223 bool equals(const ShaderNode & /*other*/) override
224 {
225 return false;
226 }
227
228 bool is_linear_operation() override
229 {
230 return true;
231 }
232};
233
234class OutputAOVNode : public ShaderNode {
235 public:
237 void simplify_settings(Scene *scene) override;
238
239 NODE_SOCKET_API(float, value)
240 NODE_SOCKET_API(float3, color)
241
242 NODE_SOCKET_API(ustring, name)
243
244 /* Don't allow output node de-duplication. */
245 bool equals(const ShaderNode & /*other*/) override
246 {
247 return false;
248 }
249
250 bool is_linear_operation() override
251 {
252 return true;
253 }
254
257};
258
266
268 public:
270
271 NODE_SOCKET_API(int, dimensions)
273 NODE_SOCKET_API(bool, use_normalize)
274 NODE_SOCKET_API(float, w)
275 NODE_SOCKET_API(float, scale)
276 NODE_SOCKET_API(float, detail)
277 NODE_SOCKET_API(float, roughness)
278 NODE_SOCKET_API(float, lacunarity)
279 NODE_SOCKET_API(float, offset)
280 NODE_SOCKET_API(float, gain)
281 NODE_SOCKET_API(float, distortion)
283};
284
286 public:
288
291 NODE_SOCKET_API(float, scale)
293 NODE_SOCKET_API(float, anisotropy)
294 NODE_SOCKET_API(float, orientation_2d)
295 NODE_SOCKET_API(float3, orientation_3d)
296};
297
299 public:
301
303 {
305 if (dimensions == 4) {
307 }
308 else if (dimensions >= 2 && feature == NODE_VORONOI_SMOOTH_F1) {
310 }
311 return result;
312 }
313
314 NODE_SOCKET_API(int, dimensions)
317 NODE_SOCKET_API(bool, use_normalize)
318 NODE_SOCKET_API(float, w)
319 NODE_SOCKET_API(float, scale)
320 NODE_SOCKET_API(float, detail)
321 NODE_SOCKET_API(float, roughness)
322 NODE_SOCKET_API(float, lacunarity)
323 NODE_SOCKET_API(float, exponent)
324 NODE_SOCKET_API(float, smoothness)
325 NODE_SOCKET_API(float, randomness)
327};
328
330 public:
332
333 NODE_SOCKET_API(NodeWaveType, wave_type)
337
338 NODE_SOCKET_API(float, scale)
339 NODE_SOCKET_API(float, distortion)
340 NODE_SOCKET_API(float, detail)
341 NODE_SOCKET_API(float, detail_scale)
342 NODE_SOCKET_API(float, detail_roughness)
343 NODE_SOCKET_API(float, phase)
345};
346
348 public:
350
351 NODE_SOCKET_API(int, depth)
353 NODE_SOCKET_API(float, scale)
354 NODE_SOCKET_API(float, distortion)
355};
356
366
368 public:
370
371 NODE_SOCKET_API(float, offset)
372 NODE_SOCKET_API(float, squash)
373 NODE_SOCKET_API(int, offset_frequency)
374 NODE_SOCKET_API(int, squash_frequency)
375
376 NODE_SOCKET_API(float3, color1)
377 NODE_SOCKET_API(float3, color2)
378 NODE_SOCKET_API(float3, mortar)
379 NODE_SOCKET_API(float, scale)
380 NODE_SOCKET_API(float, mortar_size)
381 NODE_SOCKET_API(float, mortar_smooth)
382 NODE_SOCKET_API(float, bias)
383 NODE_SOCKET_API(float, brick_width)
384 NODE_SOCKET_API(float, row_height)
386};
387
388class IESLightNode : public TextureNode {
389 public:
391
392 ~IESLightNode() override;
393 ShaderNode *clone(ShaderGraph *graph) const override;
394
395 NODE_SOCKET_API(ustring, filename)
396 NODE_SOCKET_API(ustring, ies)
397
398 NODE_SOCKET_API(float, strength)
400
401 private:
402 LightManager *light_manager;
403 int slot;
404
405 void get_slot();
406};
407
409 public:
411
412 NODE_SOCKET_API(int, dimensions)
414 NODE_SOCKET_API(float, w)
415};
416
417class MappingNode : public ShaderNode {
418 public:
420 void constant_fold(const ConstantFolder &folder) override;
422 {
423 return NODE_MAPPING;
424 }
425
427 NODE_SOCKET_API(float3, location)
428 NODE_SOCKET_API(float3, rotation)
430 NODE_SOCKET_API(NodeMappingType, mapping_type)
431};
432
433class RGBToBWNode : public ShaderNode {
434 public:
436 void constant_fold(const ConstantFolder &folder) override;
437 bool is_linear_operation() override
438 {
439 return true;
440 }
442 {
443 return NODE_CONVERT;
444 }
445
446 NODE_SOCKET_API(float3, color)
447};
448
449class ConvertNode : public ShaderNode {
450 public:
451 ConvertNode(SocketType::Type from, SocketType::Type to, bool autoconvert = false);
452 ConvertNode(const ConvertNode &other);
454
455 void constant_fold(const ConstantFolder &folder) override;
456 bool is_linear_operation() override
457 {
458 return true;
459 }
462 {
463 return NODE_CONVERT;
464 }
465
466 private:
467 SocketType::Type from, to;
468
469 union {
470 float value_float;
471 int value_int;
472 float3 value_color;
473 float3 value_vector;
474 float3 value_point;
475 float3 value_normal;
476 };
477 ustring value_string;
478
479 static const int MAX_TYPE = 13;
480 static unique_ptr<Node> create(const NodeType *type);
481 static const NodeType *(&get_node_types())[MAX_TYPE][MAX_TYPE];
482 static bool register_on_init;
483};
484
485class BsdfBaseNode : public ShaderNode {
486 public:
487 BsdfBaseNode(const NodeType *node_type);
488
489 bool is_linear_operation() override
490 {
491 return true;
492 }
493 bool has_spatial_varying() override
494 {
495 return true;
496 }
498 {
499 return closure;
500 }
501 bool has_bump() override;
502
503 bool equals(const ShaderNode & /*other*/) override
504 {
505 /* TODO(sergey): With some care BSDF nodes can be de-duplicated. */
506 return false;
507 }
508
513
515 {
516 return NODE_CLOSURE_BSDF;
517 }
518
519 protected:
521};
522
523class BsdfNode : public BsdfBaseNode {
524 public:
525 explicit BsdfNode(const NodeType *node_type);
527
528 template<typename T> void compile(SVMCompiler &compiler, const T &data);
529
530 NODE_SOCKET_API(float3, color)
531 NODE_SOCKET_API(float3, normal)
532 NODE_SOCKET_API(float, surface_mix_weight)
533};
534
535class DiffuseBsdfNode : public BsdfNode {
536 public:
538 bool is_linear_operation() override
539 {
540 return true;
541 }
542
543 NODE_SOCKET_API(float, roughness)
544};
545
546/* Disney principled BRDF */
548 public:
550
551 bool is_thin_wall();
553 bool has_surface_bssrdf() override;
554 bool has_bssrdf_bump() override;
555 void simplify_settings(Scene *scene) override;
556
557 NODE_SOCKET_API(float3, base_color)
558 NODE_SOCKET_API(float, metallic)
559 NODE_SOCKET_API(float, roughness)
560 NODE_SOCKET_API(float, ior)
561 NODE_SOCKET_API(int, thin_wall)
562 NODE_SOCKET_API(float3, normal)
563 NODE_SOCKET_API(float, alpha)
564 NODE_SOCKET_API(float, diffuse_roughness)
565 NODE_SOCKET_API(ClosureType, subsurface_method)
566 NODE_SOCKET_API(float, subsurface_weight)
567 NODE_SOCKET_API(float3, subsurface_radius)
568 NODE_SOCKET_API(float, subsurface_scale)
569 NODE_SOCKET_API(float, subsurface_ior)
570 NODE_SOCKET_API(float, subsurface_anisotropy)
571 NODE_SOCKET_API(ClosureType, distribution)
572 NODE_SOCKET_API(float, specular_ior_level)
573 NODE_SOCKET_API(float3, specular_tint)
574 NODE_SOCKET_API(float, anisotropic)
575 NODE_SOCKET_API(float, anisotropic_rotation)
576 NODE_SOCKET_API(float3, tangent)
577 NODE_SOCKET_API(float, transmission_weight)
578 NODE_SOCKET_API(float, transmission_dispersion_scale)
579 NODE_SOCKET_API(float, transmission_dispersion_abbe_number)
580 NODE_SOCKET_API(float, sheen_weight)
581 NODE_SOCKET_API(float, sheen_roughness)
582 NODE_SOCKET_API(float3, sheen_tint)
583 NODE_SOCKET_API(float, coat_weight)
584 NODE_SOCKET_API(float, coat_roughness)
585 NODE_SOCKET_API(float, coat_ior)
586 NODE_SOCKET_API(float3, coat_tint)
587 NODE_SOCKET_API(float3, coat_normal)
588 NODE_SOCKET_API(float3, emission_color)
589 NODE_SOCKET_API(float, emission_strength)
590 NODE_SOCKET_API(float, surface_mix_weight)
591 NODE_SOCKET_API(float, thin_film_thickness)
592 NODE_SOCKET_API(float, thin_film_ior)
593
594 public:
595 void attributes(Shader *shader, AttributeRequestSet *attributes) override;
597 {
598 return true;
599 }
600 bool has_surface_transparent() override;
601 bool has_surface_emission() override;
602 bool has_dispersion() override;
603
604 protected:
605 /* Checks whether the given weight input is potentially non-zero. */
606 bool has_nonzero_weight(const char *name);
607};
608
613
615 public:
617
619 {
620 return true;
621 }
622};
623
625 public:
627
629 NODE_SOCKET_API(float3, direction)
630
632 {
633 return true;
634 }
635
640};
641
642class SheenBsdfNode : public BsdfNode {
643 public:
645
646 NODE_SOCKET_API(float, roughness)
647 NODE_SOCKET_API(ClosureType, distribution)
648
650 {
651 return distribution;
652 }
653};
654
656 public:
658
659 void simplify_settings(Scene *scene) override;
661 {
662 return closure;
663 }
664
665 NODE_SOCKET_API(float3, edge_tint)
668 NODE_SOCKET_API(float3, tangent)
669 NODE_SOCKET_API(float, roughness)
670 NODE_SOCKET_API(float, anisotropy)
671 NODE_SOCKET_API(float, rotation)
672 NODE_SOCKET_API(float, thin_film_thickness)
673 NODE_SOCKET_API(float, thin_film_ior)
674 NODE_SOCKET_API(ClosureType, distribution)
675 NODE_SOCKET_API(ClosureType, fresnel_type)
676
677 void attributes(Shader *shader, AttributeRequestSet *attributes) override;
679 {
680 return true;
681 }
682
683 bool is_isotropic();
684};
685
686class GlossyBsdfNode : public BsdfNode {
687 public:
689
690 void simplify_settings(Scene *scene) override;
692 {
693 return distribution;
694 }
695
696 NODE_SOCKET_API(float3, tangent)
697 NODE_SOCKET_API(float, roughness)
698 NODE_SOCKET_API(float, anisotropy)
699 NODE_SOCKET_API(float, rotation)
700 NODE_SOCKET_API(ClosureType, distribution)
701
702 void attributes(Shader *shader, AttributeRequestSet *attributes) override;
704 {
705 return true;
706 }
707
708 bool is_isotropic();
709};
710
711class GlassBsdfNode : public BsdfNode {
712 public:
714
715 void simplify_settings(Scene *scene) override;
717 {
718 return distribution;
719 }
720
721 NODE_SOCKET_API(float3, tangent)
722 NODE_SOCKET_API(float, roughness)
723 NODE_SOCKET_API(float, anisotropy)
724 NODE_SOCKET_API(float, rotation)
725 NODE_SOCKET_API(float, IOR)
726 NODE_SOCKET_API(float, thin_film_thickness)
727 NODE_SOCKET_API(float, thin_film_ior)
728 NODE_SOCKET_API(ClosureType, distribution)
729
730 void attributes(Shader *shader, AttributeRequestSet *attributes) override;
732 {
733 return true;
734 }
735
736 bool is_isotropic();
737};
738
740 public:
742
744 {
745 return distribution;
746 }
747
748 NODE_SOCKET_API(float, roughness)
749 NODE_SOCKET_API(float, IOR)
750 NODE_SOCKET_API(ClosureType, distribution)
751};
752
753class ToonBsdfNode : public BsdfNode {
754 public:
756
757 NODE_SOCKET_API(float, smooth)
758 NODE_SOCKET_API(float, size)
759 NODE_SOCKET_API(ClosureType, component)
760};
761
763 public:
765 bool has_surface_bssrdf() override
766 {
767 return true;
768 }
769 bool has_bssrdf_bump() override;
771 {
772 return method;
773 }
774
775 NODE_SOCKET_API(float, scale)
776 NODE_SOCKET_API(float3, radius)
777 NODE_SOCKET_API(float, subsurface_ior)
778 NODE_SOCKET_API(float, subsurface_roughness)
779 NODE_SOCKET_API(float, subsurface_anisotropy)
781};
782
783class EmissionNode : public ShaderNode {
784 public:
786 void constant_fold(const ConstantFolder &folder) override;
787
788 bool has_surface_emission() override
789 {
790 return true;
791 }
792 bool has_volume_support() override
793 {
794 return true;
795 }
796 bool is_linear_operation() override
797 {
798 return true;
799 }
800
805
806 NODE_SOCKET_API(float3, color)
807 NODE_SOCKET_API(float, strength)
808 NODE_SOCKET_API(float, surface_mix_weight)
809 NODE_SOCKET_API(float, volume_mix_weight)
810
812};
813
815 public:
817 void constant_fold(const ConstantFolder &folder) override;
818 bool is_linear_operation() override
819 {
820 return true;
821 }
822
827
828 NODE_SOCKET_API(float3, color)
829 NODE_SOCKET_API(float, strength)
830 NODE_SOCKET_API(float, surface_mix_weight)
831};
832
833class HoldoutNode : public ShaderNode {
834 public:
837 {
838 return CLOSURE_HOLDOUT_ID;
839 }
840 bool is_linear_operation() override
841 {
842 return true;
843 }
844
845 NODE_SOCKET_API(float, surface_mix_weight)
846 NODE_SOCKET_API(float, volume_mix_weight)
847};
848
850 public:
852
853 bool has_spatial_varying() override
854 {
855 return true;
856 }
858 {
860 }
861
862 NODE_SOCKET_API(float3, color)
864 NODE_SOCKET_API(float3, normal)
865 NODE_SOCKET_API(int, samples)
866
867 NODE_SOCKET_API(bool, only_local)
868 NODE_SOCKET_API(bool, inside)
869};
870
871class VolumeNode : public ShaderNode {
872 public:
873 VolumeNode(const NodeType *node_type);
875 bool is_linear_operation() override
876 {
877 return true;
878 }
879
880 void compile(SVMCompiler &compiler,
881 ShaderInput *density,
882 ShaderInput *param1 = nullptr,
883 ShaderInput *param2 = nullptr);
889 {
890 return closure;
891 }
892 bool has_volume_support() override
893 {
894 return true;
895 }
896
897 NODE_SOCKET_API(float3, color)
898 NODE_SOCKET_API(float, density)
899 NODE_SOCKET_API(float, volume_mix_weight)
900
901 protected:
903
904 public:
905 bool equals(const ShaderNode & /*other*/) override
906 {
907 /* TODO(sergey): With some care Volume nodes can be de-duplicated. */
908 return false;
909 }
910};
911
916
918 public:
919 ScatterVolumeNode(const NodeType *node_type);
921
922 NODE_SOCKET_API(float, anisotropy)
923 NODE_SOCKET_API(float, IOR)
924 NODE_SOCKET_API(float, backscatter)
925 NODE_SOCKET_API(float, alpha)
926 NODE_SOCKET_API(float, diameter)
928};
929
931 public:
933
934 NODE_SOCKET_API(float3, scatter_coeffs)
935 NODE_SOCKET_API(float3, absorption_coeffs)
936 NODE_SOCKET_API(float3, emission_coeffs)
937};
938
940 public:
942 void attributes(Shader *shader, AttributeRequestSet *attributes) override;
944 {
945 return true;
946 }
947
948 NODE_SOCKET_API(ustring, density_attribute)
949 NODE_SOCKET_API(ustring, color_attribute)
950 NODE_SOCKET_API(ustring, temperature_attribute)
951
952 NODE_SOCKET_API(float, anisotropy)
953 NODE_SOCKET_API(float3, absorption_color)
954 NODE_SOCKET_API(float, emission_strength)
955 NODE_SOCKET_API(float3, emission_color)
956 NODE_SOCKET_API(float, blackbody_intensity)
957 NODE_SOCKET_API(float3, blackbody_tint)
958 NODE_SOCKET_API(float, temperature)
959};
960
961/* Interface between the I/O sockets and the SVM/OSL backend. */
963 public:
965 void attributes(Shader *shader, AttributeRequestSet *attributes) override;
966
967 /* Longitudinal roughness. */
968 NODE_SOCKET_API(float, roughness)
969 /* Azimuthal roughness. */
970 NODE_SOCKET_API(float, radial_roughness)
971 /* Randomization factor for roughnesses. */
972 NODE_SOCKET_API(float, random_roughness)
973 /* Longitudinal roughness factor for only the diffuse bounce (shiny undercoat). */
974 NODE_SOCKET_API(float, coat)
975 /* Index of reflection. */
976 NODE_SOCKET_API(float, ior)
977 /* Cuticle tilt angle. */
978 NODE_SOCKET_API(float, offset)
979 /* Direct coloring's color. */
980 NODE_SOCKET_API(float3, color)
981 /* Melanin concentration. */
982 NODE_SOCKET_API(float, melanin)
983 /* Melanin redness ratio. */
984 NODE_SOCKET_API(float, melanin_redness)
985 /* Dye color. */
987 /* Randomization factor for melanin quantities. */
988 NODE_SOCKET_API(float, random_color)
989 /* Absorption coefficient (unfiltered). */
990 NODE_SOCKET_API(float3, absorption_coefficient)
991
992 /* Aspect Ratio. */
993 NODE_SOCKET_API(float, aspect_ratio)
994
995 /* Optional modulation factors for the lobes. */
996 NODE_SOCKET_API(float, R)
997 NODE_SOCKET_API(float, TT)
998 NODE_SOCKET_API(float, TRT)
999
1000 /* Weight for mix shader. */
1001 NODE_SOCKET_API(float, surface_mix_weight)
1002 /* If linked, here will be the given random number. */
1003 NODE_SOCKET_API(float, random)
1004 /* Selected coloring parametrization. */
1006 /* Selected scattering model (chiang/huang). */
1008
1013
1014 bool has_surface_transparent() override;
1015};
1016
1017class HairBsdfNode : public BsdfNode {
1018 public:
1021 {
1022 return component;
1023 }
1024
1025 NODE_SOCKET_API(ClosureType, component)
1026 NODE_SOCKET_API(float, offset)
1027 NODE_SOCKET_API(float, roughness_u)
1028 NODE_SOCKET_API(float, roughness_v)
1029 NODE_SOCKET_API(float3, tangent)
1030};
1031
1032class GeometryNode : public ShaderNode {
1033 public:
1035 void attributes(Shader *shader, AttributeRequestSet *attributes) override;
1037 {
1038 return true;
1039 }
1040 bool has_spatial_varying() override
1041 {
1042 return true;
1043 }
1045 ShaderNodeType shader_node_type() const override;
1046};
1047
1049 public:
1051 void attributes(Shader *shader, AttributeRequestSet *attributes) override;
1053 {
1054 return true;
1055 }
1056 bool has_spatial_varying() override
1057 {
1058 return true;
1059 }
1060 ShaderNodeType shader_node_type() const override;
1061
1062 NODE_SOCKET_API(bool, from_dupli)
1063 NODE_SOCKET_API(bool, use_transform)
1064 NODE_SOCKET_API(Transform, ob_tfm)
1065};
1066
1067class UVMapNode : public ShaderNode {
1068 public:
1070 void attributes(Shader *shader, AttributeRequestSet *attributes) override;
1072 {
1073 return true;
1074 }
1075 bool has_spatial_varying() override
1076 {
1077 return true;
1078 }
1079 ShaderNodeType shader_node_type() const override;
1080
1081 NODE_SOCKET_API(ustring, attribute)
1082 NODE_SOCKET_API(bool, from_dupli)
1083};
1084
1086 public:
1088};
1089
1091 public:
1093 bool has_spatial_varying() override
1094 {
1095 return true;
1096 }
1097
1098 NODE_SOCKET_API(float, strength)
1099 NODE_SOCKET_API(float, smooth)
1100};
1101
1103 public:
1105};
1106
1108 public:
1110 void attributes(Shader *shader, AttributeRequestSet *attributes) override;
1112 {
1113 return true;
1114 }
1115};
1116
1117class HairInfoNode : public ShaderNode {
1118 public:
1120
1121 void attributes(Shader *shader, AttributeRequestSet *attributes) override;
1123 {
1124 return true;
1125 }
1126 bool has_spatial_varying() override
1127 {
1128 return true;
1129 }
1130};
1131
1133 public:
1135
1136 void attributes(Shader *shader, AttributeRequestSet *attributes) override;
1138 {
1139 return true;
1140 }
1141 bool has_spatial_varying() override
1142 {
1143 return true;
1144 }
1145};
1146
1148 public:
1150 void attributes(Shader *shader, AttributeRequestSet *attributes) override;
1152 {
1153 return true;
1154 }
1155 bool has_spatial_varying() override
1156 {
1157 return true;
1158 }
1159 void expand(ShaderGraph *graph) override;
1160};
1161
1163 public:
1165 void attributes(Shader *shader, AttributeRequestSet *attributes) override;
1167 {
1168 return true;
1169 }
1170 bool has_spatial_varying() override
1171 {
1172 return true;
1173 }
1174 void expand(ShaderGraph *graph) override;
1175
1176 NODE_SOCKET_API(ustring, layer_name)
1177};
1178
1179class ValueNode : public ShaderNode {
1180 public:
1182
1183 void constant_fold(const ConstantFolder &folder) override;
1184 bool is_linear_operation() override
1185 {
1186 return true;
1187 }
1188
1189 NODE_SOCKET_API(float, value)
1190};
1191
1192class ColorNode : public ShaderNode {
1193 public:
1195
1196 void constant_fold(const ConstantFolder &folder) override;
1197 bool is_linear_operation() override
1198 {
1199 return true;
1200 }
1201
1202 NODE_SOCKET_API(float3, value)
1203};
1204
1206 public:
1208 void constant_fold(const ConstantFolder &folder) override;
1209 bool is_linear_operation() override
1210 {
1211 return true;
1212 }
1213};
1214
1216 public:
1218 void constant_fold(const ConstantFolder &folder) override;
1219 bool is_linear_operation() override
1220 {
1221 return true;
1222 }
1223
1224 NODE_SOCKET_API(float, fac)
1225};
1226
1228 public:
1230 bool is_linear_operation() override
1231 {
1232 return true;
1233 }
1234
1235 NODE_SOCKET_API(float, weight)
1236 NODE_SOCKET_API(float, fac)
1237};
1238
1239class InvertNode : public ShaderNode {
1240 public:
1242 void constant_fold(const ConstantFolder &folder) override;
1243
1244 NODE_SOCKET_API(float, fac)
1245 NODE_SOCKET_API(float3, color)
1246
1247 bool is_linear_operation() override
1248 {
1249 return true;
1250 }
1251};
1252
1253class MixNode : public ShaderNode {
1254 public:
1256 void constant_fold(const ConstantFolder &folder) override;
1257 bool is_linear_operation() override;
1258
1259 NODE_SOCKET_API(NodeMix, mix_type)
1260 NODE_SOCKET_API(bool, use_clamp)
1261 NODE_SOCKET_API(float3, color1)
1262 NODE_SOCKET_API(float3, color2)
1263 NODE_SOCKET_API(float, fac)
1264};
1265
1266class MixColorNode : public ShaderNode {
1267 public:
1269 void constant_fold(const ConstantFolder &folder) override;
1270 bool is_linear_operation() override;
1271
1274 NODE_SOCKET_API(float, fac)
1275 NODE_SOCKET_API(bool, use_clamp)
1276 NODE_SOCKET_API(bool, use_clamp_result)
1277 NODE_SOCKET_API(NodeMix, blend_type)
1278};
1279
1280class MixFloatNode : public ShaderNode {
1281 public:
1283 void constant_fold(const ConstantFolder &folder) override;
1284 bool is_linear_operation() override;
1285
1286 NODE_SOCKET_API(float, a)
1287 NODE_SOCKET_API(float, b)
1288 NODE_SOCKET_API(float, fac)
1289 NODE_SOCKET_API(bool, use_clamp)
1290};
1291
1293 public:
1295 void constant_fold(const ConstantFolder &folder) override;
1296 bool is_linear_operation() override;
1297
1300 NODE_SOCKET_API(float, fac)
1301 NODE_SOCKET_API(bool, use_clamp)
1302};
1303
1305 public:
1307 void constant_fold(const ConstantFolder &folder) override;
1308 bool is_linear_operation() override;
1309
1313 NODE_SOCKET_API(bool, use_clamp)
1314};
1315
1317 public:
1319 void constant_fold(const ConstantFolder &folder) override;
1320 bool is_linear_operation() override
1321 {
1322 return true;
1323 }
1324
1326 NODE_SOCKET_API(float, r)
1327 NODE_SOCKET_API(float, g)
1328 NODE_SOCKET_API(float, b)
1329};
1330
1332 public:
1334 void constant_fold(const ConstantFolder &folder) override;
1335 bool is_linear_operation() override
1336 {
1337 return true;
1338 }
1340 {
1341 return NODE_COMBINE_VECTOR;
1342 }
1343
1344 NODE_SOCKET_API(float, x)
1345 NODE_SOCKET_API(float, y)
1346 NODE_SOCKET_API(float, z)
1347};
1348
1349class GammaNode : public ShaderNode {
1350 public:
1352 void constant_fold(const ConstantFolder &folder) override;
1353
1354 NODE_SOCKET_API(float3, color)
1355 NODE_SOCKET_API(float, gamma)
1356};
1357
1359 public:
1361 void constant_fold(const ConstantFolder &folder) override;
1362
1363 NODE_SOCKET_API(float3, color)
1364 NODE_SOCKET_API(float, bright)
1365 NODE_SOCKET_API(float, contrast)
1366};
1367
1369 public:
1371 void constant_fold(const ConstantFolder &folder) override;
1372 bool is_linear_operation() override
1373 {
1374 return true;
1375 }
1376
1378 NODE_SOCKET_API(float3, color)
1379};
1380
1382 public:
1384 void constant_fold(const ConstantFolder &folder) override;
1385 bool is_linear_operation() override
1386 {
1387 return true;
1388 }
1390 {
1391 return NODE_SEPARATE_VECTOR;
1392 }
1393
1395};
1396
1398 public:
1400 void constant_fold(const ConstantFolder &folder) override;
1402 {
1403 return NODE_GET_VECTOR_COMPONENT;
1404 }
1405
1408};
1409
1410class HSVNode : public ShaderNode {
1411 public:
1413
1414 NODE_SOCKET_API(float, hue)
1415 NODE_SOCKET_API(float, saturation)
1416 NODE_SOCKET_API(float, value)
1417 NODE_SOCKET_API(float, fac)
1418 NODE_SOCKET_API(float3, color)
1419};
1420
1422 public:
1424 void attributes(Shader *shader, AttributeRequestSet *attributes) override;
1426 {
1427 return true;
1428 }
1429 bool has_spatial_varying() override
1430 {
1431 return true;
1432 }
1433 ShaderNodeType shader_node_type() const override;
1434
1435 NODE_SOCKET_API(ustring, attribute)
1436 NODE_SOCKET_API(float3, missing)
1437 NODE_SOCKET_API(float, missing_alpha)
1438
1440};
1441
1442class CameraNode : public ShaderNode {
1443 public:
1445 bool has_spatial_varying() override
1446 {
1447 return true;
1448 }
1449};
1450
1451class FresnelNode : public ShaderNode {
1452 public:
1454 bool has_spatial_varying() override
1455 {
1456 return true;
1457 }
1458
1459 NODE_SOCKET_API(float3, normal)
1460 NODE_SOCKET_API(float, IOR)
1461};
1462
1464 public:
1466 bool has_spatial_varying() override
1467 {
1468 return true;
1469 }
1470
1471 NODE_SOCKET_API(float3, normal)
1472 NODE_SOCKET_API(float, blend)
1473};
1474
1476 public:
1478 bool has_spatial_varying() override
1479 {
1480 return true;
1481 }
1482
1483 NODE_SOCKET_API(float, size)
1484 NODE_SOCKET_API(bool, use_pixel_size)
1485};
1486
1488 public:
1490
1491 NODE_SOCKET_API(float, wavelength)
1492};
1493
1495 public:
1497 void constant_fold(const ConstantFolder &folder) override;
1498
1499 NODE_SOCKET_API(float, temperature)
1500};
1501
1503 public:
1505 void expand(ShaderGraph *graph) override;
1506 bool is_linear_operation() override;
1507
1509 NODE_SOCKET_API(float3, from_min)
1510 NODE_SOCKET_API(float3, from_max)
1511 NODE_SOCKET_API(float3, to_min)
1512 NODE_SOCKET_API(float3, to_max)
1513 NODE_SOCKET_API(float3, steps)
1515 NODE_SOCKET_API(bool, use_clamp)
1516};
1517
1518class MapRangeNode : public ShaderNode {
1519 public:
1521 void expand(ShaderGraph *graph) override;
1522 bool is_linear_operation() override;
1523
1524 NODE_SOCKET_API(float, value)
1525 NODE_SOCKET_API(float, from_min)
1526 NODE_SOCKET_API(float, from_max)
1527 NODE_SOCKET_API(float, to_min)
1528 NODE_SOCKET_API(float, to_max)
1529 NODE_SOCKET_API(float, steps)
1531 NODE_SOCKET_API(bool, clamp)
1532};
1533
1534class ClampNode : public ShaderNode {
1535 public:
1537 void constant_fold(const ConstantFolder &folder) override;
1538 NODE_SOCKET_API(float, value)
1539 NODE_SOCKET_API(float, min)
1540 NODE_SOCKET_API(float, max)
1541 NODE_SOCKET_API(NodeClampType, clamp_type)
1542};
1543
1544class MathNode : public ShaderNode {
1545 public:
1547 void expand(ShaderGraph *graph) override;
1548 void constant_fold(const ConstantFolder &folder) override;
1549 bool is_linear_operation() override;
1550
1551 NODE_SOCKET_API(float, value1)
1552 NODE_SOCKET_API(float, value2)
1553 NODE_SOCKET_API(float, value3)
1554 NODE_SOCKET_API(NodeMathType, math_type)
1555 NODE_SOCKET_API(bool, use_clamp)
1556};
1557
1559 public:
1561 void constant_fold(const ConstantFolder &folder) override;
1562
1563 NODE_SOCKET_API(int, boolean1)
1564 NODE_SOCKET_API(int, boolean2)
1566};
1567
1569 public:
1571 void constant_fold(const ConstantFolder &folder) override;
1572
1573 NODE_SOCKET_API(int, value1)
1574 NODE_SOCKET_API(int, value2)
1575 NODE_SOCKET_API(int, value3)
1577};
1578
1579class NormalNode : public ShaderNode {
1580 public:
1582 bool is_linear_operation() override
1583 {
1584 return true;
1585 }
1586
1587 NODE_SOCKET_API(float3, direction)
1588 NODE_SOCKET_API(float3, normal)
1589};
1590
1592 public:
1594 void constant_fold(const ConstantFolder &folder) override;
1595 bool is_linear_operation() override;
1597 {
1598 return NODE_VECTOR_MATH;
1599 }
1600
1601 NODE_SOCKET_API(float3, vector1)
1602 NODE_SOCKET_API(float3, vector2)
1604 NODE_SOCKET_API(float, scale)
1606};
1607
1609 public:
1611
1613 NODE_SOCKET_API(bool, invert)
1615 NODE_SOCKET_API(float3, center)
1616 NODE_SOCKET_API(float3, axis)
1617 NODE_SOCKET_API(float, angle)
1618 NODE_SOCKET_API(float3, rotation)
1619
1621 {
1622 return NODE_VECTOR_ROTATE;
1623 }
1624};
1625
1627 public:
1629
1634
1636 {
1637 return NODE_VECTOR_TRANSFORM;
1638 }
1639};
1640
1641class BumpNode : public ShaderNode {
1642 public:
1644 void constant_fold(const ConstantFolder &folder) override;
1645 bool has_spatial_varying() override
1646 {
1647 return true;
1648 }
1650 {
1652 }
1653
1654 NODE_SOCKET_API(bool, invert)
1655 NODE_SOCKET_API(bool, use_object_space)
1656 NODE_SOCKET_API(float, height)
1657 NODE_SOCKET_API(float, filter_width)
1658 NODE_SOCKET_API(float, sample_center)
1659 NODE_SOCKET_API(float, sample_x)
1660 NODE_SOCKET_API(float, sample_y)
1661 NODE_SOCKET_API(float3, normal)
1662 NODE_SOCKET_API(float, strength)
1664};
1665
1666class CurvesNode : public ShaderNode {
1667 public:
1668 explicit CurvesNode(const NodeType *node_type);
1670
1672 NODE_SOCKET_API(float, min_x)
1673 NODE_SOCKET_API(float, max_x)
1674 NODE_SOCKET_API(float, fac)
1675 NODE_SOCKET_API(float3, value)
1676 NODE_SOCKET_API(bool, extrapolate)
1677
1678 protected:
1680 void constant_fold(const ConstantFolder &folder, ShaderInput *value_in);
1681 void compile(SVMCompiler &compiler, ShaderInput *value_in, ShaderOutput *value_out);
1682 void compile(OSLCompiler &compiler, const char *name);
1684 {
1685 return NODE_CURVES;
1686 }
1687};
1688
1690 public:
1692 void constant_fold(const ConstantFolder &folder) override;
1693};
1694
1696 public:
1698 void constant_fold(const ConstantFolder &folder) override;
1699};
1700
1702 public:
1704 void constant_fold(const ConstantFolder &folder) override;
1705
1707 NODE_SOCKET_API(float, min_x)
1708 NODE_SOCKET_API(float, max_x)
1709 NODE_SOCKET_API(float, fac)
1710 NODE_SOCKET_API(float, value)
1711 NODE_SOCKET_API(bool, extrapolate)
1712};
1713
1714class RGBRampNode : public ShaderNode {
1715 public:
1717 void constant_fold(const ConstantFolder &folder) override;
1718
1721 NODE_SOCKET_API(float, fac)
1723};
1724
1726 public:
1728 NODE_SOCKET_API(float3, direction)
1729
1731 {
1732 return NODE_CLOSURE_SET_NORMAL;
1733 }
1734};
1735
1736class OSLNode final : public ShaderNode {
1737 public:
1738 static OSLNode *create(ShaderGraph *graph,
1739 const size_t num_inputs,
1740 const OSLNode *from = nullptr);
1741 ~OSLNode() override;
1742
1743 static void operator delete(void *ptr)
1744 {
1745 /* Override delete operator to silence new-delete-type-mismatch ASAN warnings
1746 * regarding size mismatch in the destructor. This is intentional as we allocate
1747 * extra space at the end of the node. */
1748 ::operator delete(ptr);
1749 }
1750 static void operator delete(void * /*unused*/, void * /*unused*/)
1751 {
1752 /* Deliberately empty placement delete operator, to avoid MSVC warning C4291. */
1753 }
1754
1755 ShaderNode *clone(ShaderGraph *graph) const override;
1756
1757 void attributes(Shader *shader, AttributeRequestSet *attributes) override;
1758
1759 char *input_default_value();
1760 void add_input(ustring name, SocketType::Type type, const int flags = 0);
1761 void add_output(ustring name, SocketType::Type type);
1762
1764
1765 bool has_surface_emission() override
1766 {
1767 return has_emission;
1768 }
1769
1770 /* Ideally we could better detect this, but we can't query this now. */
1771 bool has_spatial_varying() override
1772 {
1773 return true;
1774 }
1775 bool has_volume_support() override
1776 {
1777 return true;
1778 }
1783
1784 bool equals(const ShaderNode & /*other*/) override
1785 {
1786 return false;
1787 }
1788
1789 string filepath;
1792};
1793
1795 public:
1797 void attributes(Shader *shader, AttributeRequestSet *attributes) override;
1799 {
1800 return true;
1801 }
1802 bool has_spatial_varying() override
1803 {
1804 return true;
1805 }
1806
1808 NODE_SOCKET_API(ustring, attribute)
1809 NODE_SOCKET_API(float, strength)
1810 NODE_SOCKET_API(float3, color)
1811 NODE_SOCKET_API(int, convention)
1812 NODE_SOCKET_API(int, base)
1813};
1814
1816 public:
1818
1819 NODE_SOCKET_API(bool, use_normalize)
1821 NODE_SOCKET_API(float, r_gon_sides)
1822 NODE_SOCKET_API(float, r_gon_roundness)
1823};
1824
1825class TangentNode : public ShaderNode {
1826 public:
1828 void attributes(Shader *shader, AttributeRequestSet *attributes) override;
1830 {
1831 return true;
1832 }
1833 bool has_spatial_varying() override
1834 {
1835 return true;
1836 }
1838 {
1839 return NODE_TANGENT;
1840 }
1841
1844 NODE_SOCKET_API(ustring, attribute)
1845};
1846
1847class BevelNode : public ShaderNode {
1848 public:
1850 bool has_spatial_varying() override
1851 {
1852 return true;
1853 }
1855 {
1857 }
1858
1859 NODE_SOCKET_API(float, radius)
1860 NODE_SOCKET_API(float3, normal)
1861 NODE_SOCKET_API(int, samples)
1862};
1863
1865 public:
1867 void constant_fold(const ConstantFolder &folder) override;
1869 {
1871 }
1872
1874 NODE_SOCKET_API(float, height)
1875 NODE_SOCKET_API(float, midlevel)
1876 NODE_SOCKET_API(float, scale)
1877 NODE_SOCKET_API(float3, normal)
1878};
1879
1881 public:
1883 void attributes(Shader *shader, AttributeRequestSet *attributes) override;
1885 {
1886 return true;
1887 }
1888 void constant_fold(const ConstantFolder &folder) override;
1890 {
1892 }
1893
1895 NODE_SOCKET_API(ustring, attribute)
1897 NODE_SOCKET_API(float, midlevel)
1898 NODE_SOCKET_API(float, scale)
1899};
1900
1901class RaycastNode : public ShaderNode {
1902 public:
1908
1910
1911 /* Copy constructor for the purposes of the clone() functionality. */
1912 RaycastNode(const RaycastNode &other);
1913
1914 void global_attributes(Shader *shader, AttributeRequestSet *attributes) override;
1915
1916 bool has_spatial_varying() override
1917 {
1918 return true;
1919 }
1921 {
1923 }
1925 {
1926 return NODE_RAYCAST;
1927 }
1928
1929 /* Add an output socket to the instance of this node which provides access to specified attribute
1930 * samples at the intersection. */
1931 void add_output_attribute_socket(ustring attribute_name,
1932 AttributeOutputType attribute_output_type,
1933 ustring socket_id);
1934
1936 NODE_SOCKET_API(float3, direction)
1937 NODE_SOCKET_API(float, length)
1938
1939 NODE_SOCKET_API(bool, only_local)
1940
1941 private:
1942 struct AttributeOutput {
1943 ustring attribute_name;
1944 AttributeOutputType attribute_output_type;
1945 ustring socket_id;
1946 };
1947 vector<AttributeOutput> attribute_outputs_;
1948
1949 /* Types for the dynamically registered output sockets. */
1950 unique_ptr_vector<SocketType> socket_types_;
1951};
1952
1954 public:
1956
1957 NODE_SOCKET_API(float, seconds)
1958 NODE_SOCKET_API(float, frame)
1959};
1960
#define final(a, b, c)
Definition BLI_hash_c.hh:21
unsigned long long int uint64_t
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
Definition btDbvt.cpp:52
btScalar max
SIMD_FORCE_INLINE const btScalar & z() const
Return the z value.
Definition btQuadWord.h:117
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition btQuadWord.h:119
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
Definition btVector3.h:356
bool is_linear_operation() override
void constant_fold(const ConstantFolder &folder) override
uint64_t get_feature() override
bool has_spatial_varying() override
bool has_spatial_varying() override
bool has_attribute_dependency() override
void attributes(Shader *shader, AttributeRequestSet *attributes) override
void constant_fold(const ConstantFolder &folder) override
uint64_t get_feature() override
bool is_linear_operation() override
uint64_t get_feature() override
bool has_spatial_varying() override
void constant_fold(const ConstantFolder &folder) override
void constant_fold(const ConstantFolder &folder) override
void constant_fold(const ConstantFolder &folder) override
bool equals(const ShaderNode &) override
uint64_t get_feature() override
bool has_spatial_varying() override
ClosureType get_closure_type() override
ShaderNodeType shader_node_type() const override
bool is_linear_operation() override
ClosureType closure
bool has_bump() override
BsdfBaseNode(const NodeType *node_type)
BsdfNode(const NodeType *node_type)
void compile(SVMCompiler &compiler, const T &data)
void constant_fold(const ConstantFolder &folder) override
bool has_spatial_varying() override
uint64_t get_feature() override
bool has_spatial_varying() override
void constant_fold(const ConstantFolder &folder) override
void constant_fold(const ConstantFolder &folder) override
bool is_linear_operation() override
bool is_linear_operation() override
void constant_fold(const ConstantFolder &folder) override
ShaderNodeType shader_node_type() const override
void constant_fold(const ConstantFolder &folder) override
bool is_linear_operation() override
bool is_linear_operation() override
ShaderNodeType shader_node_type() const override
void constant_fold(const ConstantFolder &folder) override
ConvertNode(SocketType::Type from, SocketType::Type to, bool autoconvert=false)
NodeConvert convert_type()
void compile(SVMCompiler &compiler, ShaderInput *value_in, ShaderOutput *value_out)
CurvesNode(const NodeType *node_type)
ShaderNodeType shader_node_type() const override
void constant_fold(const ConstantFolder &folder, ShaderInput *value_in)
bool is_linear_operation() override
uint64_t get_feature() override
void constant_fold(const ConstantFolder &folder) override
bool is_linear_operation() override
bool has_volume_support() override
void constant_fold(const ConstantFolder &folder) override
uint64_t get_feature() override
bool from_auto_conversion
bool has_surface_emission() override
ShaderNodeType shader_node_type() const override
ShaderNode * clone(ShaderGraph *graph) const override
void attributes(Shader *shader, AttributeRequestSet *attributes) override
bool has_attribute_dependency() override
void update_images(const SVMCompiler &compiler) override
ImageParams image_params() const
bool equals(const ShaderNode &other) override
void constant_fold(const ConstantFolder &folder) override
bool has_spatial_varying() override
void constant_fold(const ConstantFolder &folder) override
bool has_spatial_varying() override
bool has_attribute_dependency() override
ShaderNodeType shader_node_type() const override
void attributes(Shader *shader, AttributeRequestSet *attributes) override
void constant_fold(const ConstantFolder &folder) override
ShaderNodeType shader_node_type() const override
void simplify_settings(Scene *scene) override
ClosureType get_closure_type() override
bool has_attribute_dependency() override
void attributes(Shader *shader, AttributeRequestSet *attributes) override
bool has_attribute_dependency() override
void attributes(Shader *shader, AttributeRequestSet *attributes) override
void simplify_settings(Scene *scene) override
ClosureType get_closure_type() override
ClosureType get_closure_type() override
bool has_attribute_dependency() override
void attributes(Shader *shader, AttributeRequestSet *attributes) override
bool has_spatial_varying() override
ClosureType get_closure_type() override
bool is_linear_operation() override
ShaderNode * clone(ShaderGraph *graph) const override
virtual void update_images(const SVMCompiler &compiler)=0
bool is_texture_node_and_needs_derivatives(const SVMCompiler &compiler) override
bool equals(const ShaderNode &other) override
ImageSlotTextureNode(const NodeType *node_type)
void update_images(const SVMCompiler &compiler) override
ImageParams image_params() const
void cull_tiles(Scene *scene, ShaderGraph *graph)
ShaderNode * clone(ShaderGraph *graph) const override
void attributes(Shader *shader, AttributeRequestSet *attributes) override
bool has_attribute_dependency() override
ShaderNodeType shader_node_type() const override
bool equals(const ShaderNode &other) override
void constant_fold(const ConstantFolder &folder) override
bool is_linear_operation() override
void constant_fold(const ConstantFolder &folder) override
bool has_spatial_varying() override
bool has_spatial_varying() override
bool is_linear_operation() override
void expand(ShaderGraph *graph) override
ShaderNodeType shader_node_type() const override
void constant_fold(const ConstantFolder &folder) override
void expand(ShaderGraph *graph) override
void constant_fold(const ConstantFolder &folder) override
bool is_linear_operation() override
ClosureType get_closure_type() override
void attributes(Shader *shader, AttributeRequestSet *attributes) override
void simplify_settings(Scene *scene) override
bool has_attribute_dependency() override
bool is_linear_operation() override
void constant_fold(const ConstantFolder &folder) override
bool is_linear_operation() override
bool is_linear_operation() override
void constant_fold(const ConstantFolder &folder) override
bool is_linear_operation() override
void constant_fold(const ConstantFolder &folder) override
bool is_linear_operation() override
void constant_fold(const ConstantFolder &folder) override
void constant_fold(const ConstantFolder &folder) override
bool is_linear_operation() override
bool is_linear_operation() override
void constant_fold(const ConstantFolder &folder) override
bool has_spatial_varying() override
bool has_attribute_dependency() override
void attributes(Shader *shader, AttributeRequestSet *attributes) override
bool is_linear_operation() override
uint64_t get_feature() override
string bytecode_hash
bool equals(const ShaderNode &) override
bool has_volume_support() override
static OSLNode * create(ShaderGraph *graph, const size_t num_inputs, const OSLNode *from=nullptr)
bool has_surface_emission() override
bool has_emission
bool has_spatial_varying() override
string filepath
bool is_linear_operation() override
bool equals(const ShaderNode &) override
void simplify_settings(Scene *scene) override
bool is_linear_operation() override
bool equals(const ShaderNode &) override
bool has_attribute_dependency() override
void attributes(Shader *shader, AttributeRequestSet *attributes) override
void attributes(Shader *shader, AttributeRequestSet *attributes) override
bool has_attribute_dependency() override
bool has_spatial_varying() override
bool subsurface_has_positive_weight()
void attributes(Shader *shader, AttributeRequestSet *attributes) override
bool has_dispersion() override
bool has_attribute_dependency() override
bool has_surface_bssrdf() override
void simplify_settings(Scene *scene) override
bool has_nonzero_weight(const char *name)
bool has_surface_transparent() override
bool has_bssrdf_bump() override
bool has_surface_emission() override
uint64_t get_feature() override
void attributes(Shader *shader, AttributeRequestSet *attributes) override
void attributes(Shader *shader, AttributeRequestSet *attributes) override
bool has_attribute_dependency() override
void constant_fold(const ConstantFolder &folder) override
void constant_fold(const ConstantFolder &folder) override
void constant_fold(const ConstantFolder &folder) override
ShaderNodeType shader_node_type() const override
bool is_linear_operation() override
bool has_surface_transparent() override
uint64_t get_feature() override
RaycastNode(const RaycastNode &other)
uint64_t get_feature() override
bool has_spatial_varying() override
ShaderNodeType shader_node_type() const override
ClosureType get_closure_type() override
ScatterVolumeNode(const NodeType *node_type)
Definition scene.h:133
void constant_fold(const ConstantFolder &folder) override
bool is_linear_operation() override
void constant_fold(const ConstantFolder &folder) override
ShaderNodeType shader_node_type() const override
bool is_linear_operation() override
ShaderNodeType shader_node_type() const override
bool need_derivatives() const
ShaderNodeSpecialType special_type
virtual uint64_t get_feature()
virtual void constant_fold(const ConstantFolder &)
ShaderNode(const NodeType *type)
ClosureType get_closure_type() override
float get_sun_size()
void simplify_settings(Scene *scene) override
ImageHandle handle
float get_sun_average_radiance()
bool has_bssrdf_bump() override
ClosureType get_closure_type() override
bool has_surface_bssrdf() override
bool has_spatial_varying() override
void attributes(Shader *shader, AttributeRequestSet *attributes) override
ShaderNodeType shader_node_type() const override
bool has_attribute_dependency() override
bool has_spatial_varying() override
bool has_attribute_dependency() override
void attributes(Shader *shader, AttributeRequestSet *attributes) override
int compile(SVMCompiler &compiler, ShaderInput *vector_in)
SVMStackOffset compile_begin(SVMCompiler &compiler, ShaderInput *vector_in, ShaderNode *node)
Transform compute_transform()
Projection projection
Mapping x_mapping
void compile(SVMCompiler &compiler, const SVMStackOffset offset_in, const SVMStackOffset offset_out, ShaderNode *node)
Mapping z_mapping
Mapping y_mapping
void compile_end(SVMCompiler &compiler, ShaderInput *vector_in, const SVMStackOffset vector_offset)
TextureMapping tex_mapping
TextureNode(const NodeType *node_type)
bool has_surface_transparent() override
void attributes(Shader *shader, AttributeRequestSet *attributes) override
bool has_spatial_varying() override
bool has_attribute_dependency() override
bool is_linear_operation() override
void constant_fold(const ConstantFolder &folder) override
void constant_fold(const ConstantFolder &folder) override
void attributes(Shader *shader, AttributeRequestSet *attributes) override
bool has_attribute_dependency() override
uint64_t get_feature() override
bool is_linear_operation() override
void expand(ShaderGraph *graph) override
ShaderNodeType shader_node_type() const override
void constant_fold(const ConstantFolder &folder) override
bool is_linear_operation() override
ShaderNodeType shader_node_type() const override
ShaderNodeType shader_node_type() const override
bool has_attribute_dependency() override
bool has_spatial_varying() override
void attributes(Shader *shader, AttributeRequestSet *attributes) override
void attributes(Shader *shader, AttributeRequestSet *attributes) override
bool has_attribute_dependency() override
bool has_spatial_varying() override
uint64_t get_feature() override
ClosureType get_closure_type() override
ClosureType closure
bool has_volume_support() override
bool equals(const ShaderNode &) override
VolumeNode(const NodeType *node_type)
bool is_linear_operation() override
uint64_t get_feature() override
bool has_spatial_varying() override
#define KERNEL_FEATURE_NODE_PORTAL
#define KERNEL_FEATURE_NODE_BSDF
#define KERNEL_FEATURE_NODE_PRINCIPLED_HAIR
#define KERNEL_FEATURE_NODE_VORONOI_EXTRA
#define KERNEL_FEATURE_NODE_VOLUME
#define KERNEL_FEATURE_NODE_RAYTRACE
#define KERNEL_FEATURE_NODE_EMISSION
#define KERNEL_FEATURE_NODE_BUMP
#define CCL_NAMESPACE_END
#define position
#define index(i)
#define smooth
#define attribute(slot)
#define frequency(freq)
float distance(float, float) RET
constexpr T clamp(T, U, U) RET
float length(VecOp< float, D >) RET
float2x2 invert(float2x2 mat)
float3x3 scale(float3x3 mat, float2 scale)
Quaternion interpolate(Quaternion a, Quaternion b, float t)
#define NODE_SOCKET_API_STRUCT_MEMBER(type_, name, member)
Definition graph/node.h:77
#define NODE_SOCKET_API_ARRAY(type_, name)
Definition graph/node.h:64
#define NODE_SOCKET_API(type_, name)
Definition graph/node.h:56
ccl_gpu_kernel_postfix ccl_global KernelWorkTile * tiles
NodeVectorTransformType
ShaderNodeType
NodeCombSepColorType
NodeVectorRotateType
NodeMapRangeType
NodeWaveType
ClosureType
@ CLOSURE_HOLDOUT_ID
NodeBooleanMathType
NodeVoronoiFeature
@ NODE_VORONOI_SMOOTH_F1
NodeEnvironmentProjection
NodeGradientType
NodeMathType
NodeIntegerMathType
NodeConvert
NodeSkyType
NodePrincipledHairModel
NodeWaveProfile
uint8_t SVMStackOffset
NodeVoronoiDistanceMetric
NodeTangentAxis
NodePrincipledHairParametrization
NodeNoiseType
NodeWaveBandsDirection
NodeGaborType
NodeTangentDirectionType
NodeVectorMathType
NodeClampType
NodeImageProjection
NodeWaveRingsDirection
NodeMappingType
NodeNormalMapSpace
NodeVectorTransformConvertSpace
#define T
#define R
#define vector3
#define fmaxf
#define SHADER_NODE_NO_CLONE_CLASS(type)
@ SHADER_SPECIAL_TYPE_IMAGE_SLOT
#define SHADER_NODE_CLASS(type)
#define SHADER_NODE_BASE_CLASS(type)
float3 sun_direction(float sun_cos_theta)
Definition sky_math.h:457
#define min(a, b)
Definition sort.cc:38
bool equals(const Node &other) const
const NodeType * type
Definition graph/node.h:179
ustring name
Definition graph/node.h:178
Node(const NodeType *type, ustring name=ustring())
ImageAlphaType
Definition types_image.h:61
InterpolationType
Definition types_image.h:24
ExtensionType
Definition types_image.h:80