Blender V5.3
displace.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
10
12#include "kernel/svm/util.h"
13
15
17
18/* Bump Node */
19template<uint64_t node_feature_mask>
21 ccl_private ShaderData *sd,
22 ccl_private float *stack,
24{
25#ifdef __RAY_DIFFERENTIALS__
27 /* get normal input */
28 float3 normal_in = stack_load_float3_default(stack, node.normal_offset, sd->N);
29
30 /* If we have saved bump state, read the full differential from there.
31 * Just using the compact form in those cases leads to incorrect normals (see #111588). */
33 if (node.bump_state_offset == SVM_STACK_INVALID) {
34 dP = differential_from_compact(sd->Ng, sd->dP);
35 }
36 else {
37 dP.dx = stack_load_float3(stack, node.bump_state_offset + 4);
38 dP.dy = stack_load_float3(stack, node.bump_state_offset + 7);
39 }
40
41 if (node.use_object_space) {
42 object_inverse_normal_transform(kg, sd, &normal_in);
45 }
46
47 /* get surface tangents from normal */
48 const float3 Rx = cross(dP.dy, normal_in);
49 const float3 Ry = cross(normal_in, dP.dx);
50
51 /* get bump values */
52 const float h_c = stack_load_float(stack, node.center_offset);
53 const float h_x = stack_load_float(stack, node.dx_offset);
54 const float h_y = stack_load_float(stack, node.dy_offset);
55
56 /* compute surface gradient and determinant */
57 const float det = dot(dP.dx, Rx);
58 const float3 surfgrad = (h_x - h_c) * Rx + (h_y - h_c) * Ry;
59
60 const float absdet = fabsf(det);
61
62 float strength = stack_load(stack, node.strength);
63 float scale = stack_load(stack, node.scale);
64
65 if (node.invert) {
66 scale *= -1.0f;
67 }
68
69 strength = max(strength, 0.0f);
70
71 /* Compute and output perturbed normal.
72 * dP'dx = dPdx + scale * (h_x - h_c) / filter_width * normal
73 * dP'dy = dPdy + scale * (h_y - h_c) / filter_width * normal
74 * N' = cross(dP'dx, dP'dy)
75 * = cross(dPdx, dPdy) - scale * ((h_y - h_c) / filter_width * Ry + (h_x - h_c) /
76 * filter_width * Rx) ≈ det * normal_in - scale * surfgrad / filter_width
77 */
78 float3 normal_out = safe_normalize(node.bump_filter_width * absdet * normal_in -
79 scale * signf(det) * surfgrad);
80 if (is_zero(normal_out)) {
81 normal_out = normal_in;
82 }
83 else {
84 normal_out = normalize(strength * normal_out + (1.0f - strength) * normal_in);
85 }
86
87 if (node.use_object_space) {
88 object_normal_transform(kg, sd, &normal_out);
89 }
90
91 stack_store_float3(stack, node.out_offset, normal_out);
92 }
93 else {
94 stack_store_float3(stack, node.out_offset, zero_float3());
95 }
96#endif
97}
98
99/* Displacement Node */
100
101template<uint64_t node_feature_mask>
103 ccl_private float *stack,
105{
107 const float3 dP = stack_load_float3(stack, node.fac_offset);
108 sd->P += dP;
109 }
110}
111
112template<uint64_t node_feature_mask>
114 ccl_private ShaderData *sd,
115 ccl_private float *stack,
117{
119 const float height = stack_load(stack, node.height);
120 const float midlevel = stack_load(stack, node.midlevel);
121 const float scale = stack_load(stack, node.scale);
122 const float3 normal = stack_load_float3_default(stack, node.normal_offset, sd->N);
123
124 float3 dP = normal;
125
126 if (node.space == NODE_NORMAL_MAP_OBJECT) {
127 /* Object space. */
129 dP *= (height - midlevel) * scale;
130 object_dir_transform(kg, sd, &dP);
131 }
132 else {
133 /* World space. */
134 dP *= (height - midlevel) * scale;
135 }
136
137 stack_store_float3(stack, node.out_offset, dP);
138 }
139 else {
140 stack_store_float3(stack, node.out_offset, zero_float3());
141 }
142}
143
144template<uint64_t node_feature_mask>
146 KernelGlobals kg,
147 ccl_private ShaderData *sd,
148 ccl_private float *stack,
150{
152 const float3 vector = stack_load(stack, node.vector);
153 const float midlevel = stack_load(stack, node.midlevel);
154 const float scale = stack_load(stack, node.scale);
155 float3 dP = (vector - make_float3(midlevel, midlevel, midlevel)) * scale;
156
157 if (node.space == NODE_NORMAL_MAP_TANGENT) {
158 /* Tangent space. */
159 float3 normal = sd->N;
160 object_inverse_normal_transform(kg, sd, &normal);
161
162 const AttributeDescriptor attr = find_attribute(kg, sd, node.attr);
163 float3 tangent;
164 if (is_attribute_found(attr)) {
165 tangent = primitive_surface_attribute<float3>(kg, sd, attr);
166 }
167 else {
168 tangent = normalize(sd->dPdu);
169 }
170
171 float3 bitangent = safe_normalize(cross(normal, tangent));
172 const AttributeDescriptor attr_sign = find_attribute(kg, sd, node.attr_sign);
173 if (is_attribute_found(attr_sign)) {
174 const float sign = primitive_surface_attribute<float>(kg, sd, attr_sign);
175 bitangent *= sign;
176 }
177
178 dP = tangent * dP.x + normal * dP.y + bitangent * dP.z;
179 }
180
181 if (node.space != NODE_NORMAL_MAP_WORLD) {
182 /* Tangent or object space. */
183 object_dir_transform(kg, sd, &dP);
184 }
185
186 stack_store_float3(stack, node.displacement_offset, dP);
187 }
188 else {
189 stack_store_float3(stack, node.displacement_offset, zero_float3());
190 }
191}
192
btScalar max
ccl_device_inline float3 stack_load_float3_default(const ccl_private float *stack, const uint a, const float3 value)
ccl_device_inline float3 stack_load_float3(const ccl_private float *stack, const uint a)
ccl_device_inline void stack_store_float3(ccl_private float *stack, const uint a, const float3 f)
CCL_NAMESPACE_BEGIN ccl_device_inline float stack_load_float(const ccl_private float *stack, const uint a)
ccl_device_inline T stack_load(const ccl_private float *stack, const uint a)
#define IF_KERNEL_NODES_FEATURE(feature)
#define ccl_private
#define SVM_STACK_INVALID
#define ccl_global
#define ccl_device_noinline
#define CCL_NAMESPACE_END
ccl_device_forceinline float3 make_float3(const float x, const float y, const float z)
ccl_device_forceinline differential3 differential_from_compact(const float3 D, const float dD)
ccl_device void svm_node_set_displacement(ccl_private ShaderData *sd, ccl_private float *stack, const ccl_global SVMNodeSetDisplacement &node)
Definition displace.h:102
ccl_device_noinline void svm_node_displacement(KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, const ccl_global SVMNodeDisplacement &node)
Definition displace.h:113
ccl_device_noinline void svm_node_vector_displacement(KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, const ccl_global SVMNodeVectorDisplacement &node)
Definition displace.h:145
CCL_NAMESPACE_BEGIN ccl_device_noinline void svm_node_set_bump(KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, const ccl_global SVMNodeSetBump &node)
Definition displace.h:20
VecBase< float, D > normalize(VecOp< float, D >) RET
float dot(VecOp< float, D >, VecOp< float, D >) RET
constexpr T sign(T) RET
VecBase< float, 3 > cross(VecOp< float, 3 >, VecOp< float, 3 >) RET
float3x3 scale(float3x3 mat, float2 scale)
bool is_zero(float3x3 a)
VecT safe_normalize(VecT vector)
CCL_NAMESPACE_BEGIN ccl_device_forceinline bool is_attribute_found(const ccl_private AttributeDescriptor &desc)
ccl_device_inline AttributeDescriptor find_attribute(const ccl_global AttributeMap *attributes_map, uint attr_offset, const int prim, const uint64_t id)
ccl_device_inline void object_dir_transform(KernelGlobals kg, const ccl_private ShaderData *sd, ccl_private float3 *D)
ccl_device_inline void object_normal_transform(KernelGlobals kg, const ccl_private ShaderData *sd, ccl_private T *N)
ccl_device_inline void object_inverse_dir_transform(KernelGlobals kg, const ccl_private ShaderData *sd, ccl_private float3 *D)
ccl_device_inline void object_inverse_normal_transform(KernelGlobals kg, const ccl_private ShaderData *sd, ccl_private float3 *N)
@ NODE_NORMAL_MAP_TANGENT
@ NODE_NORMAL_MAP_WORLD
@ NODE_NORMAL_MAP_OBJECT
ccl_device_inline float signf(const float f)
Definition math_base.h:502
CCL_NAMESPACE_BEGIN ccl_device_inline float3 zero_float3()
Definition math_float3.h:17
CCL_NAMESPACE_BEGIN ccl_device_forceinline T primitive_surface_attribute(KernelGlobals kg, const ccl_private ShaderData *sd, const AttributeDescriptor desc)
Definition primitive.h:32
#define fabsf
#define ccl_device
float z
Definition sky_math.h:136
float y
Definition sky_math.h:136
float x
Definition sky_math.h:136