Blender  V2.93
svm_attribute.h
Go to the documentation of this file.
1 /*
2  * Copyright 2011-2013 Blender Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 CCL_NAMESPACE_BEGIN
18 
19 /* Attribute Node */
20 
21 ccl_device AttributeDescriptor svm_node_attr_init(
22  KernelGlobals *kg, ShaderData *sd, uint4 node, NodeAttributeOutputType *type, uint *out_offset)
23 {
24  *out_offset = node.z;
25  *type = (NodeAttributeOutputType)node.w;
26 
27  AttributeDescriptor desc;
28 
29  if (sd->object != OBJECT_NONE) {
30  desc = find_attribute(kg, sd, node.y);
31  if (desc.offset == ATTR_STD_NOT_FOUND) {
32  desc = attribute_not_found();
33  desc.offset = 0;
34  desc.type = (NodeAttributeType)node.w;
35  }
36  }
37  else {
38  /* background */
39  desc = attribute_not_found();
40  desc.offset = 0;
41  desc.type = (NodeAttributeType)node.w;
42  }
43 
44  return desc;
45 }
46 
47 ccl_device void svm_node_attr(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node)
48 {
49  NodeAttributeOutputType type = NODE_ATTR_OUTPUT_FLOAT;
50  uint out_offset = 0;
51  AttributeDescriptor desc = svm_node_attr_init(kg, sd, node, &type, &out_offset);
52 
53 #ifdef __VOLUME__
54  /* Volumes
55  * NOTE: moving this into its own node type might help improve performance. */
56  if (primitive_is_volume_attribute(sd, desc)) {
57  const float4 value = volume_attribute_float4(kg, sd, desc);
58 
59  if (type == NODE_ATTR_OUTPUT_FLOAT) {
60  const float f = volume_attribute_value_to_float(value);
61  stack_store_float(stack, out_offset, f);
62  }
63  else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
64  const float3 f = volume_attribute_value_to_float3(value);
65  stack_store_float3(stack, out_offset, f);
66  }
67  else {
68  const float f = volume_attribute_value_to_alpha(value);
69  stack_store_float(stack, out_offset, f);
70  }
71  return;
72  }
73 #endif
74 
75  /* Surface. */
76  if (desc.type == NODE_ATTR_FLOAT) {
77  float f = primitive_surface_attribute_float(kg, sd, desc, NULL, NULL);
78  if (type == NODE_ATTR_OUTPUT_FLOAT) {
79  stack_store_float(stack, out_offset, f);
80  }
81  else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
82  stack_store_float3(stack, out_offset, make_float3(f, f, f));
83  }
84  else {
85  stack_store_float(stack, out_offset, 1.0f);
86  }
87  }
88  else if (desc.type == NODE_ATTR_FLOAT2) {
89  float2 f = primitive_surface_attribute_float2(kg, sd, desc, NULL, NULL);
90  if (type == NODE_ATTR_OUTPUT_FLOAT) {
91  stack_store_float(stack, out_offset, f.x);
92  }
93  else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
94  stack_store_float3(stack, out_offset, make_float3(f.x, f.y, 0.0f));
95  }
96  else {
97  stack_store_float(stack, out_offset, 1.0f);
98  }
99  }
100  else if (desc.type == NODE_ATTR_FLOAT4 || desc.type == NODE_ATTR_RGBA) {
101  float4 f = primitive_surface_attribute_float4(kg, sd, desc, NULL, NULL);
102  if (type == NODE_ATTR_OUTPUT_FLOAT) {
103  stack_store_float(stack, out_offset, average(float4_to_float3(f)));
104  }
105  else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
106  stack_store_float3(stack, out_offset, float4_to_float3(f));
107  }
108  else {
109  stack_store_float(stack, out_offset, f.w);
110  }
111  }
112  else {
113  float3 f = primitive_surface_attribute_float3(kg, sd, desc, NULL, NULL);
114  if (type == NODE_ATTR_OUTPUT_FLOAT) {
115  stack_store_float(stack, out_offset, average(f));
116  }
117  else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
118  stack_store_float3(stack, out_offset, f);
119  }
120  else {
121  stack_store_float(stack, out_offset, 1.0f);
122  }
123  }
124 }
125 
126 ccl_device void svm_node_attr_bump_dx(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node)
127 {
128  NodeAttributeOutputType type = NODE_ATTR_OUTPUT_FLOAT;
129  uint out_offset = 0;
130  AttributeDescriptor desc = svm_node_attr_init(kg, sd, node, &type, &out_offset);
131 
132 #ifdef __VOLUME__
133  /* Volume */
134  if (primitive_is_volume_attribute(sd, desc)) {
135  if (type == NODE_ATTR_OUTPUT_FLOAT) {
136  stack_store_float(stack, out_offset, 0.0f);
137  }
138  else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
139  stack_store_float3(stack, out_offset, make_float3(0.0f, 0.0f, 0.0f));
140  }
141  else {
142  stack_store_float(stack, out_offset, 1.0f);
143  }
144  return;
145  }
146 #endif
147 
148  /* Surface */
149  if (desc.type == NODE_ATTR_FLOAT) {
150  float dx;
151  float f = primitive_surface_attribute_float(kg, sd, desc, &dx, NULL);
152  if (type == NODE_ATTR_OUTPUT_FLOAT) {
153  stack_store_float(stack, out_offset, f + dx);
154  }
155  else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
156  stack_store_float3(stack, out_offset, make_float3(f + dx, f + dx, f + dx));
157  }
158  else {
159  stack_store_float(stack, out_offset, 1.0f);
160  }
161  }
162  else if (desc.type == NODE_ATTR_FLOAT2) {
163  float2 dx;
164  float2 f = primitive_surface_attribute_float2(kg, sd, desc, &dx, NULL);
165  if (type == NODE_ATTR_OUTPUT_FLOAT) {
166  stack_store_float(stack, out_offset, f.x + dx.x);
167  }
168  else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
169  stack_store_float3(stack, out_offset, make_float3(f.x + dx.x, f.y + dx.y, 0.0f));
170  }
171  else {
172  stack_store_float(stack, out_offset, 1.0f);
173  }
174  }
175  else if (desc.type == NODE_ATTR_FLOAT4 || desc.type == NODE_ATTR_RGBA) {
176  float4 dx;
177  float4 f = primitive_surface_attribute_float4(kg, sd, desc, &dx, NULL);
178  if (type == NODE_ATTR_OUTPUT_FLOAT) {
179  stack_store_float(stack, out_offset, average(float4_to_float3(f + dx)));
180  }
181  else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
182  stack_store_float3(stack, out_offset, float4_to_float3(f + dx));
183  }
184  else {
185  stack_store_float(stack, out_offset, f.w + dx.w);
186  }
187  }
188  else {
189  float3 dx;
190  float3 f = primitive_surface_attribute_float3(kg, sd, desc, &dx, NULL);
191  if (type == NODE_ATTR_OUTPUT_FLOAT) {
192  stack_store_float(stack, out_offset, average(f + dx));
193  }
194  else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
195  stack_store_float3(stack, out_offset, f + dx);
196  }
197  else {
198  stack_store_float(stack, out_offset, 1.0f);
199  }
200  }
201 }
202 
203 ccl_device void svm_node_attr_bump_dy(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node)
204 {
205  NodeAttributeOutputType type = NODE_ATTR_OUTPUT_FLOAT;
206  uint out_offset = 0;
207  AttributeDescriptor desc = svm_node_attr_init(kg, sd, node, &type, &out_offset);
208 
209 #ifdef __VOLUME__
210  /* Volume */
211  if (primitive_is_volume_attribute(sd, desc)) {
212  if (type == NODE_ATTR_OUTPUT_FLOAT) {
213  stack_store_float(stack, out_offset, 0.0f);
214  }
215  else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
216  stack_store_float3(stack, out_offset, make_float3(0.0f, 0.0f, 0.0f));
217  }
218  else {
219  stack_store_float(stack, out_offset, 1.0f);
220  }
221  return;
222  }
223 #endif
224 
225  /* Surface */
226  if (desc.type == NODE_ATTR_FLOAT) {
227  float dy;
228  float f = primitive_surface_attribute_float(kg, sd, desc, NULL, &dy);
229  if (type == NODE_ATTR_OUTPUT_FLOAT) {
230  stack_store_float(stack, out_offset, f + dy);
231  }
232  else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
233  stack_store_float3(stack, out_offset, make_float3(f + dy, f + dy, f + dy));
234  }
235  else {
236  stack_store_float(stack, out_offset, 1.0f);
237  }
238  }
239  else if (desc.type == NODE_ATTR_FLOAT2) {
240  float2 dy;
241  float2 f = primitive_surface_attribute_float2(kg, sd, desc, NULL, &dy);
242  if (type == NODE_ATTR_OUTPUT_FLOAT) {
243  stack_store_float(stack, out_offset, f.x + dy.x);
244  }
245  else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
246  stack_store_float3(stack, out_offset, make_float3(f.x + dy.x, f.y + dy.y, 0.0f));
247  }
248  else {
249  stack_store_float(stack, out_offset, 1.0f);
250  }
251  }
252  else if (desc.type == NODE_ATTR_FLOAT4 || desc.type == NODE_ATTR_RGBA) {
253  float4 dy;
254  float4 f = primitive_surface_attribute_float4(kg, sd, desc, NULL, &dy);
255  if (type == NODE_ATTR_OUTPUT_FLOAT) {
256  stack_store_float(stack, out_offset, average(float4_to_float3(f + dy)));
257  }
258  else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
259  stack_store_float3(stack, out_offset, float4_to_float3(f + dy));
260  }
261  else {
262  stack_store_float(stack, out_offset, f.w + dy.w);
263  }
264  }
265  else {
266  float3 dy;
267  float3 f = primitive_surface_attribute_float3(kg, sd, desc, NULL, &dy);
268  if (type == NODE_ATTR_OUTPUT_FLOAT) {
269  stack_store_float(stack, out_offset, average(f + dy));
270  }
271  else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
272  stack_store_float3(stack, out_offset, f + dy);
273  }
274  else {
275  stack_store_float(stack, out_offset, 1.0f);
276  }
277  }
278 }
279 
280 CCL_NAMESPACE_END
uint
unsigned int uint
Definition: BLI_sys_types.h:83
type
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum type
Definition: GPU_legacy_stubs.h:167
NULL
return NULL
Definition: bmesh_operator_api_inline.h:224
if
if(data)
Definition: bmesh_operator_api_inline.h:177
node
OperationNode * node
Definition: deg_builder_cycle.cc:54
attribute_not_found
ccl_device_inline AttributeDescriptor attribute_not_found()
Definition: geom_attribute.h:40
find_attribute
ccl_device_inline AttributeDescriptor find_attribute(KernelGlobals *kg, const ShaderData *sd, uint id)
Definition: geom_attribute.h:54
primitive_surface_attribute_float4
ccl_device_inline float4 primitive_surface_attribute_float4(KernelGlobals *kg, const ShaderData *sd, const AttributeDescriptor desc, float4 *dx, float4 *dy)
Definition: geom_primitive.h:105
primitive_surface_attribute_float2
ccl_device_inline float2 primitive_surface_attribute_float2(KernelGlobals *kg, const ShaderData *sd, const AttributeDescriptor desc, float2 *dx, float2 *dy)
Definition: geom_primitive.h:53
primitive_surface_attribute_float
CCL_NAMESPACE_BEGIN ccl_device_inline float primitive_surface_attribute_float(KernelGlobals *kg, const ShaderData *sd, const AttributeDescriptor desc, float *dx, float *dy)
Definition: geom_primitive.h:30
primitive_surface_attribute_float3
ccl_device_inline float3 primitive_surface_attribute_float3(KernelGlobals *kg, const ShaderData *sd, const AttributeDescriptor desc, float3 *dx, float3 *dy)
Definition: geom_primitive.h:79
stack_store_float3
ccl_device_inline void stack_store_float3(float *stack, uint a, float3 f)
Definition: kernel/svm/svm.h:54
stack_store_float
ccl_device_inline void stack_store_float(float *stack, uint a, float f)
Definition: kernel/svm/svm.h:75
ccl_device
#define ccl_device
Definition: kernel_compat_cuda.h:59
CCL_NAMESPACE_END
#define CCL_NAMESPACE_END
Definition: kernel_compat_cuda.h:23
make_float3
#define make_float3(x, y, z)
Definition: kernel_compat_opencl.h:109
kg
kg
Definition: kernel_split_function.h:63
ATTR_STD_NOT_FOUND
@ ATTR_STD_NOT_FOUND
Definition: kernel_types.h:773
OBJECT_NONE
#define OBJECT_NONE
Definition: kernel_types.h:59
ShaderData
ShaderData
Definition: kernel_types.h:1015
CCL_NAMESPACE_BEGIN
Definition: blender_python.cpp:54
AttributeDescriptor::type
NodeAttributeType type
Definition: kernel_types.h:783
svm_node_attr_bump_dx
ccl_device void svm_node_attr_bump_dx(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node)
Definition: svm_attribute.h:126
svm_node_attr_init
CCL_NAMESPACE_BEGIN ccl_device AttributeDescriptor svm_node_attr_init(KernelGlobals *kg, ShaderData *sd, uint4 node, NodeAttributeOutputType *type, uint *out_offset)
Definition: svm_attribute.h:21
svm_node_attr
ccl_device void svm_node_attr(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node)
Definition: svm_attribute.h:47
svm_node_attr_bump_dy
ccl_device void svm_node_attr_bump_dy(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node)
Definition: svm_attribute.h:203
NodeAttributeOutputType
NodeAttributeOutputType
Definition: svm_types.h:160
NODE_ATTR_OUTPUT_FLOAT
@ NODE_ATTR_OUTPUT_FLOAT
Definition: svm_types.h:162
NODE_ATTR_OUTPUT_FLOAT3
@ NODE_ATTR_OUTPUT_FLOAT3
Definition: svm_types.h:161
NodeAttributeType
NodeAttributeType
Definition: svm_types.h:166
NODE_ATTR_FLOAT
@ NODE_ATTR_FLOAT
Definition: svm_types.h:167
NODE_ATTR_RGBA
@ NODE_ATTR_RGBA
Definition: svm_types.h:171
NODE_ATTR_FLOAT2
@ NODE_ATTR_FLOAT2
Definition: svm_types.h:168
NODE_ATTR_FLOAT4
@ NODE_ATTR_FLOAT4
Definition: svm_types.h:170
float4_to_float3
ccl_device_inline float3 float4_to_float3(const float4 a)
Definition: util_math.h:415
average
ccl_device_inline float average(const float2 &a)
Definition: util_math_float2.h:183
Generated on Tue Jan 31 2023 14:37:24 for Blender by  doxygen 1.9.1