#include <cstdio>

#pragma warning(disable:4996)

#include <unicode/utf16.h>

#include <locale>
int main()
{
  std::setlocale(LC_CTYPE, "");

  const char16_t* str = u"い👨‍👦は";

  const char16_t* p = str;
  int i = 0;
  while (p[i]) {

    bool bs = U16_IS_SURROGATE(p[i]);//サロゲートペアかどうか

    int iback = i;
    char32_t u32c;
    U16_NEXT_UNSAFE(p, i,u32c);

    if (bs==false) {
      if (p[iback] == 0x200d) {//サロゲートペアではないが、結合文字
        printf("[%x] Combine string\n", p[iback]);
      }
      else {//一文字
        printf("%s [%x] (%lc) -> %x\n",
          " true ",
          p[iback],
          p[iback],
          u32c
        );
      }
    }
    else {//サロゲートペア
      printf("%s [%x,%x] -> %x ",
        " false",
        U16_LEAD(u32c),//u32からサロゲートペアを求める
        U16_TRAIL(u32c),
        u32c
      );
      printf(" * [%x,%x]", p[iback], p[iback + 1]);//u16のサロゲートペアを表示
      puts("");
    }
  }

}

#include <iostream>

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

#include <FTGL/ftgl.h>

#pragma comment(lib,"opengl32.lib")
#pragma comment(lib,"freeglut.lib")
#pragma comment(lib,"ftgl.lib")

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

// FTGLを管理しやすくするクラス
struct CFtglObject {
  const char* FONT_PATHNAME = "C:\\Windows\\Fonts\\msgothic.ttc";
  FTPixmapFont* g_pFont;
  unsigned long g_ulFontSize;  // フォントサイズ

  ~CFtglObject() {
    delete g_pFont;
  }


  // フォントの初期化
  void init(const unsigned long fontsize) {

    g_ulFontSize = fontsize;

    if (!g_pFont) {
      g_pFont = new FTPixmapFont(FONT_PATHNAME);
      if (g_pFont->Error()) {
        delete g_pFont;
        g_pFont = nullptr;
      }
      else {
        g_pFont->FaceSize(g_ulFontSize);
      }
    }
  }

  // FTGLで文字列を描画
  void print(const std::wstring& wstr, float x, float y) {

    if (g_pFont) {
      glRasterPos2f(x, y);
      g_pFont->Render(wstr.c_str());
    }

  }
  FTPixmapFont& get_font() { return *g_pFont; }
};

CFtglObject ftglo;

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

  glViewport(0, 0, width, height);

  glClearColor(0.2, 0.2, 0.2, 1);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glOrtho(-1, 1, -1, 1, 1, -1);

  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();


  glEnable(GL_CULL_FACE);
  double v = 0.7;


  glBegin(GL_QUADS);
  glColor3d(0, 0, 1);
  glVertex2d(-v, -v);
  glColor3d(1, 0, 1);
  glVertex2d(v, -v);
  glColor3d(1, 1, 1);
  glVertex2d(v, v);
  glColor3d(0, 1, 1);
  glVertex2d(-v, v);
  glEnd();

  glLineWidth(2);
  glBegin(GL_LINES);
  glColor3d(1, 1, 0);
  glVertex2d(-v, 0);
  glColor3d(1, 1, 1);
  glVertex2d(v, 0);

  glColor3d(1, 1, 0);
  glVertex2d(0, -v);
  glColor3d(1, 1, 1);
  glVertex2d(0, v);
  glEnd();

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

  const wchar_t* text;

  text = L"いろはに";
  ftglo.print(text, 0, 0);
  FTBBox bbox = ftglo.get_font().BBox(text);
  float BoxHeightPixel = bbox.Upper().Yf() - bbox.Lower().Yf();//文字列の高さを求める

  // BoxHeightの単位がピクセルらしいので、これを現在の文字幅に修正する。
  // 現在は -1 ～ 1の範囲を0～height-1ピクセルで表示しているので、
  float ratioh = 2.f/height;
  float pixelh = ratioh * BoxHeightPixel;

  text = L"ほへと";
  ftglo.print(text, 0, pixelh);

  glFlush();
}

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

  disp();
}



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

  ftglo.init(32);

  glutCreateWindow("sample");
  glutDisplayFunc(disp);
  glutReshapeFunc(reshape);
  glutMainLoop();

  return 0;
}

//https://suzulang.com/2d-triangle-in-out-check/
template<typename real_t>
inline bool isInTheTriangle(
  real_t px, real_t py,
  real_t p0x, real_t p0y,
  real_t p1x, real_t p1y,
  real_t p2x, real_t p2y
) {
  real_t Area = 0.5 * (-p1y * p2x + p0y * (-p1x + p2x) + p0x * (p1y - p2y) + p1x * p2y);

  real_t s = 1.0 / (2.0 * Area) * (p0y * p2x - p0x * p2y + (p2y - p0y) * px + (p0x - p2x) * py);
  real_t t = 1.0 / (2.0 * Area) * (p0x * p1y - p0y * p1x + (p0y - p1y) * px + (p1x - p0x) * py);


  real_t e = 0.05;
  real_t tmin = 0.0 - e;
  real_t tmax = 1.0 + e;

  if (

    (tmin < s) && (s < tmax) &&
    (tmin < t) && (t < tmax) &&
    (tmin < (1 - s - t)) &&
    ((1 - s - t) < tmax)

    ) {
    return true;
  }
  else {
    return false;
  }
}

  auto p0 = glm::vec3(-0.913841, 0.999223, 0);
  auto p1 = glm::vec3(0.032665, -0.787554, 0);
  auto p2 = glm::vec3(0.853559, 0.974719, 0);

  glBegin(GL_TRIANGLES);
  glVertex2fv(glm::value_ptr(p0));
  glVertex2fv(glm::value_ptr(p1));
  glVertex2fv(glm::value_ptr(p2));
  glEnd();

  glPointSize(5);
  glBegin(GL_POINTS);
  for (float x = -2.f; x < 2.f; x += 0.1f) {
      for (float y = -2.f; y < 2.f; y += 0.1f) {

    bool hit = isInTheTriangle(
        x, y,
        p0.x, p0.y,
        p1.x, p1.y,
        p2.x, p2.y
    );

    if (hit)
        glColor3d(1, 0, 0);
    else
        glColor3d(0.7, 0.7, 0.7);

    glVertex2f(x,y);


      }
  }
  glEnd();

#pragma warning(disable:4996)

#include <iostream>

#include <unicode/utf16.h>

int main()
{
  const char16_t* u16c = u"あいう";

  char32_t u32c;

  FILE* fp = fopen("test.txt", "w");
  U16_GET_UNSAFE(u16c, 0, u32c);
  fwrite(&u32c, 4, 1, fp);

  U16_GET_UNSAFE(u16c, 2, u32c);
  fwrite(&u32c, 4, 1, fp);


  fclose(fp);
}

    std::u32string cc;
    // U16_LENGTH 与えられたu32がu16で何要素になるか
    int len;
    cc = U"a";
    len = U16_LENGTH(cc[0]);
    printf("--- %d\n", len); // 1 utf16一文字
    cc = U"あ";
    len = U16_LENGTH(cc[0]);
    printf("--- %d\n", len); // 1 utf16一文字
    cc = U"👨‍👩‍👧‍👦";
    len = U16_LENGTH(cc[0]);
    printf("--- %d\n", len); // 2 結合文字の最初の一文字
    cc = U"𠀋";
    len = U16_LENGTH(cc[0]);
    printf("--- %d\n", len); // 2 サロゲートペア
    cc = U"𠀋𡚴";
    len = U16_LENGTH(cc[0]);
    printf("--- %d\n", len); // 2 最初の一文字がサロゲートペア