7f5dd29abd
Replace the C-class pattern function pointers with actual class methods. Other than the obvious benefit of not requiring the "this" pointer to be explicitly passed into every function call, this will make it much simpler to remove the entire C-API class and replace it with its "impl" next. For that next step we need to expose code to the implementation of the topology refiner, so instead of defining stubs locally in the opensubdiv intern class, we spread some WITH_OPENSUBDIV checks in the blenkernel. As far as I know this is the only way to remove the intermediate C-API and call opensubdiv functions directly from there.
383 lines
13 KiB
C++
383 lines
13 KiB
C++
/* SPDX-FileCopyrightText: 2018 Blender Authors
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0-or-later */
|
|
|
|
/** \file
|
|
* \ingroup bke
|
|
*/
|
|
|
|
#include "BKE_subdiv_eval.hh"
|
|
|
|
#include "BLI_math_vector.h"
|
|
#include "BLI_task.h"
|
|
#include "BLI_utildefines.h"
|
|
|
|
#include "BKE_customdata.hh"
|
|
#include "BKE_mesh.hh"
|
|
#include "BKE_subdiv.hh"
|
|
|
|
#include "MEM_guardedalloc.h"
|
|
|
|
#include "opensubdiv_evaluator_capi.hh"
|
|
#include "opensubdiv_topology_refiner_capi.hh"
|
|
|
|
/* --------------------------------------------------------------------
|
|
* Helper functions.
|
|
*/
|
|
|
|
namespace blender::bke::subdiv {
|
|
|
|
static eOpenSubdivEvaluator opensubdiv_evalutor_from_subdiv_evaluator_type(
|
|
eSubdivEvaluatorType evaluator_type)
|
|
{
|
|
switch (evaluator_type) {
|
|
case SUBDIV_EVALUATOR_TYPE_CPU: {
|
|
return OPENSUBDIV_EVALUATOR_CPU;
|
|
}
|
|
case SUBDIV_EVALUATOR_TYPE_GPU: {
|
|
return OPENSUBDIV_EVALUATOR_GPU;
|
|
}
|
|
}
|
|
BLI_assert_msg(0, "Unknown evaluator type");
|
|
return OPENSUBDIV_EVALUATOR_CPU;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------
|
|
* Main subdivision evaluation.
|
|
*/
|
|
|
|
bool eval_begin(Subdiv *subdiv,
|
|
eSubdivEvaluatorType evaluator_type,
|
|
OpenSubdiv_EvaluatorCache *evaluator_cache,
|
|
const OpenSubdiv_EvaluatorSettings *settings)
|
|
{
|
|
stats_reset(&subdiv->stats, SUBDIV_STATS_EVALUATOR_CREATE);
|
|
if (subdiv->topology_refiner == nullptr) {
|
|
/* Happens on input mesh with just loose geometry,
|
|
* or when OpenSubdiv is disabled */
|
|
return false;
|
|
}
|
|
if (subdiv->evaluator == nullptr) {
|
|
eOpenSubdivEvaluator opensubdiv_evaluator_type =
|
|
opensubdiv_evalutor_from_subdiv_evaluator_type(evaluator_type);
|
|
stats_begin(&subdiv->stats, SUBDIV_STATS_EVALUATOR_CREATE);
|
|
subdiv->evaluator = openSubdiv_createEvaluatorFromTopologyRefiner(
|
|
subdiv->topology_refiner, opensubdiv_evaluator_type, evaluator_cache);
|
|
stats_end(&subdiv->stats, SUBDIV_STATS_EVALUATOR_CREATE);
|
|
if (subdiv->evaluator == nullptr) {
|
|
return false;
|
|
}
|
|
}
|
|
else {
|
|
/* TODO(sergey): Check for topology change. */
|
|
}
|
|
subdiv->evaluator->setSettings(subdiv->evaluator, settings);
|
|
eval_init_displacement(subdiv);
|
|
return true;
|
|
}
|
|
|
|
#ifdef WITH_OPENSUBDIV
|
|
|
|
static void set_coarse_positions(Subdiv *subdiv,
|
|
const Span<float3> positions,
|
|
const bke::LooseVertCache &verts_no_face)
|
|
{
|
|
OpenSubdiv_Evaluator *evaluator = subdiv->evaluator;
|
|
if (verts_no_face.count == 0) {
|
|
evaluator->setCoarsePositions(
|
|
evaluator, reinterpret_cast<const float *>(positions.data()), 0, positions.size());
|
|
return;
|
|
}
|
|
Array<float3> used_vert_positions(positions.size() - verts_no_face.count);
|
|
const BitSpan bits = verts_no_face.is_loose_bits;
|
|
int used_vert_count = 0;
|
|
for (const int vert : positions.index_range()) {
|
|
if (bits[vert]) {
|
|
continue;
|
|
}
|
|
used_vert_positions[used_vert_count] = positions[vert];
|
|
used_vert_count++;
|
|
}
|
|
evaluator->setCoarsePositions(evaluator,
|
|
reinterpret_cast<const float *>(used_vert_positions.data()),
|
|
0,
|
|
used_vert_positions.size());
|
|
}
|
|
|
|
/* Context which is used to fill face varying data in parallel. */
|
|
struct FaceVaryingDataFromUVContext {
|
|
OpenSubdiv_TopologyRefiner *topology_refiner;
|
|
const Mesh *mesh;
|
|
OffsetIndices<int> faces;
|
|
const float (*mloopuv)[2];
|
|
float (*buffer)[2];
|
|
int layer_index;
|
|
};
|
|
|
|
static void set_face_varying_data_from_uv_task(void *__restrict userdata,
|
|
const int face_index,
|
|
const TaskParallelTLS *__restrict /*tls*/)
|
|
{
|
|
FaceVaryingDataFromUVContext *ctx = static_cast<FaceVaryingDataFromUVContext *>(userdata);
|
|
OpenSubdiv_TopologyRefiner *topology_refiner = ctx->topology_refiner;
|
|
const int layer_index = ctx->layer_index;
|
|
const float(*mluv)[2] = &ctx->mloopuv[ctx->faces[face_index].start()];
|
|
|
|
/* TODO(sergey): OpenSubdiv's C-API converter can change winding of
|
|
* loops of a face, need to watch for that, to prevent wrong UVs assigned.
|
|
*/
|
|
const int num_face_vertices = topology_refiner->getNumFaceVertices(face_index);
|
|
const int *uv_indices = topology_refiner->getFaceFVarValueIndices(face_index, layer_index);
|
|
for (int vertex_index = 0; vertex_index < num_face_vertices; vertex_index++, mluv++) {
|
|
copy_v2_v2(ctx->buffer[uv_indices[vertex_index]], *mluv);
|
|
}
|
|
}
|
|
|
|
static void set_face_varying_data_from_uv(Subdiv *subdiv,
|
|
const Mesh *mesh,
|
|
const float (*mloopuv)[2],
|
|
const int layer_index)
|
|
{
|
|
OpenSubdiv_TopologyRefiner *topology_refiner = subdiv->topology_refiner;
|
|
OpenSubdiv_Evaluator *evaluator = subdiv->evaluator;
|
|
const int num_faces = topology_refiner->getNumFaces();
|
|
const float(*mluv)[2] = mloopuv;
|
|
|
|
const int num_fvar_values = topology_refiner->getNumFVarValues(layer_index);
|
|
/* Use a temporary buffer so we do not upload UVs one at a time to the GPU. */
|
|
float(*buffer)[2] = static_cast<float(*)[2]>(
|
|
MEM_mallocN(sizeof(float[2]) * num_fvar_values, __func__));
|
|
|
|
FaceVaryingDataFromUVContext ctx;
|
|
ctx.topology_refiner = topology_refiner;
|
|
ctx.layer_index = layer_index;
|
|
ctx.mloopuv = mluv;
|
|
ctx.mesh = mesh;
|
|
ctx.faces = mesh->faces();
|
|
ctx.buffer = buffer;
|
|
|
|
TaskParallelSettings parallel_range_settings;
|
|
BLI_parallel_range_settings_defaults(¶llel_range_settings);
|
|
parallel_range_settings.min_iter_per_thread = 1;
|
|
|
|
BLI_task_parallel_range(
|
|
0, num_faces, &ctx, set_face_varying_data_from_uv_task, ¶llel_range_settings);
|
|
|
|
evaluator->setFaceVaryingData(evaluator, layer_index, &buffer[0][0], 0, num_fvar_values);
|
|
|
|
MEM_freeN(buffer);
|
|
}
|
|
|
|
static void set_vertex_data_from_orco(Subdiv *subdiv, const Mesh *mesh)
|
|
{
|
|
const float(*orco)[3] = static_cast<const float(*)[3]>(
|
|
CustomData_get_layer(&mesh->vert_data, CD_ORCO));
|
|
const float(*cloth_orco)[3] = static_cast<const float(*)[3]>(
|
|
CustomData_get_layer(&mesh->vert_data, CD_CLOTH_ORCO));
|
|
|
|
if (orco || cloth_orco) {
|
|
const OpenSubdiv_TopologyRefiner *topology_refiner = subdiv->topology_refiner;
|
|
OpenSubdiv_Evaluator *evaluator = subdiv->evaluator;
|
|
const int num_verts = topology_refiner->getNumVertices();
|
|
|
|
if (orco && cloth_orco) {
|
|
/* Set one by one if have both. */
|
|
for (int i = 0; i < num_verts; i++) {
|
|
float data[6];
|
|
copy_v3_v3(data, orco[i]);
|
|
copy_v3_v3(data + 3, cloth_orco[i]);
|
|
evaluator->setVertexData(evaluator, data, i, 1);
|
|
}
|
|
}
|
|
else {
|
|
/* Faster single call if we have either. */
|
|
if (orco) {
|
|
evaluator->setVertexData(evaluator, orco[0], 0, num_verts);
|
|
}
|
|
else if (cloth_orco) {
|
|
evaluator->setVertexData(evaluator, cloth_orco[0], 0, num_verts);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void get_mesh_evaluator_settings(OpenSubdiv_EvaluatorSettings *settings, const Mesh *mesh)
|
|
{
|
|
settings->num_vertex_data = (CustomData_has_layer(&mesh->vert_data, CD_ORCO) ? 3 : 0) +
|
|
(CustomData_has_layer(&mesh->vert_data, CD_CLOTH_ORCO) ? 3 : 0);
|
|
}
|
|
|
|
#endif
|
|
|
|
bool eval_begin_from_mesh(Subdiv *subdiv,
|
|
const Mesh *mesh,
|
|
const float (*coarse_vertex_cos)[3],
|
|
eSubdivEvaluatorType evaluator_type,
|
|
OpenSubdiv_EvaluatorCache *evaluator_cache)
|
|
{
|
|
#ifdef WITH_OPENSUBDIV
|
|
OpenSubdiv_EvaluatorSettings settings = {0};
|
|
get_mesh_evaluator_settings(&settings, mesh);
|
|
if (!eval_begin(subdiv, evaluator_type, evaluator_cache, &settings)) {
|
|
return false;
|
|
}
|
|
return eval_refine_from_mesh(subdiv, mesh, coarse_vertex_cos);
|
|
#else
|
|
UNUSED_VARS(subdiv, mesh, coarse_vertex_cos, evaluator_type, evaluator_cache);
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
bool eval_refine_from_mesh(Subdiv *subdiv, const Mesh *mesh, const float (*coarse_vertex_cos)[3])
|
|
{
|
|
#ifdef WITH_OPENSUBDIV
|
|
if (subdiv->evaluator == nullptr) {
|
|
/* NOTE: This situation is supposed to be handled by begin(). */
|
|
BLI_assert_msg(0, "Is not supposed to happen");
|
|
return false;
|
|
}
|
|
/* Set coordinates of base mesh vertices. */
|
|
set_coarse_positions(
|
|
subdiv,
|
|
coarse_vertex_cos ?
|
|
Span(reinterpret_cast<const float3 *>(coarse_vertex_cos), mesh->verts_num) :
|
|
mesh->vert_positions(),
|
|
mesh->verts_no_face());
|
|
|
|
/* Set face-varying data to UV maps. */
|
|
const int num_uv_layers = CustomData_number_of_layers(&mesh->corner_data, CD_PROP_FLOAT2);
|
|
for (int layer_index = 0; layer_index < num_uv_layers; layer_index++) {
|
|
const float(*mloopuv)[2] = static_cast<const float(*)[2]>(
|
|
CustomData_get_layer_n(&mesh->corner_data, CD_PROP_FLOAT2, layer_index));
|
|
set_face_varying_data_from_uv(subdiv, mesh, mloopuv, layer_index);
|
|
}
|
|
/* Set vertex data to orco. */
|
|
set_vertex_data_from_orco(subdiv, mesh);
|
|
/* Update evaluator to the new coarse geometry. */
|
|
stats_begin(&subdiv->stats, SUBDIV_STATS_EVALUATOR_REFINE);
|
|
subdiv->evaluator->refine(subdiv->evaluator);
|
|
stats_end(&subdiv->stats, SUBDIV_STATS_EVALUATOR_REFINE);
|
|
return true;
|
|
#else
|
|
UNUSED_VARS(subdiv, mesh, coarse_vertex_cos);
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
void eval_init_displacement(Subdiv *subdiv)
|
|
{
|
|
if (subdiv->displacement_evaluator == nullptr) {
|
|
return;
|
|
}
|
|
if (subdiv->displacement_evaluator->initialize == nullptr) {
|
|
return;
|
|
}
|
|
subdiv->displacement_evaluator->initialize(subdiv->displacement_evaluator);
|
|
}
|
|
|
|
/* --------------------------------------------------------------------
|
|
* Single point queries.
|
|
*/
|
|
|
|
void eval_limit_point(
|
|
Subdiv *subdiv, const int ptex_face_index, const float u, const float v, float r_P[3])
|
|
{
|
|
eval_limit_point_and_derivatives(subdiv, ptex_face_index, u, v, r_P, nullptr, nullptr);
|
|
}
|
|
|
|
void eval_limit_point_and_derivatives(Subdiv *subdiv,
|
|
const int ptex_face_index,
|
|
const float u,
|
|
const float v,
|
|
float r_P[3],
|
|
float r_dPdu[3],
|
|
float r_dPdv[3])
|
|
{
|
|
subdiv->evaluator->evaluateLimit(subdiv->evaluator, ptex_face_index, u, v, r_P, r_dPdu, r_dPdv);
|
|
|
|
/* NOTE: In a very rare occasions derivatives are evaluated to zeros or are exactly equal.
|
|
* This happens, for example, in single vertex on Suzannne's nose (where two quads have 2 common
|
|
* edges).
|
|
*
|
|
* This makes tangent space displacement (such as multi-resolution) impossible to be used in
|
|
* those vertices, so those needs to be addressed in one way or another.
|
|
*
|
|
* Simplest thing to do: step inside of the face a little bit, where there is known patch at
|
|
* which there must be proper derivatives. This might break continuity of normals, but is better
|
|
* that giving totally unusable derivatives. */
|
|
|
|
if (r_dPdu != nullptr && r_dPdv != nullptr) {
|
|
if ((is_zero_v3(r_dPdu) || is_zero_v3(r_dPdv)) || equals_v3v3(r_dPdu, r_dPdv)) {
|
|
subdiv->evaluator->evaluateLimit(subdiv->evaluator,
|
|
ptex_face_index,
|
|
u * 0.999f + 0.0005f,
|
|
v * 0.999f + 0.0005f,
|
|
r_P,
|
|
r_dPdu,
|
|
r_dPdv);
|
|
}
|
|
}
|
|
}
|
|
|
|
void eval_limit_point_and_normal(Subdiv *subdiv,
|
|
const int ptex_face_index,
|
|
const float u,
|
|
const float v,
|
|
float r_P[3],
|
|
float r_N[3])
|
|
{
|
|
float dPdu[3], dPdv[3];
|
|
eval_limit_point_and_derivatives(subdiv, ptex_face_index, u, v, r_P, dPdu, dPdv);
|
|
cross_v3_v3v3(r_N, dPdu, dPdv);
|
|
normalize_v3(r_N);
|
|
}
|
|
|
|
void eval_vertex_data(
|
|
Subdiv *subdiv, const int ptex_face_index, const float u, const float v, float r_vertex_data[])
|
|
{
|
|
subdiv->evaluator->evaluateVertexData(subdiv->evaluator, ptex_face_index, u, v, r_vertex_data);
|
|
}
|
|
|
|
void eval_face_varying(Subdiv *subdiv,
|
|
const int face_varying_channel,
|
|
const int ptex_face_index,
|
|
const float u,
|
|
const float v,
|
|
float r_face_varying[2])
|
|
{
|
|
subdiv->evaluator->evaluateFaceVarying(
|
|
subdiv->evaluator, face_varying_channel, ptex_face_index, u, v, r_face_varying);
|
|
}
|
|
|
|
void eval_displacement(Subdiv *subdiv,
|
|
const int ptex_face_index,
|
|
const float u,
|
|
const float v,
|
|
const float dPdu[3],
|
|
const float dPdv[3],
|
|
float r_D[3])
|
|
{
|
|
if (subdiv->displacement_evaluator == nullptr) {
|
|
zero_v3(r_D);
|
|
return;
|
|
}
|
|
subdiv->displacement_evaluator->eval_displacement(
|
|
subdiv->displacement_evaluator, ptex_face_index, u, v, dPdu, dPdv, r_D);
|
|
}
|
|
|
|
void eval_final_point(
|
|
Subdiv *subdiv, const int ptex_face_index, const float u, const float v, float r_P[3])
|
|
{
|
|
if (subdiv->displacement_evaluator) {
|
|
float dPdu[3], dPdv[3], D[3];
|
|
eval_limit_point_and_derivatives(subdiv, ptex_face_index, u, v, r_P, dPdu, dPdv);
|
|
eval_displacement(subdiv, ptex_face_index, u, v, dPdu, dPdv, D);
|
|
add_v3_v3(r_P, D);
|
|
}
|
|
else {
|
|
eval_limit_point(subdiv, ptex_face_index, u, v, r_P);
|
|
}
|
|
}
|
|
|
|
} // namespace blender::bke::subdiv
|