Пример #1
0
    void Start(MMDModel model)
    {
        mesh = model;//GetComponent<MeshFilter>().mesh;

        keytype = KEYType.KEY_BSPLINE;
        overts  = mesh.OrigVertice;
        verts   = mesh.Vertice;
        int len = verts.Length;

        nverts = new Vertex[len];
        NotifyChanged( );
        init_latt_deform( );
        lattice_deform_vertsFull( );
        topind = LatticeData.FirstIndex(l => SamePos(l.Value.Position, new Vector3(0, 1, 0)));
#if INTERPOLATION
        interp = new Interpolation.Elastic(2, 10, 7, 1);
#endif
    }
Пример #2
0
    void key_curve_position_weights(float t, float[] data, KEYType type)
    {
        float t2, t3, fc;

        if (type == KEYType.KEY_LINEAR)
        {
            data[0] = 0.0f;
            data[1] = -t + 1.0f;
            data[2] = t;
            data[3] = 0.0f;
        }
        else if (type == KEYType.KEY_CARDINAL)
        {
            t2 = t * t;
            t3 = t2 * t;
            fc = 0.71f;

            data[0] = -fc * t3 + 2.0f * fc * t2 - fc * t;
            data[1] = (2.0f - fc) * t3 + (fc - 3.0f) * t2 + 1.0f;
            data[2] = (fc - 2.0f) * t3 + (3.0f - 2.0f * fc) * t2 + fc * t;
            data[3] = fc * t3 - fc * t2;
        }
        else if (type == KEYType.KEY_BSPLINE)
        {
            t2 = t * t;
            t3 = t2 * t;

            data[0] = -0.16666666f * t3 + 0.5f * t2 - 0.5f * t + 0.16666666f;
            data[1] = 0.5f * t3 - t2 + 0.66666666f;
            data[2] = -0.5f * t3 + 0.5f * t2 + 0.5f * t + 0.16666666f;
            data[3] = 0.16666666f * t3;
        }
        else if (type == KEYType.KEY_CATMULL_ROM)
        {
            t2 = t * t;
            t3 = t2 * t;
            fc = 0.5f;

            data[0] = -fc * t3 + 2.0f * fc * t2 - fc * t;
            data[1] = (2.0f - fc) * t3 + (fc - 3.0f) * t2 + 1.0f;
            data[2] = (fc - 2.0f) * t3 + (3.0f - 2.0f * fc) * t2 + fc * t;
            data[3] = fc * t3 - fc * t2;
        }
    }
Пример #3
0
    //リサイズ部分以外終わり
    // latice割数を増やす
    void BKE_lattice_resize(int uNew, int vNew, int wNew)    //, Object *ltOb)
    {
        //頂点ウェイトグループはすべて開放される
        if (dvert.Length != 0)
        {
            //BKE_defvert_array_free(lt->dvert, lt->pntsu * lt->pntsv * lt->pntsw);
            //lt->dvert = NULL;
        }
        while (uNew * vNew * wNew > 32000)
        {
            if (uNew >= vNew && uNew >= wNew)
            {
                uNew--;
            }
            else if (vNew >= uNew && vNew >= wNew)
            {
                vNew--;
            }
            else
            {
                wNew--;
            }
        }

        var vertexCos = new Vertex[uNew * vNew * wNew];  //tmp_vcos
        var fudu      = calc_lat_fudu(gridFlag, uNew);
        var fvdv      = calc_lat_fudu(gridFlag, vNew);
        var fwdw      = calc_lat_fudu(gridFlag, wNew);

        if (alreadyCreate)
        {
            //1分割まで減らされたり、元から1分割でないなら
            if (uNew != 1 && UVW[0] != 1)
            {
                du = (UVW[0] - 1) * du / (uNew - 1);
            }

            if (vNew != 1 && UVW[1] != 1)
            {
                dv = (UVW[1] - 1) * dv / (vNew - 1);
            }

            if (wNew != 1 && UVW[2] != 1)
            {
                dw = (UVW[2] - 1) * dw / (wNew - 1);
            }
        }

        var co = vertexCos;

        fu = fudu[0];
        du = fudu[1];
        fv = fvdv[0];
        dv = fvdv[1];
        fw = fwdw[0];
        dw = fwdw[1];

        float wc  = fw;
        float vc  = fv;
        float uc  = fu;
        int   coi = 0;

        for (int w = 0; w < wNew; w++, wc += dw)
        {
            vc = fv;
            for (int v = 0; v < vNew; v++, vc += dv)
            {
                uc = fu;
                for (int u = 0; u < uNew; u++, coi++, uc += du)
                {
                    var cv = new Vector3(-uc, -vc, -wc);
                    // todo 同じかどうかよく調べる
                    co[coi].Position = (cv);
                }
            }
        }
        if (alreadyCreate)
        {
            //var mat = new float[4, 4];
            var typeu = keytype; //lt->typeu, typev = lt->typev, typew = lt->typew;

            //endpointsがマッチするので強制的にlinに変える
            //lt->typeu = lt->typev = lt->typew
            keytype = KEYType.KEY_LINEAR;

            //変更された座標を使わないように
            //BKE_displist_free(&ltOb->curve_cache->disp);

            //オブジェクトの行列を退避、デフォームさせてから戻す
            //copy_m4_m4(mat, ltOb->obmat);
            //unit_m4(ltOb->obmat);

#if false
            var mat = transform.localToWorldMatrix;
#endif
            //transform.localToWorldMatrix = Matrix4x4.identity;
            lattice_deform_vertsFull( );
            //copy_m4_m4(ltOb->obmat, mat);
            keytype = typeu;
            //lt->typeu = typeu;
            //lt->typev = typev;
            //lt->typew = typew;
        }
        alreadyCreate = true;
        // pntsu
        UVW[0] = uNew;
        UVW[1] = vNew;
        UVW[2] = wNew;
        actbp  = LT_ACTBP_NONE;
        //bpの処理をしていないが、これでいいはず
        LatticeString   = co.Select(x => new ReactiveProperty <string>(x.ToString( ))).ToList( );
        LatticeData     = LatticeString.Select(reactiveProperty).ToArray( );
        RelativeLattice = new LatticeType[LatticeData.Length];
    }