import bpy
import mathutils

def _nearestLineLinePoints3_(A,B,C,D):
    AC = C-A
    
    n1 = B-A
    n1.normalize()
    
    n2 = D-C
    n2.normalize()
    
    AmC=A-C
    CmA=C-A
    
    ###############################################
    numerator = n2.dot(AmC) + n2.dot(n1) * ( n1.dot(CmA) / n1.dot(n1) )
    denominator = n2.dot(n2) - n1.dot(n2)**2 / n1.dot(n1)
    
    d2 = numerator / denominator
    ###############################################
    numerator = n1.dot(CmA) + n1.dot(n2) * d2
    denominator = n1.dot(n1)
    
    d1 = numerator / denominator
    ###############################################
    
    dn1 = n1 * d1
    _PAB = A + dn1
    
    dn2 = n2 * d2
    _PCD = C + dn2
    
    return _PAB,_PCD

        
    
A = mathutils.Vector((0.390268,-0.093855,-0.48373))
B = mathutils.Vector((-0.401277 ,0.95607,-0.045612))
C = mathutils.Vector((-0.475275 ,-0.448733 ,0.344921))
D = mathutils.Vector((0.231105 ,0.937974 ,-0.776157))

PAB = mathutils.Vector((0,0,0))
PCD = mathutils.Vector((0,0,0))

ret = _nearestLineLinePoints3_(A,B,C,D)
    
PAB = ret[0]
PCD = ret[1]

#############################################
print( PAB,PCD)

#頂点定義
verts = []
verts.append( A )
verts.append( B )
verts.append( C )
verts.append( D )
verts.append( PAB )
verts.append( PCD )


#面を、それを構成する頂点番号で定義
edges =[]
edges.append( [0,1] )
edges.append( [2,3] )
edges.append( [4,5] )

#頂点と頂点番号からメッシュを作成
mymesh = bpy.data.meshes.new("mymesh")
mymesh.from_pydata(verts,edges,[]) #作成部分
mymesh.update()

#オブジェクトを作成し、メッシュを登録
obj = bpy.data.objects.new("My_Object", mymesh)

#オブジェクトのマテリアルを作成
mat = bpy.data.materials.new("Mat1")
mat.diffuse_color = (0.3,0.7,0.5,1.0)
obj.active_material = mat

#オブジェクトを登録
bpy.context.scene.collection.objects.link(obj)

// 末端 isum
inline int isum()
{
  return 0;
}

// 再帰呼び出し isum
template<typename First, typename... Rest>
int isum(const First& first, const Rest&... rest)
{
  return first + isum(rest...);
}

// 再起の最後
template<typename First, typename Second>
inline auto div(const First& first, const Second& second)
{
  return first / second;
}

// 連続で割り算を行う関数
template<typename First, typename Second, typename... Rest>
inline auto div(const First& first, const Second& second, const Rest& ... rest)
{
  return div( div(first , second) , rest...);
}

#include <iostream>

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

// 再起の最後
template<typename First, typename Second>
inline auto div(const First& first, const Second& second)
{
  return first / second;
}

// 連続で割り算を行う関数
template<typename First, typename Second, typename... Rest>
inline auto div(const First& first, const Second& second, const Rest& ... rest)
{
  return div(div(first, second), rest...);
}

//////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////
// 後ろから計算する場合

// 再起の最後
inline auto backDIV()
{
  return 1.0;
}

// 連続で割り算を行う関数
template<typename First, typename... Rest>
inline auto backDIV(const First& first, const Rest& ... rest)
{
  return first / backDIV(rest...) ;
}

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


int main()
{
  std::cout << "普通計算:";
  double k1 = 5.0 / 8.0 / 2.0;
  std::cout << k1;

  std::cout << std::endl;
  std::cout << "再帰(前方):";
  double k2 = div(5.0, 8.0, 2.0);
  std::cout << k2;


  std::cout << std::endl;
  std::cout << "再帰(後方):";
  double k3 = backDIV(5.0, 8.0, 2.0);
  std::cout << k3;



  int i;
  std::cin >> i;
}

import bpy

# @brief 与えられたCyclesのノードツリーの中のImage Textureノードを全て取得して返す
# @param [in] nodetree Cyclesのノードツリー
# @return Image Textureノードの一覧
def get_all_textures(nodetree):
    nodes = nodetree.nodes

    texturenodelist = []
        
    for node in nodes:
        if node.type == 'TEX_IMAGE':
            texturenodelist.append(node)
            
    return texturenodelist

# @brief ノードのto_nodeを辿り、特定のノードが見つかるまで再帰的に検索する
# @param [in] node Cyclesのノード
# @return 見つかったノード
# @retval None 見つからなかった場合
def get_input_to(node):
    
    if node.type == 'BUMP':
        return node
    if node.type == 'NORMAL_MAP':
        return node
    elif node.type == 'BSDF_DIFFUSE':
        return node
    elif node.type == 'BSDF_GLOSSY':
        return node
    elif node.type == 'BSDF_PRINCIPLED':
        return node

    for output in node.outputs:
        for link in output.links:
            return get_input_to(link.to_node)# 目的のノード出ないなら再帰呼び出し
    return None

# @brief テクスチャノードから、そのノードが繋がっているノードを探す
# @param [in] texnode CyclesのImage Textureノード
# @return 見つかったBump,Normalまたは各種BSDFノード
# @retval None 見つからなかった
def get_tex_input_to(texnode):
    for link in texnode.outputs["Color"].links:# テクスチャノードの"Color"に接続されたノードを探す
        prevnode = link.to_node
        tonode = get_input_to(prevnode)
        
        if tonode is not None:
            return tonode

    return None

# @brief マテリアルスロット内の全てのマテリアルについて、テクスチャノードの接続先を検索する
# @param [in] slots マテリアルスロット
# @return なし
def about_all_material(slots):
    
    for slot in slots:
        
        texturenodelist=[]
        
        material = slot.material
    
        nodetree = material.node_tree
        
        print("------" , material.name , "-------")
        texturenodelist = get_all_textures(nodetree)
        
        for texnode in texturenodelist:
            
            inputto = get_tex_input_to(texnode)
            
            print( texnode.name , inputto )

print("---------------")
print("---------------")
print("---------------")

# 呼び出し
about_all_material(bpy.context.active_object.material_slots)

#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")

#pragma warning(disable:4996)

// freeglut:
// http://freeglut.sourceforge.net/

// freetype2:
// https://www.freetype.org/

//FTGL
// https://sourceforge.net/projects/ftgl/

// 参考サイト　FTGLの使い方
// http://slis.tsukuba.ac.jp/~fujisawa.makoto.fu/lecture/iml/text/screen_character.html

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

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());
    }

  }

};

CFtglObject ftglo;

static int rot = 0;

//描画関数
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);

  glLoadIdentity();
  glScaled(0.5, 0.5, 0.5);

  glRotatef(rot, 1, 1, 1);
  rot++;

  glDisable(GL_CULL_FACE);
  double v = 0.7;

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

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

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

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

  glEnd();