GameApi_cmd.hh

Go to the documentation of this file.

 
 
#ifdef DEFINE_ALL
#define FEATURE_GLTF 1
#define FEATURE_VOXEL 1
#define FEATURE_VOLUME 1
#else
#define FEATURE_GLTF 1
#define FEATURE_VOXEL 1
#define FEATURE_VOLUME 1
#endif
#define FEATURE_FONT 1
#define FEATURE_MATERIAL 1
#define FEATURE_FRAMEBUFFER 1
#define FEATURE_PTS 1
#define FEATURE_WAVEFORM 1
#define FEATURE_GUI 1
#define FEATURE_BOOLEANOPS 1
#define FEATURE_OGL_SETUP 1
 
#ifdef DEFINE_ALL
#define ALL 1
#else
#include "GameApi_short_defines.hh"
#endif
 
 
 
 
#if (NEWSHADOW2_GLTF==1)||(GLTF_NEWSHADOW2==1)
#define FEATURE_GLTF 1
#endif
#if (SPHERE_BO==1)||(OR_ELEM_BO==1)||(INTERSECT_BO==1)||(CUBE_BO==1)||(FD_MIN==1)
#define FEATURE_VOLUME 1
#endif
 
 
 
int ret_type_count(std::string s);
struct DelApiItemF
{
  std::vector<GameApiItem*> items;
  ~DelApiItemF() { int s = items.size(); for(int i=0;i<s;i++) delete items[i]; }
};
int to_int(std::string s);
float to_float(std::string s);
 
extern DelApiItemF g_api_item_deleter;
 
template<class T>
void set_empty(GameApi::EveryApi &ev, T &t) { t.id=0; }
 
#define MACRO2(lab, funccall) \
  void set_empty(GameApi::EveryApi&ev,lab &l);
 
MACRO2(GameApi::BM,ev.bitmap_api.newbitmap(10,10,0x00000000))
#if (FEATURE_VOLUME==1)
MACRO2(GameApi::FD,ev.dist_api.fd_cube(0.0,0.0,0.0,0.0,0.0,0.0))
#endif
MACRO2(GameApi::BO,ev.bool_api.cube_bo(ev,0.0,0.0,0.0,0.0,0.0,0.0,1,1))
MACRO2(GameApi::BB,ev.bool_bitmap_api.bb_empty(10,10))
MACRO2(GameApi::FB,ev.float_bitmap_api.fb_empty(10,10))
MACRO2(GameApi::PT,ev.point_api.origo())
MACRO2(GameApi::V,ev.vector_api.null_vector())
MACRO2(GameApi::FO,ev.float_volume_api.distance())
MACRO2(GameApi::SFO,ev.sh_api.cube())
MACRO2(GameApi::O,ev.volume_api.o_cube(0.0,0.0,0.0,0.0,0.0,0.0))
MACRO2(GameApi::CBM,ev.cont_bitmap_api.cbm_empty(10.0,10.0))
MACRO2(GameApi::P,ev.polygon_api.p_empty())
MACRO2(GameApi::SH,ev.shader_api.colour_shader())
MACRO2(GameApi::CO,ev.color_api.u_color(0xffffffff))
MACRO2(GameApi::LI,ev.lines_api.from_polygon(ev.polygon_api.p_empty()))
MACRO2(GameApi::MN,ev.move_api.mn_empty())
MACRO2(GameApi::MT,ev.materials_api.m_def(ev))
MACRO2(GameApi::C,ev.curve_api.linear(std::vector<GameApi::PT>()))
MACRO2(GameApi::PD,ev.polygon_dist_api.empty(ev))
MACRO2(GameApi::WV,ev.waveform_api.wv_empty(1.0))
MACRO2(GameApi::ML,ev.polygon_api.render_vertex_array_ml2(ev,ev.polygon_api.p_empty()))
MACRO2(GameApi::CFB,ev.float_bitmap_api.X_bitmap(300.0,300.0))
MACRO2(GameApi::FI,ev.font_api.load_font("https://meshpage.org/assets/Chunkfive.otf",20,20))
MACRO2(GameApi::HML,ev.mainloop_api.html_url("https://meshpage.org/assets/empty_hml.mp"))
MACRO2(GameApi::PTS,ev.points_api.pt_array(ev,std::vector<GameApi::PT>{ev.point_api.point(0.0,0.0,0.0)}))
MACRO2(GameApi::IBM,ev.bitmap_api.convert_fb_to_ibm_bitmap(ev.float_bitmap_api.fb_empty(10,10),0.0,0.3))
MACRO2(GameApi::TF,ev.mainloop_api.gltf_loadKK2("https://meshpage.org/assets/test.glb"))
MACRO2(GameApi::OVX,ev.voxel_api.empty_ovx())
MACRO2(GameApi::FS,ev.float_scene_api.fs_sphere(0.0,0.0,0.0,300.0))
#undef MACRO2
 
std::string empty_param(std::string s);  
std::string unique_id_apiitem();
 
 
template<class T>
class TypeToString { public: static constexpr const char * str=""; };
 
#define MAC(a) \
  template<> class TypeToString<GameApi::a> { public: static constexpr const char * str=#a; };
 
  MAC(BS)
  MAC(US)
  MAC(CS)
  MAC(CSI)
  MAC(TT)
  MAC(PBO)
  MAC(SHP)
  MAC(SHI)
  MAC(AA)
  MAC(GC)
  MAC(GS)
  MAC(HML)
  MAC(UV)
  MAC(AV)
  MAC(H)
  MAC(FBU)
  MAC(FML)
  MAC(CG)
  MAC(INP)
  MAC(IBM)
  MAC(DS)
  MAC(SBM)
  MAC(PN)
  MAC(DC)
  MAC(CBB)
  MAC(CFB)
  MAC(SI)
  MAC(PLP)
  MAC(PLL)
  MAC(PLF)
  MAC(PR)
  MAC(CMD)
  MAC(FI)
  MAC(SD)
  MAC(GI)
  MAC(FF)
  MAC(IF)
  MAC(PF)
  MAC(SF)
  MAC(ARR)
  MAC(PAR)
  MAC(CPP)
  MAC(PTT)
  MAC(KF)
    MAC(BLK)
  MAC(RUN)
  MAC(EV)
  MAC(AC)
  MAC(MX)
  MAC(Pa)
  MAC(Va)
  MAC(AS)
  MAC(MC)
  MAC(MS)
  MAC(MT)
  MAC(SMT)
  MAC(TL)
  MAC(MN)
  MAC(CP)
  MAC(DR)
  MAC(OM)
  MAC(FO)
  MAC(WV)
  MAC(BM)
  MAC(BMA)
  MAC(VBM)
  MAC(BB)
  MAC(FB)
  MAC(CBM)
  MAC(SP)
  MAC(SA)
  MAC(PT)
  MAC(V)
  MAC(LN)
  MAC(RM)
  MAC(IS)
  MAC(O)
  MAC(P)
  MAC(OO)
  MAC(PP)
  MAC(PA)
  MAC(LA)
  MAC(TN)
  MAC(SH)
  MAC(C)
  MAC(CO)
  MAC(F)
  MAC(FA)
  MAC(Ft)
  MAC(VF)
  MAC(PPT)
  MAC(PSP)
  MAC(MA)
  MAC(S)
  MAC(Vb)
  MAC(T)
  MAC(E)
  MAC(L)
  MAC(LAY)
  MAC(MP)
  MAC(MV)
  MAC(LL)
  MAC(ME)
  MAC(ST)
  MAC(TY)
  MAC(PS)
  MAC(ID)
  MAC(Str)
  MAC(Fi)
  MAC(Op)
  MAC(D)
  MAC(Ht)
  MAC(BF)
  MAC(VA)
  MAC(VAA)
  MAC(VX)
  MAC(PL)
  MAC(PLA)
  MAC(TX)
  MAC(TXID)
  MAC(TXA)
  MAC(TR)
  MAC(VV)
  MAC(Q)
  MAC(DO)
  MAC(PC)
  MAC(SV)
  MAC(FOA)
  MAC(COV)
  MAC(LI)
  MAC(LLA)
  MAC(FD)
  MAC(VO)
  MAC(PTS)
  MAC(MSA)
  MAC(PTA)
  MAC(RD)
  MAC(FBO)
  MAC(SM)
  MAC(TRK)
  MAC(WAV)
  MAC(TBUF)
  MAC(SFO)
  MAC(W)
  MAC(WM)
  MAC(FtA)
  MAC(ML)
  MAC(GML)
  MAC(TF)
  MAC(SHC)
  MAC(EX)
  MAC(PH)
  MAC(TS)
  MAC(CT)
  MAC(CC)
  MAC(IM)
  MAC(FFi)
  MAC(VFi)
  MAC(MB)
  MAC(PKG)
  MAC(ATT)
  MAC(CX)
  MAC(OVX)
  MAC(TRA)
  MAC(TRB)
  MAC(TRR)
  MAC(FS)
#undef MAC
 
 
template<class T, class RT, class... P>
int funccall(std::stringstream &ss, GameApi::Env &ee, GameApi::EveryApi &ev, T (GameApi::EveryApi::*api),
         RT (T::*fptr)(P...), std::vector<std::string> s, GameApi::ExecuteEnv &e, const std::vector<std::string> &param_name, const std::string &return_type);
 
 
 
 
std::pair<std::string,std::string> CodeGen_1(GameApi::EveryApi &ev, std::vector<std::string> params, std::vector<std::string> param_names, std::vector<std::string> param_type, std::vector<std::string> param_exprs, std::string return_type, std::string api_name, std::string func_name, int j);
 
struct ApiSplit
{
  std::string def;
  std::string author;
  std::string license;
};
 
ApiSplit split_api_default(std::string def);
 
 
template<std::size_t ...>
struct add_all : std::integral_constant< std::size_t,0 > { };
 
template<std::size_t X, std::size_t ... Xs>
struct add_all<X,Xs...> : std::integral_constant< std::size_t, X+add_all<Xs...>::value> { };
 
 
inline bool print_if_false(const bool assertion, std::string msg) {
    if(!assertion) {
        // endl to flush
        std::cout << msg << std::endl;
    }
    return assertion;
}
 
template<class T, class RT, class... P>
class ApiItem : public GameApiItem
{
public:
  ApiItem(T (GameApi::EveryApi::*api), RT (T::*fptr)(P...),
      std::string name, 
      std::vector<std::string> param_name,
      std::vector<std::string> param_type,
      std::vector<std::string> param_default,
      std::string ret_type, std::string api_name, std::string func_name,
      std::string symbols, std::string comment) 
    : api(api), fptr(fptr), name(name), param_name(param_name),
      param_type(param_type), param_default(param_default), 
      return_type(ret_type), api_name(api_name), func_name(func_name), symbols(symbols), comment(comment) { }
  int Count() const { return 1; }
  std::string Name(int i) const { return name; }
  int ParamCount(int i) const {
    assert(print_if_false(sizeof...(P) == param_name.size(),"ERROR: param_name array size problems: " + api_name + "::" + name));
    assert(print_if_false(sizeof...(P) == param_type.size(),"ERROR: param_type array size problems: " + api_name + "::" + name));
    assert(print_if_false(sizeof...(P) == param_default.size(),"ERROR: param_default array size problems: " + name));
    return param_name.size(); }
  std::string ParamName(int i, int p) const { return param_name[p]; }
  std::string ParamType(int i, int p) const { return param_type[p]; }
  std::string ParamDefault(int i, int p) const { return split_api_default(param_default[p]).def; }
  std::string DefaultAuthor(int i, int p) const { return split_api_default(param_default[p]).author; }
  std::string DefaultLicense(int i, int p) const { return split_api_default(param_default[p]).license; }
  std::string ReturnType(int i) const { return return_type; }
  std::string ApiName(int i) const { return api_name; }
  std::string FuncName(int i) const { return func_name; }
  std::string Symbols() const { return symbols; }
  std::string Comment() const { return comment; }
 
#if USE_CHAISCRIPT
  static RT chai_cb(GameApiItem *item, GameApi::EveryApi *ev, T (GameApi::EveryApi::*api), P... p) {
    ApiItem<T,RT,P...> *ptr = (ApiItem<T,RT,P...>*)item;
    T *ptr2 = &(ev->*api);
    RT val = (ptr2->*(ptr->fptr))(p...);
    return val;
  }
  void RegisterToChai(GameApi::EveryApi *ev, chaiscript::ChaiScript *chai)
  {
    std::function<RT (P... p)> f = [ev,this](P...p) -> RT { return chai_cb(this, ev, this->api, p...); };
    chai->add(chaiscript::fun(f), func_name.c_str());
  }
#endif
  
  int Execute(std::stringstream &ss, GameApi::Env &ee, GameApi::EveryApi &ev, std::vector<std::string> params, GameApi::ExecuteEnv &e, int j)
  {
    int s = params.size();
    for(int i=0;i<s;i++) if (params[i]=="") params[i]="?";
 
    //std::cout << "PARAMS_SIZE:" << params.size() << "==" << param_name.size() << std::endl;
    if (params.size()!=param_name.size()) {
    if (ApiName(0)=="mainloop_api" && FuncName(0)=="array_ml") {
      params.insert(params.begin(),"ev");
    } else {
      std::cout << "Error: param vectors different size: " << ApiName(0) << "::" << FuncName(0) << std::endl;
    }
    }
    int ret = funccall(ss,ee, ev, api, fptr, params, e, param_name, return_type);
    int ret_count = ret_type_count(return_type);
    if (ret_count>1 && j!=-1)
      { // multiple return values
    GameApi::ARR arr; 
    arr.id = ret;
    ArrayType *t = find_array(ee, arr);
    ret = t->vec[j];
      }
    return ret;
  }
  
 
  std::pair<std::string,std::string> CodeGen(GameApi::EveryApi &ev, std::vector<std::string> params, std::vector<std::string> param_names, std::vector<std::string> param_exprs, int j)
  {
    std::pair<std::string,std::string> p = CodeGen_1(ev,params, param_names, param_type, param_exprs,return_type,api_name,func_name,j);
    return p;
  }
private:
  T GameApi::EveryApi::*api;
  RT (T::*fptr)(P...);
  std::string name;
  std::vector<std::string> param_name;
  std::vector<std::string> param_type;
  std::vector<std::string> param_default;
  std::string return_type;
  std::string api_name;
  std::string func_name;
  std::string symbols;
  std::string comment;
};
 
 
 
 
 
template<class T>
class FromStreamClass
{
public:
  T from_stream(std::stringstream &ss, GameApi::EveryApi &ev)
  {
    //std::cout << "Type using default: " << typeid(T).name() << std::endl;
    bool neg = false;
    std::string s;
    ss >> s;
 
    if (s.size()>0 && s[0]=='-')
      {
    neg = true;
    s = s.substr(1);
      }
    
  T t;
  std::stringstream is(s);
  is >> t;
  if (neg) t = -t;
 
  //std::cout << "Default: " << t << std::endl;
  return t;
  }
};
 
std::string FloatExprEval(std::string s);
int find_float_ch(std::string s, char ch);
 
 
float to_float(std::string s);
 
 
 
#define MACRO(lab) \
template<>         \
class FromStreamClass<lab> \
{ \
public:\
  lab from_stream(std::stringstream &ss, GameApi::EveryApi &ev)\
  {\
  lab bm;\
  std::string s;\
  ss >> s;\
  if (s=="@") {\
        set_empty(ev,bm);\
    std::cout << "Warning: Empty slot in left side of node detected! " << TypeToString<lab>::str << std::endl; \
      return bm;\
  }\
  bm.id = to_int(s);\
  return bm;\
  }\
};
MACRO(GameApi::CS)
MACRO(GameApi::CSI)
MACRO(GameApi::GML)
MACRO(GameApi::BM)
MACRO(GameApi::FtA)
MACRO(GameApi::FD)
MACRO(GameApi::BO)
MACRO(GameApi::BB)
MACRO(GameApi::FB)
MACRO(GameApi::PT)
MACRO(GameApi::V)
MACRO(GameApi::FO)
MACRO(GameApi::SFO)
MACRO(GameApi::O)
MACRO(GameApi::COV)
MACRO(GameApi::CBM)
MACRO(GameApi::P)
MACRO(GameApi::SH)
MACRO(GameApi::CO)
MACRO(GameApi::Ft)
MACRO(GameApi::VA)
MACRO(GameApi::VX)
MACRO(GameApi::PL)
MACRO(GameApi::TX)
MACRO(GameApi::TXID)
MACRO(GameApi::TXA)
MACRO(GameApi::LI)
MACRO(GameApi::LLA)
MACRO(GameApi::PTS)
MACRO(GameApi::FBO)
MACRO(GameApi::W)
MACRO(GameApi::ML)
MACRO(GameApi::PTA)
MACRO(GameApi::MN)
MACRO(GameApi::VO)
MACRO(GameApi::IM)
MACRO(GameApi::TL)
MACRO(GameApi::T)
MACRO(GameApi::MT)
MACRO(GameApi::C)
MACRO(GameApi::MS)
MACRO(GameApi::MC)
MACRO(GameApi::SA)
MACRO(GameApi::PD)
MACRO(GameApi::WV)
MACRO(GameApi::CC)
MACRO(GameApi::BLK)
MACRO(GameApi::RUN)
MACRO(GameApi::PTT)
MACRO(GameApi::KF)
MACRO(GameApi::CPP)
MACRO(GameApi::IF)
MACRO(GameApi::SF)
MACRO(GameApi::SD)
MACRO(GameApi::FI)
MACRO(GameApi::GI)
MACRO(GameApi::ARR)
MACRO(GameApi::CMD)
MACRO(GameApi::PA)
MACRO(GameApi::PLF)
MACRO(GameApi::PLL)
MACRO(GameApi::PLP)
MACRO(GameApi::CBB)
MACRO(GameApi::CFB)
MACRO(GameApi::PH)
MACRO(GameApi::DC)
MACRO(GameApi::PN)
MACRO(GameApi::PF)
MACRO(GameApi::FF)
MACRO(GameApi::S)
MACRO(GameApi::SBM)
MACRO(GameApi::IBM)
MACRO(GameApi::INP)
MACRO(GameApi::MA)
MACRO(GameApi::CG)
MACRO(GameApi::FML)
MACRO(GameApi::FBU)
MACRO(GameApi::AV)
MACRO(GameApi::UV)
MACRO(GameApi::FFi)
MACRO(GameApi::VFi)
MACRO(GameApi::FA)
MACRO(GameApi::PKG)
MACRO(GameApi::GS)
MACRO(GameApi::TF)
MACRO(GameApi::HML)
MACRO(GameApi::PBO)
MACRO(GameApi::SHP)
MACRO(GameApi::SHI)
MACRO(GameApi::SHC)
MACRO(GameApi::SMT)
MACRO(GameApi::TT)
MACRO(GameApi::BS)
MACRO(GameApi::OVX)
MACRO(GameApi::TRA)
MACRO(GameApi::TRB)
MACRO(GameApi::TRR)
MACRO(GameApi::PV)
MACRO(GameApi::FS)
#undef MACRO
 
 
template<>
class FromStreamClass<float>
{
public:
  float from_stream(std::stringstream &ss, GameApi::EveryApi &ev)
  {
    //std::cout << "Type using default: " << typeid(T).name() << std::endl;
 
    std::string s;
    ss >> s;
    bool neg = false;
    if (s.size()>0 && s[0]=='-')
      {
    neg = true;
    s = s.substr(1);
      }
    s=FloatExprEval(s);
 
  float t;
  //std::stringstream is(s);
  t = to_float(s);
  if (neg) t = -t;
 
  //std::cout << "Default: " << t << std::endl;
  return t;
  }
};
 
 
template<>
class FromStreamClass<std::string>
{
public:
  std::string from_stream(std::stringstream &ss, GameApi::EveryApi &ev)
  {
    std::string s;
    ss >> s;
    if (s.size()>0 && s[0]=='"' && s[s.size()-1]=='"')
      {
    s=s.substr(1,s.size()-2);
      }
    if (s=="?") s="";
    return s;
  }
};
template<>
class FromStreamClass<GameApi::EveryApi &>
{
public:
  GameApi::EveryApi &from_stream(std::stringstream &ss, GameApi::EveryApi &ev)
  {
    std::string s;
    ss >> s;
    return ev;
  }
};
 
template<>
class FromStreamClass<bool>
{
public:
  bool from_stream(std::stringstream &ss, GameApi::EveryApi &ev)
  {
    std::string s;
    ss >> s;
  if (s=="false") return false;
  if (s=="true") return true;
  if (s=="1") return true;
  return false;
  }
};
 
 
 
template<>
class FromStreamClass<unsigned int>
{
public:
  unsigned int from_stream(std::stringstream &ss, GameApi::EveryApi &ev)
  {
  unsigned int bm;
  //char c;
  //is >> c;
  //is >> c;
  //std::stringstream is(s);
  ss >> std::hex >> bm >> std::dec;
  return bm;
  }
};
 
template<>
class FromStreamClass<std::vector<std::string>>
{
public:
  std::vector<std::string> from_stream(std::stringstream &sk, GameApi::EveryApi &ev)
  {
    std::string s;
    sk >> s;
    std::vector<std::string> vec;
    if (s.size()<2)
      {
    std::cout << "from_stream length problem" << std::endl;
    return vec;
      }
    char c = s[0];
    if (c!='[') { std::cout << "from_stream parse error on std::vector" << std::endl; return vec; }
 
    FromStreamClass<std::string> cls;
    int ss = s.size();
    std::string next;
    int prev = 1;
    for(int i=1;i<ss;i++)
      {
    if (s[i]==',' || s[i]==']')
      {
        std::string substr = s.substr(prev, i-prev);
        std::stringstream sk1(substr);
        //std::cout << "SUBSTR:" << substr << std::endl;
        std::string t = cls.from_stream(sk1, ev);
        //std::cout << "RESULT:" << t << std::endl;
        vec.push_back(t);
        prev=i+1;
        if (s[i]==']') { break; }
      }
      }
    return vec;
  } 
};
 
template<class T>
class FromStreamClass<std::vector<T>>
{
public:
  std::vector<T> from_stream(std::stringstream &sk, GameApi::EveryApi &ev)
  {
    std::string s;
    sk >> s;
 
    if (s=="@") return std::vector<T>();
    //std::cout << "Vector:" << s << std::endl;
    std::vector<T> vec;
    if (s.size()>0 && s[0]!='[')
      { // ARR version
    //std::cout << "Arr version" << s << std::endl;
    GameApi::ARR arr;
    std::stringstream ss(s);
    ss >> arr.id;
    ArrayType *t = find_array(ev.get_env(), arr);
    int s = t->vec.size();
    for(int i=0;i<s;i++)
      {
        T tt;
        tt.id = t->vec[i];
        vec.push_back(tt);
      }
    return vec;
      }
    if (s.size()<2)
      {
    std::cout << "from_stream length problem" << std::endl;
    return vec;
      }
    char c = s[0];
    if (c!='[') { std::cout << "from_stream parse error on std::vector" << std::endl; return vec; }
 
    FromStreamClass<T> cls;
    int ss = s.size();
    std::string next;
    int prev = 1;
    for(int i=1;i<ss;i++)
      {
    if (s[i]==',' || s[i]==']')
      {
        std::string substr = s.substr(prev, i-prev);
        std::stringstream sk1(substr);
        // std::cout << "SUBSTR:" << substr << ":" << std::endl;
        T t = cls.from_stream(sk1, ev);
        //std::cout << "RESULT:" << t.id << std::endl;
        vec.push_back(t);
        prev=i+1;
        if (s[i]==']') { break; }
      }
      }
    return vec;
  } 
};
 
 
 
 
void funccall_1(std::vector<std::string> &s, GameApi::ExecuteEnv &e, std::vector<std::string> param_name);
 
template<typename T> T from_stream2(std::stringstream &is, GameApi::EveryApi &ev)
{
  FromStreamClass<T> cls;
  //std::string s;
  //is >> s;
  //std::cout << "FromStreamClass: " << s << " " << typeid(T).name() << std::endl;
  return cls.from_stream(is,ev);
}
 
#if 0
 
template<class...T,std::size_t... Is>
void read_tuple(std::istream &is, std::tuple<T...>&t, std::index_sequence<Is...>)
{
  ( (is >> std::get<Is>(t)), ... );
}
 
template<class RT,class...P>
RT call_working(std::istream &params, std::function<RT(P...)> fptr ) {
  std::tuple<P...> args;
  read_tuple(params, args, std::make_index_sequence<sizeof...(P)>{});
  RT t = std::apply(fptr,args);
  return t;
}
 
#endif
 
 
template<class T, class RT, class... P>
int funccall(std::stringstream &ss, GameApi::Env &ee, GameApi::EveryApi &ev, T (GameApi::EveryApi::*api),
         RT (T::*fptr)(P...), std::vector<std::string> s, GameApi::ExecuteEnv &e, const std::vector<std::string> &param_name, const std::string &return_type)
{
  funccall_1(s,e,param_name);
 
#ifdef EMSCRIPTEN
#define ORDER 1
#endif
#ifdef ANDROID
#define ORDER 1
#endif
#ifdef RASPI
#define ORDER 1
#endif
#ifdef ARM2
#define ORDER 1
#endif
 
#if 0
  
  //std::stringstream ss;
  int s2 = s.size();
#ifndef ORDER
  for(int i=s2-1;i>=0;i--)
    {
      ss << s[i] << " ";
    }
  //std::cout << "NO ORDER!" << std::endl;
#else
  for(int i=0;i<s2;i++)
    {
      ss << s[i] << " ";
    }
  // std::cout << "YES ORDER!" << std::endl;
#endif
  // std::cout << "FuncCall: " << ss.str() << std::endl;
 
  //std::stringstream ss2(ss.str());
  T *ptr = &(ev.*api);
  RT val = (ptr->*fptr)(from_stream2<P>(ss,ev)...);
 
#endif
 
  int s2 = s.size();
  for(int i=0;i<s2;i++)
    {
      ss << s[i] << " ";
    }
 
  std::tuple<P...> args = {from_stream2<P>(ss,ev)...};
  
  T *ptr = &(ev.*api);
 
  RT val = std::apply([&](auto&&... unpacked) {
    return (ptr->*fptr)(unpacked...);
  }, args);
  
  //RT val = call_working<RT,P...>(ss,std::function<RT(P...)>([ptr,fptr](P... p) -> RT { return (ptr->*fptr)(p...);}));
  
  //std::cout << "RETURN:" << val.id << std::endl;
  //std::cout << "RETURN TYPE:" << return_type << std::endl;
   
  //std::cout << "FuncCall returning: " << val.id << std::endl;
  return val.id; //template_get_id(val);
}
 
 
 
 
 
template<class T, class RT, class... P>
GameApiItem* ApiItemF(T (GameApi::EveryApi::*api), RT (T::*fptr)(P...),
              std::string name,
              std::vector<std::string> param_name,
              std::vector<std::string> param_type,
              std::vector<std::string> param_default,
              std::string return_type, std::string api_name, std::string func_name, std::string symbols="", std::string comment="")
{
  GameApiItem *item = new ApiItem<T,RT,P...>(api, fptr, name, param_name, param_type, param_default, return_type, api_name, func_name, symbols,comment);
  g_api_item_deleter.items.push_back(item);
  return item;
}
 
 
class EnvGameApiItem_int : public GameApiItem
{
public:
  EnvGameApiItem_int() { }
  virtual int Count() const { return 1; }
  virtual std::string Name(int i) const { return "env_params_int"; }
  virtual int ParamCount(int i) const { return 1+5; }
  virtual std::string ParamName(int i, int p) const {
    switch(p) {
    case 0: return "ml";
    case 1: return "&1";
    case 2: return "&2";
    case 3: return "&3";
    case 4: return "&4";
    case 5: return "&5";
    default: return "";
    };
  }
  virtual std::string ParamType(int i, int p) const {
    switch(p) {
    case 0: return "ML";
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return "std::string";
    default:
      return "";
    };
  }
  virtual std::string ParamDefault(int i, int p) const {
    switch(p) {
    case 0: return "";
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return "@";
    default:
      return "";
    };
  }
  virtual std::string DefaultAuthor(int i, int p) const { return ""; }
  virtual std::string DefaultLicense(int i, int p) const { return ""; }
  virtual std::string ReturnType(int i) const { return "ML"; }
  virtual std::string ApiName(int i) const { return "mainloop_api"; }
  virtual std::string FuncName(int i) const { return "identity_int"; }
  virtual std::string Symbols() const { return ""; }
  virtual std::string Comment() const { return "env setup"; }
  virtual int Execute(std::stringstream &ss, GameApi::Env &ee, GameApi::EveryApi &ev, std::vector<std::string> params, GameApi::ExecuteEnv &e, int j)
  {
    std::stringstream ss2(params[0]);
    int val = 0;
    ss2 >> val;
    return val;
  }
  virtual std::pair<std::string,std::string> CodeGen(GameApi::EveryApi &ev, std::vector<std::string> params, std::vector<std::string> param_names, std::vector<std::string> param_exprs, int j)
  {
    std::pair<std::string,std::string> p = CodeGen_1(ev,params, param_names, { "ml","&1","&2","&3","&4","&5" }, param_exprs, "ML","mainloop_api","identity_int",j);
    return p;
  }
  virtual void BeginEnv(GameApi::ExecuteEnv &e, std::vector<GameApiParam> params) {
    if (params[1].expr != "@")
      {
    e.names.push_back("&1");
    e.values.push_back(params[1].expr);
      }
    if (params[2].expr != "@")
      {
    e.names.push_back("&2");
    e.values.push_back(params[2].expr);
      }
    if (params[3].expr != "@")
      {
    e.names.push_back("&3");
    e.values.push_back(params[3].expr);
      }
 
    if (params[4].expr != "@")
      {
    e.names.push_back("&4");
    e.values.push_back(params[4].expr);
      }
    if (params[5].expr != "@")
      {
    e.names.push_back("&5");
    e.values.push_back(params[5].expr);
      }
    env_params = params;
  }
  virtual void EndEnv(GameApi::ExecuteEnv &e) {
    int s = e.names.size();
    for(int i=0;i<s;i++)
      {
    if ((e.names[i]=="&1" && env_params[1].expr!="@" )||
        (e.names[i]=="&2"  && env_params[2].expr!="@")||
        (e.names[i]=="&3"  && env_params[3].expr!="@")||
        (e.names[i]=="&4"  && env_params[4].expr!="@")||
        (e.names[i]=="&5"  && env_params[5].expr!="@"))
      {
        e.names.erase(e.names.begin() + i);
        e.values.erase(e.values.begin() + i);
        i--;
        s--;
      }
      }
 
  }
private:
  std::vector<GameApiParam> env_params;  
};
 
class EnvGameApiItem_string : public GameApiItem
{
public:
  EnvGameApiItem_string() { }
  virtual int Count() const { return 1; }
  virtual std::string Name(int i) const { return "env_params_string"; }
  virtual int ParamCount(int i) const { return 1+5; }
  virtual std::string ParamName(int i, int p) const {
    switch(p) {
    case 0: return "ml";
    case 1: return "$1";
    case 2: return "$2";
    case 3: return "$3";
    case 4: return "$4";
    case 5: return "$5";
    default: return "";
    };
  }
  virtual std::string ParamType(int i, int p) const {
    switch(p) {
    case 0: return "ML";
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return "std::string";
    default:
      return "";
    };
  }
  virtual std::string ParamDefault(int i, int p) const {
    switch(p) {
    case 0: return "";
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return "@";
    default:
      return "";
    };
  }
  virtual std::string DefaultAuthor(int i, int p) const { return ""; }
  virtual std::string DefaultLicense(int i, int p) const { return ""; }
  virtual std::string ReturnType(int i) const { return "ML"; }
  virtual std::string ApiName(int i) const { return "mainloop_api"; }
  virtual std::string FuncName(int i) const { return "identity_string"; }
  virtual std::string Symbols() const { return ""; }
  virtual std::string Comment() const { return "env setup"; }
  virtual int Execute(std::stringstream &ss, GameApi::Env &ee, GameApi::EveryApi &ev, std::vector<std::string> params, GameApi::ExecuteEnv &e, int j)
  {
    std::stringstream ss2(params[0]);
    int val = 0;
    ss2 >> val;
    return val;
  }
  virtual std::pair<std::string,std::string> CodeGen(GameApi::EveryApi &ev, std::vector<std::string> params, std::vector<std::string> param_names, std::vector<std::string> param_exprs, int j)
  {
    std::pair<std::string,std::string> p = CodeGen_1(ev,params, param_names, { "ml","$1","$2","$3","$4","$5" }, param_exprs, "ML","mainloop_api","identity_string",j);
    return p;
  }
  virtual void BeginEnv(GameApi::ExecuteEnv &e, std::vector<GameApiParam> params) {
    if (params[1].expr != "@")
      {
    std::cout << "BeginEnv::Choose 1: " << params[1].expr << std::endl;
    e.names.push_back("$1");
    e.values.push_back(params[1].expr);
      }
    if (params[2].expr != "@")
      {
    std::cout << "BeginEnv::Choose 2: " << params[2].expr << std::endl;
    e.names.push_back("$2");
    e.values.push_back(params[2].expr);
      }
    if (params[3].expr != "@")
      {
    std::cout << "BeginEnv::Choose 3: " << params[3].expr << std::endl;
    e.names.push_back("$3");
    e.values.push_back(params[3].expr);
      }
 
    if (params[4].expr != "@")
      {
    std::cout << "BeginEnv::Choose 4: " << params[4].expr << std::endl;
    e.names.push_back("$4");
    e.values.push_back(params[4].expr);
      }
    if (params[5].expr != "@")
      {
    std::cout << "BeginEnv::Choose 5: " << params[5].expr << std::endl;
    e.names.push_back("$5");
    e.values.push_back(params[5].expr);
      }
    env_params = params;
  }
  virtual void EndEnv(GameApi::ExecuteEnv &e) {
    int s = e.names.size();
    for(int i=0;i<s;i++)
      {
    if ((e.names[i]=="$1" && env_params[1].expr!="@" )||
        (e.names[i]=="$2"  && env_params[2].expr!="@")||
        (e.names[i]=="$3"  && env_params[3].expr!="@")||
        (e.names[i]=="$4"  && env_params[4].expr!="@")||
        (e.names[i]=="$5"  && env_params[5].expr!="@"))
      {
        e.names.erase(e.names.begin() + i);
        e.values.erase(e.values.begin() + i);
        i--;
        s--;
      }
      }
 
  }
private:
  std::vector<GameApiParam> env_params;  
};
 
class EnvGameApiItem_float : public GameApiItem
{
public:
  EnvGameApiItem_float() { }
  virtual int Count() const { return 1; }
  virtual std::string Name(int i) const { return "env_params_float"; }
  virtual int ParamCount(int i) const { return 1+5; }
  virtual std::string ParamName(int i, int p) const {
    switch(p) {
    case 0: return "ml";
    case 1: return "%1";
    case 2: return "%2";
    case 3: return "%3";
    case 4: return "%4";
    case 5: return "%5";
    default: return "";
    };
  }
  virtual std::string ParamType(int i, int p) const {
    switch(p) {
    case 0: return "ML";
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return "std::string";
    default:
      return "";
    };
  }
  virtual std::string ParamDefault(int i, int p) const {
    switch(p) {
    case 0: return "";
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return "@";
    default:
      return "";
    };
  }
  virtual std::string DefaultAuthor(int i, int p) const { return ""; }
  virtual std::string DefaultLicense(int i, int p) const { return ""; }
  virtual std::string ReturnType(int i) const { return "ML"; }
  virtual std::string ApiName(int i) const { return "mainloop_api"; }
  virtual std::string FuncName(int i) const { return "identity_float"; }
  virtual std::string Symbols() const { return ""; }
  virtual std::string Comment() const { return "env setup"; }
  virtual int Execute(std::stringstream &ss, GameApi::Env &ee, GameApi::EveryApi &ev, std::vector<std::string> params, GameApi::ExecuteEnv &e, int j)
  {
    std::stringstream ss2(params[0]);
    int val = 0;
    ss2 >> val;
    return val;
  }
  virtual std::pair<std::string,std::string> CodeGen(GameApi::EveryApi &ev, std::vector<std::string> params, std::vector<std::string> param_names, std::vector<std::string> param_exprs, int j)
  {
    std::pair<std::string,std::string> p = CodeGen_1(ev,params, param_names, { "ml","%1","%2","%3","%4","%5" }, param_exprs, "ML","mainloop_api","identity_float",j);
    return p;
  }
  virtual void BeginEnv(GameApi::ExecuteEnv &e, std::vector<GameApiParam> params) {
    if (params[1].expr != "@")
      {
    e.names.push_back("%1");
    e.values.push_back(params[1].expr);
      }
    if (params[2].expr != "@")
      {
    e.names.push_back("%2");
    e.values.push_back(params[2].expr);
      }
    if (params[3].expr != "@")
      {
    e.names.push_back("%3");
    e.values.push_back(params[3].expr);
      }
 
    if (params[4].expr != "@")
      {
    e.names.push_back("%4");
    e.values.push_back(params[4].expr);
      }
    if (params[5].expr != "@")
      {
    e.names.push_back("%5");
    e.values.push_back(params[5].expr);
      }
    env_params = params;
  }
  virtual void EndEnv(GameApi::ExecuteEnv &e) {
    int s = e.names.size();
    for(int i=0;i<s;i++)
      {
    if ((e.names[i]=="%1" && env_params[1].expr!="@" )||
        (e.names[i]=="%2"  && env_params[2].expr!="@")||
        (e.names[i]=="%3"  && env_params[3].expr!="@")||
        (e.names[i]=="%4"  && env_params[4].expr!="@")||
        (e.names[i]=="%5"  && env_params[5].expr!="@"))
      {
        e.names.erase(e.names.begin() + i);
        e.values.erase(e.values.begin() + i);
        i--;
        s--;
      }
      }
 
  }
private:
  std::vector<GameApiParam> env_params;  
};
std::vector<std::string> parse_sep(std::string s, char sep);
 
inline std::vector<std::string> choose_param3(std::vector<std::string> vec, int ii)
{
  std::vector<std::string> res;
  int s = vec.size();
  for(int i=0;i<s;i++)
    {
      std::string s2 = vec[i];
      std::vector<std::string> v = parse_sep(s2,'&');
      if (ii<v.size())
    {
      res.push_back(v[ii]);
    }
      else
    {
      res.push_back(s2);
    }
    }
  return res;
}
 
inline std::string generate_seq(int n, int count)
{
  std::stringstream ss;
  int s = count;
  for(int i=0;i<s;i++) {
    ss << "%" << n;
    if (i!=s-1) ss << "&";
  }
  return ss.str();
}
 
std::string replace_str(std::string code, std::string repl, std::string subst);
class EnvGameApiItem_arr : public GameApiItem
{
public:
  EnvGameApiItem_arr() {
  }
  virtual int Count() const { return 1; }
  virtual std::string Name(int i) const { return "env_params_arr"; }
  virtual int ParamCount(int i) const { return 1+5; }
  virtual std::string ParamName(int i, int p) const {
    switch(p) {
    case 0: return "ml";
    case 1: return "%1";
    case 2: return "%2";
    case 3: return "%3";
    case 4: return "%4";
    case 5: return "%5";
 
      //case 6: return "e1";
      //case 7: return "e2";
      //case 8: return "e3";
      //case 9: return "e4";
      //case 10: return "e5";
    default: return "";
    };
  }
  virtual std::string ParamType(int i, int p) const {
    switch(p) {
    case 0: return "ML";
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
       return "std::string";
       //case 6:
       //case 7:
       //case 8:
       //case 9:
       //case 10:
       //return "std::string";
    default:
      return "";
    };
  }
  virtual std::string ParamDefault(int i, int p) const {
    switch(p) {
    case 0: return "";
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return "@";
      //case 6:
      //case 7:
      //case 8:
      //case 9:
      //case 10:
      //return "@";
    default:
      return "";
    };
  }
  virtual std::string DefaultAuthor(int i, int p) const { return ""; }
  virtual std::string DefaultLicense(int i, int p) const { return ""; }
  virtual std::string ReturnType(int i) const { return "[ML]"; }
  virtual std::string ApiName(int i) const { return "mainloop_api"; }
  virtual std::string FuncName(int i) const { return "identity_arr"; }
  virtual std::string Symbols() const { return ""; }
  virtual std::string Comment() const { return "env setup arr"; }
  virtual int Execute(std::stringstream &ss, GameApi::Env &ee, GameApi::EveryApi &ev, std::vector<std::string> params, GameApi::ExecuteEnv &e, int j)
  {
    static int count=0;
    if (count==0) {
      count=1;
      std::cout << "Warning: env_params_arr cannot be deployed, and you must move to script_ML_array before deploy." << std::endl;
    }
    
    std::vector<std::string> arr1 = parse_sep(params[1],'&');
    std::vector<std::string> arr2 = parse_sep(params[2],'&');
    std::vector<std::string> arr3 = parse_sep(params[3],'&');
    std::vector<std::string> arr4 = parse_sep(params[4],'&');
    std::vector<std::string> arr5 = parse_sep(params[5],'&');
 
    //std::vector<std::string> e1 = parse_sep(params[6],'&');
    //std::vector<std::string> e2 = parse_sep(params[7],'&');
    //std::vector<std::string> e3 = parse_sep(params[8],'&');
    //std::vector<std::string> e4 = parse_sep(params[9],'&');
    //std::vector<std::string> e5 = parse_sep(params[10],'&');
 
 
 
    
    int N = std::max(std::max(std::max(std::max(arr1.size(),arr2.size()),
                       arr3.size()),
                  arr4.size()),
             arr5.size());
    //int N2 = std::max(std::max(std::max(std::max(e1.size(),e2.size()),
    //                     e3.size()),
    //                e4.size()),
    //           e5.size());
    int NN = N; //std::max(N,N2);
    arr1.resize(NN);
    arr2.resize(NN);
    arr3.resize(NN);
    arr4.resize(NN);
    arr5.resize(NN);
 
    //e1.resize(NN);
    //e2.resize(NN);
    //e3.resize(NN);
    //e4.resize(NN);
    //e5.resize(NN);
 
    
    
    std::stringstream ss2(params[0]);
    int val = 0;
    ss2 >> val;
    GameApi::ML ml;
    ml.id = val;
    std::string line;
    std::string prev_line;
    std::string prev_line2;
    std::vector<std::string> vec;
    std::string res;
    //while(std::getline(ss3,line)) {
    //  prev_line2 = prev_line;
    //  prev_line = line;
    //  res+=prev_line2;
    //  res+="\n";
    //}
    std::vector<GameApi::ML> res_vec;
    for(int i=0;i<NN;i++)
      {
 
    m_ii = i;
    GameApi::RUN r = ev.blocker_api.game_window2(ev,ml,false,false,0.0,100000.0);
    GameApi::HML hml = ev.mainloop_api.emscripten_frame2(ev,r,"https://meshpage.org/assets",true);
    Html *hml2 = find_html(ev.get_env(),hml);
    hml2->Prepare();
    std::string script = hml2->script_file();
    //std::stringstream ss3(script);
    res=script;
 
 
    GameApi::ExecuteEnv &ee2 = e;
    std::vector<GameApiParam> paramvec;
    std::stringstream ss2; ss2 << ml.id;
 
    paramvec.push_back({"ml", ss2.str(),"ML",false,0,0,""});
    paramvec.push_back({"%1", arr1[i],"float",false,0,0,generate_seq(1,arr1.size()) /*e1[i]*/ });
    paramvec.push_back({"%2", arr2[i],"float",false,0,0,generate_seq(2,arr2.size()) /*e2[i]*/});
    paramvec.push_back({"%3", arr3[i],"float",false,0,0,generate_seq(3,arr3.size()) /*e3[i]*/});
    paramvec.push_back({"%4", arr4[i], "float",false,0,0,generate_seq(4,arr4.size()) /*e4[i]*/});
    paramvec.push_back({"%5", arr5[i], "float",false,0,0,generate_seq(5,arr5.size()) /*e5[i]*/});
    BeginEnv2(e, paramvec);
 
 
    
    res = replace_str(res, "@", "\n");
 
    // these break the feature that envparams_float_array can be used nested multiple times in the hierarchy
    res = replace_str(res, "%1", arr1[i]);
    res = replace_str(res, "%2", arr2[i]);
    res = replace_str(res, "%3", arr3[i]);
    res = replace_str(res, "%4", arr4[i]);
    res = replace_str(res, "%5", arr5[i]);
    
    std::pair<int,std::string> p = GameApi::execute_codegen(ee,ev,res,ee2);
    if (p.first==-1) { continue; }
    assert(p.second=="ML");
    int id = p.first;
    GameApi::ML res_ml;
    res_ml.id = id;
    res_vec.push_back(res_ml);
    EndEnv2(e);
      }
    std::vector<int> res_vec2;
    int s = res_vec.size();
    for(int i=0;i<s;i++) res_vec2.push_back(res_vec[i].id);
 
 
    ArrayType *array = new ArrayType;
    array->type=2;
    array->vec = res_vec2;
    GameApi::ARR a = add_array(ee,array);
    return a.id;
  }
  virtual std::pair<std::string,std::string> CodeGen(GameApi::EveryApi &ev, std::vector<std::string> params, std::vector<std::string> param_names, std::vector<std::string> param_exprs, int j)
  {
    if (!recursion_stopper) {
      recursion_stopper=true;
    //std::cout << "OUR CODEGEN..." << std::endl;
    std::pair<std::string,std::string> p = CodeGen_1(ev,choose_param3(params,m_ii), { "ml", "%1", "%2", "%3", "%4", "%5" }, { "ml","%1","%2","%3","%4","%5" }, choose_param3(param_exprs,m_ii), "ML","mainloop_api","identity_arr",j);
    //std::cout << "END_OF_OUR_CODEGEN" << std::endl;
    recursion_stopper=false;
    return p;
    } else {
      return std::make_pair("",""); 
    }
  }
  virtual void BeginEnv(GameApi::ExecuteEnv &e, std::vector<GameApiParam> param) { }
  virtual void EndEnv(GameApi::ExecuteEnv &e) { }
  
  virtual void BeginEnv2(GameApi::ExecuteEnv &e, std::vector<GameApiParam> params) {
    if (params[1].expr != "@")
      {
    e.names.push_back("%1");
    e.values.push_back(params[1].expr);
      }
    if (params[2].expr != "@")
      {
    e.names.push_back("%2");
    e.values.push_back(params[2].expr);
      }
    if (params[3].expr != "@")
      {
    e.names.push_back("%3");
    e.values.push_back(params[3].expr);
      }
 
    if (params[4].expr != "@")
      {
    e.names.push_back("%4");
    e.values.push_back(params[4].expr);
      }
    if (params[5].expr != "@")
      {
    e.names.push_back("%5");
    e.values.push_back(params[5].expr);
      }
    env_params = params;
  }
  virtual void EndEnv2(GameApi::ExecuteEnv &e) {
    int s = e.names.size();
    for(int i=0;i<s;i++)
      {
    if ((e.names[i]=="%1" && env_params[1].expr!="@" )||
        (e.names[i]=="%2"  && env_params[2].expr!="@")||
        (e.names[i]=="%3"  && env_params[3].expr!="@")||
        (e.names[i]=="%4"  && env_params[4].expr!="@")||
        (e.names[i]=="%5"  && env_params[5].expr!="@"))
      {
        e.names.erase(e.names.begin() + i);
        e.values.erase(e.values.begin() + i);
        i--;
        s--;
      }
      }
 
  }
private:
  std::vector<GameApiParam> env_params;  
  int m_ii=0;
  bool recursion_stopper=false;
};
class EnvGameApiItem_arr_p : public GameApiItem
{
public:
  EnvGameApiItem_arr_p() {
  }
  virtual int Count() const { return 1; }
  virtual std::string Name(int i) const { return "env_params_arr_p"; }
  virtual int ParamCount(int i) const { return 1+5; }
  virtual std::string ParamName(int i, int p) const {
    switch(p) {
    case 0: return "ml";
    case 1: return "%1";
    case 2: return "%2";
    case 3: return "%3";
    case 4: return "%4";
    case 5: return "%5";
 
      //case 6: return "e1";
      //case 7: return "e2";
      //case 8: return "e3";
      //case 9: return "e4";
      //case 10: return "e5";
    default: return "";
    };
  }
  virtual std::string ParamType(int i, int p) const {
    switch(p) {
    case 0: return "P";
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
       return "std::string";
       //case 6:
       //case 7:
       //case 8:
       //case 9:
       //case 10:
       //return "std::string";
    default:
      return "";
    };
  }
  virtual std::string ParamDefault(int i, int p) const {
    switch(p) {
    case 0: return "";
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return "@";
      //case 6:
      //case 7:
      //case 8:
      //case 9:
      //case 10:
      //return "@";
    default:
      return "";
    };
  }
  virtual std::string DefaultAuthor(int i, int p) const { return ""; }
  virtual std::string DefaultLicense(int i, int p) const { return ""; }
  virtual std::string ReturnType(int i) const { return "[P]"; }
  virtual std::string ApiName(int i) const { return "mainloop_api"; }
  virtual std::string FuncName(int i) const { return "identity_arr_p"; }
  virtual std::string Symbols() const { return ""; }
  virtual std::string Comment() const { return "env setup arr"; }
  virtual int Execute(std::stringstream &ss, GameApi::Env &ee, GameApi::EveryApi &ev, std::vector<std::string> params, GameApi::ExecuteEnv &e, int j)
  {
    static int count=0;
    if (count==0) {
      count=1;
      std::cout << "Warning: env_params_arr_p cannot be deployed, and you must move to script_P_array before deploy." << std::endl;
    }
    
    std::vector<std::string> arr1 = parse_sep(params[1],'&');
    std::vector<std::string> arr2 = parse_sep(params[2],'&');
    std::vector<std::string> arr3 = parse_sep(params[3],'&');
    std::vector<std::string> arr4 = parse_sep(params[4],'&');
    std::vector<std::string> arr5 = parse_sep(params[5],'&');
 
    //std::vector<std::string> e1 = parse_sep(params[6],'&');
    //std::vector<std::string> e2 = parse_sep(params[7],'&');
    //std::vector<std::string> e3 = parse_sep(params[8],'&');
    //std::vector<std::string> e4 = parse_sep(params[9],'&');
    //std::vector<std::string> e5 = parse_sep(params[10],'&');
 
 
 
    
    int N = std::max(std::max(std::max(std::max(arr1.size(),arr2.size()),
                       arr3.size()),
                  arr4.size()),
             arr5.size());
    //int N2 = std::max(std::max(std::max(std::max(e1.size(),e2.size()),
    //                     e3.size()),
    //                e4.size()),
    //           e5.size());
    int NN = N; //std::max(N,N2);
    arr1.resize(NN);
    arr2.resize(NN);
    arr3.resize(NN);
    arr4.resize(NN);
    arr5.resize(NN);
 
    //e1.resize(NN);
    //e2.resize(NN);
    //e3.resize(NN);
    //e4.resize(NN);
    //e5.resize(NN);
 
    
    
    std::stringstream ss2(params[0]);
    int val = 0;
    ss2 >> val;
    GameApi::P p;
    p.id = val;
    std::string line;
    std::string prev_line;
    std::string prev_line2;
    std::vector<std::string> vec;
    std::string res;
    //while(std::getline(ss3,line)) {
    //  prev_line2 = prev_line;
    //  prev_line = line;
    //  res+=prev_line2;
    //  res+="\n";
    //}
    std::vector<GameApi::P> res_vec;
    for(int i=0;i<NN;i++)
      {
 
    m_ii = i;
    GameApi::ML ml = ev.polygon_api.render_vertex_array_ml2(ev,p);
    GameApi::RUN r = ev.blocker_api.game_window2(ev,ml,false,false,0.0,100000.0);
    GameApi::HML hml = ev.mainloop_api.emscripten_frame2(ev,r,"https://meshpage.org/assets",true);
    Html *hml2 = find_html(ev.get_env(),hml);
    hml2->Prepare();
    std::string script = hml2->script_file();
    //std::stringstream ss3(script);
    res=script;
 
 
    GameApi::ExecuteEnv &ee2 = e;
    std::vector<GameApiParam> paramvec;
    std::stringstream ss2; ss2 << ml.id;
 
    paramvec.push_back({"ml", ss2.str(),"ML",false,0,0,""});
    paramvec.push_back({"%1", arr1[i],"float",false,0,0,generate_seq(1,arr1.size()) /*e1[i]*/ });
    paramvec.push_back({"%2", arr2[i],"float",false,0,0,generate_seq(2,arr2.size()) /*e2[i]*/});
    paramvec.push_back({"%3", arr3[i],"float",false,0,0,generate_seq(3,arr3.size()) /*e3[i]*/});
    paramvec.push_back({"%4", arr4[i], "float",false,0,0,generate_seq(4,arr4.size()) /*e4[i]*/});
    paramvec.push_back({"%5", arr5[i], "float",false,0,0,generate_seq(5,arr5.size()) /*e5[i]*/});
    BeginEnv2(e, paramvec);
 
 
    
    res = replace_str(res, "@", "\n");
 
    // these break the feature that envparams_float_array can be used nested multiple times in the hierarchy
    res = replace_str(res, "%1", arr1[i]);
    res = replace_str(res, "%2", arr2[i]);
    res = replace_str(res, "%3", arr3[i]);
    res = replace_str(res, "%4", arr4[i]);
    res = replace_str(res, "%5", arr5[i]);
    //std::cout << "SCRIPT:" << res << std::endl;
    std::pair<int,std::string> p = GameApi::execute_codegen(ee,ev,res,ee2);
    if (p.first==-1) { continue; }
    assert(p.second=="P");
    int id = p.first;
    GameApi::P res_p;
    res_p.id = id;
    res_vec.push_back(res_p);
    EndEnv2(e);
      }
    std::vector<int> res_vec2;
    int s = res_vec.size();
    for(int i=0;i<s;i++) res_vec2.push_back(res_vec[i].id);
 
 
    ArrayType *array = new ArrayType;
    array->type=2;
    array->vec = res_vec2;
    GameApi::ARR a = add_array(ee,array);
    return a.id;
  }
  virtual std::pair<std::string,std::string> CodeGen(GameApi::EveryApi &ev, std::vector<std::string> params, std::vector<std::string> param_names, std::vector<std::string> param_exprs, int j)
  {
    if (!recursion_stopper) {
      recursion_stopper=true;
    //std::cout << "OUR CODEGEN..." << std::endl;
    std::pair<std::string,std::string> p = CodeGen_1(ev,choose_param3(params,m_ii), { "p", "%1", "%2", "%3", "%4", "%5" }, { "p","%1","%2","%3","%4","%5" }, choose_param3(param_exprs,m_ii), "ML","mainloop_api","identity_arr_p",j);
    //std::cout << "END_OF_OUR_CODEGEN" << std::endl;
    recursion_stopper=false;
    return p;
    } else { return std::make_pair("",""); }
  }
  virtual void BeginEnv(GameApi::ExecuteEnv &e, std::vector<GameApiParam> param) { }
  virtual void EndEnv(GameApi::ExecuteEnv &e) { }
  
  virtual void BeginEnv2(GameApi::ExecuteEnv &e, std::vector<GameApiParam> params) {
    if (params[1].expr != "@")
      {
    e.names.push_back("%1");
    e.values.push_back(params[1].expr);
      }
    if (params[2].expr != "@")
      {
    e.names.push_back("%2");
    e.values.push_back(params[2].expr);
      }
    if (params[3].expr != "@")
      {
    e.names.push_back("%3");
    e.values.push_back(params[3].expr);
      }
 
    if (params[4].expr != "@")
      {
    e.names.push_back("%4");
    e.values.push_back(params[4].expr);
      }
    if (params[5].expr != "@")
      {
    e.names.push_back("%5");
    e.values.push_back(params[5].expr);
      }
    env_params = params;
  }
  virtual void EndEnv2(GameApi::ExecuteEnv &e) {
    int s = e.names.size();
    for(int i=0;i<s;i++)
      {
    if ((e.names[i]=="%1" && env_params[1].expr!="@" )||
        (e.names[i]=="%2"  && env_params[2].expr!="@")||
        (e.names[i]=="%3"  && env_params[3].expr!="@")||
        (e.names[i]=="%4"  && env_params[4].expr!="@")||
        (e.names[i]=="%5"  && env_params[5].expr!="@"))
      {
        e.names.erase(e.names.begin() + i);
        e.values.erase(e.values.begin() + i);
        i--;
        s--;
      }
      }
 
  }
private:
  std::vector<GameApiParam> env_params;  
  int m_ii=0;
  bool recursion_stopper=false;
};