蒙皮和BS的Compute Shader参考 - 柚子其实是蜜柑

Unity 的蒙皮和 Bs 的 ComputeShader 的一种实现的参考。

Unity-Built-in-Shaders/DefaultResources/Internal-BlendShape.compute at master · TwoTailsGames/Unity-Built-in-Shaders · GitHub

1
// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)
2

3
#pragma kernel main
4
#pragma kernel main SKIN_NORM
5
#pragma kernel main SKIN_NORM SKIN_TANG
6

7
#include "HLSLSupport.cginc"
8
#include "Internal-Skinning-Util.cginc"
9

10
struct BlendShapeVertex
11
{
12
    int index;
13
    float3 pos;
14
    float3 norm;
15
    float3 tang;
16
};
17

18
uint g_FirstVert; // First vertex from blend shape buffer to use
19
uint g_VertCount; // Sparse vertex count, not the full amount of vertices in mesh
20
float g_Weight;
21

22
[numthreads(64, 1, 1)]
23
void main(uint3 threadID : SV_DispatchThreadID, SAMPLER_UNIFORM RWStructuredBuffer<MeshVertex> inOutMeshVertices, SAMPLER_UNIFORM StructuredBuffer<BlendShapeVertex> inBlendShapeVertices)
24
{
25
    const uint t = threadID.x;
26

27
    if (t >= g_VertCount)
28
    {
29
        return;
30
    }
31

32
    BlendShapeVertex blendShapeVert = inBlendShapeVertices[t + g_FirstVert];
33

34
    const uint vertIndex = blendShapeVert.index;
35

36
    inOutMeshVertices[vertIndex].pos += blendShapeVert.pos * g_Weight;
37
#if SKIN_NORM
38
    inOutMeshVertices[vertIndex].norm += blendShapeVert.norm * g_Weight;
39
#endif
40
#if SKIN_TANG
41
    inOutMeshVertices[vertIndex].tang.xyz += blendShapeVert.tang * g_Weight;
42
#endif
43
}

Unity-Built-in-Shaders/DefaultResources/Internal-Skinning.compute at master · TwoTailsGames/Unity-Built-in-Shaders · GitHub

1
// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)
2

3
// Generic compute skinning ... with pos, norm, and tangent skinning
4

5
#pragma kernel main SKIN_BONESFORVERT=0
6
#pragma kernel main SKIN_BONESFORVERT=0 SKIN_NORM
7
#pragma kernel main SKIN_BONESFORVERT=0 SKIN_TANG
8
#pragma kernel main SKIN_BONESFORVERT=0 SKIN_NORM SKIN_TANG
9
#pragma kernel main SKIN_BONESFORVERT=1
10
#pragma kernel main SKIN_BONESFORVERT=1 SKIN_NORM
11
#pragma kernel main SKIN_BONESFORVERT=1 SKIN_TANG
12
#pragma kernel main SKIN_BONESFORVERT=1 SKIN_NORM SKIN_TANG
13
#pragma kernel main SKIN_BONESFORVERT=2
14
#pragma kernel main SKIN_BONESFORVERT=2 SKIN_NORM
15
#pragma kernel main SKIN_BONESFORVERT=2 SKIN_TANG
16
#pragma kernel main SKIN_BONESFORVERT=2 SKIN_NORM SKIN_TANG
17
#pragma kernel main SKIN_BONESFORVERT=4
18
#pragma kernel main SKIN_BONESFORVERT=4 SKIN_NORM
19
#pragma kernel main SKIN_BONESFORVERT=4 SKIN_TANG
20
#pragma kernel main SKIN_BONESFORVERT=4 SKIN_NORM SKIN_TANG
21

22
#include "HLSLSupport.cginc"
23

24
uint g_VertCount;
25

26
#if defined(SHADER_API_D3D11) || defined(SHADER_API_XBOXONE) || defined(SHADER_API_PS4) || defined(SHADER_API_GLCORE) || defined(SHADER_API_GLES3) || defined(SHADER_API_VULKAN) || defined(SHADER_API_METAL) || defined(SHADER_API_PSSL) || defined(SHADER_API_SWITCH)
27
#define STRUCTURED_BUFFER_SUPPORT 1
28
#else
29
#define STRUCTURED_BUFFER_SUPPORT 0
30
#endif
31

32
struct MeshVertex
33
{
34
    float3 pos;
35
#if SKIN_NORM
36
    float3 norm;
37
#endif
38
#if SKIN_TANG
39
    float4 tang;
40
#endif
41
};
42

43
struct SkinInfluence
44
{
45
#if SKIN_BONESFORVERT <= 1
46
    int index0;
47
#elif SKIN_BONESFORVERT == 2
48
    float weight0, weight1;
49
    int index0, index1;
50
#elif SKIN_BONESFORVERT == 4
51
    float weight0, weight1, weight2, weight3;
52
    int index0, index1, index2, index3;
53
#endif
54
};
55

56
#if SKIN_NORM && SKIN_TANG
57
#define VERTEX_STRIDE 10
58
#elif SKIN_NORM
59
#define VERTEX_STRIDE 6
60
#else
61
#define VERTEX_STRIDE 3
62
#endif
63

64

65
#if !STRUCTURED_BUFFER_SUPPORT
66
MeshVertex FetchVert(SAMPLER_UNIFORM Buffer<float> vertices, const uint index, const uint stride)
67
{
68
    MeshVertex vert;
69

70
    uint offset = index * stride;
71
    vert.pos.x = vertices[offset++];
72
    vert.pos.y = vertices[offset++];
73
    vert.pos.z = vertices[offset++];
74

75
#if SKIN_NORM
76
    vert.norm.x = vertices[offset++];
77
    vert.norm.y = vertices[offset++];
78
    vert.norm.z = vertices[offset++];
79
#endif
80

81
#if SKIN_TANG
82
    vert.tang.x = vertices[offset++];
83
    vert.tang.y = vertices[offset++];
84
    vert.tang.z = vertices[offset++];
85
    vert.tang.w = vertices[offset++];
86
#endif
87

88
    return vert;
89
}
90

91
void StoreVert(SAMPLER_UNIFORM RWBuffer<float> vertices, float3 pos, float3 normal, float4 tang, const uint index, const uint stride)
92
{
93
    uint offset = index * stride;
94
    vertices[offset++] = pos.x;
95
    vertices[offset++] = pos.y;
96
    vertices[offset++] = pos.z;
97

98
#if SKIN_NORM
99
    vertices[offset++] = normal.x;
100
    vertices[offset++] = normal.y;
101
    vertices[offset++] = normal.z;
102
#endif
103

104
#if SKIN_TANG
105
    vertices[offset++] = tang.x;
106
    vertices[offset++] = tang.y;
107
    vertices[offset++] = tang.z;
108
    vertices[offset++] = tang.w;
109
#endif
110
}
111

112
#endif
113

114

115
[numthreads(64, 1, 1)]
116
#if !STRUCTURED_BUFFER_SUPPORT
117
void main(uint3 threadID : SV_DispatchThreadID, SAMPLER_UNIFORM Buffer<float> inVertices, SAMPLER_UNIFORM StructuredBuffer<SkinInfluence> inSkin, SAMPLER_UNIFORM RWBuffer<float> outVertices, SAMPLER_UNIFORM StructuredBuffer<float4x4> inMatrices)
118
#else
119
void main(uint3 threadID : SV_DispatchThreadID, SAMPLER_UNIFORM StructuredBuffer<MeshVertex> inVertices, SAMPLER_UNIFORM StructuredBuffer<SkinInfluence> inSkin, SAMPLER_UNIFORM RWStructuredBuffer<MeshVertex> outVertices, SAMPLER_UNIFORM StructuredBuffer<float4x4> inMatrices)
120
#endif
121
{
122
    const uint t = threadID.x;
123

124
    if (t >= g_VertCount)
125
    {
126
        return;
127
    }
128

129
#if !STRUCTURED_BUFFER_SUPPORT
130
    const MeshVertex vert = FetchVert(inVertices, t, VERTEX_STRIDE);
131
#else
132
    const MeshVertex vert = inVertices[t];
133
#endif
134
    SkinInfluence si = inSkin[t];
135

136
    float3 vPos = vert.pos.xyz;
137
#if SKIN_NORM
138
    float3 vNorm = vert.norm.xyz;
139
#endif
140
#if SKIN_TANG
141
    float3 vTang = vert.tang.xyz;
142
#endif
143

144
    float3 oPos = float3(0, 0, 0);
145
    float3 oNorm = float3(0, 0, 0);
146
    float4 oTang = float4(0, 0, 0, 0);
147

148
#if SKIN_BONESFORVERT == 0
149
    uint startIndex = si.index0;
150
    uint endIndex = inSkin[t + 1].index0;
151
    float4x4 blendedMatrix = 0;
152
    for (uint i = startIndex; i < endIndex; i++)
153
    {
154
        uint weightAndIndex = inSkin[i].index0;
155
        float weight = float(weightAndIndex >> 16) * (1.0f / 65535.0f);
156
        uint index = weightAndIndex & 0xFFFF;
157
        blendedMatrix += inMatrices[index] * weight;
158
    }
159
#elif SKIN_BONESFORVERT == 1
160
    const float4x4 blendedMatrix = inMatrices[si.index0];
161
#elif SKIN_BONESFORVERT == 2
162
    const float4x4 blendedMatrix = inMatrices[si.index0] * si.weight0 +
163
                                   inMatrices[si.index1] * si.weight1;
164
#elif SKIN_BONESFORVERT == 4
165
    const float4x4 blendedMatrix = inMatrices[si.index0] * si.weight0 +
166
                                   inMatrices[si.index1] * si.weight1 +
167
                                   inMatrices[si.index2] * si.weight2 +
168
                                   inMatrices[si.index3] * si.weight3;
169
#endif
170

171
    oPos = mul(blendedMatrix, float4(vPos, 1)).xyz;
172

173
#if SKIN_NORM
174
    oNorm = mul(blendedMatrix, float4(vNorm, 0)).xyz;
175
#endif
176

177
#if SKIN_TANG
178
    oTang.xyz = mul(blendedMatrix, float4(vTang, 0)).xyz;
179
    oTang.w = vert.tang.w;
180
#endif
181

182
#if STRUCTURED_BUFFER_SUPPORT
183
    outVertices[t].pos = oPos;
184
#if SKIN_NORM
185
    outVertices[t].norm = oNorm;
186
#endif
187
#if SKIN_TANG
188
    outVertices[t].tang = oTang;
189
#endif
190
#else
191
    StoreVert(outVertices, oPos, oNorm, oTang, t, VERTEX_STRIDE);
192
#endif
193
}