mirror of
https://github.com/HifiExperiments/overte.git
synced 2025-06-23 10:39:35 +02:00
265 lines
9.9 KiB
Text
265 lines
9.9 KiB
Text
<!
|
|
// Skinning.slh
|
|
// libraries/render-utils/src
|
|
//
|
|
// Created by Sam Gateau on 10/5/15.
|
|
// Copyright 2013 High Fidelity, Inc.
|
|
//
|
|
// Distributed under the Apache License, Version 2.0.
|
|
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
|
!>
|
|
<@if not SKINNING_SLH@>
|
|
<@def SKINNING_SLH@>
|
|
|
|
const int MAX_CLUSTERS = 128;
|
|
const int INDICES_PER_VERTEX = 4;
|
|
|
|
<@func declareUseDualQuaternionSkinning(USE_DUAL_QUATERNION_SKINNING)@>
|
|
|
|
layout(std140) uniform skinClusterBuffer {
|
|
mat4 clusterMatrices[MAX_CLUSTERS];
|
|
};
|
|
|
|
<@if USE_DUAL_QUATERNION_SKINNING@>
|
|
|
|
mat4 dualQuatToMat4(vec4 real, vec4 dual) {
|
|
float twoRealXSq = 2.0 * real.x * real.x;
|
|
float twoRealYSq = 2.0 * real.y * real.y;
|
|
float twoRealZSq = 2.0 * real.z * real.z;
|
|
float twoRealXY = 2.0 * real.x * real.y;
|
|
float twoRealXZ = 2.0 * real.x * real.z;
|
|
float twoRealXW = 2.0 * real.x * real.w;
|
|
float twoRealZW = 2.0 * real.z * real.w;
|
|
float twoRealYZ = 2.0 * real.y * real.z;
|
|
float twoRealYW = 2.0 * real.y * real.w;
|
|
vec4 col0 = vec4(1.0 - twoRealYSq - twoRealZSq,
|
|
twoRealXY + twoRealZW,
|
|
twoRealXZ - twoRealYW,
|
|
0.0);
|
|
vec4 col1 = vec4(twoRealXY - twoRealZW,
|
|
1.0 - twoRealXSq - twoRealZSq,
|
|
twoRealYZ + twoRealXW,
|
|
0.0);
|
|
vec4 col2 = vec4(twoRealXZ + twoRealYW,
|
|
twoRealYZ - twoRealXW,
|
|
1.0 - twoRealXSq - twoRealYSq,
|
|
0.0);
|
|
vec4 col3 = vec4(2.0 * (-dual.w * real.x + dual.x * real.w - dual.y * real.z + dual.z * real.y),
|
|
2.0 * (-dual.w * real.y + dual.x * real.z + dual.y * real.w - dual.z * real.x),
|
|
2.0 * (-dual.w * real.z - dual.x * real.y + dual.y * real.x + dual.z * real.w),
|
|
1.0);
|
|
|
|
return mat4(col0, col1, col2, col3);
|
|
}
|
|
|
|
// dual quaternion linear blending
|
|
void skinPosition(ivec4 skinClusterIndex, vec4 skinClusterWeight, vec4 inPosition, out vec4 skinnedPosition) {
|
|
|
|
// linearly blend scale and dual quaternion components
|
|
vec4 sAccum = vec4(0.0, 0.0, 0.0, 0.0);
|
|
vec4 rAccum = vec4(0.0, 0.0, 0.0, 0.0);
|
|
vec4 dAccum = vec4(0.0, 0.0, 0.0, 0.0);
|
|
vec4 cAccum = vec4(0.0, 0.0, 0.0, 0.0);
|
|
vec4 polarityReference = clusterMatrices[skinClusterIndex[0]][1];
|
|
for (int i = 0; i < INDICES_PER_VERTEX; i++) {
|
|
mat4 clusterMatrix = clusterMatrices[(skinClusterIndex[i])];
|
|
float clusterWeight = skinClusterWeight[i];
|
|
|
|
vec4 scale = clusterMatrix[0];
|
|
vec4 real = clusterMatrix[1];
|
|
vec4 dual = clusterMatrix[2];
|
|
vec4 cauterizedPos = clusterMatrix[3];
|
|
|
|
// to ensure that we rotate along the shortest arc, reverse dual quaternions with negative polarity.
|
|
float dqClusterWeight = clusterWeight;
|
|
if (dot(real, polarityReference) < 0.0) {
|
|
dqClusterWeight = -clusterWeight;
|
|
}
|
|
|
|
sAccum += scale * clusterWeight;
|
|
rAccum += real * dqClusterWeight;
|
|
dAccum += dual * dqClusterWeight;
|
|
cAccum += cauterizedPos * clusterWeight;
|
|
}
|
|
|
|
// normalize dual quaternion
|
|
float norm = length(rAccum);
|
|
rAccum /= norm;
|
|
dAccum /= norm;
|
|
|
|
// conversion from dual quaternion to 4x4 matrix.
|
|
mat4 m = dualQuatToMat4(rAccum, dAccum);
|
|
|
|
// sAccum.w indicates the amount of cauterization for this vertex.
|
|
// 0 indicates no cauterization and 1 indicates full cauterization.
|
|
// TODO: make this cauterization smoother or implement full dual-quaternion scale support.
|
|
const float CAUTERIZATION_THRESHOLD = 0.1;
|
|
if (sAccum.w > CAUTERIZATION_THRESHOLD) {
|
|
skinnedPosition = cAccum;
|
|
} else {
|
|
sAccum.w = 1.0;
|
|
skinnedPosition = m * (sAccum * inPosition);
|
|
}
|
|
}
|
|
|
|
void skinPositionNormal(ivec4 skinClusterIndex, vec4 skinClusterWeight, vec4 inPosition, vec3 inNormal,
|
|
out vec4 skinnedPosition, out vec3 skinnedNormal) {
|
|
|
|
// linearly blend scale and dual quaternion components
|
|
vec4 sAccum = vec4(0.0, 0.0, 0.0, 0.0);
|
|
vec4 rAccum = vec4(0.0, 0.0, 0.0, 0.0);
|
|
vec4 dAccum = vec4(0.0, 0.0, 0.0, 0.0);
|
|
vec4 cAccum = vec4(0.0, 0.0, 0.0, 0.0);
|
|
vec4 polarityReference = clusterMatrices[skinClusterIndex[0]][1];
|
|
|
|
for (int i = 0; i < INDICES_PER_VERTEX; i++) {
|
|
mat4 clusterMatrix = clusterMatrices[(skinClusterIndex[i])];
|
|
float clusterWeight = skinClusterWeight[i];
|
|
|
|
vec4 scale = clusterMatrix[0];
|
|
vec4 real = clusterMatrix[1];
|
|
vec4 dual = clusterMatrix[2];
|
|
vec4 cauterizedPos = clusterMatrix[3];
|
|
|
|
// to ensure that we rotate along the shortest arc, reverse dual quaternions with negative polarity.
|
|
float dqClusterWeight = clusterWeight;
|
|
if (dot(real, polarityReference) < 0.0) {
|
|
dqClusterWeight = -clusterWeight;
|
|
}
|
|
|
|
sAccum += scale * clusterWeight;
|
|
rAccum += real * dqClusterWeight;
|
|
dAccum += dual * dqClusterWeight;
|
|
cAccum += cauterizedPos * clusterWeight;
|
|
}
|
|
|
|
// normalize dual quaternion
|
|
float norm = length(rAccum);
|
|
rAccum /= norm;
|
|
dAccum /= norm;
|
|
|
|
// conversion from dual quaternion to 4x4 matrix.
|
|
mat4 m = dualQuatToMat4(rAccum, dAccum);
|
|
|
|
// sAccum.w indicates the amount of cauterization for this vertex.
|
|
// 0 indicates no cauterization and 1 indicates full cauterization.
|
|
// TODO: make this cauterization smoother or implement full dual-quaternion scale support.
|
|
const float CAUTERIZATION_THRESHOLD = 0.1;
|
|
if (sAccum.w > CAUTERIZATION_THRESHOLD) {
|
|
skinnedPosition = cAccum;
|
|
} else {
|
|
sAccum.w = 1.0;
|
|
skinnedPosition = m * (sAccum * inPosition);
|
|
}
|
|
|
|
skinnedNormal = vec3(m * vec4(inNormal, 0));
|
|
}
|
|
|
|
void skinPositionNormalTangent(ivec4 skinClusterIndex, vec4 skinClusterWeight, vec4 inPosition, vec3 inNormal, vec3 inTangent,
|
|
out vec4 skinnedPosition, out vec3 skinnedNormal, out vec3 skinnedTangent) {
|
|
|
|
// linearly blend scale and dual quaternion components
|
|
vec4 sAccum = vec4(0.0, 0.0, 0.0, 0.0);
|
|
vec4 rAccum = vec4(0.0, 0.0, 0.0, 0.0);
|
|
vec4 dAccum = vec4(0.0, 0.0, 0.0, 0.0);
|
|
vec4 cAccum = vec4(0.0, 0.0, 0.0, 0.0);
|
|
vec4 polarityReference = clusterMatrices[skinClusterIndex[0]][1];
|
|
|
|
for (int i = 0; i < INDICES_PER_VERTEX; i++) {
|
|
mat4 clusterMatrix = clusterMatrices[(skinClusterIndex[i])];
|
|
float clusterWeight = skinClusterWeight[i];
|
|
|
|
vec4 scale = clusterMatrix[0];
|
|
vec4 real = clusterMatrix[1];
|
|
vec4 dual = clusterMatrix[2];
|
|
vec4 cauterizedPos = clusterMatrix[3];
|
|
|
|
// to ensure that we rotate along the shortest arc, reverse dual quaternions with negative polarity.
|
|
float dqClusterWeight = clusterWeight;
|
|
if (dot(real, polarityReference) < 0.0) {
|
|
dqClusterWeight = -clusterWeight;
|
|
}
|
|
|
|
sAccum += scale * clusterWeight;
|
|
rAccum += real * dqClusterWeight;
|
|
dAccum += dual * dqClusterWeight;
|
|
cAccum += cauterizedPos * clusterWeight;
|
|
}
|
|
|
|
// normalize dual quaternion
|
|
float norm = length(rAccum);
|
|
rAccum /= norm;
|
|
dAccum /= norm;
|
|
|
|
// conversion from dual quaternion to 4x4 matrix.
|
|
mat4 m = dualQuatToMat4(rAccum, dAccum);
|
|
|
|
// sAccum.w indicates the amount of cauterization for this vertex.
|
|
// 0 indicates no cauterization and 1 indicates full cauterization.
|
|
// TODO: make this cauterization smoother or implement full dual-quaternion scale support.
|
|
const float CAUTERIZATION_THRESHOLD = 0.1;
|
|
if (sAccum.w > CAUTERIZATION_THRESHOLD) {
|
|
skinnedPosition = cAccum;
|
|
} else {
|
|
sAccum.w = 1.0;
|
|
skinnedPosition = m * (sAccum * inPosition);
|
|
}
|
|
|
|
skinnedNormal = vec3(m * vec4(inNormal, 0));
|
|
skinnedTangent = vec3(m * vec4(inTangent, 0));
|
|
}
|
|
|
|
<@else@> // USE_DUAL_QUATERNION_SKINNING
|
|
|
|
void skinPosition(ivec4 skinClusterIndex, vec4 skinClusterWeight, vec4 inPosition, out vec4 skinnedPosition) {
|
|
vec4 newPosition = vec4(0.0, 0.0, 0.0, 0.0);
|
|
|
|
for (int i = 0; i < INDICES_PER_VERTEX; i++) {
|
|
mat4 clusterMatrix = clusterMatrices[(skinClusterIndex[i])];
|
|
float clusterWeight = skinClusterWeight[i];
|
|
newPosition += clusterMatrix * inPosition * clusterWeight;
|
|
}
|
|
|
|
skinnedPosition = newPosition;
|
|
}
|
|
|
|
void skinPositionNormal(ivec4 skinClusterIndex, vec4 skinClusterWeight, vec4 inPosition, vec3 inNormal,
|
|
out vec4 skinnedPosition, out vec3 skinnedNormal) {
|
|
vec4 newPosition = vec4(0.0, 0.0, 0.0, 0.0);
|
|
vec4 newNormal = vec4(0.0, 0.0, 0.0, 0.0);
|
|
|
|
for (int i = 0; i < INDICES_PER_VERTEX; i++) {
|
|
mat4 clusterMatrix = clusterMatrices[(skinClusterIndex[i])];
|
|
float clusterWeight = skinClusterWeight[i];
|
|
newPosition += clusterMatrix * inPosition * clusterWeight;
|
|
newNormal += clusterMatrix * vec4(inNormal.xyz, 0.0) * clusterWeight;
|
|
}
|
|
|
|
skinnedPosition = newPosition;
|
|
skinnedNormal = newNormal.xyz;
|
|
}
|
|
|
|
void skinPositionNormalTangent(ivec4 skinClusterIndex, vec4 skinClusterWeight, vec4 inPosition, vec3 inNormal, vec3 inTangent,
|
|
out vec4 skinnedPosition, out vec3 skinnedNormal, out vec3 skinnedTangent) {
|
|
vec4 newPosition = vec4(0.0, 0.0, 0.0, 0.0);
|
|
vec4 newNormal = vec4(0.0, 0.0, 0.0, 0.0);
|
|
vec4 newTangent = vec4(0.0, 0.0, 0.0, 0.0);
|
|
|
|
for (int i = 0; i < INDICES_PER_VERTEX; i++) {
|
|
mat4 clusterMatrix = clusterMatrices[(skinClusterIndex[i])];
|
|
float clusterWeight = skinClusterWeight[i];
|
|
newPosition += clusterMatrix * inPosition * clusterWeight;
|
|
newNormal += clusterMatrix * vec4(inNormal.xyz, 0.0) * clusterWeight;
|
|
newTangent += clusterMatrix * vec4(inTangent.xyz, 0.0) * clusterWeight;
|
|
}
|
|
|
|
skinnedPosition = newPosition;
|
|
skinnedNormal = newNormal.xyz;
|
|
skinnedTangent = newTangent.xyz;
|
|
}
|
|
|
|
<@endif@> // if USE_DUAL_QUATERNION_SKINNING
|
|
|
|
<@endfunc@> // func declareUseDualQuaternionSkinning(USE_DUAL_QUATERNION_SKINNING)
|
|
|
|
<@endif@> // if not SKINNING_SLH
|