mirror of
https://github.com/PixarAnimationStudios/OpenSubdiv
synced 2024-11-14 16:01:08 +00:00
ff34c514f5
This updates the patch basis evaluation functions in Osd
to match recent changes to far/patchBasis.
This also exposes a common facility for dealing with PatchCoord,
PatchArray, and PatchParam. These are exposed as global functions
operating on struct data, since C++ style class methods are not
supported by all of the Osd shader and kernel execution envirionments.
Changes:
- Merged far/patchBasis.cpp to osd/patchBasisCommon{,Types,Eval}.h
- Exposed PatchCoord, PatchArray, and PatchParam to Osd kernels
- exposed OsdEvaluatePatchBasis and OsdEvaluatePatchBasisNormalized
- Updated CPU, TBB, Omp, CUDA, OpenCL, GLSL, HLSL, and Metal evaluators
- Updated glFVarViewer
197 lines
7.0 KiB
C
197 lines
7.0 KiB
C
//
|
|
// Copyright 2018 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.
|
|
//
|
|
|
|
#ifndef OPENSUBDIV3_OSD_PATCH_BASIS_COMMON_EVAL_H
|
|
#define OPENSUBDIV3_OSD_PATCH_BASIS_COMMON_EVAL_H
|
|
|
|
OSD_FUNCTION_STORAGE_CLASS
|
|
// template <typename REAL>
|
|
int
|
|
OsdEvaluatePatchBasisNormalized(
|
|
int patchType, OsdPatchParam param,
|
|
OSD_REAL s, OSD_REAL t,
|
|
OSD_OUT_ARRAY(OSD_REAL, wP, 20),
|
|
OSD_OUT_ARRAY(OSD_REAL, wDs, 20),
|
|
OSD_OUT_ARRAY(OSD_REAL, wDt, 20),
|
|
OSD_OUT_ARRAY(OSD_REAL, wDss, 20),
|
|
OSD_OUT_ARRAY(OSD_REAL, wDst, 20),
|
|
OSD_OUT_ARRAY(OSD_REAL, wDtt, 20)) {
|
|
|
|
int boundaryMask = OsdPatchParamGetBoundary(param);
|
|
|
|
int nPoints = 0;
|
|
if (patchType == OSD_PATCH_DESCRIPTOR_REGULAR) {
|
|
#if OSD_ARRAY_ARG_BOUND_OPTIONAL
|
|
nPoints = Osd_EvalBasisBSpline(s, t, wP, wDs, wDt, wDss, wDst, wDtt);
|
|
if (boundaryMask != 0) {
|
|
Osd_boundBasisBSpline(
|
|
boundaryMask, wP, wDs, wDt, wDss, wDst, wDtt);
|
|
}
|
|
#else
|
|
OSD_REAL wP16[16], wDs16[16], wDt16[16],
|
|
wDss16[16], wDst16[16], wDtt16[16];
|
|
nPoints = Osd_EvalBasisBSpline(
|
|
s, t, wP16, wDs16, wDt16, wDss16, wDst16, wDtt16);
|
|
if (boundaryMask != 0) {
|
|
Osd_boundBasisBSpline(
|
|
boundaryMask, wP16, wDs16, wDt16, wDss16, wDst16, wDtt16);
|
|
}
|
|
for (int i=0; i<nPoints; ++i) {
|
|
wP[i] = wP16[i];
|
|
wDs[i] = wDs16[i]; wDt[i] = wDt16[i];
|
|
wDss[i] = wDss16[i]; wDst[i] = wDst16[i]; wDtt[i] = wDtt16[i];
|
|
}
|
|
#endif
|
|
} else if (patchType == OSD_PATCH_DESCRIPTOR_LOOP) {
|
|
#if OSD_ARRAY_ARG_BOUND_OPTIONAL
|
|
nPoints = Osd_EvalBasisBoxSplineTri(
|
|
s, t, wP, wDs, wDt, wDss, wDst, wDtt);
|
|
if (boundaryMask != 0) {
|
|
Osd_boundBasisBoxSplineTri(
|
|
boundaryMask, wP, wDs, wDt, wDss, wDst, wDtt);
|
|
}
|
|
#else
|
|
OSD_REAL wP12[12], wDs12[12], wDt12[12],
|
|
wDss12[12], wDst12[12], wDtt12[12];
|
|
nPoints = Osd_EvalBasisBoxSplineTri(
|
|
s, t, wP12, wDs12, wDt12, wDss12, wDst12, wDtt12);
|
|
if (boundaryMask != 0) {
|
|
Osd_boundBasisBoxSplineTri(
|
|
boundaryMask, wP12, wDs12, wDt12, wDss12, wDst12, wDtt12);
|
|
}
|
|
for (int i=0; i<nPoints; ++i) {
|
|
wP[i] = wP12[i];
|
|
wDs[i] = wDs12[i]; wDt[i] = wDt12[i];
|
|
wDss[i] = wDss12[i]; wDst[i] = wDst12[i]; wDtt[i] = wDtt12[i];
|
|
}
|
|
#endif
|
|
} else if (patchType == OSD_PATCH_DESCRIPTOR_GREGORY_BASIS) {
|
|
nPoints = Osd_EvalBasisGregory(s, t, wP, wDs, wDt, wDss, wDst, wDtt);
|
|
} else if (patchType == OSD_PATCH_DESCRIPTOR_GREGORY_TRIANGLE) {
|
|
#if OSD_ARRAY_ARG_BOUND_OPTIONAL
|
|
nPoints = Osd_EvalBasisGregoryTri(s, t, wP, wDs, wDt, wDss, wDst, wDtt);
|
|
#else
|
|
OSD_REAL wP15[15], wDs15[15], wDt15[15],
|
|
wDss15[15], wDst15[15], wDtt15[15];
|
|
nPoints = Osd_EvalBasisGregoryTri(
|
|
s, t, wP15, wDs15, wDt15, wDss15, wDst15, wDtt15);
|
|
for (int i=0; i<nPoints; ++i) {
|
|
wP[i] = wP15[i];
|
|
wDs[i] = wDs15[i]; wDt[i] = wDt15[i];
|
|
wDss[i] = wDss15[i]; wDst[i] = wDst15[i]; wDtt[i] = wDtt15[i];
|
|
}
|
|
#endif
|
|
} else if (patchType == OSD_PATCH_DESCRIPTOR_QUADS) {
|
|
#if OSD_ARRAY_ARG_BOUND_OPTIONAL
|
|
nPoints = Osd_EvalBasisLinear(s, t, wP, wDs, wDt, wDss, wDst, wDtt);
|
|
#else
|
|
OSD_REAL wP4[4], wDs4[4], wDt4[4],
|
|
wDss4[4], wDst4[4], wDtt4[4];
|
|
nPoints = Osd_EvalBasisLinear(
|
|
s, t, wP4, wDs4, wDt4, wDss4, wDst4, wDtt4);
|
|
for (int i=0; i<nPoints; ++i) {
|
|
wP[i] = wP4[i];
|
|
wDs[i] = wDs4[i]; wDt[i] = wDt4[i];
|
|
wDss[i] = wDss4[i]; wDst[i] = wDst4[i]; wDtt[i] = wDtt4[i];
|
|
}
|
|
#endif
|
|
} else if (patchType == OSD_PATCH_DESCRIPTOR_TRIANGLES) {
|
|
#if OSD_ARRAY_ARG_BOUND_OPTIONAL
|
|
nPoints = Osd_EvalBasisLinearTri(s, t, wP, wDs, wDt, wDss, wDst, wDtt);
|
|
#else
|
|
OSD_REAL wP3[3], wDs3[3], wDt3[3],
|
|
wDss3[3], wDst3[3], wDtt3[3];
|
|
nPoints = Osd_EvalBasisLinearTri(
|
|
s, t, wP3, wDs3, wDt3, wDss3, wDst3, wDtt3);
|
|
for (int i=0; i<nPoints; ++i) {
|
|
wP[i] = wP3[i];
|
|
wDs[i] = wDs3[i]; wDt[i] = wDt3[i];
|
|
wDss[i] = wDss3[i]; wDst[i] = wDst3[i]; wDtt[i] = wDtt3[i];
|
|
}
|
|
#endif
|
|
} else {
|
|
// assert(0);
|
|
}
|
|
return nPoints;
|
|
}
|
|
|
|
OSD_FUNCTION_STORAGE_CLASS
|
|
// template <typename REAL>
|
|
int
|
|
OsdEvaluatePatchBasis(
|
|
int patchType, OsdPatchParam param,
|
|
OSD_REAL s, OSD_REAL t,
|
|
OSD_OUT_ARRAY(OSD_REAL, wP, 20),
|
|
OSD_OUT_ARRAY(OSD_REAL, wDs, 20),
|
|
OSD_OUT_ARRAY(OSD_REAL, wDt, 20),
|
|
OSD_OUT_ARRAY(OSD_REAL, wDss, 20),
|
|
OSD_OUT_ARRAY(OSD_REAL, wDst, 20),
|
|
OSD_OUT_ARRAY(OSD_REAL, wDtt, 20)) {
|
|
|
|
OSD_REAL derivSign = 1.0f;
|
|
|
|
if ((patchType == OSD_PATCH_DESCRIPTOR_LOOP) ||
|
|
(patchType == OSD_PATCH_DESCRIPTOR_GREGORY_TRIANGLE) ||
|
|
(patchType == OSD_PATCH_DESCRIPTOR_TRIANGLES)) {
|
|
OSD_REAL uv[2] = OSD_ARRAY_2(OSD_REAL, s, t);
|
|
OsdPatchParamNormalizeTriangle(param, uv);
|
|
s = uv[0];
|
|
t = uv[1];
|
|
if (OsdPatchParamIsTriangleRotated(param)) {
|
|
derivSign = -1.0f;
|
|
}
|
|
} else {
|
|
OSD_REAL uv[2] = OSD_ARRAY_2(OSD_REAL, s, t);
|
|
OsdPatchParamNormalize(param, uv);
|
|
s = uv[0];
|
|
t = uv[1];
|
|
}
|
|
|
|
int nPoints = OsdEvaluatePatchBasisNormalized(
|
|
patchType, param, s, t, wP, wDs, wDt, wDss, wDst, wDtt);
|
|
|
|
if (OSD_OPTIONAL(wDs && wDt)) {
|
|
OSD_REAL d1Scale =
|
|
derivSign * OSD_REAL_CAST(1 << OsdPatchParamGetDepth(param));
|
|
|
|
for (int i = 0; i < nPoints; ++i) {
|
|
wDs[i] *= d1Scale;
|
|
wDt[i] *= d1Scale;
|
|
}
|
|
|
|
if (OSD_OPTIONAL(wDss && wDst && wDtt)) {
|
|
OSD_REAL d2Scale = derivSign * d1Scale * d1Scale;
|
|
|
|
for (int i = 0; i < nPoints; ++i) {
|
|
wDss[i] *= d2Scale;
|
|
wDst[i] *= d2Scale;
|
|
wDtt[i] *= d2Scale;
|
|
}
|
|
}
|
|
}
|
|
return nPoints;
|
|
}
|
|
|
|
#endif /* OPENSUBDIV3_OSD_PATCH_BASIS_COMMON_EVAL_H */
|