use threadpool::ThreadPool;

fn main() {

    // スレッドを四枚作成
    let pool = threadpool::ThreadPool::new(4);

    // テスト用データ
    let myarray = std::sync::Arc::new(std::sync::Mutex::new(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));

    for i in 0..10{

        // myarrayは参照なので、cloneして参照を複製する
        // クロージャに渡すmoveキーワードによって、myarray2がクロージャにムーブされる
        let array2 = myarray.clone();

        // スレッドプールにジョブを追加
        pool.execute(move || {

            let mut data  = array2.lock().unwrap();
            data[i] *= 2;

        } );

    }

    // スレッドの終了を待つ
    pool.join();

    // 結果を表示
    let data = myarray.lock().unwrap();
    println!("{:?}", data);    

}

use threadpool::ThreadPool;

// チャンネルを使うために必要
use std::sync::mpsc::channel;

fn main() {

    // スレッドを四枚作成
    let pool = threadpool::ThreadPool::new(4);

    // スレッドで処理した結果を受け取るためのチャンネルを作成
    let (sender,receiver) = channel::<i32>();

    // テスト用データ
    let myarray = std::sync::Arc::new(std::sync::Mutex::new(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));

    for i in 0..10{

        // myarrayは参照なので、cloneして参照を複製する
        // クロージャに渡すmoveキーワードによって、myarray2がクロージャにムーブされる
        let array2 = myarray.clone();

        let sender2 = sender.clone();
        // スレッドプールにジョブを追加
        pool.execute(move || {

            let mut data  = array2.lock().unwrap();
            data[i] *= 2;

            sender2.send(data[i]*10).unwrap(); // このジョブの結果をチャンネルに送信
        } );

    }


    // スレッドの終了を待つ
    pool.join();

    // 全ての処理が終わったら、チャンネルを閉じる
    drop(sender);

    // チャンネルから結果を受け取る
    for itr in receiver.iter(){
        print!("{} ", &itr);
    }
 

}

macro_rules! マクロ名 {
    ($引数:expr) => {
        println!("引数を使う: {}", $引数);
    };
}

macro_rules! print_arg {
    ($arg:expr) => {
        println!("Argument: {}", $arg);
    };
}

      
   
fn main(){
    print_arg!(3.5);  // 出力:  Argument: 3.5
}

macro_rules! print_arg {

    ($e1:expr, $e2:expr) =>{

        println!("e1: {} e2 {}", $e1,$e2);

    };

}


fn main(){
    print_arg!(3.5 , "hello");
}

macro_rules! print_arg {
    ( $($arg:expr) , * ) => {

        $(
            println!("Argument: {}", $arg);
        ) *
        
    };
}

fn main(){
    print_arg!(3.5 , "hello" , 6);
    // Argument: 3.5
    // Argument: hello
    // Argument: 6
}

trait MyPrint{
    fn print(&self);
}

impl MyPrint for i32{
    fn print(&self){
        println!("i32: {}", *self);
    }
}
impl MyPrint for f32{
    fn print(&self){
        println!("f32: {}", *self);
    }
}

macro_rules! print_arg {
    ($e:expr) =>{
        MyPrint::print(&$e);
    };
}

fn main(){
    print_arg!(3.5); // f32: 3.5
    print_arg!(100); // i32: 100
}

// バッファ名
GLuint buffer[3];
const int VTX = 0;
const int COL = 1;
const int IDX = 2;

void init_data() {

  float v = 0.7;
  // 頂点データ
  std::vector< std::array<float,3> > vertex = {
    { 0.0f,  0.0f ,0.0f}, // 中心 (0)
    { 1.0f,  0.0f ,0.0f}, // 右中 (1)
    { 0.5f,  0.87f,0.0f}, // 右上 (2)
    {-0.5f,  0.87f,0.0f}, // 左上 (3)
    {-1.0f,  0.0f ,0.0f}, // 左中 (4)
    {-0.5f, -0.87f,0.0f}, // 左下 (5)
    { 0.5f, -0.87f,0.0f} // 右下 (6)
  };

  // 色データ
  std::vector< std::array<float, 3> > color = {
    {1.0f, 1.0f, 1.0f},
    {0.0f, 1.0f, 0.0f},
    {0.0f, 0.0f, 1.0f},
    {1.0f, 1.0f, 0.0f},
    {1.0f, 0.0f, 1.0f},
    {0.0f, 1.0f, 1.0f},
    {0.5f, 0.5f, 0.5f}
  };

  // インデックスデータ
  std::vector< std::array<GLuint, 3> > index = {
  { 0, 1, 2 },
  { 0, 2, 3 },
  { 0, 3, 4 },
  { 0, 4, 5 },
  { 0, 5, 6 },
  { 0, 6, 1 }
  };

  // バッファ作成
  glGenBuffers(3, &buffer[0]);
  ///////////////////////////////////////////
  // 頂点バッファの作成
  glBindBuffer(GL_ARRAY_BUFFER, buffer[VTX]);
  glBufferData(
    GL_ARRAY_BUFFER,
    sizeof(GLfloat) * 3 * vertex.size(),
    vertex[0].data(),
    GL_STATIC_DRAW);
  ///////////////////////////////////////////
  // 色バッファの作成
  glBindBuffer(GL_ARRAY_BUFFER, buffer[COL]);
  glBufferData(
    GL_ARRAY_BUFFER,
    sizeof(GLfloat) * 4 * color.size(),
    color[0].data(),
    GL_STATIC_DRAW);
  ///////////////////////////////////////////
  // インデックスバッファの作成
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer[IDX]);
  glBufferData(
    GL_ELEMENT_ARRAY_BUFFER,
    sizeof(GLuint) * 3 * index.size(),
    index[0].data(),
    GL_STATIC_DRAW
  );

}

void render_data() {
  glEnableClientState(GL_COLOR_ARRAY);  // 色配列を有効化
  glEnableClientState(GL_VERTEX_ARRAY); // 頂点配列を有効化

  // 頂点配列を有効化
  glBindBuffer(GL_ARRAY_BUFFER, buffer[VTX]);
  glVertexPointer(3, GL_FLOAT, 0, 0);

  // 色配列を有効化
  glBindBuffer(GL_ARRAY_BUFFER, buffer[COL]);
  glColorPointer(4, GL_FLOAT, 0, 0);

  // インデックス配列を有効化
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer[IDX]);

  // 描画
  glDrawElements(GL_TRIANGLES, 6*3/*６頂点。各頂点３要素*/, GL_UNSIGNED_INT, 0);

  // 頂点配列を無効化
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}

void finalizer() {
  glDeleteBuffers(3, buffer);
}

#include <Windows.h>
#include <GL/glew.h>

#include <gl/GL.h>
#include <gl/GLU.h>
#include <gl/freeglut.h>

#include <vector>
#include <array>

#pragma comment(lib, "opengl32.lib")
#pragma comment(lib, "glew32.lib")

//ウィンドウの幅と高さ
int width, height;

double rotate_angle = 0;

// バッファ名
GLuint buffer;

void init_data() {
  glEnableClientState(GL_VERTEX_ARRAY);

  float v = 0.7;
  std::vector< std::array<float,3> > data;
  data.push_back({ 0.f,0.f,0.f });
  data.push_back({ -v,-v,0 });
  data.push_back({ v,-v,0 });

  glGenBuffers(1, &buffer);
  glBindBuffer(GL_ARRAY_BUFFER, buffer);
  glBufferData(
    GL_ARRAY_BUFFER,
    sizeof(GLfloat) * 3 * data.size(),
    data[0].data(),
    GL_STATIC_DRAW);
  glVertexPointer(3, GL_FLOAT, 0, 0);

}

void render_data() {
  glColor3f(1, 0, 0);
  // バッファのデータと関連づけ
  glBindBuffer(GL_ARRAY_BUFFER, buffer);
  glVertexPointer(3, GL_FLOAT, 0, 0);
  // 描画
  glDrawArrays(GL_TRIANGLE_STRIP, 0, 3);
}

//描画関数
void disp(void) {

  glClearColor(0.2, 0.2, 0.2, 1);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glViewport(0, 0, width, height);
  //カメラの設定
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(60, width / (double)height, 0.1, 3);
  glMatrixMode(GL_MODELVIEW);//モデルビューの設定
  glLoadIdentity();
  glTranslated(0, 0, -2);
  glRotated(rotate_angle, 0, 1, 0);

  ////////////////////////////////////////////
  render_data();
  ////////////////////////////////////////////


  glFlush();
}

void finalizer() {
  glDeleteBuffers(1, &buffer);
}

//ウィンドウサイズの変化時に呼び出される
void reshape(int w, int h) {
  width = w; height = h;

  disp();
}

void timer(int value)
{
  rotate_angle += 5;

  disp();
  glutTimerFunc(10, timer, 0);
}

//エントリポイント
int main(int argc, char** argv)
{
  glutInit(&argc, argv);
  glutInitWindowPosition(100, 50);
  glutInitWindowSize(500, 500);
  glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);

  glutCreateWindow("sample");

  glewInit();
  init_data();


  glutDisplayFunc(disp);
  glutReshapeFunc(reshape);
  glutTimerFunc(1000, timer, 0);//タイマー
  glutMainLoop();

  finalizer();

  return 0;
}