Пример #1
0
    public static Vector3[] GetIDsAndWeights(int seed, float[] triAreas, int[] triangles, Vector3[] vertices)
    {
        float randomVal = getRandomFloatFromSeed(seed * 20);

        int tri0 = 3 * getTri(randomVal, triAreas);
        int tri1 = tri0 + 1;
        int tri2 = tri0 + 2;

        tri0 = triangles[tri0];
        tri1 = triangles[tri1];
        tri2 = triangles[tri2];

        Vector3 pos = GetRandomPointInTriangle(seed, vertices[tri0], vertices[tri1], vertices[tri2]);

        float a0     = HelperFunctions.AreaOfTriangle(pos, vertices[tri1], vertices[tri2]);
        float a1     = HelperFunctions.AreaOfTriangle(pos, vertices[tri0], vertices[tri2]);
        float a2     = HelperFunctions.AreaOfTriangle(pos, vertices[tri0], vertices[tri1]);
        float aTotal = a0 + a1 + a2;

        float p0 = a0 / aTotal;
        float p1 = a1 / aTotal;
        float p2 = a2 / aTotal;

        return(new [] { new Vector3(tri0, tri1, tri2), new Vector3(p0, p1, p2) });
    }
Пример #2
0
    public static float[] GetTriAreas(int[] triangles, Vector3[] vertices)
    {
        float[] triAreas = new float[triangles.Length / 3];


        float totalArea = 0;

        for (int i = 0; i < triangles.Length / 3; i++)
        {
            int tri0 = i * 3;
            int tri1 = tri0 + 1;
            int tri2 = tri0 + 2;
            tri0 = triangles[tri0];
            tri1 = triangles[tri1];
            tri2 = triangles[tri2];
            float area = HelperFunctions.AreaOfTriangle(vertices[tri0], vertices[tri1], vertices[tri2]);
            triAreas[i] = area;
            totalArea  += area;
        }

        for (int i = 0; i < triAreas.Length; i++)
        {
            triAreas[i] /= totalArea;
        }


        return(triAreas);
    }
Пример #3
0
    public static Point getVertInfo(int seed, float randomVal, float[] triAreas, int[] triValues, VertBuffer vertBuffer)
    {
        int tri0 = 3 * HelperFunctions.getTri(randomVal, triAreas);
        int tri1 = tri0 + 1;
        int tri2 = tri0 + 2;

        tri0 = triValues[tri0];
        tri1 = triValues[tri1];
        tri2 = triValues[tri2];

        Vector3 pos = HelperFunctions.GetRandomPointInTriangle(seed, vertBuffer.vertices[tri0], vertBuffer.vertices[tri1], vertBuffer.vertices[tri2]);

        float a0     = HelperFunctions.AreaOfTriangle(pos, vertBuffer.vertices[tri1], vertBuffer.vertices[tri2]);
        float a1     = HelperFunctions.AreaOfTriangle(pos, vertBuffer.vertices[tri0], vertBuffer.vertices[tri2]);
        float a2     = HelperFunctions.AreaOfTriangle(pos, vertBuffer.vertices[tri0], vertBuffer.vertices[tri1]);
        float aTotal = a0 + a1 + a2;

        float p0 = a0 / aTotal;
        float p1 = a1 / aTotal;
        float p2 = a2 / aTotal;



        Vector3 nor = vertBuffer.normals[tri0] * p0 + vertBuffer.normals[tri1] * p1 + vertBuffer.normals[tri2] * p2;

        nor = nor.normalized;
//          Vector3 color   = tri0.color  * p0 + tri1.color  * p1 + tri2.color  * p2;

        Vector2 uv = vertBuffer.uvs[tri0] * p0 + vertBuffer.uvs[tri1] * p1 + vertBuffer.uvs[tri2] * p2;


        Point p = new Point();

        p.uv         = uv;
        p.nor        = nor;
        p.triWeights = new Vector3(p0, p1, p2);
        p.triIDs     = new Vector3(tri0, tri1, tri2);

        return(p);
    }
Пример #4
0
    void CreateBuffers()
    {
        _buffer = new ComputeBuffer(fullVertCount, vertStructSize * sizeof(float));
        values  = new float[fullVertCount * vertStructSize];



        // Used for assigning to our buffer;
        int index = 0;



        triAreas = new float[triBuffer.values.Length / 3];


        float totalArea = 0;

        for (int i = 0; i < triBuffer.values.Length / 3; i++)
        {
            int tri0 = i * 3;
            int tri1 = tri0 + 1;
            int tri2 = tri0 + 2;
            tri0 = triBuffer.values[tri0];
            tri1 = triBuffer.values[tri1];
            tri2 = triBuffer.values[tri2];
            float area = HelperFunctions.AreaOfTriangle(vertBuffer.vertices[tri0], vertBuffer.vertices[tri1], vertBuffer.vertices[tri2]);
            triAreas[i] = area;
            totalArea  += area;
        }

        for (int i = 0; i < triAreas.Length; i++)
        {
            triAreas[i] /= totalArea;
        }

        for (int i = 0; i < fullVertCount; i++)
        {
            int id = i;
            //print( index);
            //print( inValues.Length );

            int idInHair = id % numVertsPerHair;
            int hairID   = (int)Mathf.Floor((float)id / (float)numVertsPerHair);

            // Resets using same hairID, so RandomPointInTriangle shoudl work
            float randomVal = HelperFunctions.getRandomFloatFromSeed(hairID * 20);

            int tri0 = 3 * HelperFunctions.getTri(randomVal, triAreas);
            int tri1 = tri0 + 1;
            int tri2 = tri0 + 2;



            tri0 = triBuffer.values[tri0];
            tri1 = triBuffer.values[tri1];
            tri2 = triBuffer.values[tri2];

            Vector3 pos = HelperFunctions.GetRandomPointInTriangle(hairID, vertBuffer.vertices[tri0], vertBuffer.vertices[tri1], vertBuffer.vertices[tri2]);

            float a0     = HelperFunctions.AreaOfTriangle(pos, vertBuffer.vertices[tri1], vertBuffer.vertices[tri2]);
            float a1     = HelperFunctions.AreaOfTriangle(pos, vertBuffer.vertices[tri0], vertBuffer.vertices[tri2]);
            float a2     = HelperFunctions.AreaOfTriangle(pos, vertBuffer.vertices[tri0], vertBuffer.vertices[tri1]);
            float aTotal = a0 + a1 + a2;

            float p0 = a0 / aTotal;
            float p1 = a1 / aTotal;
            float p2 = a2 / aTotal;


            Vector3 nor = vertBuffer.normals[tri0] * p0 + vertBuffer.normals[tri1] * p1 + vertBuffer.normals[tri2] * p2;
            nor = nor.normalized;

//          Vector3 tan    = vertBuffer.tangents[tri0]  * p0 + vertBuffer.tangents[tri1]  * p1 + vertBuffer.tangents[tri2]  * p2;
            ///      tan = tan.normalized;

            /*float3 tang    = tri0.tang  * p0 + tri1.tang  * p1 + tri2.tang  * p2;
             * float3 color   = tri0.color  * p0 + tri1.color  * p1 + tri2.color  * p2;
             * float2 uv      = tri0.uv * p0 + tri1.uv * p1 + tri2.uv * p2;*/


            float idVal = (float)id / (float)fullVertCount;
            float uvX   = (float)idInHair / (float)numVertsPerHair;
            float uvY   = (float)hairID / (float)totalHairs;

            int xID = hairID % 180;
            int zID = (int)Mathf.Floor((float)hairID / (float)180);

            float xPos = (float)xID / 180;
            float zPos = (float)zID / 180;

            Vector3 fPos = pos + nor * hairLength * uvX;

            // pos
            values[index++] = fPos.x;
            values[index++] = fPos.y;
            values[index++] = fPos.z;

            // oPos
            values[index++] = fPos.x;
            values[index++] = fPos.y;
            values[index++] = fPos.z;

            //vel
            values[index++] = 0;
            values[index++] = 0;
            values[index++] = 0;

            // nor
            values[index++] = nor.x;
            values[index++] = nor.y;
            values[index++] = nor.z;

            // uv
            values[index++] = uvX;
            values[index++] = uvY;

            // debug
            values[index++] = 1;
            values[index++] = 1;
            values[index++] = 1;


            // triIDs
            values[index++] = tri0;
            values[index++] = tri1;
            values[index++] = tri2;

            // triWeights
            values[index++] = p0;
            values[index++] = p1;
            values[index++] = p2;
        }

        _buffer.SetData(values);
    }
Пример #5
0
    void CreateBuffers()
    {
        _buffer = new ComputeBuffer(numberMeshes, BasisStructSize * sizeof(float));
        values  = new float[numberMeshes * BasisStructSize];

        triAreas = new float[triBuffer.triangles.Length / 3];

        // Used for assigning to our buffer;
        int index = 0;

        //   print( numberMeshes );
//    print( values.Length );

        float totalArea = 0;


        for (int i = 0; i < triBuffer.triangles.Length / 3; i++)
        {
            int tri0 = i * 3;
            int tri1 = tri0 + 1;
            int tri2 = tri0 + 2;
            tri0 = triBuffer.triangles[tri0];
            tri1 = triBuffer.triangles[tri1];
            tri2 = triBuffer.triangles[tri2];


            float area = HelperFunctions.AreaOfTriangle(vertBuffer.vertices[tri0], vertBuffer.vertices[tri1], vertBuffer.vertices[tri2]);
            triAreas[i] = area;
            totalArea  += area;
        }


        for (int i = 0; i < triAreas.Length; i++)
        {
            triAreas[i] /= totalArea;
        }



        for (int i = 0; i < numberMeshes; i++)
        {
            int id = i;

            float randomVal = Random.value;

            int tri0 = 3 * HelperFunctions.getTri(randomVal, triAreas);
            int tri1 = tri0 + 1;
            int tri2 = tri0 + 2;

            tri0 = triBuffer.triangles[tri0];
            tri1 = triBuffer.triangles[tri1];
            tri2 = triBuffer.triangles[tri2];

            Vector3 pos = HelperFunctions.GetRandomPointInTriangle(id, vertBuffer.vertices[tri0], vertBuffer.vertices[tri1], vertBuffer.vertices[tri2]);

            float a0     = HelperFunctions.AreaOfTriangle(pos, vertBuffer.vertices[tri1], vertBuffer.vertices[tri2]);
            float a1     = HelperFunctions.AreaOfTriangle(pos, vertBuffer.vertices[tri0], vertBuffer.vertices[tri2]);
            float a2     = HelperFunctions.AreaOfTriangle(pos, vertBuffer.vertices[tri0], vertBuffer.vertices[tri1]);
            float aTotal = a0 + a1 + a2;

            float p0 = a0 / aTotal;
            float p1 = a1 / aTotal;
            float p2 = a2 / aTotal;


            Vector3 nor = vertBuffer.normals[tri0] * p0 + vertBuffer.normals[tri1] * p1 + vertBuffer.normals[tri2] * p2;
            nor = nor.normalized;
//          Vector3 color   = tri0.color  * p0 + tri1.color  * p1 + tri2.color  * p2;


            Vector2 uv = vertBuffer.uvs[tri0] * p0 + vertBuffer.uvs[tri1] * p1 + vertBuffer.uvs[tri2] * p2;

            Vector3 left = Vector3.Cross(nor, Vector3.up);
            left.Normalize();
            Vector3 forward = Vector3.Cross(left, nor);


//          print( id );



            values[index++] = id;

            //transform
            for (int j = 0; j < 16; j++)
            {
                values[index++] = 0;
            }

            // uv
            values[index++] = uv.x;
            values[index++] = uv.y;

            // triIDs
            values[index++] = tri0;
            values[index++] = tri1;
            values[index++] = tri2;

            // triWeights
            values[index++] = p0;
            values[index++] = p1;
            values[index++] = p2;

            // debug
            values[index++] = 1;
            values[index++] = 0;
            values[index++] = 0;
        }

        _buffer.SetData(values);
    }
Пример #6
0
    // Use this for initialization
    void Start()
    {
        physicsKernel  = physics.FindKernel("CSMain");
        skinningKernel = skinning.FindKernel("CSMain");


        skinningKernel  = skinning.FindKernel("CSMain");
        transformKernel = transform.FindKernel("CSMain");

        physicsKernel    = physics.FindKernel("CSMain");
        constraintKernel = constraint.FindKernel("CSMain");

        numberOfBonesPerLimb  = boneBuffer.boneCount;
        numberOfPointsPerLimb = numberOfBonesPerLimb + 1;

        print(vertBuffer.vertCount);
        totalNumberBones  = numberOfBonesPerLimb * numberOfLimbs;
        totalNumberVerts  = vertBuffer.vertCount * numberOfLimbs;
        totalNumberPoints = (numberOfPointsPerLimb) * numberOfLimbs;

        print(totalNumberVerts);
        print(totalNumberBones);

        fullPointBuffer = new ComputeBuffer(totalNumberPoints, pointStructSize * sizeof(float));
        fullBoneBuffer  = new ComputeBuffer(totalNumberBones, boneStructSize * sizeof(float));
        fullVertBuffer  = new ComputeBuffer(totalNumberVerts, vertBuffer.structSize * sizeof(float));

        boneValues  = new float[totalNumberBones * boneStructSize];
        vertValues  = new float[totalNumberVerts * vertBuffer.structSize];
        pointValues = new float[totalNumberPoints * pointStructSize];

        int     index = 0;
        Vector3 basePosition;
        Vector3 fPos;

        for (int i = 0; i < numberOfLimbs; i++)
        {
            // Resets using same hairID, so RandomPointInTriangle shoudl work
            float randomVal = HelperFunctions.getRandomFloatFromSeed(i * 20);

            int tri0 = (int)(randomVal * (float)(baseTriBuffer.triangles.Length / 3)) * 3;
            //int tri0 = (int)(randomVal *  1000 + 1000 ) * 3;
            int tri1 = tri0 + 1;
            int tri2 = tri0 + 2;



            tri0 = baseTriBuffer.triangles[tri0];
            tri1 = baseTriBuffer.triangles[tri1];
            tri2 = baseTriBuffer.triangles[tri2];


            Vector3 pos = HelperFunctions.GetRandomPointInTriangle(i, baseVertBuffer.vertices[tri0], baseVertBuffer.vertices[tri1], baseVertBuffer.vertices[tri2]);

            float a0     = HelperFunctions.AreaOfTriangle(pos, baseVertBuffer.vertices[tri1], baseVertBuffer.vertices[tri2]);
            float a1     = HelperFunctions.AreaOfTriangle(pos, baseVertBuffer.vertices[tri0], baseVertBuffer.vertices[tri2]);
            float a2     = HelperFunctions.AreaOfTriangle(pos, baseVertBuffer.vertices[tri0], baseVertBuffer.vertices[tri1]);
            float aTotal = a0 + a1 + a2;

            float p0 = a0 / aTotal;
            float p1 = a1 / aTotal;
            float p2 = a2 / aTotal;


            Vector3 nor = baseVertBuffer.normals[tri0] * p0 + baseVertBuffer.normals[tri1] * p1 + baseVertBuffer.normals[tri2] * p2;
            nor = nor.normalized;


            basePosition = baseTransform.TransformPoint(pos);//new Vector3( i * .1f, 0 , 0);



            for (int j = 0; j < numberOfBonesPerLimb; j++)
            {
                fPos = boneBuffer.bones[j].transform.position + basePosition;


                pointValues[index++] = 1;

                pointValues[index++] = fPos.x;
                pointValues[index++] = fPos.y;
                pointValues[index++] = fPos.z;

                pointValues[index++] = fPos.x;
                pointValues[index++] = fPos.y;
                pointValues[index++] = fPos.z;


                pointValues[index++] = nor.x;
                pointValues[index++] = nor.y;
                pointValues[index++] = nor.z;


                pointValues[index++] = (float)i / (float)numberOfLimbs;
                pointValues[index++] = (float)j / (float)numberOfBonesPerLimb;

                pointValues[index++] = 0;
                pointValues[index++] = 1;
                pointValues[index++] = 0;
            }


            fPos = boneBuffer.bones[numberOfBonesPerLimb - 1].transform.position + basePosition + Vector3.up * .1f;

            pointValues[index++] = 1;

            pointValues[index++] = fPos.x;
            pointValues[index++] = fPos.y;
            pointValues[index++] = fPos.z;

            pointValues[index++] = fPos.x;
            pointValues[index++] = fPos.y;
            pointValues[index++] = fPos.z;


            pointValues[index++] = 0;
            pointValues[index++] = 1;
            pointValues[index++] = 0;


            pointValues[index++] = (float)i / (float)numberOfLimbs;
            pointValues[index++] = 1;

            pointValues[index++] = 0;
            pointValues[index++] = 1;
            pointValues[index++] = 0;
        }

        fullPointBuffer.SetData(pointValues);



        index = 0;
        for (int i = 0; i < numberOfLimbs; i++)
        {
            float rot = 360 * Random.value;
            for (int j = 0; j < numberOfBonesPerLimb; j++)
            {
                boneValues[index++] = i;
                boneValues[index++] = j;

                boneValues[index++] = boneBuffer.bones[j].transform.localToWorldMatrix[0, 0];
                boneValues[index++] = boneBuffer.bones[j].transform.localToWorldMatrix[1, 0];
                boneValues[index++] = boneBuffer.bones[j].transform.localToWorldMatrix[2, 0];
                boneValues[index++] = boneBuffer.bones[j].transform.localToWorldMatrix[3, 0];
                boneValues[index++] = boneBuffer.bones[j].transform.localToWorldMatrix[0, 1];
                boneValues[index++] = boneBuffer.bones[j].transform.localToWorldMatrix[1, 1];
                boneValues[index++] = boneBuffer.bones[j].transform.localToWorldMatrix[2, 1];
                boneValues[index++] = boneBuffer.bones[j].transform.localToWorldMatrix[3, 1];
                boneValues[index++] = boneBuffer.bones[j].transform.localToWorldMatrix[0, 2];
                boneValues[index++] = boneBuffer.bones[j].transform.localToWorldMatrix[1, 2];
                boneValues[index++] = boneBuffer.bones[j].transform.localToWorldMatrix[2, 2];
                boneValues[index++] = boneBuffer.bones[j].transform.localToWorldMatrix[3, 2];
                boneValues[index++] = boneBuffer.bones[j].transform.localToWorldMatrix[0, 3];
                boneValues[index++] = boneBuffer.bones[j].transform.localToWorldMatrix[1, 3];
                boneValues[index++] = boneBuffer.bones[j].transform.localToWorldMatrix[2, 3];
                boneValues[index++] = boneBuffer.bones[j].transform.localToWorldMatrix[3, 3];



                var rotation = Matrix4x4.Rotate(boneBuffer.bones[j].rotation);


                var quat = QuaternionFromMatrix(boneBuffer.bones[j].transform.localToWorldMatrix);
                //undo rotations of blender
                var tmpMat = Matrix4x4.Rotate(quat) * boneBuffer.bindPoses[j];

                //adding random y rotation!
                tmpMat = Matrix4x4.Rotate(Quaternion.AngleAxis(rot, Vector3.up)) * tmpMat;


                boneValues[index++] = tmpMat[0, 0];
                boneValues[index++] = tmpMat[1, 0];
                boneValues[index++] = tmpMat[2, 0];
                boneValues[index++] = tmpMat[3, 0];
                boneValues[index++] = tmpMat[0, 1];
                boneValues[index++] = tmpMat[1, 1];
                boneValues[index++] = tmpMat[2, 1];
                boneValues[index++] = tmpMat[3, 1];
                boneValues[index++] = tmpMat[0, 2];
                boneValues[index++] = tmpMat[1, 2];
                boneValues[index++] = tmpMat[2, 2];
                boneValues[index++] = tmpMat[3, 2];
                boneValues[index++] = tmpMat[0, 3];
                boneValues[index++] = tmpMat[1, 3];
                boneValues[index++] = tmpMat[2, 3];
                boneValues[index++] = tmpMat[3, 3];
            }
        }

        fullBoneBuffer.SetData(boneValues);



        index = 0;
        for (int j = 0; j < numberOfLimbs; j++)
        {
            for (int i = 0; i < vertBuffer.vertCount; i++)
            {
                // used
                vertValues[index++] = j;

                // positions
                vertValues[index++] = vertBuffer.vertices[i].x * .99f;
                vertValues[index++] = vertBuffer.vertices[i].y * .99f;
                vertValues[index++] = vertBuffer.vertices[i].z * .99f;

                // vel
                vertValues[index++] = 0;
                vertValues[index++] = 0;
                vertValues[index++] = 0;

                // normals
                vertValues[index++] = vertBuffer.normals[i].x;
                vertValues[index++] = vertBuffer.normals[i].y;
                vertValues[index++] = vertBuffer.normals[i].z;

                // uvs
                vertValues[index++] = vertBuffer.uvs[i].x;
                vertValues[index++] = vertBuffer.uvs[i].y;


                // target pos
                vertValues[index++] = vertBuffer.vertices[i].x;
                vertValues[index++] = vertBuffer.vertices[i].y;
                vertValues[index++] = vertBuffer.vertices[i].z;



                // bindPositions
                vertValues[index++] = vertBuffer.vertices[i].x;
                vertValues[index++] = vertBuffer.vertices[i].y;
                vertValues[index++] = vertBuffer.vertices[i].z;


                // bindNor
                vertValues[index++] = vertBuffer.normals[i].x;
                vertValues[index++] = vertBuffer.normals[i].y;
                vertValues[index++] = vertBuffer.normals[i].z;

                // bone weights
                vertValues[index++] = vertBuffer.weights[i].weight0;
                vertValues[index++] = vertBuffer.weights[i].weight1;
                vertValues[index++] = vertBuffer.weights[i].weight2;
                vertValues[index++] = vertBuffer.weights[i].weight3;

                // bone indices
                vertValues[index++] = vertBuffer.weights[i].boneIndex0;
                vertValues[index++] = vertBuffer.weights[i].boneIndex1;
                vertValues[index++] = vertBuffer.weights[i].boneIndex2;
                vertValues[index++] = vertBuffer.weights[i].boneIndex3;

                // Debug
                vertValues[index++] = 1;
                vertValues[index++] = 0;
                vertValues[index++] = 0;
            }
        }

        fullVertBuffer.SetData(vertValues);



        transformGroups  = ((totalNumberBones) + (numThreads - 1)) / numThreads;
        constraintGroups = ((totalNumberPoints) + (numThreads - 1)) / numThreads;
        skinningGroups   = ((totalNumberVerts) + (numThreads - 1)) / numThreads;
        physicsGroups    = ((totalNumberPoints) + (numThreads - 1)) / numThreads;
    }