Subversion Repositories DIN Is Noise

/*

* mesh.cc

* DIN Is Noise is copyright (c) 2006-2025 Jagannathan Sampath

* DIN Is Noise is released under GNU Public License 2.0

* For more information, please visit https://dinisnoise.org/

*/

#include "mesh.h"

#include "drone.h"

#include "dingl.h"

#include "random.h"

#include "container.h"

#include "vector2d.h"

#include "console.h"

#include <string.h>

using namespace std;

mesh::mesh () {

  num_polys = 0;

  r = g = b = 0.0f;

}

void mesh::destroy () {

  if (gl_pts) delete[] gl_pts;

  if (clr) delete[] clr;

}

void mesh::add_poly (drone* d0, drone* d1, drone* d2, drone* d3) {

  if (d0 && d1 && d2 && d3) {

    ++num_polys;

    polys.push_back (poly (d0, d1, d2, d3));

    int np = num_polys * 4;

    if (np > n_glpts) {

      if (gl_pts) delete[] gl_pts;

      gl_pts = new int [2 * np];

      if (clr) delete[] clr;

      clr = new float [4 * np];

      n_glpts = np;

    }

  }

}

void mesh::remove_poly (drone* pd) {

  for (poly_iterator i = polys.begin (), j = polys.end (); i != j;) {

    poly& pi = *i;

    for (int k = 0; k < 4; ++k) {

      if (pi.drones[k] == pd) {

        i = polys.erase (i);

        j = polys.end ();

        --num_polys;

        goto erased;

      }

    }

    ++i;

    erased:

      ;

  }

}

void mesh::draw () {

  int c = 0, m = 0, n = 0;

  for (poly_iterator i = polys.begin (), j = polys.end (); i != j; ++i) {

    poly& p = *i;

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

      drone* pd = p.drones[j];

      gl_pts[m++]= pd->sx;

      gl_pts[m++]= pd->y;

      clr[c++]=pd->r * pd->gab.amount;

      clr[c++]=pd->g * pd->gab.amount;

      clr[c++]=pd->b * pd->gab.amount;

      clr[c++]=0.25f * pd->fdr.amount;

    }

    n += 4;

  }

  // draw the polygons

  glEnableClientState (GL_COLOR_ARRAY);

  glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);

  glColorPointer (4, GL_FLOAT, 0, clr);

  glVertexPointer (2, GL_INT, 0, gl_pts);

  glDrawArrays (GL_QUADS, 0, n); // filled polygons

  glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);

  glColorPointer (4, GL_FLOAT, 0, clr);

  glVertexPointer (2, GL_INT, 0, gl_pts);

  glDrawArrays (GL_QUADS, 0, n); // polygon outlines

  glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);

  glDisableClientState (GL_COLOR_ARRAY);

}

mesh_data::mesh_data () : meshp(0) {

  clear ();

}

void mesh_data::clear () {

  mesh = 0;

  rows = cols = 0;

  row = col = 0;

  rowcol = 0;

  if (meshp) delete[] meshp;

  meshp = 0;

  n_meshp = 0;

  drone_pend = 0;

  drones_per_pend = 2;

  apply_to_am_bpm = 1;

  apply_to_fm_bpm = 1;

  meshd.clear ();

  orderer = 0;

  order.clear ();

}

mesh_data::~mesh_data () {

  if (meshp) delete[] meshp;

}

void mesh_data::set_mesh (int m, int r, int c) {

  mesh = m;

  rows = r;

  cols = c;

  rowcol = rows * cols;

  int _2rowcol = 2 * rowcol;

  if (rowcol > n_meshp) {

    if (meshp) delete[] meshp;

    meshp = new float [_2rowcol];

    meshd.resize (rowcol);

    n_meshp = rowcol;

  }

  memset (meshp, 0, _2rowcol * sizeof (float));

}

void mesh_data::gen_mesh_pts (const box<float>& region) {

  if (mesh) {

    float rl = (region.right - region.left);

    float bt = (region.top - region.bottom);

    int cols_1 = cols - 1, rows_1 = rows - 1;

    col = rl * 1.0f / cols_1;

    row = bt * 1.0f /  rows_1;

    float x, y = region.bottom;

    int p = 0;

    for (int i = 0; i < rows; ++i) {

      x = region.left;

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

        meshp[p++] = x;

        meshp[p++] = y;

        x += col;

      }

      y += row;

    }

  }

}

void mesh_data::order_order () {

  order.resize (rowcol);

  if (orderer)

    (*orderer)(order, this);

  else {

    ascending_rows_orderer asc;

    asc (order);

  }

}

void ascending_rows_orderer::operator() (std::vector<int>& order, mesh_data* md) {

  for (int i = 0, j = order.size (); i < j; ++i) order[i] = i;

}

void descending_rows_orderer::operator () (std::vector<int>& order, mesh_data* md) {

  for (int j = md->rows - 1, o = 0; j > -1; --j) {

    int k = j * md->cols;

    for (int i = 0; i < md->cols; ++i) order[o++]=k+i;

  }

}

void ascending_cols_orderer::operator() (std::vector<int>& order, mesh_data* md) {

  for (int i = 0, o = 0; i < md->cols; ++i) {

    for (int j = 0; j < md->rows; ++j) {

      int k = j * md->cols + i;

      order[o++]=k;

    }

  }

}

void descending_cols_orderer::operator () (std::vector<int>& order, mesh_data* md) {

  for (int i = 0, o = 0; i < md->cols; ++i) {

    for (int j = md->rows - 1; j > -1; --j) {

      int k = j * md->cols + i;

      order[o++]=k;

    }

  }

}

void random_orderer::operator () (std::vector<int>& order, mesh_data* md) {

  ascending_rows_orderer asc;

  asc (order);

  std::vector<int> orig_order = order;

  int n = order.size (), m = n;

  rnd<int> r;

  for (int i = 0; i < n; ++i) {

    r.set (0, m-1);

    int j = r();

    order[i] = orig_order[j];

    erase_id (orig_order, j);

    --m;

  }

}

proximity_orderer::proximity_orderer (int so) {

  sort_opt = so;

}

void proximity_orderer::get_xy (float& x, float& y, int m, int n, mesh_data* md) {

  int p = m * md->cols + n;

  int _2p = 2 * p;

  x = md->meshp[_2p];

  y = md->meshp[_2p+1];

}

void proximity_orderer::operator () (std::vector<int>& order, mesh_data* md) {

  float px, py; get_xy (px, py, ROW, COL, md);

  v_dist_id.resize (md->rowcol);

  for (int i = 0, j = md->rowcol, k = 0; i < j; ++i, k += 2) {

    float x = md->meshp[k];

    float y = md->meshp[k+1];

    double d2 = magnitude2 (px, py, x, y);

    dist_id& did = v_dist_id[i];

    did.d2 = d2;

    did.id = i;

  }

  if (sort_opt == NEAREST)

    sort (v_dist_id.begin (), v_dist_id.end (), asc);

  else

    sort (v_dist_id.begin (), v_dist_id.end (), desc);

  for (int i = 0, j = order.size (); i < j; ++i) order[i]=v_dist_id[i].id;

  v_dist_id.clear ();

}