#module Math2Disp
// Math2Disp module Ver.0.30 by fujidig

// 軸
#enum AXIS_X = 0
#enum AXIS_Y
#enum NUM_AXIS

#deffunc _init@Math2Disp
    // 初期化

    ddim size, NUM_AXIS
    size( AXIS_X ) = 32.0
    size( AXIS_Y ) = -32.0
    ddim orgPos, NUM_AXIS
    orgPos( AXIS_X ) = double( ginfo_sx ) / 2
    orgPos( AXIS_Y ) = double( ginfo_sy ) / 2
    return

#defcfunc IsInvalidAxis@Math2Disp int axis
    // 正しくない軸の値か ( Private )
    // IsInvalidAxis( axis )
    //  axis      : 軸の値
    //  戻り値    : 正しい値か否かの真偽値

    return ( ( axis < 0 ) || ( axis >= NUM_AXIS ) )

#defcfunc getOtherAxis@Math2Disp int axis
    // もう一方の軸の値を取得 ( Private )
    // IsInvalidAxis( axis )
    //  axis      : 軸の値
    //  戻り値    : axis に対してもう一方の軸の値

    if ( axis == AXIS_X ) {
        return AXIS_Y
    } else {
        return AXIS_X
    }

#deffunc backupData@Math2Disp var backup
    // size と orgPos を一つの変数に保存 ( Private )
    // backupData backup
    //  backup    : 保存先変数

    sdim backup, NUM_AXIS * 8 * 2 // size と orgPos が入るだけのサイズ
    memcpy backup, size,   NUM_AXIS * 8
    memcpy backup, orgPos, NUM_AXIS * 8, NUM_AXIS * 8
    return

#deffunc restoreData@Math2Disp var backup
    // 保存した変数から size と orgPos に復元
    // restoreData backup
    //  backup    : 復元元変数

    memcpy size,   backup, NUM_AXIS * 8
    memcpy orgPos, backup, NUM_AXIS * 8, 0, NUM_AXIS * 8
    return

#deffunc _setSize@Math2Disp int axis, double dispSize, double mathSize
#define setSize( %1, %2, %3 = 1 ) _setSize %1, %2, %3
    // 指定した軸のサイズを指定する ( Private )
    // setSize axis, dispSize, mathSize
    //  axis      : 軸
    //  dispSize  : ディスプレイ座標でのサイズ (ピクセル)
    //  mathSize  : dispSize に対応する数学座標でのサイズ
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    if ( ( dispSize == 0.0 ) || ( mathSize == 0.0 ) ) {
        return 1
    }
    if ( IsInvalidAxis( axis ) ) {
        return 1
    }
    size( axis ) = dispSize / mathSize
    if ( axis == AXIS_Y ) {
        size( axis ) *= -1    // Y軸の場合は反転
    }
    return 0

#deffunc _m2d_SetXSize double dispSize, double mathSize
#define global m2d_SetXSize( %1, %2 = 1 ) _m2d_SetXSize %1, %2
    // X軸のサイズを指定する
    // m2d_SetXSize dispSize, mathSize
    //  dispSize  : ディスプレイ座標でのサイズ (ピクセル)
    //  mathSize  : dispSize に対応する数学座標でのサイズ
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    setSize AXIS_X, dispSize, mathSize
    return stat

#deffunc _m2d_SetYSize double dispSize, double mathSize
#define global m2d_SetYSize( %1, %2 = 1 ) _m2d_SetYSize %1, %2
    // Y軸のサイズを指定する
    // m2d_SetYSize dispSize, mathSize
    //  dispSize  : ディスプレイ座標でのサイズ (ピクセル)
    //  mathSize  : dispSize に対応する数学座標でのサイズ
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    setSize AXIS_Y, dispSize, mathSize
    return stat

#deffunc _m2d_SetSize double dispXSize, double dispYSize, double mathXSize, double mathYSize, local backup, local result
#define global m2d_SetSize( %1, %2, %3 = 1, %4 = 1 ) _m2d_SetSize %1, %2, %3, %4
    // X軸、Y軸両方のサイズを指定する
    // m2d_SetSize dispXSize, dispYSize, mathXSize, mathYSize
    //  dispXSize : ディスプレイ座標でのX軸のサイズ (ピクセル)
    //  dispYSize : ディスプレイ座標でのY軸のサイズ (ピクセル)
    //  mathXSize : dispXSize に対応する数学座標でのサイズ
    //  mathYSize : dispYSize に対応する数学座標でのサイズ
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    backupData backup
    m2d_SetXSize dispXSize, mathXSize
    result = stat
    if ( result != 0 ) {
        restoreData backup
        return result
    }
    m2d_SetYSize dispYSize, mathYSize
    result = stat
    if ( result != 0 ) {
        restoreData backup
        return result
    }
    return 0

#defcfunc _GetSize@Math2Disp int axis, double mathSize, local dispSize
#define ctype GetSize( %1 = 1, %2 ) _GetSize( %1, %2 )
    // 指定した軸のサイズを取得する ( Private )
    // GetSize( axis, mathSize )
    //  axis      : 軸
    //  mathSize  : 数学座標のサイズ
    //  戻り値    : mathSize に対応するディスプレイサイズ

    dispSize = size( axis ) * mathSize
    if ( axis == AXIS_Y ) {
        dispSize *= -1    // Y軸の場合は反転
    }
    return dispSize

#defcfunc _m2d_GetSizeX double mathSize
#define global ctype m2d_GetSizeX( %1 = 1 ) _m2d_GetSizeX( %1 )
    // X軸のディスプレイサイズを取得する
    // m2d_GetSizeX( mathSize )
    //  mathSize  : 数学座標のサイズ
    //  戻り値    : mathSize に対応するディスプレイサイズ

    return GetSize( AXIS_X, mathSize )

#defcfunc _m2d_GetSizeY double mathSize
#define global ctype m2d_GetSizeY( %1 = 1 ) _m2d_GetSizeY( %1 )
    // Y軸のディスプレイサイズを取得する
    // m2d_GetSizeY( mathSize )
    //  mathSize  : 数学座標のサイズ
    //  戻り値    : mathSize に対応するディスプレイサイズ

    return GetSize( AXIS_Y, mathSize )

#deffunc _setPos@Math2Disp int axis, double disp, double math
#define setPos( %1, %2, %3 = 0 ) _setPos %1, %2, %3
    // 指定した軸のディスプレイ座標を設定 ( Private )
    // setPos axis, disp, math
    //  axis      : 軸
    //  disp      : ディスプレイ座標（ピクセル）
    //  math      : dispに対応する数学座標
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    if ( IsInvalidAxis( axis ) ) {
        return 1
    }
    orgPos( axis ) = ( disp - size( axis ) * math )
    return 0

#deffunc _m2d_setPosX double disp, double math
#define global m2d_setPosX( %1, %2 = 0 ) _m2d_setPosX %1, %2
    // X軸のディスプレイ座標を設定
    // setPosX disp, math
    //  disp      : ディスプレイ座標（ピクセル）
    //  math      : disp に対応する数学座標
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    setPos AXIS_X, disp, math
    return stat

#deffunc _m2d_setPosY double disp, double math
#define global m2d_setPosY( %1, %2 = 0 ) _m2d_setPosY %1, %2
    // Y軸のディスプレイ座標を設定
    // setPosY disp, math
    //  disp      : ディスプレイ座標（ピクセル）
    //  math      : disp に対応する数学座標
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    setPos AXIS_Y, disp, math
    return stat

#deffunc _m2d_SetPos double dispX, double dispY, double mathX, double mathY, local backup, local result
#define global m2d_SetPos( %1, %2, %3 = 0, %4 = 0 ) _m2d_SetPos %1, %2, %3, %4
    // 原点の位置(ピクセル)を指定
    // m2d_SetPos dispX, dispY, mathX, mathY
    //  dispX     : ディスプレイX座標（ピクセル）
    //  dispY     : ディスプレイY座標（ピクセル）
    //  mathX     : dispX に対応する数学座標
    //  mathY     : dispY に対応する数学座標
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    backupData backup
    m2d_setPosX dispX, mathX
    result = stat
    if ( result != 0 ) {
        restoreData backup
        return result
    }
    m2d_setPosY dispY, mathY
    result = stat
    if ( result != 0 ) {
        restoreData backup
        return result
    }
    return 0

#deffunc m2d_Set double dispX1, double dispY1, double mathX1, double mathY1, \
                 double dispX2, double dispY2, double mathX2, double mathY2, local backup, local result
    // 二点の座標とそれに対応する数学座標から位置とサイズを設定
    // m2d_Set dispX1, dispY1, mathX1, mathY1, dispX2, dispY2, mathX2, mathY2
    //  dispX1    : 一つ目のディスプレイX座標
    //  dispY1    : 一つ目のディスプレイY座標
    //  mathX1    : dispX1 に対応する数学座標
    //  mathY1    : dispY1 に対応する数学座標
    //  dispX2    : 二つ目のディスプレイX座標
    //  dispY2    : 二つ目のディスプレイY座標
    //  mathX2    : dispX2 に対応する数学座標
    //  mathY2    : dispY2 に対応する数学座標
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    backupData backup
    m2d_SetSize dispX2 - dispX1, dispY2 - dispY1, mathX2 - mathX1, mathY1 - mathY2
    result = stat
    if ( stat != 0 ) {
        restoreData backup
        return stat
    }
    m2d_SetPos dispX1, dispY1, mathX1, mathY1
    result = stat
    if ( stat != 0 ) {
        restoreData backup
        return stat
    }
    return 0

#defcfunc _GetDisp@Math2Disp int axis, double math
#define ctype GetDisp( %1, %2 = 0 ) _GetDisp( %1, %2 )
    // 指定した軸の数学座標からディスプレイ座標を取得 ( Private )
    // GetDisp( axis, math )
    //  axis      : 軸
    //  math      : 数学座標
    //  戻り値    : math に対応するディスプレイ座標

    return orgPos( axis ) + size( axis ) * math

#defcfunc _m2d_GetDispX double math
#define global ctype m2d_GetDispX( %1 = 0 ) _m2d_GetDispX( %1 )
    // X軸の数学座標からディスプレイ座標を取得
    // m2d_GetDispX( math )
    //  math      : 数学座標
    //  戻り値    : math に対応するディスプレイ座標

    return GetDisp( AXIS_X, math )

#defcfunc _m2d_GetDispY double math
#define global ctype m2d_GetDispY( %1 = 0 ) _m2d_GetDispY( %1 )
    // Y軸の数学座標からディスプレイ座標を取得
    // m2d_GetDispY( math )
    //  math      : 数学座標
    //  戻り値    : math に対応するディスプレイ座標

    return GetDisp( AXIS_Y, math )

#defcfunc GetMath@Math2Disp int axis, double disp
    // 指定した軸のディスプレイ座標から数学座標を取得 ( Private )
    // GetMath( axis, disp )
    //  axis      : 軸
    //  disp      : ディスプレイ座標
    //  戻り値    : disp に対応する数学座標

    return ( disp - orgPos( axis ) ) / size( axis )

#defcfunc m2d_GetMathX double disp
    // X軸のディスプレイ座標から数学座標を取得
    // m2d_GetMathX( disp )
    //  disp      : ディスプレイ座標
    //  戻り値    : disp に対応する数学座標

    return GetMath( AXIS_X, disp )

#defcfunc m2d_GetMathY double disp
    // Y軸のディスプレイ座標から数学座標を取得
    // m2d_GetMathY( disp )
    //  disp      : ディスプレイ座標
    //  戻り値    : disp に対応する数学座標

    return GetMath( AXIS_Y, disp )

#defcfunc GetDispMin@Math2Disp int axis
    // 指定した軸の画面端のディスプレイ座標を取得
    // GetDispMin( axis )
    //  axis      : 軸
    //  戻り値    : ディスプレイ座標

    return 0.0

#defcfunc GetDispMax@Math2Disp int axis
    // 指定した軸の画面端のディスプレイ座標を取得
    // GetDispMax( axis )
    //  axis      : 軸
    //  戻り値    : ディスプレイ座標

    if ( axis == AXIS_X ) {
        return double( ginfo_sx )
    } else {
        return double( ginfo_sy )
    }

#deffunc GetEdgeMath@Math2Disp int axis, var minMath, var maxMath, local math1, local math2
    // 指定した軸の画面端の数学座標を取得する
    //  GetEdgeMath axis, minMath, maxMath
    //  axis      : 軸
    //  minMath   : 画面端の数学座標（小さい方）
    //  minMath   : 画面端の数学座標（大きい方）
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    if ( IsInvalidAxis( axis ) ) {
        return 1
    }
    math1 = GetMath( axis, GetDispMin( axis ) )
    math2 = GetMath( axis, GetDispMax( axis ) )

    if ( math2 > math1 ) {
        minMath = math1
        maxMath = math2
    } else {
        minMath = math2
        maxMath = math1
    }
    return 0

#deffunc m2d_GetEdgeMathX var minMath, var maxMath
    // X軸の画面端の数学座標
    // m2d_GetEdgeMathY minMath, maxMath
    //  minMath   : 画面端の数学座標（小さい方）
    //  minMath   : 画面端の数学座標（大きい方）
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    GetEdgeMath AXIS_X, minMath, maxMath
    return stat

#deffunc m2d_GetEdgeMathY var minMath, var maxMath
    // Y軸の画面端の数学座標
    // m2d_GetEdgeMathY minMath, maxMath
    //  minMath   : 画面端の数学座標（小さい方）
    //  minMath   : 画面端の数学座標（大きい方）
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    GetEdgeMath AXIS_Y, minMath, maxMath
    return stat


// 指定座標が画面内か
#defcfunc IsInScreen@Math2Disp int axis, double math, local disp
    // 指定した軸の数学座標が画面内か ( Private )
    // IsInScreen( axis, math )
    //  axis      : 軸
    //  math      : 数学座標
    //  戻り値    : math が画面内かの真偽値

    disp = GetDisp( axis, math )
    return ( disp >= GetDispMin( axis ) ) && ( disp < GetDispMax( axis ) )

#defcfunc m2d_IsXInScreen double math
    // X軸の数学座標が画面内か
    // m2d_IsXInScreen( math )
    //  math      : 数学座標
    //  戻り値    : math が画面内かの真偽値

    return IsInScreen( AXIS_X )

#defcfunc m2d_IsYInScreen double math
    // Y軸の数学座標が画面内か
    // m2d_IsYInScreen( math )
    //  math      : 数学座標
    //  戻り値    : math が画面内かの真偽値

    return IsInScreen( AXIS_X )

#defcfunc m2d_IsPtInScreen double mathX, double mathY
    // 数学座標が画面内か
    // m2d_IsPtInScreen( math )
    //  mathX     : 数学X座標
    //  mathY     : 数学Y座標
    //  戻り値    : ( mathX, mathY ) が画面内かの真偽値

    return m2d_IsYInScreen( mathX ) && m2d_IsYInScreen( mathY )

#deffunc drawGrid@Math2Disp int axis, local math, local mathInc, local mathEnd,  local disp, local dispInc, local fDrawGraduation, local GraduationPos
    // 指定した軸のグリッドを描画する ( Private )
    // drawGrid axis
    //  axis      : 軸

    GetEdgeMath axis, math, mathEnd
    mathInc = 1.0
    math = double( int( math / mathInc ) ) * mathInc
    disp = GetDisp( axis, math )
    dispInc = size( axis ) * mathInc

    fDrawGraduation = IsInScreen( getOtherAxis( axis ), 0 )

    if ( fDrawGraduation ) {
        GraduationPos = GetDisp( getOtherAxis( axis ), 0 )
        font "Times New Roman", 12
    }
    repeat
        if ( math == 0.0 ) {
            color
        } else {
            color 224, 224, 224
        }
        if ( axis == AXIS_X ) {
            line disp, ginfo_sy, disp, 0
        } else {
            line ginfo_sx, disp, 0, disp
        }
        if ( fDrawGraduation ) {
            color
            if ( axis == AXIS_X ) {
                pos disp, GraduationPos
            } else {
                pos GraduationPos, disp
            }
            mes strf( "%g", math )
        }
        if( math > mathEnd ) {
            break
        }
        math += mathInc
        disp += dispInc
    loop
    return

#deffunc m2d_DrawGrid
    // グリッドを描画する
    // m2d_DrawGrid

    drawGrid AXIS_X
    drawGrid AXIS_Y
    return

#global

    _init@Math2Disp