crease.h

Go to the documentation of this file.

//
//   Copyright 2014 DreamWorks Animation LLC.
//
//   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.
//
#ifndef OPENSUBDIV3_SDC_CREASE_H
#define OPENSUBDIV3_SDC_CREASE_H
 
#include "../version.h"
 
#include "../sdc/options.h"
 
namespace OpenSubdiv {
namespace OPENSUBDIV_VERSION {
 
namespace Sdc {

 
class Crease {
public:

    static float const SHARPNESS_SMOOTH;    // =  0.0f, do we really need this?
    static float const SHARPNESS_INFINITE;  // = 10.0f;
 
    static bool IsSmooth(float sharpness)    { return sharpness <= SHARPNESS_SMOOTH; }
    static bool IsSharp(float sharpness)     { return sharpness > SHARPNESS_SMOOTH; }
    static bool IsInfinite(float sharpness)  { return sharpness >= SHARPNESS_INFINITE; }
    static bool IsSemiSharp(float sharpness) { return (SHARPNESS_SMOOTH < sharpness) && (sharpness < SHARPNESS_INFINITE); }

    enum Rule {
        RULE_UNKNOWN = 0,
        RULE_SMOOTH  = (1 << 0),
        RULE_DART    = (1 << 1),
        RULE_CREASE  = (1 << 2),
        RULE_CORNER  = (1 << 3)
    };
 
public:
    Crease() : _options() { }
    Crease(Options const& options) : _options(options) { }
    ~Crease() { }
 
    bool IsUniform() const { return _options.GetCreasingMethod() == Options::CREASE_UNIFORM; }


    float SharpenBoundaryEdge(float edgeSharpness) const;
    float SharpenBoundaryVertex(float edgeSharpness) const;
 
    //  For future consideration
    //float SharpenNonManifoldEdge(float edgeSharpness) const;
    //float SharpenNonManifoldVertex(float edgeSharpness) const;


    float SubdivideUniformSharpness(float vertexOrEdgeSharpness) const;
 
    float SubdivideVertexSharpness(float vertexSharpness) const;
 
    float SubdivideEdgeSharpnessAtVertex(float        edgeSharpness,
                                         int          incidentEdgeCountAtEndVertex,
                                         float const* edgeSharpnessAroundEndVertex) const;
 
    void SubdivideEdgeSharpnessesAroundVertex(int          incidentEdgeCountAtVertex,
                                              float const* incidentEdgeSharpnessAroundVertex,
                                              float*       childEdgesSharpnessAroundVertex) const;


    Rule DetermineVertexVertexRule(float        vertexSharpness,
                                   int          incidentEdgeCount,
                                   float const* incidentEdgeSharpness) const;
    Rule DetermineVertexVertexRule(float        vertexSharpness,
                                   int          sharpEdgeCount) const;

    float ComputeFractionalWeightAtVertex(float        vertexSharpness,
                                          float        childVertexSharpness,
                                          int          incidentEdgeCount,
                                          float const* incidentEdgeSharpness,
                                          float const* childEdgesSharpness) const;
 
    void GetSharpEdgePairOfCrease(float const * incidentEdgeSharpness,
                                  int           incidentEdgeCount,
                                  int           sharpEdgePair[2]) const;
 
    //  Would these really help?  Maybe only need Rules for the vertex-vertex case...
    //
    //  Rule DetermineEdgeVertexRule(float parentEdgeSharpness) const;
    //  Rule DetermineEdgeVertexRule(float childEdge1Sharpness, float childEdge2Sharpness) const;
 
protected:
    float decrementSharpness(float sharpness) const;
 
private:
    Options _options;
};
 
 
//
//  Inline declarations:
//
inline float
Crease::SharpenBoundaryEdge(float /* edgeSharpness */) const {
 
    //
    //  Despite the presence of the BOUNDARY_NONE option, boundary edges are always sharpened.
    //  Much of the code relies on sharpness to indicate boundaries to avoid the more complex
    //  topological inspection
    //
    return SHARPNESS_INFINITE;
}
 
inline float
Crease::SharpenBoundaryVertex(float vertexSharpness) const {
 
    return (_options.GetVtxBoundaryInterpolation() == Options::VTX_BOUNDARY_EDGE_AND_CORNER) ?
            SHARPNESS_INFINITE : vertexSharpness;
}
 
inline float
Crease::decrementSharpness(float sharpness) const {
 
    if (IsSmooth(sharpness)) return Crease::SHARPNESS_SMOOTH;  // redundant but most common
    if (IsInfinite(sharpness)) return Crease::SHARPNESS_INFINITE;
    if (sharpness > 1.0f) return (sharpness - 1.0f);
    return Crease::SHARPNESS_SMOOTH;
}
 
inline float
Crease::SubdivideUniformSharpness(float vertexOrEdgeSharpness) const {
 
    return decrementSharpness(vertexOrEdgeSharpness);
}
 
inline float
Crease::SubdivideVertexSharpness(float vertexSharpness) const {
 
    return decrementSharpness(vertexSharpness);
}
 
inline void
Crease::GetSharpEdgePairOfCrease(float const * incidentEdgeSharpness, int incidentEdgeCount,
                                 int sharpEdgePair[2]) const {
 
    //  Only to be called when a crease is present at a vertex -- exactly two sharp
    //  edges are expected here:
    //
    sharpEdgePair[0] = 0;
    while (IsSmooth(incidentEdgeSharpness[sharpEdgePair[0]])) ++ sharpEdgePair[0];
 
    sharpEdgePair[1] = incidentEdgeCount - 1;
    while (IsSmooth(incidentEdgeSharpness[sharpEdgePair[1]])) -- sharpEdgePair[1];
}
 
} // end namespace sdc
 
} // end namespace OPENSUBDIV_VERSION
using namespace OPENSUBDIV_VERSION;
} // end namespace OpenSubdiv
 
#endif /* OPENSUBDIV3_SDC_CREASE_H */