import bpy
import sys


def my_triangulation(target = bpy.context.object) :

    # なにも選択されていなければ終了
    if target == None:
        return False

    # メッシュだけを対象とする
    if target.type == 'MESH' :

        # EDITモードへ移行するために現在のモードを保存して奥
        current = bpy.context.object.mode

        # Editモードへ移行
        bpy.ops.object.mode_set(mode = 'EDIT')

        # 三角形分割実行
        bpy.ops.mesh.quads_convert_to_tris()

        # モードをリストア。これをしないとEDITモードのままで終わる。
        bpy.ops.object.mode_set(mode = current)

    else:
        return False

    return True



############################################
############################################

def to_simple_polygon_file(outputto) :
    obj = bpy.context.active_object

    mesh = obj.data

    pvecname = "points"   # 頂点データの配列の変数名
    vnvecname = "vnorms"  # 頂点法線の配列の変数名
    fvecname = "faces"    # 面データの配列の変数名
    fnvecname = "fnorms"  # 面法線の配列の変数名

    print("/////////////////////////////////////")

    print("#szlm,-,-,-,-", file = outputto)


    for f in mesh.polygons:
        if not fvecname is None :
            print(
                "ti,",
                f.vertices[0], ",",
                f.vertices[1], ",",
                f.vertices[2],
                0,
                file = outputto
            )

        if not fnvecname is None :
            print(
                "tn,",
                f.normal.x, ",",
                f.normal.y, ",",
                f.normal.z,
                0,
                file = outputto
            )

    for v in mesh.vertices:
        if not pvecname is None :
            print(
                "pp,",
                v.co.x, ",",
                v.co.y, ",",
                v.co.z,
                0,
                file = outputto
            )

        if not vnvecname is None :
            print(
                "pn,",
                v.normal.x, ",",
                v.normal.y, ",",
                v.normal.z,
                0,
                file = outputto
            )



# 三角形分割
ret = my_triangulation()

o = open('c:/data/myfile3.txt', 'w')
to_simple_polygon_file(o)
o.close()
#as_cpp_array(sys.stdout)

#pragma once

#pragma warning(disable:4996)

#include <vector>
#include <array>
#include <type_traits>
#include <string>

/*
#szlm,-,-,-,-
ti,1,2,3,-
tc,0.1,0.1,0.1,-
tn,0.1,0.1,0.1,-
pp,0.1,0.1,0.1,-
pc,0.1,0.1,0.1,-
pn,0.1,0.1,0.1,-
*/

struct szlm {
  std::vector<std::array<int, 4>> ti;
  std::vector<std::array<float, 4>> 
    tc // triangle color
    ,tn// triangle normal
    ,pp// point position
    ,pc// point color
    ,pn// point normal
    ;
};
//! @brief 簡易的メッシュフォーマットの読み込み
//! @param [in] file ファイル名
//! @param [out] mesh メッシュを保存する構造体
bool read_mesh(const char* file, szlm* mesh) {
  FILE* fp = fopen(file, "r");
  if (fp == NULL)
    return false;

  constexpr size_t DIM = 4;

  const size_t BUFFERSIZE = 2048;
  char b[BUFFERSIZE];
  //,で分割
  auto split = [](char* buffer, std::vector<std::string>& split)->void {
    const char* sp = ",";
    char* tok = strtok(buffer, sp);
    while (tok != NULL) {
      split.push_back(tok);
      tok = strtok(NULL, sp);  /* 2回目以降 */
    }
  };
  //配列へ入力

  while (fgets(b, BUFFERSIZE, fp) != NULL) {
    std::array<int, DIM> ii;
    std::array<float, DIM> ff;
    std::fill_n(ii.begin(), DIM, -1);
    std::fill_n(ff.begin(), DIM, INFINITY);
    std::vector<std::string> line;
    split(b, line);//入力行を,で分割
    for (size_t i = 1; i < (std::min)(DIM, line.size()); i++) {
      ii[i - 1] = atoi(line[i].c_str());
      ff[i - 1] = atof(line[i].c_str());
    }

    if (b[0] == '#')continue;
    else if (strncmp(b, "ti", 2) == 0)mesh->ti.push_back({ ii[0],ii[1],ii[2],ii[3] });// triangle pointindex
    else if (strncmp(b, "tc", 2) == 0)mesh->tc.push_back({ ff[0],ff[1],ff[2],ff[3] });// triangle color
    else if (strncmp(b, "tn", 2) == 0)mesh->tn.push_back({ ff[0],ff[1],ff[2],ff[3] });// triangle normal
    else if (strncmp(b, "pp", 2) == 0)mesh->pp.push_back({ ff[0],ff[1],ff[2],ff[3] });// point position
    else if (strncmp(b, "pc", 2) == 0)mesh->pc.push_back({ ff[0],ff[1],ff[2],ff[3] });// point color
    else if (strncmp(b, "pn", 2) == 0)mesh->pn.push_back({ ff[0],ff[1],ff[2],ff[3] });// point normal
  }
  fclose(fp);

  return false;
}

void disp(const szlm& mesh) {

    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    glBegin(GL_TRIANGLES);
    for (size_t i = 0; i < mesh.ti.size(); i++) {
        int v0 = mesh.ti[i][0];
        int v1 = mesh.ti[i][1];
        int v2 = mesh.ti[i][2];

        glNormal3fv(mesh.tn[i].data());
        glVertex3fv(mesh.pp[v0].data());
        glVertex3fv(mesh.pp[v1].data());
        glVertex3fv(mesh.pp[v2].data());

    }
    glEnd();

}


int main()
{

    struct szlm mesh;
    read_mesh("C:\\data\\myfile3.txt", &mesh);

    /* ... */


    disp(mesh);
}

#pragma once

#include "Grid.hpp"

#include <array>
#include <vector>
#include <memory>

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

// 三次元オブジェクトのスーパークラス
class object_3d {
protected:
  glm::vec3 _color;
public:

  object_3d(const glm::vec3& color_) :_color(color_) {}
  object_3d() {}

  virtual bool intersect(
    glm::vec3* pos_,
    glm::vec3* color_,
    glm::vec3* normal_,
    float* distance_,
    const std::array<glm::vec3, 2>& ray_)const = 0;

  const glm::vec3& color()const { return _color; }
  glm::vec3& color() { return _color; }

};

// 球オブジェクト
class object_sphere:public object_3d {
  glm::vec3 _center;
  float _r;
public:
  object_sphere(glm::vec3 center_, glm::vec3 color_,float radius_) :
    _center(center_),_r(radius_), object_3d(color_) {}
  object_sphere() {}

  virtual bool intersect(
    glm::vec3* pos_, 
    glm::vec3* color_,
    glm::vec3* normal_,
    float* distance_,
    const std::array<glm::vec3, 2>& ray_)const override;

};

// 三角形オブジェクト
class object_triangle :public object_3d {
  std::array<glm::vec3,3> _points;
public:
  object_triangle(
    std::array<glm::vec3, 3> points_, glm::vec3 color_) :
    _points(points_), object_3d(color_){}
  object_triangle() {}

  bool intersect(
    glm::vec3* pos_,
    glm::vec3* color_,
    glm::vec3* normal_,
    float* distance_,
    const std::array<glm::vec3, 2>& ray_)const override;


};

//////////////////////////////////////////////
//////////////////////////////////////////////
// ポイントライト
class light_point {
  glm::vec3 _position;
  glm::vec3 _diffuse_color;
  glm::vec3 _ambient_color;
  glm::vec3 _specular_color;
public:

  light_point(
    const glm::vec3& position_, 
    const glm::vec3& diffuse_color_,
    const glm::vec3& ambient_color_,
    const glm::vec3& specular_color_
  ) :
    _position(position_), 
    _diffuse_color(diffuse_color_),
    _ambient_color(ambient_color_),
    _specular_color(specular_color_)
  {}
  light_point() {}

  glm::vec3 calc_vector_point_to_light(const glm::vec3& point_)const {
    // from -> _position
    return glm::normalize(_position - point_);
  }

  const glm::vec3& position()const {return _position;}
  glm::vec3& position() { return _position; }

  const glm::vec3& diffuse_color()const {return _diffuse_color;}
  glm::vec3& diffuse_color() { return _diffuse_color; }

  const glm::vec3& ambient_color()const { return _ambient_color; }
  glm::vec3& ambient_color() { return _ambient_color; }

  const glm::vec3& specular_color()const { return _specular_color; }
  glm::vec3& specular_color() { return _specular_color; }

};

struct hit_pixel_t {
  glm::vec3 _position;
  glm::vec3 _color;
  hit_pixel_t(const glm::vec3& position_, const glm::vec3& color_) :
    _position(position_), _color(color_) {}

};


// レイキャスト用のクラス
class my_raycast {
  grid g[2];
  float _startZ;
  float _endZ;
  int _pxwidth;
  int _pxheight;
public:

  glm::vec3 get_eye_position()const {
    float a = g[0].ywidth() / 2.0;
    float b = g[1].ywidth() / 2.0;
    float d = glm::length(g[1].center() - g[0].center());
    float c = a * d / (b - a);


    // 始点　→　終点
    glm::vec3 veceye = g[1].center() - g[0].center();
    veceye = glm::normalize(veceye);
    return g[0].center()  - veceye * c;
  }

  my_raycast() {}

  int width()const { return _pxwidth; }
  int height()const { return _pxheight; }

  // レイの開始点となるグリッド、終点となるグリッドを作成する
  void set(const float startZ_, const float endZ_, const int pxwidth_, const int pxheight_);

  //グリッド取得
  const grid& get_grid(const size_t index)const {
    return g[index];
  }

  //グリッドから作成するレイの数を取得
  int ray_count() {
    return g[0].cellCount();
  }

  //グリッドから作成するレイを取得
  std::array<glm::vec3, 2> get_ray(const size_t index)const;

  //始点グリッド、終点グリッドの中間の位置を取得（表示用）
  float lookatZ()const {
    return (_startZ + _endZ) / 2.f;
  }


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

private:

  // オブジェクト一覧
  std::vector< std::shared_ptr<object_3d> > _objlist;


  std::vector< hit_pixel_t > _hits;
public:
  void raycast();
  std::vector< hit_pixel_t >& get_intersects() {return _hits;}
  
  void set_object(const object_sphere& obj_);
  void set_object(const object_triangle& obj_);
  
  //////////////////////////////
private:
  light_point _light;
public:
  void set_light(const light_point& light_);

  const light_point& get_light()const { return _light; }
};

// objectNormal 面法線
// lightDirection そのポイント→光源へのベクトル
// lightColor ライトの色
inline glm::vec3 calc_diffuse(
  const glm::vec3& lightDiffuse, 
  const glm::vec3& MaterialDiffuse, 
  const glm::vec3& lightIncidence,
  const glm::vec3& objectNormal) 
{
  // 拡散反射は「そのポイント→光源」と面法線の内積を取る

  float sDotN = glm::max(glm::dot(-lightIncidence, objectNormal), 0.f);

  return lightDiffuse * MaterialDiffuse *sDotN;
}

inline glm::vec3 calc_ambient(
  const glm::vec3& LightAmbient, 
  const glm::vec3& MaterialAmbient) 
{
  return LightAmbient * MaterialAmbient;
}

// https://araramistudio.jimdo.com/2017/10/02/%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0-directx-11%E3%81%A7%E9%8F%A1%E9%9D%A2%E5%8F%8D%E5%B0%84-specular-reflection/
// https://amengol.github.io/game_physics/using-glm-reflect-to-react/
// https://learnopengl.com/Lighting/Basic-Lighting

inline glm::vec3 calc_specular(
  const glm::vec3& eyePosition,
  const glm::vec3& lightSpecularColor,
  const glm::vec3& materialSpecularColor,
  const glm::vec3& lightIncidence, // 入射
  const float materialShininess,
  const glm::vec3& objectNormal,
  const glm::vec3& objectPosition
)
{

  glm::vec3 VertexToEye = glm::normalize(eyePosition - objectPosition);


  glm::vec3 LightReflect = glm::normalize(glm::reflect(lightIncidence, objectNormal));

  float SpecularFactor = glm::pow(glm::max(glm::dot(VertexToEye, LightReflect),0.f), materialShininess);

  glm::vec3 SpecularColor(0, 0, 0);
  SpecularColor = SpecularFactor * lightSpecularColor * materialSpecularColor;

  return SpecularColor;

}

#include "raycast.hpp"

#include <glm/gtx/intersect.hpp>
#include <glm/gtx/normal.hpp >

#include <memory>

bool object_sphere::intersect(
  glm::vec3* pos_, 
  glm::vec3* color_,
  glm::vec3* normal_,
  float* distance_,
  const std::array<glm::vec3, 2>& ray_) const{

  glm::vec3 nray = glm::normalize(ray_[1] - ray_[0]);

  float distance;

  bool valid = glm::intersectRaySphere(ray_[0], nray, _center, _r*_r, distance);

  //レイが衝突した点の座標
  *pos_ = ray_[0] + nray * distance;

  //色の設定
  *color_ = _color;


  //面法線
  // 球中心 → 衝突点
  *normal_ = glm::normalize(*pos_ - _center);

  *distance_ = distance;

  return valid;
}


bool object_triangle::intersect(
  glm::vec3* pos_,
  glm::vec3* color_,
  glm::vec3* normal_,
  float* distance_,
  const std::array<glm::vec3, 2>& ray_)const {

  glm::vec3 nray = glm::normalize(ray_[1] - ray_[0]);

  float distance;

  glm::vec2 bary;
  
  bool valid = glm::intersectRayTriangle(
    ray_[0],
    nray,
    _points[0],
    _points[1],
    _points[2],
    bary,
    distance
  );

  //レイが衝突した点の座標
  *pos_ = ray_[0] + nray * distance;


  //色の設定
  *color_ = _color;

  //面法線
  *normal_ = glm::triangleNormal(
    _points[0],
    _points[1],
    _points[2]
    ); // normalize済


  *distance_ = distance;
  return valid;

}



void my_raycast::set(const float startZ_, const float endZ_, const int pxwidth_, const int pxheight_) {
  _startZ = startZ_;
  _endZ = endZ_;

  _pxwidth = pxwidth_;
  _pxheight = pxheight_;

  glm::vec3 vecx(1, 0, 0);
  glm::vec3 vecy(0, 1, 0);

  g[0] = grid(
    vecx,
    vecy,
    glm::vec3(0, 0, _startZ),
    1.f, 1.f,
    pxwidth_, pxheight_
  );
  g[1] = grid(
    vecx,
    vecy,
    glm::vec3(0, 0, _endZ),
    2.f, 2.f,
    pxwidth_, pxheight_
  );

}


std::array<glm::vec3, 2> my_raycast::get_ray(const size_t index)const {
  return
    std::array<glm::vec3, 2>{
    g[0][index].center(),
      g[1][index].center()
  };

}

void my_raycast::set_object(const object_sphere& obj_) {
  _objlist.push_back(std::make_shared<object_sphere>(obj_));
}
void my_raycast::set_object(const object_triangle& obj_) {
  _objlist.push_back(std::make_shared<object_triangle>(obj_));
}

void my_raycast::set_light(const light_point& light_) {
  _light = light_;
}

void my_raycast::raycast() {

  // 結果の初期化
  float inf = std::numeric_limits<float>::infinity();
  _hits.clear();
  _hits.resize(_pxwidth * _pxheight,
    hit_pixel_t(
      glm::vec3(inf, inf, inf),
      glm::vec3(0, 0, 0)
    )
  );

  for (size_t i = 0; i < _pxwidth * _pxheight; i++) {

    auto ray = get_ray(i);

    glm::vec3 p; // レイがヒットした座標
    glm::vec3 c; // レイがヒットした位置の色
    glm::vec3 n; // レイがヒットした位置の法線

    float distance = (std::numeric_limits<float>::max)();
    bool hit = false;
    for (auto _obj : _objlist) {
      float _tmpdist;
      glm::vec3 tmp_p;
      glm::vec3 tmp_c;
      glm::vec3 tmp_n;