sandey/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity
71cd9f9fbb
blender/intern/cycles/scene/mesh_displace.cpp
Brecht Van Lommel fd25e883e2 Cycles: remove prefix from source code file names 
Remove prefix of filenames that is the same as the folder name. This used
to help when #includes were using individual files, but now they are always
relative to the cycles root directory and so the prefixes are redundant.

For patches and branches, git merge and rebase should be able to detect the
renames and move over code to the right file.
2021-10-26 15:37:04 +02:00

411 lines
12 KiB
C++
Raw Blame History

/*
* Copyright 2011-2013 Blender Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "device/device.h"
#include "integrator/shader_eval.h"
#include "scene/mesh.h"
#include "scene/object.h"
#include "scene/scene.h"
#include "scene/shader.h"
#include "util/foreach.h"
#include "util/map.h"
#include "util/progress.h"
#include "util/set.h"
CCL_NAMESPACE_BEGIN
static float3 compute_face_normal(const Mesh::Triangle &t, float3 *verts)
{
float3 v0 = verts[t.v[0]];
float3 v1 = verts[t.v[1]];
float3 v2 = verts[t.v[2]];
float3 norm = cross(v1 - v0, v2 - v0);
float normlen = len(norm);
if (normlen == 0.0f)
return make_float3(1.0f, 0.0f, 0.0f);
return norm / normlen;
}
/* Fill in coordinates for mesh displacement shader evaluation on device. */
static int fill_shader_input(const Scene *scene,
const Mesh *mesh,
const int object_index,
device_vector<KernelShaderEvalInput> &d_input)
{
int d_input_size = 0;
KernelShaderEvalInput *d_input_data = d_input.data();
const array<int> &mesh_shaders = mesh->get_shader();
const array<Node *> &mesh_used_shaders = mesh->get_used_shaders();
const array<float3> &mesh_verts = mesh->get_verts();
const int num_verts = mesh_verts.size();
vector<bool> done(num_verts, false);
int num_triangles = mesh->num_triangles();
for (int i = 0; i < num_triangles; i++) {
Mesh::Triangle t = mesh->get_triangle(i);
int shader_index = mesh_shaders[i];
Shader *shader = (shader_index < mesh_used_shaders.size()) ?
static_cast<Shader *>(mesh_used_shaders[shader_index]) :
scene->default_surface;
if (!shader->has_displacement || shader->get_displacement_method() == DISPLACE_BUMP) {
continue;
}
for (int j = 0; j < 3; j++) {
if (done[t.v[j]])
continue;
done[t.v[j]] = true;
/* set up object, primitive and barycentric coordinates */
int object = object_index;
int prim = mesh->prim_offset + i;
float u, v;
switch (j) {
case 0:
u = 1.0f;
v = 0.0f;
break;
case 1:
u = 0.0f;
v = 1.0f;
break;
default:
u = 0.0f;
v = 0.0f;
break;
}
/* back */
KernelShaderEvalInput in;
in.object = object;
in.prim = prim;
in.u = u;
in.v = v;
d_input_data[d_input_size++] = in;
}
}
return d_input_size;
}
/* Read back mesh displacement shader output. */
static void read_shader_output(const Scene *scene,
Mesh *mesh,
const device_vector<float> &d_output)
{
const array<int> &mesh_shaders = mesh->get_shader();
const array<Node *> &mesh_used_shaders = mesh->get_used_shaders();
array<float3> &mesh_verts = mesh->get_verts();
const int num_verts = mesh_verts.size();
const int num_motion_steps = mesh->get_motion_steps();
vector<bool> done(num_verts, false);
const float *d_output_data = d_output.data();
int d_output_index = 0;
Attribute *attr_mP = mesh->attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
int num_triangles = mesh->num_triangles();
for (int i = 0; i < num_triangles; i++) {
Mesh::Triangle t = mesh->get_triangle(i);
int shader_index = mesh_shaders[i];
Shader *shader = (shader_index < mesh_used_shaders.size()) ?
static_cast<Shader *>(mesh_used_shaders[shader_index]) :
scene->default_surface;
if (!shader->has_displacement || shader->get_displacement_method() == DISPLACE_BUMP) {
continue;
}
for (int j = 0; j < 3; j++) {
if (!done[t.v[j]]) {
done[t.v[j]] = true;
float3 off = make_float3(d_output_data[d_output_index + 0],
d_output_data[d_output_index + 1],
d_output_data[d_output_index + 2]);
d_output_index += 3;
/* Avoid illegal vertex coordinates. */
off = ensure_finite3(off);
mesh_verts[t.v[j]] += off;
if (attr_mP != NULL) {
for (int step = 0; step < num_motion_steps - 1; step++) {
float3 *mP = attr_mP->data_float3() + step * num_verts;
mP[t.v[j]] += off;
}
}
}
}
}
}
bool GeometryManager::displace(Device *device, Scene *scene, Mesh *mesh, Progress &progress)
{
/* verify if we have a displacement shader */
if (!mesh->has_true_displacement()) {
return false;
}
const size_t num_verts = mesh->verts.size();
const size_t num_triangles = mesh->num_triangles();
if (num_triangles == 0) {
return false;
}
string msg = string_printf("Computing Displacement %s", mesh->name.c_str());
progress.set_status("Updating Mesh", msg);
/* find object index. todo: is arbitrary */
size_t object_index = OBJECT_NONE;
for (size_t i = 0; i < scene->objects.size(); i++) {
if (scene->objects[i]->get_geometry() == mesh) {
object_index = i;
break;
}
}
/* Evaluate shader on device. */
ShaderEval shader_eval(device, progress);
if (!shader_eval.eval(SHADER_EVAL_DISPLACE,
num_verts,
3,
function_bind(&fill_shader_input, scene, mesh, object_index, _1),
function_bind(&read_shader_output, scene, mesh, _1))) {
return false;
}
/* stitch */
unordered_set<int> stitch_keys;
for (pair<int, int> i : mesh->vert_to_stitching_key_map) {
stitch_keys.insert(i.second); /* stitching index */
}
typedef unordered_multimap<int, int>::iterator map_it_t;
for (int key : stitch_keys) {
pair<map_it_t, map_it_t> verts = mesh->vert_stitching_map.equal_range(key);
float3 pos = zero_float3();
int num = 0;
for (map_it_t v = verts.first; v != verts.second; ++v) {
int vert = v->second;
pos += mesh->verts[vert];
num++;
}
if (num <= 1) {
continue;
}
pos *= 1.0f / num;
for (map_it_t v = verts.first; v != verts.second; ++v) {
mesh->verts[v->second] = pos;
}
}
/* for displacement method both, we only need to recompute the face
* normals, as bump mapping in the shader will already alter the
* vertex normal, so we start from the non-displaced vertex normals
* to avoid applying the perturbation twice. */
mesh->attributes.remove(ATTR_STD_FACE_NORMAL);
mesh->add_face_normals();
bool need_recompute_vertex_normals = false;
foreach (Node *node, mesh->get_used_shaders()) {
Shader *shader = static_cast<Shader *>(node);
if (shader->has_displacement && shader->get_displacement_method() == DISPLACE_TRUE) {
need_recompute_vertex_normals = true;
break;
}
}
if (need_recompute_vertex_normals) {
bool flip = mesh->transform_negative_scaled;
vector<bool> tri_has_true_disp(num_triangles, false);
for (size_t i = 0; i < num_triangles; i++) {
int shader_index = mesh->shader[i];
Shader *shader = (shader_index < mesh->used_shaders.size()) ?
static_cast<Shader *>(mesh->used_shaders[shader_index]) :
scene->default_surface;
tri_has_true_disp[i] = shader->has_displacement &&
shader->get_displacement_method() == DISPLACE_TRUE;
}
/* static vertex normals */
/* get attributes */
Attribute *attr_fN = mesh->attributes.find(ATTR_STD_FACE_NORMAL);
Attribute *attr_vN = mesh->attributes.find(ATTR_STD_VERTEX_NORMAL);
float3 *fN = attr_fN->data_float3();
float3 *vN = attr_vN->data_float3();
/* compute vertex normals */
/* zero vertex normals on triangles with true displacement */
for (size_t i = 0; i < num_triangles; i++) {
if (tri_has_true_disp[i]) {
for (size_t j = 0; j < 3; j++) {
vN[mesh->get_triangle(i).v[j]] = zero_float3();
}
}
}
/* add face normals to vertex normals */
for (size_t i = 0; i < num_triangles; i++) {
if (tri_has_true_disp[i]) {
for (size_t j = 0; j < 3; j++) {
int vert = mesh->get_triangle(i).v[j];
vN[vert] += fN[i];
/* add face normals to stitched vertices */
if (stitch_keys.size()) {
map_it_t key = mesh->vert_to_stitching_key_map.find(vert);
if (key != mesh->vert_to_stitching_key_map.end()) {
pair<map_it_t, map_it_t> verts = mesh->vert_stitching_map.equal_range(key->second);
for (map_it_t v = verts.first; v != verts.second; ++v) {
if (v->second == vert) {
continue;
}
vN[v->second] += fN[i];
}
}
}
}
}
}
/* normalize vertex normals */
vector<bool> done(num_verts, false);
for (size_t i = 0; i < num_triangles; i++) {
if (tri_has_true_disp[i]) {
for (size_t j = 0; j < 3; j++) {
int vert = mesh->get_triangle(i).v[j];
if (done[vert]) {
continue;
}
vN[vert] = normalize(vN[vert]);
if (flip)
vN[vert] = -vN[vert];
done[vert] = true;
}
}
}
/* motion vertex normals */
Attribute *attr_mP = mesh->attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
Attribute *attr_mN = mesh->attributes.find(ATTR_STD_MOTION_VERTEX_NORMAL);
if (mesh->has_motion_blur() && attr_mP && attr_mN) {
for (int step = 0; step < mesh->motion_steps - 1; step++) {
float3 *mP = attr_mP->data_float3() + step * mesh->verts.size();
float3 *mN = attr_mN->data_float3() + step * mesh->verts.size();
/* compute */
/* zero vertex normals on triangles with true displacement */
for (size_t i = 0; i < num_triangles; i++) {
if (tri_has_true_disp[i]) {
for (size_t j = 0; j < 3; j++) {
mN[mesh->get_triangle(i).v[j]] = zero_float3();
}
}
}
/* add face normals to vertex normals */
for (size_t i = 0; i < num_triangles; i++) {
if (tri_has_true_disp[i]) {
for (size_t j = 0; j < 3; j++) {
int vert = mesh->get_triangle(i).v[j];
float3 fN = compute_face_normal(mesh->get_triangle(i), mP);
mN[vert] += fN;
/* add face normals to stitched vertices */
if (stitch_keys.size()) {
map_it_t key = mesh->vert_to_stitching_key_map.find(vert);
if (key != mesh->vert_to_stitching_key_map.end()) {
pair<map_it_t, map_it_t> verts = mesh->vert_stitching_map.equal_range(
key->second);
for (map_it_t v = verts.first; v != verts.second; ++v) {
if (v->second == vert) {
continue;
}
mN[v->second] += fN;
}
}
}
}
}
}
/* normalize vertex normals */
vector<bool> done(num_verts, false);
for (size_t i = 0; i < num_triangles; i++) {
if (tri_has_true_disp[i]) {
for (size_t j = 0; j < 3; j++) {
int vert = mesh->get_triangle(i).v[j];
if (done[vert]) {
continue;
}
mN[vert] = normalize(mN[vert]);
if (flip)
mN[vert] = -mN[vert];
done[vert] = true;
}
}
}
}
}
}
return true;
}
CCL_NAMESPACE_END
View Git Blame Copy Permalink