//  カーペットクラス

//    カーペット1枚の情報（主に画像、座標）を管理

//--------------------------------------------------

class CCarpet{

  constructor(x, y, w, h, cx, cy){

    this.g = createGraphics(w, h);

    this.x = x;

    this.y = y;

    this.w = w;

    this.h = h;

    this.cx = cx;

    this.cy = cy;

    this.sewing()

  }

  //--------------------------------------------------

  //  描画

  //--------------------------------------------------

  draw(){

    image(this.g, this.x, this.y);

  }

  //--------------------------------------------------

  //  削除（明示的にremove()しないとメモリリークしているようであったため）

  //--------------------------------------------------

  delete(){

    this.g.remove();

    this.g = undefined;

  }

  //--------------------------------------------------

  //  移動

  //--------------------------------------------------

  move(){

    //  **16の時*3.245だと目視でピッタリなのでヨシッ！

    //  （本当はちゃんと積分して求める必要がある…）

    this.x -= sin(TIME / TILE_SIZE * PI / 8) ** 16 * PI / 2 * 3.245;

  }

  //--------------------------------------------------

  //  模様の生成

  //--------------------------------------------------

  sewing(){

    this.g.background(0);

    this.g.loadPixels();

​

    const P = this.g.pixels;

    const W = this.g.width

    const H = this.g.height

    const HW = W / 2;

    const HH = H / 2;

    let pr, pg, pb;  //  ピクセルのRGB値の計算結果

    //  カーペット概略図

    //    ######################### <--[###]外枠 Outer-Frame

    //    #########################

    //    ##-*-*-*-*-*+*-*-*-*-*-## <--[-*-]中枠 Middle-Frame

    //    ##*-*-*-*-*-+-*-*-*-*-*##

    //    ##-*.......+.+.......*-## <--[...]内枠 Inner-Frame

    //    ##*-......+.@.+......-*## <--[ @ ]内円 Inner-Medallion

    //    ##-*.......+.+.......*-## <--[ + ]外円 Outer-Medallion

    //    ##*-*-*-*-*-+-*-*-*-*-*##

    //    ##-*-*-*-*-*+*-*-*-*-*-##

    //    #########################

    //    #########################

​

    //--------------------------------------------------

    //  Frame Division

    //    小さいと比較的構成タイルが目視できるようになる。

    //    大きいと細かくなり繰り返し模様度が強くなる。

    //    小さい方がパターン変化が強いのでsqrt()して確率に傾斜をつける

    let of_div = int(sqrt(random(80))) + 1;

    let mf_div = int(sqrt(random(50))) + 1;

    let if_div = int(sqrt(random(50))) + 1;

    //--------------------------------------------------

    //  Frame Length

    //    各枠の長さ

    let if_length = random(40) + 10;

    let mf_length = if_length + random(50);

    //  1タイルカーペットの場合は枠を短くする

    if(this.g.width == TILE_SIZE){

      if_length /= 2.5;

      mf_length /= 2.5;

    }

    if(this.g.height == TILE_SIZE){

      if_length /= 2.5;

      mf_length /= 2.5;

    }

    //--------------------------------------------------

    //  Accuracy Level

    //    正確さレベル

    //    弱いと全体が水面や魚眼レンズのようにゆがむ

    let accuracyLevel = random(500) + 10;

    //--------------------------------------------------

    //  Medallion Length

    //    各円の長さ

    let im_length = (random(1) < MD_RATE ? 1 : 0) * (random(50) + 50);

    let om_start_length = im_length + random(200 - im_length);

    let om_end_length = om_start_length + 

        (random(1) < MD_RATE ? 1 : 0) * (random(100) + 25);

​

    //  1タイルカーペットの場合は大きさを小さくする

    if(this.g.width == TILE_SIZE){

      im_length /= 1.5;

      om_start_length /= 1.5;

      om_end_length /= 1.5;

    }

    if(this.g.height == TILE_SIZE){

      im_length /= 1.5;

      om_start_length /= 1.5;

      om_end_length /= 1.5;

    }

​

    //--------------------------------------------------

    //  Frame Value Param

    //    フレームの座標の値の計算に使用するパラメーター

    //    Value = (BitOpResult * exp) % mod * mag

    const if_vpExp = sqrt(random(1000)) + 1;

    const if_vpMod = random(100) + if_vpExp + 1;

    const if_vpMag = random(4) + 2;

    const mf_vpExp = sqrt(random(1000)) + 1;

    const mf_vpMod = random(100) + mf_vpExp + 1;

    const mf_vpMag = random(4) + 2;

    const of_vpExp = sqrt(random(1000)) + 1;

    const of_vpMod = random(100) + of_vpExp + 1;

    const of_vpMag = random(4) + 2;

​

    //--------------------------------------------------

    //  Frame Color Param

    //    フレームのRGBの色計算に使用するパラメーター

    //    Color = Value % mod * mag

    const if_cpModR = int(random(50)) + 40;

    const if_cpModG = int(random(50)) + 40;

    const if_cpModB = int(random(50)) + 40;

    const if_cpMagR = random(4) + 3;

    const if_cpMagG = random(4) + 3;

    const if_cpMagB = random(4) + 3;

    const mf_cpModR = int(random(50)) + 40;

    const mf_cpModG = int(random(50)) + 40;

    const mf_cpModB = int(random(50)) + 40;

    const mf_cpMagR = random(4) + 3;

    const mf_cpMagG = random(4) + 3;

    const mf_cpMagB = random(4) + 3;

    const of_cpModR = int(random(50)) + 40;

    const of_cpModG = int(random(50)) + 40;

    const of_cpModB = int(random(50)) + 40;

    const of_cpMagR = random(4) + 3;

    const of_cpMagG = random(4) + 3;

    const of_cpMagB = random(4) + 3;

    //--------------------------------------------------

    //  Medallion Value Param

    //    メダリオンの座標の値の計算に使用するパラメーター

    //    Value = BitOpResult % mod * mag

    const im_vpMod = random(99) + 10;

    const im_vpMag = random(99) + im_vpMod + 1;

    const om_vpMod = random(99) + 8;

    const om_vpMag = random(99) + om_vpMod + 1;

    //--------------------------------------------------

    //  Medallion Color Param

    //    メダリオンのRGBの色計算に使用するパラメーター

    //    Color = Value % mod * mag * strong

    const im_cpModR = int(random(50)) + 40;

    const im_cpModG = int(random(50)) + 40;

    const im_cpModB = int(random(50)) + 40;

    const im_cpMagR = random(4) + 3;

    const im_cpMagG = random(4) + 3;

    const im_cpMagB = random(4) + 3;

    const om_cpModR = int(random(50)) + 40;

    const om_cpModG = int(random(50)) + 40;

    const om_cpModB = int(random(50)) + 40;

    const om_cpMagR = random(4) + 3;

    const om_cpMagG = random(4) + 3;

    const om_cpMagB = random(4) + 3;

    let m_strongR = 0.5;

    let m_strongG = 0.5;

    let m_strongB = 0.5;

    switch(int(random(3))){

      case 0: m_strongR = 1.0; break;

      case 1: m_strongG = 1.0; break;

      case 2: m_strongB = 1.0; break;

    }

    //--------------------------------------------------

    //  Petal Count

    //    メダリオンの花弁数。

    //    2なら円（楕円）。

    const im_petalCount = int(random(4) + 1) * 2

    const om_petalCount = int(random(4) + 1) * 2

    const medallionRatio = random(0.5) + 1;    // メダリオンの縦横比

    const medallionRatioX = this.g.width > this.g.height ? medallionRatio : 1;

    const medallionRatioY = this.g.width < this.g.height ? medallionRatio : 1;

    const medallionDecoMagni = random(10); // メダリオンの歪み装飾倍率

    //--------------------------------------------------

    //  Medallion Division

    //    メダリオンの模様の粗さ

    //    小さいとほぼメダリオンの罫線になる

    //    大きいと模様の塊が見える

    let im_div = random(6) + 1;

    let om_div = random(6) + 1;

    //  各ピクセル値の計算

    for(let y = 0; y < this.g.height; y++){

      for(let x = 0; x < this.g.width; x++){

        let fixRate = 1.0;  //  色飛び補正用

​

        if (x < CARPET_BORDER ||

            this.g.width - CARPET_BORDER <= x ||

            y < CARPET_BORDER ||

            this.g.height - CARPET_BORDER <= y){  //  境界線

          pr = 0;

          pg = 0;

          pb = 0;

​

        }else{

          //  座標の正規化

          let X = x - this.g.width / 2;

          let Y = y - this.g.height / 2;

          let AX = abs(X);

          let AY = abs(Y);

          let ANGLE = atan2(X, Y); // 回転を画面に合わせるためx,yの順にする

​

          //  歪み計算

          const accuracyRate = abs(sin((AX + AY) / accuracyLevel) * 0.1) + 0.9;

​

          //  周期計算

          let periodX, periodY;

          if(AX < HW - mf_length  && AY < HH - mf_length){

            periodX = W / if_div;

            periodY = H / if_div;

          }else if(AX < HW - if_length  && AY < HH - if_length){

            periodX = W / mf_div;

            periodY = H / mf_div;

          }else{

            periodX = W / of_div;

            periodY = H / of_div;

          }

​

          //  仮想座標計算

          //    座標が周期内においてどの位置にいるかの算出

          //    VFは複雑性を追加するためのフレーバー

          let VX = abs((AX * accuracyRate) % periodX - periodX / 2);

          let VY = abs((AY * accuracyRate) % periodY - periodY / 2);

          let VF = abs(int(VX / of_div) + int(VY / of_div));

​

          //--------------------------------------------------

          //  Medallion Distance

          //    メダリオンの距離

          const medallionDistance = dist(X / medallionRatioX,

                                         Y / medallionRatioY, 0, 0);

          let im_distance = medallionDistance + 

              medallionDecoMagni * cos(ANGLE * im_petalCount);

          let om_distance = medallionDistance +

              medallionDecoMagni * cos(ANGLE * om_petalCount);

​

          let V = 0;  //  ビット演算によって決まった値を格納。ビット演算のパターンを増やしても面白いかも。

          if(im_distance < im_length){  //  内円

            V = (VX & VY | (im_distance / im_div)) % im_vpMod * im_vpMag;

            pr = V % im_cpModR * im_cpMagR * m_strongR;

            pg = V % im_cpModG * im_cpMagG * m_strongG;

            pb = V % im_cpModB * im_cpMagB * m_strongB;

​

          }else if(om_start_length < om_distance 

                   && om_distance < om_end_length){ // 外円

            V = (VX & VY | (om_distance / om_div)) % om_vpMod * om_vpMag;

            pr = V % om_cpModR * om_cpMagR * m_strongR;

            pg = V % om_cpModG * om_cpMagG * m_strongG;

            pb = V % om_cpModB * om_cpMagB * m_strongB;

​

          }else if (AX < HW-mf_length && AY < HH-mf_length){ // 内枠

            V = ((VX & VY | VF) * if_vpExp ) % if_vpMod * if_vpMag;

            pr = V % if_cpModR * if_cpMagR;

            pg = V % if_cpModG * if_cpMagG;

            pb = V % if_cpModB * if_cpMagB;

​

          }else if (AX < HW-if_length && AY < HH-if_length){ // 中枠

            V = ((VX & VY | VF) * mf_vpExp) % mf_vpMod * of_vpMag;

            pr = V % mf_cpModR * mf_cpMagR;

            pg = V % mf_cpModG * mf_cpMagG;

            pb = V % mf_cpModB * mf_cpMagB;

​

          }else{

            V = ((VX ^ VY | VF) * of_vpExp) % of_vpMod * of_vpMag; // 外枠

            pr = V % of_cpModR * of_cpMagR;

            pg = V % of_cpModG * of_cpMagG;

            pb = V % of_cpModB * of_cpMagB;

          }

​

          //  色飛びを抑える

          if(pr + pg + pb < 50){

            fixRate = 50 / min(pr, pg, pb, 10)

          }else{

            fixRate = 255 / max(pr, pg, pb, 255);

          }

        }

​

        const index = x * 4 + y * 4 * this.g.width;

        P[index + 0] = pr * fixRate;

        P[index + 1] = pg * fixRate;

        P[index + 2] = pb * fixRate;

      }

    }

    this.g.updatePixels();

  }

}