- re-implement the pool allocator
- use templates to remove code redundancy between regular & limit stencils
- leverage [] operator overloading to simplify stencil factorization
- add the ability to treat subdivision levels independently (see below)
- refactor Far::TopologyRefiner::Interpolate<>() methods to pass buffers by reference
(allows overloading of [] operator)
- rename some of the stencil factory options
- propagate changes to Osd / examples / tutorials...
Cause: std::vector.resize() function invalidates Vtr::Level pointers held by FVarLevel
Fix: switch std::vector<Vtr::Level> to std::vector<Vtr::Level *> and cycle through
the vector with appropriate new/delete.
Catmull-Clark Subdivision Surfaces", Niessner et al, Eurographics 2012.
This change includes;
-topology identification for single-crease patch during adaptive refinement.
-patch array population (similar to boundary)
-sharpness buffer generation
-glsl shader
Eval stuffs will be coming.
- added semi-sharp tag to FVar ValueTags and applied in base FVarLevel
- re-assess status of tagged semi-sharp values in each FVarRefinement
- detect and apply fractional weighting in InterpolateFaceVarying()
- "propagate corners" added as new enumeration to Sdc::Options
- topology tags within FVar channel initialized and propagated
- face-varying Interpolate() method updated to deal with creases
- removed old alternative to Catmark feature adaptive selection
- removed unused methods from Vtr::SparseSelector
- made use of Level::VTag's new "incomplete" member in both
- added an option to Far::StencilTablesFactory to generate stencils for
coarse control vertices
- refactored interpolation code out into Far::PatchTables
- corrected tangent interpolation
- code cleanup & comments
- bi-cubic patches should be mostly covered, although portions of the interpolation code
need to be refactored out into Far::PatchTables as vertex templated functions (following
patterns established in the Far::TopologyRefiner)
- end-cap patches still have to be done (prob. going to drop Gregory in favor of bilinear)
- Presto needs a fully bilinear code path (no patches) - really ???
Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a
The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
* added public functions to `FarMeshFactory` that duplicate, rearrange, and split vertices
* added supporting protected functions to `FarCatmarkSubdivisionTablesFactory` and `FarPatchTablesFactory`
* The CATMARK_QUAD_FACE_VERTEX kernel calculates the face-vertex for a quadrilateral face. It applies to every face after the first subdivision step, and may be applied for the first subdivision step of a quadrilateral coarse mesh.
* The CATMARK_TRI_QUAD_FACE_VERTEX kernel calculates the face-vertex for a triangle or quadrilateral face. It may be applied for the first subdivision step of a coarse mesh composed of triangles and/or quadrilaterals.
* Both kernels calculate each face-vertex using four vertex indices (triangles are specified by repeating the third index). Therefore neither kernel uses the F_ITa codex table, and instead the first vertex offset in the F_IT index table is stored in the FarKernelBatch's table offset.
Moved transient states (current vertex buffer etc) to controller.
ComputeContext becomes constant so that it's well suited for coarse-grain
parallelism on cpu. The prims sharing same topology (ComputeContext) can
be refined simultaneously by having mutiple compute controllers.
Client facing API doesn't change.
- fix the vertesIsBSpline logic to correctly recognize these sharp corner vertices
- fix another bug where a loop was missing vertices from from quad faces with 2
non-consecutive boundaries
fixes#294
* rolled getNumFVarVertices into allocateTables
* renamed tessellate to triangulateQuads (technically speaking, Loop scheme uses a trivial triangulation)
* condensed the pointer arithmetic used for triangulating the data tables
Delete scheme specialized subdivision tables. The base class FarSubdivisionTables
already has all tables, so we just need scheme enum to identify which scheme
the subdivision tables belong to.
This brings a lot of code cleanups around far factory classes.
* replace void* of all kernel applications with CONTEXT template parameter.
It eliminates many static_casts from void* for both far and osd classes.
* move the big switch-cases of far default kernel launches out of Refine so
that osd controllers can arbitrary mix default kernels and custom kernels.
* change FarKernelBatch::kernelType from enum to int, clients can add
custom kernel types.
* remove a back-pointer to farmesh from subdivision table.
* untemplate all subdivision table classes and template their compute methods
instead. Those methods take a typed vertex storage.
* remove an unused argument FarMesh from the constructor of subdivision
table factories.
minor code cleanups:
- change Descriptor::iterator to use a static vector instead of overly complicated logic
- change the private factory PatchType struct for better readability
- variable name changes
The new table accomodates verts with valence up to 20.
Dr. DeRose provided me with a python script to generate the tables, but wants to
investigate a closed-form alternative to pre-computed tables.
Also: our logic is incorrect - it is missing adjacent face-points in the
interpolation (apparently this has been incorrect since day 1). Further fixes
coming next year...
fixes#246
The logic that invalidates the vertices in the control stencil and
the cached bspline patch weights was not triggering correctly.
Hopefully this new bit of logic should clear up some of the incorrect results.
fixes#246
Limit tangent stencil crease rule was accumulating the wrong vertices. This
change switches from using an Hbr operator to using a less efficient std::list,
but allows us to rotate around the vertex from an arbitrary starting incident
edge.
The values returned are "plausible", but more extensive testing would be required
to validate this new code.
fixes#246
The tangents were only scaled in the "bail-out" code branch that
pushes vertices to the limit and performs bi-linear interpolation.
Now we are also scaling the bi-cubic patch interpolation code branch.
There may be another code path left to fix (as well as some pointers
being currently unchecked)
fixes#243
The previous fix pointed far indexing tables to the origin vertex
of duped singular verts.
This fix goes one step further and actually shifts all vertex indexing
to start at the end of the coarse mesh vertices, using the space for
data that was previously occupied by duplicated singular verts.
The consequence is that client code no longer needs to duplicate vertex
data in vertex buffers (huzzah !).
- fix FarSubdivisionTablesFactory to shift factory vertex table offsets using Hbr's
singular verts map
- fix schema table factories (Catmark, Loop...) to correctly use these offsets
- remove vertex data duplication code from osdPolySmooth example
- remove some (unrelated) cruft from glViewer example
- shape_utils unfortunately still needs to dubplicate the singular verts to
allow the coarse edge drawing in our example viewers to work correctly
(although it could be fixed to avoid data duplication too...)
fixes#241
- Add a vector of index pairs to HbrMesh to track the index of a split
vertex and its origin vertex
- Correct the Far remap tables in FarSubdivisionTablesFactory to point split
vertices to their origin instead of themselves
- Fix regression/common/shape_utils.h to use the new HbrMesh::GetSplitVertices()
method.
- Fix the osdPolySmooth example to use the new HbrMesh::GetSplitVertices()
method.
- Add a paragraph to the documentation
fixes#241
- implement virtual accessors in FarSubdivision tables that return a Scheme enum
- implement a safe typeid comparison in FarMeshFactory to get the same information
from Hbr subdivision classes
fixes#240
set HBR_ADAPTIVE before including hbr code. Also use an ifndef in
far/meshFactory.h so that code can be included where someone else has
already defined HBR_ADAPTIVE.
New text:
Copyright 2013 Pixar
Licensed under the Apache License, Version 2.0 (the "Apache License")
with the following modification; you may not use this file except in
compliance with the Apache License and the following modification to it:
Section 6. Trademarks. is deleted and replaced with:
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor
and its affiliates, except as required to comply with Section 4(c) of
the License and to reproduce the content of the NOTICE file.
You may obtain a copy of the Apache License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the Apache License with the above modification is
distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the Apache License for the specific
language governing permissions and limitations under the Apache License.
- Adding FarStencilTables and FarStencilTablesFactory classes
- Adding Osd EvalStencil context & controllers for CPU, OMP and TBB backends
- Adding the code example glStencilViewer
- Adding reST documentation
- Changing version to 2.2.0_dev
- Fix HbrMesh::Unrefine function
- Fix "CanEval" function in OsdVertexBufferDescriptor
Note 0: there is no stencil support for hierarchical edits
Note 1: there is no support for face-varying data stencils yet
Note 2: the current stencil factory is lazy but the caching system is not re-entrant
- add macro "_add_doxy_headers" in order to track all header files elligible for
doxygen documenation. This captures public header files that would otherwise be
excluded from installation because they are not supported by the OS. Private
header files remain excluded though.
- add custom targets and commands so that documentation build produces functioning
RST and Doxygen documentation both in the build and install stages
- switched to Doxygen 1.8 (because markdown will make in-lined documentation easier)
- added build switches to disable examples, regression and python-SWIG targets
- fixed doxygen link in the nav bar
- modified python html processing tool to match Cmake changes
Gregory patch shaders rely on a correct estimate of the maximum valence of the vertices in the mesh.
In the current feature adaptive analysis, we stop at level 1, the center vertex of the heptagon is
never traversed, and its high valence is therefore not recorded. The fix is to take advantage of the
first pass and use the number of vertices in the coarse faces to catch those high-sided non-quads that
would generate high valence vertices that may not be revisited in the second pass.
These functions are exclusive to uniformly subdivided topology. With the recent refactoring
of PatchTables and the generalization of topology, uniform meshes only retain the topology
of the highest level of subdivision by default. These functions are now fixed to reflect the
change.
- remove PatchMap from FarPatchTables
- add a new FarPatchMap quad-tree class (constructed from FarPatchTables)
- refactor the EvalLimitController to use the quad-tree search instead of a
serial loop access
fixes#174
- trivial return if Gregory specific patch data is set
- or iterate through the patch-arrays until an adaptive patch is found (REGULAR,...,GREGORY_BOUNDARY)
fixes#173
- minor refactoring of the LimitEvalContext to accomodate all the data buffers
- pushing some minor sub-patch functionality back to FarPatchParams
- extend example code with randomly generated varying vertex colors
create patch tables arrays for when instantiating the FarPatchArrayVector.
default of -1 selects the highest level of subdivision that the factory is able to generate
note : this functionality will eventually have to be exposed to client code from the
FarMeshFactory API
some un-connected face-vertices. FarSubdivisionTablesFactory has been hardened
so as to not trip over these, but apparently Gregory patch valence tables
generation is tripping over one of those in FarPatchTablesFactory.
fixes#162
- FarKernelBatch becomes a class w/ accessors
- split the FarKernelBatchFactory to its own header file
- add doxy doc
- propagate fallout to the rest of the code base
creases and other features and determine the isolation level needed.
Minor improvements:
- we now have a custom "corner" isolation level : with edge-only boundary
interpolation rules, corner vertices are rounded and would require an
isolation level of 10. In practice however, 5 appears to be more than
enough to produce a perfectly rounded shape and is set as a default
for this value.
- the logic has been made a little more efficient by moving the vertex
sharpness tags tests to a separate loop so as not to repeat the check
multiple times for a given vertex
Also added some doxy comments
fixes#161
of this quad to be tagged as boundary. These vertices will cause the
feature adaptive pass to generate sub-faces where appropriate, however
the face itself will not be identified as "non-patch", which causes the
FarPatchTables factory to mis-identify it and fall-back on an assert.
This fix flags these particular quad faces in the first adaptive pass.
The particular shape that caused the crash has also been addded to our
regression suite.
fixes#159
a new function is added to avoid confusion.
-GetNumVertices() returns number of vertices
-GetNumVerticesTotal() returns total number of vertices includins number of lower levels.
#closes 156
be used as intended to specify an installation directory, which can be located anywhere on the
file system.
Also improved the doxygen target and made the doxy build "quiet".
fixes#154
note : this is not using traditional bit-fields as we cannot guarantee that the CPU-side
compiler will match the bit-packing of the compilers used on the GPU-side.
- replace ptex indexing with the FarPtexCoord structure as a way to pass per-patch
ptex data to the shaders.
We are replacing a vector<int> arranged as :
int[0] : ptex face index
int[1] : (u,v) as 16 bits encoding the log2 coordinate of the top left corner
Instead we are now using a struct arranged as :
int[0] : ptex face index
int[1] : is a bit-field containing u,v, rotation, depth and non-quad
The u,v coordinates have been reduced to 10 bits instead of 16, which still
gives us a lot of margin.
- Replace OsdVertexBufferDescriptor with something more adequate for general
primvar representation (this name will probably eventually change...)
- Improve OsdPatchDescriptor
- add a "loop" boolean (true if the patch is of loop type)
- add a GetPatchSize() accessor
- OsdPatchArray :
- remove some redundant elements (still more to do there)
- Fix all shader / examples / regressions & stuff to make this all work.
fixes#143
2 client APIs are changed.
- VertexBuffer::UpdateData() takes start vertex offset
- ComputeController::Refine() takes FarKernelBatchVector
Also, ComputeContext no longer holds farmesh.
Client can free farmesh after OsdComputeContext is created.
(but still need FarKernelBatchVector to apply subdivision kernels)
- add tag parsing for h-hole in shape_utils
- re-create Renderman's test shape from the documentation (catmark_square_hedit.h)
- fix Hbr to correctly pass the hole tag from parent to child face
- fix FarSubdivisionTables to handle disconnected face-vertices without crashing
fixes#75
while retaining a necessary 1-ring on the inside of a hole edge
- add IsInsideHole() function to HbrHalfEdge
- add HasChild() function to HbrVertex and HbrHalfedge
- add a regression shape with adjacent holes and creases (tests dart, crease & boundaries)
Note : this does not address hierarchical edits inside holes or hole tags in hierarchical edits
fixes#78
- make sure HBR passes down the hole tag to children when subdividing faces
- minor API modification : allow to unset the hole flag on a face
- modify uniform / adaptive FarMeshFactory to be aware of the flag
- make the FarSubdivisionTableFactory assert when finding unconnected HBR vertices (as it should)
* Uniform subdivision :
The refinement scheme only creates faces & vertices necessary
to maintain the one-ring around the edges of a hole, so this solution
is quite efficient.
* Adaptive subdivision :
At the moment we are still performing full topological analysis on holes and
only skipping patches associated to holes. This is sub-optimal in 2 ways :
1. the topological analysis can potentially be cranking on a lot of unnecessary
geometry
2. even though we may not be drawing the patches, the compute stage is still
applying kernels on all the control vertices of these patches.
We will have to revisit feature adaptive subdivision & holes, so keep the issue active.
fixes#78
- [Feature Adaptive GPU Rendering of Catmull-Clark Surfaces](http://research.microsoft.com/en-us/um/people/cloop/tog2012.pdf).
- New API architecture : we are planning to lock on to this new framework as the basis for backward compatibility, which we will enforce from Release 1.0 onward. Subsequent releases of OpenSubdiv should not break client code.
- DirectX 11 support
- and much more...
There seems to be a bug in clang: despite the fact that FarMeshFactory is
declared to be a friend class from FarSubdivisionTables, clang protests that
VertexKernelBatch is not accessable.
This hack adds an #ifdef __clang__ block to make that structure public and keep
Far compiling under OSX.
- All data representation classes are now single-templated for a vertex class 'U'
- All constructors / instancing code has been moved into "Factory" functions that are dual-templated
for two vertex classes <class T, class U=T>. This allows hbr specialization with a placeholder
vertex flass 'T' for faster analysis without paying interpolation costs, while far can still specialize
a fully implemented vertex class 'U' with full subdivision functionality.
- Some preliminary clean-up work on FarVertexEditTables with the addition of a FarVertexEdit class
as a replacement for the former HbrVertedEdit which was introducing back dependencies on hbr. The
implementation is very lightweight. Some slight renaming / cleanup of the code, with some more to
be done.
- there are no more dependencies on hbr (not even #include) from far's data structure !
Notes :
- the FarDispatcher mechanism has become somewhat awkward and should be re-evaluated when refactoring osd.
- the "Factory" pattern survives this round of refactoring until we can find something better.
Closes#34
- modify shape_utils to return a vector of coarse vertices when creating an hbr mesh
- minor cleanup of osd mesh and the addition of a vector parameter in the creator to
save the remapping between the hbr mesh progenitor and the current serialized osd mesh.
- minor fallout modifications to the glutViewer & far regression code
Notes :
- the dual template of far is causing a lot of complications
-> suggest finding a way to isolate the T template to the factory code.
-> far needs a concept of a vector of vertex & varying data (to abstract the vertex buffer
away from osd)
-> the dispatched mechanism is awkward and needs refactoring
-> suggest moving the default CPU kernels away from the subdivision tables
-> suggest finding a way to completely untemplate the tables (we might need a templated
factory function though)
-> osd should be able to call delete on the far mesh to get rid of all the CPU-bound data
once the GPU data has been laid-out.
Closes#18.
rules are set to "none" (both in Catmark & Loop)
* Amended shape_utils to always set a default boundary interp. rule
even when no tag was read (ie. don't default to "none")
* Added a regression test for the "dart" shape to test both
"edge only" and "edge corner" boundary interp. rules.
Closes#2.
