//参考元：
//http://zarb.org/~gc/html/libpng.html


#include <iostream>

#include <png.h>

#pragma comment(lib,"libpng16.lib")

//エラーの時強制終了
void abort_(const char* c) {
  printf(c);
  abort();
}

//! @brief pngファイル読み込み関数
//! @param [in] file_name ファイル名
//! @param [out] width 画像幅（ピクセル）
//! @param [out] height 画像高さ（ピクセル）
//! @param [out] color_type RGBかRGBAか...等
//! @param [out] bit_depth チャンネルのビット数
//! @param [out] row_pointers 画像データへのポインタのポインタ
void read_png(
  const char* file_name,
  int* width,
  int* height,
  png_byte* color_type,
  png_byte* bit_depth,
  png_bytep** row_pointers

) {


  png_byte  header[8];    // 8 is the maximum size that can be checked

  FILE *fp = fopen(file_name, "rb");
  if (!fp) {
    abort_("[read_png_file] File could not be opened for reading");
  }
  fread(header, 1, 8, fp);
  if (png_sig_cmp(header, 0, 8)) {
    abort_("[read_png_file] File is not recognized as a PNG file");
  }
  
  
  png_structp png_ptr;
  png_infop info_ptr;

  /* initialize stuff */
  png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
  
  if (!png_ptr)
    abort_("[read_png_file] png_create_read_struct failed");
  
  info_ptr = png_create_info_struct(png_ptr);
  if (!info_ptr)
    abort_("[read_png_file] png_create_info_struct failed");
  
  if (setjmp(png_jmpbuf(png_ptr)))
    abort_("[read_png_file] Error during init_io");
  
  png_init_io(png_ptr, fp);
  png_set_sig_bytes(png_ptr, 8);
  
  png_read_info(png_ptr, info_ptr);

      

  /////////////////////////////////////////
  // 画像情報の取得
  *width = png_get_image_width(png_ptr, info_ptr);
  *height = png_get_image_height(png_ptr, info_ptr);
  *color_type = png_get_color_type(png_ptr, info_ptr);
  *bit_depth = png_get_bit_depth(png_ptr, info_ptr);
  //
  /////////////////////////////////////////

  int number_of_passes;
  number_of_passes = png_set_interlace_handling(png_ptr);
  png_read_update_info(png_ptr, info_ptr);
  
  /* read file */
  if (setjmp(png_jmpbuf(png_ptr)))
    abort_("[read_png_file] Error during read_image");
  

  /////////////////////////////////////////
  // 画像の読み込み
  *row_pointers = (png_bytep*) malloc(sizeof(png_bytep) * *height);

  for (int y=0; y < *height; y++)
    (*row_pointers)[y] = (png_byte*) malloc(png_get_rowbytes(png_ptr,info_ptr));
  
  png_read_image(png_ptr, *row_pointers);
  //
  /////////////////////////////////////////

  
  fclose(fp);
}

int main()
{
  int width;
  int height;
  png_byte color_type;
  png_byte bit_depth;

  png_bytep* row_pointers;

  ////////////////////////////////
  // 画像読み込み
  read_png(
    R"(c:\test\test.png)",
    &width,
    &height,
    &color_type,
    &bit_depth,
    &row_pointers
  );
  //
  ////////////////////////////////

  std::cout << "width : " << width << std::endl;
  std::cout << "height: " << height << std::endl;
  std::cout << "colortype: " << (int)color_type << std::endl;
  std::cout << "bitdepth: " << (int)bit_depth << std::endl;

  ////////////////////////////////
  //１ピクセルのバイト数を算出
  //RGBかRGBAだけ出力
  int pixelsize;
  switch (color_type){
  case PNG_COLOR_TYPE_RGB:
    pixelsize = bit_depth / 8 * 3;
    break;
  case PNG_COLOR_TYPE_RGB_ALPHA:
    pixelsize = bit_depth / 8 * 4;
    break;
  default:
    std::cout << "RGB/RGBA only" << std::endl;
  }
  //
  ////////////////////////////////

  ///////////////////////////////////////////////
  // PPM形式に変換して出力
  FILE* fp = fopen(R"(C:\test\out.ppm)", "wb");
  fprintf(fp, "P3\n%d %d\n%d\n", width, height, 255);

  size_t k = 0;
  for (size_t i = 0; i < (size_t)height; i++) {

    png_bytep yhead = row_pointers[i];

    for (size_t j = 0; j < (size_t)width; j++) {

      png_bytep xpix = yhead + pixelsize * j;

      fprintf(fp, "%d %d %d ", xpix[0], xpix[1], xpix[2]);
      k++;
    }
    fprintf(fp, "\n");
  }

  fclose(fp);
  //
  ///////////////////////////////////////////////

  ///////////////////////////////////////////////
  // メモリの解放
  for (size_t i = 0; i < (size_t)height; i++) {
    png_bytep yhead = row_pointers[i];
    free(yhead);
  }
  free(row_pointers);
  //
  ///////////////////////////////////////////////

  std::cout << "fin" << std::endl;

  int i;
  std::cin >> i;

}

#include <csetjmp>

std::jmp_buf jmp_bf;

int main()
{

  int a = 3;
  int b = 0;



  if (setjmp(jmp_bf) == 0) {

    if (b == 0) {

      longjmp(jmp_bf, 1);

    }

    int c = a / b;
    printf("%d / %d = %d", a, b, c);

  }
  else {

    printf("0 divide error.\n");

  }
  
}

int main()
{

  int a = 3;
  int b = 0;


  try{

    int c = a / b;
    printf("%d / %d = %d", a, b, c);

  }
  catch(...) {

    std::cout << "0 divide error";

  }



  std::cout << "Hello World!\n";
}

#include <iostream>

#include <csetjmp>

std::jmp_buf jmp_bf;

int divide(int a, int b) {

  if (b == 0) {
    longjmp(jmp_bf, 1);//mainのsetjmpまで飛ぶ
  }

  return a / b;
}

int main()
{

  int a = 3;
  int b = 0;

  //初回は0
  //longjmp後は1
 if (setjmp(jmp_bf) == 0) {

    int c = divide(a,b);

    printf("%d / %d = %d", a, b, c);

  }
  else {

    printf("0 divide error.\n");

  }

}

#include <cstdio>

#include <Windows.h>
#include <gl/GL.h>
#include <GLFW/glfw3.h>

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

// ウィンドウを格納する変数
GLFWwindow* window1;
GLFWwindow* window2;


//キー入力を処理するコールバック関数
void key_callback(GLFWwindow* pwin, int key, int scancode, int action, int mods) {

  if ( action != GLFW_PRESS)
    return;

  //ウィンドウの判別をポインタで行う
  if (window1 == pwin) {
    printf("window 1 ");
  }
  if (window2 == pwin) {
    printf("window 2 ");
  }

  //キーイベント
  if ( key == GLFW_KEY_UP) {
    printf("key up\n");
  }
  else if ( key == GLFW_KEY_DOWN ) {
    printf("key down\n");
  }
  else if ( key == GLFW_KEY_LEFT ) {
    printf("key left\n");
  }
  else if ( key == GLFW_KEY_RIGHT ) {
    printf("key right\n");
  }
  else {
    printf("\n");
  }

}

// マウスクリックを処理するコールバック関数
void mouse_button_callback(GLFWwindow* pwin, int button, int action, int mods) {

  if (action != GLFW_PRESS) {
    return;
  }

  //ウィンドウの判別をポインタで行う
  if (window1 == pwin) {
    printf("window 1 ");
  }
  if (window2 == pwin) {
    printf("window 2 ");
  }

  //マウスイベント
  if (button == GLFW_MOUSE_BUTTON_LEFT) {
    printf("L - down\n");
  }
  else if (button == GLFW_MOUSE_BUTTON_RIGHT) {
    printf("R - down\n");
  }
  else if (button == GLFW_MOUSE_BUTTON_MIDDLE) {
    printf("M - down\n");
  }
  else {
    printf("\n");
  }
  
}


void render1(int width,int height);//window 1 用描画関数
void render2(int width, int height);//window 2 用描画関数

int main()
{
  if (glfwInit() == GL_FALSE) {
    return 1;
  }

  window1 = glfwCreateWindow(400,400,"window 1",NULL,NULL);
  window2 = glfwCreateWindow(400,400,"window 2",NULL,NULL);

  if (window1 == nullptr) {
    glfwTerminate();
    return 1;
  }
  if (window2 == nullptr) {
    glfwTerminate();
    return 1;
  }

  ////////////////////////////////////////////
  // コールバック関数の設定

  glfwSetKeyCallback(window1, key_callback);
  glfwSetKeyCallback(window2, key_callback);

  glfwSetMouseButtonCallback(window1, mouse_button_callback);
  glfwSetMouseButtonCallback(window2, mouse_button_callback);

  //
  ////////////////////////////////////////////


  while (glfwWindowShouldClose(window1) == GL_FALSE) {

    int width, height;

    ////////////////////////////////////////////////////////
    glfwGetFramebufferSize(window1, &width, &height);
    glfwMakeContextCurrent(window1);
    render1(width,height);
    glfwSwapBuffers(window1);
    ////////////////////////////////////////////////////////
    glfwGetFramebufferSize(window2, &width, &height);
    glfwMakeContextCurrent(window2);
    render2(width, height);
    glfwSwapBuffers(window2);
    ////////////////////////////////////////////////////////

    // イベント取得
    glfwWaitEvents();

  }

  glfwTerminate();

}

void render1(int width, int height) {

  glViewport(0, 0, width, height);
  glOrtho(-1, 1, -1, 1, -1, 1);

  glClearColor(0, 0, 0, 1);
  glClear(GL_COLOR_BUFFER_BIT);
  glBegin(GL_QUADS);
  glColor3d(1, 0, 0);
  glVertex2d(-0.7, -0.7);
  glColor3d(0, 1, 0);
  glVertex2d(-0.7, 0.7);
  glColor3d(0, 0, 1);
  glVertex2d(0.7, 0.7);
  glColor3d(1, 1, 1);
  glVertex2d(0.7, -0.7);
  glEnd();

}
void render2(int width, int height) {

  glViewport(0, 0, width, height);
  glOrtho(-1, 1, -1, 1, -1, 1);

  glClearColor(0, 0, 0, 1);
  glClear(GL_COLOR_BUFFER_BIT);
  glBegin(GL_QUADS);
  glColor3d(0, 1, 1);
  glVertex2d(-0.7, -0.7);
  glColor3d(1, 0, 1);
  glVertex2d(-0.7, 0.7);
  glColor3d(1, 1, 0);
  glVertex2d(0.7, 0.7);
  glColor3d(0, 0, 0);
  glVertex2d(0.7, -0.7);
  glEnd();

}
 

#include <cstdio>

#include <Windows.h>
#include <gl/GL.h>
#include <GLFW/glfw3.h>

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

// 参考文献 ////////////////////////////////////////
// https://www.glfw.org/docs/latest/input_guide.html
 
//キー入力を処理するコールバック関数
void key_callback(GLFWwindow* pwin, int key, int scancode, int action, int mods) {

  // https://www.glfw.org/docs/latest/group__keys.html#ga99aacc875b6b27a072552631e13775c7

  // action ... GLFW_PRESS , GLFW_REPEAT , GLFW_RELEASE

  //特殊キー
  if (key == GLFW_KEY_UP && action == GLFW_PRESS) {
    printf("key up\n");
  }
  if (key == GLFW_KEY_DOWN && action == GLFW_PRESS) {
    printf("key down\n");
  }
  if (key == GLFW_KEY_LEFT && action == GLFW_PRESS) {
    printf("key left\n");
  }
  if (key == GLFW_KEY_RIGHT && action == GLFW_PRESS) {
    printf("key right\n");
  }

  if (key >= GLFW_KEY_A && key <= GLFW_KEY_Z) {
    if (action == GLFW_PRESS) {
      const char* key_name = glfwGetKeyName(key, 0);
      printf("key - %s\n", key_name);
    }
  }

}


// マウスクリックを処理するコールバック関数
void mouse_button_callback(GLFWwindow* pwin, int button, int action, int mods) {

  if (button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_PRESS) {
    printf("L - down\n");
  }
  if (button == GLFW_MOUSE_BUTTON_RIGHT && action == GLFW_PRESS) {
    printf("R - down\n");
  }
  if (button == GLFW_MOUSE_BUTTON_MIDDLE && action == GLFW_PRESS) {
    printf("M - down\n");
  }
  
}


// マウスホイールを処理するコールバック関数
void mouse_wheel_callback(GLFWwindow* window, double xoffset, double yoffset)
{
  if (yoffset < 0) {
    printf("wheel down \n");
  }
  if (yoffset > 0) {
    printf("wheel up \n");
  }
}


int main()
{
  if (glfwInit() == GL_FALSE) {
    return 1;
  }

  GLFWwindow* window = glfwCreateWindow(
    400,
    400,
    "window title",
    NULL,
    NULL
  );

  if (window == nullptr) {
    glfwTerminate();
    return 1;
  }

  ////////////////////////////////////////////
  // コールバック関数の設定
  glfwSetKeyCallback(window, key_callback);

  glfwSetMouseButtonCallback(window, mouse_button_callback);

  glfwSetScrollCallback(window, mouse_wheel_callback);
  //
  ////////////////////////////////////////////


  glfwMakeContextCurrent(window);

  while (glfwWindowShouldClose(window) == GL_FALSE) {

    int width, height;
    glfwGetFramebufferSize(window, &width, &height);

    /////////////////////
    // 描画
    glViewport(0, 0, width, height);
    glOrtho(-1, 1, -1, 1, -1, 1);

    glClearColor(0.2, 0.2, 0.2, 1);
    glClear(GL_COLOR_BUFFER_BIT);
    //
    /////////////////////

    glfwSwapBuffers(window);

    // イベント取得
    glfwWaitEvents();

  }

  glfwTerminate();

}