#include <zip.h>

#include <iostream>

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

int main(int argc, char* argv[])
{
  // ZIPファイルを読み取り専用で開く
  int errorp;

  zip_t* zipper = zip_open(R"(C:\test\zipdata.zip)", ZIP_RDONLY , &errorp);

  // ZIP内のファイルの個数を取得
  zip_int64_t num_entries = zip_get_num_entries(zipper, 0);

  // ZIP内のファイルの各ファイル名を取得
  std::cout << "count: " << num_entries << std::endl;
  for (zip_int64_t index = 0; index < num_entries; index++) {
    std::cout << "[" << index << "]" << zip_get_name(zipper, index, ZIP_FL_ENC_RAW) << std::endl;
  }

  // ZIP内の2番目のファイルに関する情報を取得する
  struct zip_stat sb;
  zip_int64_t index = 2;
  zip_stat_index(zipper, index, 0, &sb);

  // 2番目のファイルのファイルサイズと同じメモリを確保する
  char* contents = new char[sb.size];

  // 2番目のファイルの内容をメモリに読み込む
  zip_file* zf = zip_fopen(zipper, sb.name, 0);
  zip_fread(zf, contents, sb.size);
  zip_fclose(zf);

  zip_close(zipper);

  //////////////////
  // ファイル名を出力できる形に変更
  // ファイル一覧は階層構造をしておらず、ディレクトリ区切りは'/'で直接出力できないので
  // ファイル名中の'/'を'-'に置き換える。
  // 本来なら再帰的にディレクトリを作るなどすべき。
  std::string target = sb.name;
  for (size_t i = 0; i < target.size(); i++) {
    if (target[i] == '/') {
      target[i] = '-';
    }
  }
  //
  //////////////////

  // 解凍したファイルを作成
  std::string outname = R"(C:\test\)" + target;
  FILE* of = fopen(outname.c_str(), "wb");
  fwrite(contents, 1, sb.size, of);
  fclose(of);

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

#include <zip.h>

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


int main(int argc, char* argv[])
{

  int errorp;
  zip_t* zipper = zip_open(R"(C:\dev\out.zip)", ZIP_CREATE | ZIP_EXCL, &errorp);

  zip_source_t* source;

  try {
    /////////////////////////////////////////////////////////////////////
    /////////////////////////////////////////////////////////////////////
    // ファイル追加

    source = zip_source_file(zipper, R"(C:\test\data\img1.jpg)", 0, 0);
    if (zip_file_add(zipper, R"(img1.jpg)", source, ZIP_FL_ENC_UTF_8) < 0) {
      //エラー処理
      zip_source_free(source);
      throw 1;
    }
    source = zip_source_file(zipper, R"(C:\test\data\img2.jpg)", 0, 0);
    if (zip_file_add(zipper, R"(img2.jpg)", source, ZIP_FL_ENC_UTF_8) < 0) {
      //エラー処理
      zip_source_free(source);
      throw 1;
    }
    source = zip_source_file(zipper, R"(C:\test\data\img3.jpg)", 0, 0);
    if (zip_file_add(zipper, R"(img3.jpg)", source, ZIP_FL_ENC_UTF_8) < 0) {
      //エラー処理
      zip_source_free(source);
      throw 1;
    }

    /////////////////////////////////////////////////////////////////////
    /////////////////////////////////////////////////////////////////////
    // ディレクトリ追加
    if (zip_dir_add(zipper, "folder", ZIP_FL_ENC_UTF_8) < 0) {
      //エラー処理
      zip_source_free(source);
      throw 1;
    }

    /////////////////////////////////////////////////////////////////////
    /////////////////////////////////////////////////////////////////////
    // ファイル追加

    source = zip_source_file(zipper, R"(C:\test\data\dir\img4.jpg)", 0, 0);
    if (zip_file_add(zipper, R"(folder\img4.jpg)", source, ZIP_FL_ENC_UTF_8) < 0) {
      //エラー処理
      zip_source_free(source);
      throw 1;
    }
    source = zip_source_file(zipper, R"(C:\test\data\dir\img5.jpg)", 0, 0);
    if (zip_file_add(zipper, R"(folder\img5.jpg)", source, ZIP_FL_ENC_UTF_8) < 0) {
      //エラー処理
      zip_source_free(source);
      throw 1;
    }
    source = zip_source_file(zipper, R"(C:\test\data\dir\img6.jpg)", 0, 0);
    if (zip_file_add(zipper, R"(folder\img6.jpg)", source, ZIP_FL_ENC_UTF_8) < 0) {
      //エラー処理
      zip_source_free(source);
      throw 1;
    }

    zip_close(zipper);

  }
  catch (...) {
    zip_close(zipper);
  }

  return 0;
}

import bpy

# textオブジェクトの追加

fontCurve1 = bpy.data.curves.new(type="FONT",name="fontCurve1")
obj = bpy.data.objects.new("textObject",fontCurve1)
obj.data.body = "Hello"# textオブジェクトの内容
      
# 新しいCollrectionを作成
newCol = bpy.data.collections.new('Collection 1')

# 現在のシーンにコレクションをリンク
bpy.context.scene.collection.children.link(newCol)

newCol.objects.link(obj)

# フォントの変更

fnt = bpy.data.fonts.load('C:\Windows\Fonts\HARNGTON.TTF')
obj.data.font = fnt
 

#pragma once

//////////////////////////////////////////////////////
//////////////////////////////////////////////////////
// プライマリテンプレート
template<typename T>
struct GETTER;

//////////////////////////////////////////////////////
//////////////////////////////////////////////////////
// 特殊化用の構造体

//小文字 x,y,z用特殊化用の構造体
template<typename T>
struct access_xyz {
  using scalar_t = decltype(T::x);
  static inline scalar_t& X(T& v) { return v.x; }
  static inline scalar_t& Y(T& v) { return v.y; }
  static inline scalar_t& Z(T& v) { return v.z; }
  static inline const scalar_t& X(const T& v) { return v.x; }
  static inline const scalar_t& Y(const T& v) { return v.y; }
  static inline const scalar_t& Z(const T& v) { return v.z; }
};

//大文字 X,Y,Z用特殊化用の構造体
template<typename T>
struct access_XYZ {
  using scalar_t = decltype(T::X);
  static inline scalar_t& X(T& v) { return v.X; }
  static inline scalar_t& Y(T& v) { return v.Y; }
  static inline scalar_t& Z(T& v) { return v.Z; }
  static inline const scalar_t& X(const T& v) { return v.X; }
  static inline const scalar_t& Y(const T& v) { return v.Y; }
  static inline const scalar_t& Z(const T& v) { return v.Z; }
};

//配列用特殊化用の構造体
template<typename U,typename T>
struct access_ARRAY{
  static inline U& X(T& v) { return v[0]; }
  static inline U& Y(T& v) { return v[1]; }
  static inline U& Z(T& v) { return v[2]; }
  static inline const U& X(const T& v) { return v[0]; }
  static inline const U& Y(const T& v) { return v[1]; }
  static inline const U& Z(const T& v) { return v[2]; }
};

//////////////////////////////////////////////////////
//////////////////////////////////////////////////////
// データ型（サンプル）
// 型１
struct vec_t {
  double x, y, z;
};

// 型２
struct VEC_t {
  double X, Y, Z;
};

//////////////////////////////////////////////////////
//////////////////////////////////////////////////////
//特殊化１（デフォルトの型）

template<>
struct GETTER<vec_t> :public access_xyz<vec_t> {};

template<>
struct GETTER<VEC_t> :public access_XYZ<VEC_t> {};

//////////////////////////////////////////////////////
//////////////////////////////////////////////////////
// 特殊化２（ポインタ版）

template<typename T>
struct GETTER<T*> : public access_ARRAY<T,T*> {};

template<class T, std::size_t N>
struct GETTER<T[N]> : public access_ARRAY<T, T[N]> {};

template<typename T, std::size_t N>
struct GETTER<std::array<T, N> > : public access_ARRAY<T, std::array<T, N> > {};

//////////////////////////////////////////////////////
//////////////////////////////////////////////////////
// 関数本体

template<
  typename T,
  class G = GETTER<T>
>
double length(const T & v) {

  return
    sqrt(
      G::X(v) * G::X(v) +
      G::Y(v) * G::Y(v) +
      G::Z(v) * G::Z(v)
    );
}

template<
  typename T,
  class G = GETTER<T>
>
void normalize(T & v) {

  double L = length(v);

  G::X(v) = G::X(v) / L;
  G::Y(v) = G::Y(v) / L;
  G::Z(v) = G::Z(v) / L;

}