1 /*************************************************************************/
2 /* visual_shader_nodes.h */
3 /*************************************************************************/
4 /* This file is part of: */
5 /* GODOT ENGINE */
6 /* https://godotengine.org */
7 /*************************************************************************/
8 /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
9 /* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
10 /* */
11 /* Permission is hereby granted, free of charge, to any person obtaining */
12 /* a copy of this software and associated documentation files (the */
13 /* "Software"), to deal in the Software without restriction, including */
14 /* without limitation the rights to use, copy, modify, merge, publish, */
15 /* distribute, sublicense, and/or sell copies of the Software, and to */
16 /* permit persons to whom the Software is furnished to do so, subject to */
17 /* the following conditions: */
18 /* */
19 /* The above copyright notice and this permission notice shall be */
20 /* included in all copies or substantial portions of the Software. */
21 /* */
22 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
23 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
24 /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
25 /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
26 /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
27 /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
28 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
29 /*************************************************************************/
30
31 #ifndef VISUAL_SHADER_NODES_H
32 #define VISUAL_SHADER_NODES_H
33
34 #include "scene/resources/visual_shader.h"
35
36 ///////////////////////////////////////
37 /// CONSTANTS
38 ///////////////////////////////////////
39
40 class VisualShaderNodeScalarConstant : public VisualShaderNode {
41 GDCLASS(VisualShaderNodeScalarConstant, VisualShaderNode);
42 float constant;
43
44 protected:
45 static void _bind_methods();
46
47 public:
48 virtual String get_caption() const;
49
50 virtual int get_input_port_count() const;
51 virtual PortType get_input_port_type(int p_port) const;
52 virtual String get_input_port_name(int p_port) const;
53
54 virtual int get_output_port_count() const;
55 virtual PortType get_output_port_type(int p_port) const;
56 virtual String get_output_port_name(int p_port) const;
57
58 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
59
60 void set_constant(float p_value);
61 float get_constant() const;
62
63 virtual Vector<StringName> get_editable_properties() const;
64
65 VisualShaderNodeScalarConstant();
66 };
67
68 ///////////////////////////////////////
69
70 class VisualShaderNodeBooleanConstant : public VisualShaderNode {
71 GDCLASS(VisualShaderNodeBooleanConstant, VisualShaderNode);
72 bool constant;
73
74 protected:
75 static void _bind_methods();
76
77 public:
78 virtual String get_caption() const;
79
80 virtual int get_input_port_count() const;
81 virtual PortType get_input_port_type(int p_port) const;
82 virtual String get_input_port_name(int p_port) const;
83
84 virtual int get_output_port_count() const;
85 virtual PortType get_output_port_type(int p_port) const;
86 virtual String get_output_port_name(int p_port) const;
87
88 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
89
90 void set_constant(bool p_value);
91 bool get_constant() const;
92
93 virtual Vector<StringName> get_editable_properties() const;
94
95 VisualShaderNodeBooleanConstant();
96 };
97
98 ///////////////////////////////////////
99
100 class VisualShaderNodeColorConstant : public VisualShaderNode {
101 GDCLASS(VisualShaderNodeColorConstant, VisualShaderNode);
102 Color constant;
103
104 protected:
105 static void _bind_methods();
106
107 public:
108 virtual String get_caption() const;
109
110 virtual int get_input_port_count() const;
111 virtual PortType get_input_port_type(int p_port) const;
112 virtual String get_input_port_name(int p_port) const;
113
114 virtual int get_output_port_count() const;
115 virtual PortType get_output_port_type(int p_port) const;
116 virtual String get_output_port_name(int p_port) const;
117
118 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
119
120 void set_constant(Color p_value);
121 Color get_constant() const;
122
123 virtual Vector<StringName> get_editable_properties() const;
124
125 VisualShaderNodeColorConstant();
126 };
127
128 ///////////////////////////////////////
129
130 class VisualShaderNodeVec3Constant : public VisualShaderNode {
131 GDCLASS(VisualShaderNodeVec3Constant, VisualShaderNode);
132 Vector3 constant;
133
134 protected:
135 static void _bind_methods();
136
137 public:
138 virtual String get_caption() const;
139
140 virtual int get_input_port_count() const;
141 virtual PortType get_input_port_type(int p_port) const;
142 virtual String get_input_port_name(int p_port) const;
143
144 virtual int get_output_port_count() const;
145 virtual PortType get_output_port_type(int p_port) const;
146 virtual String get_output_port_name(int p_port) const;
147
148 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
149
150 void set_constant(Vector3 p_value);
151 Vector3 get_constant() const;
152
153 virtual Vector<StringName> get_editable_properties() const;
154
155 VisualShaderNodeVec3Constant();
156 };
157
158 ///////////////////////////////////////
159
160 class VisualShaderNodeTransformConstant : public VisualShaderNode {
161 GDCLASS(VisualShaderNodeTransformConstant, VisualShaderNode);
162 Transform constant;
163
164 protected:
165 static void _bind_methods();
166
167 public:
168 virtual String get_caption() const;
169
170 virtual int get_input_port_count() const;
171 virtual PortType get_input_port_type(int p_port) const;
172 virtual String get_input_port_name(int p_port) const;
173
174 virtual int get_output_port_count() const;
175 virtual PortType get_output_port_type(int p_port) const;
176 virtual String get_output_port_name(int p_port) const;
177
178 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
179
180 void set_constant(Transform p_value);
181 Transform get_constant() const;
182
183 virtual Vector<StringName> get_editable_properties() const;
184
185 VisualShaderNodeTransformConstant();
186 };
187
188 ///////////////////////////////////////
189 /// TEXTURES
190 ///////////////////////////////////////
191
192 class VisualShaderNodeTexture : public VisualShaderNode {
193 GDCLASS(VisualShaderNodeTexture, VisualShaderNode);
194 Ref<Texture> texture;
195
196 public:
197 enum Source {
198 SOURCE_TEXTURE,
199 SOURCE_SCREEN,
200 SOURCE_2D_TEXTURE,
201 SOURCE_2D_NORMAL,
202 SOURCE_DEPTH,
203 SOURCE_PORT,
204 };
205
206 enum TextureType {
207 TYPE_DATA,
208 TYPE_COLOR,
209 TYPE_NORMALMAP
210 };
211
212 private:
213 Source source;
214 TextureType texture_type;
215
216 protected:
217 static void _bind_methods();
218
219 public:
220 virtual String get_caption() const;
221
222 virtual int get_input_port_count() const;
223 virtual PortType get_input_port_type(int p_port) const;
224 virtual String get_input_port_name(int p_port) const;
225
226 virtual int get_output_port_count() const;
227 virtual PortType get_output_port_type(int p_port) const;
228 virtual String get_output_port_name(int p_port) const;
229
230 virtual String get_input_port_default_hint(int p_port) const;
231
232 virtual Vector<VisualShader::DefaultTextureParam> get_default_texture_parameters(VisualShader::Type p_type, int p_id) const;
233 virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
234 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
235
236 void set_source(Source p_source);
237 Source get_source() const;
238
239 void set_texture(Ref<Texture> p_value);
240 Ref<Texture> get_texture() const;
241
242 void set_texture_type(TextureType p_type);
243 TextureType get_texture_type() const;
244
245 virtual Vector<StringName> get_editable_properties() const;
246
247 virtual String get_warning(Shader::Mode p_mode, VisualShader::Type p_type) const;
248
249 VisualShaderNodeTexture();
250 };
251
252 VARIANT_ENUM_CAST(VisualShaderNodeTexture::TextureType)
VARIANT_ENUM_CAST(VisualShaderNodeTexture::Source)253 VARIANT_ENUM_CAST(VisualShaderNodeTexture::Source)
254
255 ///////////////////////////////////////
256
257 class VisualShaderNodeCubeMap : public VisualShaderNode {
258 GDCLASS(VisualShaderNodeCubeMap, VisualShaderNode);
259 Ref<CubeMap> cube_map;
260
261 public:
262 enum Source {
263 SOURCE_TEXTURE,
264 SOURCE_PORT
265 };
266
267 enum TextureType {
268 TYPE_DATA,
269 TYPE_COLOR,
270 TYPE_NORMALMAP
271 };
272
273 private:
274 Source source;
275 TextureType texture_type;
276
277 protected:
278 static void _bind_methods();
279
280 public:
281 virtual String get_caption() const;
282
283 virtual int get_input_port_count() const;
284 virtual PortType get_input_port_type(int p_port) const;
285 virtual String get_input_port_name(int p_port) const;
286 virtual String get_input_port_default_hint(int p_port) const;
287
288 virtual int get_output_port_count() const;
289 virtual PortType get_output_port_type(int p_port) const;
290 virtual String get_output_port_name(int p_port) const;
291
292 virtual Vector<VisualShader::DefaultTextureParam> get_default_texture_parameters(VisualShader::Type p_type, int p_id) const;
293 virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
294 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
295
296 void set_source(Source p_source);
297 Source get_source() const;
298
299 void set_cube_map(Ref<CubeMap> p_value);
300 Ref<CubeMap> get_cube_map() const;
301
302 void set_texture_type(TextureType p_type);
303 TextureType get_texture_type() const;
304
305 virtual Vector<StringName> get_editable_properties() const;
306
307 VisualShaderNodeCubeMap();
308 };
309
310 VARIANT_ENUM_CAST(VisualShaderNodeCubeMap::TextureType)
VARIANT_ENUM_CAST(VisualShaderNodeCubeMap::Source)311 VARIANT_ENUM_CAST(VisualShaderNodeCubeMap::Source)
312
313 ///////////////////////////////////////
314 /// OPS
315 ///////////////////////////////////////
316
317 class VisualShaderNodeScalarOp : public VisualShaderNode {
318 GDCLASS(VisualShaderNodeScalarOp, VisualShaderNode);
319
320 public:
321 enum Operator {
322 OP_ADD,
323 OP_SUB,
324 OP_MUL,
325 OP_DIV,
326 OP_MOD,
327 OP_POW,
328 OP_MAX,
329 OP_MIN,
330 OP_ATAN2,
331 OP_STEP
332 };
333
334 protected:
335 Operator op;
336
337 static void _bind_methods();
338
339 public:
340 virtual String get_caption() const;
341
342 virtual int get_input_port_count() const;
343 virtual PortType get_input_port_type(int p_port) const;
344 virtual String get_input_port_name(int p_port) const;
345
346 virtual int get_output_port_count() const;
347 virtual PortType get_output_port_type(int p_port) const;
348 virtual String get_output_port_name(int p_port) const;
349
350 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
351
352 void set_operator(Operator p_op);
353 Operator get_operator() const;
354
355 virtual Vector<StringName> get_editable_properties() const;
356
357 VisualShaderNodeScalarOp();
358 };
359
VARIANT_ENUM_CAST(VisualShaderNodeScalarOp::Operator)360 VARIANT_ENUM_CAST(VisualShaderNodeScalarOp::Operator)
361
362 class VisualShaderNodeVectorOp : public VisualShaderNode {
363 GDCLASS(VisualShaderNodeVectorOp, VisualShaderNode);
364
365 public:
366 enum Operator {
367 OP_ADD,
368 OP_SUB,
369 OP_MUL,
370 OP_DIV,
371 OP_MOD,
372 OP_POW,
373 OP_MAX,
374 OP_MIN,
375 OP_CROSS,
376 OP_ATAN2,
377 OP_REFLECT,
378 OP_STEP
379 };
380
381 protected:
382 Operator op;
383
384 static void _bind_methods();
385
386 public:
387 virtual String get_caption() const;
388
389 virtual int get_input_port_count() const;
390 virtual PortType get_input_port_type(int p_port) const;
391 virtual String get_input_port_name(int p_port) const;
392
393 virtual int get_output_port_count() const;
394 virtual PortType get_output_port_type(int p_port) const;
395 virtual String get_output_port_name(int p_port) const;
396
397 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
398
399 void set_operator(Operator p_op);
400 Operator get_operator() const;
401
402 virtual Vector<StringName> get_editable_properties() const;
403
404 VisualShaderNodeVectorOp();
405 };
406
VARIANT_ENUM_CAST(VisualShaderNodeVectorOp::Operator)407 VARIANT_ENUM_CAST(VisualShaderNodeVectorOp::Operator)
408
409 ///////////////////////////////////////
410
411 class VisualShaderNodeColorOp : public VisualShaderNode {
412 GDCLASS(VisualShaderNodeColorOp, VisualShaderNode);
413
414 public:
415 enum Operator {
416 OP_SCREEN,
417 OP_DIFFERENCE,
418 OP_DARKEN,
419 OP_LIGHTEN,
420 OP_OVERLAY,
421 OP_DODGE,
422 OP_BURN,
423 OP_SOFT_LIGHT,
424 OP_HARD_LIGHT
425 };
426
427 protected:
428 Operator op;
429
430 static void _bind_methods();
431
432 public:
433 virtual String get_caption() const;
434
435 virtual int get_input_port_count() const;
436 virtual PortType get_input_port_type(int p_port) const;
437 virtual String get_input_port_name(int p_port) const;
438
439 virtual int get_output_port_count() const;
440 virtual PortType get_output_port_type(int p_port) const;
441 virtual String get_output_port_name(int p_port) const;
442
443 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
444
445 void set_operator(Operator p_op);
446 Operator get_operator() const;
447
448 virtual Vector<StringName> get_editable_properties() const;
449
450 VisualShaderNodeColorOp();
451 };
452
VARIANT_ENUM_CAST(VisualShaderNodeColorOp::Operator)453 VARIANT_ENUM_CAST(VisualShaderNodeColorOp::Operator)
454
455 ///////////////////////////////////////
456 /// TRANSFORM-TRANSFORM MULTIPLICATION
457 ///////////////////////////////////////
458
459 class VisualShaderNodeTransformMult : public VisualShaderNode {
460 GDCLASS(VisualShaderNodeTransformMult, VisualShaderNode);
461
462 public:
463 enum Operator {
464 OP_AxB,
465 OP_BxA,
466 OP_AxB_COMP,
467 OP_BxA_COMP
468 };
469
470 protected:
471 Operator op;
472
473 static void _bind_methods();
474
475 public:
476 virtual String get_caption() const;
477
478 virtual int get_input_port_count() const;
479 virtual PortType get_input_port_type(int p_port) const;
480 virtual String get_input_port_name(int p_port) const;
481
482 virtual int get_output_port_count() const;
483 virtual PortType get_output_port_type(int p_port) const;
484 virtual String get_output_port_name(int p_port) const;
485
486 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
487
488 void set_operator(Operator p_op);
489 Operator get_operator() const;
490
491 virtual Vector<StringName> get_editable_properties() const;
492
493 VisualShaderNodeTransformMult();
494 };
495
VARIANT_ENUM_CAST(VisualShaderNodeTransformMult::Operator)496 VARIANT_ENUM_CAST(VisualShaderNodeTransformMult::Operator)
497
498 ///////////////////////////////////////
499 /// TRANSFORM-VECTOR MULTIPLICATION
500 ///////////////////////////////////////
501
502 class VisualShaderNodeTransformVecMult : public VisualShaderNode {
503 GDCLASS(VisualShaderNodeTransformVecMult, VisualShaderNode);
504
505 public:
506 enum Operator {
507 OP_AxB,
508 OP_BxA,
509 OP_3x3_AxB,
510 OP_3x3_BxA,
511 };
512
513 protected:
514 Operator op;
515
516 static void _bind_methods();
517
518 public:
519 virtual String get_caption() const;
520
521 virtual int get_input_port_count() const;
522 virtual PortType get_input_port_type(int p_port) const;
523 virtual String get_input_port_name(int p_port) const;
524
525 virtual int get_output_port_count() const;
526 virtual PortType get_output_port_type(int p_port) const;
527 virtual String get_output_port_name(int p_port) const;
528
529 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
530
531 void set_operator(Operator p_op);
532 Operator get_operator() const;
533
534 virtual Vector<StringName> get_editable_properties() const;
535
536 VisualShaderNodeTransformVecMult();
537 };
538
VARIANT_ENUM_CAST(VisualShaderNodeTransformVecMult::Operator)539 VARIANT_ENUM_CAST(VisualShaderNodeTransformVecMult::Operator)
540
541 ///////////////////////////////////////
542 /// SCALAR FUNC
543 ///////////////////////////////////////
544
545 class VisualShaderNodeScalarFunc : public VisualShaderNode {
546 GDCLASS(VisualShaderNodeScalarFunc, VisualShaderNode);
547
548 public:
549 enum Function {
550 FUNC_SIN,
551 FUNC_COS,
552 FUNC_TAN,
553 FUNC_ASIN,
554 FUNC_ACOS,
555 FUNC_ATAN,
556 FUNC_SINH,
557 FUNC_COSH,
558 FUNC_TANH,
559 FUNC_LOG,
560 FUNC_EXP,
561 FUNC_SQRT,
562 FUNC_ABS,
563 FUNC_SIGN,
564 FUNC_FLOOR,
565 FUNC_ROUND,
566 FUNC_CEIL,
567 FUNC_FRAC,
568 FUNC_SATURATE,
569 FUNC_NEGATE,
570 FUNC_ACOSH,
571 FUNC_ASINH,
572 FUNC_ATANH,
573 FUNC_DEGREES,
574 FUNC_EXP2,
575 FUNC_INVERSE_SQRT,
576 FUNC_LOG2,
577 FUNC_RADIANS,
578 FUNC_RECIPROCAL,
579 FUNC_ROUNDEVEN,
580 FUNC_TRUNC,
581 FUNC_ONEMINUS
582 };
583
584 protected:
585 Function func;
586
587 static void _bind_methods();
588
589 public:
590 virtual String get_caption() const;
591
592 virtual int get_input_port_count() const;
593 virtual PortType get_input_port_type(int p_port) const;
594 virtual String get_input_port_name(int p_port) const;
595
596 virtual int get_output_port_count() const;
597 virtual PortType get_output_port_type(int p_port) const;
598 virtual String get_output_port_name(int p_port) const;
599
600 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
601
602 void set_function(Function p_func);
603 Function get_function() const;
604
605 virtual Vector<StringName> get_editable_properties() const;
606
607 VisualShaderNodeScalarFunc();
608 };
609
VARIANT_ENUM_CAST(VisualShaderNodeScalarFunc::Function)610 VARIANT_ENUM_CAST(VisualShaderNodeScalarFunc::Function)
611
612 ///////////////////////////////////////
613 /// VECTOR FUNC
614 ///////////////////////////////////////
615
616 class VisualShaderNodeVectorFunc : public VisualShaderNode {
617 GDCLASS(VisualShaderNodeVectorFunc, VisualShaderNode);
618
619 public:
620 enum Function {
621 FUNC_NORMALIZE,
622 FUNC_SATURATE,
623 FUNC_NEGATE,
624 FUNC_RECIPROCAL,
625 FUNC_RGB2HSV,
626 FUNC_HSV2RGB,
627 FUNC_ABS,
628 FUNC_ACOS,
629 FUNC_ACOSH,
630 FUNC_ASIN,
631 FUNC_ASINH,
632 FUNC_ATAN,
633 FUNC_ATANH,
634 FUNC_CEIL,
635 FUNC_COS,
636 FUNC_COSH,
637 FUNC_DEGREES,
638 FUNC_EXP,
639 FUNC_EXP2,
640 FUNC_FLOOR,
641 FUNC_FRAC,
642 FUNC_INVERSE_SQRT,
643 FUNC_LOG,
644 FUNC_LOG2,
645 FUNC_RADIANS,
646 FUNC_ROUND,
647 FUNC_ROUNDEVEN,
648 FUNC_SIGN,
649 FUNC_SIN,
650 FUNC_SINH,
651 FUNC_SQRT,
652 FUNC_TAN,
653 FUNC_TANH,
654 FUNC_TRUNC,
655 FUNC_ONEMINUS
656 };
657
658 protected:
659 Function func;
660
661 static void _bind_methods();
662
663 public:
664 virtual String get_caption() const;
665
666 virtual int get_input_port_count() const;
667 virtual PortType get_input_port_type(int p_port) const;
668 virtual String get_input_port_name(int p_port) const;
669
670 virtual int get_output_port_count() const;
671 virtual PortType get_output_port_type(int p_port) const;
672 virtual String get_output_port_name(int p_port) const;
673
674 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
675
676 void set_function(Function p_func);
677 Function get_function() const;
678
679 virtual Vector<StringName> get_editable_properties() const;
680
681 VisualShaderNodeVectorFunc();
682 };
683
VARIANT_ENUM_CAST(VisualShaderNodeVectorFunc::Function)684 VARIANT_ENUM_CAST(VisualShaderNodeVectorFunc::Function)
685
686 ///////////////////////////////////////
687 /// COLOR FUNC
688 ///////////////////////////////////////
689
690 class VisualShaderNodeColorFunc : public VisualShaderNode {
691 GDCLASS(VisualShaderNodeColorFunc, VisualShaderNode);
692
693 public:
694 enum Function {
695 FUNC_GRAYSCALE,
696 FUNC_SEPIA
697 };
698
699 protected:
700 Function func;
701
702 static void _bind_methods();
703
704 public:
705 virtual String get_caption() const;
706
707 virtual int get_input_port_count() const;
708 virtual PortType get_input_port_type(int p_port) const;
709 virtual String get_input_port_name(int p_port) const;
710
711 virtual int get_output_port_count() const;
712 virtual PortType get_output_port_type(int p_port) const;
713 virtual String get_output_port_name(int p_port) const;
714
715 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
716
717 void set_function(Function p_func);
718 Function get_function() const;
719
720 virtual Vector<StringName> get_editable_properties() const;
721
722 VisualShaderNodeColorFunc();
723 };
724
VARIANT_ENUM_CAST(VisualShaderNodeColorFunc::Function)725 VARIANT_ENUM_CAST(VisualShaderNodeColorFunc::Function)
726
727 ///////////////////////////////////////
728 /// TRANSFORM FUNC
729 ///////////////////////////////////////
730
731 class VisualShaderNodeTransformFunc : public VisualShaderNode {
732 GDCLASS(VisualShaderNodeTransformFunc, VisualShaderNode);
733
734 public:
735 enum Function {
736 FUNC_INVERSE,
737 FUNC_TRANSPOSE
738 };
739
740 protected:
741 Function func;
742
743 static void _bind_methods();
744
745 public:
746 virtual String get_caption() const;
747
748 virtual int get_input_port_count() const;
749 virtual PortType get_input_port_type(int p_port) const;
750 virtual String get_input_port_name(int p_port) const;
751
752 virtual int get_output_port_count() const;
753 virtual PortType get_output_port_type(int p_port) const;
754 virtual String get_output_port_name(int p_port) const;
755
756 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
757
758 void set_function(Function p_func);
759 Function get_function() const;
760
761 virtual Vector<StringName> get_editable_properties() const;
762
763 VisualShaderNodeTransformFunc();
764 };
765
VARIANT_ENUM_CAST(VisualShaderNodeTransformFunc::Function)766 VARIANT_ENUM_CAST(VisualShaderNodeTransformFunc::Function)
767
768 ///////////////////////////////////////
769 /// DOT
770 ///////////////////////////////////////
771
772 class VisualShaderNodeDotProduct : public VisualShaderNode {
773 GDCLASS(VisualShaderNodeDotProduct, VisualShaderNode);
774
775 public:
776 virtual String get_caption() const;
777
778 virtual int get_input_port_count() const;
779 virtual PortType get_input_port_type(int p_port) const;
780 virtual String get_input_port_name(int p_port) const;
781
782 virtual int get_output_port_count() const;
783 virtual PortType get_output_port_type(int p_port) const;
784 virtual String get_output_port_name(int p_port) const;
785
786 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
787
788 VisualShaderNodeDotProduct();
789 };
790
791 ///////////////////////////////////////
792 /// LENGTH
793 ///////////////////////////////////////
794
795 class VisualShaderNodeVectorLen : public VisualShaderNode {
796 GDCLASS(VisualShaderNodeVectorLen, VisualShaderNode);
797
798 public:
799 virtual String get_caption() const;
800
801 virtual int get_input_port_count() const;
802 virtual PortType get_input_port_type(int p_port) const;
803 virtual String get_input_port_name(int p_port) const;
804
805 virtual int get_output_port_count() const;
806 virtual PortType get_output_port_type(int p_port) const;
807 virtual String get_output_port_name(int p_port) const;
808
809 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
810
811 VisualShaderNodeVectorLen();
812 };
813
814 ///////////////////////////////////////
815 /// DETERMINANT
816 ///////////////////////////////////////
817
818 class VisualShaderNodeDeterminant : public VisualShaderNode {
819 GDCLASS(VisualShaderNodeDeterminant, VisualShaderNode);
820
821 public:
822 virtual String get_caption() const;
823
824 virtual int get_input_port_count() const;
825 virtual PortType get_input_port_type(int p_port) const;
826 virtual String get_input_port_name(int p_port) const;
827
828 virtual int get_output_port_count() const;
829 virtual PortType get_output_port_type(int p_port) const;
830 virtual String get_output_port_name(int p_port) const;
831
832 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
833
834 VisualShaderNodeDeterminant();
835 };
836
837 ///////////////////////////////////////
838 /// CLAMP
839 ///////////////////////////////////////
840
841 class VisualShaderNodeScalarClamp : public VisualShaderNode {
842 GDCLASS(VisualShaderNodeScalarClamp, VisualShaderNode);
843
844 public:
845 virtual String get_caption() const;
846
847 virtual int get_input_port_count() const;
848 virtual PortType get_input_port_type(int p_port) const;
849 virtual String get_input_port_name(int p_port) const;
850
851 virtual int get_output_port_count() const;
852 virtual PortType get_output_port_type(int p_port) const;
853 virtual String get_output_port_name(int p_port) const;
854
855 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
856
857 VisualShaderNodeScalarClamp();
858 };
859
860 ///////////////////////////////////////
861
862 class VisualShaderNodeVectorClamp : public VisualShaderNode {
863 GDCLASS(VisualShaderNodeVectorClamp, VisualShaderNode);
864
865 public:
866 virtual String get_caption() const;
867
868 virtual int get_input_port_count() const;
869 virtual PortType get_input_port_type(int p_port) const;
870 virtual String get_input_port_name(int p_port) const;
871
872 virtual int get_output_port_count() const;
873 virtual PortType get_output_port_type(int p_port) const;
874 virtual String get_output_port_name(int p_port) const;
875
876 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
877
878 VisualShaderNodeVectorClamp();
879 };
880
881 ///////////////////////////////////////
882 /// DERIVATIVE FUNCTIONS
883 ///////////////////////////////////////
884
885 class VisualShaderNodeScalarDerivativeFunc : public VisualShaderNode {
886 GDCLASS(VisualShaderNodeScalarDerivativeFunc, VisualShaderNode);
887
888 public:
889 enum Function {
890 FUNC_SUM,
891 FUNC_X,
892 FUNC_Y
893 };
894
895 protected:
896 Function func;
897
898 static void _bind_methods();
899
900 public:
901 virtual String get_caption() const;
902
903 virtual int get_input_port_count() const;
904 virtual PortType get_input_port_type(int p_port) const;
905 virtual String get_input_port_name(int p_port) const;
906
907 virtual int get_output_port_count() const;
908 virtual PortType get_output_port_type(int p_port) const;
909 virtual String get_output_port_name(int p_port) const;
910
911 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
912
913 void set_function(Function p_func);
914 Function get_function() const;
915
916 virtual Vector<StringName> get_editable_properties() const;
917
918 VisualShaderNodeScalarDerivativeFunc();
919 };
920
VARIANT_ENUM_CAST(VisualShaderNodeScalarDerivativeFunc::Function)921 VARIANT_ENUM_CAST(VisualShaderNodeScalarDerivativeFunc::Function)
922
923 ///////////////////////////////////////
924
925 class VisualShaderNodeVectorDerivativeFunc : public VisualShaderNode {
926 GDCLASS(VisualShaderNodeVectorDerivativeFunc, VisualShaderNode);
927
928 public:
929 enum Function {
930 FUNC_SUM,
931 FUNC_X,
932 FUNC_Y
933 };
934
935 protected:
936 Function func;
937
938 static void _bind_methods();
939
940 public:
941 virtual String get_caption() const;
942
943 virtual int get_input_port_count() const;
944 virtual PortType get_input_port_type(int p_port) const;
945 virtual String get_input_port_name(int p_port) const;
946
947 virtual int get_output_port_count() const;
948 virtual PortType get_output_port_type(int p_port) const;
949 virtual String get_output_port_name(int p_port) const;
950
951 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
952
953 void set_function(Function p_func);
954 Function get_function() const;
955
956 virtual Vector<StringName> get_editable_properties() const;
957
958 VisualShaderNodeVectorDerivativeFunc();
959 };
960
VARIANT_ENUM_CAST(VisualShaderNodeVectorDerivativeFunc::Function)961 VARIANT_ENUM_CAST(VisualShaderNodeVectorDerivativeFunc::Function)
962
963 ///////////////////////////////////////
964 /// FACEFORWARD
965 ///////////////////////////////////////
966
967 class VisualShaderNodeFaceForward : public VisualShaderNode {
968 GDCLASS(VisualShaderNodeFaceForward, VisualShaderNode);
969
970 public:
971 virtual String get_caption() const;
972
973 virtual int get_input_port_count() const;
974 virtual PortType get_input_port_type(int p_port) const;
975 virtual String get_input_port_name(int p_port) const;
976
977 virtual int get_output_port_count() const;
978 virtual PortType get_output_port_type(int p_port) const;
979 virtual String get_output_port_name(int p_port) const;
980
981 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
982
983 VisualShaderNodeFaceForward();
984 };
985
986 ///////////////////////////////////////
987 /// OUTER PRODUCT
988 ///////////////////////////////////////
989
990 class VisualShaderNodeOuterProduct : public VisualShaderNode {
991 GDCLASS(VisualShaderNodeOuterProduct, VisualShaderNode);
992
993 public:
994 virtual String get_caption() const;
995
996 virtual int get_input_port_count() const;
997 virtual PortType get_input_port_type(int p_port) const;
998 virtual String get_input_port_name(int p_port) const;
999
1000 virtual int get_output_port_count() const;
1001 virtual PortType get_output_port_type(int p_port) const;
1002 virtual String get_output_port_name(int p_port) const;
1003
1004 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1005
1006 VisualShaderNodeOuterProduct();
1007 };
1008
1009 ///////////////////////////////////////
1010 /// STEP
1011 ///////////////////////////////////////
1012
1013 class VisualShaderNodeVectorScalarStep : public VisualShaderNode {
1014 GDCLASS(VisualShaderNodeVectorScalarStep, VisualShaderNode);
1015
1016 public:
1017 virtual String get_caption() const;
1018
1019 virtual int get_input_port_count() const;
1020 virtual PortType get_input_port_type(int p_port) const;
1021 virtual String get_input_port_name(int p_port) const;
1022
1023 virtual int get_output_port_count() const;
1024 virtual PortType get_output_port_type(int p_port) const;
1025 virtual String get_output_port_name(int p_port) const;
1026
1027 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1028
1029 VisualShaderNodeVectorScalarStep();
1030 };
1031
1032 ///////////////////////////////////////
1033 /// SMOOTHSTEP
1034 ///////////////////////////////////////
1035
1036 class VisualShaderNodeScalarSmoothStep : public VisualShaderNode {
1037 GDCLASS(VisualShaderNodeScalarSmoothStep, VisualShaderNode);
1038
1039 public:
1040 virtual String get_caption() const;
1041
1042 virtual int get_input_port_count() const;
1043 virtual PortType get_input_port_type(int p_port) const;
1044 virtual String get_input_port_name(int p_port) const;
1045
1046 virtual int get_output_port_count() const;
1047 virtual PortType get_output_port_type(int p_port) const;
1048 virtual String get_output_port_name(int p_port) const;
1049
1050 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1051
1052 VisualShaderNodeScalarSmoothStep();
1053 };
1054
1055 ///////////////////////////////////////
1056
1057 class VisualShaderNodeVectorSmoothStep : public VisualShaderNode {
1058 GDCLASS(VisualShaderNodeVectorSmoothStep, VisualShaderNode);
1059
1060 public:
1061 virtual String get_caption() const;
1062
1063 virtual int get_input_port_count() const;
1064 virtual PortType get_input_port_type(int p_port) const;
1065 virtual String get_input_port_name(int p_port) const;
1066
1067 virtual int get_output_port_count() const;
1068 virtual PortType get_output_port_type(int p_port) const;
1069 virtual String get_output_port_name(int p_port) const;
1070
1071 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1072
1073 VisualShaderNodeVectorSmoothStep();
1074 };
1075
1076 ///////////////////////////////////////
1077
1078 class VisualShaderNodeVectorScalarSmoothStep : public VisualShaderNode {
1079 GDCLASS(VisualShaderNodeVectorScalarSmoothStep, VisualShaderNode);
1080
1081 public:
1082 virtual String get_caption() const;
1083
1084 virtual int get_input_port_count() const;
1085 virtual PortType get_input_port_type(int p_port) const;
1086 virtual String get_input_port_name(int p_port) const;
1087
1088 virtual int get_output_port_count() const;
1089 virtual PortType get_output_port_type(int p_port) const;
1090 virtual String get_output_port_name(int p_port) const;
1091
1092 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1093
1094 VisualShaderNodeVectorScalarSmoothStep();
1095 };
1096
1097 ///////////////////////////////////////
1098 /// DISTANCE
1099 ///////////////////////////////////////
1100
1101 class VisualShaderNodeVectorDistance : public VisualShaderNode {
1102 GDCLASS(VisualShaderNodeVectorDistance, VisualShaderNode);
1103
1104 public:
1105 virtual String get_caption() const;
1106
1107 virtual int get_input_port_count() const;
1108 virtual PortType get_input_port_type(int p_port) const;
1109 virtual String get_input_port_name(int p_port) const;
1110
1111 virtual int get_output_port_count() const;
1112 virtual PortType get_output_port_type(int p_port) const;
1113 virtual String get_output_port_name(int p_port) const;
1114
1115 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1116
1117 VisualShaderNodeVectorDistance();
1118 };
1119
1120 ///////////////////////////////////////
1121 /// REFRACT
1122 ///////////////////////////////////////
1123
1124 class VisualShaderNodeVectorRefract : public VisualShaderNode {
1125 GDCLASS(VisualShaderNodeVectorRefract, VisualShaderNode);
1126
1127 public:
1128 virtual String get_caption() const;
1129
1130 virtual int get_input_port_count() const;
1131 virtual PortType get_input_port_type(int p_port) const;
1132 virtual String get_input_port_name(int p_port) const;
1133
1134 virtual int get_output_port_count() const;
1135 virtual PortType get_output_port_type(int p_port) const;
1136 virtual String get_output_port_name(int p_port) const;
1137
1138 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1139
1140 VisualShaderNodeVectorRefract();
1141 };
1142
1143 ///////////////////////////////////////
1144 /// MIX
1145 ///////////////////////////////////////
1146
1147 class VisualShaderNodeScalarInterp : public VisualShaderNode {
1148 GDCLASS(VisualShaderNodeScalarInterp, VisualShaderNode);
1149
1150 public:
1151 virtual String get_caption() const;
1152
1153 virtual int get_input_port_count() const;
1154 virtual PortType get_input_port_type(int p_port) const;
1155 virtual String get_input_port_name(int p_port) const;
1156
1157 virtual int get_output_port_count() const;
1158 virtual PortType get_output_port_type(int p_port) const;
1159 virtual String get_output_port_name(int p_port) const;
1160
1161 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1162
1163 VisualShaderNodeScalarInterp();
1164 };
1165
1166 ///////////////////////////////////////
1167
1168 class VisualShaderNodeVectorInterp : public VisualShaderNode {
1169 GDCLASS(VisualShaderNodeVectorInterp, VisualShaderNode);
1170
1171 public:
1172 virtual String get_caption() const;
1173
1174 virtual int get_input_port_count() const;
1175 virtual PortType get_input_port_type(int p_port) const;
1176 virtual String get_input_port_name(int p_port) const;
1177
1178 virtual int get_output_port_count() const;
1179 virtual PortType get_output_port_type(int p_port) const;
1180 virtual String get_output_port_name(int p_port) const;
1181
1182 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1183
1184 VisualShaderNodeVectorInterp();
1185 };
1186
1187 ///////////////////////////////////////
1188
1189 class VisualShaderNodeVectorScalarMix : public VisualShaderNode {
1190 GDCLASS(VisualShaderNodeVectorScalarMix, VisualShaderNode);
1191
1192 public:
1193 virtual String get_caption() const;
1194
1195 virtual int get_input_port_count() const;
1196 virtual PortType get_input_port_type(int p_port) const;
1197 virtual String get_input_port_name(int p_port) const;
1198
1199 virtual int get_output_port_count() const;
1200 virtual PortType get_output_port_type(int p_port) const;
1201 virtual String get_output_port_name(int p_port) const;
1202
1203 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1204
1205 VisualShaderNodeVectorScalarMix();
1206 };
1207
1208 ///////////////////////////////////////
1209 /// COMPOSE
1210 ///////////////////////////////////////
1211
1212 class VisualShaderNodeVectorCompose : public VisualShaderNode {
1213 GDCLASS(VisualShaderNodeVectorCompose, VisualShaderNode);
1214
1215 public:
1216 virtual String get_caption() const;
1217
1218 virtual int get_input_port_count() const;
1219 virtual PortType get_input_port_type(int p_port) const;
1220 virtual String get_input_port_name(int p_port) const;
1221
1222 virtual int get_output_port_count() const;
1223 virtual PortType get_output_port_type(int p_port) const;
1224 virtual String get_output_port_name(int p_port) const;
1225
1226 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1227
1228 VisualShaderNodeVectorCompose();
1229 };
1230
1231 ///////////////////////////////////////
1232
1233 class VisualShaderNodeTransformCompose : public VisualShaderNode {
1234 GDCLASS(VisualShaderNodeTransformCompose, VisualShaderNode);
1235
1236 public:
1237 virtual String get_caption() const;
1238
1239 virtual int get_input_port_count() const;
1240 virtual PortType get_input_port_type(int p_port) const;
1241 virtual String get_input_port_name(int p_port) const;
1242
1243 virtual int get_output_port_count() const;
1244 virtual PortType get_output_port_type(int p_port) const;
1245 virtual String get_output_port_name(int p_port) const;
1246
1247 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1248
1249 VisualShaderNodeTransformCompose();
1250 };
1251
1252 ///////////////////////////////////////
1253 /// DECOMPOSE
1254 ///////////////////////////////////////
1255
1256 class VisualShaderNodeVectorDecompose : public VisualShaderNode {
1257 GDCLASS(VisualShaderNodeVectorDecompose, VisualShaderNode);
1258
1259 public:
1260 virtual String get_caption() const;
1261
1262 virtual int get_input_port_count() const;
1263 virtual PortType get_input_port_type(int p_port) const;
1264 virtual String get_input_port_name(int p_port) const;
1265
1266 virtual int get_output_port_count() const;
1267 virtual PortType get_output_port_type(int p_port) const;
1268 virtual String get_output_port_name(int p_port) const;
1269
1270 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1271
1272 VisualShaderNodeVectorDecompose();
1273 };
1274
1275 ///////////////////////////////////////
1276
1277 class VisualShaderNodeTransformDecompose : public VisualShaderNode {
1278 GDCLASS(VisualShaderNodeTransformDecompose, VisualShaderNode);
1279
1280 public:
1281 virtual String get_caption() const;
1282
1283 virtual int get_input_port_count() const;
1284 virtual PortType get_input_port_type(int p_port) const;
1285 virtual String get_input_port_name(int p_port) const;
1286
1287 virtual int get_output_port_count() const;
1288 virtual PortType get_output_port_type(int p_port) const;
1289 virtual String get_output_port_name(int p_port) const;
1290
1291 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1292
1293 VisualShaderNodeTransformDecompose();
1294 };
1295
1296 ///////////////////////////////////////
1297 /// UNIFORMS
1298 ///////////////////////////////////////
1299
1300 class VisualShaderNodeScalarUniform : public VisualShaderNodeUniform {
1301 GDCLASS(VisualShaderNodeScalarUniform, VisualShaderNodeUniform);
1302
1303 public:
1304 virtual String get_caption() const;
1305
1306 virtual int get_input_port_count() const;
1307 virtual PortType get_input_port_type(int p_port) const;
1308 virtual String get_input_port_name(int p_port) const;
1309
1310 virtual int get_output_port_count() const;
1311 virtual PortType get_output_port_type(int p_port) const;
1312 virtual String get_output_port_name(int p_port) const;
1313
1314 virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
1315 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1316
1317 VisualShaderNodeScalarUniform();
1318 };
1319
1320 ///////////////////////////////////////
1321
1322 class VisualShaderNodeBooleanUniform : public VisualShaderNodeUniform {
1323 GDCLASS(VisualShaderNodeBooleanUniform, VisualShaderNodeUniform);
1324
1325 public:
1326 virtual String get_caption() const;
1327
1328 virtual int get_input_port_count() const;
1329 virtual PortType get_input_port_type(int p_port) const;
1330 virtual String get_input_port_name(int p_port) const;
1331
1332 virtual int get_output_port_count() const;
1333 virtual PortType get_output_port_type(int p_port) const;
1334 virtual String get_output_port_name(int p_port) const;
1335
1336 virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
1337 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1338
1339 VisualShaderNodeBooleanUniform();
1340 };
1341
1342 ///////////////////////////////////////
1343
1344 class VisualShaderNodeColorUniform : public VisualShaderNodeUniform {
1345 GDCLASS(VisualShaderNodeColorUniform, VisualShaderNodeUniform);
1346
1347 public:
1348 virtual String get_caption() const;
1349
1350 virtual int get_input_port_count() const;
1351 virtual PortType get_input_port_type(int p_port) const;
1352 virtual String get_input_port_name(int p_port) const;
1353
1354 virtual int get_output_port_count() const;
1355 virtual PortType get_output_port_type(int p_port) const;
1356 virtual String get_output_port_name(int p_port) const;
1357
1358 virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
1359 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1360
1361 VisualShaderNodeColorUniform();
1362 };
1363
1364 ///////////////////////////////////////
1365
1366 class VisualShaderNodeVec3Uniform : public VisualShaderNodeUniform {
1367 GDCLASS(VisualShaderNodeVec3Uniform, VisualShaderNodeUniform);
1368
1369 public:
1370 virtual String get_caption() const;
1371
1372 virtual int get_input_port_count() const;
1373 virtual PortType get_input_port_type(int p_port) const;
1374 virtual String get_input_port_name(int p_port) const;
1375
1376 virtual int get_output_port_count() const;
1377 virtual PortType get_output_port_type(int p_port) const;
1378 virtual String get_output_port_name(int p_port) const;
1379
1380 virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
1381 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1382
1383 VisualShaderNodeVec3Uniform();
1384 };
1385
1386 ///////////////////////////////////////
1387
1388 class VisualShaderNodeTransformUniform : public VisualShaderNodeUniform {
1389 GDCLASS(VisualShaderNodeTransformUniform, VisualShaderNodeUniform);
1390
1391 public:
1392 virtual String get_caption() const;
1393
1394 virtual int get_input_port_count() const;
1395 virtual PortType get_input_port_type(int p_port) const;
1396 virtual String get_input_port_name(int p_port) const;
1397
1398 virtual int get_output_port_count() const;
1399 virtual PortType get_output_port_type(int p_port) const;
1400 virtual String get_output_port_name(int p_port) const;
1401
1402 virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
1403 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1404
1405 VisualShaderNodeTransformUniform();
1406 };
1407
1408 ///////////////////////////////////////
1409
1410 class VisualShaderNodeTextureUniform : public VisualShaderNodeUniform {
1411 GDCLASS(VisualShaderNodeTextureUniform, VisualShaderNodeUniform);
1412
1413 public:
1414 enum TextureType {
1415 TYPE_DATA,
1416 TYPE_COLOR,
1417 TYPE_NORMALMAP,
1418 TYPE_ANISO,
1419 };
1420
1421 enum ColorDefault {
1422 COLOR_DEFAULT_WHITE,
1423 COLOR_DEFAULT_BLACK
1424 };
1425
1426 protected:
1427 TextureType texture_type;
1428 ColorDefault color_default;
1429
1430 protected:
1431 static void _bind_methods();
1432
1433 public:
1434 virtual String get_caption() const;
1435
1436 virtual int get_input_port_count() const;
1437 virtual PortType get_input_port_type(int p_port) const;
1438 virtual String get_input_port_name(int p_port) const;
1439 virtual String get_input_port_default_hint(int p_port) const;
1440
1441 virtual int get_output_port_count() const;
1442 virtual PortType get_output_port_type(int p_port) const;
1443 virtual String get_output_port_name(int p_port) const;
1444
1445 virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
1446 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1447
1448 Vector<StringName> get_editable_properties() const;
1449
1450 void set_texture_type(TextureType p_type);
1451 TextureType get_texture_type() const;
1452
1453 void set_color_default(ColorDefault p_default);
1454 ColorDefault get_color_default() const;
1455
1456 VisualShaderNodeTextureUniform();
1457 };
1458
1459 VARIANT_ENUM_CAST(VisualShaderNodeTextureUniform::TextureType)
VARIANT_ENUM_CAST(VisualShaderNodeTextureUniform::ColorDefault)1460 VARIANT_ENUM_CAST(VisualShaderNodeTextureUniform::ColorDefault)
1461
1462 ///////////////////////////////////////
1463
1464 class VisualShaderNodeTextureUniformTriplanar : public VisualShaderNodeTextureUniform {
1465 GDCLASS(VisualShaderNodeTextureUniformTriplanar, VisualShaderNodeTextureUniform);
1466
1467 public:
1468 virtual String get_caption() const;
1469
1470 virtual int get_input_port_count() const;
1471 virtual PortType get_input_port_type(int p_port) const;
1472 virtual String get_input_port_name(int p_port) const;
1473
1474 virtual String get_input_port_default_hint(int p_port) const;
1475
1476 virtual String generate_global_per_node(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
1477 virtual String generate_global_per_func(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
1478 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1479
1480 VisualShaderNodeTextureUniformTriplanar();
1481 };
1482
1483 ///////////////////////////////////////
1484
1485 class VisualShaderNodeCubeMapUniform : public VisualShaderNodeTextureUniform {
1486 GDCLASS(VisualShaderNodeCubeMapUniform, VisualShaderNodeTextureUniform);
1487
1488 public:
1489 virtual String get_caption() const;
1490
1491 virtual int get_input_port_count() const;
1492 virtual PortType get_input_port_type(int p_port) const;
1493 virtual String get_input_port_name(int p_port) const;
1494
1495 virtual int get_output_port_count() const;
1496 virtual PortType get_output_port_type(int p_port) const;
1497 virtual String get_output_port_name(int p_port) const;
1498
1499 virtual String get_input_port_default_hint(int p_port) const;
1500 virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
1501 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1502
1503 VisualShaderNodeCubeMapUniform();
1504 };
1505
1506 ///////////////////////////////////////
1507 /// IF
1508 ///////////////////////////////////////
1509
1510 class VisualShaderNodeIf : public VisualShaderNode {
1511 GDCLASS(VisualShaderNodeIf, VisualShaderNode);
1512
1513 public:
1514 virtual String get_caption() const;
1515
1516 virtual int get_input_port_count() const;
1517 virtual PortType get_input_port_type(int p_port) const;
1518 virtual String get_input_port_name(int p_port) const;
1519
1520 virtual int get_output_port_count() const;
1521 virtual PortType get_output_port_type(int p_port) const;
1522 virtual String get_output_port_name(int p_port) const;
1523
1524 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const;
1525
1526 VisualShaderNodeIf();
1527 };
1528
1529 ///////////////////////////////////////
1530 /// SWITCH
1531 ///////////////////////////////////////
1532
1533 class VisualShaderNodeSwitch : public VisualShaderNode {
1534 GDCLASS(VisualShaderNodeSwitch, VisualShaderNode);
1535
1536 public:
1537 virtual String get_caption() const;
1538
1539 virtual int get_input_port_count() const;
1540 virtual PortType get_input_port_type(int p_port) const;
1541 virtual String get_input_port_name(int p_port) const;
1542
1543 virtual int get_output_port_count() const;
1544 virtual PortType get_output_port_type(int p_port) const;
1545 virtual String get_output_port_name(int p_port) const;
1546
1547 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const;
1548
1549 VisualShaderNodeSwitch();
1550 };
1551
1552 class VisualShaderNodeScalarSwitch : public VisualShaderNodeSwitch {
1553 GDCLASS(VisualShaderNodeScalarSwitch, VisualShaderNodeSwitch);
1554
1555 public:
1556 virtual String get_caption() const;
1557
1558 virtual PortType get_input_port_type(int p_port) const;
1559 virtual PortType get_output_port_type(int p_port) const;
1560
1561 VisualShaderNodeScalarSwitch();
1562 };
1563
1564 ///////////////////////////////////////
1565 /// FRESNEL
1566 ///////////////////////////////////////
1567
1568 class VisualShaderNodeFresnel : public VisualShaderNode {
1569 GDCLASS(VisualShaderNodeFresnel, VisualShaderNode);
1570
1571 public:
1572 virtual String get_caption() const;
1573
1574 virtual int get_input_port_count() const;
1575 virtual PortType get_input_port_type(int p_port) const;
1576 virtual String get_input_port_name(int p_port) const;
1577
1578 virtual int get_output_port_count() const;
1579 virtual PortType get_output_port_type(int p_port) const;
1580 virtual String get_output_port_name(int p_port) const;
1581
1582 virtual String get_input_port_default_hint(int p_port) const;
1583 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const;
1584
1585 VisualShaderNodeFresnel();
1586 };
1587
1588 ///////////////////////////////////////
1589 /// Is
1590 ///////////////////////////////////////
1591
1592 class VisualShaderNodeIs : public VisualShaderNode {
1593 GDCLASS(VisualShaderNodeIs, VisualShaderNode);
1594
1595 public:
1596 enum Function {
1597 FUNC_IS_INF,
1598 FUNC_IS_NAN,
1599 };
1600
1601 protected:
1602 Function func;
1603
1604 protected:
1605 static void _bind_methods();
1606
1607 public:
1608 virtual String get_caption() const;
1609
1610 virtual int get_input_port_count() const;
1611 virtual PortType get_input_port_type(int p_port) const;
1612 virtual String get_input_port_name(int p_port) const;
1613
1614 virtual int get_output_port_count() const;
1615 virtual PortType get_output_port_type(int p_port) const;
1616 virtual String get_output_port_name(int p_port) const;
1617
1618 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1619
1620 void set_function(Function p_func);
1621 Function get_function() const;
1622
1623 virtual Vector<StringName> get_editable_properties() const;
1624
1625 VisualShaderNodeIs();
1626 };
1627
VARIANT_ENUM_CAST(VisualShaderNodeIs::Function)1628 VARIANT_ENUM_CAST(VisualShaderNodeIs::Function)
1629
1630 ///////////////////////////////////////
1631 /// Compare
1632 ///////////////////////////////////////
1633
1634 class VisualShaderNodeCompare : public VisualShaderNode {
1635 GDCLASS(VisualShaderNodeCompare, VisualShaderNode);
1636
1637 public:
1638 enum ComparisonType {
1639 CTYPE_SCALAR,
1640 CTYPE_VECTOR,
1641 CTYPE_BOOLEAN,
1642 CTYPE_TRANSFORM
1643 };
1644
1645 enum Function {
1646 FUNC_EQUAL,
1647 FUNC_NOT_EQUAL,
1648 FUNC_GREATER_THAN,
1649 FUNC_GREATER_THAN_EQUAL,
1650 FUNC_LESS_THAN,
1651 FUNC_LESS_THAN_EQUAL,
1652 };
1653
1654 enum Condition {
1655 COND_ALL,
1656 COND_ANY,
1657 };
1658
1659 protected:
1660 ComparisonType ctype;
1661 Function func;
1662 Condition condition;
1663
1664 protected:
1665 static void _bind_methods();
1666
1667 public:
1668 virtual String get_caption() const;
1669
1670 virtual int get_input_port_count() const;
1671 virtual PortType get_input_port_type(int p_port) const;
1672 virtual String get_input_port_name(int p_port) const;
1673
1674 virtual int get_output_port_count() const;
1675 virtual PortType get_output_port_type(int p_port) const;
1676 virtual String get_output_port_name(int p_port) const;
1677
1678 virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
1679
1680 void set_comparison_type(ComparisonType p_type);
1681 ComparisonType get_comparison_type() const;
1682
1683 void set_function(Function p_func);
1684 Function get_function() const;
1685
1686 void set_condition(Condition p_cond);
1687 Condition get_condition() const;
1688
1689 virtual Vector<StringName> get_editable_properties() const;
1690 virtual String get_warning(Shader::Mode p_mode, VisualShader::Type p_type) const;
1691
1692 VisualShaderNodeCompare();
1693 };
1694
1695 VARIANT_ENUM_CAST(VisualShaderNodeCompare::ComparisonType)
1696 VARIANT_ENUM_CAST(VisualShaderNodeCompare::Function)
1697 VARIANT_ENUM_CAST(VisualShaderNodeCompare::Condition)
1698
1699 #endif // VISUAL_SHADER_NODES_H
1700