#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 最初の一文字がサロゲートペア

#pragma warning(disable:4996)
#include <iostream>
#include <unicode/utf16.h>
int main()
{
  // UTF32
  //char32_t u32c = U'あ';
  char32_t u32c = U'𠀋';
  
  // char32->char16に変換したとき何文字になるかをチェック
  if (U16_LENGTH(u32c) == 2){

    // utf16に変換したときサロゲートペアになる場合は上下サロゲートを算出
    char16_t aa[2];
    aa[0] = U16_LEAD(u32c);  // 上位サロゲート
    aa[1] = U16_TRAIL(u32c); // 下位サロゲート
    // ファイル出力
    FILE* fp = fopen("test.txt", "w");
    fwrite(aa, 2, 2, fp);
    fclose(fp);

  }
  else {

    //サロゲートペアに変換する必要がなければコードユニット値がutf16文字

    char16_t u16 = char16_t(u32c);
    // ファイル出力
    FILE* fp = fopen("test.txt", "w");
    fwrite(&u16, 2, 1, fp);
    fclose(fp);

  }
}

static float z = 3.f;
{
  z -= 0.1;

  glm::vec3 p(1, z, 0); //どこか頂点
  glm::vec3 a(0, -2, 0);//線分の始点
  glm::vec3 b(0, 2, 0); //線分の終点

  // 点に最も近い直線上の点を求めるのに必要
  // #include <glm/gtx/closest_point.hpp>
  glm::vec3 kk = glm::closestPointOnLine(p, a, b);

  glLineWidth(3);//線分
  glBegin(GL_LINES);
  glVertex3fv(glm::value_ptr(a));
  glVertex3fv(glm::value_ptr(b));
  glEnd();

  glPointSize(7);//どこか頂点
  glColor3d(1, 0, 0);
  glBegin(GL_POINTS);
  glVertex3fv(glm::value_ptr(p));
  glEnd();

  glPointSize(7);//線分上の点
  glColor3d(0, 1, 0);
  glBegin(GL_POINTS);
  glVertex3fv(glm::value_ptr(kk));
  glEnd();
}

import bpy

# マテリアルにワイヤフレームを追加する
def set_wireframe(mat):

    nodetree = mat.node_tree

    nodes = nodetree.nodes

    MaterialOutput = nodes['Material Output']

    # MaterialOutputにつながっているノードを取得。
    # backup -- (wireframe) -- MaterialOutput と挟み込む
    backup = MaterialOutput.inputs[0].links[0].from_node

    # ワイヤフレームに必要なノードを追加
    wireframe = nodes.new('ShaderNodeWireframe')
    diffuse = nodes.new('ShaderNodeBsdfDiffuse')
    mixnode = nodes.new('ShaderNodeMixShader')

    # ワイヤフレームの色を黒に設定
    diffuse.inputs["Color"].default_value[0] =0
    diffuse.inputs["Color"].default_value[1] =0
    diffuse.inputs["Color"].default_value[2] =0

    # mix , diffuse , wireframe の三つをつなげる
    nodetree.links.new(wireframe.outputs[0],mixnode.inputs[0])
    nodetree.links.new(diffuse.outputs[0],mixnode.inputs[2])
    # mixにこれまで指定されていたノードをつなぐ
    nodetree.links.new(backup.outputs[0],mixnode.inputs[1])

    # mixをMaterialOutputへ繋げる
    nodetree.links.new(mixnode.outputs[0],MaterialOutput.inputs[0])

    # 位置調整
    
    # MaterialOutputを少し右へずらし、その位置にmixを入れ、同じ位置にdiffuseとwireframeを入れる
    MaterialOutput.location.x = MaterialOutput.location.x + 200
    mixnode.location.x = MaterialOutput.location.x - 200
    wireframe.location.x = mixnode.location.x
    diffuse.location.x =  mixnode.location.x

    # mix,wireframe,diffuseの高さを変えてそれぞれ配置する
    mixnode.location.y = MaterialOutput.location.y
    wireframe.location.y = mixnode.location.y + 200
    diffuse.location.y = mixnode.location.y - 200

    # ワイヤフレームの線の太さを設定
    wireframe.inputs["Size"].default_value = 0.05


set_wireframe(
    bpy.context.active_object.material_slots["Material"].material)