griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Subdiv: Use nested namespaces and static for opensubdiv module

Browse Source 
Declaring the `blender::opensubdiv` namespace on one line is just shorter.
`static` is preferred over anonymous namespaces since it's locally visible.
This commit is contained in:
Hans Goudey
2024-04-18 16:41:12 -04:00
parent be75f1ac2b
commit ec09931d55
27 changed files with 230 additions and 295 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
intern/opensubdiv/internal/base/memory.h
View File

@@ -7,10 +7,8 @@
#include "MEM_guardedalloc.h"
namespace blender {
namespace opensubdiv {
namespace blender::opensubdiv {
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv
#endif // OPENSUBDIV_BASE_MEMORY_H_

6
intern/opensubdiv/internal/base/type_convert.cc
View File

@@ -13,8 +13,7 @@
#include <cassert>
#include <opensubdiv/sdc/crease.h>
namespace blender {
namespace opensubdiv {
namespace blender::opensubdiv {
OpenSubdiv::Sdc::SchemeType getSchemeTypeFromCAPI(OpenSubdiv_SchemeType type)
{
@@ -91,5 +90,4 @@ OpenSubdiv::Sdc::Options::VtxBoundaryInterpolation getVtxBoundaryInterpolationFr
return Options::VTX_BOUNDARY_EDGE_ONLY;
}
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv

6
intern/opensubdiv/internal/base/type_convert.h
View File

@@ -18,8 +18,7 @@
struct OpenSubdiv_Converter;
namespace blender {
namespace opensubdiv {
namespace blender::opensubdiv {
// Convert scheme type from C-API enum to an OpenSubdiv native enum.
OpenSubdiv::Sdc::SchemeType getSchemeTypeFromCAPI(OpenSubdiv_SchemeType type);
@@ -36,7 +35,6 @@ OpenSubdiv_FVarLinearInterpolation getCAPIFVarLinearInterpolationFromOSD(
OpenSubdiv::Sdc::Options::VtxBoundaryInterpolation getVtxBoundaryInterpolationFromCAPI(
OpenSubdiv_VtxBoundaryInterpolation boundary_interpolation);
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv
#endif // OPENSUBDIV_BASE_TYPE_CONVERT_H_

6
intern/opensubdiv/internal/base/util.cc
View File

@@ -4,8 +4,7 @@
#include "internal/base/util.h"
namespace blender {
namespace opensubdiv {
namespace blender::opensubdiv {
void stringSplit(std::vector<std::string> *tokens,
const std::string &str,
@@ -39,5 +38,4 @@ void stringSplit(std::vector<std::string> *tokens,
}
}
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv

6
intern/opensubdiv/internal/base/util.h
View File

@@ -8,15 +8,13 @@
#include <string>
#include <vector>
namespace blender {
namespace opensubdiv {
namespace blender::opensubdiv {
void stringSplit(std::vector<std::string> *tokens,
const std::string &str,
const std::string &separators,
bool skip_empty);
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv
#endif // OPENSUBDIV_BASE_UTIL_H_

7
intern/opensubdiv/internal/evaluator/eval_output.cc
View File

@@ -6,9 +6,7 @@
#include "internal/evaluator/eval_output.h"
namespace blender {
namespace opensubdiv {
namespace blender::opensubdiv {
bool is_adaptive(CpuPatchTable *patch_table)
{
return patch_table->GetPatchArrayBuffer()[0].GetDescriptor().IsAdaptive();
@@ -19,5 +17,4 @@ bool is_adaptive(GLPatchTable *patch_table)
return patch_table->GetPatchArrays()[0].GetDescriptor().IsAdaptive();
}
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv

9
intern/opensubdiv/internal/evaluator/eval_output.h
View File

@@ -23,8 +23,7 @@ using OpenSubdiv::Osd::CpuPatchTable;
using OpenSubdiv::Osd::GLPatchTable;
using OpenSubdiv::Osd::PatchCoord;
namespace blender {
namespace opensubdiv {
namespace blender::opensubdiv {
// Base class for the implementation of the evaluators.
class EvalOutputAPI::EvalOutput {
@@ -114,8 +113,6 @@ class EvalOutputAPI::EvalOutput {
}
};
namespace {
// Buffer which implements API required by OpenSubdiv and uses an existing memory as an underlying
// storage.
template<typename T> class RawDataWrapperBuffer {
@@ -161,7 +158,6 @@ class ConstPatchCoordWrapperBuffer : public RawDataWrapperVertexBuffer<const Pat
{
}
};
} // namespace
// Discriminators used in FaceVaryingVolatileEval in order to detect whether we are using adaptive
// patches as the CPU and OpenGL PatchTable have different APIs.
@@ -646,7 +642,6 @@ class VolatileEvalOutput : public EvalOutputAPI::EvalOutput {
DEVICE_CONTEXT *device_context_;
};
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv
#endif // OPENSUBDIV_EVAL_OUTPUT_H_

6
intern/opensubdiv/internal/evaluator/eval_output_cpu.cc
View File

@@ -4,8 +4,6 @@
*
* Author: Sergey Sharybin. */
namespace blender {
namespace opensubdiv {
namespace blender::opensubdiv {
}
} // namespace blender
} // namespace blender::opensubdiv

6
intern/opensubdiv/internal/evaluator/eval_output_cpu.h
View File

@@ -17,8 +17,7 @@ using OpenSubdiv::Far::StencilTable;
using OpenSubdiv::Osd::CpuEvaluator;
using OpenSubdiv::Osd::CpuVertexBuffer;
namespace blender {
namespace opensubdiv {
namespace blender::opensubdiv {
// NOTE: Define as a class instead of typedef to make it possible
// to have anonymous class in opensubdiv_evaluator_internal.h
@@ -48,7 +47,6 @@ class CpuEvalOutput : public VolatileEvalOutput<CpuVertexBuffer,
}
};
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv
#endif // OPENSUBDIV_EVAL_OUTPUT_CPU_H_

10
intern/opensubdiv/internal/evaluator/eval_output_gpu.cc
View File

@@ -11,10 +11,7 @@
using OpenSubdiv::Osd::PatchArray;
using OpenSubdiv::Osd::PatchArrayVector;
namespace blender {
namespace opensubdiv {
namespace {
namespace blender::opensubdiv {
static void buildPatchArraysBufferFromVector(const PatchArrayVector &patch_arrays,
OpenSubdiv_Buffer *patch_arrays_buffer)
@@ -27,8 +24,6 @@ static void buildPatchArraysBufferFromVector(const PatchArrayVector &patch_array
patch_arrays_buffer, 0, patch_array_byte_site, &patch_arrays[0]);
}
} // namespace
GpuEvalOutput::GpuEvalOutput(const StencilTable *vertex_stencils,
const StencilTable *varying_stencils,
const std::vector<const StencilTable *> &all_face_varying_stencils,
@@ -110,5 +105,4 @@ void GpuEvalOutput::wrapFVarSrcBuffer(const int face_varying_channel,
src_buffer->wrap_device_handle(src_buffer, vertex_buffer->BindVBO());
}
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv

6
intern/opensubdiv/internal/evaluator/eval_output_gpu.h
View File

@@ -15,8 +15,7 @@
using OpenSubdiv::Osd::GLVertexBuffer;
namespace blender {
namespace opensubdiv {
namespace blender::opensubdiv {
class GpuEvalOutput : public VolatileEvalOutput<GLVertexBuffer,
GLVertexBuffer,
@@ -53,7 +52,6 @@ class GpuEvalOutput : public VolatileEvalOutput<GLVertexBuffer,
void wrapFVarSrcBuffer(const int face_varying_channel, OpenSubdiv_Buffer *src_buffer) override;
};
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv
#endif // OPENSUBDIV_EVAL_OUTPUT_GPU_H_

201
intern/opensubdiv/internal/evaluator/evaluator_capi.cc
View File

@@ -14,145 +14,143 @@
#include "internal/evaluator/evaluator_cache_impl.h"
#include "internal/evaluator/evaluator_impl.h"
namespace {
void setSettings(struct OpenSubdiv_Evaluator *evaluator,
const OpenSubdiv_EvaluatorSettings *settings)
static void setSettings(struct OpenSubdiv_Evaluator *evaluator,
const OpenSubdiv_EvaluatorSettings *settings)
{
evaluator->impl->eval_output->setSettings(settings);
}
void setCoarsePositions(OpenSubdiv_Evaluator *evaluator,
const float *positions,
const int start_vertex_index,
const int num_vertices)
static void setCoarsePositions(OpenSubdiv_Evaluator *evaluator,
const float *positions,
const int start_vertex_index,
const int num_vertices)
{
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)
static 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,
const int num_vertices)
static void setVaryingData(OpenSubdiv_Evaluator *evaluator,
const float *varying_data,
const int start_vertex_index,
const int num_vertices)
{
evaluator->impl->eval_output->setVaryingData(varying_data, start_vertex_index, num_vertices);
}
void setFaceVaryingData(OpenSubdiv_Evaluator *evaluator,
const int face_varying_channel,
const float *face_varying_data,
const int start_vertex_index,
const int num_vertices)
static void setFaceVaryingData(OpenSubdiv_Evaluator *evaluator,
const int face_varying_channel,
const float *face_varying_data,
const int start_vertex_index,
const int num_vertices)
{
evaluator->impl->eval_output->setFaceVaryingData(
face_varying_channel, face_varying_data, start_vertex_index, num_vertices);
}
void setCoarsePositionsFromBuffer(OpenSubdiv_Evaluator *evaluator,
const void *buffer,
const int start_offset,
const int stride,
const int start_vertex_index,
const int num_vertices)
static void setCoarsePositionsFromBuffer(OpenSubdiv_Evaluator *evaluator,
const void *buffer,
const int start_offset,
const int stride,
const int start_vertex_index,
const int num_vertices)
{
evaluator->impl->eval_output->setCoarsePositionsFromBuffer(
buffer, start_offset, stride, start_vertex_index, num_vertices);
}
void setVaryingDataFromBuffer(OpenSubdiv_Evaluator *evaluator,
const void *buffer,
const int start_offset,
const int stride,
const int start_vertex_index,
const int num_vertices)
static void setVaryingDataFromBuffer(OpenSubdiv_Evaluator *evaluator,
const void *buffer,
const int start_offset,
const int stride,
const int start_vertex_index,
const int num_vertices)
{
evaluator->impl->eval_output->setVaryingDataFromBuffer(
buffer, start_offset, stride, start_vertex_index, num_vertices);
}
void setFaceVaryingDataFromBuffer(OpenSubdiv_Evaluator *evaluator,
const int face_varying_channel,
const void *buffer,
const int start_offset,
const int stride,
const int start_vertex_index,
const int num_vertices)
static void setFaceVaryingDataFromBuffer(OpenSubdiv_Evaluator *evaluator,
const int face_varying_channel,
const void *buffer,
const int start_offset,
const int stride,
const int start_vertex_index,
const int num_vertices)
{
evaluator->impl->eval_output->setFaceVaryingDataFromBuffer(
face_varying_channel, buffer, start_offset, stride, start_vertex_index, num_vertices);
}
void refine(OpenSubdiv_Evaluator *evaluator)
static void refine(OpenSubdiv_Evaluator *evaluator)
{
evaluator->impl->eval_output->refine();
}
void evaluateLimit(OpenSubdiv_Evaluator *evaluator,
const int ptex_face_index,
const float face_u,
const float face_v,
float P[3],
float dPdu[3],
float dPdv[3])
static void evaluateLimit(OpenSubdiv_Evaluator *evaluator,
const int ptex_face_index,
const float face_u,
const float face_v,
float P[3],
float dPdu[3],
float dPdv[3])
{
evaluator->impl->eval_output->evaluateLimit(ptex_face_index, face_u, face_v, P, dPdu, dPdv);
}
void evaluatePatchesLimit(OpenSubdiv_Evaluator *evaluator,
const OpenSubdiv_PatchCoord *patch_coords,
const int num_patch_coords,
float *P,
float *dPdu,
float *dPdv)
static void evaluatePatchesLimit(OpenSubdiv_Evaluator *evaluator,
const OpenSubdiv_PatchCoord *patch_coords,
const int num_patch_coords,
float *P,
float *dPdu,
float *dPdv)
{
evaluator->impl->eval_output->evaluatePatchesLimit(
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])
static 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,
float face_v,
float varying[3])
static void evaluateVarying(OpenSubdiv_Evaluator *evaluator,
const int ptex_face_index,
float face_u,
float face_v,
float varying[3])
{
evaluator->impl->eval_output->evaluateVarying(ptex_face_index, face_u, face_v, varying);
}
void evaluateFaceVarying(OpenSubdiv_Evaluator *evaluator,
const int face_varying_channel,
const int ptex_face_index,
float face_u,
float face_v,
float face_varying[2])
static void evaluateFaceVarying(OpenSubdiv_Evaluator *evaluator,
const int face_varying_channel,
const int ptex_face_index,
float face_u,
float face_v,
float face_varying[2])
{
evaluator->impl->eval_output->evaluateFaceVarying(
face_varying_channel, ptex_face_index, face_u, face_v, face_varying);
}
void getPatchMap(struct OpenSubdiv_Evaluator *evaluator,
struct OpenSubdiv_Buffer *patch_map_handles,
struct OpenSubdiv_Buffer *patch_map_quadtree,
int *min_patch_face,
int *max_patch_face,
int *max_depth,
int *patches_are_triangular)
static void getPatchMap(struct OpenSubdiv_Evaluator *evaluator,
struct OpenSubdiv_Buffer *patch_map_handles,
struct OpenSubdiv_Buffer *patch_map_quadtree,
int *min_patch_face,
int *max_patch_face,
int *max_depth,
int *patches_are_triangular)
{
evaluator->impl->eval_output->getPatchMap(patch_map_handles,
patch_map_quadtree,
@@ -162,70 +160,71 @@ void getPatchMap(struct OpenSubdiv_Evaluator *evaluator,
patches_are_triangular);
}
void fillPatchArraysBuffer(struct OpenSubdiv_Evaluator *evaluator,
struct OpenSubdiv_Buffer *patch_array_buffer)
static void fillPatchArraysBuffer(struct OpenSubdiv_Evaluator *evaluator,
struct OpenSubdiv_Buffer *patch_array_buffer)
{
evaluator->impl->eval_output->fillPatchArraysBuffer(patch_array_buffer);
}
void wrapPatchIndexBuffer(struct OpenSubdiv_Evaluator *evaluator,
struct OpenSubdiv_Buffer *patch_index_buffer)
static void wrapPatchIndexBuffer(struct OpenSubdiv_Evaluator *evaluator,
struct OpenSubdiv_Buffer *patch_index_buffer)
{
evaluator->impl->eval_output->wrapPatchIndexBuffer(patch_index_buffer);
}
void wrapPatchParamBuffer(struct OpenSubdiv_Evaluator *evaluator,
struct OpenSubdiv_Buffer *patch_param_buffer)
static void wrapPatchParamBuffer(struct OpenSubdiv_Evaluator *evaluator,
struct OpenSubdiv_Buffer *patch_param_buffer)
{
evaluator->impl->eval_output->wrapPatchParamBuffer(patch_param_buffer);
}
void wrapSrcBuffer(struct OpenSubdiv_Evaluator *evaluator, struct OpenSubdiv_Buffer *src_buffer)
static void wrapSrcBuffer(struct OpenSubdiv_Evaluator *evaluator,
struct OpenSubdiv_Buffer *src_buffer)
{
evaluator->impl->eval_output->wrapSrcBuffer(src_buffer);
}
void wrapSrcVertexDataBuffer(struct OpenSubdiv_Evaluator *evaluator,
struct OpenSubdiv_Buffer *src_buffer)
static void wrapSrcVertexDataBuffer(struct OpenSubdiv_Evaluator *evaluator,
struct OpenSubdiv_Buffer *src_buffer)
{
evaluator->impl->eval_output->wrapSrcVertexDataBuffer(src_buffer);
}
void fillFVarPatchArraysBuffer(struct OpenSubdiv_Evaluator *evaluator,
const int face_varying_channel,
struct OpenSubdiv_Buffer *patch_array_buffer)
static void fillFVarPatchArraysBuffer(struct OpenSubdiv_Evaluator *evaluator,
const int face_varying_channel,
struct OpenSubdiv_Buffer *patch_array_buffer)
{
evaluator->impl->eval_output->fillFVarPatchArraysBuffer(face_varying_channel,
patch_array_buffer);
}
void wrapFVarPatchIndexBuffer(struct OpenSubdiv_Evaluator *evaluator,
const int face_varying_channel,
struct OpenSubdiv_Buffer *patch_index_buffer)
static void wrapFVarPatchIndexBuffer(struct OpenSubdiv_Evaluator *evaluator,
const int face_varying_channel,
struct OpenSubdiv_Buffer *patch_index_buffer)
{
evaluator->impl->eval_output->wrapFVarPatchIndexBuffer(face_varying_channel, patch_index_buffer);
}
void wrapFVarPatchParamBuffer(struct OpenSubdiv_Evaluator *evaluator,
const int face_varying_channel,
struct OpenSubdiv_Buffer *patch_param_buffer)
static void wrapFVarPatchParamBuffer(struct OpenSubdiv_Evaluator *evaluator,
const int face_varying_channel,
struct OpenSubdiv_Buffer *patch_param_buffer)
{
evaluator->impl->eval_output->wrapFVarPatchParamBuffer(face_varying_channel, patch_param_buffer);
}
void wrapFVarSrcBuffer(struct OpenSubdiv_Evaluator *evaluator,
const int face_varying_channel,
struct OpenSubdiv_Buffer *src_buffer)
static void wrapFVarSrcBuffer(struct OpenSubdiv_Evaluator *evaluator,
const int face_varying_channel,
struct OpenSubdiv_Buffer *src_buffer)
{
evaluator->impl->eval_output->wrapFVarSrcBuffer(face_varying_channel, src_buffer);
}
bool hasVertexData(struct OpenSubdiv_Evaluator *evaluator)
static bool hasVertexData(struct OpenSubdiv_Evaluator *evaluator)
{
return evaluator->impl->eval_output->hasVertexData();
}
void assignFunctionPointers(OpenSubdiv_Evaluator *evaluator)
static void assignFunctionPointers(OpenSubdiv_Evaluator *evaluator)
{
evaluator->setSettings = setSettings;
@@ -263,8 +262,6 @@ void assignFunctionPointers(OpenSubdiv_Evaluator *evaluator)
evaluator->hasVertexData = hasVertexData;
}
} // namespace
OpenSubdiv_Evaluator *openSubdiv_createEvaluatorFromTopologyRefiner(
OpenSubdiv_TopologyRefiner *topology_refiner,
eOpenSubdivEvaluator evaluator_type,

18
intern/opensubdiv/internal/evaluator/evaluator_impl.cc
View File

@@ -38,10 +38,7 @@ using OpenSubdiv::Far::TopologyRefiner;
using OpenSubdiv::Osd::PatchArray;
using OpenSubdiv::Osd::PatchCoord;
namespace blender {
namespace opensubdiv {
namespace {
namespace blender::opensubdiv {
// Array implementation which stores small data on stack (or, rather, in the class itself).
template<typename T, int kNumMaxElementsOnStack> class StackOrHeapArray {
@@ -126,10 +123,10 @@ template<typename T, int kNumMaxElementsOnStack> class StackOrHeapArray {
// 32 is a number of inner vertices along the patch size at subdivision level 6.
typedef StackOrHeapArray<PatchCoord, 32 * 32> StackOrHeapPatchCoordArray;
void convertPatchCoordsToArray(const OpenSubdiv_PatchCoord *patch_coords,
const int num_patch_coords,
const PatchMap *patch_map,
StackOrHeapPatchCoordArray *array)
static void convertPatchCoordsToArray(const OpenSubdiv_PatchCoord *patch_coords,
const int num_patch_coords,
const PatchMap *patch_map,
StackOrHeapPatchCoordArray *array)
{
array->resize(num_patch_coords);
for (int i = 0; i < num_patch_coords; ++i) {
@@ -139,8 +136,6 @@ void convertPatchCoordsToArray(const OpenSubdiv_PatchCoord *patch_coords,
}
}
} // namespace
////////////////////////////////////////////////////////////////////////////////
// Evaluator wrapper for anonymous API.
@@ -410,8 +405,7 @@ bool EvalOutputAPI::hasVertexData() const
return implementation_->hasVertexData();
}
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv
OpenSubdiv_EvaluatorImpl::OpenSubdiv_EvaluatorImpl()
: eval_output(NULL), patch_map(NULL), patch_table(NULL)

6
intern/opensubdiv/internal/evaluator/evaluator_impl.h
View File

@@ -24,8 +24,7 @@ struct OpenSubdiv_EvaluatorSettings;
struct OpenSubdiv_PatchCoord;
struct OpenSubdiv_TopologyRefiner;
namespace blender {
namespace opensubdiv {
namespace blender::opensubdiv {
class PatchMap;
@@ -183,8 +182,7 @@ class EvalOutputAPI {
EvalOutput *implementation_;
};
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv
struct OpenSubdiv_EvaluatorImpl {
public:

6
intern/opensubdiv/internal/evaluator/gl_compute_evaluator.cc
View File

@@ -39,8 +39,7 @@ using OpenSubdiv::Osd::PatchArrayVector;
extern "C" char datatoc_glsl_compute_kernel_glsl[];
namespace blender {
namespace opensubdiv {
namespace blender::opensubdiv {
template<class T> GLuint createSSBO(std::vector<T> const &src)
{
@@ -657,5 +656,4 @@ bool GLComputeEvaluator::_PatchKernel::Compile(BufferDescriptor const &srcDesc,
return true;
}
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv

7
intern/opensubdiv/internal/evaluator/gl_compute_evaluator.h
View File

@@ -19,8 +19,7 @@ class StencilTable;
} // namespace OPENSUBDIV_VERSION
} // namespace OpenSubdiv
namespace blender {
namespace opensubdiv {
namespace blender::opensubdiv {
/// \brief GL stencil table (Shader Storage buffer)
///
@@ -2440,7 +2439,7 @@ class GLComputeEvaluator {
void DispatchCompute(int totalDispatchSize) const;
};
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv
#endif // OPENSUBDIV_GL_COMPUTE_EVALUATOR_H_

6
intern/opensubdiv/internal/evaluator/patch_map.cc
View File

@@ -14,8 +14,7 @@ using OpenSubdiv::Far::PatchParam;
using OpenSubdiv::Far::PatchParamTable;
using OpenSubdiv::Far::PatchTable;
namespace blender {
namespace opensubdiv {
namespace blender::opensubdiv {
//
// Inline quadtree assembly methods used by the constructor:
@@ -192,5 +191,4 @@ void PatchMap::initializeQuadtree(PatchTable const &patchTable)
_quadtree.swap(tmpTree);
}
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv

7
intern/opensubdiv/internal/evaluator/patch_map.h
View File

@@ -10,8 +10,7 @@
#include <opensubdiv/far/patchTable.h>
namespace blender {
namespace opensubdiv {
namespace blender::opensubdiv {
/// \brief An quadtree-based map connecting coarse faces to their sub-patches
///
@@ -245,7 +244,7 @@ inline PatchMap::Handle const *PatchMap::FindPatch(int faceid, double u, double
assert(0);
return 0;
}
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv
#endif // OPENSUBDIV_PATCH_MAP_H_

6
intern/opensubdiv/internal/topology/mesh_topology.cc
View File

@@ -8,8 +8,7 @@
#include <cassert>
namespace blender {
namespace opensubdiv {
namespace blender::opensubdiv {
MeshTopology::MeshTopology() : num_vertices_(0), num_edges_(0), num_faces_(0) {}
@@ -253,5 +252,4 @@ void MeshTopology::finishResizeTopology()
}
}
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv

6
intern/opensubdiv/internal/topology/mesh_topology.h
View File

@@ -13,8 +13,7 @@
struct OpenSubdiv_Converter;
namespace blender {
namespace opensubdiv {
namespace blender::opensubdiv {
// Simplified representation of mesh topology.
// Only includes parts of actual mesh topology which is needed to perform
@@ -160,7 +159,6 @@ class MeshTopology {
MEM_CXX_CLASS_ALLOC_FUNCS("MeshTopology");
};
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv
#endif // OPENSUBDIV_MESH_TOPOLOGY_H_

38
intern/opensubdiv/internal/topology/mesh_topology_compare.cc
View File

@@ -13,15 +13,12 @@
#include "opensubdiv_converter_capi.hh"
namespace blender {
namespace opensubdiv {
namespace {
namespace blender::opensubdiv {
////////////////////////////////////////////////////////////////////////////////
// Quick preliminary checks.
int getEffectiveNumEdges(const OpenSubdiv_Converter *converter)
static int getEffectiveNumEdges(const OpenSubdiv_Converter *converter)
{
if (converter->getNumEdges == nullptr) {
return 0;
@@ -30,8 +27,8 @@ int getEffectiveNumEdges(const OpenSubdiv_Converter *converter)
return converter->getNumEdges(converter);
}
bool isEqualGeometryCounters(const MeshTopology &mesh_topology,
const OpenSubdiv_Converter *converter)
static bool isEqualGeometryCounters(const MeshTopology &mesh_topology,
const OpenSubdiv_Converter *converter)
{
if (converter->getNumVertices(converter) != mesh_topology.getNumVertices()) {
return false;
@@ -51,7 +48,8 @@ bool isEqualGeometryCounters(const MeshTopology &mesh_topology,
// Edges.
bool isEqualGeometryEdge(const MeshTopology &mesh_topology, const OpenSubdiv_Converter *converter)
static bool isEqualGeometryEdge(const MeshTopology &mesh_topology,
const OpenSubdiv_Converter *converter)
{
const int num_requested_edges = getEffectiveNumEdges(converter);
if (num_requested_edges != mesh_topology.getNumEdges()) {
@@ -72,7 +70,8 @@ bool isEqualGeometryEdge(const MeshTopology &mesh_topology, const OpenSubdiv_Con
// Faces.
bool isEqualGeometryFace(const MeshTopology &mesh_topology, const OpenSubdiv_Converter *converter)
static bool isEqualGeometryFace(const MeshTopology &mesh_topology,
const OpenSubdiv_Converter *converter)
{
const int num_requested_faces = converter->getNumFaces(converter);
if (num_requested_faces != mesh_topology.getNumFaces()) {
@@ -99,7 +98,8 @@ bool isEqualGeometryFace(const MeshTopology &mesh_topology, const OpenSubdiv_Con
// Geometry comparison entry point.
bool isEqualGeometry(const MeshTopology &mesh_topology, const OpenSubdiv_Converter *converter)
static bool isEqualGeometry(const MeshTopology &mesh_topology,
const OpenSubdiv_Converter *converter)
{
if (!isEqualGeometryEdge(mesh_topology, converter)) {
return false;
@@ -117,7 +117,8 @@ bool isEqualGeometry(const MeshTopology &mesh_topology, const OpenSubdiv_Convert
// Vertices.
// TODO(sergey): Make this function usable by factory as well.
float getEffectiveVertexSharpness(const OpenSubdiv_Converter *converter, const int vertex_index)
static float getEffectiveVertexSharpness(const OpenSubdiv_Converter *converter,
const int vertex_index)
{
if (converter->isInfiniteSharpVertex != nullptr &&
converter->isInfiniteSharpVertex(converter, vertex_index))
@@ -132,7 +133,8 @@ float getEffectiveVertexSharpness(const OpenSubdiv_Converter *converter, const i
return 0.0f;
}
bool isEqualVertexTags(const MeshTopology &mesh_topology, const OpenSubdiv_Converter *converter)
static bool isEqualVertexTags(const MeshTopology &mesh_topology,
const OpenSubdiv_Converter *converter)
{
const int num_vertices = mesh_topology.getNumVertices();
for (int vertex_index = 0; vertex_index < num_vertices; ++vertex_index) {
@@ -150,7 +152,7 @@ bool isEqualVertexTags(const MeshTopology &mesh_topology, const OpenSubdiv_Conve
// Edges.
// TODO(sergey): Make this function usable by factory as well.
float getEffectiveEdgeSharpness(const OpenSubdiv_Converter *converter, const int edge_index)
static float getEffectiveEdgeSharpness(const OpenSubdiv_Converter *converter, const int edge_index)
{
if (converter->getEdgeSharpness != nullptr) {
return converter->getEdgeSharpness(converter, edge_index);
@@ -159,7 +161,8 @@ float getEffectiveEdgeSharpness(const OpenSubdiv_Converter *converter, const int
return 0.0f;
}
bool isEqualEdgeTags(const MeshTopology &mesh_topology, const OpenSubdiv_Converter *converter)
static bool isEqualEdgeTags(const MeshTopology &mesh_topology,
const OpenSubdiv_Converter *converter)
{
const int num_edges = mesh_topology.getNumEdges();
for (int edge_index = 0; edge_index < num_edges; ++edge_index) {
@@ -188,7 +191,7 @@ bool isEqualEdgeTags(const MeshTopology &mesh_topology, const OpenSubdiv_Convert
// Tags comparison entry point.
bool isEqualTags(const MeshTopology &mesh_topology, const OpenSubdiv_Converter *converter)
static bool isEqualTags(const MeshTopology &mesh_topology, const OpenSubdiv_Converter *converter)
{
if (!isEqualVertexTags(mesh_topology, converter)) {
return false;
@@ -200,8 +203,6 @@ bool isEqualTags(const MeshTopology &mesh_topology, const OpenSubdiv_Converter *
return true;
}
} // namespace
////////////////////////////////////////////////////////////////////////////////
// Entry point.
@@ -225,5 +226,4 @@ bool MeshTopology::isEqualToConverter(const OpenSubdiv_Converter *converter) con
return true;
}
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv

6
intern/opensubdiv/internal/topology/mesh_topology_test.cc
View File

@@ -7,8 +7,7 @@
#include "internal/topology/mesh_topology.h"
#include "testing/testing.h"
namespace blender {
namespace opensubdiv {
namespace blender::opensubdiv {
TEST(MeshTopology, TrivialVertexSharpness)
{
@@ -82,5 +81,4 @@ TEST(MeshTopology, TrivialFaceTopology)
EXPECT_TRUE(mesh_topology.isFaceVertexIndicesEqual(2, {{7, 8, 9, 10, 11}}));
}
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv

78
intern/opensubdiv/internal/topology/topology_refiner_capi.cc
View File

@@ -10,26 +10,24 @@
#include "internal/base/type_convert.h"
#include "internal/topology/topology_refiner_impl.h"
namespace {
const OpenSubdiv::Far::TopologyRefiner *getOSDTopologyRefiner(
static const OpenSubdiv::Far::TopologyRefiner *getOSDTopologyRefiner(
const OpenSubdiv_TopologyRefiner *topology_refiner)
{
return topology_refiner->impl->topology_refiner;
}
const OpenSubdiv::Far::TopologyLevel &getOSDTopologyBaseLevel(
static const OpenSubdiv::Far::TopologyLevel &getOSDTopologyBaseLevel(
const OpenSubdiv_TopologyRefiner *topology_refiner)
{
return getOSDTopologyRefiner(topology_refiner)->GetLevel(0);
}
int getSubdivisionLevel(const OpenSubdiv_TopologyRefiner *topology_refiner)
static int getSubdivisionLevel(const OpenSubdiv_TopologyRefiner *topology_refiner)
{
return topology_refiner->impl->settings.level;
}
bool getIsAdaptive(const OpenSubdiv_TopologyRefiner *topology_refiner)
static bool getIsAdaptive(const OpenSubdiv_TopologyRefiner *topology_refiner)
{
return topology_refiner->impl->settings.is_adaptive;
}
@@ -37,17 +35,17 @@ bool getIsAdaptive(const OpenSubdiv_TopologyRefiner *topology_refiner)
////////////////////////////////////////////////////////////////////////////////
// Query basic topology information from base level.
int getNumVertices(const OpenSubdiv_TopologyRefiner *topology_refiner)
static int getNumVertices(const OpenSubdiv_TopologyRefiner *topology_refiner)
{
return getOSDTopologyBaseLevel(topology_refiner).GetNumVertices();
}
int getNumEdges(const OpenSubdiv_TopologyRefiner *topology_refiner)
static int getNumEdges(const OpenSubdiv_TopologyRefiner *topology_refiner)
{
return getOSDTopologyBaseLevel(topology_refiner).GetNumEdges();
}
int getNumFaces(const OpenSubdiv_TopologyRefiner *topology_refiner)
static int getNumFaces(const OpenSubdiv_TopologyRefiner *topology_refiner)
{
return getOSDTopologyBaseLevel(topology_refiner).GetNumFaces();
}
@@ -62,39 +60,41 @@ static void convertArrayToRaw(const OpenSubdiv::Far::ConstIndexArray &array, int
}
}
int getNumFaceVertices(const OpenSubdiv_TopologyRefiner *topology_refiner, const int face_index)
static int getNumFaceVertices(const OpenSubdiv_TopologyRefiner *topology_refiner,
const int face_index)
{
const OpenSubdiv::Far::TopologyLevel &base_level = getOSDTopologyBaseLevel(topology_refiner);
return base_level.GetFaceVertices(face_index).size();
}
void getFaceVertices(const OpenSubdiv_TopologyRefiner *topology_refiner,
const int face_index,
int *face_vertices_indices)
static void getFaceVertices(const OpenSubdiv_TopologyRefiner *topology_refiner,
const int face_index,
int *face_vertices_indices)
{
const OpenSubdiv::Far::TopologyLevel &base_level = getOSDTopologyBaseLevel(topology_refiner);
OpenSubdiv::Far::ConstIndexArray array = base_level.GetFaceVertices(face_index);
convertArrayToRaw(array, face_vertices_indices);
}
int getNumFaceEdges(const OpenSubdiv_TopologyRefiner *topology_refiner, const int face_index)
static int getNumFaceEdges(const OpenSubdiv_TopologyRefiner *topology_refiner,
const int face_index)
{
const OpenSubdiv::Far::TopologyLevel &base_level = getOSDTopologyBaseLevel(topology_refiner);
return base_level.GetFaceEdges(face_index).size();
}
void getFaceEdges(const OpenSubdiv_TopologyRefiner *topology_refiner,
const int face_index,
int *face_edges_indices)
static void getFaceEdges(const OpenSubdiv_TopologyRefiner *topology_refiner,
const int face_index,
int *face_edges_indices)
{
const OpenSubdiv::Far::TopologyLevel &base_level = getOSDTopologyBaseLevel(topology_refiner);
OpenSubdiv::Far::ConstIndexArray array = base_level.GetFaceEdges(face_index);
convertArrayToRaw(array, face_edges_indices);
}
void getEdgeVertices(const OpenSubdiv_TopologyRefiner *topology_refiner,
const int edge_index,
int edge_vertices_indices[2])
static void getEdgeVertices(const OpenSubdiv_TopologyRefiner *topology_refiner,
const int edge_index,
int edge_vertices_indices[2])
{
const OpenSubdiv::Far::TopologyLevel &base_level = getOSDTopologyBaseLevel(topology_refiner);
OpenSubdiv::Far::ConstIndexArray array = base_level.GetEdgeVertices(edge_index);
@@ -103,22 +103,24 @@ void getEdgeVertices(const OpenSubdiv_TopologyRefiner *topology_refiner,
edge_vertices_indices[1] = array[1];
}
int getNumVertexEdges(const OpenSubdiv_TopologyRefiner *topology_refiner, const int vertex_index)
static int getNumVertexEdges(const OpenSubdiv_TopologyRefiner *topology_refiner,
const int vertex_index)
{
const OpenSubdiv::Far::TopologyLevel &base_level = getOSDTopologyBaseLevel(topology_refiner);
return base_level.GetVertexEdges(vertex_index).size();
}
void getVertexEdges(const OpenSubdiv_TopologyRefiner *topology_refiner,
const int vertex_index,
int *vertex_edges_indices)
static void getVertexEdges(const OpenSubdiv_TopologyRefiner *topology_refiner,
const int vertex_index,
int *vertex_edges_indices)
{
const OpenSubdiv::Far::TopologyLevel &base_level = getOSDTopologyBaseLevel(topology_refiner);
OpenSubdiv::Far::ConstIndexArray array = base_level.GetVertexEdges(vertex_index);
convertArrayToRaw(array, vertex_edges_indices);
}
int getNumFacePtexFaces(const OpenSubdiv_TopologyRefiner *topology_refiner, const int face_index)
static int getNumFacePtexFaces(const OpenSubdiv_TopologyRefiner *topology_refiner,
const int face_index)
{
const int num_face_vertices = topology_refiner->getNumFaceVertices(topology_refiner, face_index);
if (num_face_vertices == 4) {
@@ -127,7 +129,7 @@ int getNumFacePtexFaces(const OpenSubdiv_TopologyRefiner *topology_refiner, cons
return num_face_vertices;
}
int getNumPtexFaces(const OpenSubdiv_TopologyRefiner *topology_refiner)
static int getNumPtexFaces(const OpenSubdiv_TopologyRefiner *topology_refiner)
{
const int num_faces = topology_refiner->getNumFaces(topology_refiner);
int num_ptex_faces = 0;
@@ -137,8 +139,8 @@ int getNumPtexFaces(const OpenSubdiv_TopologyRefiner *topology_refiner)
return num_ptex_faces;
}
void fillFacePtexIndexOffset(const OpenSubdiv_TopologyRefiner *topology_refiner,
int *face_ptex_index_offset)
static void fillFacePtexIndexOffset(const OpenSubdiv_TopologyRefiner *topology_refiner,
int *face_ptex_index_offset)
{
const int num_faces = topology_refiner->getNumFaces(topology_refiner);
int num_ptex_faces = 0;
@@ -151,28 +153,30 @@ void fillFacePtexIndexOffset(const OpenSubdiv_TopologyRefiner *topology_refiner,
////////////////////////////////////////////////////////////////////////////////
// Face-varying data.
int getNumFVarChannels(const struct OpenSubdiv_TopologyRefiner *topology_refiner)
static int getNumFVarChannels(const struct OpenSubdiv_TopologyRefiner *topology_refiner)
{
const OpenSubdiv::Far::TopologyLevel &base_level = getOSDTopologyBaseLevel(topology_refiner);
return base_level.GetNumFVarChannels();
}
OpenSubdiv_FVarLinearInterpolation getFVarLinearInterpolation(
static OpenSubdiv_FVarLinearInterpolation getFVarLinearInterpolation(
const struct OpenSubdiv_TopologyRefiner *topology_refiner)
{
return blender::opensubdiv::getCAPIFVarLinearInterpolationFromOSD(
getOSDTopologyRefiner(topology_refiner)->GetFVarLinearInterpolation());
}
int getNumFVarValues(const struct OpenSubdiv_TopologyRefiner *topology_refiner, const int channel)
static int getNumFVarValues(const struct OpenSubdiv_TopologyRefiner *topology_refiner,
const int channel)
{
const OpenSubdiv::Far::TopologyLevel &base_level = getOSDTopologyBaseLevel(topology_refiner);
return base_level.GetNumFVarValues(channel);
}
const int *getFaceFVarValueIndices(const struct OpenSubdiv_TopologyRefiner *topology_refiner,
const int face_index,
const int channel)
static const int *getFaceFVarValueIndices(
const struct OpenSubdiv_TopologyRefiner *topology_refiner,
const int face_index,
const int channel)
{
const OpenSubdiv::Far::TopologyLevel &base_level = getOSDTopologyBaseLevel(topology_refiner);
return &base_level.GetFaceFVarValues(face_index, channel)[0];
@@ -181,7 +185,7 @@ const int *getFaceFVarValueIndices(const struct OpenSubdiv_TopologyRefiner *topo
////////////////////////////////////////////////////////////////////////////////
// Internal helpers.
void assignFunctionPointers(OpenSubdiv_TopologyRefiner *topology_refiner)
static void assignFunctionPointers(OpenSubdiv_TopologyRefiner *topology_refiner)
{
topology_refiner->getSubdivisionLevel = getSubdivisionLevel;
topology_refiner->getIsAdaptive = getIsAdaptive;
@@ -207,15 +211,13 @@ void assignFunctionPointers(OpenSubdiv_TopologyRefiner *topology_refiner)
topology_refiner->getFaceFVarValueIndices = getFaceFVarValueIndices;
}
OpenSubdiv_TopologyRefiner *allocateTopologyRefiner()
static OpenSubdiv_TopologyRefiner *allocateTopologyRefiner()
{
OpenSubdiv_TopologyRefiner *topology_refiner = MEM_new<OpenSubdiv_TopologyRefiner>(__func__);
assignFunctionPointers(topology_refiner);
return topology_refiner;
}
} // namespace
OpenSubdiv_TopologyRefiner *openSubdiv_createTopologyRefinerFromConverter(
OpenSubdiv_Converter *converter, const OpenSubdiv_TopologyRefinerSettings *settings)
{

15
intern/opensubdiv/internal/topology/topology_refiner_factory.cc
View File

@@ -299,12 +299,9 @@ inline void TopologyRefinerFactory<TopologyRefinerData>::reportInvalidTopology(
} /* namespace OPENSUBDIV_VERSION */
} /* namespace OpenSubdiv */
namespace blender {
namespace opensubdiv {
namespace blender::opensubdiv {
namespace {
OpenSubdiv::Sdc::Options getSDCOptions(OpenSubdiv_Converter *converter)
static OpenSubdiv::Sdc::Options getSDCOptions(OpenSubdiv_Converter *converter)
{
using OpenSubdiv::Sdc::Options;
@@ -320,7 +317,8 @@ OpenSubdiv::Sdc::Options getSDCOptions(OpenSubdiv_Converter *converter)
return options;
}
TopologyRefinerFactoryType::Options getTopologyRefinerOptions(OpenSubdiv_Converter *converter)
static TopologyRefinerFactoryType::Options getTopologyRefinerOptions(
OpenSubdiv_Converter *converter)
{
using OpenSubdiv::Sdc::SchemeType;
@@ -337,8 +335,6 @@ TopologyRefinerFactoryType::Options getTopologyRefinerOptions(OpenSubdiv_Convert
return topology_options;
}
} // namespace
TopologyRefinerImpl *TopologyRefinerImpl::createFromConverter(
OpenSubdiv_Converter *converter, const OpenSubdiv_TopologyRefinerSettings &settings)
{
@@ -368,5 +364,4 @@ TopologyRefinerImpl *TopologyRefinerImpl::createFromConverter(
return topology_refiner_impl;
}
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv

6
intern/opensubdiv/internal/topology/topology_refiner_impl.cc
View File

@@ -6,8 +6,7 @@
#include "internal/topology/topology_refiner_impl.h"
namespace blender {
namespace opensubdiv {
namespace blender::opensubdiv {
TopologyRefinerImpl::TopologyRefinerImpl() : topology_refiner(nullptr) {}
@@ -16,5 +15,4 @@ TopologyRefinerImpl::~TopologyRefinerImpl()
delete topology_refiner;
}
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv

6
intern/opensubdiv/internal/topology/topology_refiner_impl.h
View File

@@ -19,8 +19,7 @@
struct OpenSubdiv_Converter;
namespace blender {
namespace opensubdiv {
namespace blender::opensubdiv {
class TopologyRefinerImpl {
public:
@@ -61,8 +60,7 @@ class TopologyRefinerImpl {
MEM_CXX_CLASS_ALLOC_FUNCS("TopologyRefinerImpl");
};
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv
struct OpenSubdiv_TopologyRefinerImpl : public blender::opensubdiv::TopologyRefinerImpl {};

39
intern/opensubdiv/internal/topology/topology_refiner_impl_compare.cc
View File

@@ -12,17 +12,15 @@
#include "opensubdiv_converter_capi.hh"
namespace blender {
namespace opensubdiv {
namespace {
namespace blender::opensubdiv {
const OpenSubdiv::Far::TopologyRefiner *getOSDTopologyRefiner(
static const OpenSubdiv::Far::TopologyRefiner *getOSDTopologyRefiner(
const TopologyRefinerImpl *topology_refiner_impl)
{
return topology_refiner_impl->topology_refiner;
}
const OpenSubdiv::Far::TopologyLevel &getOSDTopologyBaseLevel(
static const OpenSubdiv::Far::TopologyLevel &getOSDTopologyBaseLevel(
const TopologyRefinerImpl *topology_refiner_impl)
{
return getOSDTopologyRefiner(topology_refiner_impl)->GetLevel(0);
@@ -31,16 +29,16 @@ const OpenSubdiv::Far::TopologyLevel &getOSDTopologyBaseLevel(
////////////////////////////////////////////////////////////////////////////////
// Quick preliminary checks.
bool checkSchemeTypeMatches(const TopologyRefinerImpl *topology_refiner_impl,
const OpenSubdiv_Converter *converter)
static bool checkSchemeTypeMatches(const TopologyRefinerImpl *topology_refiner_impl,
const OpenSubdiv_Converter *converter)
{
const OpenSubdiv::Sdc::SchemeType converter_scheme_type =
blender::opensubdiv::getSchemeTypeFromCAPI(converter->getSchemeType(converter));
return (converter_scheme_type == getOSDTopologyRefiner(topology_refiner_impl)->GetSchemeType());
}
bool checkOptionsMatches(const TopologyRefinerImpl *topology_refiner_impl,
const OpenSubdiv_Converter *converter)
static bool checkOptionsMatches(const TopologyRefinerImpl *topology_refiner_impl,
const OpenSubdiv_Converter *converter)
{
typedef OpenSubdiv::Sdc::Options Options;
const Options options = getOSDTopologyRefiner(topology_refiner_impl)->GetSchemeOptions();
@@ -54,8 +52,8 @@ bool checkOptionsMatches(const TopologyRefinerImpl *topology_refiner_impl,
return true;
}
bool checkPreliminaryMatches(const TopologyRefinerImpl *topology_refiner_impl,
const OpenSubdiv_Converter *converter)
static bool checkPreliminaryMatches(const TopologyRefinerImpl *topology_refiner_impl,
const OpenSubdiv_Converter *converter)
{
return checkSchemeTypeMatches(topology_refiner_impl, converter) &&
checkOptionsMatches(topology_refiner_impl, converter);
@@ -68,9 +66,9 @@ bool checkPreliminaryMatches(const TopologyRefinerImpl *topology_refiner_impl,
// indexing and, possibly, move to mesh topology as well if winding affects
// face-varyign as well.
bool checkSingleUVLayerMatch(const OpenSubdiv::Far::TopologyLevel &base_level,
const OpenSubdiv_Converter *converter,
const int layer_index)
static bool checkSingleUVLayerMatch(const OpenSubdiv::Far::TopologyLevel &base_level,
const OpenSubdiv_Converter *converter,
const int layer_index)
{
converter->precalcUVLayer(converter, layer_index);
const int num_faces = base_level.GetNumFaces();
@@ -91,8 +89,8 @@ bool checkSingleUVLayerMatch(const OpenSubdiv::Far::TopologyLevel &base_level,
return true;
}
bool checkUVLayersMatch(const TopologyRefinerImpl *topology_refiner_impl,
const OpenSubdiv_Converter *converter)
static bool checkUVLayersMatch(const TopologyRefinerImpl *topology_refiner_impl,
const OpenSubdiv_Converter *converter)
{
using OpenSubdiv::Far::TopologyLevel;
const int num_layers = converter->getNumUVLayers(converter);
@@ -109,14 +107,12 @@ bool checkUVLayersMatch(const TopologyRefinerImpl *topology_refiner_impl,
return true;
}
bool checkTopologyAttributesMatch(const TopologyRefinerImpl *topology_refiner_impl,
const OpenSubdiv_Converter *converter)
static bool checkTopologyAttributesMatch(const TopologyRefinerImpl *topology_refiner_impl,
const OpenSubdiv_Converter *converter)
{
return checkUVLayersMatch(topology_refiner_impl, converter);
}
} // namespace
bool TopologyRefinerImpl::isEqualToConverter(const OpenSubdiv_Converter *converter) const
{
if (!blender::opensubdiv::checkPreliminaryMatches(this, converter)) {
@@ -136,5 +132,4 @@ bool TopologyRefinerImpl::isEqualToConverter(const OpenSubdiv_Converter *convert
return true;
}
} // namespace opensubdiv
} // namespace blender
} // namespace blender::opensubdiv