海飞丝头发的研究和实现

   private void OnDrawGizmos()
    ｛
        if (!DebugDraw || GetVertices() == null || !ValidateImpl(false))
            return;
        var scalpToWorld = ScalpProvider.ToWorldMatrix;
        var vertices = GetVertices();
        for (var i = 1; i < vertices.Count; i++)
        ｛
            if (i % Segments == 0)
                continue;
            var vertex1 = scalpToWorld.MultiplyPoint3x4(vertices[i - 1]);
            var vertex2 = scalpToWorld.MultiplyPoint3x4(vertices[i]);
            Gizmos.DrawLine(vertex1, vertex2);
        ｝
        var worldBounds = GetBounds();
        Gizmos.DrawWireCube(worldBounds.center, worldBounds.size);
    ｝

  private void UpdateBodies(RenderParticle[] renderParticles)
    ｛
        var renderSettings = settings.RenderSettings;
        var sizeY = settings.StandsSettings.Provider.GetSegmentsNum();
        //sizeY是单根头发的段数，i是第几根头发，y是这个头发里的第几段,t是百分比
        for (var i = 0; i < renderParticles.Length; i++)
        ｛
             var x = i / sizeY;
             var y = i % sizeY;
             var t = (float)y / sizeY;
             //下面是渲染的三个参数，后面渲染部分在解释
             var data = new RenderParticle
             ｛
                 Color = ColorToVector(renderSettings.ColorProvider.GetColor(settings, x, y, sizeY)),
                 Interpolation = Mathf.Clamp01(renderSettings.InterpolationCurve.Evaluate(t)),
                 WavinessScale = Mathf.Clamp01(renderSettings.WavinessScaleCurve.Evaluate(t)) * renderSettings.WavinessScale,
                 WavinessFrequency = Mathf.Clamp01(renderSettings.WavinessFrequencyCurve.Evaluate(t)) * renderSettings.WavinessFrequency,
             ｝;
             renderParticles[i] = data;
             ｝
    ｝
		

half3 CurveDirrection(half3 axis, half2 uv, half amplitude, half frequency)
    ｛
     //波动，uv.x就是当前所占百分比，uv.y是第几根，这个算法看上去比较难理解，其实就是每个轴，以圆形进行运动。大波浪的感觉。
        half angle = uv.x*frequency + uv.y;
        half c = cos(angle);
        half s = sin(angle);
        half3 vecX = half3(0, c, s);
        half3 vecY = half3(c, 0, s);
        half3 vecZ = half3(c, s, 0);
        half3 vec = normalize(vecX*axis.x + vecY*axis.y + vecZ*axis.z);
        return vec*amplitude; 
    ｝
    RenderParticle GetSplineBodyData(int x, half t, uint sizeY)
    ｛
    //渲染部分因为不需要贝塞尔插值，只需要当前点和下一个点lerp一下就行了
        int sizeYm1 = sizeY - 1;
        int y = (int)(t*sizeY);
        half tStep = 1.0f / sizeY;
        half localT = (t % tStep) * sizeY;
        int startI = x*sizeY;
        int y1 = min(y, sizeYm1);
        int y2 = min(y + 1, sizeYm1);
        RenderParticle b1 = renderParticles[startI + y1];
        RenderParticle b2 = renderParticles[startI + y2];
        RenderParticle b;
        b.color = lerp(b1.color, b2.color, localT);
        b.interpolation = lerp(b1.interpolation, b2.interpolation, localT);
        b.wavinessScale = lerp(b1.wavinessScale, b2.wavinessScale, localT);
        b.wavinessFrequency = lerp(b1.wavinessFrequency, b2.wavinessFrequency, localT);
        return b;
    ｝
    float3 GetSplinePoint(int x, float t, uint sizeY)
    ｛
     //sizeYm1就是八个间隔，y就是整根头发对应下的这个部分的值。这里要找到原始的珍珠对应新的曲面细分下的百分比。localT就是把0-1这个区间划分成九个0-1，startI就是找到新的曲面细分对应原始的顶点的位置。例如x=1，那么起始点就是9，y0就是y-1,y1就是y，y2就是y+1，这里还处理的范围，防止越界。找到对应的三个点之后，就可以做贝塞尔曲线的插值。插值的部分理论上就是这个点位于这三个点中的具体位置。所以t取余1/sizeY之后，还要乘以sizeY，就是正确的插值位置。
        int sizeYm1 = sizeY - 1;
        int y = (uint)(t*sizeY);
        half tStep = 1.0f / sizeY;
        half localT = (t % tStep) * sizeY;
        int startI = x*sizeY;
        int y0 = max(0, y - 1);
        int y1 = min(y, sizeYm1);
        int y2 = min(y + 1, sizeYm1);
        float3 p0 = particles[startI + y0].position;
        float3 p1 = particles[startI + y1].position;
        float3 p2 = particles[startI + y2].position;
        float3 cPoint1 = (p0 + p1)*0.5f;
        float3 cPoint2 = (p1 + p2)*0.5f;
        return GetBezierPoint(cPoint1, p1, cPoint2, localT);
    ｝
    [numthreads(THREADS,1,1)]
    void CSTesselate (uint3 id : SV_DispatchThreadID)
    ｛
    //id是这个线程在所有线程组中的位置，因为定义的yz都是1，所以其实就是id.x就是第几个线程，而一个顶点对应一个线程。tessSegments是曲面细分出的顶点数，这个可以优化成离摄像机越远，顶点数就越少。
    那么y在这里就是在一个曲面细分小段里的余数，x就是第几个曲面细分小段。t就是他所占曲面细分的百分比
    segments是每根头发的段数。工程里是9.
        uint y = id.x % tessSegments;
        uint x = id.x / tessSegments;
        float t = y / (float)tessSegments;
        float tessStep = 1.0/tessSegments;
        float3 tessPosition =  GetSplinePoint(x, saturate(t), segments);
        RenderParticle renderParticle = GetSplineBodyData(x, saturate(t), segments);
        float3 curve = CurveDirrection(normalize(wavinessAxis), half2(t, x), renderParticle.wavinessScale, renderParticle.wavinessFrequency);
        TessRenderParticle tessParticle;
        tessParticle.position = tessPosition + curve;
        tessParticle.tangent = float3(0,0,0);
        tessParticle.color = renderParticle.color;
        tessParticle.interpolation = renderParticle.interpolation;
        tessRenderParticles[id.x] = tessParticle;
        AllMemoryBarrierWithGroupSync();
        int sign = y == 0 ? -1 : 1;
        tessRenderParticles[id.x].tangent = normalize(tessParticle.position - tessRenderParticles[id.x - sign].position)*sign;
    ｝

private static List<int> ProcessIndicesForMesh(int startIndex, List<Vector3> scalpVertices, List<int> scalpIndices, List<Vector3> hairVertices, int segments, float accuracy = Accuracy)
    ｛
         var hairIndices = new List<int>();
    //遍历头皮的顶点，每三个构成一个三角形，对应的头发也要是3的倍数才行。遍历头发的顶点，将靠近头皮的部分一一对应，最终，每一个头皮的顶点都获得对应的一个头发的顶点的索引。
         for (var i = 0; i < scalpIndices.Count; i++)
         ｛
             var index = scalpIndices[i];
             var scalpVertex = scalpVertices[index];
             if (i % 3 == 0)
                  FixNotCompletedPolygon(hairIndices);
             for (var j = 0; j < hairVertices.Count; j += segments)
             ｛
                  var hairVertex = hairVertices[j];
                  if ((hairVertex - scalpVertex).sqrMagnitude < accuracy*accuracy)
                  ｛
                       hairIndices.Add(startIndex + j);
                       break;
                  ｝
              ｝
          ｝
          FixNotCompletedPolygon(hairIndices);
          return hairIndices;
    ｝
     public static List<int> ProcessIndices(List<int> scalpIndices, List<Vector3> scalpVertices, List<List<Vector3>> hairVerticesGroups, int segments, float accuracy = Accuracy)
    ｛
          var hairIndices = new List<int>();
          var grouStartIndex = 0;
          foreach (var hairVertices in hairVerticesGroups)
          ｛
               var groupIndices = ProcessIndicesForMesh(grouStartIndex, scalpVertices, scalpIndices, hairVertices, segments, accuracy);
               hairIndices.AddRange(groupIndices);
               grouStartIndex += hairVertices.Count;
           ｝
    //拿到所有的索引之后，再除以9，就是每个顶点对应的头发第几根
           for (var i = 0; i < hairIndices.Count; i++)
           ｛
                hairIndices[i] = hairIndices[i] / segments;
           ｝
           return hairIndices;
    ｝

//这事各项异性高光，将切线沿着法线进行一定程度的移动，可以展现头发的高光
    half3 ShiftTangent(half3 tangent, half3 normal, half shift)
    ｛
        return normalize(tangent + shift * normal);
    ｝
    这就是标准的Kajiya-Kay Model公式
    half Specular(half3 tangent, half3 viewDir, half3 lightDir, half exponent)
    ｛
        half3 h = normalize(viewDir + lightDir);
        half dotTH = dot(tangent, h);
        half sinTH = sqrt(1.0 - dotTH * dotTH);
        half dirAtten = smoothstep(-1.0, 0.0, dotTH);
        return dirAtten * pow(sinTH, exponent);
    ｝
    fixed3 SpecularColor(GS_OUTPUT i, fixed shift, half width1, half width2, fixed3 color)
    ｛
        half3 tangent1 = ShiftTangent(i.tangent, i.normal, i.factor.y - shift);
        half3 tangent2 = ShiftTangent(i.tangent, i.normal, i.factor.y + shift);
        half3 specular1 = Specular(tangent1, i.viewDir, i.lightDir, width1);
        half3 specular2 = Specular(tangent2, i.viewDir, i.lightDir, width2);
        return color * specular1*specular2;
    ｝
    float4 FS(GS_OUTPUT i) :SV_Target
    ｛
        fixed3 lightColor = _LightColor0 * LIGHT_ATTENUATION(i)*i.factor.x;
        fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.rgb*i.color;
        fixed3 diffuse = Diffuse(i.normal, i.lightDir, _Diffuse)*i.color*lightColor;
        fixed3 specular = SpecularColor(i, _SpecularShift, _PrimarySpecular, _SecondarySpecular, _SpecularColor)*(max(lightColor, 0.35));
        fixed4 final = fixed4(diffuse + specular + ambient, 1);
        UNITY_APPLY_FOG(i.fogCoord, final);
        return final;
    ｝

 float3 DistanceJointSolveImpl(float3 position1, float3 position2, float distance)
    ｛
        float3 relPosition = position1 - position2;
        float actualDistance = length(relPosition);
        float penetration = (distance - actualDistance) / actualDistance;
        return relPosition*penetration;
    ｝
    //按照现在的距离和上次的距离的比较，得到的矫正全部应用到第二个点的位置。
    void DistanceJointsSolve(uint i1, uint i2, float distance)
    ｛
        Particle particle1 = particles[i1];
        Particle particle2 = particles[i2];
        float3 correction = DistanceJointSolveImpl(particle1.position, particle2.position, distance)*step;
        particle2.position -= correction;
        particle2.lastPosition -= correction*0.9;
        particles[i2] = particle2;
    ｝
    [numthreads(THREADS,1,1)]
    void CSSplineJoints (uint3 id : SV_DispatchThreadID)
    ｛
        if(id.x*segments >= pointJointsLength)
            return;
    //从本地坐标转到世界坐标之后的两个点
        for(uint i = 1; i < segments; i++)
        ｛
            uint index = id.x*segments + i;
            PointJoint joint1 = pointJoints[index - 1];
            float4x4 m1 = transforms[joint1.matrixId];
            float3 guidePosition1 = mul(m1, float4(joint1.position, 1.0)).xyz;
            PointJoint joint2 = pointJoints[index];
            float4x4 m2 = transforms[joint2.matrixId];
            float3 guidePosition2 = mul(m2, float4(joint2.position, 1.0)).xyz;
            float distance = length(guidePosition2 - guidePosition1);
            DistanceJointsSolve(joint1.bodyId, joint2.bodyId, distance);
        ｝
    ｝