#include "AnimationEditor.h"
#include "AnimationEditor_CharaSelect.h"
#include "AnimationEditor_AnimSelect.h"
#include "AnimationEditor_EventEdit.h"
#include "DxLib.h"
#include <string.h>
#include <math.h>

// 物理素材リストの座標と幅と高さ
#define PHYSMATTYPE_LIST_X          (SCREEN_WIDTH - ( PHYSMATTYPE_LIST_W + 24 ) )
#define PHYSMATTYPE_LIST_Y          (16 + TOOL_WINDOW_NAME_HEIGHT)
#define PHYSMATTYPE_LIST_W          (128)
#define PHYSMATTYPE_LIST_H          (100)

// セーブボタンの座標
#define SAVEBUTTON_X                (SCREEN_WIDTH  - 80)
#define SAVEBUTTON_Y                (SCREEN_HEIGHT - 30)

// セーブ完了表示をする時間
#define SAVECOMP_DISPTIME           (1.0f)

// セーブ完了表示をする座標
#define SAVECOMP_DISPTIME_X         (SCREEN_WIDTH  - 95)
#define SAVECOMP_DISPTIME_Y         (SCREEN_HEIGHT - 55)

// カメラのマウスによる移動速度
#define CAMERA_MOUSE_SPEED          (1.0f)

// カメラの角度変更速度
#define CAMERA_ANGLE_SPEED          (0.01f)

// カメラのマウスホイールによる移動速度
#define CAMERA_MOUSE_WHEEL_SPEED    (60.0f)

// アニメーションの再生速度
#define ANIM_SPEED                  (30.0f)


// アニメーションエディターの情報
SAnimEditorData g_AEData;


// アニメーションエディターの初期化を行う
//     戻り値 : 初期化が成功したか( true:成功した  false:失敗した )
static bool AnimationEditor_Initialize( void );

// アニメーションエディターの後始末を行う
static void AnimationEditor_Terminate( void );

// アニメーションエディターのメインループを行う
//     戻り値 : 処理が正常に終了したかどうか(true:正常に終了した  false:エラーが発生した)
static bool AnimationEditor_MainLoop( void );

// アニメーション情報を保存する
//     戻り値 : アニメーションデータの保存に成功したかどうか
//              ( true:成功した  false:失敗した )
static bool SaveAnimInfo( void );

// マウスの状態推移処理を行う
static void Mouse_Step( void );

// カメラ処理の初期化を行う
static void CameraInitialize( void );

// カメラのセットアップを行う
static void CameraSetup( void );

// 指定の範囲内のイベントが存在するかチェックをして、存在した場合はイベントを処理する
static void EventCheck(
    // チェックする範囲の開始位置
    float StartTime,

    // チェックする範囲の開始位置
    float EndTime
);

// アニメーションの状態推移処理を行う
static void AnimStep(
    // 推移させる時間( 単位：秒 )
    float StepTime
);

// 状態推移処理を行う
//     戻り値 : 処理が正常に終了したかどうか(true:正常に終了した  false:エラーが発生した)
static bool Step(
    // 推移させる時間( 単位：秒 )
    float StepTime
);

// 描画処理を行う
static void Render( void );

// キャラ選択・アニメーション選択・イベント編集の表示をＯＦＦにする
void MainUIHide( void )
{
    // キャラクター選択処理の表示状態をＯＦＦにする
    CharaSelect_SetVisible( false );

    // アニメーション選択処理の表示状態をＯＦＦにする
    AnimSelect_SetVisible( false );

    // イベント編集処理の表示状態をＯＦＦにする
    EventEdit_SetVisible( false );
}

// アニメーション情報を保存する
//     戻り値 : アニメーションデータの保存に成功したかどうか
//              ( true:成功した  false:失敗した )
static bool SaveAnimInfo( void )
{
    int                 i;
    int                 j;
    SCharaAnimBaseInfo *CMInfo;
    SCharaBaseInfo     *CBInfo;
    char                FilePath[ MAX_PATH ];

    // キャラの数だけ繰り返し
    for( i = 0; i < EChara_Num; i++, CBInfo++ )
    {
        CBInfo = CharaBase_GetInfo( ( EChara )i );
        CMInfo = CBInfo->AnimInfo;

        // アニメーションの数だけ繰り返し
        for( j = 0; j < ECharaAnim_Num; j++, CMInfo++ )
        {
            // アニメーションが存在しない場合は次のループへ
            if( CMInfo->Handle <= 0 )
            {
                continue;
            }

            // アニメーションの内容が何も変更されていない場合は次のループへ
            if( !CMInfo->Info.Change )
            {
                continue;
            }

            // 保存ファイルパスを作成
            sprintf( FilePath, CHARADATA_DIR "%s\\%s", CBInfo->DirectoryName,
                    CharaBase_GetAnimFileInfo( ( ECharaAnim )j )->FileName );

            // アニメーション情報をファイルに保存する
            if( !SaveAnimInfoFile( &CMInfo->Info, FilePath ) )
            {
                MessageBox( NULL, "セーブに失敗しました。", "セーブ失敗", MB_OK );
                return false;
            }
        }
    }

    // 「ｾｰﾌﾞ完了」を表示する時間をセット
    g_AEData.SaveCompDispTime = SAVECOMP_DISPTIME;

    // 正常終了
    return true;
}

// マウスの状態推移処理を行う
static void Mouse_Step( void )
{
    int MouseInput;
    int MouseX;
    int MouseY;
    int MouseMoveX;
    int MouseMoveY;
    int MouseWheelRot;

    // 現在のマウスカーソルの座標を取得
    GetMousePoint( &MouseX, &MouseY );

    // マウスのボタン押下状態を取得
    MouseInput = GetMouseInput();

    // マウスホイールの回転数を取得
    MouseWheelRot = GetMouseWheelRotVol();

    // マウスカーソルの移動量を算出
    MouseMoveX = MouseX - g_AEData.MouseBackX;
    MouseMoveY = MouseY - g_AEData.MouseBackY;

    // マウスの中心ボタンがクリックされていたら
    // マウスカーソルの移動量に合わせてカメラの注視点をマウスから見た上下方向に移動
    if( MouseInput & MOUSE_INPUT_MIDDLE )
    {
        g_AEData.Camera.LookAtPosition.y += MouseMoveY * CAMERA_MOUSE_SPEED; 
    }
    else
    // マウスの右ボタンがクリックされていたらカメラの向きを変更
    if( MouseInput & MOUSE_INPUT_RIGHT )
    {
        g_AEData.Camera.HAngle -= CAMERA_ANGLE_SPEED * MouseMoveX;
        if( g_AEData.Camera.HAngle < 0.0f )
        {
            g_AEData.Camera.HAngle += DX_PI_F * 2.0f;
        }
        else
        if(  g_AEData.Camera.HAngle >= DX_PI_F * 2.0f )
        {
            g_AEData.Camera.HAngle -= DX_PI_F * 2.0f;
        }

        g_AEData.Camera.VAngle += CAMERA_ANGLE_SPEED * MouseMoveY;
        if( g_AEData.Camera.VAngle < -( DX_PI_F / 2.0f - 0.1f ) )
        {
            g_AEData.Camera.VAngle = -( DX_PI_F / 2.0f - 0.1f );
        }
        if( g_AEData.Camera.VAngle > DX_PI_F / 2.0f - 0.1f )
        {
            g_AEData.Camera.VAngle = DX_PI_F / 2.0f - 0.1f;
        }
    }

    // マウスホイールが回転されたらカメラの位置をカメラから見た前後の方向に移動
    if( MouseWheelRot != 0 )
    {
        g_AEData.Camera.Distance += MouseWheelRot * CAMERA_MOUSE_WHEEL_SPEED;
    }

    // マウスの座標を保存
    g_AEData.MouseBackX = MouseX;
    g_AEData.MouseBackY = MouseY;
}

// 状態推移処理を行う
//     戻り値 : 処理が正常に終了したかどうか(true:正常に終了した  false:エラーが発生した)
static bool Step(
    // 推移させる時間( 単位：秒 )
    float StepTime
)
{
    // 「ｾｰﾌﾞ完了」の表示を行う残り時間を減らす処理を行う
    if( g_AEData.SaveCompDispTime > 0.0f )
    {
        g_AEData.SaveCompDispTime -= StepTime;
        if( g_AEData.SaveCompDispTime < 0.0f )
        {
            g_AEData.SaveCompDispTime = 0.0f;
        }
    }

    // マウスの状態推移処理を行う
    Mouse_Step();

    // ツール処理の状態推移処理を行う
    if( !Tool_Step( StepTime ) )
    {
        return false;
    }

    // 物理音の素材タイプリストの状態が変化したら、物理音の素材タイプを変更する
    if( ToolList_GetChange( g_AEData.PhysMatTypeTList, true ) )
    {
        g_AEData.PhysMatType =
            ( EMaterialType )ToolList_GetSelectIndex( g_AEData.PhysMatTypeTList );
    }

    // セーブボタンが押されたらアニメーションデータのセーブ処理を行う
    if( ToolButton_GetClick( g_AEData.SaveTButton, true ) )
    {
        SaveAnimInfo();
    }

    // 編集モードによって処理を分岐
    switch( g_AEData.Mode )
    {
    case EEditMode_CharaSelect:
        // キャラ選択処理の状態推移処理を行う
        if( !CharaSelect_Step() )
        {
            return false;
        }
        break;

    case EEditMode_AnimSelect:
        // アニメーション選択処理の状態推移処理を行う
        if( !AnimSelect_Step() )
        {
            return false;
        }
        break;

    case EEditMode_EventEdit:
        // イベント編集処理の状態推移処理を行う
        if( !EventEdit_Step( StepTime ) )
        {
            return false;
        }
        break;
    }

    // アニメーションの状態推移処理を行う
    AnimStep( g_AEData.StepTime );

    // 正常終了
    return true;
}

// 描画処理を行う
static void Render( void )
{
    int             i;
    MATRIX          FrameMat;
    SCharaBaseInfo *CBInfo;

    // カメラのセットアップを行う
    CameraSetup();

    CBInfo = CharaBase_GetInfo( g_AEData.TargetChara );

    // キャラ本体の３Ｄモデルを描画する
    MV1DrawModel( CBInfo->ModelHandle );

    // キャラのサブ３Ｄモデルがある場合はサブ３Ｄモデルを描画する
    for( i = 0; i < CBInfo->SubModelNum; i++ )
    {
        // サブ３Ｄモデルをアタッチするフレームのローカル→ワールド変換行列を取得する
        FrameMat = MV1GetFrameLocalWorldMatrix(
            CBInfo->ModelHandle, CBInfo->SubModel[ i ].AttachFrameIndex );

        // サブ３Ｄモデルハンドルに取得した変換行列をセットする
        MV1SetMatrix( CBInfo->SubModel[ i ].ModelHandle, FrameMat );

        // サブ３Ｄモデルを描画
        MV1DrawModel( CBInfo->SubModel[ i ].ModelHandle );
    }

    // 編集モードによって処理を分岐
    switch( g_AEData.Mode )
    {
    case EEditMode_CharaSelect:
        // キャラ選択処理の描画処理を行う
        CharaSelect_Render();
        break;

    case EEditMode_AnimSelect:
        // アニメーション選択処理の描画処理を行う
        AnimSelect_Render();
        break;

    case EEditMode_EventEdit:
        // イベント編集処理の描画処理を行う
        EventEdit_Render();
        break;
    }

    // 「ｾｰﾌﾞ完了」の表示時間が０では無い場合は「ｾｰﾌﾞ完了」を描画する
    if( g_AEData.SaveCompDispTime > 0.001f )
    {
        DrawString( SAVECOMP_DISPTIME_X, SAVECOMP_DISPTIME_Y,
                                "ｾｰﾌﾞ完了", GetColor( 255,255,0 ) );
    }

    // ツール処理の描画処理を行う
    Tool_Draw();
}

// カメラ処理の初期化を行う
static void CameraInitialize( void )
{
    g_AEData.Camera.HAngle         = DX_PI_F;
    g_AEData.Camera.VAngle         = 0.05f;
    g_AEData.Camera.Distance       = 270.0f;
    g_AEData.Camera.LookAtPosition = VGet( 0.0f, 75.0f, 0.0f );
}

// カメラのセットアップを行う
static void CameraSetup( void )
{
    VECTOR RootPosition;
    float  Sin;
    float  Cos;

    // カメラが映す手前距離と置く距離を設定
    SetCameraNearFar( 10.0f, 3000.0f );

    // 編集対象のキャラのルートフレームの座標を取得する
    RootPosition = MV1GetFramePosition(
                        CharaBase_GetInfo( g_AEData.TargetChara )->ModelHandle,
                        CharaBase_GetInfo( g_AEData.TargetChara )->RootFrameIndex );

    // 注視点のx,z座標を編集対象のキャラのルートフレームの座標にする
    g_AEData.Camera.LookAtPosition.x = RootPosition.x;
    g_AEData.Camera.LookAtPosition.z = RootPosition.z;

    // カメラの座標を算出
    Sin = sin( g_AEData.Camera.VAngle );
    Cos = cos( g_AEData.Camera.VAngle );
    g_AEData.Camera.EyePosition.x = 0.0f;
    g_AEData.Camera.EyePosition.z =   Cos * g_AEData.Camera.Distance;
    g_AEData.Camera.EyePosition.y =   Sin * g_AEData.Camera.Distance;

    Sin = sin( g_AEData.Camera.HAngle );
    Cos = cos( g_AEData.Camera.HAngle );
    g_AEData.Camera.EyePosition.x = - Sin * g_AEData.Camera.EyePosition.z;
    g_AEData.Camera.EyePosition.z =   Cos * g_AEData.Camera.EyePosition.z;

    g_AEData.Camera.EyePosition =
        VAdd( g_AEData.Camera.EyePosition, g_AEData.Camera.LookAtPosition );

    // カメラが向いている方向のベクトルを算出
    g_AEData.Camera.Direction =
        VNorm( VSub( g_AEData.Camera.LookAtPosition, g_AEData.Camera.EyePosition ) );

    // カメラから見た右方向を算出
    g_AEData.Camera.Right =
        VNorm( VCross( g_AEData.Camera.Direction, VGet( 0.0f, -1.0f, 0.0f ) ) );

    // カメラの設定を描画処理に反映する
    SetCameraPositionAndTarget_UpVecY(
        g_AEData.Camera.EyePosition, g_AEData.Camera.LookAtPosition );

    // ３Ｄサウンドのリスナーの位置と方向を設定( カメラの位置と向きを設定 )
    Set3DSoundListenerPosAndFrontPos_UpVecY(
        g_AEData.Camera.EyePosition, g_AEData.Camera.LookAtPosition );
}

// キャラクターモデルにアタッチするアニメーションをセットアップする
void SetupAttachAnim( void )
{
    SCharaBaseInfo *CBInfo;

    // 既にアニメーションをアタッチしている可能性があるので、デタッチ処理をしておく
    MV1DetachAnim( g_AEData.AnimAttachModelHandle, g_AEData.AnimAttachIndex );
    MV1DetachAnim( g_AEData.AnimAttachModelHandle, g_AEData.NextAnimAttachIndex );

    // アニメーションの新しいアタッチ先の３Ｄモデルハンドルを取得
    CBInfo = CharaBase_GetInfo( g_AEData.TargetChara );
    g_AEData.AnimAttachModelHandle = CBInfo->ModelHandle;

    // 編集対象のアニメーションを３Ｄモデルにアタッチ
    g_AEData.AnimAttachIndex = MV1AttachAnim(
        CBInfo->ModelHandle, 0, CBInfo->AnimInfo[ g_AEData.TargetAnim ].Handle, 0 );

    // アニメーションキャンセル後に再生するアニメーションを３Ｄモデルにアタッチ
    g_AEData.NextAnimAttachIndex = MV1AttachAnim(
        CBInfo->ModelHandle, 0, CBInfo->AnimInfo[ g_AEData.NextAnim ].Handle,   0 );

    // 編集対象のアニメーションのブレンド率を１００％に、
    // アニメーションキャンセル後に再生するアニメーションのブレンド率を０％にする
    MV1SetAttachAnimBlendRate(
        g_AEData.AnimAttachModelHandle, g_AEData.AnimAttachIndex,     1.0f );

    MV1SetAttachAnimBlendRate(
        g_AEData.AnimAttachModelHandle, g_AEData.NextAnimAttachIndex, 0.0f );
}

// キャラクターモデルにアタッチしたアニメーションの再生時間をセットアップする
void SetupAttachAnimTime( void )
{
    SAnimInfo      *AInfo;
    SAnimEventInfo *AEInfo;

    // アニメーションの再生を停止状態にする
    g_AEData.AnimPlay = false;

    AInfo = &CharaBase_GetInfo(g_AEData.TargetChara)->AnimInfo[g_AEData.TargetAnim].Info;
    AEInfo = &AInfo->Event[ g_AEData.TargetEvent ];

    // イベントの時間をアタッチしたアニメーションの再生時間にセットする
    MV1SetAttachAnimTime(
        g_AEData.AnimAttachModelHandle, g_AEData.AnimAttachIndex, AEInfo->TimeF );

    // 編集対象のアニメーションのブレンド率を１００％に、
    // アニメーションキャンセル後に再生するアニメーションのブレンド率を０％にする
    MV1SetAttachAnimBlendRate(
        g_AEData.AnimAttachModelHandle, g_AEData.AnimAttachIndex,     1.0f );

    MV1SetAttachAnimBlendRate(
        g_AEData.AnimAttachModelHandle, g_AEData.NextAnimAttachIndex, 0.0f );
}

// アニメーションの再生を開始する
void AnimPlay( void )
{
    g_AEData.AnimPlay         = true;
    g_AEData.AnimPlayTime     = 0.0f;
    g_AEData.NextAnimPlay     = false;
    g_AEData.NextAnimPlayTime = 0.0f;
}

// アニメーションの再生を停止する
void AnimStop( void )
{
    g_AEData.AnimPlay         = false;
    g_AEData.AnimPlayTime     = 0.0f;
    g_AEData.NextAnimPlay     = false;
    g_AEData.NextAnimPlayTime = 0.0f;
}

// アニメーションの状態推移処理を行う
static void AnimStep(
    // 推移させる時間( 単位：秒 )
    float StepTime
)
{
    float BackPlayTime;
    float TotalTime;
    bool  StopFlag = false;

    // アニメーションが再生中では無い場合は何もせずに終了
    if( !g_AEData.AnimPlay )
    {
        return;
    }

    // アニメーションキャンセル後はアニメーションキャンセル後に
    // 再生するアニメーションの処理を行う
    if( g_AEData.NextAnimPlay )
    {
        // アニメーションキャンセル後に再生するアニメーションの総時間を取得
        TotalTime = MV1GetAttachAnimTotalTime(
                g_AEData.AnimAttachModelHandle, g_AEData.NextAnimAttachIndex );

        // 再生時間を進める
        g_AEData.NextAnimPlayTime += StepTime * ANIM_SPEED;

        // アニメーションの終端まできたら再生処理を停止する
        if( g_AEData.NextAnimPlayTime > TotalTime )
        {
            g_AEData.NextAnimPlayTime = TotalTime;
            StopFlag = true;
        }

        // 再生時間をセット
        MV1SetAttachAnimTime(
            g_AEData.AnimAttachModelHandle,
            g_AEData.NextAnimAttachIndex,
            g_AEData.NextAnimPlayTime
        );

        // アニメーションキャンセル後に再生するアニメーションのブレンド率を１００％にする
        MV1SetAttachAnimBlendRate(
            g_AEData.AnimAttachModelHandle, g_AEData.NextAnimAttachIndex, 1.0f );

        MV1SetAttachAnimBlendRate(
            g_AEData.AnimAttachModelHandle, g_AEData.AnimAttachIndex,     0.0f );
    }
    else
    {
        // アニメーションの総時間を取得
        TotalTime = MV1GetAttachAnimTotalTime(
                g_AEData.AnimAttachModelHandle, g_AEData.AnimAttachIndex );

        // 進める前の再生時間を保存しておく
        BackPlayTime = g_AEData.AnimPlayTime;

        // 再生時間を進める
        g_AEData.AnimPlayTime += StepTime * ANIM_SPEED;

        // アニメーションの総再生時間を超えたら処理を分岐
        if( g_AEData.AnimPlayTime > TotalTime )
        {
            // ループタイプのアニメーションの場合はアニメーションをループさせる
            if( CharaBase_GetAnimFileInfo( g_AEData.TargetAnim )->LoopFlag )
            {
                g_AEData.AnimPlayTime -= TotalTime;
            }
            else
            {
                // ループタイプでは無い場合は再生を停止する
                g_AEData.AnimPlayTime = 0.0f;
                StopFlag = true;
            }
        }

        // イベントのチェック＋処理、終端まで再生したかどうかで引数を変更する
        EventCheck( BackPlayTime, StopFlag ? -1.0f : g_AEData.AnimPlayTime );

        // 再生時間をセット
        MV1SetAttachAnimTime(
            g_AEData.AnimAttachModelHandle,
            g_AEData.AnimAttachIndex,
            g_AEData.AnimPlayTime
        );

        // アニメーションキャンセル後に再生するアニメーションのブレンド率を０％にする
        MV1SetAttachAnimBlendRate(
            g_AEData.AnimAttachModelHandle, g_AEData.NextAnimAttachIndex, 0.0f );

        MV1SetAttachAnimBlendRate(
            g_AEData.AnimAttachModelHandle, g_AEData.AnimAttachIndex,     1.0f );
    }

    // 再生が停止したかどうかで処理を分岐
    if( StopFlag )
    {
        // アニメーションの再生を停止する
        AnimStop();

        if( g_AEData.Mode == EEditMode_EventEdit )
        {
            // キャラクターモデルにアタッチしたアニメーションの再生時間をセットアップする
            SetupAttachAnimTime();
        }
    }
}

// 指定の範囲内のイベントが存在するかチェックをして、存在した場合はイベントを処理する
static void EventCheck(
    // チェックする範囲の開始位置
    float StartTime,

    // チェックする範囲の開始位置
    float EndTime
)
{
    SAnimInfo            *AInfo;
    const SAnimEventInfo *AEInfo;
    SAnimEventCheck       AEventCheck;
    SCharaBaseInfo       *CBInfo;
    int                   i;

    CBInfo = CharaBase_GetInfo( g_AEData.TargetChara );
    AInfo  = &CBInfo->AnimInfo[ g_AEData.TargetAnim ].Info;

    // 指定の時間範囲にあるイベントを取得する
    AnimInfoEventCheck( AInfo, &AEventCheck, StartTime, EndTime );

    // 指定の時間範囲にあるイベントを全て処理する
    for( i = 0; i < AEventCheck.EventNum; i++ )
    {
        AEInfo = AEventCheck.Event[ i ];

        // イベントのタイプによって処理を分岐
        switch( AEInfo->Type )
        {
        case EAnimEventType_AnimCancel:     // アニメーションキャンセルイベント
            // アニメーションキャンセルが無効な場合は何もしない
            if( !g_AEData.NextAnimValid )
            {
                break;
            }

            // アニメーションキャンセルをしたかどうかのフラグを立てる
            g_AEData.NextAnimPlay = true;

            // アニメーションキャンセル後に再生するアニメーションの再生時間をセット
            g_AEData.NextAnimPlayTime = g_AEData.AnimPlayTime - AEInfo->TimeF;
            MV1SetAttachAnimTime(
                g_AEData.AnimAttachModelHandle,
                g_AEData.NextAnimAttachIndex,
                g_AEData.NextAnimPlayTime
            );

            // アニメーションキャンセル後に再生するアニメーションのブレンド率を１００％にする
            MV1SetAttachAnimBlendRate(
                g_AEData.AnimAttachModelHandle, g_AEData.NextAnimAttachIndex, 1.0f );

            MV1SetAttachAnimBlendRate(
                g_AEData.AnimAttachModelHandle, g_AEData.AnimAttachIndex,     0.0f );
            break;

        case EAnimEventType_Sound:          // サウンド再生イベント
            // イベントに設定されているサウンドを再生する
            Sound_PlaySound3D(
                VGet( 0.0f, 0.0f, 0.0f ), AEInfo->SoundHandle, DX_PLAYTYPE_BACK );
            break;

        case EAnimEventType_PhysicsSound:   // 物理サウンド再生イベント
            // 対応する物理サウンドが無い場合は何もしない
            if( CBInfo->AnimPhysicsSound[ AEInfo->PhysicsSound ][ g_AEData.PhysMatType ] == -1 )
            {
                break;
            }

            // 物理サウンドに対応した物理素材の音を再生する
            Sound_PlaySound3D(
                VGet( 0.0f, 0.0f, 0.0f ),
                CBInfo->AnimPhysicsSound[ AEInfo->PhysicsSound ][ g_AEData.PhysMatType ],
                DX_PLAYTYPE_BACK
            );
            break;
        }
    }
}

// アニメーションエディターの初期化を行う
//     戻り値 : 初期化が成功したか( true:成功した  false:失敗した )
static bool AnimationEditor_Initialize( void )
{
    int i;

    // ウインドウモードで起動する
    ChangeWindowMode( TRUE );

    // 画面の解像度を設定
    SetGraphMode( SCREEN_WIDTH, SCREEN_HEIGHT, 32 );

    // ウインドウのテキストを設定
    SetWindowText( "Anim Editor" );

    // ３Ｄサウンドの１メートル当たりの値を設定
    Set3DSoundOneMetre( 100.0f ) ;

    // ＤＸライブラリを初期化
    if( DxLib_Init() < 0 )
    {
        return false;
    }

    // 背景は暗い緑色にする
    SetBackgroundColor( 0, 128, 0 );

    // フォントの初期化を行う
    ChangeFontType( DX_FONTTYPE_ANTIALIASING_EDGE_8X8 );
    SetFontThickness( 1 );
    SetFontSize( 20 );

    //裏画面を描画対象にする
    SetDrawScreen( DX_SCREEN_BACK );

    // カメラ処理の初期化を行う
    CameraInitialize();

    // ツール処理の初期化を行う
    if( !Tool_Initialize() )
    {
        return false;
    }

    // キャラ基本情報を初期化
    if( !CharaBase_Initialize() )
    {
        return false;
    }

    // 編集モードをキャラ選択モードにする
    g_AEData.Mode        = EEditMode_CharaSelect;
    g_AEData.TargetChara = ( EChara )0;
    g_AEData.TargetAnim  = ( ECharaAnim )0;

    // 物理素材タイプリスト表示用ウインドウの作成
    g_AEData.PhysMatTypeTWindow = ToolWindow_Create( 
        -1, false, true, false, "物理音素材一覧",
        PHYSMATTYPE_LIST_X, PHYSMATTYPE_LIST_Y,
        PHYSMATTYPE_LIST_W, PHYSMATTYPE_LIST_H,
        PHYSMATTYPE_LIST_W, PHYSMATTYPE_LIST_H
    );
    if( g_AEData.PhysMatTypeTWindow == -1 )
    {
        return false;
    }

    // 物理素材タイプリストの作成
    g_AEData.PhysMatTypeTList = ToolList_Create();
    if( g_AEData.PhysMatTypeTList == -1 )
    {
        return false;
    }

    // 物理素材タイプリストの初期化
    ToolList_Initialize( g_AEData.PhysMatTypeTList, g_AEData.PhysMatTypeTWindow );

    // 全ての物理素材タイプをリストに追加する
    for( i = 0; i < EMaterialType_Num; i++ )
    {
        if( !ToolList_AddObj(
                g_AEData.PhysMatTypeTList, GetMaterialTypeName( ( EMaterialType )i ) ) )
        {
            return false;
        }
    }

    // セーブボタンの作成
    g_AEData.SaveTButton = ToolButton_Create(
        false, "SAVE", SAVEBUTTON_X, SAVEBUTTON_Y, 50, BUTTON_H );

    // キャラ選択処理の初期化を行う
    if( !CharaSelect_Initialize() )
    {
        return false;
    }

    // アニメーション選択処理の初期化を行う
    if( !AnimSelect_Initialize() )
    {
        return false;
    }

    // イベント編集処理の初期化を行う
    if( !EventEdit_Initialize() )
    {
        return false;
    }

    // キャラ選択・アニメーション選択・イベント編集の表示をＯＦＦにする
    MainUIHide();

    // キャラ選択処理のキャラリストをセットアップする
    CharaSelect_SetupList();

    // キャラクターモデルにアタッチするアニメーションをセットアップする
    SetupAttachAnim();

    // アニメーションの再生を開始する
    AnimPlay();

    // 正常終了
    return true;
}

// アニメーションエディターの後始末を行う
static void AnimationEditor_Terminate( void )
{
    // ツールの後始末処理を行う
    Tool_Terminate();

    // キャラの基本情報の後始末を行う
    CharaBase_Terminate();

    // ＤＸライブラリの後始末を行う
    DxLib_End();
}

// アニメーションエディターのメインループを行う
//     戻り値 : 処理が正常に終了したかどうか(true:正常に終了した  false:エラーが発生した)
static bool AnimationEditor_MainLoop( void )
{
    LONGLONG NowTime;

    // 現在の時間を取得する
    g_AEData.TimeTemp = GetNowHiPerformanceCount();

    // 最初のフレームの仮の経過時間を設定する
    g_AEData.StepTime = 0.01f;

    // ウインドウが閉じられるか、エラーが発生するまでループ
    while( ProcessMessage() == 0 )
    {
        // 状態推移処理を行う
        if( !Step( g_AEData.StepTime ) )
        {
            return false;
        }

        // 描画処理を行う
        Render();

        // 裏画面の内容を表画面に反映する
        ScreenFlip();

        // 現在の時間を取得する
        NowTime = GetNowHiPerformanceCount();

        // 経過時間を算出する
        g_AEData.StepTime = ( NowTime - g_AEData.TimeTemp ) / 1000000.0f;

        // 現在の時間を保存する
        g_AEData.TimeTemp = NowTime;

        // 画面をクリアする
        ClearDrawScreen();
    }

    // 正常終了
    return true;
}

// アニメーションエディターのメイン処理
//     戻り値 : 正常に処理が完了したかどうか
//              ( true : 正常に処理を完了した   false : エラーが発生した )
bool AnimationEditor_Main( void )
{
    // アニメーションエディターの初期化を行う
    if( !AnimationEditor_Initialize() )
    {
        return false;
    }

    // アニメーションエディターのメインループを行う
    if( !AnimationEditor_MainLoop() )
    {
        return false;
    }

    // アニメーションエディターの後始末をする
    AnimationEditor_Terminate();

    // 正常終了
    return true;
}