床井研究室

#pragma once
#include "gg.h"
using namespace gg;
 
// 標準ライブラリ
#include <array>
 
//
// ベクトルデータ
//
using Vector = std::array<GLfloat, 4>;

std::array<GLfloat, 4> v;

Vector v;

//
// 粒子データ
//
struct Particle
{
  // 位置
  Vector position;
 
  // 速度
  Vector velocity;
 
  // デフォルトコンストラクタ
  Particle()
  {}
 
  // 引数で初期化を行うコンストラクタ
  Particle(float px, float py, float pz,
    float vx = 0.0f, float vy = 0.0f, float vz = 0.0f)
    : position{ px, py, pz, 1.0f }, velocity{ vx, vy, vz, 0.0f }
  {}
 
  // デストラクタ
  ~Particle()
  {}
};

Particle p;

const int x = 10;

x = 20;

Particle p(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f);

position{ px, py, pz, 1.0f }, velocity{ vx, vy, vz, 0.0f }

Particle p{ 1.0f, 2.0f, 3.0f };

#pragma once
#include "Particle.h"
 
// 標準ライブラリ
#include <vector>
 
//
// 粒子群データ
//
using Particles = std::vector<Particle>;

//
// 粒子群オブジェクト
//
class Blob
{
  // 頂点配列オブジェクト名
  GLuint vao;
 
  // 頂点バッファオブジェクト名
  GLuint vbo;
 
  // 頂点の数
  const GLsizei count;
 
public:
 
  // コンストラクタ
  Blob(const Particles &particles);
 
  // デストラクタ
  virtual ~Blob();
 
  // コピーコンストラクタによるコピー禁止
  Blob(const Blob &blob) = delete;
 
  // 代入によるコピー禁止
  Blob &operator=(const Blob &blob) = delete;
 
  // 初期化
  void initialize(const Particles &particles) const;
 
  // 描画
  void draw() const;
};

//
// 粒子群オブジェクト
//
#include "Blob.h"
 
// コンストラクタ
Blob::Blob(const Particles &particles)
  : count(static_cast<GLsizei>(particles.size()))
{
  // 頂点配列オブジェクトを作成する
  glGenVertexArrays(1, &vao);
  glBindVertexArray(vao);

  // 頂点バッファオブジェクトを作成する
  glGenBuffers(1, &vbo);
  glBindBuffer(GL_ARRAY_BUFFER, vbo);
  glBufferData(GL_ARRAY_BUFFER, count * sizeof(Particle), nullptr, GL_STATIC_DRAW);

  // 結合されている頂点バッファオブジェクトを in 変数から参照できるようにする
  glVertexAttribPointer(0, std::tuple_size<Vector>::value, GL_FLOAT, GL_FALSE,
    sizeof(Particle), &static_cast<const Particle *>(0)->position);
  glEnableVertexAttribArray(0);
  glVertexAttribPointer(1, std::tuple_size<Vector>::value, GL_FLOAT, GL_FALSE,
    sizeof(Particle), &static_cast<const Particle *>(0)->velocity);
  glEnableVertexAttribArray(1);

  // 頂点バッファオブジェクトにデータを格納する
  initialize(particles);
}

// デストラクタ
Blob::~Blob()
{
  // 頂点配列オブジェクトを削除する
  glDeleteVertexArrays(1, &vao);
 
  // 頂点バッファオブジェクトを削除する
  glDeleteBuffers(1, &vbo);
}

// 初期化
void Blob::initialize(const Particles &particles) const
{
  // 頂点バッファオブジェクトを結合する
  glBindBuffer(GL_ARRAY_BUFFER, vbo);
  
  // 頂点バッファオブジェクトにデータを格納する
  Particle *p(static_cast<Particle *>(glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY)));
  for (auto particle : particles)
  {
    p->position = particle.position;
    p->velocity = particle.velocity;
    ++p;
  }
  glUnmapBuffer(GL_ARRAY_BUFFER);
}

// 描画
void Blob::draw() const
{
  // 描画する頂点配列オブジェクトを指定する
  glBindVertexArray(vao);
 
  // 点で描画する
  glDrawArrays(GL_POINTS, 0, count);
}

//
// アプリケーション本体
//
#include "GgApplication.h"
  
// 粒子群オブジェクト
#include "Blob.h"
  
// 標準ライブラリ
#include <memory>
#include <random>
  
// 生成する粒子群の数
const int bCount(8);
  
// 生成する粒子群の中心位置の範囲
const GLfloat bRange(1.5f);
  
// 一つの粒子群の粒子数
const int pCount(1000);
  
// 一つの粒子群の中心からの距離の平均
const GLfloat pMean(0.0f);
  
// 一つの粒子群の中心からの距離の標準偏差
const GLfloat pDeviation(0.3f);

//
// 粒子群の生成
//
//   particles 粒子群の格納先
//   count 粒子群の粒子数
//   rn メルセンヌツイスタ法による乱数
//   cx, cy, cz 粒子群の中心位置
//   mean 粒子の粒子群の中心からの距離の平均値
//   deviation 粒子の粒子群の中心からの距離の標準偏差
//
void generateParticles(Particles &particles, int count,
  GLfloat cx, GLfloat cy, GLfloat cz,
  std::mt19937 &rn, GLfloat mean, GLfloat deviation)
{
  // 一様実数分布
  //   [0, 2) の値の範囲で等確率に実数を生成する
  std::uniform_real_distribution<GLfloat> uniform(0.0f, 2.0f);
  
  // 正規分布
  //   平均 mean、標準偏差 deviation で分布させる
  std::normal_distribution<GLfloat> normal(mean, deviation);
  
  // 格納先のメモリをあらかじめ確保しておく
  particles.reserve(particles.size() + count);
  
  // 原点中心に直径方向に正規分布する粒子群を発生する
  for (int i = 0; i < count; ++i)
  {
    // 緯度方向
    const GLfloat cp(uniform(rn) - 1.0f);
    const GLfloat sp(sqrt(1.0f - cp * cp));
    
    // 経度方向
    const GLfloat t(3.1415927f * uniform(rn));
    const GLfloat ct(cos(t)), st(sin(t));
    
    // 粒子の粒子群の中心からの距離 (半径)
    const GLfloat r(normal(rn));
    
    // 粒子を追加する
    particles.emplace_back(r * sp * ct + cx, r * sp * st + cy, r * cp + cz);
  }
}

//
// アプリケーションの実行
//
void GgApplication::run()
{
  // ウィンドウを作成する
  Window window("Flow");
  
  //
  // 粒子群オブジェクトの作成
  //
  
  // 乱数の種に使うハードウェア乱数
  //std::random_device seed;
  
  // メルセンヌツイスタ法による乱数の系列を設定する
  //std::mt19937 rn(seed());
  std::mt19937 rn(54321);
  
  // 粒子群データの初期値
  Particles initial;
  
  // 一様実数分布
  //   [-1.0, 1.0) の値の範囲で等確率に実数を生成する
  std::uniform_real_distribution<GLfloat> center(-bRange, bRange);
  
  // 発生する粒子群の数だけ繰り返す
  for (int i = 0; i < bCount; ++i)
  {
    // 点の玉中心位置
    const GLfloat cx(center(rn)), cy(center(rn)), cz(center(rn));
    
    // 中心からの距離に対して密度が正規分布に従う点の玉を生成する
    generateParticles(initial, pCount, cx, cy, cz, rn, pMean, pDeviation);
  }

  // 粒子群オブジェクトを作成する
  std::unique_ptr<const Blob> blob(new Blob(initial));

//
// 粒子群オブジェクト
//
class Blob
{
  // 頂点配列オブジェクト名
  GLuint vao;
 
  // 頂点バッファオブジェクト名
  GLuint vbo;
 
  // 頂点の数
  const GLsizei count;
 
  // 描画用のシェーダ
  const GLuint drawShader;
 
  // uniform 変数の場所
  const GLint mpLoc, mvLoc;
  
public:
  
  ...

  ...
 
  // 初期化
  void initialize(const Particles &particles) const;
  
  // 描画
  void draw(const GgMatrix &mp, const GgMatrix &mv) const;
  
  // 更新
  void update() const;
};

// コンストラクタ
Blob::Blob(const Particles &particles)
  : count(static_cast<GLsizei>(particles.size()))
  , drawShader(ggLoadShader("point.vert", "point.frag"))
  , mpLoc(glGetUniformLocation(drawShader, "mp"))
  , mvLoc(glGetUniformLocation(drawShader, "mv"))
{
  ...
}

// 描画
void Blob::draw(const GgMatrix &mp, const GgMatrix &mv) const
{
  // 描画する頂点配列オブジェクトを指定する
  glBindVertexArray(vao);
  
  // 点のシェーダプログラムの使用開始
  glUseProgram(drawShader);
  
  // uniform 変数を設定する
  glUniformMatrix4fv(mpLoc, 1, GL_FALSE, mp.get());
  glUniformMatrix4fv(mvLoc, 1, GL_FALSE, mv.get());
  
  // 点で描画する
  glDrawArrays(GL_POINTS, 0, count);
}

  ...
  
  //
  // 描画の設定
  //
  
  // ビュー変換行列を求める
  const GgMatrix view{ ggLookat(0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f) };
  
  // 背面カリングを有効にする
  glEnable(GL_CULL_FACE);

  // デプスバッファを有効にする
  glEnable(GL_DEPTH_TEST);
  
  // 背景色を指定する
  glClearColor(0.1f, 0.2f, 0.3f, 0.0f);
  
  // 時計をリセットする
  glfwSetTime(0.0);
  
  // ウィンドウが開いている間繰り返す
  while (window)
  {
    // ウィンドウを消去する
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    // 透視投影変換行列を求める
    const GgMatrix projection(ggPerspective(1.0f, window.getAspect(), 1.0f, 10.0f));
    
    // モデル変換行列を求める
    const GgMatrix model(window.getTrackball());
    
    // モデルビュー変換行列を求める
    const GgMatrix modelview(view * model);
    
    // 粒子群オブジェクトを描画する
    blob->draw(projection, modelview);
    
    // カラーバッファを入れ替える
    window.swapBuffers();
  }
}