21 const size_t object_index,
27 const array<int> &mesh_shaders = mesh->get_shader();
28 const array<Node *> &mesh_used_shaders = mesh->get_used_shaders();
34 for (
int i = 0; i < num_triangles; i++) {
36 const int shader_index = mesh_shaders[i];
37 Shader *shader = (shader_index < mesh_used_shaders.
size()) ?
38 static_cast<Shader *
>(mesh_used_shaders[shader_index]) :
45 for (
int j = 0; j < 3; j++) {
53 const int object = object_index;
79 d_input_data[d_input_size++] =
in;
91 const array<int> &mesh_shaders = mesh->get_shader();
92 const array<Node *> &mesh_used_shaders = mesh->get_used_shaders();
95 const int num_motion_steps = mesh->get_motion_steps();
98 const float *d_output_data = d_output.
data();
99 int d_output_index = 0;
106 for (
int i = 0; i < num_triangles; i++) {
108 const int shader_index = mesh_shaders[i];
109 Shader *shader = (shader_index < mesh_used_shaders.
size()) ?
110 static_cast<Shader *
>(mesh_used_shaders[shader_index]) :
117 for (
int j = 0; j < 3; j++) {
121 d_output_data[d_output_index + 1],
122 d_output_data[d_output_index + 2]);
127 mesh_verts[t.
v[j]] =
float3(mesh_verts[t.
v[j]]) + off;
128 if (attr_P !=
nullptr) {
131 mP[t.
v[j]] =
float3(mP[t.
v[j]]) + off;
149 for (
size_t i = 0; i < num_triangles; i++) {
150 if (tri_recompute[i]) {
152 for (
size_t j = 0; j < 3; j++) {
158 for (
size_t i = 0; i < num_triangles; i++) {
159 if (tri_recompute[i]) {
162 for (
size_t j = 0; j < 3; j++) {
163 vN[triangle.
v[j]] += fN;
178 const size_t num_verts = mesh->
num_verts();
182 if (tri_recompute[i]) {
184 for (
size_t j = 0; j < 3; j++) {
185 const int vert = triangle.
v[j];
211 const bool *
smooth = mesh->get_smooth().data();
214 if (!tri_recompute[i]) {
219 for (
size_t j = 0; j < 3; j++) {
220 const int vert = triangle.
v[j];
225 const float3 delta = post - pre_vN[vert];
234 for (
size_t j = 0; j < 3; j++) {
247 const size_t num_verts = mesh->
num_verts();
252 auto compute_normals = [&](
const packed_float3 *verts_data) {
257 for (
size_t i = 0; i < num_verts; i++) {
267 pre_displace_vN = compute_normals(mesh->
get_position());
272 const int num_steps = mesh->get_motion_steps() - 1;
273 pre_displace_motion_vN.resize(num_steps);
274 for (
int attr_step = 1; attr_step <= num_steps; attr_step++) {
276 pre_displace_motion_vN[attr_step - 1] = compute_normals(mP);
294 pre_displace_vN.
data(),
303 const size_t num_verts = mesh->
num_verts();
305 for (
int attr_step = 1; attr_step < mesh->get_motion_steps(); attr_step++) {
315 pre_displace_motion_vN[attr_step - 1].data(),
329 const size_t num_verts = mesh->
num_verts();
340 for (
int attr_step = 1; attr_step < mesh->get_motion_steps(); attr_step++) {
358 const size_t num_verts = mesh->
num_verts();
361 if (num_triangles == 0) {
369 bool need_recompute_vertex_normals =
false;
370 bool need_recompute_all_vertex_normals =
false;
376 if (has_corner_normals) {
377 need_recompute_vertex_normals =
true;
378 need_recompute_all_vertex_normals =
true;
385 const string msg =
string_printf(
"Computing Displacement %s", mesh->
name.c_str());
391 for (
size_t i = 0; i < scene->
objects.
size(); i++) {
392 if (scene->
objects[i]->get_geometry() == mesh) {
400 if (!shader_eval.
eval(
405 return fill_shader_input(scene, mesh, object_index, d_input);
408 read_shader_output(scene, mesh, d_output);
417 for (
Node *
node : mesh->get_used_shaders()) {
420 need_recompute_vertex_normals =
true;
425 if (need_recompute_vertex_normals) {
427 vector<bool> tri_recompute(num_triangles, need_recompute_all_vertex_normals);
429 if (!need_recompute_all_vertex_normals) {
430 for (
size_t i = 0; i < num_triangles; i++) {
431 const int shader_index = mesh->shader[i];
432 Shader *shader = (shader_index < mesh->used_shaders.size()) ?
433 static_cast<Shader *
>(mesh->used_shaders[shader_index]) :
444 if (has_corner_normals) {
446 mesh, vN_float, pre_displace_vN, pre_displace_motion_vN, tri_recompute, flip);
Attribute * find(ustring name) const
const T * data(const int step=0) const
T * data_for_write(const int step=0)
bool displace(Device *device, Scene *scene, Mesh *mesh, Progress &progress)
bool has_true_displacement() const
const packed_float3 * get_position() const
bool transform_negative_scaled
packed_float3 * get_position_for_write()
void add_undisplaced(Scene *scene)
NODE_DECLARE size_t num_verts() const
bool has_motion_blur() const override
size_t num_triangles() const
Triangle get_triangle(const size_t i) const
void update_tangents(Scene *scene, bool undisplaced)
void set_status(const string &status_, const string &substatus_="")
unique_ptr_vector< Object > objects
bool eval(const ShaderEvalType type, const int max_num_inputs, const int num_channels, const std::function< int(device_vector< KernelShaderEvalInput > &)> &fill_input, const std::function< void(device_vector< float > &)> &read_output)
static void fill_shader_input(device_vector< KernelShaderEvalInput > &d_input, const Octree *octree, const Object *object, const Shader *shader, const int resolution)
static void read_shader_output(const device_vector< float > &d_output, const Octree *octree, const int num_channels, const int resolution, vector< Extrema< float > > &sigmas)
#define CCL_NAMESPACE_END
VecBase< float, D > step(VecOp< float, D >, VecOp< float, D >) RET
VecT safe_normalize(VecT vector)
ccl_device_inline float ensure_finite(const float v)
CCL_NAMESPACE_BEGIN ccl_device_inline float3 zero_float3()
static void save_pre_displacement_normals(const Mesh *mesh, array< float3 > &pre_displace_vN, vector< array< float3 > > &pre_displace_motion_vN)
static void apply_corner_normal_delta(const Mesh *mesh, const packed_float3 *verts_data, const vector< float3 > &post_vN, const float3 *pre_vN, const vector< bool > &tri_recompute, const bool flip, packed_normal *cN)
static void compute_vertex_normals(const Mesh *mesh, const packed_float3 *verts_data, const vector< bool > &tri_recompute, vector< float3 > &vN)
static void recompute_displaced_corner_normals(Mesh *mesh, const vector< float3 > &vN_float, const array< float3 > &pre_displace_vN, const vector< array< float3 > > &pre_displace_motion_vN, const vector< bool > &tri_recompute, const bool flip)
static void recompute_displaced_vertex_normals(Mesh *mesh, const vector< float3 > &vN_float, const vector< bool > &tri_recompute, const bool flip)
static void store_vertex_normals(const Mesh *mesh, const vector< float3 > &vN_float, const vector< bool > &tri_recompute, const bool flip, packed_normal *vN)
CCL_NAMESPACE_BEGIN string string_printf(const char *format,...)
float3 compute_normal(const packed_float3 *verts) const