encode Shift_JIS ;
/*================================================
1090_Icosa_pyramid_00 / 120515
================================================*/

import Graphics ; import Graphics3D ; import GUI ; import Math ; 

/*==============================================*/

/* ウィンドウの構築などの初期化処理を行う関数、メインプログラムから呼び出す */

void G3D_INIT( ){

    MAIN_GRAPHICS = newGraphics( ); 
    RENDERER = newGraphics3DRenderer( WIDTH, HEIGHT, MAIN_GRAPHICS ) ;
    MAIN_WINDOW = newWindow( 
        WindowPositionX, 0, WIDTH+14, HEIGHT+39, " Hello 3DCG ! " 
    ) ;
    MAIN_DISPLAY_LABEL = newGraphicsLabel( 0, 0, WIDTH, HEIGHT, MAIN_GRAPHICS ) ;
    addComponent( MAIN_DISPLAY_LABEL, MAIN_WINDOW );
    setGraphics3DDefaultEventHandler( RENDERER, MAIN_DISPLAY_LABEL );
    setGraphics3DColor( RENDERER, BG_RED, BG_GREEN, BG_BLUE, 255 );

}

/* ウィンドウを閉じた際に呼び出される関数 */

void onWindowClose( int id ) { ROOP = false ; } /* ループを脱出 */

/*==============================================*/

bool ROOP = true ;
float o=0.0, a=1.0 ;
float Slv = 2*cos( PI/4 ) ; float ISlv = cos( PI/4 ) ;
float Gld = 2*cos( PI/5 ) ; float IGld = Gld - 1.0 ;
float Plt = 2*cos( PI/6 ) ; float IPlt = tan( PI/6 ) ;
int O = newVector( o, o, o ) ; 
string RusenURL = "http://rusen.seesaa.net/" ;

int rrate = 20 ; /* １秒間にループを回る回数*sec */
float t = o ; /* 時刻カウンタ変数 */
float flowt = a ; /* 時間の流れの速さ */
float step = flowt/rrate ;
int picid = 10000*5 ; /* save id */
int picnumber = 1 ; /* file id */
int TIME_END = 2000 ; /* アニメーションの終了枚数 */

int MAIN_GRAPHICS, MAIN_WINDOW, MAIN_DISPLAY_LABEL, RENDERER ;
int WIDTH = (int)( 256*2.75 ) ; int HEIGHT = (int)( 256*2.75 ) ; /* 画面の縦横 */
int WindowPositionX = 100 ;

int BG_RED, BG_GREEN, BG_BLUE ; /* 背景色（1.0-0.0） */
{    
    float BG_BlackWhite = o ;
    BG_RED = (int)( 255*BG_BlackWhite ) ; 
    BG_GREEN = (int)( 255*BG_BlackWhite ) ; 
    BG_BLUE = (int)( 255*BG_BlackWhite ) ;
}

/*==============================================*/

G3D_INIT(); /* 3D画面を起動 */
hide();

int paralight = newLight( -2.0, 3.0, 5.0, 0.6 ) ; 
addLight( paralight, RENDERER );

int amblight = newAmbientLight( o, o, o, 0.6 ) ; 
addLight( amblight, RENDERER );

/*==============================================*/

int N_setup = 2 ; /* 設定数 */
int Opacity[N_setup]; /* 表不透明度 */
float Emissive[N_setup]; /* Emissive(1.0-0.0) */
float Diffractive[N_setup]; /* Diffractive(1.0-0.0) */
float Diffuse[N_setup]; /* Diffuse(1.0-0.0) */
float Specular_Angle[N_setup]; /* Specular angle(1.5-0.0) */
float Specular_Intensity[N_setup]; /* Specular ref(1.0-0.0) */
float Ambient[N_setup]; /* Ambient(1.0-0.0) */

{ 
    int i = 0 ;
    Opacity[i] = 255 ;
    Emissive[i] = 0.0 ; Diffractive[i] = 0.8 ; 
    Diffuse[i] = 1.0 ; Ambient[i] = 0.9 ;
    Specular_Angle[i] = 0.6 ; Specular_Intensity[i] = 0.5 ;
}
{ 
    int i = 1 ;
    Opacity[i] = 50 ;
    Emissive[i] = 0.6 ; Diffractive[i] = 0.3 ; 
    Diffuse[i] = 1.0 ; Ambient[i] = 0.5 ;
    Specular_Angle[i] = 1.5 ; Specular_Intensity[i] = 1.0 ;
}

/*==============================================*/

/* element */

int N = 3 ; /* characteristic number */
int N3 = 1 ; /* number of 3d element */
int N2V3 = 60 ; /* number of 2d element 各面に付ける三角錐側面総数 */
int N0V3 = 32 ; /* number of 0d element 含各面に付ける三角錐天頂点 */

/*==============================================*/

/* 座標系の生成と配置 */

/* bcd on gcd on hcd on icd */
int icd = newCoordinate() ; addCoordinate( icd, RENDERER ) ;
int hcd = newCoordinate() ; addCoordinate( hcd, RENDERER, icd ) ;
int gcd = newCoordinate() ; addCoordinate( gcd, RENDERER, hcd ) ;
int bcd = newCoordinate() ; addCoordinate( bcd, RENDERER, gcd ) ;

int bc[N3];
for ( int i=0; i<N3; i++ ) {
    bc[i] = newCoordinate() ; addCoordinate( bc[i], RENDERER, bcd );
}

int NCcd = 0 ; int Ccd[N3][NCcd]; /* Cylinder coordinate */
for ( int i=0; i<N3; i++ ) { for ( int j=0; j<NCcd; j++ ) {
    Ccd[i][j] = newCoordinate() ; addCoordinate( Ccd[i][j], RENDERER, bc[i] );
} }

int world = getWorldCoordinate( RENDERER ) ;
int screen = getScreenCoordinate( RENDERER ) ;
int txtcd = newCoordinate() ; addCoordinate( txtcd, RENDERER, screen );

/*==============================================*/

/* Vector */

/* 原点中心icosahedron頂点と各面に付けるpyramid天頂点ベクトル
0thはy軸上、icosahedron頂点は0th〜11th */

int VV[N0V3]; 

for ( int i=0; i<N0V3; i++ ) { VV[i] = newVector() ; }



void SetBaseVIcosaPyramid( int v[], float rad, float pyramidheight ) {

    float icosahedron_inrad = IPlt*( ( 7.0 - 4*Gld )^( -0.5 ) ) * rad ;

/* icosahedron v[0, 1, 2, 6, 7, 11] */
    SetBaseVIcosahedron( v, rad );

/* G centerof icosahedron face v[12, 17, 22, 27] */
    SetVTriangleGravity( v[12], v[0], v[1], v[2] );
    SetVTriangleGravity( v[17], v[1], v[2], v[6] );
    SetVTriangleGravity( v[22], v[2], v[6], v[7] );
    SetVTriangleGravity( v[27], v[6], v[7], v[11] );

    for ( int i=12; i<=27; i+=5 ) {
        setVectorLength( v[i], icosahedron_inrad + pyramidheight );
    }

}



void SetVIcosaPyramid( int v[], float rad, float pyramidheight ) {

    float icosahedron_inrad = IPlt*( ( 7.0 - 4*Gld )^( -0.5 ) ) * rad ;

/* icosahedron 12頂点 */
    SetVIcosahedron( v, rad );

/* G centerof icosahedron face */
    for ( int i=0; i<5; i++ ) {
        SetVTriangleGravity( v[12+i], v[0], v[1], v[2] );
        rotYVector( v[12+i], 2*PI/5 * i );
        SetVTriangleGravity( v[v[17+i], v[1], v[2], v[6] );
        rotYVector( v[17+i], 2*PI/5 * i );
        SetVTriangleGravity( v[v[22+i], v[2], v[6], v[7] );
        rotYVector( v[22+i], 2*PI/5 * i );
        SetVTriangleGravity( v[v[27+i], v[6], v[7], v[11] );
        rotYVector( v[27+i], 2*PI/5 * i );
    }

    for ( int i=12; i<32; i++ ) {
        setVectorLength( v[i], icosahedron_inrad + pyramidheight );
    }

}



void SetBaseVIcosahedron( int v[], float rad ) {

    float y = ( 2*Gld - 1.0 )/5 * rad ;
    float z = 2*y;
    V( v[0], o, rad, o );
    for ( int i=1; i<=2; i++ ) {
        V( v[i], o, y, z );
        rotYVector( v[i], 2*PI/5 * ( i-1 ) );
        V( v[5+i], o, -y, z );
        rotYVector( v[5+i], PI/5 + 2*PI/5 * ( i-1 ) );
    }
    V( v[11], o, -rad, o );
}



void SetVIcosahedron( int v[], float rad ) {
    float y = ( 2*Gld - 1.0 )/5 * rad ;
    float z = 2*y;
    V( v[0], o, rad, o );
    for ( int i=1; i<=5; i++ ) {
        V( v[i], o, y, z );
        rotYVector( v[i], 2*PI/5 * ( i-1 ) );
        V( v[5+i], o, -y, z );
        rotYVector( v[i], PI/5 + 2*PI/5 * ( i-1 ) );
    }
    V( v[11], o, -rad, o );
}

/*==============================================*/

/* Polygon */

int Tr[N3][N2V3];

for ( int i=0; i<N3; i++ ) { 
    for ( int j=0; j<N2V3; j++ ) {
        Tr[i][j] = newTrianglePolygon( o,o,o, o,o,o, o,o,o ) ;
    } 
}

for ( int i=0; i<N3; i++ ) { 
    for ( int j=0; j<N2V3; j++ ) {
        setPolygonCull( Tr[i][j], false, false );
        SPP( Tr[i][j], 0 );
        AP( Tr[i][j], bc[i] );
    }
}



void SetIcosaPyramidTriangle( int tr[][], int n3, int v[] ) {

/* icosahedron v[0, 1, 2, 6, 7, 11] 
G centerof icosahedron face v[12, 17, 22, 27] */

    for ( int j=0; j<5; j++ ) {

        SetTriangle( tr[n3][3*j + 0], v[12], v[0], v[1] );
        SetTriangle( tr[n3][3*j + 1], v[12], v[1], v[2] );
        SetTriangle( tr[n3][3*j + 2], v[12], v[2], v[0] );

        SetTriangle( tr[n3][3*j + 15 + 0], v[17], v[1], v[6] );
        SetTriangle( tr[n3][3*j + 15 + 1], v[17], v[6], v[2] );
        SetTriangle( tr[n3][3*j + 15 + 2], v[17], v[2], v[1] );

        SetTriangle( tr[n3][3*j + 2*15 + 0], v[22], v[6], v[7] );
        SetTriangle( tr[n3][3*j + 2*15 + 1], v[22], v[7], v[2] );
        SetTriangle( tr[n3][3*j + 2*15 + 2], v[22], v[2], v[6] );

        SetTriangle( tr[n3][3*j + 3*15 + 0], v[27], v[11], v[7] );
        SetTriangle( tr[n3][3*j + 3*15 + 1], v[27], v[7], v[6] );
        SetTriangle( tr[n3][3*j + 3*15 + 2], v[27], v[6], v[11] );

        if ( j>0 ) {
            for ( int k=0; k<4; k++ ) {
                for ( int l=0; l<3; l++ ) {
                    rotYPolygon( tr[n3][3*j + k*15 + l], 2*PI/5 * j );
                }
            }
        }
    }
}



void SetIcosaPyramidTriangle( 
    int tr[][], int n3, bool limited, int v[], float detachparameter 
) {

    float rad = getVectorLength ( v[0] ) ;

/* icosahedron v[0, 1, 2, 6, 7, 11] 
G centerof icosahedron face v[12, 17, 22, 27] */

    if ( limited == false ) {

        for ( int j=0; j<5; j++ ) {

            SetTriangle( tr[n3][3*j + 0], v[12], v[0], v[1] );
            SetTriangle( tr[n3][3*j + 1], v[12], v[1], v[2] );
            SetTriangle( tr[n3][3*j + 2], v[12], v[2], v[0] );
            if ( detachparameter != o ) {
                int detachv = newVector( v[12] ) ;
                setVectorLength( detachv, detachparameter * rad );
                movePolygon( tr[n3][3*j + 0], detachv );
                movePolygon( tr[n3][3*j + 1], detachv );
                movePolygon( tr[n3][3*j + 2], detachv );
            }

            SetTriangle( tr[n3][3*j + 15 + 0], v[17], v[1], v[6] );
            SetTriangle( tr[n3][3*j + 15 + 1], v[17], v[6], v[2] );
            SetTriangle( tr[n3][3*j + 15 + 2], v[17], v[2], v[1] );
            if ( detachparameter != o ) {
                int detachv = newVector( v[17] ) ;
                setVectorLength( detachv, detachparameter * rad );
                movePolygon( tr[n3][3*j + 15 + 0], detachv );
                movePolygon( tr[n3][3*j + 15 + 1], detachv );
                movePolygon( tr[n3][3*j + 15 + 2], detachv );
            }
    
            SetTriangle( tr[n3][3*j + 2*15 + 0], v[22], v[6], v[7] );
            SetTriangle( tr[n3][3*j + 2*15 + 1], v[22], v[7], v[2] );
            SetTriangle( tr[n3][3*j + 2*15 + 2], v[22], v[2], v[6] );
            if ( detachparameter != o ) {
                int detachv = newVector( v[22] ) ;
                setVectorLength( detachv, detachparameter * rad );
                movePolygon( tr[n3][3*j + 2*15 + 0], detachv );
                movePolygon( tr[n3][3*j + 2*15 + 1], detachv );
                movePolygon( tr[n3][3*j + 2*15 + 2], detachv );
            }
    
            SetTriangle( tr[n3][3*j + 3*15 + 0], v[27], v[11], v[7] );
            SetTriangle( tr[n3][3*j + 3*15 + 1], v[27], v[7], v[6] );
            SetTriangle( tr[n3][3*j + 3*15 + 2], v[27], v[6], v[11] );
            if ( detachparameter != o ) {
                int detachv = newVector( v[27] ) ;
                setVectorLength( detachv, detachparameter * rad );
                movePolygon( tr[n3][3*j + 3*15 + 0], detachv );
                movePolygon( tr[n3][3*j + 3*15 + 1], detachv );
                movePolygon( tr[n3][3*j + 3*15 + 2], detachv );
            }
    
            if ( j>0 ) {
                for ( int k=0; k<4; k++ ) {
                    for ( int l=0; l<3; l++ ) {
                        rotYPolygon( tr[n3][3*j + k*15 + l], 2*PI/5 * j );
                    }
                }
            }
        }

    } else {

        SetTriangle( tr[n3][0], v[12], v[0], v[1] );
        SetTriangle( tr[n3][1], v[12], v[1], v[2] );
        SetTriangle( tr[n3][2], v[12], v[2], v[0] );
        if ( detachparameter != o ) {
            int detachv = newVector( v[12] ) ;
            setVectorLength( detachv, detachparameter * rad );
            movePolygon( tr[n3][0], detachv );
            movePolygon( tr[n3][1], detachv );
            movePolygon( tr[n3][2], detachv );
        }
    }
}



void SetIcosaPyramidTriangleColor( 
    int tr[][], int n3, bool limited, int v[], int opacity 
) {

/* normal vector に基づいて面に色を付ける */

    int n[] = length( tr ) ; int n2 = n[0] ;
    int normalv[n2]; 

    if ( limited == false ) {

        for ( int i=0; i<60; i++ ) { normalv[i] = newVector() ; }
    
        for ( int i=0; i<5; i++ ) {
    
            normalv[3*i + 0*15 + 0] = GetNormalV( v[12], v[0], v[1] ) ;
            normalv[3*i + 0*15 + 1] = GetNormalV( v[12], v[1], v[2] ) ;
            normalv[3*i + 0*15 + 2] = GetNormalV( v[12], v[2], v[0] ) ;
    
            normalv[3*i + 1*15 + 0] = GetNormalV( v[17], v[1], v[6] );
            normalv[3*i + 1*15 + 1] = GetNormalV( v[17], v[6], v[2] );
            normalv[3*i + 1*15 + 2] = GetNormalV( v[17], v[2], v[1] );
    
            normalv[3*i + 2*15 + 0] = GetNormalV( v[22], v[6], v[7] );
            normalv[3*i + 2*15 + 1] = GetNormalV( v[22], v[7], v[2] );
            normalv[3*i + 2*15 + 2] = GetNormalV( v[22], v[2], v[6] );
    
            normalv[3*i + 3*15 + 0] = GetNormalV( v[27], v[11], v[7] );
            normalv[3*i + 3*15 + 1] = GetNormalV( v[27], v[7], v[6] );
            normalv[3*i + 3*15 + 2] = GetNormalV( v[27], v[6], v[11] );
    
            if ( i>0 ) {
                for ( int j=0; j<4; j++ ) {
                    for ( int k=0; k<3; k++ ) {
                        rotYVector( normalv[3*i + j*15 + k], 2*PI/5 * i );
                    }
                }
            }
        }
    
        float cx, cy, cz ; int nr, ng, nb ;
        int xax = newVector( -a, o, o ) ; rotYVector( xax, PI/12 );
        int yax = newVector( o, -a, o ) ; rotZVector( yax, PI/12 );
        int zax = newVector( o, o, -a ) ; rotXVector( zax, -PI/12 );
    
        for ( int i=0; i<n2; i++ ) {
    
            nb = (int)( 255 * ( 1.0 + VInPr( xax, normalv[i] ) ) / 2 ) ;
            nr = (int)( 255 * ( 1.0 + VInPr( yax, normalv[i] ) ) / 2 ) ;
            ng = (int)( 255 * ( 1.0 + VInPr( zax, normalv[i] ) ) / 2 ) ;
    
            setPolygonColor( tr[n3][i], nr, ng, nb, opacity );
        }

    } else {

        for ( int i=0; i<3; i++ ) { normalv[i] = newVector() ; }

        normalv[0] = GetNormalV( v[12], v[0], v[1] ) ;
        normalv[1] = GetNormalV( v[12], v[1], v[2] ) ;
        normalv[2] = GetNormalV( v[12], v[2], v[0] ) ;

        float cx, cy, cz ; int nr, ng, nb ;
        int xax = newVector( -a, o, o ) ; rotYVector( xax, PI/12 );
        int yax = newVector( o, -a, o ) ; rotZVector( yax, PI/12 );
        int zax = newVector( o, o, -a ) ; rotXVector( zax, -PI/12 );
    
        for ( int i=0; i<3; i++ ) {
    
            nb = (int)( 255 * ( 1.0 + VInPr( xax, normalv[i] ) ) / 2 ) ;
            nr = (int)( 255 * ( 1.0 + VInPr( yax, normalv[i] ) ) / 2 ) ;
            ng = (int)( 255 * ( 1.0 + VInPr( zax, normalv[i] ) ) / 2 ) ;
    
            setPolygonColor( tr[n3][i], nr, ng, nb, opacity );
        }

    }
}

/*==============================================*/

/* Pyramid */

/* 特徴的な形のときのpyramidの高さ */
float PH( float rad, string polyhedron_name ) { /* pyramid height */

    float icosa_edge = ( 2 * ( 2.0 + Gld )^( -0.5 ) ) * rad ;

    if ( polyhedron_name == "Dented icosahedron" ) {
        return -IPlt * ( 7.0 - 4*Gld )^( -0.5 ) * rad * 0.99999 ;
    } else
    if ( polyhedron_name == "Excavated icosahedron" ) {
        return -( Slv*IPlt ) * icosa_edge ;
    } else 
    if ( polyhedron_name == "Great dodecahedron" ) {
        return -IPlt*( 2.0 - Gld ) * icosa_edge ;
    } else
    if ( polyhedron_name == "Icosahedron" ) {
        return o ;
    } else
    if ( polyhedron_name == "Rhombic triacontahedron" ) {
        return ( IPlt/2 ) * ( 2.0 - Gld ) * icosa_edge ;
    } else
    if ( polyhedron_name == "Small triambic icosahedron" ) {
        return IPlt/( 2*Gld - 1.0 ) * icosa_edge ;
    } else
    if ( polyhedron_name == "Right angled pyramid" ) {
        return ISlv*IPlt * icosa_edge ;
    } else
    if ( polyhedron_name == "da Vinci's star" ) {
        return ( Slv*IPlt ) * icosa_edge ;
    } else
    if ( polyhedron_name == "Great stellated dodecahedron" ) {
        return IPlt * ( Gld +1.0 ) * icosa_edge ;
    } else { alert( "NG" ); return 10*a ; }

}



float Hdi = PH( a, "Dented icosahedron" ) ; 
float Hei = PH( a, "Excavated icosahedron" ) ; 
float Hgd = PH( a, "Great dodecahedron" ) ;
float Hi = PH( a, "Icosahedron" ) ;
float Hrt = PH( a, "Rhombic triacontahedron" ) ;
float Hsti = PH( a, "Small triambic icosahedron" ) ;
float Hra = PH( a, "Right angled pyramid" ) ;
float Hdv = PH( a, "da Vinci's star" ) ;
float Hgsd = PH( a, "Great stellated dodecahedron" ) ;

/*==============================================*/

/* 座標軸モデルを生成 */

int axis0 = newAxisModel( 5*a, 5*a, 5*a ) ;
int axis1 = newAxisModel( 3.5*a, 3.5*a, 3.5*a ) ;
int axis2 = newAxisModel( 2*a, 2*a, 2*a ) ;
int axis3 = newAxisModel( 1.5*a, 1.5*a, 1.5*a ) ;
int axis4 = newAxisModel( 0.5*a, 0.5*a, 0.5*a ) ;

/*==============================================*/

/* animation */

/* 動画への書き出しを制御するスイッチ（trueならON, falseならOFF） */
bool MOVIE = false ; 

/* 連番画像ファイルNo */
int time = 0 ; 

/* カウント */
int count = 0 ;

/*----------------------------------------------*/

/* 変数 */

/* 時刻受け渡し用の変数 */
float tc[20];
float t0=o, t1=o, dt=o, dt0=o, dt1=o, t2=o, t3=o ;

/* 位置、角度 */
float CamY = 0.0*a ; float CamZ = 20*a ; /* camera原点 */
float inix[N3+1][3];
float Grav[3] = o ;
float aa[N3+1] = o , ba[N3+1] = o , ga[N3+1] = o ;
int Vi[N3+1]; int Vt[N3+1]; int Vf[N3+1];
int Ve[N3+1];
for ( int i=0; i<=N3; i++ ) {
    Vi[i] = newVector() ; Vt[i] = newVector() ; Vf[i] = newVector() ;
    Ve[i] = newVector() ;
}

/* その他の変数 */
float Graphic_Magnification = 1000.0 ;
int rusen = SetTextLowLeft( RusenURL, Graphic_Magnification, -0.0025 ) ;

/*==============================================*/

/* GUI Component */

int WINDOW; int LABEL[3];

int N_para = length(LABEL) ; int SLIDER[N_para]; int Check; 

bool Limited = false ;
double p[N_para] = o ; p[0] = Hgd ; p[2] = 255.0 ; /* p[2]は不透明度 */

string C_text; string L_text[N_para]; 
{
    C_text = "変形、移動させる面を限定する" ;
    L_text[0] = "角錐の高さ" ; 
    L_text[1] = "角錐間の距離" ; 
    L_text[2] = "面の透明度" ; 
}



void createSettingWindow() {

    int nl = length(LABEL) , ns = nl ;
    int L_x = 15 , L_w = 280 ; 
    int L_h = 15 ; int L_yspace = 15 ; int L_y[nl];
    int S_x = L_x , S_w = L_w, S_h = L_h , S_yspace = 5 ; int S_y[ns];
    int C_x = L_x , C_w = L_w , C_y = 20 , C_h = 15 , C_yspace = L_yspace ;
    {
        int initial_L_y = C_y + C_h + L_yspace + 10;
        for ( int i=0; i<nl; i++ ) {
            L_y[i] = initial_L_y + ( L_h + L_yspace + S_h + S_yspace ) * i ;
            S_y[i] = L_y[i] + L_h + S_yspace ;
        }
    }

    int W_x = WindowPositionX + WIDTH + 12 ;
    int W_y = 0 ;
    int W_w = L_w + 40 ;
    int W_h = S_y[ns-1] +  S_h + 70 ;

    {
        string W_text = "Setting Window" ;
        WINDOW = newWindow( W_x, W_y, W_w, W_h, W_text );

        Check = newCheckBox( C_x, C_y, C_w, C_h, C_text, false ); 
        addComponent( Check, WINDOW );

        for ( int i=0; i<nl; i++ ) {
            LABEL[i] = newTextLabel( L_x, L_y[i], L_w, L_h, L_text[i] );
            addComponent( LABEL[i], WINDOW );
            SLIDER[i] = newHorizontalSlider( S_x, S_y[i], S_w, S_h, Hgd );
            addComponent( SLIDER[i], WINDOW );
        }
    }

    paintComponent( WINDOW );
}


/*==============================================*/

/* event */


double StepPH( double var ) {

    double ph , stillrange ;
    int num_section =5 ;
    double x[num_section];
    {
        stillrange = 1.0 / 2 ;

        for ( int i=0; i<num_section; i++ ) {
            x[i] = var * num_section - i ;
            x[i] = ( x[i] - stillrange/2 ) / (1.0 - stillrange ) ;
            x[i] = Ft( x[i] ) ;
        }
    }
    ph = Hgd*( 1.0 - x[0] ) + Hi*x[0]*( 1.0 - x[1] ) 
            + Hrt*x[1]*( 1.0 - x[2] ) + Hsti*x[2]*( 1.0 - x[3] )
            + Hdv*x[3]*( 1.0 - x[4] ) + Hgsd*x[4] ;

    return ph ;

}



void onSliderMove( int id, float value ) {

    if ( id == SLIDER[0] ) {

        p[0] = StepPH( value );

        if ( p[0] == Hgd ) {
            L_text[0] = "大十二面体(Great dodecahedron)" ; 
        } else if ( p[0] < Hi ) {
            L_text[0] = "大十二面体 <=====> 正二十面体" ; 
        } else if ( p[0] == Hi ) {
            L_text[0] = "正二十面体(Icosahedron)" ; 
        } else if ( p[0] < Hrt ) {
            L_text[0] = "正二十面体 <=====> 菱形三十面体" ; 
        } else if ( p[0] == Hrt ) {
            L_text[0] = "菱形三十面体(Rhombic triacontahedron)" ; 
        } else if ( p[0] < Hsti ) {
            L_text[0] = "菱形三十面体 <=====> 六十面体" ; 
        } else if ( p[0] == Hsti ) {
            L_text[0] = "六十面体(Small triambic icosahedron)" ; 
        } else if ( p[0] < Hdv ) {
            L_text[0] = "六十面体 <=====> ダ・ヴィンチの星" ; 
        } else if ( p[0] == Hdv ) {
            L_text[0] = "ダ・ヴィンチの星(英語名不明)" ; 
        } else if ( p[0] < Hgsd ) {
            L_text[0] = "ダ・ヴィンチの星 <=====> 大星型十二面体" ; 
        } else if ( p[0] == Hgsd ) {
            L_text[0] = "大星型十二面体(Great stellated dodecahedron)" ; 
        } 

        SetBaseVIcosaPyramid( VV, a, p[0] );
        SetIcosaPyramidTriangle( Tr, 0, Limited, VV, p[1] );
        SetIcosaPyramidTriangleColor( Tr, 0, Limited, VV, p[2] );

    } else if ( id == SLIDER[1] ) {

        p[1] = value ;
        digit( 3 );
        varfloat q = ( 1.0 + p[1] ) ;
        L_text[1] = "角錐間の距離 = " + q + " 倍" ; 

        SetBaseVIcosaPyramid( VV, a, p[0] );
        SetIcosaPyramidTriangle( Tr, 0, Limited, VV, p[1] );
        SetIcosaPyramidTriangleColor( Tr, 0, Limited, VV, p[2] );

    } else if ( id == SLIDER[2] ) {

        double r = 1.0 - value ;
        p[2] = (int)( 255 * r ) ;
        L_text[2] = "面の透明度 = " + (int)( 100*value ) + " %" ; 

        SetIcosaPyramidTriangleColor( Tr, 0, Limited, VV, p[2] );

    }

    for ( int i=0; i < N_para ; i++ ) {
        setComponentText( LABEL[i], L_text[i] );
        paintComponent( LABEL[i] );
    }
}



void onCheckBoxClick( id, bool state ){

    if ( state == true ) {

        alert( linefeed()
            +"20個すべての三角錐の高さをゼロ（正二十面体の状態）に" + linefeed()
            +"リセットします。 その後は１つの三角錐のみに操作が限定" + linefeed()
            +"されます。" + linefeed()
         ) ;

    } else if ( state == false ) {

        alert( linefeed()
            +"20個すべての三角錐の高さをゼロ（正二十面体の状態）に" + linefeed()
            +"リセットします。 その後は操作の限定が解除されます。" + linefeed()
         ) ;
    }

    float p0reset = 0.2 ; 
    setComponentValue( SLIDER[0], p0reset );
    setComponentValue( SLIDER[1], o );
    setComponentValue( SLIDER[2], o );

    Limited = state ;

}

/*==============================================*/

/* animation Loop */

while ( ROOP ) 
{ 

t = t+step ; count = count+1 ;
if ( count%100 == 0 ) { print( count/10 + "/" ); }

/*==============================================*/

t1 = 2*step ;

/* cameraとworld座標系の位置関係 */
dt1 = o ; S() ; if ( Bt() ) {    
    CamZ = 7.25*a ;
    SCO( world, o, o, o ); SCEA( world, o, o, o );
    setCameraOrigin( world, o, CamY, CamZ ); 
    setCameraEulerAngle( world, o, o, o );
    spinXCamera( world, -atan( CamY/CamZ ) );
    setGraphics3DCenter( RENDERER, WIDTH/2, HEIGHT/2 );
    setGraphics3DMagnification( RENDERER, Graphic_Magnification );
//    setGraphics3DDistance(RENDERER, 10.0);
    setGraphics3DClipFront( RENDERER, o );
    setGraphics3DClipBack( RENDERER, -100000*a );
}

/*----------------------------------------------*/

/* 座標軸モデルの配置 */

S(); if ( Bt() ) {

/*
     addModel( axis0, RENDERER, bcd );

    addModel( axis1, RENDERER, bcd );

     addModel( axis2, RENDERER, bcd );

     addModel( axis3, RENDERER, bc[1] );
     addModel( axis4, RENDERER, bc[4] );
*/

}

/*----------------------------------------------*/

/* TextPolygon 

dt1 = 0.5 ; S(); if ( Bt() ) {
    SPCBk( rusen, 0 ); AP( rusen, screen );
}


D( o, 3.0 ); T(); if ( Bt() ) {
    SPCBk( rusen, (int)( 255*Tu() ) );
}


D( 1.0, 5.0 ); T(); if ( Bt() ) {
    SPCBk( rusen, (int)( 255*( 1.0-0.95*Tu() ) ) );
}
*/
/*==============================================*/

tc[0] = 2/10.0 ; 
tc[1] = 5/10.0 ; tc[2] = 8/10.0 ; 
tc[3] = 4.0 ; tc[4] = 5.0 ;

tc[10] = 10.0 ;

tanAtO = 0.8 ;

/*----------------------------------------------*/

D( o, tc[1] ); T(); if ( Bt() ) {
    SetBaseVIcosaPyramid( VV, a*Tu(), PH( a*Tu(), "Icosahedron" ) );
    SetIcosaPyramidTriangle( Tr, 0, false, VV, o );
    SetIcosaPyramidTriangleColor( Tr, 0, false, VV, Opacity[0] );
}


D( tc[0], tc[1] ); T(); if ( Bt() ) {
    SetBaseVIcosaPyramid( VV, a, Hi*TuR() + Hgd*Tu() );
    SetIcosaPyramidTriangle( Tr, 0, false, VV, o );
    SetIcosaPyramidTriangleColor( Tr, 0, false, VV, Opacity[0] );
}


D( tc[0], tc[1] ); T(); if ( Bt() ) {
    SetBaseVIcosaPyramid( VV, a, Hgd*TuR() + Hi*Tu() );
    SetIcosaPyramidTriangle( Tr, 0, false, VV, o );
    SetIcosaPyramidTriangleColor( Tr, 0, false, VV, Opacity[0] );
}


D( tc[0], tc[1] ); T(); if ( Bt() ) {
    SetBaseVIcosaPyramid( VV, a, Hi*TuR() + Hgsd*Tu() );
    SetIcosaPyramidTriangle( Tr, 0, true, VV, o );
    SetIcosaPyramidTriangleColor( Tr, 0, true, VV, Opacity[0] );
}


D( tc[0], tc[1] ); T(); if ( Bt() ) {
    SetBaseVIcosaPyramid( VV, a, Hgsd*TuR() + Hi*Tu() );
    SetIcosaPyramidTriangle( Tr, 0, true, VV, o );
    SetIcosaPyramidTriangleColor( Tr, 0, true, VV, Opacity[0] );
}


D( tc[0], tc[1] ); T(); if ( Bt() ) {
    SetBaseVIcosaPyramid( VV, a, Hi*TuR() + Hgsd*Tu() );
    SetIcosaPyramidTriangle( Tr, 0, true, VV, 0.5*Tu() );
    SetIcosaPyramidTriangleColor( Tr, 0, true, VV, Opacity[0] );
}


D( tc[0], tc[1] ); T(); if ( Bt() ) {
    SetBaseVIcosaPyramid( VV, a, Hgsd*TuR() + Hgd*Tu() );
    SetIcosaPyramidTriangle( Tr, 0, true, VV, 0.5 );
    SetIcosaPyramidTriangleColor( Tr, 0, true, VV, Opacity[0] );
}


D( tc[0], tc[1] ); T(); if ( Bt() ) {
    SetBaseVIcosaPyramid( VV, a, Hgd*TuR() + Hi*Tu() );
    SetIcosaPyramidTriangle( Tr, 0, true, VV, 0.5*TuR() );
    SetIcosaPyramidTriangleColor( Tr, 0, true, VV, Opacity[0] );
}


D( tc[0], tc[1] ); T(); if ( Bt() ) {
    SetBaseVIcosaPyramid( VV, a, Hi*TuR() + Hsti*Tu() );
    SetIcosaPyramidTriangle( Tr, 0, false, VV, o );
    SetIcosaPyramidTriangleColor( Tr, 0, false, VV, Opacity[0] );
}


D( tc[0], tc[1] ); T(); if ( Bt() ) {
    SetBaseVIcosaPyramid( VV, a, Hsti );
    SetIcosaPyramidTriangle( Tr, 0, false, VV, 0.5*Tu() );
    SetIcosaPyramidTriangleColor( Tr, 0, false, VV, Opacity[0] );
}


D( tc[0], tc[1] ); T(); if ( Bt() ) {
    SetBaseVIcosaPyramid( VV, a, Hsti );
    SetIcosaPyramidTriangle( Tr, 0, false, VV, 0.5*TuR() );
    SetIcosaPyramidTriangleColor( Tr, 0, false, VV, Opacity[0] );
}


D( tc[0], tc[1] ); T(); if ( Bt() ) {
    SetBaseVIcosaPyramid( VV, a, Hsti*TuR() + Hrt*Tu() );
    SetIcosaPyramidTriangle( Tr, 0, false, VV, o );
    SetIcosaPyramidTriangleColor( Tr, 0, false, VV, Opacity[0] );
}


D( tc[1], tc[2] ); T(); if ( Bt() ) {
    SetBaseVIcosaPyramid( VV, a, Hrt );
    SetIcosaPyramidTriangle( Tr, 0, false, VV, o );
    SetIcosaPyramidTriangleColor( Tr, 0, false, VV, 
        (int)( Opacity[0] * ( 1.0 - 0.5*Tu() ) )
    );
}


D( tc[0], tc[1] ); T(); if ( Bt() ) {
    SetBaseVIcosaPyramid( VV, a, Hrt*TuR() + Hgsd*Tu() );
    SetIcosaPyramidTriangle( Tr, 0, false, VV, o );
    SetIcosaPyramidTriangleColor( Tr, 0, false, VV, (int)( Opacity[0] * 0.5 ) )
    );
}


D( tc[0], tc[1] ); T(); if ( Bt() ) {
    SetBaseVIcosaPyramid( VV, a, Hgsd*TuR() + Hrt*Tu() );
    SetIcosaPyramidTriangle( Tr, 0, false, VV, o );
    SetIcosaPyramidTriangleColor( Tr, 0, false, VV, (int)( Opacity[0] * 0.5 ) )
    );
}


D( tc[0], tc[1] ); T(); if ( Bt() ) {
    SetBaseVIcosaPyramid( VV, a, Hrt );
    SetIcosaPyramidTriangle( Tr, 0, false, VV, o );
    SetIcosaPyramidTriangleColor( Tr, 0, false, VV, 
        (int)( Opacity[0] * ( 1.0 - 0.5*TuR() ) )
    );
}


D( tc[1], tc[1] ); T(); if ( Bt() ) {
    SetBaseVIcosaPyramid( VV, a, Hrt*TuR() + Hgd*Tu() );
    SetIcosaPyramidTriangle( Tr, 0, false, VV, o );
    SetIcosaPyramidTriangleColor( Tr, 0, false, VV, Opacity[0] );
}

/*==============================================*/

dt1 = o ; S(); if ( Bt() ) {
    createSettingWindow(); 
}

/*==============================================*/

/* TextPolygon 

D( o, 5.0 ); T(); if ( Bt() ) {
    SPCWt( rusen, (int)( 255*( 1.0 - 0.95*TuR() ) ) );
}

D( o, 3.0 ); T(); if ( Bt() ) {
    SPCWt( rusen, (int)( 255*( 1.0 - 0.95*Tu() ) ) );
}
*/
/*==============================================*/

/* 座標系の回転 */

t1 = t1 + 40.0 ;

{ float rot = 4/180.0 ; float cf; float bk;

    if ( t > t1+o ) {
        bk = ( Gt2( Ft( 1.01 - GCEAB( gcd )/PI ) ) )^4.0 ;
    } else { 
        bk = o ; 
    }
    cf = 1.0 - bk ; SYC( gcd, cf*rot );
}

/*==============================================*/

/* 描画 */

    sleep( 1000/rrate );  /* 毎回1/rrateミリ秒だけ停止（ウェイト）*/
    paintGraphics3D( RENDERER );  /* 3DCGを描画 */
    paintComponent( MAIN_DISPLAY_LABEL );  /* GUIの再描画 */
    paintComponent( MAIN_WINDOW );  /* GUIの再描画 */

/*----------------------------------------------*/

/* save picture */

/* 連番ファイル名で画像出力（ 動画スイッチがtrueのときのみ ）*/
    if ( MOVIE == true ) { 
        time = time + 1 ; picnumber = picid + time ; 
        exportGraphics(
         MAIN_GRAPHICS, "./movie/0" + picnumber + ".png", "PNG" 
        ) ;
    }

/*----------------------------------------------*/

/* TIME_ENDループ目でプログラムを強制終了 */

    if ( time == TIME_END ) { 
        alert( "上限枚数に達したため、プログラムを終了します。 時刻=" + time);
        exit();
    }



}

/*==============================================*/

exit(); /* アニメーションループを脱出するとプログラムを終了 */

/* キー入力があった際に呼び出される */
void onKeyDown( int id, string key ){

/* キー入力がスペースキーの場合 */
    if ( key == "SPACE" ) {
/* 動画スイッチがtrueのときはfalseにする */
        if ( MOVIE == true ) {
            MOVIE = false ; /* 動画スイッチをfalse（OFF）に */
            alert( "録画を一時停止しました。 時刻=" + time );
/* それ以外の場合、つまり動画スイッチがfalseのときはtrueにする */
        } else {
            alert( "録画を開始します。 時刻=" + time );
            MOVIE = true　;
/* 動画スイッチをtrue（ON）に　※メッセージ表示のタイムラグを考慮してこの順番 */
        }
    }
}

/*==============================================*/

/* function120515 */

/*----------------------------------------------*/

/* print */

void PrintlnVector( int v, string s ) {
    println( " " );
    println( "Vector " + s + " = ( "
        + getVectorX( v ) + ", "
        + getVectorY( v ) + ", "
        + getVectorZ( v ) + " )"
     ) ;
}

void PrintVector( int v, string s ) {
    println( "Vector " + s + " = ( "
        + getVectorX( v ) + ", "
        + getVectorY( v ) + ", "
        + getVectorZ( v ) + " )"
     ) ;
}

void PrintlnAngle( float angle, string s ) {
    println( " " );
    println( "Angle " + s + " = "
        + angle + ", " + angle*PI + ", " + angle*180 + " deg"
     ) ;

}

void PrintAngle( float angle, string s ) {
    println( "Angle "+ s + " = "
        + angle + ", " + angle*PI + ", " + angle*180 + " deg"
     ) ;
}

void PrintlnVectoralue( float value, string s ) {
    println( " " );
    println( "Value " + s + " = " + value );
}

void PrintValue( float value, string s ) {
    println( "Value " + s + " = " + value );
}

void PrintlnInteger( int integer, string s ) {
    println( " " );
    println( "Inteter " + s + " = " + integer );
}

void PrintInteger( int integer, string s ) {
    println( "Integer " + s + " = " + integer );
}

/*----------------------------------------------*/

/* 時刻 */

void T() { t0 = t1+dt1 ; t1 = t0+dt0 ; }
void T2() { t0 = t2 ; t1 = t3 ; }
void S() { t0 = t1+dt1 ; t1 = t0+step ; }
void D( float delt1, float delt0 ) { dt1 = delt1 ; dt0 = delt0 ; }

/* Ft(var)---var<0で0、var>1で1、それ以外はvarと等しい値を返す関数 */
float Ft( float var ) {
    float value;
    if( var <= o ) { 
        value = o ; 
    } else if ( ( var>o ) && ( var<1.0 ) ) { 
        value = var ; 
    } else { 
        value = 1.0 ; 
    }
    return value ;
}

float Tu() {
    float var = ( t-t0 )/( t1-t0-step ) ;
    if ( t > t1-step ) { var=1.0 ; } /*分母の-step追加120418*/
//    if(var>0.98){print("---"+Ft(var)+" at "+t+"---");}
    return Ft( var ) ;
}

float TuR() { return 1.0 - Tu() ; }

/* Su()---周期１で0-1-0 */
float Su( float var ) { 
    float value = ( 1.0-cos( 2*PI*var ) )/2 ;
    return value ;
}

float SuR( float var ) {
    return 1.0 - Su( var ) ;
}

/* Gt(var)---Ft(var)を滑らかにした関数 */
float Gt1( float var ) {  /* sin関数 */
    return 0.5*( 1.0 + sin( PI*Ft( var ) - 0.5*PI ) ) ;
}

float tanAtO=1.5; /* ３次関数の中心点での微分係数。0.8がちょうどよい */
float Yt( float var ) {
    return 
     ( ( 1.0 - tanAtO )*( 2*var - 1.0 )^3 + tanAtO*( 2*var - 1.0 ) + 1.0 )/2.0 ;
}

float Gt( float var ) { return Gt1( Yt( var ) ) ; }

float Gt2( float var ) { /* sin逆関数 */
    return ( 1/PI )*asin( 2*var - 1.0 ) + 1/2.0 ;
}

float Zt( float var ) { /* lemni型関数 */
    return ( 1/PI )*( 2*var - 1.0 )*( 1.0 - ( 2*var - 1.0 )^2 )^( 1.0/2.0 ) ;
} 
float Gt3( float var ) { return Gt2( var ) + Zt( var ) ; } /* 半円の積分 */

/* Tu()を滑らかにした関数。t0<=t<=t1で0<=Tg()<=1 */
float Tg() { return Gt( Tu() ) ; }

float TgR() { return 1.0 - Tg() ; }

bool Bt() { return ( t>=t0 ) && ( t<t1 ) ; }

bool Bs() { return t < t0+step ; }

bool Bt2() { return ( t>=t2 ) && ( t<t3 ) ; }

void Q( float var1, float var2, int xvar ) {
    if ( (t>=var1) && (t<var2) ) {
        step = xvar/rrate ;
    } else {
        step = 1.0/rrate; 
    }
}

/*----------------------------------------------*/

/* angle */

float GCEAA( int coord ) { return getCoordinateEulerAngleAlpha( coord ) ; }
float GCEAB( int coord ) { return getCoordinateEulerAngleBeta( coord ) ; }
float GCEAG( int coord ) { return getCoordinateEulerAngleGamma( coord ) ; }

int GCEAV( int coord ) {
    int av = newVector() ;
    setVector( av, GCEAA( coord )/PI, GCEAB( coord )/PI, GCEAG( coord )/PI ) ;
    return av ;
}

void GCEAV( int v, int cd ) {
    float aangle, bangle, gangle ;
    aangle = GCEAA( cd )/PI ; 
    bangle = GCEAB( cd )/PI ; 
    gangle = GCEAG( cd )/PI ;
    setVector( v, aangle, bangle, gangle );
}

void GCEA( int cd[], int i ) {
    aa[i] = GCEAA( cd[i] )/PI ; 
    ba[i] = GCEAB( cd[i] )/PI ; 
    ga[i] = GCEAG( cd[i] )/PI ;
}

void SCEA( int coord, float aangle ,float bangle, float gangle ) {
    setCoordinateEulerAngle( coord, PI*aangle, PI*bangle, PI*gangle ) ;
}

void SCEA( int coord, float angle[] ) {
    setCoordinateEulerAngle( coord, PI*angle[0], PI*angle[1], PI*angle[2] ) ;
}

void SCEA( int coord, int av ) {
    setCoordinateEulerAngle( coord,
     PI*getVectorX( av ), PI*getVectorY( av ), PI*getVectorZ( av )
     ) ;
}

void RC( int coord, float angle, 
 float axx, float axy, float axz,
 float ox, float oy, float oz )
{
    rotCoordinate( coord, angle*PI, axx, axy, axz, ox, oy, oz ) ;
}

void RVC(int coord, float angle, 
    float axx, float axy, float axz,
    float bxx, float bxy, float bxz){
    rotCoordinate(coord, angle*PI, axx-bxx, axy-bxy, axz-bxz, bxx, bxy, bxz);}
void RXC(int coord, float angle){
    rotXCoordinate(coord, angle*PI);}
void RYC(int coord, float angle){
    rotYCoordinate(coord, angle*PI);}
void RZC(int coord, float angle){
    rotZCoordinate(coord, angle*PI);}
void SXC(int coord, float angle){
    spinXCoordinate(coord, angle*PI);}
void SYC(int coord, float angle){
    spinYCoordinate(coord, angle*PI);}
void SZC(int coord, float angle){
    spinZCoordinate(coord, angle*PI);}

void ARC( int coord, float angle, int Ovector, int Pvector )
{ /* ベクトルOPを軸とする回転 */
    int axisvector = newVector() ;
    VDff( axisvector, Pvector, Ovector ) ;
    rotCoordinate( coord, angle*PI, axisvector, Ovector );
}

/*----------------------------------------------*/

/* position */

float GCOX(int coord){return getCoordinateOriginX(coord);}
float GCOY(int coord){return getCoordinateOriginY(coord);}
float GCOZ(int coord){return getCoordinateOriginZ(coord);}
float[] GCO(int coord){return getCoordinateOrigin(coord);}

void GCOV( int v, int cd ) {
    setVector( v, GCOX( cd ), GCOY( cd ), GCOZ( cd ) );
}

int GCOV(int cd){
    int v=newVector();
    setVector(v, 
     getCoordinateOriginX(cd), getCoordinateOriginY(cd), getCoordinateOriginZ(cd)
    );
    return v;
}

void SCO(int coord, float ox, float oy, float oz){
    setCoordinateOrigin(coord, ox, oy, oz);}

void SCO(int cd, int v){
    setCoordinateOrigin(cd, v);
}

void SCO(int cd, float x[]){
    setCoordinateOrigin(cd, x[0], x[1], x[2]);
}

/* set camera */
void SetCamT( float ox, float oy, float oz ) {
    float cx, cy, cz ;
    if ( t < t0+step ) {
        cx = -getCoordinateOriginX( world ) ;
        cy = -getCoordinateOriginY( world ) ;
        cz = -getCoordinateOriginZ( world ) ;
    }
    SetCamOrigin( cx*TgR() + ox*Tg() , cy*TgR() + oy*Tg() , cz*TgR() + oz*Tg() ) ;
}

/* set camera origin */
void SetCamOrigin( float vx, float vy, float vz ) {
    setCameraOrigin( world, vx, vy, vz ) ;
}

/* G-Center */

void GetCoordinateG( int cd[], int m, int n ) {
    float smmtn[3] ; smmtn = o ;
    for ( int i=m; i<=n; i++ ) {
        smmtn[0] = smmtn[0] + GCOX( cd[i] ) ;
        smmtn[1] = smmtn[1] + GCOY( cd[i] ) ;
        smmtn[2] = smmtn[2] + GCOZ( cd[i] ) ;
    }
    Grav = smmtn/( n-m+1 ) ;
}

/*----------------------------------------------*/

/* base */

float[] GCBX(int coord){return getCoordinateBaseX(coord);}
float[] GCBY(int coord){return getCoordinateBaseY(coord);}
float[] GCBZ(int coord){return getCoordinateBaseZ(coord);}

/*----------------------------------------------*/

/* vector */

void V(int v, int v0){
    setVector(v, v0);
}

void V(int v, float x, float y, float z){
    setVector(v, x, y, z);
}

void V( int v, int i, int j, int k, float pitch, float shift ) {
    setVector( v, pitch*i-shift, pitch*j-shift, pitch*k-shift );
}

void V( int v, float var[] ) {
    setVector( v, var );
}

int V( int ix, int iy, int iz, float pitch, float shift ) {
    int v = newVector() ;
    setVector( v, pitch*ix-shift, pitch*iy-shift, pitch*iz-shift );
    return v ;
}

int V( float x, float y, float z ) {
    int v = newVector( x, y, z ) ;
    return v ;
}

int V( int v ) { 
    int vector = newVector( v ) ;
    return vector ;
}

/* vector multiplication */
void VMlt(int vid, float var){scaleVector(vid, var, var, var);}

void VMlt(int v, int ov, float var){
    setVector(v, ov); VMlt(v, var);
}

void VInDv(int v, int v0, int v1, float var){/* v0, v1間をvar:1-varに内分する点のvectorをvに代入 */
    VDff(v, v1, v0);
    VMlt(v, var); VDgn(v, v0, v);
}

int VInDv(int v0, int v1, float var){
    int v=newVector();
    VDff(v, v1, v0);
    VMlt(v, var); VDgn(v, v0, v);
}

/* vector diffrence */
void VDff(int difvcid, int endvcid, int intlvcid){
    setVector(difvcid,
        getVectorX(endvcid)-getVectorX(intlvcid),
        getVectorY(endvcid)-getVectorY(intlvcid),
        getVectorZ(endvcid)-getVectorZ(intlvcid)
    );
}

int VDff( int endvcid, int intlvcid ) {
    int v = newVector() ;
    setVector( v,
     getVectorX( endvcid ) - getVectorX( intlvcid ) ,
     getVectorY( endvcid ) - getVectorY( intlvcid ) ,
     getVectorZ( endvcid ) - getVectorZ( intlvcid )
    ) ;
    return v ;
}

/* vector diagonal */
void VDgn(int diagonalvcid, int vc1, int vc2){
    setVector(diagonalvcid,
        getVectorX(vc1)+getVectorX(vc2),
        getVectorY(vc1)+getVectorY(vc2),
        getVectorZ(vc1)+getVectorZ(vc2)
    );
}

/* vector diagonal */
int VDgn(int vc1, int vc2){
    int v=newVector();
    setVector(v,
        getVectorX(vc1)+getVectorX(vc2),
        getVectorY(vc1)+getVectorY(vc2),
        getVectorZ(vc1)+getVectorZ(vc2)
    );
    return v;
}

/* Inner product */
float VInPr( int v1, int v2 ) {
    return getVectorInnerProduct( v1, v2 ) ;
}

/* get angle between 2 vectors */
float GtVcCs(int vc1, int vc2){
    float ipr=getVectorInnerProduct(vc1, vc2);
    float len1=getVectorLength(vc1); //PrintValue(len1, "len1");
    float len2=getVectorLength(vc2); //PrintValue(len2, "len2");
    float costh=ipr/len1/len2;
    return costh;
}
float GtVcSn(int vc1, int vc2){
    int cv=newVector();
    getVectorCrossProduct(vc1, vc2, cv);
    return getVectorLength(cv)/getVectorLength(vc1)/getVectorLength(vc2);
}

void AV(int v, int cd){
    addVector(v, RENDERER, cd);
}
void RMV(int v, int cd){
    removeVector(v, RENDERER, cd);
}

void TRV( int tv, int tcd, int ov, int ocd ) {
    int copyv = newVector( ov ) ;
    AV( ov, ocd );
    transformVector( ov, copyv, tcd );
    setVector( tv, copyv );
    RMV( ov, ocd );
}
    
int TRV(int tcd, int ov, int ocd){
    int copyv=newVector(ov);
    AV(ov, ocd);
    transformVector(ov, copyv, tcd);
    RMV(ov, ocd);
    return copyv;
}

float GetDHAngle(int u0, int u1, int u2, int v0, int v1, int v2){
    float cosangle=o, angle=o; /*二面角 */
    int u01, u02, v01, v02; /* 0を始点とするベクトル */
    u01=VDff(u1, u0); u02=VDff(u2, u0);
    v01=VDff(v1, v0); v02=VDff(v2, v0);
    int nu=newVector(); int nv=newVector(); /* normal vector */
    getVectorCrossProduct(u01, u02, nu); PrintlnVector(nu, "Normal_Vector_1");
    getVectorCrossProduct(v01, v02, nv); PrintVector(nv, "Normal_Vector_2");
    cosangle=GtVcCs(nu, nv);
    PrintlnAngle(acos(cosangle)/PI, "cos(th)");
    float dhangle=1.0-acos(cosangle)/PI;
    PrintAngle(dhangle, "Dihedralangle");
    return 1.0-acos(cosangle)/PI;
}

int GetNormalV( int pv1, int pv2, int pv3 ) {
    int v = newVector() ;
    int dv1 = VDff( pv2, pv1 ) ; int dv2 = VDff( pv3, pv2 ) ;
    getVectorCrossProduct( dv1, dv2, v );
    setVectorLength( v, 1.0 );
    return v ;
}

void SetVGravity( int gv, int v[] ) {
    int n = length( v ) ; int sumv = newVector( O ) ;
    for ( int i=0; i<n; i++ ) {
        VDgn( sumv, sumv, v[i] );
    }
    VMlt( gv, sumv, 1.0/n );
}

void SetVTriangleGravity( int gv, int v1, int v2, int v3 ) {
    int sumv = newVector() ;
    VDgn( sumv, v1, v2 ); VDgn( sumv, sumv, v3 );
    VMlt( gv, sumv, 1.0/3 );
}

/*----------------------------------------------*/

/* set polygon/model color */

void SPC(int polygon, int r, int g, int b, int op){
    setPolygonColor(polygon, r, g, b, op);
}

void SPC( int polygon, int opacity, float color ) {
    int rcolor = Color( 0, 3, color ) ;
    int gcolor = Color( 0, 3, color - 1.0/3.0 ) ; 
    int bcolor = Color( 0, 3, color + 1.0/3.0 ) ;
    setPolygonColor( polygon, rcolor, gcolor, bcolor, opacity );
}

void SPCWt(int polygon, int opacity){
    setPolygonColor(polygon, 255, 255, 255, opacity);
}

void SPCBk(int polygon, int opacity){
    setPolygonColor(polygon, 0, 0, 0, opacity);
}

void SPCRd(int polygon, int opacity){
    setPolygonColor(polygon, 255, 0, 0, opacity);
}

void SPCGn(int polygon, int opacity){
    setPolygonColor(polygon, 0, 255, 0, opacity);
}

void SPCBl(int polygon, int opacity){
    setPolygonColor(polygon, 0, 0, 255, opacity);
}

void SMC(int model, int r, int g, int b, int op){
    setModelColor(model, r, g, b, op);
}

int Color( int Nth, int NofC, float Offset ) {
    float x; float var = (float)Nth / (float)NofC ;
    var = var + Offset ;
    while ( var < o ) { var = var + 1.0 ; }
    while ( var > 1.0 ) { var = var - 1.0 ; }
     if ( ( var>=0 ) && ( var<1.0/6.0 ) ) { x = 1.0 ; }
    else if ( ( var>=1.0/6.0 ) && ( var<1.0/3.0 ) ) { x = -6*var + 2.0 ; }
    else if ( ( var>=1.0/3.0 ) && ( var<2.0/3.0 ) ) { x = o ; }
    else if ( ( var>=2.0/3.0 ) && ( var<5.0/6.0 ) ) { x = 6*var - 4.0 ; }
    else { x = 1.0 ; }
    x = 255*x ;
    return (int)x ; }

void SPP( int polygon, int i ) {
    setPolygonEmissive    ( polygon, Emissive[i] ) ;
    setPolygonSpecular    ( polygon, Specular_Intensity[i], Specular_Angle[i] ) ;
    setPolygonDiffractive( polygon, Diffractive[i] ) ;
    setPolygonDiffuse    ( polygon, Diffuse[i] ) ;
    setPolygonAmbient    ( polygon, Ambient[i] ) ;
}

void SMP( int model, int i ) {
    setModelEmissive    ( model, Emissive[i] ) ;
    setModelSpecular    ( model, Specular_Intensity[i], Specular_Angle[i] ) ;
    setModelDiffractive    ( model, Diffractive[i] ) ;
    setModelDiffuse        ( model, Diffuse[i] ) ;
    setModelAmbient        ( model, Ambient[i] ) ;
}

/*----------------------------------------------*/

/* add, remove */

void AP(int polygon, int cd){
    addPolygon(polygon, RENDERER, cd);
}

void RP(int polygon, int cd){
    removePolygon(polygon, RENDERER, cd);
}

void AM(int modelid, int cdid){
    addModel(modelid, RENDERER, cdid);
}

/*----------------------------------------------*/

/* TextPolygon */

int SetTextLowLeft( string s, float mag, float z ) {
    float size = -80*z/mag ;
    float x = -size*WIDTH/165 ; float y = x*HEIGHT/WIDTH ;
    int txtpolygon = newTextPolygon( x, y, z, size, s ) ;
    movePolygon( txtpolygon, x, y, z );
    return txtpolygon ;
}

/*----------------------------------------------*/

/* Sylinder */

/* set Cylinder */
void SetCylinder(int cylid, int coordid, int intlv, int endv, float rad){
    int direction=newVector();
    VDff(direction, intlv, endv);
    SetZax(coordid, direction); /* z軸方向セット */
    setModelSize(cylid, 
        rad, rad, getVectorLength(direction)
    ); /* 長さをセット */
    setCoordinateOrigin(coordid, endv);
}

/* set Cylinder and Coordinate */
void SetCylinderCoordinate( 
 int cylnid, float rad, int coordid, int intlv, int endv
) {
    int direction = newVector() ;
    VDff( direction, intlv, endv );
    SetZax( coordid, direction ); /* z軸方向セット */
    setModelSize( cylnid, rad, rad, getVectorLength( direction ) ); /* 長さをセット */
    setCoordinateOrigin( coordid, endv ); /* 座標系原点をendvと一致させる */
}

/* set z axis */
void SetZax( int cdid, int directionvc ) {
    float vx = getVectorX( directionvc ) ;
    float vy = getVectorY( directionvc ) ;
    float vz = getVectorZ( directionvc ) ;
    float azimuth; /* on zx plane */
    float poler; /* from zx plane to y axis */
    if ( vz == o ) { 
        azimuth = PI/2 ; 
    } else { 
        azimuth = acos( vz/( ( vx^2 + vz^2 )^0.5 ) ) ; 
    }
    if ( vx < 0 ) { azimuth = -azimuth ; }
    if ( vx^2 + vz^2 == o ) { 
        poler = PI/2 ; 
    } else { 
        poler = PI/2 - acos( vy/( ( vx^2 + vy^2 + vz^2 )^0.5 ) ) ; 
    }
    setCoordinateEulerAngle( cdid, o, o, o );
    spinYCoordinate( cdid, azimuth );
    spinXCoordinate( cdid, -poler );
}

/*----------------------------------------------*/

/* set Sphere */

void SetSphere( int Sphid, float rad ) {
    setModelSize( Sphid, rad, rad, rad );
}

/*----------------------------------------------*/

/* set Polygon vector */

void SetLineV( int ln, int v1, int v2 ) {
    setPolygonVector( ln, v1, v2 );
}

void SetPointV( int point, int v ) {
    setPolygonVector( point, v );
}

/* for triangle polygon */

void SetTriangle( int polygon1, int polygon2, int polygon3, 
 int vc0, int vc1, int vc2, int vc3 )
{
    setPolygonVector( polygon1, vc0, vc1, vc2 );
    setPolygonVector( polygon2, vc0, vc2, vc3 );
    setPolygonVector( polygon3, vc0, vc3, vc1 );
}

void SetTriangle( int polygon, int vc1, int vc2, int vc3 ) {
    setPolygonVector( polygon, vc1, vc2, vc3 );
}

void SetTriangle_withG( int pl1, int pl2, int pl3, int v1, int v2, int v3 ) {
    int gv = newVector() ;
    VDgn( gv, v1, v2 ); VDgn( gv, gv, v3 ); VMlt( gv, 1.0/3 );
    setPolygonVector( pl1, gv, v1, v2 );
    setPolygonVector( pl2, gv, v2, v3 );
    setPolygonVector( pl3, gv, v3, v1 );
}

/*==============================================*/