- retained precision of constants in Sdc Catmark scheme
- improved precision of constants & intermediate values in Sdc Loop scheme
- improved precision of constants & intermediate values CatmarkPatchBuilder
- converted all internal Far patch basis evaluation to templates
The issue is that FeatureMask structure has size of an integer, but only
first 11 bytes are initialized, the rest is left non-initialized to a
stack memory of RefineAdaptive(). This will cause issues with IsEmpty()
which check whether any of integer's bits are set, effectively causing
jumps dependent on a non-initialized memory.
- new PatchTableBuilder class now implements PatchTableFactory::Create()
- population of tables now independent of scheme or patch type
- nested LocalPointHelper handles local point sharing and stencils
- new PatchBuilder class encapsulates patch queries and conversions:
- provides patch types associated with schemes and client options
- handles all topological queries about patches in the base class
- subclasses for the three subdivision schemes to support conversions
- conversions encapsulated in new SparseMatrix class for re-use
- removed Far end-cap factory classes and Far::GregoryBasis
- extended adaptive refinement to support Bilinear scheme (not enabled)
- extended Vtr::StackBuffer to avoid compiler inefficiencies
Previously, Far::PatchTableFactory::computePatchParam() was
considering all faces with a face vertex count != 4 as
irregular. This was incorrect for triangle refinement as
was the calculation of the UV subface parametric offsets for
triangle subfaces.
This is foundational work for implementing full support
for Loop scheme patch tables. This fix also allows correct
decoding of the parameter mapping for triangles resulting
from uniform refinement of Loop scheme meshes.
Updated Metal patch shaders to resolve degenerate normals.
This fix was ported from the GLSL patch shader source.
Also, added missing inf sharp test cases to mtlViewer.
Updated HLSL patch shaders to resolve degenerate normals.
This fix was ported from the GLSL patch shader source.
Also, added missing inf sharp test cases to dxViewer.
- corrected assertion to use face-varying index offset instead of vertex
- added missing face-varying conditional when generateAllLevels set
- factored base-level index offsets into local options for clarity
- added Doxygen comments to describe overall indexing behavior
- modified Gregory patch shader to use existing Bezier patch evaluation
- rewrote Bezier patch evaluation to use intermediate bilinear points
- added detection and resolution of degenerate normal
- eval normal partials no longer uses Weingarten eqns (requires N != 0)
- updated normal partials to use differentiation/projection
Updated MtlComputeEvaluator documentation to be
consistent with the documentation for other compute
evaluator implementations and fixed missing or
incorrect doxygen tags.
Also, updated the overloads for the EvalStencils
and EvalPatches methods to account for 1st and
2nd derivative evaluation.
Most GL implementations support a maximum of 4 transform
feedback buffer bindings. With the addition of 1st and 2nd
derivative evaluation up to 6 bindings might be required,
i.e. dst, du, dv, duu, duv, dvv.
This change extends the GLXFB Evaluator interface to allow
a client to specialize the evaluator when it is known that
(at least) the 1st derivative and 2nd derivative outputs
are interleaved together into shared buffers.
When this option is used, the maximum number of transform
feedback buffer bindings can be reduced to 3 instead of 6.
Now that Far::LimitStencilTable and Far::PatchTable
support evaluation of 1st and 2nd derivatives the
Osd Evaluator API for evaluating stencils and patches
has been updated to match.
- added Far::PatchTableFactory::Options::generateLegacySharpCornerPatches
- legacy behavior of sharp patches at smooth corners preserved by default
- added corresponding option bit to Osd::MeshBits
- updated examples/glViewer with option
Noticed a few typos when browsing comments. Proceeded with a "manual
spell check", reading all comments and tweaking spelling, grammar,
punctuation.
Didn't bother with Hbr library.
Comments only, no functional changes.
Extended Far::StencilTableFactory to support the creation
of stencil tables for face-varying channels. We already
use stencil tables to compute local point face-varying values.
These changes allow a stencil table to be created which
refines face-varying primvar data for all refined points.
- extended smooth corner patch approximation to fvar and inf-sharp patches
- fixed assignment and refinement bugs for inf-sharp tags in fvar space
- fixed interpolation bug with Bilinear scheme and LINEAR_NONE option
- added public methods for fvar topology to Far::TopologyRefiner
- updated base level tagging to ignore the boundary interpolation option
- updated regression shape for edge-only to illustrate behavior
- updated regression shapes to favor default viewng direction of examples
The symbol OPENSUBDIV_GREGORY_EVAL_TRUE_DERIVATIVES
determines the method used to compute derivative weights
for Gregory basis patches.
Setting this symbol during CMake configuration (and
hence during C++ and shader compilation) will enable
the use of true derivative weights.
The default behavior is to use a simpler approximation
for consistency with earlier releases.
The methods which return arrays of FVarPatchParam have
been made plural, e.g. GetFVarPatchParams(), for consistency
with the other methods in PatchTable.
Also fixed a missing doxygen tag.
Far::LimitStencilTableFactory computes limit stencils using
patches from a Far::PatchTable, creating one temporarily if
necessary. This change propagates the useInfSharpPatch option
from adaptively refined topologies.
Recent CUDA SDKs no longer support the "compute_11"
gpu architecture. We now fallback to "compute_20"
instead for newer SDK versions. Additionally, this
behavior can be overriden using the new CMake list
variable OSD_CUDA_NVCC_FLAGS so that it is easier
for clients to target newer architectures and specify
additional arguments.
- added new public member to PatchTableFactory::Options
- replaced internal option with new public option
- updated tagging and Gregory conversion for sharp patches
Implemented EvalPatchesVarying and EvalPatchesFaceVarying
methods for Osd::*Evaluator classes, i.e. cpu, omp, tbb,
GLXFB, GLSLCompute, OpenCL, and CUDA.
Also, the GPU Kernel implementations have been updated to use
the common patchBasis implementation instead of re-implementing
methods to compute patch basis weights locally.
This is used to compute patch basis weights for
the Osd::*Evaluator classes that are unable to
use the C++ implementation from far/patchBasis.h,
e.g. the GLSL, HLSL, OpenCL, and CUDA kernels.
Instead of duplicating this code for each different
kernel language, we share a single implementation
which is minimally adapted to accommodate specific
language restrictions and syntax.
This implementation can also be used by client
shader code executed while drawing, e.g. to
compute patch basis weights for evaluating varying
and face-varying patches.
This was an obsolete relic from when PatchDescriptor
was more than a single enum value, but it can cause
problems when sharing patch descriptor values between
devices.
Also, marked the GetNumFVarControlVertices() method as
deprecated.
This reverts most of the recent changes to the
organization of Far::PatchParam. In particular,
the core parameterization is no longer exposed
as a speparate PatchParamBase class.
We'll revisit this again in a later release, but
for now we will stick with a more straight
forward implementation.
This change updates the Far::LimitStencilFactory to
to support options to generate 1st and 2nd derivative
limit stencil weights.
For backward compatibility, the option to generate 1st
derivatives defaults to true. While for efficiency,
the option to generate 2nd derivatives defaults to false.
Also, updated the Far::LimitStencil class to expose
computed 1st and 2nd derivative limit stencil weights.
- added flag to consider features in face-varying channels
- added flag to reduce refinement for infinitely sharp patches
- added secondary isolation level to reduce refinement of smooth features
- updated face-varying VTag conversion to set VTag::_corner correctly
- updated adaptive refinement to prevent over-isolation of inf-sharp features
- fixed patch regularity test when inf-sharp and xord features not separated
at level 0 or 1
- generalized BSpline end-cap factory boundary test to defer to Gregory patch
for any non-smooth corner
- extended FeatureMask class with more extensive set of features
- added FeatureMask methods to convert AdaptiveOptions to features
- updated RefineAdaptive() with simplified FeatureMask creation
- extracted core face selection to simple local functions using FeatureMasks
- created separate face selection for face-varying channels
- extracted inf-sharp feature selection for use by vertex and FVar selection
- changed Level::VSpan start member from edge to face local index
- added additional Level::VSpan members for non-manifold cases
- updated existing usage of Level::VSpan for new members and methods
- moved and updated definition of FVarLevel::ValueSpan for clarity
- removed unused tag for inf-sharp features from Vtr::Level::VTag
- added tags for inf-sharp features to Vtr::FVarLevel::ValueTag
- updated the conversion from ValueTag to VTag
- removed awkward and little used tagging methods from Vtr::FVarLevel
- replaced obsolete methods in face-varying adaptive refinement
- changes mainly involve Far::PatchTableFactory
- treatment of patches more clearly separated into regular and irregular
- patch identification now determines regularity and defers classification
- topology inspection specialized for regular vs irregular patches
- face-verying patches re-use patch information when topology matches
- added Vtr::Level methods to improve access to tags for face-varying values
- improved initial tagging of face-varying values in Vtr::FVarLevel
The patches generated for a face-varying channel can be a
mix of regular patches and patches in an alternate basis
for faces that are irregular in face-varying space.
This mix of patches is packed into a single fvar value array
in the patch table using a consistent stride with the individual
patch type determined by the fvar patch param encoding.
- Added Far::PatchParamBase::IsRegular() to designate which
patches are regular.
- Updated Far::PatchTableFactory to gather mixed basis
patches when using the Gregory basis approximation for
irregular patches.
- Fixed Far::PatchTable::EvaluateBasisFaceVarying() to
use the fvar patch param encoding to determine the type
of face-varying patches.
Updated Far::PatchTableFactory to be able to populate patches
for smooth evaluation of face-varying data channels.
- Moved computePatchTag() method to BuilderContext
- Added computeFVarPatchTag() method to BuilderContext
- Use Vtr::Level::VSpan to represent the partial ring
around vertices for face-varying patches.
- Added the option generateFVarLinearPatches (defaults
to true) to support the legacy behavior of generating
linear patches for face-varying data channels regardless
of the underlying face-varying linear interpolation modes.
These methods now compute the patch basis in terms
of Far::PatchParamBase instead of Far::PatchParam
This allows these methods to be more easily reused
for evaluating patches for face-varying data.
This refactoring of Far::PatchParam maintains source
compatibility with earlier releases while allowing the
core patch parameterization to be reused for patches
from face-varying channels.
This introduces a new internal interface class named
Far::PatchParamInterface which provides an interface to
the core patch parameterization and which is implemented
by both Far::PatchParamBase and Far::PatchParam.
Added significant documentation detail to this new
interface class as well as two new methods
MapRefinedToCoarse() and MapCoarseToRefined()
in favor of the now deprecated Normalize().
The parameterization of irregular faces is offset by one level
of refinement from the parameterization of regular faces. This
matches the parameterization used for Ptex texture mapping onto
irregular faces.
This was expressed awkwardly during the assigment of values to
Far::PatchParam, where we pre-decremented the refinement level
for non-quad patches in order to compensate for the incorrect
pre-increment of the refinement depth value stored for non-quad
patches.
In order to support a consistent API for refinement and
evaluation of varying primvar data, Far::PatchTable needs
to provide indices for varying data. This adds support to
Far::PatchTableFactory for generating these indices.
- removed obsolete and unused code from GregoryBasis and ProtoBasis
- reorganized computation in ProtoBasis to clarify interdependencies
- separated topological inspection from computation
- made a clearer distinction between interior and boundary cases
- improved clarity/consistency of formulae, particularly wrt sin/cos usage
- added comments, including concerns over consistency and efficiency
Added support for gathering face-varying patch points to
the Far::EndCap*PatchFactory classes. Also, changed these classes
to compute varying stencils optionally, since separate varying
stencils are not needed for face-varying patches.
Also, removed a no longer used stateless factory method from
the EndCapGregoryBasisPatchFactory.
Re-organized the implementation of the patch table factory
in advance of adding support for bicubic face-varying patches.
- Renamed the AdaptiveContext internal class to BuilderContext
since this can be used (eventually) to build patch tables for
uniformly refined topology as well as adaptively refined
topology.
- Added utility methods to gather patch vertices from the
levels (and eventually fvarLevels) of a refiner.
- Replaced the FVarChannelCursor with a simpler array of integer
face-varying channel indices.
- Extracted the topology inspection needed to identify
patches into a computePatchTag() method.
- Simplified the two-pass traversal of the topology into a
single pass traversal of the refined topology followed by
an iteration over the patches that have been identified.
- Replaced internal templated PatchTypes class with simpler
and more direct accounting and patch array building facilities.
- Changed the API of the end cap patch factories to no longer
depend on the patch table factory's PatchFaceTag. This has
been superseded by the specification of appropriate
VSpans at the corners of the end patch.
- added new Vtr::Level::VTag members for inf-sharp features
- updated Vtr::Level::print() to recognize new tags
- explicitly initialized tags for new edge-verts in Vtr::Refinement
- initialized tags for base level verts in Far::TopologyRefinerFactory
This change updates Far::PatchTable to include support for
evaluating varying and face-varying data on patches.
This adds to existing API and follows the existing patterns
used for vertex patches.
This includes data and methods to evaluate varying and
face-varying basis functions as well as methods to compute
local point values for varying and face-varying primvar data.
This is the foundation for updating Far::PatchTableFactory
to generate bicubic patches for face-varying channels.
- removed PatchTableFactory assert that irreg patches exist at last level
- fixed Gregory end cap Factory to accomodate irreg patches at any level
- parameterized adaptive refinement for differing feature sets per level
- added definition and gathering method to Vtr::Level
- extended Far::EndCap...PatchFactories with VSpan[4] for patch corners
- extended Far::EndCapGregoryPatchFactory to avoid last level assumption
- adapted Far::PatchTableFactory to use above extensions
- extended Far::GregoryBasis to recognize VSpan corners
- simplified Far::GregoryBasis treatement of boundaries
- fixed bug in Far::GregoryBasis related to smooth corners
An earlier change improved transient memory used during the construction
of end cap stencil tables but could leave unused capacity in the internal
containers of the resulting stencil tables. This change adds an additional
internal factory helper method which trims this storage.
This change make the bspline patch tess control/hull shader revert to
control vertex mirroring for boundary edges when the patch sharpness is
zero. This change helps improve some shader codegen optimization and
L1 cache behavior on (at least) Kepler GPUs with recent drivers.
Re-organized the single-crease patch code path in the tessellation
control/hull shaders to improve performance in the case where no patches
have non-zero crease sharpnesses.
Changed a couple of local 4x4 matrices to global uniforms to
work around a performance problem on recent GL drivers.
There are two local 4x4 float matrices with constant initializers
in the function OsdComputePerPatchVertexBSpline(...). Changing
these from local variables to global initialized uniforms improves
performance dramatically on recent NVIDIA drivers (e.g. 361.48 windows).
There is no such difference with Direct3D, but this change updates
the shader code for both implementations for consistency.
This method now returns the number of _farLevels where previously
it returned the number of _levels. This is primarily a semantic
difference, as the two containers should have equal size. But this
method is intended to accompany Far::TopologyRefiner::GetLevel()
which returns a reference to an element in _farLevels;
My previous fix added some defensive logic in case the
local point stencil table was empty when attempting to
append local point stencils to an existing stencil table.
This change fixes Far::PatchTableFactory to not return
empty local point stencil tables when there are no local
point stencils. This behavior is now more consistent with
earlier releases.
We will leave the earlier defensive logic in place as well.
Now StencilTableFactory::AppendLocalPointStencilTable() does
nothing when the localPointStencilTable is empty. This avoids
a potential crash (failed assertion) when both the baseStencilTable
and the localPointStencilTable are empty, as is the case for
simple geometry like the all-quads torus regression test shape.
For now, the common patch shader code supports fractional spacing
modes only when screen-space tessellation is also enabled.
It's possible to relax this restriction, but that requires changing
the client shader interface.
This change includes support for both fractional_even_spacing
and fractional_odd_spacing.
The implementation follows the existing pattern of re-parameterizing
the tessellation domain only along transition boundary edges. This
allows for crack-free tessellation, but it might be better to
consistently re-parameterize all of the outer edges of all patches,
which also would be required for numerically watertight tessellation.
This is implemented in a way that requires no changes to the client
shader API. It should be more efficient to move some computations to
the control/hull shaders and reduce divergence in the execution of
eval/domain shaders.
- instead of accumulating GregoryBasis::Point (fixed size stencils
backed by stackbuffer), pack the stencils into StencilTable as they
are evaluated
- use single integer for varying stencils of patch points, not
a GregoryBasis::Point
- cap the reserved stencil entry size.
optimize PatchTableFactory::Create performance
The primary hesitation here is that this change alters the approximation for BSpline end caps, however the consensus is that BSpline end caps were already the most extreme approximation, so it makes sense to sacrifice quality for speed.
Reviewed by David, Barry, George and myself.
- replace std::vector with vtr::StackBuffer in GregoryBasis::Point
- remote getQuadOffsets call from ProtoBasis
- rewrite some inefficient code in the endcap generation.
Note that this is a temporary remedy for the performance issue in 3.0.
We'll fix it again in the later release.
This fixes a regression in the function used to identify single crease
patches. This also updates the patch color values used by the glImaging
regression test to match the colors used in other example viewers so
that patch types can be more easily identified during automated testing.
generateAllLevels flags is used when we want to have uniform refined
patch array containing all levels together. There's an index offsetting
bug when this flag is enabled.
- eliminated need for disabling warning 177 in far/patchTableFactory.cpp
- encapsulated all floating point equality tests (1572) in local functions
- bracketed all ICC specific warning pragmas with #ifdef __INTEL_COMPILER
- avoided GCC's stricter shadowing warning in vtr/array.h
This workaround actually caused linking errors related on missing
symbols and removing the workaround does not cause any duplicated
symbols with MSVC 2013.
Te issue here is that some of the functions were not considered templated
anymore because all their template arguments were specified, which made it
so compiler was creating implementation for them in every file from where
the header was included. This causes errors during linking related on the
same symbol implemented in several places.
Marking those functions as inlined solves the problem and should not cause
any bad side effects because they're small enough and likely being inlined
by an optimizer anyway.
- correctly initialize FVar tag and source entry for unconnected verts
- added regression/shape with unconnected vertices and fvar data
- fixed edge-face vector access when unconnected edges are last
In one case, we were comparing int and unsigned int.
In primvarRefiner, some values were safely uninitialized, but older compilers
(GCC 4.1) were complaining.
This change restores the use of 4-bits in Far::PatchParam to
encode the refinement level of a patch. This restores one bit
that was stolen to allow for more general encoding of boundary
edge and transition edge masks. In order to accommodate all
of the bits that are required, the transition edge mask bits
are now stored along with the faceId bits.
Also, accessors are now exposed directly as members of Far::PatchParam
and the internal bitfield class is no longer directly exposed.
If the input cv stencil is given and it includes the local point
stencils for endcaps, LimitStencilTableFactory::Create failed
because of incorrect sanity checking.
Unified transition patch drawing affects the calculation of
tessellation level metrics. Because a single edge of a shader
patch might be split into two halfs along a transition edge,
the effective maximum number of spans along any adaptive edge
is limited to half of the device maximum.
Although valence 2 gregory patch is not well supported yet, this fix
mitigates artifacts around such a vertex.
Adding a shape catmark_gregory_test8 to see this issue.
stb - potential use of uninitialized variable (this may have been safe)
farViewer - unused variable
patchTableFactory - _channelIndices potentially used uninitialized
FVarLevel - valueIndexInFace0 potentially used used uninitialized (was safe)
We'll restore this code and finish it up for the next release.
For now, removing this code restores parity with the 3.0 beta,
i.e. face-varying patches are always all bilinear.
Besides we've not been computing accurate derivatives on gregory patch,
there was a separate bug in shaders which gives completely bogus dUdV on
corner vertices. This change fixes that significant artifact, however,
is still approximating derivatives by ignoring rational components.
- moved TopologyRefiner out of the RefinerFactoryBase into Far
- moved implementation of its Factory<MESH> to far/topologyDescriptor.*
- updated examples and tutorials (no more references to FactoryBase)
There's a lot of good foundational work here to eventually support
smooth interpolation of face-varying patches. Unfortunately, this
is not quite ready to release. Therefore, we've decided to defer this
feature until a later release.
This change hides this code behind the FAR_FVAR_SMOOTH_PATCH macro.
Now the channel specifier is the last parameter in a method's
parameter list with a default of 0. This is consistent with the
topological face-varying queries and also simplifies the common
case of just a single face-varying channel.
