1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
/* SPDX-License-Identifier: GPL-2.0-or-later */
#include "BLI_assert.h"
#include "BLI_math_vector.h"
#include "BLI_string_ref.hh"
#include "DNA_node_types.h"
#include "NOD_derived_node_tree.hh"
#include "GPU_material.h"
#include "COM_shader_node.hh"
#include "COM_utilities.hh"
namespace blender::realtime_compositor {
using namespace nodes::derived_node_tree_types;
ShaderNode::ShaderNode(DNode node) : node_(node)
{
populate_inputs();
populate_outputs();
}
GPUNodeStack *ShaderNode::get_inputs_array()
{
return inputs_.data();
}
GPUNodeStack *ShaderNode::get_outputs_array()
{
return outputs_.data();
}
GPUNodeStack &ShaderNode::get_input(StringRef identifier)
{
return inputs_[node_.input_by_identifier(identifier)->index()];
}
GPUNodeStack &ShaderNode::get_output(StringRef identifier)
{
return outputs_[node_.output_by_identifier(identifier)->index()];
}
GPUNodeLink *ShaderNode::get_input_link(StringRef identifier)
{
GPUNodeStack &input = get_input(identifier);
if (input.link) {
return input.link;
}
return GPU_uniform(input.vec);
}
const DNode &ShaderNode::node() const
{
return node_;
}
const bNode &ShaderNode::bnode() const
{
return *node_;
}
static eGPUType gpu_type_from_socket_type(eNodeSocketDatatype type)
{
switch (type) {
case SOCK_FLOAT:
return GPU_FLOAT;
case SOCK_VECTOR:
return GPU_VEC3;
case SOCK_RGBA:
return GPU_VEC4;
default:
BLI_assert_unreachable();
return GPU_NONE;
}
}
static void gpu_stack_vector_from_socket(float *vector, const bNodeSocket *socket)
{
switch (socket->type) {
case SOCK_FLOAT:
vector[0] = socket->default_value_typed<bNodeSocketValueFloat>()->value;
return;
case SOCK_VECTOR:
copy_v3_v3(vector, socket->default_value_typed<bNodeSocketValueVector>()->value);
return;
case SOCK_RGBA:
copy_v4_v4(vector, socket->default_value_typed<bNodeSocketValueRGBA>()->value);
return;
default:
BLI_assert_unreachable();
}
}
static void populate_gpu_node_stack(DSocket socket, GPUNodeStack &stack)
{
/* Make sure this stack is not marked as the end of the stack array. */
stack.end = false;
/* This will be initialized later by the GPU material compiler or the compile method. */
stack.link = nullptr;
stack.sockettype = socket->type;
stack.type = gpu_type_from_socket_type((eNodeSocketDatatype)socket->type);
if (socket->is_input()) {
const DInputSocket input(socket);
DSocket origin = get_input_origin_socket(input);
/* The input is linked if the origin socket is an output socket. Had it been an input socket,
* then it is an unlinked input of a group input node. */
stack.hasinput = origin->is_output();
/* Get the socket value from the origin if it is an input, because then it would either be an
* unlinked input or an unlinked input of a group input node that the socket is linked to,
* otherwise, get the value from the socket itself. */
if (origin->is_input()) {
gpu_stack_vector_from_socket(stack.vec, origin.bsocket());
}
else {
gpu_stack_vector_from_socket(stack.vec, socket.bsocket());
}
}
else {
stack.hasoutput = socket->is_logically_linked();
}
}
void ShaderNode::populate_inputs()
{
/* Reserve a stack for each input in addition to an extra stack at the end to mark the end of the
* array, as this is what the GPU module functions expect. */
const int num_input_sockets = node_->input_sockets().size();
inputs_.resize(num_input_sockets + 1);
inputs_.last().end = true;
for (int i = 0; i < num_input_sockets; i++) {
populate_gpu_node_stack(node_.input(i), inputs_[i]);
}
}
void ShaderNode::populate_outputs()
{
/* Reserve a stack for each output in addition to an extra stack at the end to mark the end of
* the array, as this is what the GPU module functions expect. */
const int num_output_sockets = node_->output_sockets().size();
outputs_.resize(num_output_sockets + 1);
outputs_.last().end = true;
for (int i = 0; i < num_output_sockets; i++) {
populate_gpu_node_stack(node_.output(i), outputs_[i]);
}
}
} // namespace blender::realtime_compositor
|
