AuroraMiddleware/OpenSubdiv
1
0
Fork 0
mirror of https://github.com/PixarAnimationStudios/OpenSubdiv synced 2025-01-06 06:50:07 +00:00
Code Issues Releases Wiki Activity
7f03b864b7
OpenSubdiv/opensubdiv/osd/glslPatchBSpline.glsl
David G Yu f4a8cafe86 Sync'ed up GLSL and HLSL patch shader source. 
Cleaned up the Legacy Gregory shader source by accessing buffer
data through helper functions.

Switched to performing tessellation in untransformed (object) space.
2015-05-21 09:56:25 -07:00

396 lines
11 KiB
GLSL
Raw Blame History

//
// 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.
//
//----------------------------------------------------------
// Patches.TessVertexBSpline
//----------------------------------------------------------
#ifdef OSD_PATCH_VERTEX_BSPLINE_SHADER
layout(location = 0) in vec4 position;
OSD_USER_VARYING_ATTRIBUTE_DECLARE
out block {
ControlVertex v;
OSD_USER_VARYING_DECLARE
} outpt;
void main()
{
outpt.v.position = position;
OSD_PATCH_CULL_COMPUTE_CLIPFLAGS(position);
OSD_USER_VARYING_PER_VERTEX();
}
#endif
//----------------------------------------------------------
// Patches.TessControlBSpline
//----------------------------------------------------------
#ifdef OSD_PATCH_TESS_CONTROL_BSPLINE_SHADER
// Regular
uniform mat4 Q = mat4(
1.f/6.f, 4.f/6.f, 1.f/6.f, 0.f,
0.f, 4.f/6.f, 2.f/6.f, 0.f,
0.f, 2.f/6.f, 4.f/6.f, 0.f,
0.f, 1.f/6.f, 4.f/6.f, 1.f/6.f
);
// Infinite sharp
uniform mat4 Mi = mat4(
1.f/6.f, 4.f/6.f, 1.f/6.f, 0.f,
0.f, 4.f/6.f, 2.f/6.f, 0.f,
0.f, 2.f/6.f, 4.f/6.f, 0.f,
0.f, 0.f, 1.f, 0.f
);
layout(vertices = 16) out;
in block {
ControlVertex v;
OSD_USER_VARYING_DECLARE
} inpt[];
out block {
ControlVertex v;
#if defined OSD_PATCH_ENABLE_SINGLE_CREASE
vec4 P1;
vec4 P2;
float sharpness;
#endif
OSD_USER_VARYING_DECLARE
} outpt[];
patch out vec4 tessOuterLo, tessOuterHi;
#define ID gl_InvocationID
// compute single-crease patch matrix
mat4
ComputeMatrixSimplified(float sharpness)
{
float s = pow(2.0f, sharpness);
float s2 = s*s;
float s3 = s2*s;
mat4 m = mat4(
0, s + 1 + 3*s2 - s3, 7*s - 2 - 6*s2 + 2*s3, (1-s)*(s-1)*(s-1),
0, (1+s)*(1+s), 6*s - 2 - 2*s2, (s-1)*(s-1),
0, 1+s, 6*s - 2, 1-s,
0, 1, 6*s - 2, 1);
m /= (s*6.0);
m[0][0] = 1.0/6.0;
return m;
}
void main()
{
int i = ID%4;
int j = ID/4;
vec3 position[16];
for (int i=0; i<16; ++i) {
position[i] = inpt[i].v.position.xyz;
}
ivec3 patchParam = OsdGetPatchParam(OsdGetPatchIndex(gl_PrimitiveID));
OsdComputeBSplineBoundaryPoints(position, patchParam);
vec3 H[4];
for (int l=0; l<4; ++l) {
H[l] = vec3(0,0,0);
for (int k=0; k<4; ++k) {
H[l] += Q[i][k] * position[l*4 + k].xyz;
}
}
#if defined OSD_PATCH_ENABLE_SINGLE_CREASE
float sharpness = OsdGetPatchSharpness(patchParam);
if (sharpness > 0) {
float Sf = floor(sharpness);
float Sc = ceil(sharpness);
float Sr = fract(sharpness);
mat4 Mf = ComputeMatrixSimplified(Sf);
mat4 Mc = ComputeMatrixSimplified(Sc);
mat4 Mj = (1-Sr) * Mf + Sr * Mi;
mat4 Ms = (1-Sr) * Mf + Sr * Mc;
vec3 P = vec3(0);
vec3 P1 = vec3(0);
vec3 P2 = vec3(0);
for (int k=0; k<4; ++k) {
P += Mi[j][k]*H[k]; // 0 to 1-2^(-Sf)
P1 += Mj[j][k]*H[k]; // 1-2^(-Sf) to 1-2^(-Sc)
P2 += Ms[j][k]*H[k]; // 1-2^(-Sc) to 1
}
outpt[ID].v.position = vec4(P, 1.0);
outpt[ID].P1 = vec4(P1, 1.0);
outpt[ID].P2 = vec4(P2, 1.0);
outpt[ID].sharpness = sharpness;
} else {
vec3 pos = vec3(0,0,0);
for (int k=0; k<4; ++k) {
pos += Q[j][k]*H[k];
}
outpt[ID].v.position = vec4(pos, 1.0);
outpt[ID].P1 = vec4(0);
outpt[ID].P2 = vec4(0);
outpt[ID].sharpness = 0;
}
#else
{
vec3 pos = vec3(0,0,0);
for (int k=0; k<4; ++k) {
pos += Q[j][k]*H[k];
}
outpt[ID].v.position = vec4(pos, 1.0);
}
#endif
OSD_USER_VARYING_PER_CONTROL_POINT(ID, ID);
outpt[ID].v.patchCoord = OsdGetPatchCoord(patchParam);
#if defined OSD_ENABLE_SCREENSPACE_TESSELLATION
// Wait for all basis conversion to be finished
barrier();
#endif
if (ID == 0) {
OSD_PATCH_CULL(16);
#if defined OSD_ENABLE_SCREENSPACE_TESSELLATION
// Gather bezier control points to compute limit surface tess levels
for (int i=0; i<16; ++i) {
position[i] = outpt[i].v.position.xyz;
}
#endif
vec4 tessLevelOuter = vec4(0);
vec2 tessLevelInner = vec2(0);
OsdGetTessLevels(position, patchParam,
tessLevelOuter, tessLevelInner,
tessOuterLo, tessOuterHi);
gl_TessLevelOuter[0] = tessLevelOuter[0];
gl_TessLevelOuter[1] = tessLevelOuter[1];
gl_TessLevelOuter[2] = tessLevelOuter[2];
gl_TessLevelOuter[3] = tessLevelOuter[3];
gl_TessLevelInner[0] = tessLevelInner[0];
gl_TessLevelInner[1] = tessLevelInner[1];
}
}
#endif
//----------------------------------------------------------
// Patches.TessEvalBSpline
//----------------------------------------------------------
#ifdef OSD_PATCH_TESS_EVAL_BSPLINE_SHADER
layout(quads) in;
#if defined OSD_FRACTIONAL_ODD_SPACING
layout(fractional_odd_spacing) in;
#elif defined OSD_FRACTIONAL_EVEN_SPACING
layout(fractional_even_spacing) in;
#endif
in block {
ControlVertex v;
#if defined OSD_PATCH_ENABLE_SINGLE_CREASE
vec4 P1;
vec4 P2;
float sharpness;
#endif
OSD_USER_VARYING_DECLARE
} inpt[];
out block {
OutputVertex v;
#if defined OSD_PATCH_ENABLE_SINGLE_CREASE
float sharpness;
#endif
OSD_USER_VARYING_DECLARE
} outpt;
patch in vec4 tessOuterLo, tessOuterHi;
void main()
{
vec2 UV = OsdGetTessParameterization(gl_TessCoord.xy,
tessOuterLo,
tessOuterHi);
#ifdef OSD_COMPUTE_NORMAL_DERIVATIVES
float B[4], D[4], C[4];
vec3 BUCP[4] = vec3[4](vec3(0,0,0), vec3(0,0,0), vec3(0,0,0), vec3(0,0,0)),
DUCP[4] = vec3[4](vec3(0,0,0), vec3(0,0,0), vec3(0,0,0), vec3(0,0,0)),
CUCP[4] = vec3[4](vec3(0,0,0), vec3(0,0,0), vec3(0,0,0), vec3(0,0,0));
Univar4x4(UV.x, B, D, C);
#else
float B[4], D[4];
vec3 BUCP[4] = vec3[4](vec3(0,0,0), vec3(0,0,0), vec3(0,0,0), vec3(0,0,0)),
DUCP[4] = vec3[4](vec3(0,0,0), vec3(0,0,0), vec3(0,0,0), vec3(0,0,0));
Univar4x4(UV.x, B, D);
#endif
// ----------------------------------------------------------------
#if defined OSD_PATCH_ENABLE_SINGLE_CREASE
// sharpness
float sharpness = inpt[0].sharpness;
if (sharpness != 0) {
float s0 = 1.0 - pow(2.0f, -floor(sharpness));
float s1 = 1.0 - pow(2.0f, -ceil(sharpness));
for (int i=0; i<4; ++i) {
for (int j=0; j<4; ++j) {
int k = 4*i + j;
float s = UV.y;
vec3 A = (s < s0) ?
inpt[k].v.position.xyz :
((s < s1) ?
inpt[k].P1.xyz :
inpt[k].P2.xyz);
BUCP[i] += A * B[j];
DUCP[i] += A * D[j];
#ifdef OSD_COMPUTE_NORMAL_DERIVATIVES
CUCP[i] += A * C[j];
#endif
}
}
outpt.sharpness = sharpness;
} else {
for (int i=0; i<4; ++i) {
for (int j=0; j<4; ++j) {
vec3 A = inpt[4*i + j].v.position.xyz;
BUCP[i] += A * B[j];
DUCP[i] += A * D[j];
#ifdef OSD_COMPUTE_NORMAL_DERIVATIVES
CUCP[i] += A * C[j];
#endif
}
}
outpt.sharpness = 0;
}
#else
// ----------------------------------------------------------------
for (int i=0; i<4; ++i) {
for (int j=0; j<4; ++j) {
vec3 A = inpt[4*i + j].v.position.xyz;
BUCP[i] += A * B[j];
DUCP[i] += A * D[j];
#ifdef OSD_COMPUTE_NORMAL_DERIVATIVES
CUCP[i] += A * C[j];
#endif
}
}
#endif
// ----------------------------------------------------------------
vec3 position = vec3(0);
vec3 uTangent = vec3(0);
vec3 vTangent = vec3(0);
#ifdef OSD_COMPUTE_NORMAL_DERIVATIVES
// used for weingarten term
Univar4x4(UV.y, B, D, C);
vec3 dUU = vec3(0);
vec3 dVV = vec3(0);
vec3 dUV = vec3(0);
for (int k=0; k<4; ++k) {
position += B[k] * BUCP[k];
uTangent += B[k] * DUCP[k];
vTangent += D[k] * BUCP[k];
dUU += B[k] * CUCP[k];
dVV += C[k] * BUCP[k];
dUV += D[k] * DUCP[k];
}
int level = inpt[0].v.patchCoord.z;
uTangent *= 3 * level;
vTangent *= 3 * level;
dUU *= 6 * level;
dVV *= 6 * level;
dUV *= 9 * level;
vec3 n = cross(uTangent, vTangent);
vec3 normal = normalize(n);
float E = dot(uTangent, uTangent);
float F = dot(uTangent, vTangent);
float G = dot(vTangent, vTangent);
float e = dot(normal, dUU);
float f = dot(normal, dUV);
float g = dot(normal, dVV);
vec3 Nu = (f*F-e*G)/(E*G-F*F) * uTangent + (e*F-f*E)/(E*G-F*F) * vTangent;
vec3 Nv = (g*F-f*G)/(E*G-F*F) * uTangent + (f*F-g*E)/(E*G-F*F) * vTangent;
Nu = Nu/length(n) - n * (dot(Nu,n)/pow(dot(n,n), 1.5));
Nv = Nv/length(n) - n * (dot(Nv,n)/pow(dot(n,n), 1.5));
outpt.v.Nu = Nu;
outpt.v.Nv = Nv;
#else
Univar4x4(UV.y, B, D);
for (int k=0; k<4; ++k) {
position += B[k] * BUCP[k];
uTangent += B[k] * DUCP[k];
vTangent += D[k] * BUCP[k];
}
int level = inpt[0].v.patchCoord.z;
uTangent *= 3 * level;
vTangent *= 3 * level;
vec3 normal = normalize(cross(uTangent, vTangent));
#endif
outpt.v.position = OsdModelViewMatrix() * vec4(position, 1.0f);
outpt.v.normal = (OsdModelViewMatrix() * vec4(normal, 0.0f)).xyz;
outpt.v.tangent = (OsdModelViewMatrix() * vec4(uTangent, 0.0f)).xyz;
outpt.v.bitangent = (OsdModelViewMatrix() * vec4(vTangent, 0.0f)).xyz;
OSD_USER_VARYING_PER_EVAL_POINT(UV, 5, 6, 9, 10);
outpt.v.tessCoord = UV;
outpt.v.patchCoord = OsdInterpolatePatchCoord(UV, inpt[0].v.patchCoord);
OSD_DISPLACEMENT_CALLBACK;
gl_Position = OsdProjectionMatrix() * outpt.v.position;
}
#endif
Reference in New Issue View Git Blame Copy Permalink