encode Shift_JIS;
/*
================================================
1040_stella octangula_01 / 120402
================================================
*/
//==============================================
import Graphics; import Graphics3D; import GUI; import Math ; int BG_RED = 255 ; int BG_GREEN = 255 ; int BG_BLUE = 255 ; 
//----------------------------------------------
int MAIN_GRAPHICS, MAIN_WINDOW, MAIN_DISPLAY_LABEL, RENDERER ; bool ROOP = true ;
//----------------------------------------------
int WIDTH; int HEIGHT;//画面の縦横
WIDTH=(int)(256*3.0); HEIGHT=(int)(256*2.25);
int WndPstX=840-WIDTH;
//----------------------------------------------
// ウィンドウの構築などの初期化処理を行う関数、メインプログラムから呼び出す
void G3D_INIT( ){MAIN_GRAPHICS = newGraphics( ) ; RENDERER = newGraphics3DRenderer( WIDTH, HEIGHT, MAIN_GRAPHICS ) ;
    MAIN_WINDOW = newWindow(WndPstX, 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 ) ;
    int light = newLight( 1.2, 1.5, 1.0, 0.8 ) ; addLight( light, RENDERER ) ;}
// ウィンドウを閉じた際に呼び出される関数
void onWindowClose( int id ){ROOP = false ;} //ループを脱出
hide();
//==============================================
float o=0.0, a=1.0;
float nbw=o;//背景色（1.0-0.0）
int rrate=20;//１秒間にループを回る回数*sec
float t=0.0;//時刻カウンタ変数
float flowt=1.0;//時間の流れの速さ
float step=flowt/(float)rrate;
int picid=10000*5;//save id
int picnumber=1;//file id
int TIME_END = 2000 ; // アニメーションの終了枚数
//----------------------------------------------
BG_RED =(int)255*nbw; BG_GREEN =(int)255*nbw; BG_BLUE =(int)255*nbw;
G3D_INIT() ; // 3D画面を起動
//==============================================
int Nre=2;//設定数
int Opcty[Nre]=255;//表不透明度
float Emssv[Nre]=0.1;//Emissive(1.0-0.0)
float Dffrctv[Nre]=0.5;//Diffractive(1.0-0.0)
float Dffs[Nre]=1.0;//Diffuse(1.0-0.0)
float SpclrAngl[Nre]=1.3;//Specular angle(1.5-0.0)
float SpclrRf[Nre]=1.0;//Specular ref(1.0-0.0)
float Ambnt[Nre]=0.0;//Ambient(1.0-0.0)
{int i=0;
    Opcty[i]=255;
    Emssv[i]=o; Dffrctv[i]=0.5; Dffs[i]=0.6; Ambnt[i]=0.2;
    SpclrAngl[i]=0.5; SpclrRf[i]=0.95;
}{int i=1;
    Opcty[i]=50;
    Emssv[i]=0.9; Dffrctv[i]=0.3; Dffs[i]=1.0; Ambnt[i]=0.5;
    SpclrAngl[i]=1.5; SpclrRf[i]=1.0;
}
//==============================================
float Gld=2*sin(0.3*PI); float Slv=2*sin(0.25*PI);
float IGld=Gld-1.0; float ISlv=sin(0.25*PI);
float ATGl=atan(Gld)/PI; float ATIG=atan(IGld)/PI;
float ATSl=atan(Slv)/PI; float ATIS=atan(ISlv)/PI;
float s=o*a; a=a-s;//aより一回り小さくして計算
int txt=newTextPolygon(o, o, o, 0.2*a, "http://rusen.seesaa.net/"); setPolygonColor(txt, 0, 0, 0, 0);
//==============================================
//element

int LineNumber=3;
int N3=1;//3d
int N2V3=8;//正八面体の面数
int ToctV2=6;//正八面体の面１枚当たりのtriangle Polygon
int TstrV2=4*3;//正八面体１枚当たりの星型化のための部分の三角形
int N0oct=3+1;//正八面体の１面当たりの頂点と面心点（重複あり）
int N0str=(3+1)*3;//正八面体の１面当たりの星型化のための部分の三角形
//Cylinder, Sphere
int NCr, NCz;//Cylinder
int NSPl, NSAz;//Sphere
int NCyOct; int NCyOctV3=12;//cylinder model for octahedron
int NCyStr; int NCyStrV3=72;//cylinder model for stellation
int NSpOct; int NSpOctV3=NCyOctV3+1;//Sphere model for octahedron
int NSpStr; int NSpStrV3=8*6;//Sphere model for stllation
int NSpV3=NSpOctV3+NSpStrV3;//Number of Sphere model
int NCyV3=NCyOctV3+NCyStrV3;//Number of Cylinder model

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

//bcd on gcd on hcd
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];
int NCcd=NSpV3+3*8; int Ccd[N3][NCcd];//Cylinder coordinate

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

for(int i=0; i<=N3-1; i++){for(int j=0; j<=NCcd-1; j++){
    Ccd[i][j]=newCoordinate(); addCoordinate(Ccd[i][j], RENDERER, bc[i]);
}}

//==============================================
//Polygon
int TOct[N3][N2V3][ToctV2];
for(int i=0; i<=N3-1; i++){for(int j=0; j<=N2V3-1; j++){for(int k=0; k<=ToctV2-1; k++){
    TOct[i][j][k]=newTrianglePolygon(o, o, o, o, o, o, o, o, o);
    setPolygonCull(TOct[i][j][k], false, false);
     setPolygonSortOffset(TOct[i][j][k], -0.51*a);
    SPPht0(TOct[i][j][k]);
}}}

int TStr[N3][N2V3][TstrV2];
for(int i=0; i<=N3-1; i++){for(int j=0; j<=N2V3-1; j++){for(int k=0; k<=TstrV2-1; k++){
    TStr[i][j][k]=newTrianglePolygon(o, o, o, o, o, o, o, o, o);
    setPolygonCull(TStr[i][j][k], false, false);
     setPolygonSortOffset(TStr[i][j][k], 0.3*a);
    SPPht1(TStr[i][j][k]);
}}}

//==============================================
//Model

NCr=30; NCz=8;
NCr=20; NCz=1;
float CyRd=0.05*a;
int Cyl[N3][NCyV3];
for(int i=0; i<=N3-1; i++){for(int j=0; j<=NCyV3-1; j++){
    Cyl[i][j]=newTubeModel(o, o, o, NCr, NCz);
    SMPht0(Cyl[i][j]);
}}

NSPl=40; NSAz=NSPl*2;
NSPl=20; NSAz=NSPl*2;
float SpRd=CyRd*2;
int Sph[N3][NSpV3];
for(int i=0; i<=N3-1; i++){for(int j=0; j<=NSpV3-1; j++){
    Sph[i][j]=newSphereModel(o, o, o, NSAz, NSPl);
     setModelSortOffset(Sph[i][j], o*a);
    SMPht0(Sph[i][j]);
}}

//==============================================
// 座標軸モデルを生成
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
float X0=0.0, Y0=0.0, Z0=0.0, X1=0.0, Y1=0.0, Z1=0.0;
int world = getWorldCoordinate(RENDERER);
bool MOVIE = false; // 動画への書き出しを制御するスイッチ（trueならON, falseならOFF）
int time = 0;
//カウント
int count=0;
//----------------------------------------------
//時刻受け渡し用の変数
float tCPini[20]=10000.0; float tCPfin[20]=10000.0;
float tCAini[20]=10000.0; float tCAfin[20]=10000.0;
float thPini[20]=10000.0; float thPfin[20]=10000.0;
float thAini[20]=10000.0; float thAfin[20]=10000.0;
float tgPini[20]=10000.0; float tgPfin[20]=10000.0;
float tgAini[20]=10000.0; float tgAfin[20]=10000.0;
float tbPini[20]=10000.0; float tbPfin[20]=10000.0;
float tbAini[20]=10000.0; float tbAfin[20]=10000.0;
int ti=0;
int stpcnt=1000;
float tc[20];
float t0=o, t1=o, dt=o, dt0=o, dt1=o, t2=o, t3=o;
//その他の変数
float c0=o;
float xt[3];
float rotY=-0.25*PI; float rotX=acos((2.0/3.0)^0.5);//bcd点心
float dy=0.0*a; float dz=20*a;//camera原点
float amp0=1000.0;
int PNum=10;
int idxi=0, idxj=0, idxk=0, idxl=0, idxm=0, idxn=0;
int cdx0=0, cdx1=0, cdx2=0, cdx3=0, cdx4=0;
int zron[6]; for(int j=0; j<=5; j++){if(j%3==0){zron[j]=1;}else{zron[j]=0;}}
//位置、角度
float inix[N3], iniy[N3], iniz[N3];
float gx[3]=o;
float aa[N3], ba[N3], ga[N3];
//==============================================
//GUI Component
//createSettingWindow();
int WINDOW;
int Prmtr0_SLIDER, Prmtr1_SLIDER, Prmtr2_SLIDER;
int SET_A_LABEL, SET_B_LABEL, SET_R_LABEL;
int GET_LABEL;
int GET_ANGLE_TITLE_LABEL, SET_ANGLE_TITLE_LABEL;

double Prm0 = 0.0;
double Prm1 = 0.0;

void createSettingWindow(){
//    int StWnPsY=HEIGHT+0;//39;
  WINDOW = newWindow( WndPstX+WIDTH+12, 0, 310, 180, "setting window" );

  SET_A_LABEL = newTextLabel( 30, 30, 310, 15, "紫面の変形");

  addComponent( SET_A_LABEL, WINDOW );
  Prmtr0_SLIDER = newHorizontalSlider( 30, 50, 240, 15, Prm0 );
  addComponent( Prmtr0_SLIDER, WINDOW );

  SET_B_LABEL = newTextLabel( 30, 85, 510, 15, "黄緑面の変形");
  addComponent( SET_B_LABEL, WINDOW );
  Prmtr1_SLIDER = newHorizontalSlider( 30, 105, 240, 15, Prm1 );
  addComponent( Prmtr1_SLIDER, WINDOW );

  paintComponent( WINDOW );
}

//octahedronの面のnormal vector
    int NrVc[8]; for(int i=0; i<=7; i++){NrVc[i]=newVector();}
    for(int i=0; i<=1; i++){for(int j=0; j<=1; j++){for(int k=0; k<=1; k++){
        Rds=2*a;
        setVector(NrVc[i+2*j+4*k], Rds*(-1)^i, Rds*(-1)^j, Rds*(-1)^k);
    }}}

for(int i=0; i<=7; i++){
    print("i="+i+"...");
    println(getVectorX(NrVc[i])+", "+getVectorY(NrVc[i])+", "+getVectorZ(NrVc[i]));
}

//octahedronのvertex vector
    int VrVc[8][3];
    for(int i0=0; i0<=1; i0++){for(int i1=0; i1<=1; i1++){for(int i2=0; i2<=1; i2++){
        int i=i0+2*i1+4*i2;
        float vx[3];
        vx[0]=getVectorX(NrVc[i]); vx[1]=getVectorY(NrVc[i]); vx[2]=getVectorZ(NrVc[i]);
        for(int j=0; j<=2; j++){
            if((i0+i1+i2)%2==0){
                VrVc[i][j]=newVector(zron[j]*vx[j], zron[j+2]*vx[j], zron[j+1]*vx[j]);
            }else{
                VrVc[i][j]=newVector(zron[j]*vx[j], zron[j+1]*vx[j], zron[j+2]*vx[j]);
            }
        }
    }}}

    for(int i=0; i<=7; i++){for(int j=0; j<=2; j++){
        print("i="+i+", j="+j+"...");
        println(getVectorX(VrVc[i][j])+", "+
            getVectorY(VrVc[i][j])+", "+
            getVectorZ(VrVc[i][j]));
    }}


void onSliderMove( int id, float value ){

  if( id==Prmtr0_SLIDER ){
    Prm0=value;
    setComponentText( SET_A_LABEL, "紫面の変形（0 〜 1） = "+Prm0);
    paintComponent( SET_A_LABEL );

    for(int n2=0; n2<=7; n2++){if((n2==0)||(n2==3)||(n2==5)||(n2==6)){for(int i=0; i<=2; i++){int n3=0;
        int j=i+1; if(j>2){j=j-3;}
        int k=j+1; if(k>2){k=k-3;}
        int l=NSpOctV3+6*n2;
        if(Prm0<1.0/100){
            SMCAuto(Sph[n3][l+2*i], Opcty[0], cdx1, cdx0, o);
            SMCAuto(Sph[n3][l+2*i+1], Opcty[0], cdx1, cdx0, o);
        }else{
            SMCAuto(Sph[n3][l+2*i], Opcty[0], cdx3, cdx0, o);
            SMCAuto(Sph[n3][l+2*i+1], Opcty[0], cdx3, cdx0, o);
        }
        setVector(IVc, VrVc[n2][i]); 
        VctDff(EVc, VrVc[n2][j], VrVc[n2][k]); 
        VctMlt(EVc, Prm0); VctDgn(EVc, IVc, EVc);
        StCylndr(Cyl[n3][NSpOctV3+2*i-1+6*n2], Ccd[n3][NSpOctV3+2*i+6*n2], IVc, EVc);
        setVector(IVc, VrVc[n2][j]); 
        VctDff(EVc, VrVc[n2][i], VrVc[n2][k]); 
        VctMlt(EVc, Prm0); VctDgn(EVc, IVc, EVc);
        StCylndr(Cyl[n3][NSpOctV3+2*i+6*n2], Ccd[n3][NSpOctV3+2*i+1+6*n2], IVc, EVc);
        float sx[3], ex[3];
        sx=GCO(Ccd[n3][NSpOctV3+2*i+6*n2]); setVector(IVc, sx);
        if(Prm0<1.0/100){ex=sx;}else{
            ex=GCO(Ccd[n3][NSpOctV3+2*i+1+6*n2]); 
        }
        setVector(EVc, ex);
        StCylndr(Cyl[n3][NSpV3+3*n2+i-1], Ccd[n3][NSpV3+3*n2+i], IVc, EVc);
        VctDgn(TVc0, VrVc[n2][i], VrVc[n2][j]);
        VctDgn(TVc0, TVc0, IVc); VctDgn(TVc0, TVc0, EVc); VctMlt(TVc0, 1.0/4);
        StTrngl0(TStr[n3][n2][4*i], TVc0, VrVc[n2][i], IVc);
        StTrngl0(TStr[n3][n2][4*i+1], TVc0, IVc, EVc);
        StTrngl0(TStr[n3][n2][4*i+2], TVc0, EVc, VrVc[n2][j]);
        StTrngl0(TStr[n3][n2][4*i+3], TVc0, VrVc[n2][j], VrVc[n2][i]);
    }}}

  }else if( id==Prmtr1_SLIDER ){

    Prm1 =value;
    setComponentText( SET_B_LABEL, "黄緑面の変形（0 〜 1） = "+Prm1);
    paintComponent( SET_B_LABEL );

    for(int n2=0; n2<=7; n2++){if((n2==1)||(n2==2)||(n2==4)||(n2==7)){for(int i=0; i<=2; i++){int n3=0;
        int j=i+1; if(j>2){j=j-3;}
        int k=j+1; if(k>2){k=k-3;}
        int l=NSpOctV3+6*n2;
        if(Prm1<1.0/100){
            SMCAuto(Sph[n3][l+2*i], Opcty[0], cdx1, cdx0, o);
            SMCAuto(Sph[n3][l+2*i+1], Opcty[0], cdx1, cdx0, o);
        }else{
            SMCAuto(Sph[n3][l+2*i], Opcty[0], cdx4, cdx0, o);
            SMCAuto(Sph[n3][l+2*i+1], Opcty[0], cdx4, cdx0, o);
        }
        setVector(IVc, VrVc[n2][i]); 
        VctDff(EVc, VrVc[n2][j], VrVc[n2][k]); 
        VctMlt(EVc, Prm1); VctDgn(EVc, IVc, EVc);
        StCylndr(Cyl[n3][NSpOctV3+2*i-1+6*n2], Ccd[n3][NSpOctV3+2*i+6*n2], IVc, EVc);
        setVector(IVc, VrVc[n2][j]); 
        VctDff(EVc, VrVc[n2][i], VrVc[n2][k]); 
        VctMlt(EVc, Prm1); VctDgn(EVc, IVc, EVc);
        StCylndr(Cyl[n3][NSpOctV3+2*i+6*n2], Ccd[n3][NSpOctV3+2*i+1+6*n2], IVc, EVc);
        float sx[3], ex[3];
        sx=GCO(Ccd[n3][NSpOctV3+2*i+6*n2]); setVector(IVc, sx);
        if(Prm1<1.0/100){ex=sx;}else{
            ex=GCO(Ccd[n3][NSpOctV3+2*i+1+6*n2]); 
        }
        setVector(EVc, ex);
        StCylndr(Cyl[n3][NSpV3+3*n2+i-1], Ccd[n3][NSpV3+3*n2+i], IVc, EVc);
        VctDgn(TVc0, VrVc[n2][i], VrVc[n2][j]);
        VctDgn(TVc0, TVc0, IVc); VctDgn(TVc0, TVc0, EVc); VctMlt(TVc0, 1.0/4);
        StTrngl0(TStr[n3][n2][4*i], TVc0, VrVc[n2][i], IVc);
        StTrngl0(TStr[n3][n2][4*i+1], TVc0, IVc, EVc);
        StTrngl0(TStr[n3][n2][4*i+2], TVc0, EVc, VrVc[n2][j]);
        StTrngl0(TStr[n3][n2][4*i+3], TVc0, VrVc[n2][j], VrVc[n2][i]);
    }}}

  }
}
//==============================================
int IVc=newVector(); int EVc=newVector();
float Rds, Dst;
int TVc0=newVector();
int TVc1=newVector(); int TVc2=newVector(); int TVc3=newVector();
//==============================================

void addSphStr(int n3, int n2, int nspv3){
    for(int i=nspv3; i<=nspv3+5; i++){
        SMCAuto(Sph[n3][i], Opcty[0], cdx1, cdx0, o);
        StSphr(Sph[n3][i]); AM(Sph[n3][i], Ccd[n3][i]);
        int j=(i+1-nspv3)/2; if(j>2){j=j-3;}
        SCO(Ccd[n3][i], 
            getVectorX(VrVc[n2][j]), getVectorY(VrVc[n2][j]), getVectorZ(VrVc[n2][j])
        );
    }
}

void addCylStr(int n3, int n2, int ncyv3){
    int j=(ncyv3-NSpOctV3+1)/6;
    int st3, st4;
    if((j==0)||(j==3)||(j==5)||(j==6)){st3=1; st4=0;}else{st3=0; st4=1;}
    for(int i=ncyv3; i<=ncyv3+5; i++){
        SMCAuto(Cyl[n3][i], Opcty[0], st3*cdx3+st4*cdx4, cdx0, o);
        AM(Cyl[n3][i], Ccd[n3][i+1]);
    }
    for(int i=0; i<=2; i++){
        int st3, st4;
        if((n2==0)||(n2==3)||(n2==5)||(n2==6)){st3=1; st4=0;}else{st3=0; st4=1;}
        SMCAuto(Cyl[n3][NSpV3+3*n2+i-1], Opcty[0], st3*cdx3+st4*cdx4, cdx0, o);
        int j=i+1; if(j>2){j=j-3;}
        setVector(IVc, VrVc[n2][i]);
        StCylndr(Cyl[n3][NSpV3+3*n2+i-1], Ccd[n3][NSpV3+3*n2+i], IVc, IVc);
        AM(Cyl[n3][NSpV3+3*n2+i-1], Ccd[n3][NSpV3+3*n2+i]);
    }
}

void addTrnStr(int n3, int n2){
    for(int i=0; i<=TstrV2-1; i++){
        int st3, st4;
        if((n2==0)||(n2==3)||(n2==5)||(n2==6)){st3=1; st4=0;}else{st3=0; st4=1;}
        SPCAuto(TStr[n3][n2][i], Opcty[1], st3*cdx3+st4*cdx4, cdx0, o);
        AP(TStr[n3][n2][i],bc[n3]);
    }
}
//==============================================
//==============================================
while( ROOP ){t=t+step; count=count+1;
if(count%(100)==0){print(count/10+"/");}
//==============================================
    t1=0.2;
//----------------------------------------------
//cameraとworld座標系の位置関係
dt1=o; S(); if(Bt())
{    dz=10.25*a*4/3;
       X0=GCOX(world); Y0=GCOY(world); Z0=GCOZ(world);
    SCO(world, o, o, o); SCEA(world, o, o, o);
    setCameraOrigin(world, o, dy, dz); setCameraEulerAngle(world, o, o, o);
    spinXCamera(world, -atan(dy/(dz)));
    setGraphics3DClipFront(RENDERER, -0.1);
    setGraphics3DClipBack(RENDERER, -100*a);
}
//----------------------------------------------
//頂点の真上
S(); if(Bt())
{

//     addModel(axis0, RENDERER, bcd);
//    addModel(axis1, RENDERER, bc[0]);
//     addModel(axis2, RENDERER, bc[3]);
//     addModel(axis4, RENDERER, bc[5]);

//    SCEA(icd, -0.5, 0.25, 0.5); RXC(icd, ATIS);
}
//----------------------------------------------
//==============================================
tc[0]=5/10.0; tc[1]=10/10.0; tc[2]=2.0; tc[3]=4.0; tc[4]=5.0;
tc[10]=10.0;
//----------------------------------------------
cdx0=16;//色数
cdx1=8;//Spher Color
cdx2=8;//Cylinder Color
cdx3=-2;//octahedron face color 1
cdx4=4;//octahedron face color 2
tanAtO=0.8;
//----------------------------------------------

CyRd=0.04*a; SpRd=3*CyRd; Rds=2*a; c0=1.01;

dt1=0; S(); if(Bt()){//0th, 1st Sphere
    for(int i=0; i<=N3-1; i++){for(int j=0; j<=1; j++){
        SpRd=o;
        SMCAuto(Sph[i][j], Opcty[0], cdx1, cdx0, o);
        StSphr(Sph[i][j]); AM(Sph[i][j], Ccd[i][j]);
        SCO(Ccd[i][j], Rds, o, o);
    }}
}D(o, tc[0]); T(); if(Bt()){
    for(int i=0; i<=N3-1; i++){for(int j=0; j<=1; j++){
        SpRd=3*CyRd*Tg(); StSphr(Sph[i][j]);
    }}
}

dt1=o; S(); if(Bt()){int j=0;//0th cylinder
    for(int i=0; i<=N3-1; i++){
        SMCAuto(Cyl[i][j], Opcty[0], cdx2, cdx0, o);
        AM(Cyl[i][j], Ccd[i][j+1]);
    }
}D(o, tc[0]); T(); if(Bt()){int j=0;
    for(int i=0; i<=N3-1; i++){
        setVector(IVc, Rds, o, o); setVector(EVc, Rds*TuR(), Rds*Tu(), o);
        StCylndr(Cyl[i][j], Ccd[i][j+1], IVc, EVc);
    }
}

thAini[0]=t1;

dt1=o; S(); if(Bt()){int j=2;//2nd Sphere
    for(int i=0; i<=N3-1; i++){
        SMCAuto(Sph[i][j], Opcty[0], cdx1, cdx0, o);
        StSphr(Sph[i][j]); AM(Sph[i][j], Ccd[i][j]);
        SCO(Ccd[i][j], o, Rds, o);
    }for(int i=0; i<=N3-1; i++){j=1;//1st cylinder
        SMCAuto(Cyl[i][j], Opcty[0], cdx2, cdx0, o);
        AM(Cyl[i][j], Ccd[i][j+1]);
    }
}D(o, tc[0]); T(); if(Bt()){int j=1;
    for(int i=0; i<=N3-1; i++){
        setVector(IVc, o, Rds, o); setVector(EVc, o, Rds*TuR(), Rds*Tu());
        StCylndr(Cyl[i][j], Ccd[i][j+1], IVc, EVc);
    }
}

dt1=o; S(); if(Bt()){int j=3;//3rd Sphere
    for(int i=0; i<=N3-1; i++){
        SMCAuto(Sph[i][j], Opcty[0], cdx1, cdx0, o);
        StSphr(Sph[i][j]); AM(Sph[i][j], Ccd[i][j]);
        SCO(Ccd[i][j], o, Rds, o);
    }for(int i=0; i<=N3-1; i++){j=2;//2nd cylinder
        SMCAuto(Cyl[i][j], Opcty[0], cdx2, cdx0, o);
        AM(Cyl[i][j], Ccd[i][j+1]);
    }
}D(o, tc[0]); T(); if(Bt()){int j=2;
    for(int i=0; i<=N3-1; i++){
        setVector(IVc, o, o, Rds); setVector(EVc, Rds*Tu(), o, Rds*TuR());
        StCylndr(Cyl[i][j], Ccd[i][j+1], IVc, EVc);
    }
}

dt1=-dt0/2; S(); if(Bt()){int j=4;//4th Sphere
    for(int i=0; i<=N3-1; i++){
        SMCAuto(Sph[i][j], Opcty[0], cdx1, cdx0, o);
        StSphr(Sph[i][j]); AM(Sph[i][j], Ccd[i][j]);
        SCO(Ccd[i][j], o, Rds, o);
    }for(int i=0; i<=N3-1; i++){j=3;//3rd cylinder
        SMCAuto(Cyl[i][j], Opcty[0], cdx2, cdx0, o);
        AM(Cyl[i][j], Ccd[i][j+1]);
    }for(int i=0; i<=N3-1; i++){j=0;//0th TOct
        for(int k=0; k<=ToctV2-1; k++){
            AP(TOct[i][j][k], bc[i]);
        }
    }
}D(o, tc[0]); T(); if(Bt()){int j=3;//set 3rd cylinder
    for(int i=0; i<=N3-1; i++){
        setVector(IVc, Rds, o, o); setVector(EVc, Rds*TuR(), o, -Rds*Tu());
        StCylndr(Cyl[i][j], Ccd[i][j+1], IVc, EVc);
    }for(int i=0; i<=N3-1; i++){j=0;//set 0th TOct
        setVector(TVc1, Rds, o, o);
        setVector(TVc2, o, Rds, o);
        setVector(TVc3, o, o, Rds);
        DrwTrnglPlygn6(i, j, TVc1, TVc2, TVc3);
        for(int k=0; k<=ToctV2-1; k++){
            SPCAuto(TOct[i][j][k], (int)(Opcty[0]*Tu()), cdx3, cdx0, o);
        }
    }
}

dt1=o; S(); if(Bt()){int j=5;//5th Sphere
    for(int i=0; i<=N3-1; i++){
        SMCAuto(Sph[i][j], Opcty[0], cdx1, cdx0, o);
        StSphr(Sph[i][j]); AM(Sph[i][j], Ccd[i][j]);
        SCO(Ccd[i][j], o, Rds, o);
    }for(int i=0; i<=N3-1; i++){j=4;//4th cylinder
        SMCAuto(Cyl[i][j], Opcty[0], cdx2, cdx0, o);
        AM(Cyl[i][j], Ccd[i][j+1]);
    }
}D(o, tc[0]); T(); if(Bt()){int j=4;//set 4th cylinder
    for(int i=0; i<=N3-1; i++){
        setVector(IVc, o, o, -Rds); setVector(EVc, -Rds*Tu(), o, -Rds*TuR());
        StCylndr(Cyl[i][j], Ccd[i][j+1], IVc, EVc);
    }
}

dt1=o; S(); if(Bt()){int j=6;//6th Sphere
    for(int i=0; i<=N3-1; i++){
        SMCAuto(Sph[i][j], Opcty[0], cdx1, cdx0, o);
        StSphr(Sph[i][j]); AM(Sph[i][j], Ccd[i][j]);
        SCO(Ccd[i][j], o, Rds, o);
    }for(int i=0; i<=N3-1; i++){j=5;//5th cylinder
        SMCAuto(Cyl[i][j], Opcty[0], cdx2, cdx0, o);
        AM(Cyl[i][j], Ccd[i][j+1]);
    }
}D(o, tc[0]); T(); if(Bt()){int j=5;//set 5th cylinder
    for(int i=0; i<=N3-1; i++){
        setVector(IVc, -Rds, o, o); setVector(EVc, -Rds*TuR(), -Rds*Tu(), o);
        StCylndr(Cyl[i][j], Ccd[i][j+1], IVc, EVc);
    }
}

dt1=o; S(); if(Bt()){int j=7;//7th Sphere
    for(int i=0; i<=N3-1; i++){
        SMCAuto(Sph[i][j], Opcty[0], cdx1, cdx0, o);
        StSphr(Sph[i][j]); AM(Sph[i][j], Ccd[i][j]);
        SCO(Ccd[i][j], o, Rds, o);
    }for(int i=0; i<=N3-1; i++){j=6;//6th cylinder
        SMCAuto(Cyl[i][j], Opcty[0], cdx2, cdx0, o);
        AM(Cyl[i][j], Ccd[i][j+1]);
    }
}D(o, tc[0]); T(); if(Bt()){int j=6;//set 6th cylinder
    for(int i=0; i<=N3-1; i++){
        setVector(IVc, o, -Rds, o); setVector(EVc, o, -Rds*TuR(), -Rds*Tu());
        StCylndr(Cyl[i][j], Ccd[i][j+1], IVc, EVc);
    }
}

dt1=-dt0*2/3; S(); if(Bt()){int j=8;//8th Sphere
    for(int i=0; i<=N3-1; i++){
        SMCAuto(Sph[i][j], Opcty[0], cdx1, cdx0, o);
        StSphr(Sph[i][j]); AM(Sph[i][j], Ccd[i][j]);
        SCO(Ccd[i][j], o, Rds, o);
    }for(int i=0; i<=N3-1; i++){j=7;//7th cylinder
        SMCAuto(Cyl[i][j], Opcty[0], cdx2, cdx0, o);
        AM(Cyl[i][j], Ccd[i][j+1]);
    }for(int i=0; i<=N3-1; i++){j=1;//1st TOct
        for(int k=0; k<=ToctV2-1; k++){
            AP(TOct[i][j][k], bc[i]);
        }
    }
}D(o, tc[0]); T(); if(Bt()){int j=7;//set 7th cylinder
    for(int i=0; i<=N3-1; i++){
        setVector(IVc, o, o, -Rds); setVector(EVc, o, Rds*Tu(), -Rds*TuR());
        StCylndr(Cyl[i][j], Ccd[i][j+1], IVc, EVc);
    }for(int i=0; i<=N3-1; i++){j=1;//set 1st TOct
        setVector(TVc1, -Rds, o, o);
        setVector(TVc2, o, o, -Rds);
        setVector(TVc3, o, -Rds, o);
        DrwTrnglPlygn6(i, j, TVc1, TVc2, TVc3);
        for(int k=0; k<=ToctV2-1; k++){
            SPCAuto(TOct[i][j][k], (int)(Opcty[0]*Tu()), cdx4, cdx0, o);
        }
    }
}

dt1=-dt0*2/3; S(); if(Bt()){int j=9;//9th Sphere
    for(int i=0; i<=N3-1; i++){
        SMCAuto(Sph[i][j], Opcty[0], cdx1, cdx0, o);
        StSphr(Sph[i][j]); AM(Sph[i][j], Ccd[i][j]);
        SCO(Ccd[i][j], o, Rds, o);
    }for(int i=0; i<=N3-1; i++){j=8;//8th cylinder
        SMCAuto(Cyl[i][j], Opcty[0], cdx2, cdx0, o);
        AM(Cyl[i][j], Ccd[i][j+1]);
    }for(int i=0; i<=N3-1; i++){j=2;//2nd TOct
        for(int k=0; k<=ToctV2-1; k++){
            AP(TOct[i][j][k], bc[i]);
        }
    }
}D(o, tc[0]); T(); if(Bt()){int j=8;//set 8th cylinder
    for(int i=0; i<=N3-1; i++){
        setVector(IVc, o, Rds, o); setVector(EVc, -Rds*Tu(), Rds*TuR(), o);
        StCylndr(Cyl[i][j], Ccd[i][j+1], IVc, EVc);
    }for(int i=0; i<=N3-1; i++){j=2;//set 2nd TOct
        setVector(TVc1, Rds, o, o);
        setVector(TVc2, o, o, -Rds);
        setVector(TVc3, o, Rds, o);
        DrwTrnglPlygn6(i, j, TVc1, TVc2, TVc3);
        for(int k=0; k<=ToctV2-1; k++){
            SPCAuto(TOct[i][j][k], (int)(Opcty[0]*Tu()), cdx4, cdx0, o);
        }
    }
}

dt1=-dt0*2/3; S(); if(Bt()){int j=10;//10th Sphere
    for(int i=0; i<=N3-1; i++){
        SMCAuto(Sph[i][j], Opcty[0], cdx1, cdx0, o);
        StSphr(Sph[i][j]); AM(Sph[i][j], Ccd[i][j]);
        SCO(Ccd[i][j], o, Rds, o);
    }for(int i=0; i<=N3-1; i++){j=9;//9th cylinder
        SMCAuto(Cyl[i][j], Opcty[0], cdx2, cdx0, o);
        AM(Cyl[i][j], Ccd[i][j+1]);
    }for(int i=0; i<=N3-1; i++){j=3;//3rd TOct
        for(int k=0; k<=ToctV2-1; k++){
            AP(TOct[i][j][k], bc[i]);
        }
    }
}D(o, tc[0]); T(); if(Bt()){int j=9;//set 9th cylinder
    for(int i=0; i<=N3-1; i++){
        setVector(IVc, -Rds, o, o); setVector(EVc, -Rds*TuR(), o, Rds*Tu());
        StCylndr(Cyl[i][j], Ccd[i][j+1], IVc, EVc);
    }for(int i=0; i<=N3-1; i++){j=3;//set 3rd TOct
        setVector(TVc1, -Rds, o, o);
        setVector(TVc2, o, Rds, o);
        setVector(TVc3, o, o, -Rds);
        DrwTrnglPlygn6(i, j, TVc1, TVc2, TVc3);
        for(int k=0; k<=ToctV2-1; k++){
            SPCAuto(TOct[i][j][k], (int)(Opcty[0]*Tu()), cdx3, cdx0, o);
        }
    }
}

dt1=-dt0*2/3; S(); if(Bt()){int j=11;//11th Sphere
    for(int i=0; i<=N3-1; i++){
        SMCAuto(Sph[i][j], Opcty[0], cdx1, cdx0, o);
        StSphr(Sph[i][j]); AM(Sph[i][j], Ccd[i][j]);
        SCO(Ccd[i][j], o, Rds, o);
    }for(int i=0; i<=N3-1; i++){j=10;//10th cylinder
        SMCAuto(Cyl[i][j], Opcty[0], cdx2, cdx0, o);
        AM(Cyl[i][j], Ccd[i][j+1]);
    }for(int i=0; i<=N3-1; i++){j=4;//4th TOct
        for(int k=0; k<=ToctV2-1; k++){
            AP(TOct[i][j][k], bc[i]);
        }
    }
}D(o, tc[0]); T(); if(Bt()){int j=10;//set 10th cylinder
    for(int i=0; i<=N3-1; i++){
        setVector(IVc, o, o, Rds); setVector(EVc, o, -Rds*Tu(), Rds*TuR());
        StCylndr(Cyl[i][j], Ccd[i][j+1], IVc, EVc);
    }for(int i=0; i<=N3-1; i++){j=4;//set 4th TOct
        setVector(TVc1, -Rds, o, o);
        setVector(TVc2, o, Rds, o);
        setVector(TVc3, o, o, Rds);
        DrwTrnglPlygn6(i, j, TVc1, TVc2, TVc3);
        for(int k=0; k<=ToctV2-1; k++){
            SPCAuto(TOct[i][j][k], (int)(Opcty[0]*Tu()), cdx4, cdx0, o);
        }
    }
}

dt1=-dt0*2/3; S(); if(Bt()){int j=12;//12th Sphere
    for(int i=0; i<=N3-1; i++){
        SMCAuto(Sph[i][j], Opcty[0], cdx1, cdx0, o);
        StSphr(Sph[i][j]); AM(Sph[i][j], Ccd[i][j]);
        SCO(Ccd[i][j], o, Rds, o);
    }for(int i=0; i<=N3-1; i++){j=11;//11th cylinder
        SMCAuto(Cyl[i][j], Opcty[0], cdx2, cdx0, o);
        AM(Cyl[i][j], Ccd[i][j+1]);
    }for(int i=0; i<=N3-1; i++){j=5;//5th TOct
        for(int k=0; k<=ToctV2-1; k++){
            AP(TOct[i][j][k], bc[i]);
        }
    }
}D(o, tc[0]); T(); if(Bt()){int j=11;//set 11th cylinder
    for(int i=0; i<=N3-1; i++){
        setVector(IVc, o, -Rds, o); setVector(EVc, Rds*Tu(), -Rds*TuR(), o);
        StCylndr(Cyl[i][j], Ccd[i][j+1], IVc, EVc);
    }for(int i=0; i<=N3-1; i++){j=5;//set 5th TOct
        setVector(TVc1, -Rds, o, o);
        setVector(TVc2, o, -Rds, o);
        setVector(TVc3, o, o, Rds);
        DrwTrnglPlygn6(i, j, TVc1, TVc2, TVc3);
        for(int k=0; k<=ToctV2-1; k++){
            SPCAuto(TOct[i][j][k], (int)(Opcty[0]*Tu()), cdx3, cdx0, o);
        }
    }
}

dt1=-dt0*2/3; S(); if(Bt()){int j=6;//6th TOct
    for(int i=0; i<=N3-1; i++){
        for(int k=0; k<=ToctV2-1; k++){
            AP(TOct[i][j][k], bc[i]);
        }j=7;//7th TOct
        for(int k=0; k<=ToctV2-1; k++){
            AP(TOct[i][j][k], bc[i]);
        }
    }
}D(o, tc[0]); T(); if(Bt()){int j=6;//6th TOct
    for(int i=0; i<=N3-1; i++){
        setVector(TVc1, Rds, o, o);
        setVector(TVc2, o, -Rds, o);
        setVector(TVc3, o, o, -Rds);
        DrwTrnglPlygn6(i, j, TVc1, TVc2, TVc3);
        for(int k=0; k<=ToctV2-1; k++){
            SPCAuto(TOct[i][j][k], (int)(Opcty[0]*Tu()), cdx3, cdx0, o);
        }
    }for(int i=0; i<=N3-1; i++){j=7;//7th TOct
        setVector(TVc1, Rds, o, o);
        setVector(TVc2, o, -Rds, o);
        setVector(TVc3, o, o, Rds);
        DrwTrnglPlygn6(i, j, TVc1, TVc2, TVc3);
        for(int k=0; k<=ToctV2-1; k++){
            SPCAuto(TOct[i][j][k], (int)(Opcty[0]*Tu()), cdx4, cdx0, o);
        }
    }
}

dt1=o; S(); if(Bt()){
    for(int i=0; i<=7; i++){
        int j=NSpOctV3+6*i;
        addSphStr(0, i, j); addCylStr(0, i, j-1);
        addTrnStr(0, i);
    }
}

D(0.5, tc[1]); T(); if(Bt()){
    for(int n2=0; n2<=7; n2++){if((n2==0)||(n2==3)||(n2==5)||(n2==6)){for(int i=0; i<=2; i++){int n3=0;
        int j=i+1; if(j>2){j=j-3;}
        int k=j+1; if(k>2){k=k-3;}
        int l=NSpOctV3+6*n2;
        if(Tu()<1.0/100){
            SMCAuto(Sph[n3][l+2*i], Opcty[0], cdx1, cdx0, o);
            SMCAuto(Sph[n3][l+2*i+1], Opcty[0], cdx1, cdx0, o);
        }else{
            SMCAuto(Sph[n3][l+2*i], Opcty[0], cdx3, cdx0, o);
            SMCAuto(Sph[n3][l+2*i+1], Opcty[0], cdx3, cdx0, o);
        }
        setVector(IVc, VrVc[n2][i]); 
        VctDff(EVc, VrVc[n2][j], VrVc[n2][k]); 
        VctMlt(EVc, Tu()); VctDgn(EVc, IVc, EVc);
        StCylndr(Cyl[n3][NSpOctV3+2*i-1+6*n2], Ccd[n3][NSpOctV3+2*i+6*n2], IVc, EVc);
        setVector(IVc, VrVc[n2][j]); 
        VctDff(EVc, VrVc[n2][i], VrVc[n2][k]); 
        VctMlt(EVc, Tu()); VctDgn(EVc, IVc, EVc);
        StCylndr(Cyl[n3][NSpOctV3+2*i+6*n2], Ccd[n3][NSpOctV3+2*i+1+6*n2], IVc, EVc);
        float sx[3], ex[3];
        sx=GCO(Ccd[n3][NSpOctV3+2*i+6*n2]); setVector(IVc, sx);
        if(Tu()<1.0/100){ex=sx;}else{
            ex=GCO(Ccd[n3][NSpOctV3+2*i+1+6*n2]); 
        }
        setVector(EVc, ex);
        StCylndr(Cyl[n3][NSpV3+3*n2+i-1], Ccd[n3][NSpV3+3*n2+i], IVc, EVc);
        VctDgn(TVc0, VrVc[n2][i], VrVc[n2][j]);
        VctDgn(TVc0, TVc0, IVc); VctDgn(TVc0, TVc0, EVc); VctMlt(TVc0, 1.0/4);
        StTrngl0(TStr[n3][n2][4*i], TVc0, VrVc[n2][i], IVc);
        StTrngl0(TStr[n3][n2][4*i+1], TVc0, IVc, EVc);
        StTrngl0(TStr[n3][n2][4*i+2], TVc0, EVc, VrVc[n2][j]);
        StTrngl0(TStr[n3][n2][4*i+3], TVc0, VrVc[n2][j], VrVc[n2][i]);
    }}}
}

D(0.5, tc[1]); T(); if(Bt()){
    for(int n2=0; n2<=7; n2++){if((n2==1)||(n2==2)||(n2==4)||(n2==7)){for(int i=0; i<=2; i++){int n3=0;
        int j=i+1; if(j>2){j=j-3;}
        int k=j+1; if(k>2){k=k-3;}
        int l=NSpOctV3+6*n2;
        if(Tu()<1.0/100){
            SMCAuto(Sph[n3][l+2*i], Opcty[0], cdx1, cdx0, o);
            SMCAuto(Sph[n3][l+2*i+1], Opcty[0], cdx1, cdx0, o);
        }else{
            SMCAuto(Sph[n3][l+2*i], Opcty[0], cdx4, cdx0, o);
            SMCAuto(Sph[n3][l+2*i+1], Opcty[0], cdx4, cdx0, o);
        }
        setVector(IVc, VrVc[n2][i]); 
        VctDff(EVc, VrVc[n2][j], VrVc[n2][k]); 
        VctMlt(EVc, Tu()); VctDgn(EVc, IVc, EVc);
        StCylndr(Cyl[n3][NSpOctV3+2*i-1+6*n2], Ccd[n3][NSpOctV3+2*i+6*n2], IVc, EVc);
        setVector(IVc, VrVc[n2][j]); 
        VctDff(EVc, VrVc[n2][i], VrVc[n2][k]); 
        VctMlt(EVc, Tu()); VctDgn(EVc, IVc, EVc);
        StCylndr(Cyl[n3][NSpOctV3+2*i+6*n2], Ccd[n3][NSpOctV3+2*i+1+6*n2], IVc, EVc);
        float sx[3], ex[3];
        sx=GCO(Ccd[n3][NSpOctV3+2*i+6*n2]); setVector(IVc, sx);
        if((2.0+ATIS)*Tu()<1.0/100){ex=sx;}else{
            ex=GCO(Ccd[n3][NSpOctV3+2*i+1+6*n2]); 
        }
        setVector(EVc, ex);
        StCylndr(Cyl[n3][NSpV3+3*n2+i-1], Ccd[n3][NSpV3+3*n2+i], IVc, EVc);
        VctDgn(TVc0, VrVc[n2][i], VrVc[n2][j]);
        VctDgn(TVc0, TVc0, IVc); VctDgn(TVc0, TVc0, EVc); VctMlt(TVc0, 1.0/4);
        StTrngl0(TStr[n3][n2][4*i], TVc0, VrVc[n2][i], IVc);
        StTrngl0(TStr[n3][n2][4*i+1], TVc0, IVc, EVc);
        StTrngl0(TStr[n3][n2][4*i+2], TVc0, EVc, VrVc[n2][j]);
        StTrngl0(TStr[n3][n2][4*i+3], TVc0, VrVc[n2][j], VrVc[n2][i]);
    }}}
}

thAfin[0]=t1+1.0;
thAini[1]=thAfin[0]+0.5;

D(1.0, 1.5*tc[1]); T(); if(Bt()){
    for(int n2=0; n2<=7; n2++){if((n2==0)||(n2==3)||(n2==5)||(n2==6)){for(int i=0; i<=2; i++){int n3=0;
        int j=i+1; if(j>2){j=j-3;}
        int k=j+1; if(k>2){k=k-3;}
        int l=NSpOctV3+6*n2;
        if(TuR()<1.0/100){
            SMCAuto(Sph[n3][l+2*i], Opcty[0], cdx1, cdx0, o);
            SMCAuto(Sph[n3][l+2*i+1], Opcty[0], cdx1, cdx0, o);
        }else{
            SMCAuto(Sph[n3][l+2*i], Opcty[0], cdx3, cdx0, o);
            SMCAuto(Sph[n3][l+2*i+1], Opcty[0], cdx3, cdx0, o);
        }
        setVector(IVc, VrVc[n2][i]); 
        VctDff(EVc, VrVc[n2][j], VrVc[n2][k]); 
        VctMlt(EVc, TuR()); VctDgn(EVc, IVc, EVc);
        StCylndr(Cyl[n3][NSpOctV3+2*i-1+6*n2], Ccd[n3][NSpOctV3+2*i+6*n2], IVc, EVc);
        setVector(IVc, VrVc[n2][j]); 
        VctDff(EVc, VrVc[n2][i], VrVc[n2][k]); 
        VctMlt(EVc, TuR()); VctDgn(EVc, IVc, EVc);
        StCylndr(Cyl[n3][NSpOctV3+2*i+6*n2], Ccd[n3][NSpOctV3+2*i+1+6*n2], IVc, EVc);
        float sx[3], ex[3];
        sx=GCO(Ccd[n3][NSpOctV3+2*i+6*n2]); setVector(IVc, sx);
        if(TuR()<1.0/100){ex=sx;}else{
            ex=GCO(Ccd[n3][NSpOctV3+2*i+1+6*n2]); 
        }
        setVector(EVc, ex);
        StCylndr(Cyl[n3][NSpV3+3*n2+i-1], Ccd[n3][NSpV3+3*n2+i], IVc, EVc);
        VctDgn(TVc0, VrVc[n2][i], VrVc[n2][j]);
        VctDgn(TVc0, TVc0, IVc); VctDgn(TVc0, TVc0, EVc); VctMlt(TVc0, 1.0/4);
        StTrngl0(TStr[n3][n2][4*i], TVc0, VrVc[n2][i], IVc);
        StTrngl0(TStr[n3][n2][4*i+1], TVc0, IVc, EVc);
        StTrngl0(TStr[n3][n2][4*i+2], TVc0, EVc, VrVc[n2][j]);
        StTrngl0(TStr[n3][n2][4*i+3], TVc0, VrVc[n2][j], VrVc[n2][i]);
    }}}
}

D(-dt0, dt0); T(); if(Bt()){
    for(int n2=0; n2<=7; n2++){if((n2==1)||(n2==2)||(n2==4)||(n2==7)){for(int i=0; i<=2; i++){int n3=0;
        int j=i+1; if(j>2){j=j-3;}
        int k=j+1; if(k>2){k=k-3;}
        int l=NSpOctV3+6*n2;
        if(TuR()<1.0/100){
            SMCAuto(Sph[n3][l+2*i], Opcty[0], cdx1, cdx0, o);
            SMCAuto(Sph[n3][l+2*i+1], Opcty[0], cdx1, cdx0, o);
        }else{
            SMCAuto(Sph[n3][l+2*i], Opcty[0], cdx4, cdx0, o);
            SMCAuto(Sph[n3][l+2*i+1], Opcty[0], cdx4, cdx0, o);
        }
        setVector(IVc, VrVc[n2][i]); 
        VctDff(EVc, VrVc[n2][j], VrVc[n2][k]); 
        VctMlt(EVc, TuR()); VctDgn(EVc, IVc, EVc);
        StCylndr(Cyl[n3][NSpOctV3+2*i-1+6*n2], Ccd[n3][NSpOctV3+2*i+6*n2], IVc, EVc);
        setVector(IVc, VrVc[n2][j]); 
        VctDff(EVc, VrVc[n2][i], VrVc[n2][k]); 
        VctMlt(EVc, TuR()); VctDgn(EVc, IVc, EVc);
        StCylndr(Cyl[n3][NSpOctV3+2*i+6*n2], Ccd[n3][NSpOctV3+2*i+1+6*n2], IVc, EVc);
        float sx[3], ex[3];
        sx=GCO(Ccd[n3][NSpOctV3+2*i+6*n2]); setVector(IVc, sx);
        if(TuR()<1.0/100){ex=sx;}else{
            ex=GCO(Ccd[n3][NSpOctV3+2*i+1+6*n2]); 
        }
        setVector(EVc, ex);
        StCylndr(Cyl[n3][NSpV3+3*n2+i-1], Ccd[n3][NSpV3+3*n2+i], IVc, EVc);
        VctDgn(TVc0, VrVc[n2][i], VrVc[n2][j]);
        VctDgn(TVc0, TVc0, IVc); VctDgn(TVc0, TVc0, EVc); VctMlt(TVc0, 1.0/4);
        StTrngl0(TStr[n3][n2][4*i], TVc0, VrVc[n2][i], IVc);
        StTrngl0(TStr[n3][n2][4*i+1], TVc0, IVc, EVc);
        StTrngl0(TStr[n3][n2][4*i+2], TVc0, EVc, VrVc[n2][j]);
        StTrngl0(TStr[n3][n2][4*i+3], TVc0, VrVc[n2][j], VrVc[n2][i]);
    }}}
}

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

t1=t1+17.0;
thAfin[1]=t1;

if(t>thAini[1]){CntSYC1(bcd, 360);}

ti=0; t2=thAini[ti]; t3=thAfin[ti]; if(Bt2()){T2(); tanAtO=0.8;
    SCEA(hcd, 0.5, 0.25*Tg(), -0.5); RXC(hcd, (2.0+ATIS)*Tg());
    SCEA(gcd, 0.5, 2*Tg(), -0.5);
}

ti=1; t2=thAini[ti]; t3=thAfin[ti]; if(Bt2()){T2(); tanAtO=0.8;
    SCEA(hcd, 0.5, 0.25*TgR(), -0.5); RXC(hcd, (ATIS)*TgR());
}

//==============================================
//描画
    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）に　※メッセージ表示のタイムラグを考慮してこの順番1
        }
    }
}



//==============================================
//関数(1)
//時刻
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;}

//Tu()---t=t0でTu()=0、t=t1でTu()=1
float Tu(){return Ft((t-t0)/(t1-step-t0));}

//TuR()---Tuのreverse
float TuR(){return 1.0-Tu();}

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

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


//Gt(var)---Ft(var)を滑らかにした関数
float Gt1(float var){return 0.5*(1.0+sin(PI*Ft(var)-0.5*PI));}//sin関数
float tanAtO=1.5;//３次関数の中心点での微分係数。0.8がちょうどよい
float Yt(float var){return ((1-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){return (1/PI)*asin(2*var-1.0)+1/2;}//sin逆関数
float Zt(float var){return (1/PI)*(2*var-1.0)*(1-(2*var-1.0)^2)^(1.0/2.0);}//lemni型関数
float Gt3(float var){return Gt2(var)+Zt(var);}//半円の積分

//Tg()---規格化時間Tu()を滑らかにした関数。t0<=t<=t1で0<=Tg()<=1
float Tg(){return Gt(Tu());}
//TgR()---Tg()のreverse
float TgR(){return 1.0-Tg();}
//TgU()---Tg()のU-turn
float TgU(){return 4*Tg()*(1.0-Tg());}
//TgUR()---TgU()のreverse
float TgUR(){return 1.0-TgU();}
float Tg3(){return Gt(Tu());}

//Ti(ixi)---t0<=t<=t1内の幅trangeの区間でTg()を規格化したもの。
//幅trangeの区間の外側ではTi(ixi)=0, 1
//Ti(0)はt0<=t<=t0+trangeで0から1まで、Ti(Nrg-1)はt1-trange<=t<=t1で0から1まで
float trange;//Ti(ixi)が単調に増加する区間の幅
float Ti(int ixi){
    float value, shift0;
    shift0=(t1-trange-t0)*ixi/(float)(N3d-1);//時間のズレ
    return Gt((t-t0-shift0)/trange);}
//TiR(ixi)---Ti(ixi)のreverse
float TiR(int ixi){return 1.0-Ti(ixi);}

//GtRight(var)---0<=var<=1の右端幅bandの区間で0から1まで増加する関数
float band=0.2;//GtRight(var)が変化する区間の幅
float GtRight(float var){return Gt((var-1.0+band)/band);}
//GtLeft(var)---0<=var<=1の左端幅bandの区間で1から0まで減少する関数
float GtLeft(float var){return 1.0-Gt(var/band);}

//TiRight(ixi)---Gt(var)からTi(ixi)と同様にGtRight(var)から作った右端幅bandの区間で0から1まで増加する関数
float TiRight(int ixi){
    float value, shift0;
    shift0=(t1-trange-t0)*ixi/(float)(N3d-1);//時間のズレ
    return GtRight((t-t0-shift0)/trange);}

//TiLeft(ixi)---Gt(var)からTi(ixi)と同様にGt+eft(var)から作った左端幅bandの区間で1から0まで減少する関数
float TiLeft(int ixi){
    float value, shift0;
    shift0=(t1-trange-t0)*ixi/(float)(N3d-1);//時間のズレ
    return GtLeft((t-t0-shift0)/trange);}

//MakeTrack(var)---0<=t<=1の中央幅twidthで値1をとり、それ以外では滑らかに0となる関数
float twidth=0.5;//MakeTrack(var)の幅
float MakeTrack(float var){
    return Gt(2*var/(1.0-twidth))-Gt((2*var-1.0-twidth)/(1.0-twidth));}
//計算式
/*    MakeTrack(float var)
    =1.0-(GtLeft(var)+GtRight(var)) ただし2*band=1.0-twidth*/

//MakeTracki(ixi)---Gt(var)からTi(ixi)と同様にMakeTrack(var)から作った、t0+shift0<t<t0+shift0+trangeの中央幅twidthで値1をとり、それ以外では滑らかに0となる関数
//区間端での微分係数はcutで調節可
float MakeTracki(int ixi){
    float value, shift0;
    shift0=(t1-trange-t0)*ixi/(float)(N3d-1);//時間のズレ
    return MakeTrack((t-t0-shift0)/trange);}
    
bool Bt(){return (t>=t0)&&(t<t1);}
bool Bt2(){return (t>=t2)&&(t<t3);}
void Q(float var1, float var2, int xvar){
    if((t>=var1)&&(t<var2)){step=xvar/(float)rrate;}else{step=1.0/(float)rrate;}}
//----------------------------------------------
//angle
float GCEAA(int coord){return getCoordinateEulerAngleAlpha(coord);}
float GCEAB(int coord){return getCoordinateEulerAngleBeta(coord);}
float GCEAG(int coord){return getCoordinateEulerAngleGamma(coord);}
void SCEA(int coord, float aangle ,float bangle, float gangle){
    setCoordinateEulerAngle(coord, PI*aangle, PI*bangle, PI*gangle);}
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();
    VctDff(axisvector, Pvector, Ovector);
    rotCoordinate(coord, angle*PI, axisvector, Ovector);
}

void CntSYC1(int cord, int rotn){
    SYC(cord, 2.0/rotn);
    float baseX[3]; 
dt1=o; S(); if(Bt()){
    baseX=GCBX(cord);
    if(baseX[2]<o){
        ba[0]=acos(baseX[0])/PI;
    }else{
        ba[0]=-acos(baseX[0])/PI;
    }
    float cntdwn;
    if(ba[0]<o){
        cntdwn=-ba[0]*(rotn/2);
    }else{
        cntdwn=(2.0-ba[0])*(rotn/2);
    }
    stpcnt=count+(int)cntdwn;
}
if(count>=stpcnt-10){//println(GCEAB(cord)/PI*45); println(count);
    baseX=GCBX(cord);
    if(count==stpcnt-2){SYC(cord, -1.0/(rotn/2)/(5.0/1));}
    if(count==stpcnt-1){SYC(cord, -1.0/(rotn/2)/(5.0/1));}
    if(count==stpcnt+0){SYC(cord, -1.0/(rotn/2)/(5.0/2));}
    if(count==stpcnt+1){SYC(cord, -1.0/(rotn/2)/(5.0/2));}
    if(count==stpcnt+2){SYC(cord, -1.0/(rotn/2)/(5.0/3));}
    if(count==stpcnt+3){SYC(cord, -1.0/(rotn/2)/(5.0/3));}
    if(count==stpcnt+4){SYC(cord, -1.0/(rotn/2)/(5.0/4));}
    if(count==stpcnt+5){SYC(cord, -1.0/(rotn/2)/(5.0/4));}
    if(count>=stpcnt+6){SYC(cord, -1.0/(rotn/2));}
    if(baseX[2]<o){SCEA(cord, o, o, o);}
}
}
//----------------------------------------------
//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 SCO(int coord, float ox, float oy, float oz){
    setCoordinateOrigin(coord, ox, oy, oz);}

//set camera
void StCm(float ox, float oy, float oz){
    float cx, cy, cz;
    if(t<t0+step){
        cx=-getCoordinateOriginX(world);
        cy=-getCoordinateOriginY(world);
        cz=-getCoordinateOriginZ(world);
    }
    setCameraOrigin(world, cx*TgR()+ox*Tg(), cy*TgR()+oy*Tg(), cz*TgR()+oz*Tg());
}
//set camera origin
void SCmO(float vx, float vy, float vz){
    setCameraOrigin(world, vx, vy, vz);
}

//set bc Origin
void StG(){
    float smmtn[3]; smmtn=o;
    for(int i=0; i<=N3-1; i++){
        smmtn[0]=smmtn[0]+inix[i];
        smmtn[1]=smmtn[1]+iniy[i];
        smmtn[2]=smmtn[2]+iniz[i];
    }
    gx=smmtn/N3;
}
//----------------------------------------------
//base
float[] GCBX(int coord){return getCoordinateBaseX(coord);}
float[] GCBY(int coord){return getCoordinateBaseY(coord);}
float[] GCBZ(int coord){return getCoordinateBaseZ(coord);}
//----------------------------------------------
//vector
//vector multiplication
void VctMlt(int vid, float var){scaleVector(vid, var, var, var);}
//vector diffrence
void VctDff(int difvcid, int endvcid, int intlvcid){
    setVector(difvcid,
        getVectorX(endvcid)-getVectorX(intlvcid),
        getVectorY(endvcid)-getVectorY(intlvcid),
        getVectorZ(endvcid)-getVectorZ(intlvcid)
    );
}
//vector diagonal
void VctDgn(int diagonalvcid, int vc1, int vc2){
    setVector(diagonalvcid,
        getVectorX(vc1)+getVectorX(vc2),
        getVectorY(vc1)+getVectorY(vc2),
        getVectorZ(vc1)+getVectorZ(vc2)
    );
}
//get angle between 2 vectors
float GtVcCs(int vc1, int vc2){
    float ipr=getVectorInnerProduct(vc1, vc2);
    return ipr/getVectorLength(vc1)/getVectorLength(vc2);
}
float GtVcSn(int vc1, int vc2){
    int cv=newVector();
    getVectorCrossProduct(vc1, vc2, cv);
    return getVectorLength(cv)/getVectorLength(vc1)/getVectorLength(vc2);
}

//----------------------------------------------
//set polygon/model color
void SPCAuto(int polygon, int opacity, int Nth, int NofC, float offset){
    int rcolor=Color(Nth, NofC, offset);
    int gcolor=Color(Nth, NofC, offset-1.0/3.0);
    int bcolor=Color(Nth, NofC, offset+1.0/3.0);
    setPolygonColor(polygon, rcolor, gcolor, bcolor, opacity);
}

void SMCAuto(int model, int opacity, int Nth, int NofC, float offst){
    int rcolor=Color(Nth, NofC, offst);
    int gcolor=Color(Nth, NofC, offst-1.0/3.0);
    int bcolor=Color(Nth, NofC, offst+1.0/3.0);
    setModelColor(model, rcolor, gcolor, bcolor, opacity);
}

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;}

int Color1(int Nth, int NofC, float Offset){
    float x=cos(2*PI*((float)Nth/(float)NofC+Offset))+0.5;
     if(x>1){x=1.0;} if(x<0){x=0.0;} x=255*x;
    int value=(int)x; return value;}

void SPPht(int id, float emss, float spclr, float spcla, float dffr, float dffs, float ambn){
    setPolygonEmissive        (id, emss);
    setPolygonSpecular        (id, spclr, spcla);
    setPolygonDiffractive    (id, dffr);
    setPolygonDiffuse        (id, dffs);
    setPolygonAmbient        (id, ambn);
}

void SMPht(int id, float emss, float spclr, float spcla, float dffr, float dffs, float ambn){
    setModelEmissive        (id, emss);
    setModelSpecular        (id, spclr, spcla);
    setModelDiffractive        (id, dffr);
    setModelDiffuse            (id, dffs);
    setModelAmbient            (id, ambn);
}

void SMPht0(int id){
    SMPht(id, Emssv[0], SpclrRf[0], SpclrAngl[0], Dffrctv[0], Dffs[0], Ambnt[0]);
}

void SPPht0(int id){
    SPPht(id, Emssv[0], SpclrRf[0], SpclrAngl[0], Dffrctv[0], Dffs[0], Ambnt[0]);
}

void SPPht1(int id){
    SPPht(id, Emssv[1], SpclrRf[1], SpclrAngl[1], Dffrctv[1], Dffs[1], Ambnt[1]);
}

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

void AM(int modelid, int cdid){
    addModel(modelid, RENDERER, cdid);
}
//----------------------------------------------
//Sylinder
//set Cylinder
void StCylndr(int cylid, int coordid, int intlv, int endv){
    int direction=newVector();
    VctDff(direction, intlv, endv);
    StZax(coordid, direction);//z軸方向セット
    setModelSize(cylid, 
        CyRd, CyRd, getVectorLength(direction)
    );//長さをセット
    setCoordinateOrigin(coordid, endv);
}

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


//set z axis
void StZax(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 StSphr(int Sphid){
    setModelSize(Sphid, SpRd, SpRd, SpRd);
}

//----------------------------------------------
//set Polygon vector for triangle polygon
void StTrngl(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 StTrngl0(int polygon, int vc1, int vc2, int vc3){
    setPolygonVector(polygon, vc1, vc2, vc3);
}
//----------------------------------------------
void DrwTrnglPlygnG(int polygon1, int polygon2, int polygon3, int vc1, int vc2, int vc3){
    int v1=newVector();//cylinder radius 分補正したベクトル
    int lv12=newVector(); int lv23=newVector(); int lv31=newVector();
    VctDff(lv12, vc2, vc1); VctDff(lv23, vc3, vc2); VctDff(lv31, vc1, vc3);
    float len=CyRd/GtVcSn(lv12, lv31);
    setVectorLength(lv12, len); setVectorLength(lv31, len);
    VctDff(v1, lv12, lv31); VctDgn(v1, vc1, v1);
    int v2=newVector();//cylinder radius 分補正したベクトル
    len=CyRd/GtVcSn(lv23, lv12);
    setVectorLength(lv23, len); setVectorLength(lv12, len);
    VctDff(v2, lv23, lv12); VctDgn(v2, vc2, v2);
    int v3=newVector();//cylinder radius 分補正したベクトル
    len=CyRd/GtVcSn(lv31, lv23);
    setVectorLength(lv31, len); setVectorLength(lv23, len);
    VctDff(v3, lv31, lv23); VctDgn(v3, vc3, v3);
    int vt0=newVector(); int vt1=newVector(); int vt2=newVector(); int vt3=newVector();
    VctDgn(vt0, v1, v2); VctDgn(vt0, vt0, v3); VctMlt(vt0, 1.0/3);
    VctDff(vt1, v1, vt0); VctMlt(vt1, Tu());
    VctDff(vt2, v2, vt0); VctMlt(vt2, Tu());
    VctDff(vt3, v3, vt0); VctMlt(vt3, Tu());
    VctDgn(vt1, vt0, vt1); VctDgn(vt2, vt0, vt2); VctDgn(vt3, vt0, vt3);
    StTrngl(polygon1, polygon2, polygon3, vt0, vt1, vt2, vt3);
}
/*
void DrwTrnglPlygnG(int polygon1, int polygon2, int polygon3, int vc1, int vc2, int vc3){
    int vt0=newVector(); int vt1=newVector(); int vt2=newVector(); int vt3=newVector();
    VctDgn(vt0, vc1, vc2); VctDgn(vt0, vt0, vc3); VctMlt(vt0, 1.0/3);
    VctDff(vt1, vc1, vt0); VctMlt(vt1, Tu());
    VctDff(vt2, vc2, vt0); VctMlt(vt2, Tu());
    VctDff(vt3, vc3, vt0); VctMlt(vt3, Tu());
    VctDgn(vt1, vt0, vt1); VctDgn(vt2, vt0, vt2); VctDgn(vt3, vt0, vt3);
    StTrngl(polygon1, polygon2, polygon3, vt0, vt1, vt2, vt3);
}
*/
void DrwTrnglPlygn6(int n3, int n2v3, int vc1, int vc2, int vc3){
    int v1=newVector();//cylinder radius 分補正したベクトル
    int lv12=newVector(); int lv23=newVector(); int lv31=newVector();
    VctDff(lv12, vc2, vc1); VctDff(lv23, vc3, vc2); VctDff(lv31, vc1, vc3);
    float len=CyRd/GtVcSn(lv12, lv31);
    setVectorLength(lv12, len); setVectorLength(lv31, len);
    VctDff(v1, lv12, lv31); VctDgn(v1, vc1, v1);
    int v2=newVector();//cylinder radius 分補正したベクトル
    len=CyRd/GtVcSn(lv23, lv12);
    setVectorLength(lv23, len); setVectorLength(lv12, len);
    VctDff(v2, lv23, lv12); VctDgn(v2, vc2, v2);
    int v3=newVector();//cylinder radius 分補正したベクトル
    len=CyRd/GtVcSn(lv31, lv23);
    setVectorLength(lv31, len); setVectorLength(lv23, len);
    VctDff(v3, lv31, lv23); VctDgn(v3, vc3, v3);

    int v0=newVector();//center of gravity
    VctDgn(v0, vc1, vc2); VctDgn(v0, v0, vc3); VctMlt(v0, 1.0/3);
    int vt=newVector(v0);

    int v12=newVector();//edge center
    VctDgn(v12, v1, v2); VctMlt(v12, 1.0/2);
    int v23=newVector();//edge center
    VctDgn(v23, v2, v3); VctMlt(v23, 1.0/2);
    int v31=newVector();//edge center
    VctDgn(v31, v3, v1); VctMlt(v31, 1.0/2);

    VctDff(vt, v0, v12); VctMlt(vt, Tu()); VctDgn(vt, vt, v12);
    StTrngl0(TOct[n3][n2v3][0], vt, v1, v12);
    StTrngl0(TOct[n3][n2v3][1], vt, v12, v2);
    VctDff(vt, v0, v23); VctMlt(vt, Tu()); VctDgn(vt, vt, v23);
    StTrngl0(TOct[n3][n2v3][2], vt, v2, v23);
    StTrngl0(TOct[n3][n2v3][3], vt, v23, v3);
    VctDff(vt, v0, v31); VctMlt(vt, Tu()); VctDgn(vt, vt, v31);
    StTrngl0(TOct[n3][n2v3][4], vt, v3, v31);
    StTrngl0(TOct[n3][n2v3][5], vt, v31, v1);
}