package application_fx;

import java.util.ArrayList;
import java.util.List;

import javafx.scene.shape.TriangleMesh;
import javafx.scene.transform.Affine;
import javafx.scene.transform.NonInvertibleTransformException;

/**
 * ボーンアニメーション用のメッシュクラス
 * @author tomo
 *
 */
public class SkinTriangleMesh extends TriangleMesh
{
    // 基本的な行列
    private final   Affine  zeroMatrix              = new Affine( 0,0,0,0,0,0,0,0,0,0,0,0 );
    
    // バインディングポーズ情報
    private float[]         bindingPoints           = null;
    private Affine[]        bindingPointMatrixes    = null;
    private Affine[]        bindingJointMatrixes    = null;
    
    // 基本情報
    private float[]         points                  = null;
    private int[]           influenceCounts         = null;
    private float[]         weights                 = null;
    private int[]           influences              = null;
    
    // 関節情報
    private Affine[]        jointMatrixes           = null;


    /**
     * 頂点を設定
     * @param points
     */
    public void setPoints( float[] points )
    {
        // バインディング・ポーズを保存
        this.bindingPoints  = points;
        
        // 行列に変換
        List<Affine> poses      = new ArrayList<Affine>();
        for( int i=0 ; i<points.length/3 ; i++ )
        {
            // 座標を取得
            float   x   = points[ i*3 + 0 ];
            float   y   = points[ i*3 + 1 ];
            float   z   = points[ i*3 + 2 ];
            
            // 行列を作成
            Affine  affine  = new Affine( 0,0,0,x,
                                          0,0,0,y,
                                          0,0,0,z);
            
            // リストに追加
            poses.add( affine );
        }
        this.bindingPointMatrixes   = poses.toArray( new Affine[0] );
        
        // Triangleメッシュに頂点を設定
        super.getPoints().clear();
        super.getPoints().addAll( points );
    }

    /**
     * スキニングを実行
     * @param jointMatrixes
     */
    public void setJointMatrixes(Affine[] jointMatrixes)
    {
        // 関節情報を保持
        this.jointMatrixes = jointMatrixes;
        
        // 座標変換
        try {
            // 座標を計算
            calcPoint();
            
            // 新しい頂点配列を設定
            super.getPoints().clear();
            super.getPoints().addAll( points );
            
        } catch (NonInvertibleTransformException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * バインディング・ポーズにおける関節位置を定義
     * @param bindingJointMatrixes
     */
    public void setBindingJointMatrixes(Affine[] bindingJointMatrixes)
    {
        // バインディング・ポーズの関節を保持
        this.bindingJointMatrixes   = bindingJointMatrixes;
        
        // 関節情報を初期化
        this.jointMatrixes          = bindingJointMatrixes;
    }

    /**
     * 関節位置にあわせてメッシュの頂点を移動
     * とりあえず、高速化は考えない
     * @throws NonInvertibleTransformException 
     */
    private void calcPoint() throws NonInvertibleTransformException
    {   // 初期化
        int     index   = 0;
        this.points     = new float[ bindingPoints.length ];
        
        // i番目の頂点について処理を実行
        for( int i=0 ; i<influenceCounts.length ; i++ )
        {
            
            // 零行列を作成
            Affine  moveAffine  = zeroMatrix.clone();
            
            // 各頂点について、インフルーエンスの組数だけ処理を実行
            // 頂点（バインディングポーズ）*逆行列（バインディングポーズの関節）*新しい関節位置
            for( int cnt=0 ; cnt<influenceCounts[i] ; cnt++ )
            {
                // インフルーエンスを取得
                int jointIndex  = influences[ index + ( cnt * 2     ) ];
                int weightIndex = influences[ index + ( cnt * 2 + 1 ) ];
                
                // バインドポーズのジョイントの逆行列を取得
                Affine  inverse = bindingJointMatrixes[jointIndex].createInverse();
                
                // 移動先ジョイントを取得
                Affine  joint   = jointMatrixes[jointIndex];
                
                // 頂点の変換行列を作成
                Affine  transform   = new Affine();
                transform.append( joint );
                transform.append( inverse );
                
                // 重みを取得
                double  weight  = weights[weightIndex];
                
                // 行列を加算
               moveAffine.setMxx( moveAffine.getMxx() + weight * transform.getMxx() );
               moveAffine.setMxy( moveAffine.getMxy() + weight * transform.getMxy() );
               moveAffine.setMxz( moveAffine.getMxz() + weight * transform.getMxz() );
               moveAffine.setTx(  moveAffine.getTx()  + weight * transform.getTx()  );
               
               moveAffine.setMyx( moveAffine.getMyx() + weight * transform.getMyx() );
               moveAffine.setMyy( moveAffine.getMyy() + weight * transform.getMyy() );
               moveAffine.setMyz( moveAffine.getMyz() + weight * transform.getMyz() );
               moveAffine.setTy(  moveAffine.getTy()  + weight * transform.getTy()  );
               
               moveAffine.setMzx( moveAffine.getMzx() + weight * transform.getMzx() );
               moveAffine.setMzy( moveAffine.getMzy() + weight * transform.getMzy() );
               moveAffine.setMzz( moveAffine.getMzz() + weight * transform.getMzz() );
               moveAffine.setTz(  moveAffine.getTz()  + weight * transform.getTz()  );
            }
            
            // 頂点iを移動
            Affine  move        = new Affine();
            move.append( moveAffine );
            move.append( this.bindingPointMatrixes[i] );
            points[ i*3 + 0 ]   = (float) ( move.getTx() );
            points[ i*3 + 1 ]   = (float) ( move.getTy() );
            points[ i*3 + 2 ]   = (float) ( move.getTz() );
            
            // インデックスを更新
            index   += influenceCounts[i] * 2;
        }
        
    }
    
    // 以下は単純なgetter/setter

    public Affine[] getBindingJointMatrixes() {
        return bindingJointMatrixes;
    }
    public Affine[] getJointMatrixes() {
        return jointMatrixes;
    }
    public int[] getInfluenceCounts() {
        return influenceCounts;
    }
    public void setInfluenceCounts(int[] influenceCounts) {
        this.influenceCounts = influenceCounts;
    }
    public float[] getWeights() {
        return weights;
    }
    public void setWeights(float[] weights) {
        this.weights = weights;
    }
    public int[] getInfluences() {
        return influences;
    }
    public void setInfluences(int[] influences) {
        this.influences = influences;
    }
    
    
}