diff options
14 files changed, 263 insertions, 14 deletions
diff --git a/intern/opensubdiv/internal/evaluator/eval_output.h b/intern/opensubdiv/internal/evaluator/eval_output.h index a55b89001a4..cff7c8d18c9 100644 --- a/intern/opensubdiv/internal/evaluator/eval_output.h +++ b/intern/opensubdiv/internal/evaluator/eval_output.h @@ -46,6 +46,8 @@ class EvalOutputAPI::EvalOutput { virtual void updateVaryingData(const float *src, int start_vertex, int num_vertices) = 0; + virtual void updateVertexData(const float *src, int start_vertex, int num_vertices) = 0; + virtual void updateFaceVaryingData(const int face_varying_channel, const float *src, int start_vertex, @@ -70,6 +72,11 @@ class EvalOutputAPI::EvalOutput { const int num_patch_coords, float *varying) = 0; + // NOTE: vertex_data must point to a memory of at least float*num_vertex_data. + virtual void evalPatchesVertexData(const PatchCoord *patch_coord, + const int num_patch_coords, + float *vertex_data) = 0; + virtual void evalPatchesFaceVarying(const int face_varying_channel, const PatchCoord *patch_coord, const int num_patch_coords, @@ -331,11 +338,13 @@ class VolatileEvalOutput : public EvalOutputAPI::EvalOutput { const StencilTable *varying_stencils, const vector<const StencilTable *> &all_face_varying_stencils, const int face_varying_width, + const int vertex_data_width, const PatchTable *patch_table, EvaluatorCache *evaluator_cache = NULL, DEVICE_CONTEXT *device_context = NULL) : src_desc_(0, 3, 3), src_varying_desc_(0, 3, 3), + src_vertex_data_desc_(0, vertex_data_width, vertex_data_width), face_varying_width_(face_varying_width), evaluator_cache_(evaluator_cache), device_context_(device_context) @@ -352,6 +361,16 @@ class VolatileEvalOutput : public EvalOutputAPI::EvalOutput { device_context_); varying_stencils_ = convertToCompatibleStencilTable<STENCIL_TABLE>(varying_stencils, device_context_); + + // Optionally allocate additional data to be subdivided like vertex coordinates. + if (vertex_data_width > 0) { + src_vertex_data_ = SRC_VERTEX_BUFFER::Create( + vertex_data_width, num_total_vertices, device_context_); + } + else { + src_vertex_data_ = NULL; + } + // Create evaluators for every face varying channel. face_varying_evaluators.reserve(all_face_varying_stencils.size()); int face_varying_channel = 0; @@ -370,6 +389,7 @@ class VolatileEvalOutput : public EvalOutputAPI::EvalOutput { { delete src_data_; delete src_varying_data_; + delete src_vertex_data_; delete patch_table_; delete vertex_stencils_; delete varying_stencils_; @@ -390,6 +410,11 @@ class VolatileEvalOutput : public EvalOutputAPI::EvalOutput { src_varying_data_->UpdateData(src, start_vertex, num_vertices, device_context_); } + void updateVertexData(const float *src, int start_vertex, int num_vertices) override + { + src_vertex_data_->UpdateData(src, start_vertex, num_vertices, device_context_); + } + void updateFaceVaryingData(const int face_varying_channel, const float *src, int start_vertex, @@ -426,6 +451,22 @@ class VolatileEvalOutput : public EvalOutputAPI::EvalOutput { vertex_stencils_, eval_instance, device_context_); + + // Evaluate smoothly interpolated vertex data. + if (src_vertex_data_) { + BufferDescriptor dst_vertex_data_desc = src_vertex_data_desc_; + dst_vertex_data_desc.offset += num_coarse_vertices_ * src_vertex_data_desc_.stride; + const EVALUATOR *eval_instance = OpenSubdiv::Osd::GetEvaluator<EVALUATOR>( + evaluator_cache_, src_vertex_data_desc_, dst_vertex_data_desc, device_context_); + EVALUATOR::EvalStencils(src_vertex_data_, + src_vertex_data_desc_, + src_vertex_data_, + dst_vertex_data_desc, + vertex_stencils_, + eval_instance, + device_context_); + } + // Evaluate varying data. if (hasVaryingData()) { BufferDescriptor dst_varying_desc = src_varying_desc_; @@ -521,6 +562,27 @@ class VolatileEvalOutput : public EvalOutputAPI::EvalOutput { device_context_); } + // NOTE: data must point to a memory of at least float*num_vertex_data. + void evalPatchesVertexData(const PatchCoord *patch_coord, + const int num_patch_coords, + float *data) override + { + RawDataWrapperBuffer<float> vertex_data(data); + BufferDescriptor vertex_desc(0, src_vertex_data_desc_.length, src_vertex_data_desc_.length); + ConstPatchCoordWrapperBuffer patch_coord_buffer(patch_coord, num_patch_coords); + const EVALUATOR *eval_instance = OpenSubdiv::Osd::GetEvaluator<EVALUATOR>( + evaluator_cache_, src_vertex_data_desc_, vertex_desc, device_context_); + EVALUATOR::EvalPatches(src_vertex_data_, + src_vertex_data_desc_, + &vertex_data, + vertex_desc, + patch_coord_buffer.GetNumVertices(), + &patch_coord_buffer, + patch_table_, + eval_instance, + device_context_); + } + void evalPatchesFaceVarying(const int face_varying_channel, const PatchCoord *patch_coord, const int num_patch_coords, @@ -560,9 +622,11 @@ class VolatileEvalOutput : public EvalOutputAPI::EvalOutput { private: SRC_VERTEX_BUFFER *src_data_; SRC_VERTEX_BUFFER *src_varying_data_; + SRC_VERTEX_BUFFER *src_vertex_data_; PATCH_TABLE *patch_table_; BufferDescriptor src_desc_; BufferDescriptor src_varying_desc_; + BufferDescriptor src_vertex_data_desc_; int num_coarse_vertices_; diff --git a/intern/opensubdiv/internal/evaluator/eval_output_cpu.h b/intern/opensubdiv/internal/evaluator/eval_output_cpu.h index 58bae7a322e..2b3c738d6ab 100644 --- a/intern/opensubdiv/internal/evaluator/eval_output_cpu.h +++ b/intern/opensubdiv/internal/evaluator/eval_output_cpu.h @@ -44,6 +44,7 @@ class CpuEvalOutput : public VolatileEvalOutput<CpuVertexBuffer, const StencilTable *varying_stencils, const vector<const StencilTable *> &all_face_varying_stencils, const int face_varying_width, + const int vertex_data_width, const PatchTable *patch_table, EvaluatorCache *evaluator_cache = NULL) : VolatileEvalOutput<CpuVertexBuffer, @@ -54,6 +55,7 @@ class CpuEvalOutput : public VolatileEvalOutput<CpuVertexBuffer, varying_stencils, all_face_varying_stencils, face_varying_width, + vertex_data_width, patch_table, evaluator_cache) { diff --git a/intern/opensubdiv/internal/evaluator/eval_output_gpu.cc b/intern/opensubdiv/internal/evaluator/eval_output_gpu.cc index b352ed2c014..566071d581b 100644 --- a/intern/opensubdiv/internal/evaluator/eval_output_gpu.cc +++ b/intern/opensubdiv/internal/evaluator/eval_output_gpu.cc @@ -45,6 +45,7 @@ GpuEvalOutput::GpuEvalOutput(const StencilTable *vertex_stencils, const StencilTable *varying_stencils, const vector<const StencilTable *> &all_face_varying_stencils, const int face_varying_width, + const int vertex_data_width, const PatchTable *patch_table, VolatileEvalOutput::EvaluatorCache *evaluator_cache) : VolatileEvalOutput<GLVertexBuffer, @@ -55,6 +56,7 @@ GpuEvalOutput::GpuEvalOutput(const StencilTable *vertex_stencils, varying_stencils, all_face_varying_stencils, face_varying_width, + vertex_data_width, patch_table, evaluator_cache) { diff --git a/intern/opensubdiv/internal/evaluator/eval_output_gpu.h b/intern/opensubdiv/internal/evaluator/eval_output_gpu.h index dc137e4322e..2306a87b87c 100644 --- a/intern/opensubdiv/internal/evaluator/eval_output_gpu.h +++ b/intern/opensubdiv/internal/evaluator/eval_output_gpu.h @@ -40,6 +40,7 @@ class GpuEvalOutput : public VolatileEvalOutput<GLVertexBuffer, const StencilTable *varying_stencils, const vector<const StencilTable *> &all_face_varying_stencils, const int face_varying_width, + const int vertex_data_width, const PatchTable *patch_table, EvaluatorCache *evaluator_cache = NULL); diff --git a/intern/opensubdiv/internal/evaluator/evaluator_capi.cc b/intern/opensubdiv/internal/evaluator/evaluator_capi.cc index 567afd3a763..8a54ed653dc 100644 --- a/intern/opensubdiv/internal/evaluator/evaluator_capi.cc +++ b/intern/opensubdiv/internal/evaluator/evaluator_capi.cc @@ -36,6 +36,14 @@ void setCoarsePositions(OpenSubdiv_Evaluator *evaluator, evaluator->impl->eval_output->setCoarsePositions(positions, start_vertex_index, num_vertices); } +void setVertexData(OpenSubdiv_Evaluator *evaluator, + const float *vertex_data, + const int start_vertex_index, + const int num_vertices) +{ + evaluator->impl->eval_output->setVertexData(vertex_data, start_vertex_index, num_vertices); +} + void setVaryingData(OpenSubdiv_Evaluator *evaluator, const float *varying_data, const int start_vertex_index, @@ -115,6 +123,15 @@ void evaluatePatchesLimit(OpenSubdiv_Evaluator *evaluator, patch_coords, num_patch_coords, P, dPdu, dPdv); } +void evaluateVertexData(OpenSubdiv_Evaluator *evaluator, + const int ptex_face_index, + float face_u, + float face_v, + float vertex_data[3]) +{ + evaluator->impl->eval_output->evaluateVertexData(ptex_face_index, face_u, face_v, vertex_data); +} + void evaluateVarying(OpenSubdiv_Evaluator *evaluator, const int ptex_face_index, float face_u, @@ -206,6 +223,7 @@ void wrapFVarSrcBuffer(struct OpenSubdiv_Evaluator *evaluator, void assignFunctionPointers(OpenSubdiv_Evaluator *evaluator) { evaluator->setCoarsePositions = setCoarsePositions; + evaluator->setVertexData = setVertexData; evaluator->setVaryingData = setVaryingData; evaluator->setFaceVaryingData = setFaceVaryingData; @@ -217,6 +235,7 @@ void assignFunctionPointers(OpenSubdiv_Evaluator *evaluator) evaluator->evaluateLimit = evaluateLimit; evaluator->evaluateVarying = evaluateVarying; + evaluator->evaluateVertexData = evaluateVertexData; evaluator->evaluateFaceVarying = evaluateFaceVarying; evaluator->evaluatePatchesLimit = evaluatePatchesLimit; @@ -239,12 +258,16 @@ void assignFunctionPointers(OpenSubdiv_Evaluator *evaluator) OpenSubdiv_Evaluator *openSubdiv_createEvaluatorFromTopologyRefiner( OpenSubdiv_TopologyRefiner *topology_refiner, eOpenSubdivEvaluator evaluator_type, - OpenSubdiv_EvaluatorCache *evaluator_cache) + OpenSubdiv_EvaluatorCache *evaluator_cache, + const OpenSubdiv_EvaluatorSettings *settings) { OpenSubdiv_Evaluator *evaluator = MEM_new<OpenSubdiv_Evaluator>(__func__); assignFunctionPointers(evaluator); - evaluator->impl = openSubdiv_createEvaluatorInternal( - topology_refiner, evaluator_type, evaluator_cache ? evaluator_cache->impl : nullptr); + evaluator->impl = openSubdiv_createEvaluatorInternal(topology_refiner, + evaluator_type, + evaluator_cache ? evaluator_cache->impl : + nullptr, + settings); evaluator->type = evaluator->impl ? evaluator_type : static_cast<eOpenSubdivEvaluator>(0); return evaluator; } diff --git a/intern/opensubdiv/internal/evaluator/evaluator_impl.cc b/intern/opensubdiv/internal/evaluator/evaluator_impl.cc index 755b8bfbc81..bb9e6e7bd0d 100644 --- a/intern/opensubdiv/internal/evaluator/evaluator_impl.cc +++ b/intern/opensubdiv/internal/evaluator/evaluator_impl.cc @@ -182,6 +182,14 @@ void EvalOutputAPI::setVaryingData(const float *varying_data, implementation_->updateVaryingData(varying_data, start_vertex_index, num_vertices); } +void EvalOutputAPI::setVertexData(const float *vertex_data, + const int start_vertex_index, + const int num_vertices) +{ + // TODO(sergey): Add sanity check on indices. + implementation_->updateVertexData(vertex_data, start_vertex_index, num_vertices); +} + void EvalOutputAPI::setFaceVaryingData(const int face_varying_channel, const float *face_varying_data, const int start_vertex_index, @@ -286,6 +294,20 @@ void EvalOutputAPI::evaluateVarying(const int ptex_face_index, implementation_->evalPatchesVarying(&patch_coord, 1, varying); } +void EvalOutputAPI::evaluateVertexData(const int ptex_face_index, + float face_u, + float face_v, + float vertex_data[]) +{ + assert(face_u >= 0.0f); + assert(face_u <= 1.0f); + assert(face_v >= 0.0f); + assert(face_v <= 1.0f); + const PatchTable::PatchHandle *handle = patch_map_->FindPatch(ptex_face_index, face_u, face_v); + PatchCoord patch_coord(*handle, face_u, face_v); + implementation_->evalPatchesVertexData(&patch_coord, 1, vertex_data); +} + void EvalOutputAPI::evaluateFaceVarying(const int face_varying_channel, const int ptex_face_index, float face_u, @@ -403,7 +425,8 @@ OpenSubdiv_EvaluatorImpl::~OpenSubdiv_EvaluatorImpl() OpenSubdiv_EvaluatorImpl *openSubdiv_createEvaluatorInternal( OpenSubdiv_TopologyRefiner *topology_refiner, eOpenSubdivEvaluator evaluator_type, - OpenSubdiv_EvaluatorCacheImpl *evaluator_cache_descr) + OpenSubdiv_EvaluatorCacheImpl *evaluator_cache_descr, + const OpenSubdiv_EvaluatorSettings *settings) { // Only CPU and GLCompute are implemented at the moment. if (evaluator_type != OPENSUBDIV_EVALUATOR_CPU && @@ -422,6 +445,7 @@ OpenSubdiv_EvaluatorImpl *openSubdiv_createEvaluatorInternal( const bool has_face_varying_data = (num_face_varying_channels != 0); const int level = topology_refiner->getSubdivisionLevel(topology_refiner); const bool is_adaptive = topology_refiner->getIsAdaptive(topology_refiner); + const int vertex_data_width = settings->num_vertex_data; // Common settings for stencils and patches. const bool stencil_generate_intermediate_levels = is_adaptive; const bool stencil_generate_offsets = true; @@ -526,12 +550,17 @@ OpenSubdiv_EvaluatorImpl *openSubdiv_createEvaluatorInternal( varying_stencils, all_face_varying_stencils, 2, + vertex_data_width, patch_table, evaluator_cache); } else { - eval_output = new blender::opensubdiv::CpuEvalOutput( - vertex_stencils, varying_stencils, all_face_varying_stencils, 2, patch_table); + eval_output = new blender::opensubdiv::CpuEvalOutput(vertex_stencils, + varying_stencils, + all_face_varying_stencils, + 2, + vertex_data_width, + patch_table); } blender::opensubdiv::PatchMap *patch_map = new blender::opensubdiv::PatchMap(*patch_table); diff --git a/intern/opensubdiv/internal/evaluator/evaluator_impl.h b/intern/opensubdiv/internal/evaluator/evaluator_impl.h index e24d47cba79..8ecfa4477be 100644 --- a/intern/opensubdiv/internal/evaluator/evaluator_impl.h +++ b/intern/opensubdiv/internal/evaluator/evaluator_impl.h @@ -32,6 +32,7 @@ struct OpenSubdiv_Buffer; struct OpenSubdiv_EvaluatorCacheImpl; +struct OpenSubdiv_EvaluatorSettings; struct OpenSubdiv_PatchCoord; struct OpenSubdiv_TopologyRefiner; @@ -60,6 +61,8 @@ class EvalOutputAPI { void setCoarsePositions(const float *positions, const int start_vertex_index, const int num_vertices); + // Set vertex data from a continuous array of data. + void setVertexData(const float *data, const int start_vertex_index, const int num_vertices); // Set varying data from a continuous array of data. void setVaryingData(const float *varying_data, const int start_vertex_index, @@ -115,6 +118,9 @@ class EvalOutputAPI { float dPdv[3]); // Evaluate varying data at a given bilinear coordinate of given ptex face. + void evaluateVertexData(const int ptes_face_index, float face_u, float face_v, float data[]); + + // Evaluate varying data at a given bilinear coordinate of given ptex face. void evaluateVarying(const int ptes_face_index, float face_u, float face_v, float varying[3]); // Evaluate facee-varying data at a given bilinear coordinate of given @@ -198,7 +204,8 @@ struct OpenSubdiv_EvaluatorImpl { OpenSubdiv_EvaluatorImpl *openSubdiv_createEvaluatorInternal( struct OpenSubdiv_TopologyRefiner *topology_refiner, eOpenSubdivEvaluator evaluator_type, - OpenSubdiv_EvaluatorCacheImpl *evaluator_cache_descr); + OpenSubdiv_EvaluatorCacheImpl *evaluator_cache_descr, + const OpenSubdiv_EvaluatorSettings *settings); void openSubdiv_deleteEvaluatorInternal(OpenSubdiv_EvaluatorImpl *evaluator); diff --git a/intern/opensubdiv/opensubdiv_evaluator_capi.h b/intern/opensubdiv/opensubdiv_evaluator_capi.h index 1afd3e966f6..98e1db6e323 100644 --- a/intern/opensubdiv/opensubdiv_evaluator_capi.h +++ b/intern/opensubdiv/opensubdiv_evaluator_capi.h @@ -69,6 +69,11 @@ typedef struct OpenSubdiv_Evaluator { const float *positions, const int start_vertex_index, const int num_vertices); + // Set vertex data from a continuous array of coordinates. + void (*setVertexData)(struct OpenSubdiv_Evaluator *evaluator, + const float *data, + const int start_vertex_index, + const int num_vertices); // Set varying data from a continuous array of data. void (*setVaryingData)(struct OpenSubdiv_Evaluator *evaluator, const float *varying_data, @@ -129,6 +134,13 @@ typedef struct OpenSubdiv_Evaluator { float dPdu[3], float dPdv[3]); + // Evaluate vertex data at a given bilinear coordinate of given ptex face. + void (*evaluateVertexData)(struct OpenSubdiv_Evaluator *evaluator, + const int ptex_face_index, + float face_u, + float face_v, + float data[]); + // Evaluate varying data at a given bilinear coordinate of given ptex face. void (*evaluateVarying)(struct OpenSubdiv_Evaluator *evaluator, const int ptex_face_index, @@ -215,10 +227,16 @@ typedef struct OpenSubdiv_EvaluatorCache { struct OpenSubdiv_EvaluatorCacheImpl *impl; } OpenSubdiv_EvaluatorCache; +typedef struct OpenSubdiv_EvaluatorSettings { + // Number of smoothly interpolated vertex data channels. + int num_vertex_data; +} OpenSubdiv_EvaluatorSettings; + OpenSubdiv_Evaluator *openSubdiv_createEvaluatorFromTopologyRefiner( struct OpenSubdiv_TopologyRefiner *topology_refiner, eOpenSubdivEvaluator evaluator_type, - OpenSubdiv_EvaluatorCache *evaluator_cache); + OpenSubdiv_EvaluatorCache *evaluator_cache, + const OpenSubdiv_EvaluatorSettings *settings); void openSubdiv_deleteEvaluator(OpenSubdiv_Evaluator *evaluator); diff --git a/intern/opensubdiv/stub/opensubdiv_evaluator_stub.cc b/intern/opensubdiv/stub/opensubdiv_evaluator_stub.cc index bc39326b57d..78c1d23d2cc 100644 --- a/intern/opensubdiv/stub/opensubdiv_evaluator_stub.cc +++ b/intern/opensubdiv/stub/opensubdiv_evaluator_stub.cc @@ -23,7 +23,8 @@ OpenSubdiv_Evaluator *openSubdiv_createEvaluatorFromTopologyRefiner( struct OpenSubdiv_TopologyRefiner * /*topology_refiner*/, eOpenSubdivEvaluator /*evaluator_type*/, - OpenSubdiv_EvaluatorCache * /*evaluator_cache*/) + OpenSubdiv_EvaluatorCache * /*evaluator_cache*/, + const OpenSubdiv_EvaluatorSettings * /*settings*/) { return NULL; } diff --git a/source/blender/blenkernel/BKE_subdiv_eval.h b/source/blender/blenkernel/BKE_subdiv_eval.h index a33140b721d..7673f18317a 100644 --- a/source/blender/blenkernel/BKE_subdiv_eval.h +++ b/source/blender/blenkernel/BKE_subdiv_eval.h @@ -15,6 +15,7 @@ extern "C" { struct Mesh; struct OpenSubdiv_EvaluatorCache; +struct OpenSubdiv_EvaluatorSettings; struct Subdiv; typedef enum eSubdivEvaluatorType { @@ -25,7 +26,8 @@ typedef enum eSubdivEvaluatorType { /* Returns true if evaluator is ready for use. */ bool BKE_subdiv_eval_begin(struct Subdiv *subdiv, eSubdivEvaluatorType evaluator_type, - struct OpenSubdiv_EvaluatorCache *evaluator_cache); + struct OpenSubdiv_EvaluatorCache *evaluator_cache, + const struct OpenSubdiv_EvaluatorSettings *settings); /* coarse_vertex_cos is an optional argument which allows to override coordinates of the coarse * mesh. */ @@ -60,6 +62,13 @@ void BKE_subdiv_eval_limit_point_and_derivatives(struct Subdiv *subdiv, void BKE_subdiv_eval_limit_point_and_normal( struct Subdiv *subdiv, int ptex_face_index, float u, float v, float r_P[3], float r_N[3]); +/* Evaluate smoothly interpolated vertex data (such as orco). */ +void BKE_subdiv_eval_vertex_data(struct Subdiv *subdiv, + const int ptex_face_index, + const float u, + const float v, + float r_vertex_data[]); + /* Evaluate face-varying layer (such as UV). */ void BKE_subdiv_eval_face_varying(struct Subdiv *subdiv, int face_varying_channel, diff --git a/source/blender/blenkernel/intern/DerivedMesh.cc b/source/blender/blenkernel/intern/DerivedMesh.cc index 7ca76e72839..6b43fe57e93 100644 --- a/source/blender/blenkernel/intern/DerivedMesh.cc +++ b/source/blender/blenkernel/intern/DerivedMesh.cc @@ -1180,6 +1180,10 @@ static void mesh_calc_modifiers(struct Depsgraph *depsgraph, BKE_id_free(nullptr, mesh_orco_cloth); } + /* Remove temporary data layer only needed for modifier evaluation. + * Save some memory, and ensure GPU subdivision does not need to deal with this. */ + CustomData_free_layers(&mesh_final->vdata, CD_CLOTH_ORCO, mesh_final->totvert); + /* Compute normals. */ if (is_own_mesh) { mesh_calc_modifier_final_normals(mesh_input, &final_datamask, sculpt_dyntopo, mesh_final); diff --git a/source/blender/blenkernel/intern/multires_reshape_smooth.c b/source/blender/blenkernel/intern/multires_reshape_smooth.c index b76e2b3aec6..8246de12ebf 100644 --- a/source/blender/blenkernel/intern/multires_reshape_smooth.c +++ b/source/blender/blenkernel/intern/multires_reshape_smooth.c @@ -1073,7 +1073,9 @@ static void reshape_subdiv_create(MultiresReshapeSmoothContext *reshape_smooth_c converter_init(reshape_smooth_context, &converter); Subdiv *reshape_subdiv = BKE_subdiv_new_from_converter(settings, &converter); - BKE_subdiv_eval_begin(reshape_subdiv, SUBDIV_EVALUATOR_TYPE_CPU, NULL); + + OpenSubdiv_EvaluatorSettings evaluator_settings = {0}; + BKE_subdiv_eval_begin(reshape_subdiv, SUBDIV_EVALUATOR_TYPE_CPU, NULL, &evaluator_settings); reshape_smooth_context->reshape_subdiv = reshape_subdiv; diff --git a/source/blender/blenkernel/intern/subdiv_eval.c b/source/blender/blenkernel/intern/subdiv_eval.c index 9edd9815400..d03c0f89948 100644 --- a/source/blender/blenkernel/intern/subdiv_eval.c +++ b/source/blender/blenkernel/intern/subdiv_eval.c @@ -44,7 +44,8 @@ static eOpenSubdivEvaluator opensubdiv_evalutor_from_subdiv_evaluator_type( bool BKE_subdiv_eval_begin(Subdiv *subdiv, eSubdivEvaluatorType evaluator_type, - OpenSubdiv_EvaluatorCache *evaluator_cache) + OpenSubdiv_EvaluatorCache *evaluator_cache, + const OpenSubdiv_EvaluatorSettings *settings) { BKE_subdiv_stats_reset(&subdiv->stats, SUBDIV_STATS_EVALUATOR_CREATE); if (subdiv->topology_refiner == NULL) { @@ -57,7 +58,7 @@ bool BKE_subdiv_eval_begin(Subdiv *subdiv, opensubdiv_evalutor_from_subdiv_evaluator_type(evaluator_type); BKE_subdiv_stats_begin(&subdiv->stats, SUBDIV_STATS_EVALUATOR_CREATE); subdiv->evaluator = openSubdiv_createEvaluatorFromTopologyRefiner( - subdiv->topology_refiner, opensubdiv_evaluator_type, evaluator_cache); + subdiv->topology_refiner, opensubdiv_evaluator_type, evaluator_cache, settings); BKE_subdiv_stats_end(&subdiv->stats, SUBDIV_STATS_EVALUATOR_CREATE); if (subdiv->evaluator == NULL) { return false; @@ -179,13 +180,52 @@ static void set_face_varying_data_from_uv(Subdiv *subdiv, MEM_freeN(buffer); } +static void set_vertex_data_from_orco(Subdiv *subdiv, const Mesh *mesh) +{ + const float(*orco)[3] = CustomData_get_layer(&mesh->vdata, CD_ORCO); + const float(*cloth_orco)[3] = CustomData_get_layer(&mesh->vdata, CD_CLOTH_ORCO); + + if (orco || cloth_orco) { + OpenSubdiv_TopologyRefiner *topology_refiner = subdiv->topology_refiner; + OpenSubdiv_Evaluator *evaluator = subdiv->evaluator; + const int num_verts = topology_refiner->getNumVertices(topology_refiner); + + 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->vdata, CD_ORCO) ? 3 : 0) + + (CustomData_has_layer(&mesh->vdata, CD_CLOTH_ORCO) ? 3 : 0); +} + bool BKE_subdiv_eval_begin_from_mesh(Subdiv *subdiv, const Mesh *mesh, const float (*coarse_vertex_cos)[3], eSubdivEvaluatorType evaluator_type, OpenSubdiv_EvaluatorCache *evaluator_cache) { - if (!BKE_subdiv_eval_begin(subdiv, evaluator_type, evaluator_cache)) { + OpenSubdiv_EvaluatorSettings settings = {0}; + get_mesh_evaluator_settings(&settings, mesh); + if (!BKE_subdiv_eval_begin(subdiv, evaluator_type, evaluator_cache, &settings)) { return false; } return BKE_subdiv_eval_refine_from_mesh(subdiv, mesh, coarse_vertex_cos); @@ -208,6 +248,8 @@ bool BKE_subdiv_eval_refine_from_mesh(Subdiv *subdiv, const MLoopUV *mloopuv = CustomData_get_layer_n(&mesh->ldata, CD_MLOOPUV, 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. */ BKE_subdiv_stats_begin(&subdiv->stats, SUBDIV_STATS_EVALUATOR_REFINE); subdiv->evaluator->refine(subdiv->evaluator); @@ -281,6 +323,12 @@ void BKE_subdiv_eval_limit_point_and_normal(Subdiv *subdiv, normalize_v3(r_N); } +void BKE_subdiv_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 BKE_subdiv_eval_face_varying(Subdiv *subdiv, const int face_varying_channel, const int ptex_face_index, diff --git a/source/blender/blenkernel/intern/subdiv_mesh.c b/source/blender/blenkernel/intern/subdiv_mesh.c index 83427adcb43..e846dc2d807 100644 --- a/source/blender/blenkernel/intern/subdiv_mesh.c +++ b/source/blender/blenkernel/intern/subdiv_mesh.c @@ -44,6 +44,9 @@ typedef struct SubdivMeshContext { /* UV layers interpolation. */ int num_uv_layers; MLoopUV *uv_layers[MAX_MTFACE]; + /* Orco interpolation. */ + float (*orco)[3]; + float (*cloth_orco)[3]; /* Per-subdivided vertex counter of averaged values. */ int *accumulated_counters; bool have_displacement; @@ -69,6 +72,9 @@ static void subdiv_mesh_ctx_cache_custom_data_layers(SubdivMeshContext *ctx) ctx->poly_origindex = CustomData_get_layer(&subdiv_mesh->pdata, CD_ORIGINDEX); /* UV layers interpolation. */ subdiv_mesh_ctx_cache_uv_layers(ctx); + /* Orco interpolation. */ + ctx->orco = CustomData_get_layer(&subdiv_mesh->vdata, CD_ORCO); + ctx->cloth_orco = CustomData_get_layer(&subdiv_mesh->vdata, CD_CLOTH_ORCO); } static void subdiv_mesh_prepare_accumulator(SubdivMeshContext *ctx, int num_vertices) @@ -417,6 +423,34 @@ static void subdiv_mesh_tls_free(void *tls_v) /** \} */ /* -------------------------------------------------------------------- */ +/** \name Evaluation helper functions + * \{ */ + +static void subdiv_vertex_orco_evaluate(const SubdivMeshContext *ctx, + const int ptex_face_index, + const float u, + const float v, + const int subdiv_vertex_index) +{ + if (ctx->orco || ctx->cloth_orco) { + float vertex_data[6]; + BKE_subdiv_eval_vertex_data(ctx->subdiv, ptex_face_index, u, v, vertex_data); + + if (ctx->orco) { + copy_v3_v3(ctx->orco[subdiv_vertex_index], vertex_data); + if (ctx->cloth_orco) { + copy_v3_v3(ctx->orco[subdiv_vertex_index], vertex_data + 3); + } + } + else if (ctx->cloth_orco) { + copy_v3_v3(ctx->orco[subdiv_vertex_index], vertex_data); + } + } +} + +/** \} */ + +/* -------------------------------------------------------------------- */ /** \name Accumulation helpers * \{ */ @@ -530,6 +564,8 @@ static void evaluate_vertex_and_apply_displacement_copy(const SubdivMeshContext BKE_subdiv_eval_limit_point(ctx->subdiv, ptex_face_index, u, v, subdiv_vert->co); /* Apply displacement. */ add_v3_v3(subdiv_vert->co, D); + /* Evaluate undeformed texture coordinate. */ + subdiv_vertex_orco_evaluate(ctx, ptex_face_index, u, v, subdiv_vertex_index); /* Remove facedot flag. This can happen if there is more than one subsurf modifier. */ BLI_BITMAP_DISABLE(ctx->subdiv_mesh->runtime.subsurf_face_dot_tags, subdiv_vertex_index); } @@ -556,6 +592,8 @@ static void evaluate_vertex_and_apply_displacement_interpolate( BKE_subdiv_eval_limit_point(ctx->subdiv, ptex_face_index, u, v, subdiv_vert->co); /* Apply displacement. */ add_v3_v3(subdiv_vert->co, D); + /* Evaluate undeformed texture coordinate. */ + subdiv_vertex_orco_evaluate(ctx, ptex_face_index, u, v, subdiv_vertex_index); } static void subdiv_mesh_vertex_displacement_every_corner_or_edge( @@ -723,6 +761,7 @@ static void subdiv_mesh_vertex_inner(const SubdivForeachContext *foreach_context subdiv_vertex_data_interpolate(ctx, subdiv_vert, &tls->vertex_interpolation, u, v); BKE_subdiv_eval_final_point(subdiv, ptex_face_index, u, v, subdiv_vert->co); subdiv_mesh_tag_center_vertex(coarse_poly, subdiv_vertex_index, u, v, subdiv_mesh); + subdiv_vertex_orco_evaluate(ctx, ptex_face_index, u, v, subdiv_vertex_index); } /** \} */ |