docs/html/GameApi_8hh_source.html

#ifndef GAMEAPI_HH

#define GAMEAPI_HH


#include "deps.hh"

#include "Buffer.hh"

#include "GameApi_low.hh"

#include <string>

#include <functional>

#include <vector>

#include <map>

#include <iostream>


int add_block();

void set_current_block(int id);

int get_current_block();

void clear_block(int id);


extern int ELayoutEmpty;


template<class T, class K> class Array;


class CodeGenPositions;

struct ASyncData;

struct BufferRef;

struct MainLoopEnv;

class LoadStream;

  class ASyncTask;

class NewShadowShaderML_1;

namespace GameApi

{

using std::placeholders::_1;

using std::placeholders::_2;

using std::placeholders::_3;

using std::placeholders::_4;

using std::placeholders::_5;

using std::placeholders::_6;

using std::placeholders::_7;

using std::placeholders::_8;

using std::placeholders::_9;


  class ShaderApi;


struct PinIn { }; // empty class for return type of a function which

                  // sends data to hardware pins, basically opengl pieces.

template<class T>

struct PinOut { T data; }; // one-element class that fetches data from pins. Also used for return type of function.


#undef rad1

#undef rad2


#define MAC(name) \

  struct name { int id;\

  name(const name &i) : id(i.id) { } \

  name(const volatile name &i) : id(i.id) { } \

  name() : id(-1) { }               \

  name(int i) : id(i) { }\

  name &operator=(const name &i) { id=i.id; return *this; } \

  volatile name &operator=(volatile name &i) volatile { id=i.id; return *this; } \

  name* clone() const { if (id!=-1) { return new name(id); } return 0; } \

  };


#ifndef PAT_DEFINED

  MAC(PAT)

#define PAT_DEFINED 1

#endif

  MAC(ZIP)

  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)

  struct ARR { int id;

  ARR(const ARR &i) : id(i.id) { }

  ARR(const volatile ARR &i) : id(i.id) { }

  ARR() : id(-1) { }

  ARR(int i) : id(i) { }

  ARR &operator=(const ARR &i) { id=i.id; return *this; }

  volatile ARR &operator=(volatile ARR &i) volatile { id=i.id; return *this; }

  ARR* clone() const { if (id!=-1) { return new ARR(id); } return 0; }

    // special functions:

    // problem: return value should be handle, not int.

    // problem: e env is not available inside this function?

    // problem: passing env via ctor is not working, since only id

    //          data member is allowed in handles due to templates in

    //          registration system.

#if 0

    int operator[](int i) const {

      ArrayType t = find_array(e,id);

      int id2 = t->vec[i];

      return id2;

    }

#endif

    // problem: return value should be std::vector<GameApi::handle>, not std::vector<int>.

    // problem: e env is not available inside this function?

#if 0

    std::vector<int> operator std::vector<int>()

    {

      ArrayType t = find_array(e,id);

      return t->vec;

    }

#endif

  };

#if 0

  // problem: current script doesnt insert convert_bm() calls anywhere.

  std::vector<GameApi::BM> convert_bm(std::vector<int> vec)

  {

    std::vector<GameApi::BM> res;

    int s = vec.size();

    for(int i=0;i<s;i++)

      {

    GameApi::BM bm; bm.id = vec[i];

    res.push_back(bm);

      }

    return res;

  }

#endif

  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)

  struct M { float mat[16]; M(const M &ii) { for(int i=0;i<16;i++) mat[i]=ii.mat[i]; }  M() { }}; // matrix

  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)

  template<class T>

  struct A { int id; };

  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(PM)

  MAC(PV)

  MAC(FS)

  struct TRB { int id; }; // g_resize_transfer_id+g_anim_transfer_id, both included

  struct TRR { int id; }; // g_resize_transfer_id

  struct TRA { int id; }; // g_anim_transfer_id

#undef MAC


  //template<class T>

  //struct E { int id; };

  //struct A { int id; };


  struct EveryApi;

  std::vector<PTS> arr_to_pts_arr(EveryApi &ev, ARR a);


struct ExecuteEnv

{

  std::vector<std::string> names;

  std::vector<std::string> values;

  std::map<std::string, int> envmap;

  std::vector<int> env; // contains indexes to EnvImpl/all vectors

};


  template<class P, class R>


  class FunctionCb

  {

  public:

    virtual R Map(P p) const=0;

  };


  class Env;

  struct EveryApi;


#ifdef WINDOWS

#ifdef GAMEAPI_EXPORTS

#define IMPORT __declspec(dllexport)

#else

#define IMPORT __declspec(dllimport)

#endif

#define EXPORT

#else


#ifdef GAMEAPI_EXPORTS

#define IMPORT __attribute__((visibility("default")))

#else

#define IMPORT

#endif

#define EXPORT


  /*

#ifndef __clang__

#define IMPORT

#define EXPORT

#else

#ifdef GAMEAPI_COMPILATION

#define IMPORT __declspec(dllexport)

#define EXPORT __declspec(dllexport)

#else

#define IMPORT

#define EXPORT

#endif

#endif

  */

#endif


  IMPORT std::pair<int,std::string> execute_codegen(Env &e2, EveryApi &ev, std::string text, ExecuteEnv &e);


  int register_cache_deleter(void (*fptr)(void*), void *data);

  void unregister_cache_deleter(int id);


  class ASyncVec;


class Env

{

public:

  IMPORT Env();

  IMPORT void free_memory();

  IMPORT void print_dependencies(int num);

  IMPORT std::vector<int> store_counts();

  IMPORT void free_to_counts(std::vector<int> vec);

  IMPORT void free_temp_memory();

  IMPORT void async_load_url(std::string url, std::string homepage, bool nosize=false);

  IMPORT void async_load_all_urls(std::vector<std::string> urls, std::string homepage);

  IMPORT void async_load_callback(std::string url, void (*fptr)(void*), void *data);

  IMPORT int count_async_callbacks_still_pending();

  IMPORT void print_callbacks_pending();

  IMPORT void async_rem_callback(std::string url);

  IMPORT ASyncVec *get_loaded_async_url(std::string url);

  IMPORT int add_to_download_bar(std::string filename);

  IMPORT int download_index_mapping(int index);

  IMPORT int download_bar_count() const;

  //IMPORT std::vector<unsigned char> *get_download_bar_item(int i) const;

  IMPORT void set_download_data(int i, const std::vector<unsigned char> &file);

  IMPORT void set_download_progress(int i, float percentage);

  IMPORT void set_download_ready(int i);

  IMPORT std::string get_download_bar_filename(int i) const;

  IMPORT float get_download_bar_progress(int i) const;

  IMPORT bool get_download_bar_ready(int i) const;

  IMPORT void remove_download_bar_item(int i);


  IMPORT int start_async(ASyncTask *task);

  IMPORT int async_mapping(int index);

  IMPORT void remove_async(int i);

  IMPORT void async_scheduler();


  // persistent store

  IMPORT void store_file(std::string filename, ASyncVec *vec);

  IMPORT bool store_file_exists(std::string filename);

  IMPORT void load_file(std::string filename, void (*fptr)(void*), void*, bool &success);

  IMPORT ASyncVec *load_file_result(std::string filename);

  IMPORT void load_file_clean(std::string filename);


  IMPORT ~Env();

  IMPORT static Env *Latest_Env();

private:

  Env(const Env &);

  void operator=(const Env &);

public:

  void *envimpl;

  friend struct EnvImpl;

};


#if 0

class SoundApi

{

public:

  SoundApi(Env e) : e(e) { }

  SD physical_key_press(ML ml, WVI wv);

private:

  Env &e;

};

#endif


class BlockerApi

{

public:

  IMPORT BlockerApi(Env &e);

  IMPORT BLK game_window(EveryApi &ev, ML ml, bool logo, bool fpscounter, float start_time, float duration);

  IMPORT BLK game_seq(EveryApi &ev, std::vector<BLK> vec);

  IMPORT void run(BLK blk);

  IMPORT RUN webgpu_window(EveryApi &ev, GML ml);

  IMPORT RUN game_window2(EveryApi &ev, ML ml, bool logo, bool fpscounter, float start_time, float duration);

  IMPORT RUN game_window_2nd_display(EveryApi &ev, ML ml, bool logo, bool fpscounter, float start_time, float duration);

  IMPORT RUN vr_window(EveryApi &ev, ML ml, bool logo, bool fpscounter, float start_time, float dura, bool invert, bool translate);

  IMPORT ML vr_submit(EveryApi &ev, TXID left, TXID right);

  IMPORT ML vr_submit_ml(EveryApi &ev, ML ml, TXID left, TXID right, bool invert, bool translate);

  IMPORT void run2(EveryApi &ev, RUN spl);

  IMPORT RUN run_seq(EveryApi &ev, std::vector<RUN> vec);

private:

  Env &e;

};


#ifdef F_MAINLOOP_API


class MainLoopApi

{

public:

    IMPORT MainLoopApi(Env &e);

    IMPORT ~MainLoopApi();

  IMPORT void call_execute_hack(ML ml);

  IMPORT ML double_instancing(EveryApi &ev, P p, PTS static_inst, PTS real_inst, MT mat);

  IMPORT ML double_instancing_matrix(EveryApi &ev, P p, MS static_ms, MS real_ms, MT mat);

  IMPORT ML AI_modified(EveryApi &ev, ML ml, std::string url);

  IMPORT ML AI_generated(EveryApi &ev, ML ml, std::string url);

  IMPORT ML web_link(EveryApi &ev, ML item, ML highlighted_item, float pt_x, float pt_y, float pt_z, float radius, std::string url);

  IMPORT ML print_time_sync(ML ml);

  IMPORT ML key_press_print_time_sync(ML ml);

  IMPORT ML random_game_seq(float time_step,MN mn,std::vector<ML> true_vec,std::vector<ML> false_vec,float perc,int num_levels);

  //IMPORT ML reload_ml(void *next, P p, std::string name, int phase, P default_p, void *default_p_material, PTS pts, MS ms);

  IMPORT ML progress_bar_config(ML ml, bool progress_impl, bool max_impl, bool install_impl, float mult_ems0, float mult_ems1, float mult_ems2, float mult_builder);

  IMPORT TF tf_join(EveryApi &ev, TF tf);

  IMPORT ML ogl_set_frame_rate(ML ml, int fps);

  IMPORT float get_frame_time() const;

  IMPORT TRB transfer_id();

  IMPORT TRR resize_transfer_id(TRB id);

  IMPORT TRA anim_transfer_id(TRB id);

  IMPORT ARR resize_and_anim_transfer_id();

  IMPORT bool is_gltf_animated(EveryApi &ev, TF tf);

  ML mesh_anim_2(std::vector<P> time_range_start_mesh_array,

                          std::vector<P> time_range_end_mesh_array,

                          std::vector<MN> moves_array,

                          std::vector<MT> materials_array,

                          std::vector<MS> matrix_array_arrays,

                          std::vector<IF> state_machines,

         //std::vector<float> *optional_time_range_duration // probably needs to be implemented using ENUM in builder.

         std::string optional_time_range_duration_array_with_separators_float,

         std::string url_to_mp_file

                        );


  ML cmb_2____(GameApi::EveryApi &ev,

           std::string a_script_url,

           std::string a_param1,

           std::string a_param2,

           std::string a_param3,

           std::string a_param4,

           std::string a_param5,

           std::string b_script_url,

           std::string b_param1,

           std::string b_param2,

           std::string b_param3,

           std::string b_param4,

           std::string b_param5,

           std::vector<float> *optional_time_range_duration);

  ML cmb_____(GameApi::EveryApi &ev,

          std::string script_url,

          std::string param1,

          std::string param2,

          std::string param3,

          std::string param4,

          std::string param5

          );

  ML cmb_glb_3d_interpolate(GameApi::EveryApi &ev, std::vector<GameApi::TF> tf_arr,

                // Material properties

                int material_id, float mix, float self_mult, float rest_mult, float light_dir_x, float light_dir_y, float light_dir_z,

                // Animation properties

                int skin_num, int animation, int num_timeindexes, MT next, int key, std::string keys, int mode, int inst, int timeid);


  GameApi::ML glb_to_download_bar(TF tf, std::string filename);

  GameApi::ML logo_change(ML ml, BM conn, BM download, BM prepare);

  GameApi::ML get_movement_from_MV(GameApi::ML ml);


  GameApi::ML lod_anim(GameApi::EveryApi &ev, GameApi::TF tf, GameApi::PTS pts, float level1, float level2, float level3, float level4, int l1, int l2, int l3, int l4, float mix, float self_mult, float rest_mult, int mode, std::string keys, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, int start_anim_seq, bool emissive, int frame_skip);

  GameApi::ML lod_anim_matrix(GameApi::EveryApi &ev, GameApi::TF tf, GameApi::MS ms, float level1, float level2, float level3, float level4, int l1, int l2, int l3, int l4,  float mix, float self_mult, float rest_mult, int mode, std::string keys, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, int start_anim_seq, bool emissive, int frame_skip);


  GameApi::ML lod_pts_tf(GameApi::EveryApi &ev, GameApi::TF p, GameApi::PTS pts, float level1, float level2, float level3, float level4, int l1, int l2, int l3, int l4, float mix, float selt_mult, float rest_mult, int mode, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, float start_brightness, float end_brightness, bool emissive);


  GameApi::ML lod_matrix_tf(GameApi::EveryApi &ev, GameApi::TF p, GameApi::MS ms, float level1, float level2, float level3, float level4, int l1, int l2, int l3, int l4, float mix, float selt_mult, float rest_mult, int mode, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, float start_brightness, float end_brightness, bool emissive);

  GameApi::ML lod_gpu(GameApi::EveryApi &ev, GameApi::P p, GameApi::MT mat, GameApi::PTS pts, float level1_tri, /*float level1_quad, float level1_polygon,*/ float level2_tri, /*float level2_quad, float level2_polygon,*/ float level3_tri, /*float level3_quad, float level3_polygon,*/ float level4_tri, /*float level4_quad, float level4_polygon,*/ int l1, int l2, int l3, int l4);


  GameApi::ML lod_gpu_matrix(GameApi::EveryApi &ev, GameApi::P p, GameApi::MT mat, GameApi::MS ms, float level1_tri, float level1_quad, float level1_polygon, float level2_tri, float level2_quad, float level2_polygon, float level3_tri, float level3_quad, float level3_polygon, float level4_tri, float level4_quad, float level4_polygon, int l1, int l2, int l3, int l4);

  GameApi::ML lod_gpu_pts_tf(GameApi::EveryApi &ev, GameApi::P p, GameApi::MT mat, GameApi::PTS pts, float level1_tri, /*float level1_quad, float level1_polygon*/ float level2_tri, /*float level2_quad, float level2_polygon*/ float level3_tri, /*float level3_quad, float level3_polygon*/ float level4_tri, /*float level4_quad, float level4_polygon*/ int l1, int l2, int l3, int l4, float mix, float self_mult, float rest_mult, int mode, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfil, float start_brightness, float end_brightness);


  GameApi::ML lod_gpu_matrix_tf(GameApi::EveryApi &ev, GameApi::P p, GameApi::MT mat, GameApi::MS pts, float level1_tri, /*float level1_quad, float level1_polygon*/ float level2_tri, /*float level2_quad, float level2_polygon*/ float level3_tri, /*float level3_quad, float level3_polygon*/ float level4_tri, /*float level4_quad, float level4_polygon*/ int l1, int l2, int l3, int l4, float mix, float self_mult, float rest_mult, int mode, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfil, float start_brightness, float end_brightness);


  IMPORT ML lod_matrix(EveryApi &ev, P p, MT mat, MS ms,float level1, float level2, float level3, float level4, int l1, int l2, int l3, int l4);

  IMPORT ML lod(EveryApi &ev, P p, MT mat, PTS pts, float level1, float level2, float level3, float level4, int l1, int l2, int l3, int l4);

  IMPORT ML gltf_mesh_all_inst( EveryApi &ev, TF model0, float mix, float light_dir_x, float light_dir_y, float light_dir_z, int skin_id );

  IMPORT ARR gltf_mesh_all_parr( EveryApi &ev, TF model0, float mix, float light_dir_x, float light_dir_y, float light_dir_z, int skin_num );

  IMPORT ARR gltf_mesh_all_msarr( EveryApi &ev, TF model0, int skin_num );

  IMPORT ARR gltf_mesh_all_parr_msarr( EveryApi &ev, TF model0, float mix, float light_dir_x, float light_dir_y, float light_dir_z,int skin_num  );

  IMPORT std::vector<GameApi::MT> gltf_mesh_all_parr_mat( EveryApi &ev, TF model0, float mix, float light_x, float light_y, float light_z, int skin_num);

  IMPORT ML bindinst_parr_msarr( EveryApi &ev, std::vector<P> parr, std::vector<MS> msarr, std::vector<MT> mat );

  IMPORT PTS bytestore_pts(BS bs, PTS pts, char disable_char, char enable_char, bool default_is_enable);

  IMPORT ML bytestore_render(EveryApi &ev, BS bs, std::vector<ML> mls, std::string url, float delta_x, float delta_y);

  IMPORT BS string_bytestore(std::string s);

  IMPORT ML bytestore_timing(BS store, int ch, std::string s, float time_delta);

  IMPORT ML bytestore_array(EveryApi &ev, BS store, std::string url, float delta_time);

  IMPORT ML cursorkeys_to_wasd(ML ml);

  IMPORT ML if_keys(ML ml, IF fetcher, std::string keys);

  IMPORT void save_glb_store(EveryApi &ev, std::string filename, TF tf);

  IMPORT ML shader_cache_disable(ML ml, bool disable);

  IMPORT void step();

  IMPORT ML android_landscape_scale(EveryApi &ev, ML ml);

  IMPORT ML disable_resize(ML ml);

  IMPORT ML turn_to_meters_default(EveryApi &ev, ML ml, P p);

  IMPORT ML turn_to_meters(EveryApi &ev, ML ml, float sx1,float sx2, float sy1,float sy2, float sz1,float sz2);

  IMPORT void check_glerrors(std::string context);

  IMPORT HML load_zip2(EveryApi &ev, std::string zip_url);

  IMPORT HML load_zip_assets2(std::string zip_url);

  IMPORT ML load_zip(EveryApi &ev, std::string zip_url);

  IMPORT ML load_zip_assets(std::string zip_url);

  IMPORT ML disable_matrices(EveryApi &ev, ML ml, int size);

  IMPORT ML hires_ml(EveryApi &ev, ML I3, int size, int numsamples, float blur_radius);

  IMPORT ML render_txid(EveryApi &ev, P p1, TXID I7, int size);

  IMPORT ML android_resize(EveryApi &ev, ML ml, float mult);

  //IMPORT ML gltf_material_nop_resize(EveryApi &ev, TF tf, int mesh_index, int prim_index, float mix);

  //IMPORT ML prim_render(EveryApi &ev, TF tf, int mesh_index, int prim_index, std::vector<GameApi::BM> bm, std::vector<int> types, std::vector<std::string> id_labels);

  //IMPORT ML mesh_render(EveryApi &ev, TF tf, int mesh_index, std::vector<BM> bm, std::vector<int> types, std::vector<std::string> id_labels);

  //IMPORT ML gltf_material_nop(EveryApi &ev, TF tf, int mesh_index, int prim_id, float mix);

  //IMPORT ML gltf_material_mesh(EveryApi &ev, TF tf, int mesh_index, float mix);

  //IMPORT ML gltf_node2(EveryApi &ev, TF tf, int node_id, float mix);

  //IMPORT ML gltf_scene2(EveryApi &ev, TF tf, int scene_id, float mix);

  IMPORT ML concurrent_download(ML ml);

  IMPORT ML no_concurrent_download(ML ml);

  IMPORT RUN no_concurrent_download_run(RUN r);

  IMPORT ML fullscreen_button(EveryApi &ev);

  IMPORT TT timing_start();

  IMPORT TT timing_event(IF fetch, TT timing, ML show);

  IMPORT TT timing(float duration, TT link, ML show);

  IMPORT TT array_timing_chain(TT prev, float start_time, std::string durations, std::vector<ML> vec);

  IMPORT ML array_timing_chain_ml(float start_time, std::string durations, std::vector<ML> vec, int repeat);

  IMPORT ML array_timing_chain_key_ml(EveryApi &ev, int key, float time_after_key, std::string durations, std::vector<ML> vec, int repeat);

  IMPORT TT current_time(TT prev);

  IMPORT TT t_repeat(TT prev, TT curr_to_repeated, int count);

  IMPORT TT timing_switch(EveryApi &ev, float duration, TT link, ML show, ML show2, int switch_dir);

  IMPORT ML timing_exit(TT link);

  IMPORT ML scene_transparency(ML scene);

  IMPORT ML game(EveryApi &ev, int tile_sx, int tile_sy, std::string url, std::string url2, std::string url3,std::string url4, std::string tiles_string, std::string tiles_string2, int start_pos_x, int start_pos_y, int player_start_tile, int player_end_tile, BM tile_bm, BM player_bm, BM ruohikko_bm, BM corn_bm, BM vesisade_bm, BM jump_bm, FI font, BM status_bm, BM splash, std::vector<BM> item_types, std::vector<BM> enemy_types, BM weapon_bm, std::vector<BM> enemy_child_death,BM aku_death);

  IMPORT W pts_world(PTS p, int type);

  IMPORT CX cache_one(P p, MT mt);

  IMPORT CX array_cache(std::vector<CX> vec);

  IMPORT CX subworld(CX c, W w, int start_block, int end_block);

  IMPORT W array_world(std::vector<W> vec);

  IMPORT ML load_midi(EveryApi &ev, ML next, std::string url, std::string url_patchset);

  IMPORT ML ml_empty();

  IMPORT P gltf_mesh_all_p(GameApi::EveryApi&ev, TF model0);

  IMPORT ARR gltf_mesh_all_p_arr(GameApi::EveryApi &ev, TF model0,float light_dir_x, float light_dir_y, float light_dir_z, bool transparent, bool emissive, int lod_level);

  IMPORT ARR gltf_mesh_all_mt_arr( EveryApi &ev, TF model0, float mix, float self_mult, float rest_mult,float light_dir_x, float light_dir_y, float light_dir_z, bool transparent, bool emissive, int lod_level);

  IMPORT MT mainloop_material(EveryApi &ev, ML ml);

  IMPORT TF glb_load_sketchfab_zip(std::string url_to_zip);

  IMPORT TF gltf_load_sketchfab_zip(std::string url_to_zip);

  IMPORT ML vr_scale(ML ml, float);

  IMPORT ML disable_polygons(ML ml);

  IMPORT ML print_deps(ML ml, int num);

  IMPORT ML screenspace_rendering(EveryApi &ev, ML scene, SMT screenspace_material);

  IMPORT ARR load_shader2(std::string vertex_url, std::string fragment_url);

  IMPORT SHC load_shader(std::string shader_url);

  IMPORT SHI generic_anim_shader2(EveryApi &ev, SHP params, std::string funcname, SHC code, std::vector<SHI> children);

  IMPORT void make_current();

  IMPORT SHP constant_shp_f(SHP next, int num, float value);

  IMPORT SHP constant_shp_i(SHP next, int num, int value);

  IMPORT SHP constant_shp_u(SHP next, int num, unsigned int value);

  IMPORT SHP constant_shp_p3d(SHP next, int num, PT value);

  IMPORT SHP constant_shp_uvw(SHP next, int num, PT value);

  IMPORT SHP timed_shp_f(float start_time, float end_time, SHP next, int num, float start_value, float end_value);

  IMPORT SHP timed_shp_i(float start_time, float end_time, SHP next, int num, int start_value, int end_value);

  IMPORT SHP timed_shp_u(float start_time, float end_time, SHP next, int num, unsigned int start_value, unsigned int end_value);

  IMPORT SHP timed_shp_p3d(float start_time, float end_time, SHP next, int num, PT start_value, PT end_value);

  IMPORT SHP timed_shp_uvw(float start_time, float end_time, SHP next, int num, PT start_value, PT end_value);

  IMPORT ML save_deploy(HML h, std::string filename, GameApi::EveryApi &ev);

  IMPORT ML save_deploy2(EveryApi &ev, RUN run, std::string homepage, bool is_in_arr, std::string filename);

  IMPORT ML save_script(HML h, std::string filename);

  IMPORT HML html_url(std::string url);

  IMPORT SHI empty_shaderI();

  IMPORT SHI phong_vertex(SHI next);

  IMPORT SHI phong_fragment(SHI next, unsigned int ambient, unsigned int highlight, float pow);

  IMPORT ML phong_shader3(EveryApi &ev, ML ml, unsigned int ambient, unsigned int highlight, float pow);

  IMPORT SHP empty_shp();

  IMPORT ML generic_shader_fragment_only(EveryApi &ev, ML ml, SHI fragment, std::vector<TXID> vec);

  IMPORT ML generic_shader(EveryApi &ev, ML ml, SHI vertex, SHI fragment, std::vector<TXID> vec);

  IMPORT SHI generic_anim_shader(SHP,std::string, std::string, std::vector<SHI> children);

  IMPORT ML save_gltf(TF tf, std::string filename);

  IMPORT TF gltf_loadKK(std::string base_url, std::string url);

  IMPORT TF gltf_loadKK2(std::string url);

  IMPORT ML send_key_at_time(ML ml, float time, int key);

  IMPORT void start_editor_state();

  IMPORT void end_editor_state();

  IMPORT ML right_mouse_pan(EveryApi &ev, ML next);

  IMPORT ML mouse_roll_zoom(EveryApi &ev, ML next);

  IMPORT ML mouse_roll_zoom2(EveryApi &ev, ML nect);

  IMPORT ML perspective(EveryApi &ev, ML next, float mult, float front_plane, float end_plane);

  IMPORT ML anim_ML(EveryApi &ev, std::string url, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5, IF dyn);

  IMPORT ML glClear(EveryApi &ev, unsigned int color);

  IMPORT GS game_state();

  IMPORT ML gs_mouse_pos(GS gs, ML ml, int x, int y);

  IMPORT ML gs_obj_pos(GS gs, ML ml, int x, int y, int z);

  IMPORT ML gs_delta(GS gs, ML ml, int p, int n, float delta);

  IMPORT ML gs_time(GS gs, ML ml, int t);

  IMPORT ML gltf_mesh_all_env(EveryApi &ev, TF model0, BM diffuse, BM specular, BM bfrd, float mix);

  IMPORT ML transparent(ML ml);

  IMPORT ML async_gltf(ML ml, TF tf);

  IMPORT ML tunnel_tree(EveryApi &ev, std::vector<P> faces, std::vector<MN> moves, std::string url, MT mat2);

  IMPORT ML edit_3d(EveryApi &ev, P p, float radius);

  IMPORT P edit_3d_p(EveryApi &ev);

  //ML gltf_joint_matrices(EveryApi &ev, LoadGltf *load, int skin_num, int animation, int time_index, ML next);

  IMPORT ML choose_ml_from_status(ML connect, ML download, ML prepare);

  IMPORT ML key_ml(std::vector<ML> vec, std::string keys);

  IMPORT ML async_url(std::string url, ML ml);

  IMPORT ARR gltf_anim_skeleton(EveryApi &ev, TF model0, int skin_num, int animation, int channelk, int num_keyframes);

  IMPORT P gltf_scene_p(GameApi::EveryApi &ev, TF model0, int scene_id);

  IMPORT ML memmap_window2(EveryApi &ev, std::string url);

  IMPORT ML memmap_window3(EveryApi &ev, std::string url_1, std::string url_2, std::string url_3, std::string url_4, std::string url_5, std::string url_6);

  IMPORT ML ml_load_um(EveryApi &ev, std::string url);

  IMPORT ML memmap_window(EveryApi &ev, PKG p);

  IMPORT PKG load_um(DS st);

  IMPORT MB network(std::string url, std::string homapge);

  IMPORT BM img_decode(MB memblock);


  IMPORT PTS whack_a_mole_explosion(EveryApi &ev);

  IMPORT ML whack_a_mole_flag_bmchooser(ML ml);

  IMPORT ML whack_a_mole_collision(ML ml);

  IMPORT ML disable_z_buffer(ML ml);

  IMPORT ML random_instantiate(EveryApi &ev, ML ml, std::vector<MN> vec, float start_time, float time_step, float random_chance);

  IMPORT BM flip_bitmap_if_mobile(EveryApi &ev, BM bm);

  IMPORT ML isometric(ML ml, float y_angle, float x_angle, float translate);

  IMPORT ML joystick_to_wasd(ML ml);

  IMPORT ML joystick_printer(ML ml);

  IMPORT ML dyn(D d);

  IMPORT ML print_stats(P p);

  IMPORT ML chai_mainloop(EveryApi &ev, std::string url);

  IMPORT ML chai_mainloop2(EveryApi &ev, std::string url, GameApi::ML ml);

  IMPORT ML bind_obj_type(std::string name, GameApi::P obj, GameApi::MN move, GameApi::MT mat, float radius);

  IMPORT ML bind_obj_type(GameApi::EveryApi &ev, std::string url);

  IMPORT ML read_obj_pos(std::string url);

  IMPORT ML parse_areatype(EveryApi &ev, std::string url, GameApi::FB heightmap, GameApi::BM top_texture, GameApi::BM side_texture);

  IMPORT ML create_landscape(EveryApi &ev, std::string url);

  IMPORT ML create_objs(EveryApi &ev, int area_id);

  IMPORT HML emscripten_frame(EveryApi &ev, RUN r, std::string homepage);

  IMPORT HML emscripten_frame2(EveryApi &ev, RUN r, std::string homepage, bool is_envparams_arr=false);

  IMPORT HML emscripten_frame2_ML(EveryApi &ev, ML ml, std::string homepage);

  IMPORT HML emscripten_frame2_P(EveryApi &ev, P p, std::string homepage);

  IMPORT HML emscripten_frame2_MN(EveryApi &ev, MN mn, std::string homepage);

  IMPORT HML emscripten_frame2_MT(EveryApi &ev, MT mt, std::string homepage);

  IMPORT void init_window(int screen_width = 800, int screen_height=600, std::string window_title="meshpage.org -- the next technology level for web", bool vr_init=false);

  IMPORT void init(SH sh, int screen_width = 800, int screen_height = 600);

  IMPORT void init_3d(SH sh, int screen_width = 800, int screen_heigth = 600);

  IMPORT void nvidia_init();

  IMPORT void transfer_sdl_surface(MainLoopApi &orig);

  IMPORT void clear(unsigned int col = 0xff000000);

  IMPORT void clear_3d_transparent();

  IMPORT void clear_3d(unsigned int col = 0xff000000);

  IMPORT void switch_to_3d(bool b, SH sh, int screen_width=800., int screen_height = 600);

  IMPORT ML restart_game(EveryApi &ev, ML ml, int key);

  IMPORT ML matrix_range_check(EveryApi &ev, ML ml, ML ml2, std::string url); // this uses restart_game.

  IMPORT LI gltf_skeleton(EveryApi &ev, TF model0, int start_node);

  IMPORT ML gltf_mesh( EveryApi &ev, TF model0, int mesh_id, int skin_id, std::string keys, float mix, float self_mult, float rest_mult, int mode, float light_dir_x, float light_dir_y, float light_dir_z, int animation, float border_width, unsigned int border_color, bool acesfilm, bool emissive, int frame_skip, int lod_level );

  IMPORT ML gltf_mesh_all( EveryApi &ev, TF model0, float mix,float self_mult, float rest_mult,int mode, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, bool emissive, int lod_level );

  IMPORT ML gltf_mesh_all_inst2( EveryApi &ev, TF model0, TF resize_obj, PTS pts, float mix,float self_mult, float rest_mult,int mode, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, std::string keys, bool emissive, int lod_level );


  IMPORT ML gltf_mesh_all_inst_matrix( EveryApi &ev, TF model0, TF resize_obj, MS ms, float mix,float self_mult, float rest_mult,int mode, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, std::string keys, bool emissive, int lod_level );

  IMPORT ML gltf_mesh_all_anim( EveryApi &ev, TF model0, float mix, float self_mult, float rest_mult, int mode, std::string keys, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, int start_anim_seq, bool emissive, int frame_skip, int lod_level);

  IMPORT ML gltf_mesh_all_anim_inst( EveryApi &ev, TF model0, TF resize_obj, PTS ms, float mix, float self_mult, float rest_mult, int mode, std::string keys, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, bool emissive, int frame_skip, int lod_level );

  IMPORT ML gltf_mesh_all_anim_inst_matrix( EveryApi &ev, TF model0, TF resize_obj, MS ms, float mix, float self_mult, float rest_mult, int mode, std::string keys, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, bool emissive, int anim_skip, int lod_level );

  IMPORT ML gltf_node( EveryApi &ev, TF model0, int node_id, std::string keys, float mix, float self_mult, float rest_mult, int mode, float light_dir_x, float light_dir_y, float light_dir_z, int animation, float border_width, unsigned int border_color, bool transparent, bool acesfilm, bool emissive, int frame_skip, int lod_level );

  IMPORT ML gltf_scene( EveryApi &ev, TF model0, int scene_id, std::string keys , float mix,float self_mult,float rest_mult,int mode, float light_dir_x, float light_dir_y, float light_dir_z, int animation , float border_width, unsigned int border_color, bool transparent, bool acesfilm, bool emissive, int frame_skip, int lod_level );

  //IMPORT ML gltf_anim( EveryApi &ev, std::string base_url, std::string url, int animation, int channel, int mesh_index, int prim_index, MT mat );

  IMPORT ML gltf_anim2( EveryApi &ev, TF model0, int animation, int channel);

  IMPORT ML gltf_anim4( EveryApi &ev, TF model0, int animation, int channel, float mix, float self_mult, float rest_mult, int mode, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool acesfilm, bool emissive, int frame_skip, int lod_level);

  IMPORT ML gltf_scene_anim(EveryApi &ev, TF model0, int scene_id, int animation, std::string keys, float mix, float self_mult, float rest_mult,int mode, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, bool emissive, int frame_skip, int lod_level);

  IMPORT ML flip_scene_if_mobile(EveryApi &ev, ML ml);

  IMPORT ML flip_scene_x_if_mobile(EveryApi &ev, ML ml);

  IMPORT ML activate_item(ML ml, ML def);

  IMPORT ML activate_array(std::vector<ML> vec);

  IMPORT ARR activate_arr_arr(std::vector<ML> arr);

  IMPORT ML slow_activate_item(ML ml,int i);

  IMPORT BM framebuffer_bitmap(FBU framebuffer);

  IMPORT ML display_background(EveryApi &ev, ML ml, bool is_logo=false);

  IMPORT ML small_window(EveryApi &ev, ML ml, int x, int y, int sx, int sy);

  IMPORT ML drag_drop_area(EveryApi &ev, ML mainloop, RUN (*fptr)(Env &e, EveryApi &ev, std::string filename));

  IMPORT PTS score_hide_pts(PTS pts);

  IMPORT IF score_set_hide();

  //IMPORT ML looking_glass(EveryApi &ev, ML ml);

  //IMPORT TXID looking_glass_txid(EveryApi &ev, ML ml);

  //IMPORT ML looking_glass_lib(TXID id, int sx, int sy, int x, int y);

  IMPORT ML looking_glass_full(EveryApi &ev, ML ml, float amount, int mode, int start, int end);

  IMPORT void alpha(bool enabled);

  void alpha_1(bool enabled);

  IMPORT void depth_test(bool enabled);

  IMPORT void transparency(bool enabled);

  IMPORT void cursor_visible(bool enabled);

  IMPORT void antialias(bool enabled);

  IMPORT void outline_first();

  IMPORT void outline_second();

  IMPORT void outline_third();

  IMPORT void outline_disable();

  //IMPORT void reset_time();

  IMPORT float get_time();

  IMPORT void advance_time(float val);

  IMPORT float get_delta_time();

  IMPORT void reset_time();

  IMPORT int get_framenum();

  IMPORT void swapbuffers();

  IMPORT void finish();

  IMPORT BM screenshot();

  IMPORT void fpscounter_init();

  IMPORT void fpscounter_framestart();

  IMPORT void fpscounter_frameready();

  IMPORT void fpscounter_swapbuffersready();

  IMPORT float fpscounter(bool print=true);

  IMPORT ML fps_display(EveryApi &ev, ML ml, std::string font);

  IMPORT ML score_display(EveryApi &ev, ML ml, std::string font);

  IMPORT ML time_display(EveryApi &ev, ML ml, std::string font, float start_time);


  IMPORT UV face_fetcher(P p, int facenum);

  IMPORT void profile(std::string label, bool start);

  IMPORT void print_profile();

  IMPORT void delay(int ms);

  IMPORT unsigned int random();

  IMPORT unsigned int rand_max();

  IMPORT PT random_point_3d(float start_x, float end_x,float start_y, float end_y,float start_z, float end_z);

  IMPORT PT random_point_2d(float start_x, float end_x,float start_y, float end_y,float z);

  IMPORT V random_dir_vector_2d_xy(float length);

  IMPORT V random_dir_vector_2d_xz(float length);

  IMPORT V random_dir_vector_3d(float length);

  IMPORT int get_screen_width();

  IMPORT int get_screen_height();

  IMPORT void set_corner(int x, int y, int screen_sx, int screen_sy);

  IMPORT int get_corner_x();

  IMPORT int get_corner_y();

  IMPORT int get_screen_rect_sx();

  IMPORT int get_screen_rect_sy();

  IMPORT int get_screen_sx();

  IMPORT int get_screen_sy();

  IMPORT void set_screen_size(int sx, int sy);

  IMPORT void set_viewport(int x, int y, int sx, int sy);


  IMPORT bool logo_iter();

  IMPORT void save_logo(EveryApi &ev);

  IMPORT void display_logo(EveryApi &ev);

  IMPORT bool seamless_iter();

  IMPORT void display_seamless(EveryApi &ev);

  IMPORT ML debug_obj(EveryApi &ev);

  IMPORT ML restart_screen(EveryApi &ev, ML ml, std::string fontname);

  IMPORT ML save_ds_ml(EveryApi &ev, std::string output_filename, P p, bool disable_normal, bool disable_color, bool disable_texcoord, bool disable_texcoord3, bool disable_objects);

  IMPORT void save_ds_store(std::string filename, DS ds);

  IMPORT void save_png_store(std::string filename, BM bm);


  struct Event

  {

    int type=-1;

    int ch=-1;

    PT cursor_pos={-1};

    int button=-1;

    int mouse_wheel_y=0;

    bool joy0_button0=false;

    bool joy0_button1=false;

    bool joy0_button2=false;

    bool joy0_button3=false;


    bool joy1_button0=false;

    bool joy1_button1=false;

    bool joy1_button2=false;

    bool joy1_button3=false;


    int joy0_current_axis=0;

    int joy0_axis0 =0;

    int joy0_axis1 =0;

    int joy0_axis2 =0;

    int joy0_axis3 =0;

    int joy0_axis4 =0;

    int joy1_current_axis=0;

    int joy1_axis0 =0;

    int joy1_axis1 =0;

    int joy1_axis2 =0;

    int joy1_axis3 =0;

    int joy1_axis4 =0;


    int joy0_ball0 = 0;

    int joy0_ball1 = 0;

    int joy1_ball0 = 0;

    int joy1_ball1 = 0;


    bool last=false;

    std::string drag_drop_filename="";

    int repeat = 0;

  };


  struct DoubleTapState { DoubleTapState() : start_frame(0), in_between(false) { } int start_frame; bool in_between; };

  IMPORT bool ch_doubletap_detect(Event &e, int exprire_timer_count, int ch, DoubleTapState &state);

  IMPORT Event get_event();

  IMPORT void waittof();

  IMPORT SP screenspace();

  IMPORT void execute_ml(EveryApi &ev, ML ml, SH color, SH texture, SH texture_2d, SH arr_texture, M in_MV, M in_T, M in_N, int screen_width, int screen_height);

  IMPORT void event_ml(ML ml, const Event &e);

  IMPORT ML array_ml(GameApi::EveryApi &ev, std::vector<ML> vec);

  IMPORT ML slow_start_array_ml(GameApi::EveryApi &ev, std::vector<ML> vec, int max_ticks);

  IMPORT ML filter_execute_array_ml(GameApi::EveryApi &ev, std::vector<ML> vec);

  IMPORT ML or_elem_ml(GameApi::EveryApi &ev, ML m1, ML m2);

  IMPORT FML array_fml(std::vector<FML> vec);

  //IMPORT ML timing_ml(std::vector<ML> vec, float duration);

  IMPORT ML dyn_points(EveryApi &ev, ML ml, MN move, int pointnum, float pos_x, float pos_y, float pos_z);

  IMPORT ML seq_ml(std::vector<ML> vec, float time);

  IMPORT ML seq_ml_score(ML ml1, ML ml2, int score);

  IMPORT ML timed_tmp_seq_ml(ML curr, ML end, float start_time, float end_time, float show_duration, int key);

  IMPORT ML collision_seq_ml(ML curr, ML end, std::string obj1, std::string obj2, float show_duration);

  IMPORT ML collision_gen_key(ML curr, std::string obj1, std::string obj2, int key, float duration);

  IMPORT ML collision_detection(EveryApi &ev,float player_size,float enemy_size, ML normal_game_screen, ML gameover_screen);


  IMPORT M in_MV(EveryApi &ev, bool is_3d);

  IMPORT M in_T(EveryApi &ev, bool is_3d);

  IMPORT M in_N(EveryApi &ev, bool is_3d);

  IMPORT M in_P(EveryApi &ev, bool is_3d);

  IMPORT std::string get_homepage_url();

  IMPORT void set_homepage_url(std::string url);

  IMPORT void set_seamless_url(std::string url);


  IMPORT ML load_song(EveryApi& ev, ML next, std::string url);

  IMPORT ML skybox(EveryApi &ev, BM land, BM sky); // 100x100 bm's required

  IMPORT ML scale_2d_screen(EveryApi &ev, ML orig, float sx, float sy);

  IMPORT ML keyboard_toggle(ML m1, ML m2, int key);

  IMPORT ML touch_rotate(EveryApi &ev, ML ml, bool leftright, bool topdown, float x_speed, float y_speed);

  IMPORT P p_script2(EveryApi &ev, HML h, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5);

  IMPORT P load_P_script(EveryApi &ev, std::string url, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5);

  IMPORT ARR load_P_script_array(EveryApi &ev, HML hml /*std::string url*/, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5);

  IMPORT ML load_ML_script(EveryApi &ev, std::string url, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5);

  IMPORT ML load_ML_script2(EveryApi &ev, HML h, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5);

  IMPORT ML load_ML_script3(EveryApi &ev, std::string url);

  IMPORT MN load_MN_script(EveryApi &ev, std::string url, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5);

    IMPORT MN load_MN_script2(EveryApi &ev, HML h, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5);

  IMPORT MT load_MT_script(EveryApi &ev, std::string url, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5);

  IMPORT MT load_MT_script2(EveryApi &ev, HML h, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5);


  IMPORT ARR load_ML_script_array(EveryApi &ev, std::string url, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5);

  IMPORT BM load_BM_script(EveryApi &ev, std::string url, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5);

  IMPORT ARR load_BM_script_array(EveryApi &ev, std::string url, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5);

  IMPORT ARR load_BM_script_array_comb(EveryApi &ev, std::string url, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5);

  IMPORT ML prepare_pts(ML ml, PTS pts);

  IMPORT ML depthfunc(ML ml, int val);

  IMPORT ML depthmask(ML ml, bool b);

  IMPORT ML blendfunc(ML ml, int val, int val2);

  IMPORT ML cullface(ML ml, bool b, bool is_gltf);

  IMPORT ML record_keypresses(ML ml, std::string output_filename);

  IMPORT ML playback_keypresses(ML ml, std::string input_url);

  IMPORT ML setup_hmd_projection(EveryApi &ev, ML ml, bool eye, bool is_standard, float n, float f, bool translate);


  IMPORT DS load_ds_from_mem(const unsigned char *buf, const unsigned char *end);

  IMPORT DS load_ds_from_disk(std::string filename);

  IMPORT DS load_ds_from_disk_incrementally(std::string filename);

  IMPORT void save_ds(std::string output_filename, DS ds);

  IMPORT std::string ds_to_string(DS ds);


  // temp store

  IMPORT void load_ds_from_temp(std::string filename, void (*fptr)(void*), void *data, bool &success);

  IMPORT DS load_ds_from_temp2(std::string filename);

  IMPORT void load_ds_from_temp3(std::string filename);


  IMPORT INP cursor_keys_normal_move();

  IMPORT INP cursor_keys_rotate_move(float speed_rot, float pos_forward, float pos_normal, float pos_backward);

  IMPORT INP move_sequence(float start_time, float time_per_char, std::string str);

  IMPORT INP move_speed(INP orig, float speed);

  IMPORT INP gravity(INP im, IBM bitmap, float start_x, float end_x, float start_y, float end_y, float speed);

  IMPORT INP move_collision(IBM scene, float start_x, float end_x, float start_y, float end_y, float s_x, float m_x, float e_x, float s_y, float m_y, float e_y, float speed_up, float speed_down, float speed_left, float speed_right, float speed_gravity);

  IMPORT ML move_in(EveryApi &ev, ML ml, INP in);

  IMPORT ML score_adder(EveryApi &ev, ML ml, O o, MN transform, int enter_score, int leave_score, int dyn_point, float timeout);

  IMPORT ML score_adder2(EveryApi &ev, ML ml, O o,PTS points, MN transform, int enter_score, int leave_score, int dyn_point, float timeout, IF fetcher);

  IMPORT ML score_hidder(EveryApi &ev, ML ml, O o, int max_count);

  IMPORT IF state_int_fetcher(std::string url, std::string states);

  IMPORT MN state_speed_movement(MN mn, std::string url, std::string states, std::string x_speeds, std::string y_speeds, std::string z_speeds);

private:

  MainLoopApi(const MainLoopApi&);

  void operator=(const MainLoopApi&);

  float frame;

  float time;

  Env &e;

  void *priv;

};


#endif


class MixedApi

{

public:

  IMPORT MixedApi(Env &e);

  // constructing

  IMPORT MX mx_float(float val);

  IMPORT MX mx_int(int val);

  IMPORT MX mx_bool(bool val);

  IMPORT MX mx_point(float x, float y, float z);

  IMPORT MX mx_vector(float dx, float dy, float dz);

  IMPORT MX mx_color(int r, int g, int b, int a);

  IMPORT MX mx_pair(std::string name, MX val);

  IMPORT MX mx_string(std::string value);

  IMPORT MX mx_array(std::vector<MX> vec);


  // accessing

  IMPORT int mx_size(MX arr);

  IMPORT MX mx_index(MX arr, int idx);

  IMPORT MX mx_find(MX arr, std::string name);

  IMPORT float mx_to_float(MX val, float def=0.0);

  IMPORT int mx_to_int(MX val, int def=-1);

  IMPORT std::vector<std::string> mx_names(MX val);

  IMPORT std::vector<MX> mx_values(MX val);

private:

  Env &e;

};


#ifdef F_SPRITE_API


class SpriteApi

{

public:

    IMPORT SpriteApi(Env &e);

    IMPORT ~SpriteApi();

    IMPORT void spritepos(BM bm, float x, float y);

    IMPORT void preparesprite(BM bm, int bbm_choose = -1);


  IMPORT VA create_vertex_array(BM bm, bool progress=false, bool textrender=false);

  IMPORT void clear_arrays(VA va);

        IMPORT void delete_vertex_array(VA va);

        IMPORT void update_vertex_array(VA va, BM bm);

        IMPORT ML update_vertex_array_ml(VA va, BM bm);

        IMPORT void clipping_sprite(VA va, int sx, int sy, float tex_l, float tex_t, float tex_r, float teb_b);

    IMPORT void render_sprite_vertex_array(VA va);

  IMPORT ML vertex_array_render(EveryApi &ev, BM bm);

  IMPORT ML render_sprite_vertex_array_ml(EveryApi &ev, BM bm);


    IMPORT void rendersprite(BM bm, SH sh, float x, float y, float mult_x = 1.0, float mult_y = 1.0);

    IMPORT void rendersprite2(BM bm, SH sh, PT pos);

    IMPORT void rendersprite3(BM bm, int bm_choose, SH sh, float x, float y, float mult_x, float mult_y);

    void rendersprite3_1(BM bm, int bm_choose, SH sh, float x, float y, float mult_x, float mult_y);

    IMPORT void rendersprite4(BM bm, int bm_choose, SH sh, PT pos);

    IMPORT void rendersprite5(BM bm, int bm_choose, SH sh, SP move_space, SP sprite_space, float x, float y);

    IMPORT void rendersprite6(BM bm, int bm_choose, SH sh, SP move_space, SP sprite_space, PT pos);

  //IMPORT void rendersprite(BM bm, SH sh, float x, float y, float x1, float y1, float inside_x, float inside_y, float inside_x1, float inside_y1);

    IMPORT SP spritespace(BM bm);

    IMPORT PT pixelpos(BM bm, int x, int y);

  IMPORT std::vector<BM> bitmap_anim(std::function<BM (float)> f, std::vector<float> key_frames);

  IMPORT ML bitmap_anim_ml(EveryApi &ev, std::vector<BM> vec, std::vector<float> key_frames, float repeat_time);

  IMPORT ML turn_to_2d(EveryApi &ev, ML ml, float tl_x, float tl_y, float br_x, float br_y);

  IMPORT ML alt_ml_array(EveryApi &ev, std::vector<ML> vec, float start_time, float time_delta, bool repeat);

  IMPORT ARR sprite_atlas_x(EveryApi &ev, BM orig, int start_x, int end_x, int start_y, int end_y, int delta_x, int count);

  IMPORT ARR sprite_atlas_y(EveryApi &ev, BM orig, int start_x, int end_x, int start_y, int end_y, int delta_y, int count);

  IMPORT ARR sprite_atlas_xy(EveryApi &ev, BM orig, int start_x, int end_x, int start_y, int end_y, int delta_x, int delta_y, int count_x, int count_y);

private:

  SpriteApi(const SpriteApi&);

  void operator=(const SpriteApi&);

  void *priv;

  Env &e;

};


#endif


#ifdef F_TEXTURE_API


class TextureApi

{

public:

    IMPORT TextureApi(Env &e);

  IMPORT BufferRefF prepare_fb(FB bitmap, Low_GLuint &id);

  IMPORT TXID send_fb_to_gpu(BufferRefF ref, Low_GLuint id);

  IMPORT std::vector<BufferRef> prepare_many_buf(EveryApi &ev, std::vector<BM> vec, std::vector<int> types, bool mipmaps, std::vector<std::string> id_labels, std::vector<Low_GLuint> &res);

  IMPORT std::vector<TXID> prepare_many_txid(EveryApi &ev, std::vector<BufferRef> vec, std::vector<Low_GLuint> ids, std::vector<int> types, bool mipmaps, std::vector<std::string> id_labels);

  IMPORT ARR grab_to_bm_array(BM bm);

  IMPORT ARR send_screenshots_via_key_array(EveryApi &ev, ML ml3, int key, float time_delta, int num);

  IMPORT PBO create_pbo(int sx, int sy);

  IMPORT ML upload_bm_to_pbo(BM bm, PBO p);

  IMPORT ML upload_txid_to_pbo(TXID tx, PBO p); // TODO

  IMPORT BM pbo_to_bitmap(PBO p);

  IMPORT TXID pbo_to_txid(PBO p);

  IMPORT ML grab_to_server(BM bm, int id, int num);

  IMPORT ML send_screenshots_via_key_to_server(EveryApi &ev, ML ml3, int key, float time_delta, int num);

  IMPORT ML prepare_key_anim(ML next, std::vector<ML> keyed, int key, float time_delta, std::vector<std::string> filenames);

  IMPORT ML save_screenshots_via_key(EveryApi &ev, ML ml3, int key, float time_delta, int num);

  IMPORT ML save_screenshot_via_key(EveryApi &ev, ML ml3, int key, std::string filename);

  IMPORT BM grab_screen_bitmap(EveryApi &ev);

  IMPORT ML prepare_key(ML next, ML keyed, int key);

  IMPORT ARR grab_screen(EveryApi &ev, RUN r);

  IMPORT RUN combine_screens(RUN r1, RUN r2);

  IMPORT TX tex_plane(int sx, int sy);

    IMPORT TX tex_bitmap(BM bm);

    IMPORT int unique_id();

    IMPORT TX tex_assign(TX tx, int id, int x, int y, BM bm);

    IMPORT TX tex_coord(TX tx, int id, int x, int y, int width, int height);

    IMPORT Q get_tex_coord(TX tx, int id);

    Q get_tex_coord_1(TX tx, int id);

  IMPORT TXID prepare(TX tx, bool is_srgb=true, bool text_render=false);

  IMPORT TXID bufferref_to_txid(TXID old, const BufferRef &buf);

  IMPORT TXID webcam_txid(int num);

  IMPORT TXID webcam_txid_slow(EveryApi &ev, int num);

  IMPORT TXID webcam_txid_win(EveryApi &ev, int sx, int sy, int num);

  IMPORT TXID webcam_txid_linux(EveryApi &ev, int sx, int sy, int num);

  IMPORT TXID webcam_txid_emscripten(EveryApi &ev, int sx, int sy, int num);

  IMPORT TXID webcam_txid_generic(EveryApi &ev, int sx, int sy, int num);

  IMPORT TXID videofile_txid_generic(EveryApi &ev, int sx, int sy, std::string url);

  IMPORT TXID videofile_txid_emscripten(EveryApi &ev, int sx, int sy, std::string url, int num);

  IMPORT TXID videofile_txid_win32(EveryApi &ev, int sx, int sy, std::string url);

  IMPORT ML vr_overlay(TXID id, std::string key, std::string name, int sx, int sy);

  IMPORT std::vector<TXID> prepare_many(EveryApi &ev, std::vector<BM> vec, std::vector<int> types=std::vector<int>(),bool mipmaps=true, std::vector<std::string> id_labels=std::vector<std::string>(), std::vector<bool> is_srgb=std::vector<bool>());

  IMPORT TXID prepare_cubemap(EveryApi &ev, BM right, BM left, BM top, BM bottom, BM back, BM front);

    IMPORT void use(TXID tx, int i = 0);

  IMPORT void use_many(std::vector<TXID> vec, int i=0);

    IMPORT void unuse(TXID tx);

  IMPORT void delete_texid(TXID tx);

  IMPORT void delete_texid(std::vector<TXID> vec);

  IMPORT VA bind(VA va, TXID tx);

  IMPORT VA bind_many(VA va, std::vector<TXID> tx, std::vector<int> types=std::vector<int>());

        IMPORT VA bind_cubemap(VA va, TXID id);

    IMPORT VA bind_arr(VA va, TXA tx);

        IMPORT TXA prepare_arr(EveryApi &ev, std::vector<BM> vec, int sx, int sy);

  IMPORT BM to_bitmap(EveryApi &ev, TXID id);

  IMPORT ML forward_to_txid(VA va, ML mainloop, TXID id);

private:

  TextureApi(const TextureApi&);

  void operator=(const TextureApi&);

  Env &e;

  int count;

};


#endif


#ifdef F_GRID_API


class GridApi

{

public:

    IMPORT GridApi(Env &e);

    IMPORT ~GridApi();

    IMPORT SP gridtilespace(BM tilebm, int sx, int sy, int x, int y);

    IMPORT SP wholegridspace(int sx, int sy, BM grid);


    IMPORT void preparegrid(BM tile_bitmap, int tile_choose = -1);

    IMPORT void rendergrid(BM grid, int grid_choose, float top_x, float top_y);


private:

  GridApi(const GridApi&);

  void operator=(const GridApi&);

  void *priv;

  Env &e;

};


#endif


#ifdef F_BITMAP_API


class BitmapApi

{

public:

    IMPORT BitmapApi(Env &e);

    IMPORT ~BitmapApi();

  IMPORT ML isoline_render2(EveryApi &ev, FB fb, float pos, float delta_pos, int num);

  IMPORT BB isoline_render(EveryApi &ev, FB bm, float start_range, float end_range, float delta_range, int num);

  IMPORT BM render_volume_object(O o, float start_x, float end_x, float start_y, float end_y, float z, int sx, int sy, float ray_length, int sample_count);

  IMPORT ARR choose_neg_zero_positive(EveryApi &ev, FB fb, float pos);

  IMPORT BB range_choose(FB bm, float start_range, float end_range);

  IMPORT BM sphere_rays_bitmap(float center_x, float center_y, float center_z, float radius, float delta_alfa, float delta_beta, FS field, int maxiter, float c, int fptr_enum, std::vector<PT> vec, int vec_choose);

  IMPORT TXID video_source(std::string filename, int sx, int sy);

  IMPORT BM stable_diffusion(EveryApi &ev, std::string prompt, std::string filename);

  // temp store

  IMPORT BM bm_png_bm(EveryApi &ev, BM bm, std::string url);

  IMPORT void load_png_from_temp(std::string filename, void (*fptr)(void*), void *data, bool &success);

  IMPORT BM load_png_from_temp2(std::string filename);

  IMPORT void load_png_from_temp3(std::string filename);


  IMPORT BM debug_number(EveryApi &ev, BM bm0, int num, bool disable, std::string url);

  IMPORT ML display_bitmaps(EveryApi &ev, std::vector<BM> vec, float start_time, float delta_time);

  IMPORT ML vertical_bitmap_display(EveryApi &ev, std::vector<BM> vec, float y_delta);

  IMPORT BM flip_tile_bitmap(BM bm, int sx, int sy, bool is_x);

  IMPORT ML write_gif_anim2(Array<int,int> *vec, std::string filename, int delay);

  IMPORT ML gif_anim(EveryApi &ev, ML ml3, int key, float time_delta, int num, std::string filename, int delay);

  IMPORT ML write_gif_anim(std::vector<BM> vec, std::string filename, int delay);

  IMPORT ML savepng_array_ml(EveryApi &ev, std::vector<BM> bms, std::string filename_start, std::string filename_end, bool alpha, float time);

  IMPORT BM gray_to_black(BM bm, float val);

  IMPORT BM newbitmap_bm(BM bm, unsigned int color);

  IMPORT BM newbitmap_fb(FB fb, unsigned int color);

  IMPORT BM newbitmap_bb(BB bb, unsigned int color);

  IMPORT FB flood_fill(FB fb, float percentage, int x, int y, bool inv);

  IMPORT BM flood_fill_color(EveryApi &ev, BM bm, float percentage, int x, int y, unsigned int color);

  IMPORT BM flood_fill_color_inv(EveryApi &ev, BM bm, float percentage, int x, int y, unsigned int color);

  IMPORT CBM scale_bitmap2(BM bm);

  IMPORT ML save_raw(BM bm, std::string filename);

  IMPORT BM lightmap_bitmap(int sx, int sy, P faces, P faces2, int face, float light_dir_x, float light_dir_y, float light_dir_z);

  IMPORT BM circular_gradient(int sx, int sy, unsigned int center_color, unsigned int edge_color);

  IMPORT BM script_bitmap(std::string url, int sx, int sy);

  IMPORT ML grid_ml(EveryApi &ev, ML next, IBM map, float y, float pos_x, float pos_z, float x_vec_x, float x_vec_z, float z_vec_x, float z_vec_z, int start_x, int start_z, float frame_inc);

  IMPORT P p_world_from_bitmap(EveryApi &ev, std::vector<P> vec, IBM world, float pos_x, float pos_y, float pos_z, float dx, float dz, float y);

  IMPORT BM scale_to_size(BM bm, int sz);

  IMPORT BM median_filter(BM bm, int sx, int sy);

        IMPORT BM newbitmap(int sx, int sy, unsigned int color = 0x00000000);

    IMPORT BM function(std::function<unsigned(int, int)> f, int sx, int sy);

    IMPORT BM transform(BM orig, std::function<unsigned int(int, int, unsigned int)> f);

    IMPORT BM newintbitmap(char *array, int sx, int sy, std::function<int(char)> f);

        IMPORT IBM intbitmap_loader(std::string url);

  IMPORT BM calculate_baked_light(P p, P p2, BM texture, int count, float light_pos_x, float light_pos_y, float light_pos_z, float shadow_darkness, float softness);

  IMPORT BM color_bm(BM bm, unsigned int color);

  IMPORT BB choose_color(BM bm, unsigned int c1, unsigned int c2);

  IMPORT BM intbitmap_bm(IBM ibm);

  IMPORT BM chai_bm(std::string url, int sx, int sy);

  IMPORT BM bump_map(FB fb, float h);

    IMPORT BM newcolorbitmap(char *array, int sz, int sy, std::function<unsigned int(char)> f);

    IMPORT BM newtilebitmap(int sx, int sy, int tile_sx, int tile_sy);

    IMPORT BM loadbitmap(std::string filename);

        IMPORT BM loadbitmapfromurl(std::string url);

    IMPORT BM loadtilebitmap(std::string filename, int tile_sx, int tile_sy);

    IMPORT BM loadposbitmap(std::string filename);

    IMPORT BM findtile(BM tile_bitmap, int x, int y);

  IMPORT BM compose_x(BM bm1, BM bm2);

  IMPORT BM compose_y(BM bm1, BM bm2);

  IMPORT BM border(BM, int left ,int right ,int top ,int bottom);

  IMPORT BM add_shape_border(EveryApi &ev, BM bm, float dist_field_size, float start_range, float end_range, int r, int g, int b, int a, int border_size);

    IMPORT BM subbitmap(BM orig, int x, int y, int width, int height);

    IMPORT BM subbitmapimage(BM orig, int r_start_range, int r_end_range, int g_start_range, int g_end_range, int b_start_range, int b_end_range, unsigned int empty_color);

  IMPORT BM plus_bitmap(BM bm, BM bm2);

  IMPORT BM noise_vectors(int sx, int sy);

  IMPORT IBM random_int_bitmap(int sx,int sy,int min_value,int max_value);

  IMPORT IBM convert_fb_to_ibm_bitmap(FB fb, float start, float d);

  IMPORT VX convert_ibm_to_vx(IBM bm);

    IMPORT BM growbitmap(BM small_orig_bitmap, int l, int t, int r, int b);

    IMPORT BM blitbitmap(BM bg, BM orig, int x, int y);

    IMPORT BM blitbitmap_fb(BM bg, BM orig, int x, int y, FB mask);

    IMPORT BM blitbitmap_bb(BM bg, BM orig, int x, int y, BB mask);

    IMPORT BM anim_array(BM *array, int size);

    IMPORT BM modify_bitmap(BM orig, BM bm, int x, int y);

    IMPORT BM interpolate_bitmap(BM orig1, BM orig2, float x); // x=[0..1]

    IMPORT BM repeat_bitmap(BM orig, int xcount, int ycount);

    IMPORT BM sample_bitmap(BM orig, float xmult, float ymult, float x, float y);

  IMPORT BM scale_bitmap(EveryApi &ev, BM orig, int sx, int sy);

  IMPORT BM scale_bitmap_fullscreen(EveryApi &ev, BM orig);

        IMPORT BM world_from_bitmap(std::function<BM(int)> f, BM int_bm, int dx, int dy);

  IMPORT ARR cubemap(BM bm);

  IMPORT BM bm_cubemap(EveryApi &ev, BM left, BM top, BM middle, BM right, BM back, BM down, int sx, int sy);

  IMPORT BM world_from_bitmap2(EveryApi &ev, std::vector<BM> v, std::string filename, std::string chars, int dx, int dy, int sx, int sy);

  IMPORT BM world_from_bitmap3(EveryApi &ev, std::vector<BM> v, std::string url, std::string chars, int dx, int dy);

        IMPORT BM dup_x(BM orig);

    IMPORT BM flip_x(BM orig);

    IMPORT BM flip_y(BM orig);

  IMPORT BM rot90(BM orig);

        IMPORT BM alpha_color(BM orig, unsigned int color_key);

  IMPORT BM gradient(PT pos_1, PT pos_2, unsigned int color_1, unsigned int color_2, int sx, int sy);

  IMPORT BM gradient_y(unsigned int color_1, unsigned int color_2, int sx, int sy);

  IMPORT BM radial_gradient(int sx, int sy, PT pos, float r1, float r2, unsigned int color_1, unsigned int color_2);

  IMPORT BM conical_gradient(int sx, int sy, float x, float y, float angle1, float angle2, unsigned int color_1, unsigned int color_2);

  //BM bitmapandtypes(BM bm, BM (*fptr)(int)); // bm has ints in it

  IMPORT SP space(BM bm);


  IMPORT BM addsubrects(BM orig); // use subbitmap with orig bitmap.

  IMPORT void savebitmap(BM orig, std::string filename, bool alpha=false);

  IMPORT ML savebitmap_ml(EveryApi &ev, BM bm, std::string filename, bool alpha, float time);

  IMPORT void save_png(BM bm, std::string filename);

  IMPORT ML save_png_ml(EveryApi &ev, BM bm, std::string filename);

  IMPORT BM mandelbrot(bool julia,float start_x, float end_x, float start_y, float end_y, float xx, float yy, int sx, int sy,int count);

  IMPORT BM mandelbrot2(bool julia,float start_x, float end_x, float start_y, float end_y, float xx, float yy, int sx, int sy,int count);

  IMPORT BM chessboard(int tile_sx, int tile_sy, int count_x, int count_y, unsigned int c1, unsigned int c2);

  IMPORT BM color_range(BM orig, unsigned int source_upper, unsigned int source_lower, unsigned int target_upper, unsigned int target_lower);

  IMPORT BM memoize(BM orig);

  IMPORT BM memoize_all(BM orig);

  IMPORT BM persistent_cache(BM orig, std::string filename);

  IMPORT BM alt(std::vector<BM> vec, int index);

  IMPORT BM simple_blur(BM bm, float center, float left, float right, float top, float bottom); // this is dangerous operation

  IMPORT int intvalue(BM bm, int x, int y);

  IMPORT unsigned int colorvalue(BM bm, int x, int y);

  IMPORT int size_x(BM bm);

  IMPORT int size_y(BM bm);

  IMPORT void prepare(BM bm);

  IMPORT bool ready_to_prepare(BM bm);


  IMPORT BMA empty_array();

  IMPORT BMA array(BM *array, int size);

  IMPORT BM array_elem(BMA array, int i);

  IMPORT BM Indicator(int sx, int sy, int g_ind);

  IMPORT BM avg(BM bm1, BM bm2);

  IMPORT BM fix_edges(BM bm);


  IMPORT FB gradient_fb(int sx, int sy, float val, float val2, bool flip);

  IMPORT FB radial_fb(int sx, int sy, float x, float y, float r, float val_at_zero, float val_at_r);

  IMPORT FB sin_fb(FB gradient);

  IMPORT FB plus_fb(FB f1, FB f2);

  IMPORT FB mul_fb(FB f, float mul);

  IMPORT TXID txid_from_heavy(H heavy);

  IMPORT H bitmap_prepare_heavy(EveryApi &ev, H bitmap_gen, int scanlines_per_slot);

  IMPORT H network_heavy(std::string url, std::string homepageurl, H timing_heavy);

  IMPORT H bitmap_heavy(BM bm, H timing);

  IMPORT H png_heavy(EveryApi &ev, H data, std::string url, int texture_unit);

  IMPORT H png_heavy2(EveryApi &ev, H net, std::string url, int texture_unit, int sx, int sy);

  IMPORT H mtl_heavy(EveryApi &ev, H net, std::string url_prefix, int texture_unit_delta);

  IMPORT H progressive_heavy(EveryApi &ev, std::string url, std::string url2);

  IMPORT H array_heavy(std::vector<H> vec);

  IMPORT H thread_heavy(H threaded);

  IMPORT H timing_heavy(int num_frames);

  IMPORT TXID dyn_fetch_bitmap(EveryApi& ev, std::string url, int time, int texture_unit);

  IMPORT TXID dyn_fetch_bitmap2(EveryApi &ev, std::string url, std::string url2, int time, int texture_unit, int sx, int sy, int sx2, int sy2);

  IMPORT std::vector<TXID> dyn_fetch_mtl(EveryApi &ev, std::string mtl_url, ML ml2);

  IMPORT ML txidarray_from_heavy(EveryApi &ev, H heavy, std::vector<TXID> *vec, ML ml, int start_range, int end_range, int heavycount);


  IMPORT IBM create_ibm(std::vector<BB> vec);

  IMPORT BB choose_bool(IBM bm, int val);

  IMPORT ARR choose_ints(IBM bm, int count);

private:

  BitmapApi(const BitmapApi&);

  void operator=(const BitmapApi&);

  void *priv;

  Env &e;

};


#endif


#ifdef F_FLOAT_API


class FloatApi

{

public:

  IMPORT FloatApi(Env &e);

  IMPORT F value(float v);

  IMPORT F ref(float *v);

  IMPORT F array_index(float *array, int pos);

  IMPORT float get_value(F f);

private:

  Env &e;

};


#endif


#ifdef F_ARRAY_API

template<class T>


class ArrayApi

{ // handle arrays

public:

  IMPORT ArrayApi(Env &e);

  A<T> array(std::vector<T> vec);

private:

  Env &e;

};


#endif


#ifdef F_FLOAT_ARRAY_API


class FloatArrayApi

{

public:

  IMPORT FloatArrayApi(Env &e);

  FA array(float *array, int size);

  FA f_array(F *array, int size);

  FA duparray(float value, int size);

  FA duparray(FA fa, int count);

  FA subarray(FA fa, int start_index, int length);

  FA ramp(float start_value, float end_value, int steps);

  F array_index(FA fa, int index);

  BM span_arrays(FA fa1, FA fa2, CBM f);

private:

  Env &e;

};


#endif


#ifdef F_FONT_API


class FontApi

{

public:

  IMPORT FontApi(Env &e);

  IMPORT ~FontApi();

  IMPORT BM outline_bm(FI font, std::string glyph);

  IMPORT BM outline_string(EveryApi &ev, FI font, std::string str);

  IMPORT void save_atlas_store_file(FtA atlas, std::string filename);

  IMPORT FtA load_atlas_from_string(std::string buf);

  IMPORT ARR FI_sprite_atlas(EveryApi &ev, FI font, std::string chars, int sx, int sy, int y_delta);

  IMPORT ARR FI_sprite_atlas_persistent_cache(EveryApi &ev, FtA atlas, BM atlas_bm, std::string atlas_filename, std::string atlas_bm_filename);

  IMPORT BM large_string_from_atlas(EveryApi &ev, FtA atlas, BM atlas_bm, std::string url, int x_gap, int empty_line_height, int baseline_separation);

  IMPORT FF span_key_fetcher(float start_x, float end_x, float speed_x, int down_key, int up_key);

  IMPORT ARR choose_screen(float left_x, float right_x, int min_screen, int max_screen);

  IMPORT IF quake_area_fetcher(float start_x, float end_x, float start_z, float end_z);

  IMPORT Ft newfont(std::string filename, int sx, int sy);

  IMPORT BM glyph(Ft font, long idx);

  IMPORT LI glyph_outline(Ft font, long idx, float sx, float sy);

  IMPORT PL glyph_plane(Ft font, long idx, float sx, float sy, float dx, float dy);

  IMPORT BM font_string(Ft font, std::string str, int x_gap);

  IMPORT FB glyph_fb(Ft font, long idx);

  IMPORT BB glyph_bb(Ft font, long idx);


  IMPORT BM render_glyph(GI glyph);

  IMPORT BM font_atlas_engine2(EveryApi &ev, FI font, FtA atlas, float sx, float sy);

  IMPORT FtA font_atlas_info_engine2(EveryApi &ev, FI font, std::string chars, float sx, float sy, int y_delta);


  IMPORT FtA font_atlas_info(EveryApi &ev,Ft font, std::string chars, float sx, float sy, int y_delta);

  IMPORT BM font_atlas(EveryApi &ev, Ft font, FtA atlas, float sx, float sy);

  IMPORT BM font_string_from_atlas(EveryApi &ev, FtA atlas, BM atlas_bm, std::string str, int x_gap);

  IMPORT P font_string_from_atlas_opengl_pipeline(EveryApi &ev, FtA atlas, BM atlas_bm, std::string str, int x_gap);

  IMPORT void save_atlas(FtA atlas, std::string filename);

  IMPORT FtA  load_atlas(std::string filename);

  IMPORT ARR font_string_array(Ft font, std::string s, int x_gap);

  IMPORT ARR font_string_array2(FI font, std::string s);

  IMPORT SF time_string_fetcher(EveryApi &ev);

  IMPORT SF score_string_fetcher(std::string id, std::string label, int numdigits); // use score_display instead.

  IMPORT IF char_fetcher_from_string(SF string_fetcher, std::string alternatives, int idx);

  IMPORT IF key_move_2_area_fetcher(float start_x, float end_x, float start_z, float end_z);

  IMPORT IF ready_fetcher(P p);

  IMPORT ML dynamic_character(EveryApi &ev, std::vector<BM> vec, IF fetcher, int x, int y);

  IMPORT FML dynamic_character_frame(EveryApi &ev, std::vector<BM> vec, IF fetcher, int x, int y, int fmt, MN mn);

  IMPORT ML dynamic_polygon(EveryApi &ev, std::vector<P> vec, MT material, IF fetcher);

  IMPORT ML dynamic_string(EveryApi &ev, Ft font, std::string alternative_chars, SF fetcher, int x, int y, int numchars);

  IMPORT FI load_font(std::string ttf_filename, int sx, int sy);

  IMPORT ML save_font_dump(FI font, std::string chars, std::string filename);

  IMPORT FI load_font_dump(std::string url);

  IMPORT GI choose_glyph_from_font(FI font, long idx);

  IMPORT GI combine_glyphs(GI glyph1, GI glyph2);

  IMPORT SD draw_text_string_sd(std::vector<GI> glyphs, std::string str, int gap_x, int empty_line_height);

  IMPORT BM string_display_to_bitmap(SD sd, int def);

  IMPORT BM draw_text_string(FI font, std::string str, int x_gap, int empty_line_height);

  IMPORT BM draw_text_large(EveryApi &ev, FI font, std::string url, int x_gap, int empty_line_height, int baseline_separation);

  IMPORT ML dynamic_character2(EveryApi &ev, std::vector<GI> vec, std::string alternatives, IF fetcher, int x, int y);

  IMPORT IF timed_int_fetcher(EveryApi &ev, int start, int end, float start_time, float end_time);

  IMPORT IF movement_int_fetcher(int count, float x_mult, float y_mult, float z_mult);

  IMPORT IF repeat_int_fetcher(IF fetcher, float duration);

  IMPORT IF toggle_button_fetcher(float start_x, float end_x, float start_y, float end_y);

  IMPORT IF hmd_state_fetcher();

  IMPORT IF keypress_int_fetcher(int key, int key_down_value, int key_up_value);

  IMPORT IF x_comp(PF point_fetcher, float start_x, float end_x, int num_steps);

  IMPORT IF y_comp(PF point_fetcher, float start_y, float end_y, int num_steps);

  IMPORT IF z_comp(PF point_fetcher, float start_z, float end_z, int num_steps);

  IMPORT PF point_fetcher_constant(float x, float y, float z);

  IMPORT PF point_fetcher_part(PF point_fetcher, int component, FF float_fetcher);

  IMPORT PF mouse_fetcher();

  IMPORT FF choose_float_fetcher(IF int_fetcher, float a_1, float a_2, float a_3, float a_4, float a_5, float a_6, float a_7);

  IMPORT FF fps_fetcher(EveryApi &ev);

  IMPORT FF time_fetcher2(EveryApi &ev);

  IMPORT FF time_range_fetcher(float start_time, float end_time, float before_start, float start_value, float end_value, float after_end, float repeat);

  IMPORT FF time_range_fetcher_key(int key, float start_time, float end_time, float before_start, float start_value, float end_value, float after_end, float repeat);

  IMPORT FF time_range_fetcher_state(int state, IF states, float start_time, float end_time, float before_start, float start_value, float end_value, float after_end, float repeat);

  IMPORT FF time_range_fetcher_state_key(int state, int key, IF if_state, float start_time, float end_time, float before_start, float start_value, float end_value, float after_end, float repeat);

  IMPORT IF score_fetcher(EveryApi &ev);

  IMPORT IF time_fetcher(EveryApi &ev, float start_time);

  IMPORT IF hmd_request_presenting(IF i);

  IMPORT SF float_to_string_fetcher(FF fetcher);

  IMPORT SF int_to_string_fetcher(IF fetcher);

  IMPORT ML ml_chooser(std::vector<ML> vec, IF fetcher);

  IMPORT std::vector<GameApi::BM> bm_array_id_inv(ARR arr);

  IMPORT ARR bm_array_id(std::vector<BM> vec);

private:

  FontApi(const FontApi&);

  void operator=(const FontApi&);

  void *priv;

  Env &e;

};


#endif


#ifdef F_ANIM_API


class AnimApi

{

public:

  IMPORT AnimApi(Env &e);

  IMPORT ~AnimApi();

  IMPORT IS single(int val, float duration);

  IMPORT IS single(PT point, float duration);

  IMPORT IS single(float val, float duration);

  IMPORT IS line(int val1, int val2, float duration);

  IMPORT IS line(PT p1, PT p2, float duration);

  IMPORT IS line(float val1, float val2, float duration);

  IMPORT IS line_obj(P p, P p2, float duration);


  IMPORT IS repeat(IS i, int count);

  IMPORT IS repeat_infinite(IS i);


  IMPORT int timed_value(IS i, float time);

  IMPORT PT timed_value_point(IS i, float time);

  IMPORT float timed_value_float(IS i, float time);


  IMPORT int timed_value_repeat_num(IS i, float time);

  IMPORT P timeline_obj(IS i, float time);


  IMPORT IS seq_line(IS *array, int size);

  IMPORT IS par_line(IS *array, int arraysize);

  IMPORT int timeline_int(IS l, int choose_par, float time);

  IMPORT float timeline_float(IS i, int choose_par, float time);

  IMPORT PT timeline_point(IS l, int choose_par, float time);

  IMPORT P timeline_obj(IS i, int choose_par, float time);

private:

  AnimApi(const AnimApi&);

  void operator=(const AnimApi&);


  void *priv;

  Env &e;

};


#endif


#ifdef F_EVENT_API


class EventApi

{

public:

  IMPORT EventApi(Env &e);

  IMPORT ~EventApi();

  E root_event();

  E timer(E activation_event, float time);

  E key_down_event(int key, E start_time, E end_time);

  E key_up_event(int key, E start_time, E end_time);

  E activate_mouse_plane(E activation_event, MP m);

  E deactivate_mouse_plane(E deactivation_event, MP m);

  E pair(E e1, E e2);

  E array(E *array, int size);

  L polygon(E start, E end, P polygon);

  L polygon(E start, E end, P start_polygon, P end_polygon);

  L bitmap(E start, E end, BM bitmap);

  L bitmap(E start, E end, BM start_bitmap, BM end_bitmap);

  L array(L *array, int size);

  M mouse_plane();

  M mouse_rectangle(MP m, int x, int y, int width, int height);

  M array(M *array, int size);

  MV point(float x, float y, float z);

  MV line(E start, E end, MV start_mv, MV end_mv, int start_choose, int end_choose);

  LL link(L obj, MV point);

  LL link(L obj, ID pointnum, MV point);

  LL array(LL *array, int size);

  ST states(int count_states);

  ST mouse_plane(ST states, int state, M mouse);

  ST activate_event(ST states, int state, E event);

  ST enable_obj(ST states, int state, LL link);

  ST disable_obj(ST states, int state, LL link);

  E state_change(E event, int old_state, int new_state);

  void run_game(ST states, int start_state);

  std::string Serialize(ST states, int start_state);

  ST UnSerialize(std::string s);

private:

  EventApi(const EventApi&);

  void operator=(const EventApi&);

  void *priv;

  Env &e;

};


#endif


#if 0

class CurvePathApi

{

public:

  CD constant(float time, float val);

  CD linear_move(CD prev, float time, float delta);

  CD quadratic_move(CD prev, float time, float delta_pos, float end_delta_pos);

  CD cos_circular_move(float time, float center, float radius, float start_angle, float end_angle);

  CD sin_circular_move(float time, float center, float radius, float start_angle, float end_angle);

  CD cd_time_seq(CD a1, CD a2);

  CD cd_time_seq_arr(std::vector<CD> vec);

  CD cd_repeat(CD cd);


  CP xyz_combine(CD x, CD y, CD z);

  CP cp_time_seq(CP a1, CP a2);

  CP cp_time_seq_arr(std::vector<CP> vec);

  CP cp_repeat(CP cp);

  MN cp_to_movement(CP cp);

};

#endif


#ifdef F_CURVE_API


class CurveApi

{

public:

  IMPORT CurveApi(Env &e);

  IMPORT C line(PT p1, PT p2);

  IMPORT C circle_xy(PT center, float r);

  IMPORT C circle_xz(PT center, float r);

  IMPORT C circle_xy_wave(float start_r, float end_r, WV wave, float length);

  IMPORT C linear(std::vector<PT> vec);

  IMPORT C bezier(std::vector<PT> vec);


  IMPORT C scale(C curve, float mx, float my, float mz);

  IMPORT C trans(C curve, float dx, float dy, float dz);

  //C constantspeed(C curve, float speed);

  IMPORT C compose(std::vector<C> vec);

  //C plane(C curve2d, PT pos, PT u_x, PT u_y);

  IMPORT C change_length(C curve, float new_length);

  IMPORT C split(C orig_curve, float start_var, float end_var);


  IMPORT PA curve_product(C c1, C c2, PT c2_center);

  IMPORT P patch_sample(PA patch, int sx, int sy);

  IMPORT C x_curve(PA patch, float y);

  IMPORT C y_curve(PA patch, float x);


  IMPORT PT pos(C curve, float p);


  IMPORT PTS sample(C input_curve, int num_samples);

  IMPORT LI to_lines(C curve, int num_lines);

  IMPORT CG curve_group_from_lines(LI li);

  IMPORT LI lines_from_curve_group(CG curvegroup, int split);

  // curve_pos

  IMPORT CPP xy_sum();

  IMPORT CPP xy_sum2(float xmult, float ymult, float zmult);

private:

  Env &e;

};


#endif


#ifdef F_MATRIX_CURVE_API


class MatrixCurveApi

{

public:

  IMPORT MatrixCurveApi(Env &e);

  IMPORT MC from_curve(C curve);

  IMPORT MC circle_xy(float radius);

  IMPORT MC circle_xz(float radius);

  IMPORT MS sample(MC m_curve, int num);

private:

  Env &e;

};


#endif


#ifdef F_CURVES_API


class CurvesApi

{

public:

  IMPORT CurvesApi(Env &e);

  CC start(PTS points);

  CC comb(CC prev, PTS points);

  PTS extract(CC curves, int block, float val);

private:

  Env &e;

};


#endif


#ifdef F_FUNCTION_API


class FunctionApi

{

public:

  IMPORT FunctionApi(Env &e);

  IMPORT ~FunctionApi();

  F constant(float y);

  F sin();

  F cos();

  F line_from_bm_x(BM bm, int bm_x, float length);

  F line_from_bm_y(BM bm, int bm_y, float length);

  F curve_x(C c);

  F curve_y(C c);

  F curve_z(C c);

  F line(float x, float y, float x2, float y2, float begin_y, float end_y);


  float get_value(F f, float x);


  F change_range(F orig, F replace, float x_start, float x_end);

  F move_x(F orig, float delta);

  F move_y(F orig, float delta);

  F max(F orig, F orig2);

  F min(F orig, F orig2);

  F scale_y(F orig, float old_min_y, float old_max_y, float new_min_y, float new_max_y);


  F deriv(F f);

  F integrate(F f);

  std::vector<PT> equalizer(F f1, F f2, float start, float length);

  //float pullback(F a_f, F b_f, F p_a, F p_b, F f_p, float t_0, float t_1);

private:

  FunctionApi(const FunctionApi&);

  void operator=(const FunctionApi&);


  Env &e;

  void *priv;

};


#endif


#ifdef F_SPACE_API


class SpaceApi

{

public:

  IMPORT SpaceApi(Env &e);

  ~SpaceApi();

  SP rotatespace(SP s, float angle);

  SP rotatespace(SP s, PT center, float angle);

  //SP rotatespace(SP s, float center_x, float center_y, float angle);

  SP translatespace(SP s, float x, float y);

  SP scalespace(SP s, float scale_x, float scale_y);

  SP moveorigo(SP s, float x, float y);

  float sizex(SP s);

  float sizey(SP s);

  float origo_x(SP s);

  float origo_y(SP s);

  PT pos(SP sp, float x, float y, float z = 0.0); // x = (0..sizex), y=(0..sizey)

  PT posN(SP sp, float x, float y, float z=0.0); // x = (0..1), y = (0..1)

  float pt_x(PT p);

  float pt_y(PT p);

  float pt_z(PT p);

  PT plus(PT p1, PT p2);

private:

  SpaceApi(const SpaceApi&);

  void operator=(const SpaceApi&);

  Env &e;

};


#endif


#ifdef F_DUP_API


class DupApi

{

public:

  IMPORT DupApi(Env &e);

  ~DupApi();

  BM dup_bm(BM b);

  SP dup_sp(SP s);

  PT dup_pt(PT p);

  LN dup_ln(LN l);

  RM dup_rm(RM r);

  IS dup_is(IS i);

};


#endif


#ifdef F_TEXT_API


class TextApi

{

public:

    TextApi(BitmapApi &bm, SpriteApi &sp) : bm(bm), sp(sp), priv(0) { }

    IMPORT ~TextApi();

    IMPORT void load_font(std::string filename, int sx, int sy, int x, int y, char start_char, char end_char);

    IMPORT void draw_text(std::string text, int x, int y, SH sh);

private:

  TextApi(const TextApi&);

  void operator=(const TextApi&);

  BitmapApi &bm;

  SpriteApi &sp;

  void *priv;

  int sx,sy;

  char start_char, end_char;

};


#endif


#ifdef F_IMPLICIT_API


class ImplicitApi

{

public:

  IMPORT ImplicitApi(Env &e);

  IMPORT IM im_sphere(float r);

  IMPORT IM blob(float c, float c_x, float c_y, float cc_x, float cc_y);

  IMPORT IM im_translate(IM obj, float dx, float dy, float dz);

  IMPORT IM from_distance(FD fd, float pos_x, float pos_y, float pos_z, float u_x, float u_y, float u_z, float sx, float sy);

  IMPORT IM from_distance_cyl(FD fd, float pos_x, float pos_y, float pos_z, float u_x, float u_y, float u_z, float sx, float sy);

  IMPORT IM from_distance_sph(FD fd, float pos_x, float pos_y, float pos_z, float u_x, float u_y, float u_z, float sx, float sy);

  IMPORT FB render_upper(IM obj, float size_x, float size_y, int sx, int sy, float dx, float dy);

  IMPORT FB render_lower(IM obj, float size_x, float size_y, int sx, int sy, float dx, float dy);


  IMPORT BM render_upper_color(IM obj, float size_x, float size_y, int sx, int sy, float dx, float dy);

  IMPORT BM render_lower_color(IM obj, float size_x, float size_y, int sx, int sy, float dx, float dy);

private:

  Env &e;

};


#endif


#ifdef F_VOLUME_API


class VolumeApi

{

public:

  IMPORT VolumeApi(Env &e);

    IMPORT ~VolumeApi();

  IMPORT O bounding_x(O next, O next2, float x);

  IMPORT O bounding_y(O next, O next2, float y);

  IMPORT O bounding_z(O next, O next2, float z);

  IMPORT O bounding_sphere(O next, float cx, float cy, float cz, float radius);

  IMPORT BB volumeprojection(O o, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, int sx, int sy, int numsamples);

  IMPORT O boolfunction(std::function<bool(float x, float y, float z)> f);

    IMPORT O subvolume(std::function<float(float x, float y, float z)> f, float start_range, float end_range);

  IMPORT PTS random_vol_object(O o, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, int numpoints);

  IMPORT O from_polygon(P p, float x, float y, float z);  // point outside of shape.

        IMPORT O from_bool_bitmap(BB b, float dist);

    IMPORT O link_areas(O o, PT p1, PT p2, float d);

  IMPORT O o_sphere(float center_x, float center_y, float center_z, float radius);

    IMPORT O o_cube(float start_x, float end_x,float start_y, float end_y,float start_z, float end_z);

    IMPORT O o_cone(PT p1, PT p2, float rad1, float rad2);

    IMPORT O o_torus(PT center, PT u_x, PT u_y, float dist1, float dist2);


  IMPORT O instancing_volume(O o, PTS p);

    IMPORT O colour(O object, unsigned int col);

    IMPORT O reflect(O object, float val); // val = [0..1]

    IMPORT O cubetexture(O object, PT origo, PT u_x, PT u_y, PT u_z, BM bm);

    IMPORT O spheretexture(O object, PT center, BM texture, float multx, float multy);

  IMPORT O subset_color(O model, O color_subset, unsigned int color);


  //IMPORT O move(O object, PT pos);

        IMPORT O move(O obj, float dx, float dy, float dz);

    IMPORT O rotatex(O object, float angle);

    IMPORT O rotatey(O object, float angle);

    IMPORT O rotatez(O object, float angle);

    IMPORT O scale(O object, float sx, float sy, float sz);


    IMPORT O not_op(O object1);

    IMPORT O min_op(O object1, O object2);

    IMPORT O max_op(O object1, O object2);

    IMPORT O andnot_op(O object1, O object2);


    IMPORT O mandelbulb(float n, float p_x, float p_y, float p_z,float c_x, float c_y, float c_z,float radius,int iterations);

  IMPORT O mandelbrot_volume(bool julia, int count, float yy);


    IMPORT BB plane(O o, int sx, int sy,PT u_p, V u_x, V u_y,float start_x, float end_x,float start_y, float end_y,float start_z, float end_z);


    IMPORT BM render(O object, int sx, int sy, PT ray_0, PT ray_x, PT ray_y, PT ray_z);

  typedef std::function<P (float start_x, float end_x,

            float start_y, float end_y,

            float start_z, float end_z,

            unsigned int color)> fptrtype;

  IMPORT P rendercubes(O object,fptrtype fptr,int size,float wholesize); // marching cubes algo

  IMPORT PTS instanced_positions(O object,int size,float wholesize);


  IMPORT P rendercubes2(EveryApi &ev, O object,fptrtype fptr,int sx, int sy, int sz,float world_x, float world_y, float world_z); // normal for loop algo

  IMPORT P rendercubes3(O object,int sx, int sy, int sz,float start_x, float end_x,float start_y, float end_y,float start_z, float end_z);

  IMPORT PTS instanced_positions(O object,int sx, int sy, int sz,float start_x, float end_x,float start_y, float end_y, float start_z, float end_z);

  IMPORT void find_surface(O object, PT p1, PT p2, PT *res1, PT *res2, int level);

  // use RayTracingBitmap class in graph.hh

  // problem1: float values in O. (currently uses bool)

  // problem2: colors in O.

  // problem3: conversion from volumeobject to continuousvoxel<float> and continuousvoxel<color> (something like that exists already)

  // BM raytrace(O volume, int sx, int sy, V v, float z);  IMPORT BM montecarlo(O object, PT p_top, PT p_x, PT p_y, PT p_z, int sx, int sy);

private:

  VolumeApi(const VolumeApi&);

  void operator=(const VolumeApi&);


  Env &e;

};


#endif


#ifdef F_SHADER_MODULE_API


class ShaderModuleApi

{

public:

  IMPORT ShaderModuleApi(Env &e);

  IMPORT SFO empty();

  IMPORT SFO function(std::function<std::string (std::string id)> function, std::string function_name, std::vector<std::string> param_names = std::vector<std::string>(), std::vector<std::string> arg_values = std::vector<std::string>());

  IMPORT SFO color_function(SFO orig, std::function<std::string (std::string)> function, std::string function_name);

  IMPORT SFO sphere(); // vec3 center, float radius

  IMPORT SFO sphere(PT center, float radius); // ()

  IMPORT SFO cube(); // vec3 tl, vec3 br

  IMPORT SFO cube(float start_x, float end_x,float start_y, float end_y,float start_z, float end_z); // ()

  IMPORT SFO rounded_cube(float start_x, float end_x,float start_y, float end_y,float start_z, float end_z,float r);

  IMPORT SFO texture(SFO obj);

  IMPORT SFO texture_box(float start_x, float end_x,float start_y, float end_y,float start_z, float end_z);

  IMPORT SFO line(); // vec3 tl, vec3 br, float line_width1, float line_width2

  IMPORT SFO line(float start_x, float start_y, float start_z,float end_x, float end_y, float end_z,float line_width1, float line_width2);

  IMPORT SFO plane(PT center, V u_x, V u_y);

  IMPORT SFO torus(float radius_1, float radius_2);

  IMPORT SFO color(SFO obj, float r, float g, float b, float a);

  IMPORT SFO rot_x(SFO obj, float angle);

  IMPORT SFO rot_y(SFO obj, float angle); // float angle

  IMPORT SFO rot_z(SFO obj, float angle);

  IMPORT SFO rot_x(SFO obj, float angle, PT center);

  IMPORT SFO rot_y(SFO obj, float angle, PT center);

  IMPORT SFO rot_z(SFO obj, float angle, PT center);

  IMPORT SFO mod_x(SFO obj, float dx);

  IMPORT SFO mod_y(SFO obj, float dy);

  IMPORT SFO mod_z(SFO obj, float dz);

  IMPORT SFO and_not(SFO obj, SFO not_obj);

  IMPORT SFO or_elem(SFO obj1, SFO obj2);

  IMPORT SFO blend(SFO obj1, SFO obj2, float k);

  IMPORT SFO trans(SFO obj);

  IMPORT SFO trans(SFO obj, float dx, float dy, float dz);

  IMPORT SFO scale(SFO obj);

  IMPORT SFO scale(SFO obj, float sx, float sy, float sz);

  IMPORT SFO from_points(PTS p, SFO obj);

  IMPORT SFO from_lines(LI li, SFO obj);

  IMPORT SFO bind_arg(SFO obj, std::string name, std::string value);

  IMPORT SFO color_from_normal(SFO obj);

  IMPORT SFO grayscale_from_distance(SFO obj, SFO dist, float length);

  IMPORT SFO stop_generation(SFO obj);

  IMPORT SFO mix_color(SFO col1, SFO col2, float t); // kills obj side

  IMPORT SFO grayscale(SFO obj);

  IMPORT SFO noise(SFO obj, float strength);

  IMPORT SFO ambient_occulsion(SFO obj, float d, float i);

  IMPORT SFO soft_shadow(SFO scene, V light_dir, float mint, float maxt, float k, float strong);

  IMPORT SFO bounding_primitive(SFO prim, SFO inside, SFO outside);

  IMPORT SFO spherical(SFO obj, PT tl, PT br, float rr, float rp);

  IMPORT SFO render(SFO obj);

  IMPORT SFO v_render(SFO obj);

  IMPORT SFO f_render_color(SFO obj);

  IMPORT SFO color_from_position(SFO obj, float sx, float sy, float sz);

  IMPORT SFO colormod_from_position(SFO obj, float px, float py, float pz, float sx, float sy, float sz);

  IMPORT ML sfo_to_ml(EveryApi &ev, SFO sfo, float sx, float sy);

private:


  Env &e;

};


#endif


#ifdef F_INTERACTION_API


class InteractionApi

{

public:


  struct Wasd_data {

    bool up=false;

    bool down=false;

    bool left=false;

    bool right=false;

  };


  IMPORT static void wasd_movement_event(MainLoopApi::Event &e,

                float &pos_x, float &pos_y, Wasd_data &data,

                float speed_x, float speed_y);

  IMPORT static void wasd_movement_frame(MainLoopApi::Event &e,

                float &pos_x, float &pos_y, Wasd_data &data,

                float speed_x, float speed_y);


  struct Quake_data {

    bool forward=false;

    bool backward=false;

    bool left=false;

    bool right=false;

    bool side_left=false;

    bool side_right=false;

    float old_pos_x=0.0;

    float old_pos_y=0.0;

    bool mv_mode= false;

  };


  IMPORT static void quake_movement_event(GameApi::EveryApi &ev, MainLoopApi::Event &e,

                 float &pos_x, float &pos_y, float &rot_y,

                 Quake_data &data,

                 float &speed_x, float &speed_y, float speed, float rot_speed);

  IMPORT static void quake_movement_frame(GameApi::EveryApi &ev,

                 float &pos_x, float &pos_y, float &rot_y,

                 Quake_data &data,

                 float &speed_x, float &speed_y, float speed, float rot_speed);

};


#endif


#ifdef F_PICKING_API


class PickingApi

{

public:

  IMPORT PickingApi(Env &e);

  BB pick_area(EveryApi &ev, float mouse_x, float mouse_y, float radius, int scr_size_x, int scr_size_y);

  O pick_volume(M in_P, BB pick);

  bool picked( O o, float x, float y, float z);

private:

  Env &e;

};


#endif


#ifdef F_TREE_API


class TreeApi

{

public:

  IMPORT TreeApi(Env &e);

  IMPORT TL level(std::vector<MN> vec);

  IMPORT T tree(std::vector<TL> vec);

  IMPORT ML tree_ml(EveryApi &ev, T tree, std::vector<ML> vec);

  IMPORT P tree_p(EveryApi &ev, T tree, std::vector<P> vec, float time, float percentage);

  IMPORT MS tree_ms(EveryApi &ev, T tree, float time);

private:

  Env &e;

};


#endif


#ifdef F_MATERIALS_API


class MaterialsApi

{

public:

  IMPORT MaterialsApi(Env &e);

  IMPORT MT choose_material(EveryApi &ev,int i);

  IMPORT MT reload_material(EveryApi &ev, MT next, std::string name, P default_p, MT default_mat);

  IMPORT MT acesfilm_material(EveryApi &ev, MT next);

  IMPORT MT discard_material(EveryApi &ev, MT next);

  IMPORT MT hires(EveryApi &ev, MT mat, int size, int numsampled, float blur_radius);

  IMPORT MT mt_empty(EveryApi &ev);

  IMPORT MT mt_alt(EveryApi &ev, std::vector<MT> v, int index);

  IMPORT MT progressmaterial(MT nxt, void (*fptr)(void*), void*data);

  IMPORT SMT ss_def(EveryApi &ev);

  IMPORT SMT screenspace_bloom(EveryApi &ev, SMT next, float cut_x, float cut_y, float cut_z, float x_amount, float y_amount);

  IMPORT SMT generic_screenspace_material00(EveryApi &ev, SMT next, SHI vertex, SHI fragment);

  IMPORT MT phong3_material(EveryApi &ev, MT next, unsigned int ambient, unsigned int highlight, float pow);

  IMPORT MT generic_shader_material00(EveryApi &ev, MT next, SHI vertex, SHI fragment, std::vector<TXID> vec);

  IMPORT MT generic_shader_material0(EveryApi &ev, MT next, std::string, std::string, std::string);

  IMPORT MT generic_shader_material1(EveryApi &ev, MT next, SHP params, std::string, std::string, std::string);

  IMPORT MT generic_shader_material2(EveryApi &ev, MT next, SHP params, std::string, std::string, std::string, std::vector<SHI>);

  IMPORT MT gltf_material_from_file(EveryApi &ev, std::string url, float light_dir_x, float light_dir_y, float light_dir_z);

  IMPORT MT transparent_material(EveryApi &ev, BM bm, MT next, bool is_transparent);

  IMPORT MT m_keys(EveryApi &ev, std::vector<MT> vec, std::string keys);

  IMPORT MT gltf_anim_material(EveryApi &ev, TF model0, int skin_num, int animation, int num_timeindexes, MT next, int key, int mode, TRA anim_transfer_id, int frame_skip);

  IMPORT MT gltf_anim_material2(EveryApi &e, TF model0, int skin_num, int num_timeindexes, MT next, std::string keys,int mode, TRA anim_transfer_id, int frame_skip);

  IMPORT MT toon_border(EveryApi &ev, MT next, float border_width, unsigned int color, bool is_gltf);

  IMPORT ARR material_pack_1(EveryApi &ev);

  IMPORT MT m_def(EveryApi &ev);

  IMPORT MT skeletal(EveryApi &ev);

  IMPORT MT texture(EveryApi &ev, BM bm, float mix);

  IMPORT MT textureid(EveryApi &ev, TXID txid, float mix);

  IMPORT MT texture_many(EveryApi&ev, std::vector<BM> vec, float mix);

  IMPORT MT colour_material(EveryApi &ev, float mix, bool color_from_pts=false);

  IMPORT MT many_texture_id_material(EveryApi &ev, std::string mtl_url, std::string url_prefix, float mix, int start_range, int end_range);

  IMPORT MT texture_cubemap(EveryApi&ev, std::vector<BM> vec, float mix, float mix2);

  IMPORT MT texture_many2(EveryApi &ev, float mix);

  IMPORT MT texture_arr(EveryApi &ev, std::vector<BM> vec, int sx, int sy, float mix);

  IMPORT MT gltf_material( EveryApi &ev, TF model0, int material_id, float mix, float self_mult, float rest_mult, float light_dir_x, float light_dir_y, float light_dir_z, bool emissive, int lod_level=-1 );

  IMPORT MT gltf_material_manual( EveryApi &ev, float mix,float self_mult, float rest_mult, BM, BM, BM,BM,BM,bool,bool,bool,bool,bool,float,float,float,float,float,float,float, float light_dir_x, float light_dir_y, float light_dir_z );

  IMPORT MT gltf_material_env( EveryApi &ev, TF model0, int material_id, float mix, BM diffuse_env, BM specular_env, BM bfrd);

  IMPORT MT gltf_material3( EveryApi &ev, float roughness, float metallic, float base_r, float base_g, float base_b, float base_a, float mix, float self_mult, float rest_mult, float light_dir_x, float light_dir_y, float light_dir_z, bool emissive);

  IMPORT MT glow_edge(EveryApi &ev, MT next, float light_level, float gray_level, float edge_pos);

  IMPORT MT water(EveryApi &ev, MT next, unsigned int color1, unsigned int color2, unsigned int color3, float center_x, float center_y, float center_z, float wave_mult, float time_mult);


  IMPORT MT adjust(EveryApi &ev, MT nxt, unsigned int ad_color, float ad_dark, float ad_light);


  IMPORT MT phong(EveryApi &ev, MT nxt, float light_dir_x, float light_dir_y, float light_dir_z, unsigned int ambient, unsigned int specular, unsigned int highlight, float pow);

  IMPORT MT phong2(EveryApi &ev, MT nxt, float light_dir_x, float light_dir_y, float light_dir_z, unsigned int ambient, unsigned int specular, unsigned int highlight, float pow);

  IMPORT MT vertex_phong(EveryApi &ev, MT nxt, float light_dir_x, float light_dir_y, float light_dir_z, unsigned int ambient, unsigned int highlight, float pow, float mix);

  IMPORT ARR m_apply_phong(EveryApi &ev, std::vector<MT> vec, float light_dir_x, float light_dir_y, float light_dir_z, unsigned int ambient, unsigned int specular, unsigned int highlight, float pow);

  IMPORT ARR p_dup(EveryApi &ev, P obj, int count);

  IMPORT ARR m_dup(EveryApi &ev, MT mat, int count);

  IMPORT ARR m_apply_phong_color(EveryApi &ev, std::vector<MT> vec, std::vector<P> vec2, float light_dir_x, float light_dir_y, float light_dir_z, float ambient_mult, float specular_mult, float highlight_mult, float pow);

  IMPORT MT edge(EveryApi &ev, MT nxt, float edge_width, unsigned int edge_color);

  IMPORT MT gi(EveryApi &ev, MT nxt, PTS points, float obj_size);

  IMPORT MT bump_phong(EveryApi &ev, float light_dir_x, float light_dir_y, float light_dir_z, unsigned int ambient, unsigned int highlight, float pow, FB bm, float bump_width);

  IMPORT MT fog(EveryApi &ev, MT nxt, float fog_dist, unsigned int dark_color, unsigned int light_color);

  IMPORT MT shadow(EveryApi &ev, P p, std::vector<BM> vec, float p_x, float p_y, float p_z, int sx, int sy, unsigned int dark_color, float mix, float mix2);

  IMPORT MT shadow2(EveryApi &ev, P p, float p_x, float p_y, float p_z, int sx, int sy, unsigned int dark_color, float mix, float mix2, int numtextures);

  IMPORT MT newshadow(EveryApi &ev, MT nxt, P models, float light_dir_x, float light_dir_y, float light_dir_z, float dark_level, float light_level, float scale, int size, bool is_phong, int texindex, MT shadow_mt);

  IMPORT ML newshadow2_phong(EveryApi &ev, P models, MT model_mt, P shadow_mesh, MT shadow_mt, float light_dir_x, float light_dir_y, float light_dir_z, float dark_level, float light_level, unsigned int ambient_color, unsigned int dark_color, unsigned int light_color, float scale, int size, bool draw_model, MT shadow2_mt);

  IMPORT ML newshadow2_gltf(EveryApi &ev, TF I1, P shadow_p, MT shadow_mt, float light_dir_x, float light_dir_y, float light_dir_z, float dark_level, float light_level, unsigned int ambient_color, unsigned int dark_color, unsigned int light_color, float scale, int size, MT shadow2_mt, bool emissive);

  IMPORT ML gltf_newshadow2(EveryApi &ev, P models, MT model_mt, P shadow_mesh, MT shadow_mt, float light_dir_x, float light_dir_y, float light_dir_z, float dark_level, float light_level, float scale, int size, TF tf);

  IMPORT MT dyn_lights(EveryApi &ev, MT nxt, float light_pos_x, float light_pos_y, float light_pos_z, float dist, MN dyn_point);

  IMPORT MT coloured_lights(EveryApi &ev, MT nxt, float scale,

                unsigned int color_1, unsigned int color_2, unsigned int color_3, unsigned int color_4, unsigned int color_5, unsigned int color_6, unsigned int color_7, unsigned int color_8,

                PT pos_1, PT pos_2, PT pos_3, PT pos_4, PT pos_5, PT pos_6, PT pos_7, PT pos_8,

                float dist_1, float dist_2, float dist_3, float dist_4, float dist_5, float dist_6, float dist_7, float dist_8);

  IMPORT MT snow(EveryApi &ev, MT nxt, unsigned int color1=0xffaaaaaa, unsigned int color2=0xffeeeeee, unsigned int color3=0xffffffff, float mix_val=0.5f);

  IMPORT MT shading1(EveryApi &ev, MT nxt, float mix_val, float mix_val2);

  IMPORT MT shading2(EveryApi &ev, MT nxt, unsigned int color1, unsigned int colo2, unsigned int color3);

  IMPORT MT flat(EveryApi &ev, MT nxt, unsigned int color1, unsigned int color2, unsigned int color3);

  IMPORT MT fur(EveryApi &ev, MT nxt, PT center, float dist, float max_angle, int count, float size, int cone_numfaces);

  IMPORT MT noise(EveryApi &ev, int sx, int sy, int r, int g, int b, int a, int r2, int g2, int b2, int a2, float mix);


  IMPORT MT choose_color(EveryApi &ev, MT nxt, unsigned int color, float mix_val);

  IMPORT MT brashmetal(EveryApi &ev, MT nxt, int count, bool web);

  IMPORT MT marble(EveryApi &ev, MT nxt, int count, float cubesize);

  IMPORT MT web(EveryApi &ev, MT nxt, float val=1.01, float linewidth=2.0, unsigned int color=0xff000000); // TODO: add line width property

  IMPORT MT bevel(EveryApi &ev, MT nxt, float dir, float linewidth);

  IMPORT MT bloom(EveryApi &ev, MT nxt, BM bm, float r_cut, float g_cut, float b_cut, float pixel_x, float pixel_y);

  IMPORT MT dist_field_mesh(EveryApi &ev, SFO sfo, MT next);


  IMPORT MT mesh_color_from_sfo(EveryApi &ev, SFO sfo, MT next);


  IMPORT MT sfo_sandbox(EveryApi &ev, SFO sfo, MT next);

  IMPORT MT combine_materials(EveryApi &ev, MT mat1, MT mat2);


  IMPORT MT fade(EveryApi &ev, MT next, float start_time, float end_time, float start_time2, float end_time2);


  IMPORT ML bind(P p, MT mat);

  IMPORT ML bind_inst(P p, PTS pts, MT mat);

  IMPORT VA bind_inst_va_prepare(P p, MT mat);

  IMPORT ML bind_inst_va(VA va, PTS pts, MT mat, float level);

  IMPORT ML bind_inst_matrix(P p, MS ms, MT mat);

  IMPORT ML bind_inst2(P p, PTA pta, MT mat);

  IMPORT ML bind_inst_fade(P p, PTS pts, MT mat, bool flip, float start_time, float end_time);

  IMPORT ML render_instanced_ml(EveryApi &ev, P p, PTS pts, bool color_from_pts=false);

  IMPORT ML render_instanced_ml_matrix(EveryApi &ev, P p, MS pts, bool color_from_matrix=false);

  IMPORT ML render_instanced_ml_fade(EveryApi &ev, P p, PTS pts, bool flip, float start_time, float end_time, bool color_from_pts=false);

  IMPORT ML render_instanced_ml_texture(EveryApi &ev, P p, PTS pts, std::vector<BM> vec, std::vector<int> types=std::vector<int>(), std::vector<std::string> id_labels=std::vector<std::string>(), std::vector<bool> is_srgb=std::vector<bool>());

  IMPORT ML render_instanced_ml_texture_id(EveryApi &ev, P p, PTS pts, std::vector<TXID> *vec);

  IMPORT ML render_instanced_ml_cubemap(EveryApi &ev, P p, PTS pts, std::vector<BM> vec);

  IMPORT ML render_instanced_ml_texture2(EveryApi &ev, P p, PTS pts);

  //--

  IMPORT ML render_instanced_ml_texture_matrix(EveryApi &ev, P p, MS pts, std::vector<BM> vec, std::vector<int> types=std::vector<int>(), std::vector<std::string> id_labels=std::vector<std::string>(), std::vector<bool> is_srgb=std::vector<bool>());

  IMPORT ML render_instanced_ml_texture_id_matrix(EveryApi &ev, P p, MS pts, std::vector<TXID> *vec);

  IMPORT ML render_instanced_ml_cubemap_matrix(EveryApi &ev, P p, MS pts, std::vector<BM> vec);

  IMPORT ML render_instanced_ml_texture2_matrix(EveryApi &ev, P p, MS pts);

  //--


  IMPORT ML render_instanced_ml_fade_texture(EveryApi &ev, P p, PTS pts, bool flip, float start_time, float end_time, std::vector<BM> vec);

  IMPORT ML render_instanced2_ml(EveryApi &ev, VA va, PTA pta, bool color_from_pts=false);

  IMPORT ML render_instanced2_ml_texture(EveryApi &ev, VA va, PTA pta, std::vector<BM> vec);

  IMPORT ML render_instanced2_ml_texture2(EveryApi &ev, VA va, PTA pta);

  IMPORT ML render_instanced2_ml_texture_id(EveryApi &ev, VA va, PTA pta, std::vector<TXID> *vec);

  IMPORT ML render_instanced2_ml_matrix(EveryApi &ev, VA va, MSA pta);

  IMPORT ML render_instanced2_ml_fade(EveryApi &ev, VA va, PTA pta, bool flip, float start_time, float end_time);

  //ML snow(EveryApi &ev, P p);

  //ML web(EveryApi &ev, P p);

private:

  Env &e;

};


#endif


#ifdef F_INPUT_API


class InputApi

{

public:

  IMPORT InputApi(Env &e);


private:

  Env &e;

};


#endif


#ifdef F_PHYSICS_API


class PhysicsApi

{

public:

  IMPORT PhysicsApi(Env &e);

  struct PHI { PH phy; int id; };

  IMPORT PH phy_empty();

  IMPORT PHI anchor_point(PH phy, PT pos);

  PH anchor_point2(PH phy, PT pos) { PHI pp = anchor_point(phy,pos); return pp.phy; }

  IMPORT PH ext_force(PH phy, int point, V dir);

  IMPORT PH ext_force_all(PH phy, V dir);

  IMPORT PH anchor_link(PH phy, int p1, int p2, float dist);

  IMPORT PH force_obj(PH phy, O obj,

           V dir);

  IMPORT PH phy_from_p(P p);

  // PH gameover_obj(PH phy, O obj, int point)

  // PH keypress_force(PH phy, int point, V dir, int key);

  //PH array(PH *arr, int size);


  IMPORT int num_anchors(PH phy);

  IMPORT int num_forces(PH phy, int anchor);

  IMPORT int num_links(PH phy);

  IMPORT int num_force_volumes(PH phy);


  IMPORT PTS init_points(PH pos);

  IMPORT void step_points(PH phy, PTA prev_frame, float timestep);

  IMPORT PTS physics_action(EveryApi &ev, PH phy);

private:

  Env &e;

};


#endif


#ifdef F_COLLISION_PLANE


class CollisionPlane

{

public:

  IMPORT CollisionPlane(Env &e);

  IMPORT CP circle(int id, float radius);

  IMPORT CP rectangle(int id, float x, float y, float sx, float sy);

  IMPORT CP or_elem(int id, std::vector<CP> vec);

  IMPORT void set_pos(CP plane, int id, float x, float y);

  IMPORT bool check_collision(CP plane, float x, float y);

private:

  Env &e;

};


#endif


#ifdef F_SKELETAL


class Skeletal

{

public:

  IMPORT Skeletal(Env &e);

  SA root(PT absolute_pos);

  SA node(SA parent, MN matrix, PT point_offset);

  ML skeletal_bind(EveryApi &ev, std::vector<P> vec, std::vector<PT> vec2, std::vector<SA> sa_vec);

  ML skeletal_bind_material(EveryApi &ev, std::vector<P> vec, std::vector<PT> vec2, std::vector<SA> sa_vec, MT material);

private:

  Env &e;

};


#endif


class VertexAnimApi

{

public:

  IMPORT VertexAnimApi(Env &e);

  IMPORT KF keyframe_mesh(P part);

  IMPORT KF keyframe_lines(LI part);

  IMPORT KF keyframe_bind(EveryApi &ev, KF keyframe, PTT pointtransform, float delta_time);

  IMPORT KF keyframe_bind2(EveryApi &ev, KF keyframe, PTT pointtransform, float delta_time, bool dif);

  IMPORT KF curve_trans(EveryApi &ev, KF kf, C curve, CPP pos, int numsamples, float duration);

  IMPORT KF repeat_keyframes(KF rep, int count);


  IMPORT KF sample_rot(EveryApi &ev, KF kf, float nx, float ny, float nz, float angle, int numsamples, float duration);


  //KF keyframe_bind2(KF keyframe, O subpart, PTT pointtransform, float delta_time);

  IMPORT PTT empty_trans();

  IMPORT PTT curve_accessor(C curve, CPP pos, float start_pos, float time_mult);

  IMPORT PTT rot_accessor(float start_time, float time_mult, float nx, float ny, float nz, float dist_angle);

  IMPORT PTT translate_trans(PTT prev, float speed_x, float speed_y, float speed_z);

  IMPORT PTT translate_trans2(PTT prev, float duration,float dist_x, float dist_y, float dist_z);

  IMPORT PTT rotate_trans(PTT prev, float nx, float ny, float nz, float speed_angle);

  IMPORT PTT rotate_trans2(PTT prev, float duration,float nx, float ny, float nz, float dist_angle);

  IMPORT PTT scale_trans(PTT prev, float scale_speed_x, float scale_speed_y, float scale_speed_z);

  IMPORT PTT scale_trans2(PTT prev, float duration,float scale_dist_x, float scale_dist_y, float scale_dist_z);

  IMPORT ML vertex_anim_render(EveryApi &ev, KF kf);

public:

  IMPORT P change_pos(P p, P orig, PTT transform, float delta_time, bool dif);

  IMPORT LI change_pos_li(LI p, LI orig, PTT transform, float delta_time, bool dif);

private:

  Env &e;

};


class EventNode

{

public:

  IMPORT EventNode(Env &e);

  EV empty_event();

  EV key_event(EV next, int key_id, int key_type);

  EV timer_event(EV next, float time);

  EV delta_timer(EV next, EV event, float delta_time);

  //EV event_enable(EV next, EV event, EV start_event, EV end_event);

  //EV event_disable(EV next, EV event, EV start_event, EV end_event);


  AC empty_action();

  AC choose_ml_action(AC action, ML alternative);

  AC move_ml_action(AC action, MN movement, float start_time, float end_time);

  AC color_ml_action(AC action, int color_num, CC cc);

  AC send_key_action(AC action, int key_id, int key_type);

  AC change_time_action(AC action, float new_time);

  AC array_action(std::vector<AC> arr);

  AC sequence_action(std::vector<AC> arr, float time_step);

  AC skip_time_action(AC action, float delta_time);


  ML event_bind(ML next, EV event, AC action);

private:

  Env &e;

};


#ifdef F_MOVEMENT_NODE


class MovementNode

{

public:

  IMPORT MovementNode(Env &e);

  IMPORT MN mn_last_resize(MN mn);

  IMPORT MN fix_root(EveryApi &ev, MN mn);

  IMPORT ML key_move_ml(EveryApi &ev, ML ml, int key_forward, int key_backward, int key_rotate_minus, int key_rotate_plus, float speed, float rot_speed, float start_angle, float start_x, float end_x, float start_z, float end_z);

  IMPORT MN android_landscape_rotate(MN next);

  IMPORT MN android_landscape_rotate_inv(MN next);

  IMPORT MN mn_mouse_y(FF fetcher, MN move, float start_x, float end_x, float start_y, float end_y, float start_val, float end_val);

  IMPORT MN whack_a_mole_start(EveryApi &ev, MN prev, float &time);

  IMPORT MN whack_a_mole_rotate_around(EveryApi &ev, MN prev, int num, float &time);

  IMPORT MN whack_a_mole_exit(EveryApi &ev, MN prev, int exit_num, float &time);

  IMPORT MN whack_a_mole_all(EveryApi &ev, int cycle_count, int exit_num);

  IMPORT MN mn_interpolate(MN n1, MN n2, FF fetcher);

  IMPORT MN mn_interpolate2(MN n1, MN n2, float start_time, float end_time);

  IMPORT MN interpolate(MN n1, MN n2, float start_time, float end_time, float start_value, float end_value);

  IMPORT MN mn_empty();

  IMPORT MN level(MN next);

  IMPORT MN trans2(MN next, float dx, float dy, float dz);

  IMPORT MN scale2(MN next, float sx, float sy, float sz);

  IMPORT MN rotatex(MN next, float angle);

  IMPORT MN rotatey(MN next, float angle);

  IMPORT MN rotatez(MN next, float angle);

  IMPORT MN rotate_around_axis(MN next, float p_x, float p_y, float p_z, float v_x, float v_y, float v_z, float angle);

  IMPORT MN matrix(MN next, M mat);

  IMPORT MN pose(MN next, bool pose_in_screen);

  IMPORT MN debug_translate(MN next);

  IMPORT MN translate(MN next, float start_time, float end_time,float dx, float dy, float dz);

  IMPORT MN translate_wave(MN next, float start_time, float end_time, WV wave, float dx, float dy, float dz);

  IMPORT MN scale_progress(MN next, bool is_x, bool is_y, bool is_z, int state);

  IMPORT MN scale_progress_max(MN next, bool is_x, bool is_y, bool is_z, int state);

  IMPORT MN mn_fetcher(PF pf);

  IMPORT MN scale(MN next, float start_time, float end_time,float sx, float sy, float sz);

  IMPORT MN scale_wave(MN next, float start_time, float end_time,WV wave,float sx, float sy, float sz);

  IMPORT MN rotate(MN next, float start_time, float end_time,float p_x, float p_y, float p_z,float v_x, float v_y, float v_z, float angle);

  IMPORT MN rotate_wave(MN next, float start_time, float end_time,WV wave,float p_x, float p_y, float p_z,float v_x, float v_y, float v_z, float angle);


  IMPORT MN compress(MN next, float start_time, float end_time);

  IMPORT MN change_time(MN next, float d_time);

  IMPORT MN event_activate(MN next, MN event, float event_time, float duration);

  IMPORT MN anim_enable(MN next, float start_time, float end_time);

  IMPORT MN anim_disable(MN next, float start_time, float end_time);

  IMPORT MN anim_choose(std::vector<MN> vec, float start_time, float duration);

  IMPORT MN time_repeat(MN next, float start_time, float repeat_duration);

  IMPORT CC color_start(unsigned int color);

  IMPORT CC color_interpolate(CC next, unsigned int color, unsigned int color2, float start_time, float end_time);

  IMPORT void set_matrix(MN n, M m);

  IMPORT M get_matrix(MN n, float time, float delta_time);

  IMPORT ML color_ml(EveryApi &ev, int color_num, ML ml, CC cc);

  IMPORT ML move_ml(EveryApi &ev, ML ml, MN mn, int clone_count=1, float time_delta=10.0);

  IMPORT ML keypress_move_ml(EveryApi &ev, ML ml, MN mn, int clone_count=1, float time_delta=10.0, int key=32, bool flipenabled=false);

  IMPORT ML move_ml_projection(EveryApi &ev, ML ml, MN mn, int clone_count=1, float time_delta=10.0);

  IMPORT P move_ml_p(EveryApi &ev, P p, MN move, float time);

  IMPORT ML repeat_ml(EveryApi &ev, ML ml, float duration);

  IMPORT ML key_activate_ml(EveryApi &ev, ML ml, MN mn, int key, float duration);

  IMPORT ML comb_key_activate_ml(EveryApi &ev, ML ml, MN mn, int key, int key_2, float duration);

 IMPORT  ML temp_key_activate_ml(EveryApi &ev, ML ml, MN mn, int key, float duration);

  IMPORT ML move_x_ml(EveryApi &ev, ML ml, int key_forward, int key_backward, float speed, float start_x, float end_x);

  IMPORT ML move_y_ml(EveryApi &ev, ML ml, int key_forward, int key_backward, float speed, float start_y, float end_y);

  IMPORT ML move_z_ml(EveryApi &ev, ML ml, int key_forward, int key_backward, float speed, float start_z, float end_z);

  IMPORT ML rot_x_ml(EveryApi &ev, ML ml, int key_forward, int key_backward, float speed, float start_x, float end_x);

  IMPORT ML rot_y_ml(EveryApi &ev, ML ml, int key_forward, int key_backward, float speed, float start_y, float end_y);

  IMPORT ML rot_z_ml(EveryApi &ev, ML ml, int key_forward, int key_backward, float speed, float start_z, float end_z);

  IMPORT ML jump_ml(EveryApi &ev, ML ml, int key_jump, float height, float jump_duration);

  IMPORT ML move_ml_array(EveryApi &ev, std::vector<ML> ml, std::vector<MN> mn);

  IMPORT ML enable_ml(EveryApi &ev, ML ml, float start_time, float end_time);

  IMPORT ML key_event(EveryApi &ev, ML ml, MN mn, int type, int ch, int button, float duration);

  IMPORT ML wasd(EveryApi &ev, ML ml, MN w, MN a, MN s, MN d, float duration);

  IMPORT ML quake_ml(EveryApi &ev, ML ml, float speed, float rot_speed);

  IMPORT ML quake_ml2(EveryApi &ev, ML ml, float speed, float rot_speed);

  IMPORT ML quake_ml3(EveryApi &ev, ML ml, ML ml2, float speed, float rot_speed, float p_x, float p_y, float p_z);

  IMPORT ML key_printer_ml(ML ml);

  IMPORT ML local_move(EveryApi &ev, ML inner_ml, PTS center_points);

  IMPORT ML local_move_matrix(EveryApi &ev, ML inner_ml, MS center_points);

  IMPORT CMD default_cmds(float dx, float dy, float dz);

  IMPORT CMD cmd_repeat(CMD cmds, std::string repeat, float dx, float dy, float dz);

  IMPORT CMD cmd_rotate(CMD cmds, float v_x, float v_y, float v_z, float angle, float delta_angle);

  IMPORT PTS cmd_to_pts(CMD cmds, std::string commands);

  IMPORT LI cmd_to_li(CMD cmds, std::string commands);

  IMPORT PLF cmd_to_plf(CMD cmds, std::string commands);


  IMPORT ML all_cursor_keys(EveryApi &ev, ML ml, float speed, float duration);

  IMPORT ML cursor_keys(EveryApi &ev, ML ml, int key_up, int key_left, int key_down, int key_right, float speed, float duration);


  IMPORT ML player(ML prev);

  IMPORT ML enemy(ML prev);

  IMPORT ML player_pos(ML prev, PT pos);

  IMPORT ML enemy_pos(ML prev, PTS pos);

  IMPORT DC identity();

  IMPORT DC wave(float r,float speed1,float speed2,float dist1, float dist2,int sx,int sy);

  IMPORT DC sphwave(float r1, float fr_1, float t_1, float r2, float fr_2, float t_2);

  IMPORT DC explosion(float center_x, float center_y, float center_z, float start_val, float end_val, float start_time, float end_time);

  IMPORT DC compose(DC d1, DC d2);

  IMPORT DC split(DC d1, DC d2, float val);

private:

  Env &e;

};


#endif


#ifdef F_EXPR_API


class ExprApi

{

public:

  IMPORT ExprApi(Env &e);

  IMPORT EX variable(std::string name);

  IMPORT EX plus(EX e1, EX e2);

  IMPORT EX mul(EX e1, EX e2);

  IMPORT EX minus(EX e1, EX e2);

  IMPORT EX div(EX e1, EX e2);

  IMPORT EX sin(EX e1);

  IMPORT EX cos(EX e1);

  IMPORT EX float_constant(float val);

  IMPORT EX int_constant(int val);


  IMPORT EX expr_float(std::string expr, bool &success);

  IMPORT EX expr_int(std::string expr, bool &success);


  struct FloatExprEnv { std::string name; float value; };

  struct IntExprEnv { std::string name; int value; };

  IMPORT float expr_eval_float(EX expr, std::vector<FloatExprEnv> env);

  IMPORT int expr_eval_int(EX expr, std::vector<IntExprEnv> env);

private:

  Env &e;

};


#endif


#ifdef F_GUI_API


class GuiApi

{

public:

  GuiApi(Env &e, EveryApi &ev, SH sh) : e(e), ev(ev), sh(sh) { }

  IMPORT W hide_nonsearchable(W w, std::string label, W *redraw_w);

  IMPORT W hide_if_array_empty(W w, std::vector<W> items, W *redraw_w);

  IMPORT W search_panel(int sx, FtA atlas, BM atlas_bm, int x_gap, W *redraw_w);

  IMPORT W download_bar(GameApi::EveryApi &ev, std::vector<std::string> titles, std::vector<W> &close_button, std::vector<W> &buttons, FtA atlas, BM atlas_bm, int active_tab, std::vector<float> progress);

  IMPORT W directory_view(std::vector<std::string> dir_items, int &selection, std::vector<W> &clicks, FtA atlas, BM atlas_bm);

  IMPORT W asset_view(std::string url_or_filename);

  IMPORT W navi_bar(EveryApi &ev, std::vector<std::string> titles, W &back_button, W &forward_button, W &save_button, std::string &url, W &url_button, std::vector<W> &close_button, std::vector<W> &tab_change_button, W &new_tab_button, std::vector<std::string> bookmark_labels, std::vector<std::string> bookmark_urls, FtA atlas, BM atlas_bm, int &active_tab);

  IMPORT W alt(std::vector<W> vec, int *choose);

  IMPORT W overlap(EveryApi &ev, std::vector<W> vec);

  IMPORT W asset_item(EveryApi &ev, std::string jpg_url, std::string jpg_display_name, FtA atlas, BM atlas_bm);

  IMPORT W asset_dialog(EveryApi &ev, std::vector<std::string> jpg_urls, std::vector<std::string> jpg_display_names,W &select_button, W &cancel_button, FtA atlas, BM atlas_bm);

  IMPORT W dynamic_text(std::string need_letters, std::string *dyn_text, void (*fptr)(void *, float mouse_x, float mouse_y, int button, int ch, int type, int mouse_wheel_y), void *user_ptr, GameApi::FtA atlas, GameApi::BM atlas_bm, int x_gap);

  IMPORT W progress_dialog(int sx, int sy, FtA atlas, BM atlas_bm, std::vector<std::string> vec, int val, int max);

  IMPORT void update_progress_dialog(volatile W &w, int sx, int sy, FtA atlas, BM atlas_bm, std::vector<std::string> vec, int val, int max, int process);

  IMPORT void delete_widget(W w);

  IMPORT W window_decoration(int sx, int sy, std::string label, FtA atlas, BM atlas_bm);

  IMPORT W window_decoration2(int sx, int sy, std::string label, FtA atlas, BM atlas_bm, bool move);

  IMPORT W empty();

  IMPORT W bounding_box(W w);

  IMPORT W alt(GameApi::EveryApi &ev, std::vector<W> vec, int *choose);

  IMPORT W text(std::string label, FtA atlas, BM atlas_bm, int x_gap=3);

  IMPORT W icon(BM bitmap);

  IMPORT W icon_shared(BM bitmap, int key);

  IMPORT W icon_shared_noscale(BM bitmap, int key);

  IMPORT W poly(P p, SH sh, int sx, int sy, int screen_size_x, int screen_size_y);

  IMPORT W va(VA p, SH sh, int sx, int sy, int screen_size_x, int screen_size_y);

  IMPORT W ml(ML p, SH sh, SH sh2, SH sh_2d, SH sh_arr, int sx, int sy, int screen_size_x, int screen_size_y);

  IMPORT W shader_plane(SFO p, int sx, int sy, int screen_size_x, int screen_size_y);

  IMPORT W lines(LI p, SH sh, int sx, int sy, int screen_size_x, int screen_size_y);

  IMPORT W pts(PTS p, SH sh, int sx, int sy, int screen_size_x, int screen_size_y);

  IMPORT W line(W target1, int delta_x, int delta_y,W target2, int delta2_x, int delta2_y, SH sh, SH old_sh);

  IMPORT W gradient(int sx, int sy, PT pos_1, PT pos_2, unsigned int colot_1, unsigned int color_2);

  IMPORT W button(int sx, int sy, unsigned int color_1, unsigned int color_2);

  IMPORT W mouse_move(W widget, int area_x, int area_y, int area_width, int area_height);

  IMPORT W window_move(W widget, int area_x, int area_y, int area_width, int area_height);

  IMPORT W click_area(W widget, int area_x, int area_y, int area_width, int area_height, int button_id);

  IMPORT W key_area(W widget, int area_x, int area_y, int area_width, int area_height, int key);

  IMPORT W click_visibility(W area_widget, W hidden_widget);

  IMPORT W click_hide(W widget);

  IMPORT W top_right_corner_match(W wid, W floating); // returns floating

  IMPORT W or_elem(W (*w1_func)(void*), W (*w2_func)(void*), void *data);

  IMPORT W rectangle(int start_x, int end_x, int start_y, int end_y, unsigned int color);

  IMPORT W highlight(int sx, int sy);

  IMPORT W highlight(W wid);

  IMPORT W layout(W item, int left, int top, int width, int height, int right, int bottom);

  IMPORT W layout_wh(W item, int left, int top, int width, int height, int right, int bottom, int (*fptr_W)(void *), int (*fptr_H)(void *), void *ctx1, void *ctx2);

  IMPORT W layout_lt(W item, int left, int top, int width, int height, int right, int bottom, int (*fptr_l)(void *), int (*fptr_t)(void *), void *ctx1, void *ctx2);

  IMPORT W layout_rb(W item, int left, int top, int width, int height, int right, int bottom, int (*fptr_r)(void *), int (*fptr_b)(void *), void *ctx1, void *ctx2);

  IMPORT W layout_lh(W item, int left, int top, int width, int height, int right, int bottom, int (*fptr_l)(void*), int (*fptr_H)(void*), void *ctx1, void *ctx2);

  IMPORT W margin(W item, int left, int top, int right, int bottom);

  IMPORT W size(W item, int sx, int sy);

  IMPORT W left_align(W item, int sx);

  IMPORT W right_align(W item, int sx);

  IMPORT W center_align(W item, int sx);

  IMPORT W center_y(W item, int sy);

  IMPORT W layer(W w1, W w2);

  IMPORT W array_y(std::vector<W> arr, int y_gap, bool heavy=false);

  IMPORT W array_x(W *arr, int size, int x_gap);

  IMPORT W timed_visibility(W orig, W (*timed_widget_func)(void*),void*data, W insert, float start_duration, float duration, float dx);

  IMPORT W tooltip(W orig, W insert, std::string label, FtA atlas, BM atlas_bm, int x_gap=2, float dx=40.0);

  IMPORT W popup_box(std::string label, std::vector<std::string> options, FtA atlas, BM atlas_bm);

  IMPORT W popup_box_menu(std::vector<std::string> options, FtA atlas, BM atlas_bm);


  IMPORT W license_item(std::string filename, std::string &license_url, std::string &author, FtA atlas, BM atlas_bm, FtA atlas2, BM atlas_bm2);

  IMPORT W license_dialog(std::vector<std::string> filename,

              std::vector<std::string> &license_url,

              std::vector<std::string> &author_names,

              FtA atlas, BM atlas_bm,

              FtA atlas2, BM atlas_bm2,

              FtA atlas3, BM atlas_bm3,

              W &next_button, W &cancel_button, W &canvas2, W &canvas_area,W &scroll_bar);


  IMPORT W main_menu(std::vector<std::string> labels, FtA atlas, BM atlas_bm);

  IMPORT W menu(W main_menu, int menu_id, std::vector<std::string> labels, FtA atlas, BM atlas_bm);

  IMPORT W submenu(W menu, int menu_pane_id, std::vector<std::string> labels, FtA atlas, BM atlas_bm);

  IMPORT W popup_menu(int x, int y, std::vector<std::string> labels, FtA atlas, BM atlas_bm, std::vector<W> &areas);

  IMPORT W scrollbar_y(int sx, int sy, int area_y);

  IMPORT W scrollbar_x(int sx, int sy, int area_x);

  IMPORT W scroll_area(W orig, int sx, int sy, int screen_y);

  IMPORT W scroll_area2(W orig, int sx, int sy, int screen_y);

  IMPORT W waveform(std::function<float (float)> f, float start_range, float end_range, float min_value, float max_value, int sx, int sy, unsigned int true_color, unsigned int false_color);

  IMPORT W canvas(int sx, int sy);

  IMPORT W find_canvas_item(W canvas, std::string id);

  IMPORT int canvas_item_index(W canvas, W item);

  IMPORT int canvas_item(W canvas, W item, int x, int y);

  IMPORT void del_canvas_item(W canvas, int id);

  IMPORT W canvas_item_gameapi_node(int sx, int sy, std::string label, std::vector<std::string> param_types, std::vector<std::string> param_tooltips, std::string return_type, FtA atlas, BM atlas_bm, std::vector<W *> connect_click, std::string uid, std::vector<W> &params, std::string symbol, std::string comment);

  IMPORT W list_item_title(int sx, std::string label, FtA atlas, BM atlas_bm);

  IMPORT W list_item_opened(int sx, std::string label, FtA atlas, BM atlas_bm, std::vector<std::string> subitems, std::vector<std::string> subitems_tooltip, FtA atlas2, BM atlas_bm2, W insert, bool hide, W *redraw_w, std::vector<std::string> subitems_funcname);

  IMPORT W list_item(BM icon, std::string label, int sx, int sy);

  IMPORT W list(W *array, int size, int sx, int sy);

  IMPORT W dialog_item(std::string text, BM icon, int sx, int sy);

  IMPORT W dialog_border(W item);

  IMPORT W copy_paste_dialog(SH sh, W &close_button, FI font, FtA atlas, BM atlas_bm, std::string &edit);

  IMPORT W bitmap_dialog(BM bm, W &close_button, FtA atlas, BM atlas_bm, W &codegen_button, W &collect_button, FtA atlas_tiny, BM atlas_tiny_bm);

  IMPORT W polygon_dialog(P p, SH sh, int screen_size_x, int screen_size_y, W &close_button, FtA atlas, BM atlas_bm, W &codegen_button, W &collect_button, W &mem);

  IMPORT W va_dialog(VA p, SH sh, int screen_size_x, int screen_size_y, W &close_button, FtA atlas, BM atlas_bm, W &codegen_button, W &collect_button);

  IMPORT W ml_dialog(ML p, SH sh, SH sh2, SH sh_2d, SH sh_arr, int screen_size_x, int screen_size_y, W &close_button, FtA atlas, BM atlas_bm, W &codegen_button, W &collect_button);

  IMPORT W shader_dialog(SFO p, W &close_button, FtA atlas, BM atlas_bm, int screen_size_x, int screen_size_y, W &codegen_button, W &collect_button);

  IMPORT W lines_dialog(LI p, SH sh, int screen_size_x, int screen_size_y, W &close_button, FtA atlas, BM atlas_bm, W &codegen_button, W &collect_button);

  IMPORT W pts_dialog(PTS p, SH sh, int screen_size_x, int screen_size_y, W &close_button, FtA atlas, BM atlas_bm, W &codegen_button, W &collect_button);


  IMPORT W button_with_text(std::string label);

  IMPORT W button_with_icon(BM bitmap);

  IMPORT W opengl_wrapper(W widget);

  IMPORT W editor_mouse_tweak(W inner, W outer, W outerouter);

  IMPORT W string_editor(std::string allowed_chars, std::string &target, std::string &target_expr, FtA atlas, BM atlas_bm, int x_gap, int non_editable, W *redraw_w, bool allow_expr=true);

  IMPORT W multiline_string_editor(std::string allowed_chars, std::string &target, FI font, int x_gap, int line_height);

  IMPORT W url_editor(std::string &target, FtA atlas, BM atlas_bm, int x_gap, std::string &expr, int noneditnum=0);

  IMPORT W float_editor(float &target, std::string &target_expr, FtA atlas, BM atlas_bm, int x_gap, int noneditnum=0);

  IMPORT W int_editor(int &target, std::string &target_expr, FtA atlas, BM atlas_bm, int x_gap, int noneditnum=0);

  IMPORT W enum_editor(EveryApi &ev, W &click_target, int &target, FtA atlas, BM atlas_bm, int x_gap, std::string type,std::string &expr,int noneditnum=0);

  IMPORT W long_editor(long &target, FtA atlas, BM atlas_bm, int x_gap,int noneditnum, std::string &expr);

  IMPORT W point_editor(float &x, float &y, float &z, FtA atlas, BM atlas_bm, int x_gap);

  IMPORT W color_editor(std::string &col, FtA atlas, BM atlas_bm, int x_gap,int noneditnum, std::string &expr);


  struct EditTypes

  {

    int i_value;

    long l_value;

    float f_value;

    float f_x, f_y, f_z;

    std::string color;

    std::string s;

    std::string expr;

  };


  IMPORT W generic_editor(EveryApi &ev, EditTypes &target, FtA atlas, BM atlas_bm, std::string type, int x_gap, FtA atlas_tiny, BM atlas_tiny_bm, int sy, W &click_target);

  IMPORT void generic_to_string(const EditTypes &source, std::string type, std::string &target, std::string &expr);

  IMPORT void string_to_generic(EditTypes &target, std::string type, const std::string &source, const std::string &expr);

  IMPORT W edit_dialog(const std::vector<std::string> &labels, const std::vector<EditTypes*> &vec, Ft font, const std::vector<std::string> &types, W &cancel_button, W &ok_button);

  IMPORT W edit_dialog(EveryApi &ev, const std::vector<std::string> &labels, const std::vector<EditTypes*> &vec, FtA atlas, BM atlas_bm, const std::vector<std::string> &types, W &cancel_button, W &ok_button, FtA atlas_tiny, BM atlas_tiny_bm, std::vector<W> &enum_click_targets);

  IMPORT W bitmapapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer);

  IMPORT W boolbitmapapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer);

  IMPORT W floatbitmapapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer);

  IMPORT W polygonapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer);

  IMPORT W polygondistapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer);

  IMPORT W shadermoduleapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer);

  IMPORT W shaderapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer);

  IMPORT W framebuffermoduleapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer);

  IMPORT W linesapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer);

  IMPORT W pointsapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer);

  IMPORT W pointapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer);

  IMPORT W vectorapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer);

  IMPORT W volumeapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer);

  IMPORT W floatvolumeapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer);

  IMPORT W colorvolumeapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer);

  IMPORT W fontapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer);

  IMPORT W textureapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer);

  IMPORT W booleanopsapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer);

  IMPORT W moveapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer);

  IMPORT W waveformapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer);

  IMPORT W blockerapi_functions_list_item(GameApi::EveryApi &ev, FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer);


  IMPORT std::string bitmapapi_functions_item_label(int i);

  IMPORT std::string waveformapi_functions_item_label(int i);

  IMPORT std::string blockerapi_functions_item_label(GameApi::EveryApi &ev, int i);

  IMPORT std::string boolbitmapapi_functions_item_label(int i);

  IMPORT std::string floatbitmapapi_functions_item_label(int i);

  IMPORT std::string polygonapi_functions_item_label(int i);

  IMPORT std::string polygondistapi_functions_item_label(int i);

  IMPORT std::string shadermoduleapi_functions_item_label(int i);

  IMPORT std::string shaderapi_functions_item_label(int i);

  IMPORT std::string framebuffermoduleapi_functions_item_label(int i);

  IMPORT std::string linesapi_functions_item_label(int i);

  IMPORT std::string pointsapi_functions_item_label(int i);

  IMPORT std::string pointapi_functions_item_label(int i);

  IMPORT std::string vectorapi_functions_item_label(int i);

  IMPORT std::string volumeapi_functions_item_label(int i);

  IMPORT std::string floatvolumeapi_functions_item_label(int i);

  IMPORT std::string colorvolumeapi_functions_item_label(int i);

  IMPORT std::string fontapi_functions_item_label(int i);

  IMPORT std::string textureapi_functions_item_label(int i);

  IMPORT std::string booleanopsapi_functions_item_label(int i);

  IMPORT std::string moveapi_functions_item_label(int i);

  IMPORT W insert_widget(W item, std::function<void(int,int)> f);

  IMPORT void insert_widget_activate(W w, bool b);


  IMPORT void set_pos(W w, float px, float py);

  IMPORT void set_size(W ow, float sx, float sy);

  IMPORT void update(W w, PT mouse_cursor_pos, int button, int ch, int type, int mouse_wheel_y);

  IMPORT void render(W w);

  IMPORT int chosen_item(W w);

  IMPORT void select_item(W w, int item);

  IMPORT float dynamic_param(W w, int id);

  IMPORT void set_dynamic_param(W w, int id, float val);

  IMPORT std::string get_id(W w);

  IMPORT void set_id(W w, std::string id);

  IMPORT int get_index(W w);

  IMPORT void set_index(W w, int j);

  IMPORT int get_size2(W w);

  IMPORT void set_size2(W w, int sz);

  IMPORT int num_childs(W w);

  IMPORT W get_child(W w, int i);

  IMPORT int pos_x(W w);

  IMPORT int pos_y(W w);

  IMPORT int size_x(W w);

  IMPORT int size_y(W w);


  IMPORT std::vector<std::pair<std::string,std::string> > get_functions_mapping(GameApi::EveryApi &ev);

private:

  Env &e;

  EveryApi &ev;

  SH sh;

};


#endif


  class EditNode;


  struct CollectResult {

    std::vector<EditNode*> res;

    std::string p;

    std::string pn;

  };


  int collect_counter(int mode); // 0=reset, 1=count_next


#ifdef F_WMOD_API


class WModApi

{

public:

  IMPORT WModApi(Env &e);

  IMPORT std::string dep_from_function(EveryApi &ev, WM mod2, int id);

  IMPORT std::string deps_from_mod(EveryApi &ev, WM mod2);

  IMPORT std::string extract_deps(std::string filename);

  IMPORT std::string extract_funcname(std::string line);

  IMPORT void dump_functions_for_docs(GameApi::EveryApi &ev, int i);

  IMPORT int dump_functions_count();

  IMPORT std::string dump_functions(GameApi::EveryApi &ev, int i);

  IMPORT WM load(EveryApi &ev, std::string filename);

  IMPORT void save(WM mod, std::string ilename);

  IMPORT void insert_to_canvas(GameApi::EveryApi &ev, GuiApi &gui, W canvas, WM mod, int id, FtA font, BM font_bm, std::vector<W> &connect_clicks, std::vector<W> &params, std::vector<W> &diaplay_clicks, std::vector<W> &edit_clicks, std::vector<W> &delete_key, std::vector<W> &codegen_button, std::vector<W> &popup_open, void (*fptr)(void*), void *data);

  IMPORT void update_lines_from_canvas(W canvas, WM mod, int id);

  IMPORT void insert_inserted_to_canvas(GuiApi &gui, W canvas, W item, std::string uid, W &display_clicks, W &edit_clicks, W &delete_key, W &codegen_button, W &popup_open);

  IMPORT W inserted_widget(GameApi::EveryApi &ev, GuiApi &gui, WM mod2, int id, FtA atlas, BM atlas_bm, std::string func_name, std::vector<W *> connect_click, std::string uid, std::vector<W> &params);

  IMPORT std::vector<int> indexes_from_funcname(GameApi::EveryApi &ev, std::string funcname);

  IMPORT std::vector<std::string> types_from_function(GameApi::EveryApi &ev, WM mod, int id, std::string funcname);

  IMPORT std::vector<std::string> labels_from_function(GameApi::EveryApi &ev, WM mod, int id, std::string funcname);

  IMPORT std::vector<std::string*> refs_from_function(GameApi::EveryApi &ev, WM mod, int id, std::string funcname);

  IMPORT std::vector<std::string*> exprs_from_function(GameApi::EveryApi &ev, WM mod, int id, std::string funcname);

  IMPORT std::vector<std::pair<std::string,std::string> > defaults_from_function(GameApi::EveryApi &ev, std::string module_name);


  struct InsertParam {

    std::string first;

    std::string second;

    bool is_array = false;

    int line_index_in_gameapi_function_lines_array = -1;

  };


  IMPORT void insert_to_mod(WM mod, int id, std::string modname, std::string uid, bool array_return, int x, int y, std::vector<InsertParam> params);


  IMPORT std::string get_funcname(WM mod2, int id, std::string uid);

  IMPORT void change_param_value(WM mod2, int id, std::string uid, int param_index, std::string newvalue, int j);

  IMPORT void change_param_is_array(WM mod2, int id, std::string uid, int param_index, bool is_array, int ref_line_index);

  IMPORT void change_param_multiple_return_values(WM mod2, int id, std::string uid, int j, int sz);

  IMPORT int find_line_index(WM mod2, int id, std::string uid);

  IMPORT std::string param_value(WM mod2, int id, std::string uid, int param_index);

  IMPORT std::vector<std::string> parse_param_array(std::string s);

  IMPORT std::pair<std::string,int> parse_multiple_return_uid(std::string s, bool &success);

  IMPORT std::string generate_param_array(std::vector<std::string> v);

  IMPORT bool typecheck(GameApi::EveryApi &ev, WM mod2, int id, std::string uid1, std::string uid2, int param_index, int ret_index, bool &is_array, bool &is_array_return);

  IMPORT void insert_links(EveryApi &ev, GuiApi &gui, WM mod2, int id, std::vector<W> &links, W canvas, const std::vector<W> &connect_targets, SH sh2, SH sh);


  IMPORT int execute(EveryApi &ev, WM mod2, int id, std::string line_uid, ExecuteEnv &exeenv, int level, int j);

  IMPORT std::pair<int,std::vector<std::string> > collect_urls(EveryApi &ev, WM mod2, int id, std::string line_uid, ExecuteEnv &exeenv, int level, ASyncData *arr, int arr_size, int j, bool use_async=false);


  IMPORT CollectResult collect_nodes(EveryApi &ev, WM mod2, int id, std::string line_uid, int level);

  IMPORT void codegen_reset_counter();

  IMPORT std::pair<std::string, std::string> codegen(EveryApi &ev, WM mod2, int id, std::string line_uid, int level, int j, CodeGenPositions *pos=0);

  IMPORT std::string return_type(GameApi::EveryApi &ev, WM mod2, int id, std::string line_uid);

  IMPORT void delete_by_uid(WM mod2, int id, std::string line_uid);

private:

  Env &e;

};


#endif


#ifdef F_FLOAT_VOLUME_API


class FloatVolumeApi

{

public:

  IMPORT FloatVolumeApi(Env &e);

  IMPORT FO light(float dist);

  IMPORT FO julia(float c_x, float c_y, float limit);

  IMPORT FO mandelbrot(float x_x, float x_y, float limit);

  IMPORT FO function(std::function<float(float x, float y, float z)> f);

    IMPORT FO from_volume(O o, float false_val, float true_val);

    IMPORT FO from_float_bitmap(FB bm,float start_x, float end_x, float start_y, float end_y, float start_z, float end_z);

    IMPORT FO distance();

    IMPORT FO torusdistance(PT center, V u_x, V u_y, float radius);

    IMPORT FO move(FO f1, float dx, float dy, float dz);

    IMPORT FO minimum(FO f1, FO f2);

    IMPORT FO maximum(FO f1, FO f2);

  IMPORT FO waveform_sphere(WV wav, float r);

  IMPORT WV wave_move_y(WV wav, float delta);

        IMPORT O subvolume(FO f, float start_range, float end_range);

        IMPORT FO smooth(std::vector<FO> vec, float val);

        IMPORT FO interpolate(FO f1, FO f2, float val);

        IMPORT FO min_distance(C curve);


    IMPORT FO shadow(FD fd, V light_dir, float mint, float maxt, float k);


  IMPORT FB integrate_render(FO obj, int sx, int sy, int numsamples);


  //FO plus(FO f1, FO f2);

    IMPORT BM raytrace(FO object, int sx, int sy,

          PT ray_0, PT ray_x, PT ray_y, PT ray_z, float surface_value);

    IMPORT FOA prepare(FO object, int numpoints,

          float start_x, float start_y, float start_z,

          float end_x, float end_y, float end_z);

    IMPORT void render(FOA array);

private:

  FloatVolumeApi(const FloatVolumeApi&);

  void operator=(const FloatVolumeApi&);

  Env &e;

};


#endif


#ifdef F_COLOR_VOLUME_API


class ColorVolumeApi

{

public:

  IMPORT ColorVolumeApi(Env &e);

  IMPORT COV function(std::function<unsigned int(float x, float y, float z)> f);

  IMPORT COV from_float_volume(FO obj, unsigned int col0, unsigned int col1);

  IMPORT COV from_volume(O obj, unsigned int col_true, unsigned int col_false);

  IMPORT COV from_continuous_bitmap(CBM bm);


  IMPORT COV mix(COV p1, COV p2, float value); // value=[0..1]

  IMPORT COV or_cov(COV p1, COV p2);

  IMPORT COV phong(VO normal, PT light_pos, CO i_s, CO i_d, CO i_a, float k_s, float k_d, float k_a, float alfa);

  IMPORT COV directcolor(VO normal);

  IMPORT P texture(P obj, COV colors);

  IMPORT BM texture_bm(P obj, COV colors, int face, int sx, int sy);

  IMPORT BM array_bm(COV colours, int sx, int sy, float ssx, float ssy, float z);

  // TODO

private:

  ColorVolumeApi(const ColorVolumeApi&);

  void operator=(const ColorVolumeApi&);

  Env &e;

};


#endif


#ifdef F_VECTOR_VOLUME_API


class VectorVolumeApi

{

public:

  IMPORT VectorVolumeApi(Env &e);

    IMPORT VO function(std::function<V(float x, float y, float z)> f);

    IMPORT VO normal(FD fd);

  IMPORT VO normal2(FO fo, float stepsize);

  IMPORT P setup_normal(P orig, VO v);

private:

  VectorVolumeApi(const VectorVolumeApi&);

  void operator=(const VectorVolumeApi&);


  Env &e;

};


#endif


#ifdef F_DISTANCE_FLOAT_VOLUME_API


class DistanceFloatVolumeApi

{

public:

  IMPORT DistanceFloatVolumeApi(Env &e);

    IMPORT FD function(std::function<float(float x, float y, float z)> f);

    IMPORT FD fd_sphere(PT center, float radius);

    IMPORT FD fd_cube(float start_x, float end_x,float start_y, float end_y,float start_z, float end_z);

  IMPORT FD fd_round_cube(float start_x, float end_x,float start_y, float end_y,float start_z, float end_z,float r);

  IMPORT FD fd_torus(float radius_1, float radius_2);

  IMPORT FD fd_cone(float c_x, float c_y);

  IMPORT FD fd_plane(float n_x, float n_y, float n_z, float n_w);

  IMPORT FD fd_hex_prism(float h_x, float h_y);

  IMPORT FD fd_tri_prism(float h_x, float h_y);

  IMPORT FD fd_triangle(PT a, PT b, PT c);

  IMPORT FD fd_quad(PT a, PT b, PT c, PT d);

    IMPORT FD fd_line(PT start, PT end, float dist);

  IMPORT FD fd_color(FD fd, float r, float g, float b, float a);

  IMPORT FD fd_rot_x(FD fd, float angle);

  IMPORT FD fd_rot_y(FD fd, float angle);

  IMPORT FD fd_rot_z(FD fd, float angle);

  IMPORT FD fd_trans(FD fd, float dx, float dy, float dz);


    IMPORT FD fd_min(FD a1, FD a2);

        IMPORT FD fd_max(FD a1, FD a2);

  IMPORT FD fd_and_not(FD a1, FD a2);

  IMPORT FD fd_blend(FD a1, FD a2, float k);

  IMPORT FD recalculate_normals(FD fd);

  IMPORT FD ambient_occulsion(FD fd, float d, float i);

  IMPORT P distance_poly(EveryApi &ev, FD fd,

             float dx, float dy, float dz,

             int sx, int sy,

             float ssx, float ssy,

             int ssxi, int ssyi,

             float ssx2, float ssy2);

  IMPORT P distance_poly_cyl(EveryApi &ev, FD fd,

                 float pos_x, float pos_y, float pos_z,

                 float dx, float dy, float dz,

                 int sx, int sy,

                 float ssx, float ssy,

                 int ssxi, int ssyi,

                 float ssx2, float ssy2);

  IMPORT P distance_poly_sph(EveryApi &ev, FD fd,

             float dx, float dy, float dz,

             int sx, int sy,

             float ssx, float ssy,

             int ssxi, int ssyi,

             float ssx2, float ssy2);

  IMPORT PT ray_shape_intersect(FD shape, PT pos, V vec);

    IMPORT BM render(FD obj,PT pos, V u_x, V u_y, V u_z, int sx, int sy);

  IMPORT BM render2(EveryApi &ev, FD obj, int sx, int sy);

    IMPORT std::string shader_func(std::string name, FD obj, COV color);

private:

  DistanceFloatVolumeApi(const DistanceFloatVolumeApi&);

  void operator=(const DistanceFloatVolumeApi&);


  Env &e;

};


#endif


#ifdef F_SEPARATE_API


class SeparateApi

{

public:

  IMPORT SeparateApi(Env &e);

  SA empty();

  SA u_sep(SA orig, float (*sep_u)(float x, float y, float z, void *data), void *data);

  SA v_sep(SA orig, float (*sep_v)(float x, float y, float z, void *data), void *data);

  SA surf_sep(SA orig, float (*sep_dist)(float x, float y, float z, void *data), void *data);

  P create_quads(SA object, float dist, float dist_accuracy,

         float x_range_start, float x_range_end, float x_step,

         float y_range_start, float y_range_end, float y_step,

         float z_range_start, float z_range_end, float z_step,

         float u_range_start, float u_range_end, float u_step,

         float v_range_start, float v_range_end, float v_step);


private:

  Env &e;

};


#endif


#ifdef F_SURFACE_API


class SurfaceApi

{

public:

  IMPORT SurfaceApi(Env &e);

  IMPORT ~SurfaceApi();

  S plane(PT pos, V u_x, V u_y);

  S sphere(PT center, float radius);

  S torus(PT center, float dist1, float dist2, PT pos, PT u_x, PT u_y);

  S interpolate(S s1, S s2, float val); // val = [0..1]


  S betweensurface(C curve1, C curve2);


  S bitmapsphere(PT center, float radius0, float radius1, BM height);


  S color(S orig, unsigned int color);

  S texture(S orig, BM texture); // see bitmaptexturesurface from graph.hh


  BM render(S surf, int sx, int sy, PT ray_0, PT ray_x, PT ray_y, PT ray_z);

  PTS surface_points(S surf, int sx, int sy);

private:

  void *priv;

  Env &e;

};


#endif


#ifdef F_TRISTRIP_API


class TriStripApi

{

public:

  IMPORT TriStripApi(Env &e);

  ~TriStripApi() { }

  IMPORT TS from_array(PT *arr, int size);

  IMPORT TS function(std::function<PT (int i)> f, int count);

  IMPORT TS color_function(TS ts, std::function<unsigned int (int i)> f);

  IMPORT TS texcoord_function(TS ts, std::function<PT (int i)> texcoord);

  IMPORT TS normal_function(TS ts, std::function<V (int i)> normal);

  IMPORT TS rectangle_xy(float start_x, float end_x, float start_y, float end_y, float z, int sx, int sy);

  IMPORT TS rectangle_xz(float start_x, float end_x, float y, float start_z, float end_z);

  IMPORT TS circle(float center_x, float center_y, float center_z, float radius, int count);

  IMPORT TS transform(TS orig, std::function<PT (PT)> trans);


  IMPORT TS from_convex_plane(PL pl, PT pos, V u_x, V u_y);

  IMPORT TS span_3d_object(TS orig, float z_dist);


  IMPORT TS or_elem(TS t1, TS t2);

  IMPORT TS or_array(TS *array, int size);


  IMPORT void save(TS tris, std::string filename);

  IMPORT TS load(std::string filename);

  IMPORT P to_poly(TS strip);

  IMPORT TS from_poly(P poly);

private:

  Env &e;

};


#endif


#ifdef F_CUTTER_API


class CutterApi

{

public:

  IMPORT CutterApi(Env &e);

  IMPORT CT function(std::function<PT (PT,PT)> f);

  IMPORT CT plane_cut(PT pos, V u_x, V u_y);

  //IMPORT CT sphere_cut(PT center, float radius);

  IMPORT CT distance_cut(FD dist);

  IMPORT O cutter_volume(CT c, PT point_from_inside, float outside_dist);

private:

  Env &e;

};


#endif


  struct BO { int id; };

#ifdef F_BOOLEAN_OPS


class BooleanOps

{

public:

  IMPORT BooleanOps(Env &e);

  IMPORT BO create_bo(P mesh, O bools, FD fd);

  IMPORT BO cube_bo(EveryApi &ev, float start_x, float end_x,float start_y, float end_y,float start_z, float end_z,int split_x, int split_y);

  IMPORT BO sphere_bo(EveryApi &ev, PT center, float radius, int numfaces1, int numfaces2);

  //BO cone(int numfaces, PT p1, PT p2, float rad1, float rad2);

  //BO torus(int numfaces1, int numfaces2, PT center, V u_x, V u_y, float radius1, V uu_x, V uu_y, float radius2);

  IMPORT BO or_elem_bo(EveryApi &ev, BO obj, BO obj2);

  IMPORT BO and_not_bo(EveryApi &ev, BO obj, BO not_obj);

  IMPORT BO intersect_bo(EveryApi &ev, BO obj, BO obj2);

  IMPORT P to_polygon(BO obj);

  IMPORT O to_volume(BO obj);

  IMPORT FD to_dist(BO obj);

private:

  Env &e;

};


#endif

struct PD { int id; };


#ifdef F_POLYGON_DISTANCE_FIELD


class PolygonDistanceField

{

public:

  IMPORT PolygonDistanceField(Env &e);

  IMPORT PD empty(EveryApi &ev);

  IMPORT PD create_pd(P mesh, SFO distance_field);

  IMPORT PD cube_pd(EveryApi &ev, float start_x, float end_x,float start_y, float end_y,float start_z, float end_z);

  IMPORT PD rounded_cube_pd(EveryApi &ev, float start_x, float end_x,float start_y, float end_y,float start_z, float end_z,float radius);

  IMPORT PD sphere_pd(EveryApi &ev, PT center, float radius, int numfaces1, int numfaces2);

  IMPORT PD cone_pd(EveryApi &ev, int numfaces, PT p1, PT p2, float rad1, float rad2);

  IMPORT PD or_array_pd(EveryApi &ev, std::vector<PD> vec);

  IMPORT PD translate_pd(EveryApi &ev, PD orig, float dx, float dy, float dz);

  IMPORT PD rotatex_pd(EveryApi &ev, PD orig, float angle);

  IMPORT PD rotatey_pd(EveryApi &ev, PD orig, float angle);

  IMPORT PD rotatez_pd(EveryApi &ev, PD orig, float angle);

  IMPORT PD scale_pd(EveryApi &ev, PD orig, float sx, float sy, float sz);

  IMPORT PD color_from_normal_pd(EveryApi &ev, PD obj);

  IMPORT PD ambient_occulsion_sfo(EveryApi &ev, PD obj, float d, float i);

  IMPORT PD colormod_from_position(EveryApi &ev, PD obj, float px, float py, float pz, float sx, float sy, float sz);

  IMPORT MT mesh_color_from_sfo(EveryApi &ev, PD orig, MT next);


  IMPORT ML render_scene(EveryApi &ev, PD object, PD world); // this has access to sfo, P and matrix stack -- should make dynamic movement possible with proper shading which responds to movement of the objects in the scene. especially AO needs to be recalculated, but will also allow other shading stuff. This hasnt worked before since P object doesnt have access to shader side, SFO can't deal with meshes and matrix stack/ML is completely separate and it's needed for movement. // shader side needs to respond to matrix stack changes. So this is basically a bridge between matrix stack and shaders.

  IMPORT std::vector<ML> render_scene_array(EveryApi &ev, std::vector<PD> vec); // this on the other hand, is completely different -- it can connect multiple objects together in nice way. Unfortunately, builder doesn't support this api, but it's anyway useful later. (we can make builder support this prototype)


  IMPORT P get_polygon(PD p);

  IMPORT SFO get_distance_field(PD p);

private:

  Env &e;

};


#endif

#ifdef F_POLYGON_ARRAY_API


class PolygonArrayApi

{

public:

  IMPORT PolygonArrayApi(Env &e);

  Pa split_p(EveryApi &ev, P p, int max_chunk);

  Va create_vertex_array(EveryApi &ev, Pa p, bool keep=false);

  void delete_vertex_array(EveryApi &ev, Va va);

  void render_vertex_array(EveryApi &ev, Va p);

  void prepare_vertex_array_instanced(EveryApi &ev, ShaderApi &sha, Va va, PTA pta, SH sh);

  void prepare_vertex_array_instanced_matrix(EveryApi &ev, ShaderApi &sha, Va va, MSA pta, SH sh);

  void render_vertex_array_instanced(EveryApi &ev, ShaderApi &sha, Va va, PTA pta, SH sh);

private:

  Env &e;

};


#endif

#ifdef F_POLYGON_API


struct MaterialDef

{

  std::string material_name;

  float Ns;

  float Ni;

  float d;

  float Tr;

  int illum;

  float Ka_x, Ka_y, Ka_z;

  float Kd_x,Kd_y,Kd_z;

  float Ks_x,Ks_y,Ks_z;

  float Ke_x,Ke_y,Ke_z;

  std::string map_Ka;

  std::string map_Kd;

  std::string map_d;

  std::string map_bump;

  std::string bump;

};


class FloatSceneApi

{

public:

  IMPORT FloatSceneApi(Env &e);


  BM render_with_lipschitz_and_forallexists(EveryApi &ev, FS bounding_spheres, O obj, float z, float z_dist, unsigned int bg_color, float per_pixel_sample_rate, float start_x, float end_x, float start_y, float end_y, int sx, int sy);

  FS fs_sphere(float center_x, float center_y, float center_z, float radius);

  FS fs_min(FS a1, FS a2);

  FS fs_min_arr(std::vector<FS> arr);

  FS fs_bound_x(FS left, FS right, float x);

  FS fs_bound_y(FS left, FS right, float y);

  FS fs_bound_z(FS left, FS right, float z);


  FS color_scene(FS scene, unsigned int color, int fptr_enum);

  FS fd_to_fs(EveryApi &ev, FD fd);

  VX fs_to_vx(EveryApi &ev, int sx, int sy, int sz, float ssx, float ssy, float ssz, FS obj, float pos);

  O fs_to_o(FS obj, float val);

  ML fs_to_ml(EveryApi &ev, int sx, int sy, int sz,

        float ssx, float ssy, float ssz,

        FS obj,

        float pos,

          //std::vector<P> vec,

          MT mat, float sx1, float sy1, float sz1);

  ML fs_to_ml3(EveryApi &ev, int sx, int sy, int sz,

        float ssx, float ssy, float ssz,

        FS obj,

        float pos,

          //std::vector<P> vec,

           MT mat, float sx1, float sy1, float sz1,

           float border_width, unsigned int border_color);

  ML fs_to_ml4(EveryApi &ev, int sx, int sy, int sz,

        float ssx, float ssy, float ssz,

        FS obj,

        float pos,

          //std::vector<P> vec,

           float sx1, float sy1, float sz1,

           float border_width, unsigned int border_color);

  ML o_to_ml3(EveryApi &ev, int sx, int sy, int sz,

        float ssx, float ssy, float ssz,

        O obj,

        float pos,

          //std::vector<P> vec,

           MT mat, float sx1, float sy1, float sz1,

           float border_width, unsigned int border_color);

  ML o_to_ml4(EveryApi &ev, int sx, int sy, int sz,

        float ssx, float ssy, float ssz,

        O obj,

        float pos,

          //std::vector<P> vec,

           float sx1, float sy1, float sz1,

           float border_width, unsigned int border_color);

  ML fs_to_ml2(EveryApi &ev, int sx, int sy, int sz,

        float ssx, float ssy, float ssz,

        FS obj,

        float pos,

          //std::vector<P> vec,

          MT mat, float sx1, float sy1, float sz1, float border_width, unsigned int border_color);

private:

  Env &e;

};


class PolygonApi

{

public:

    IMPORT PolygonApi(Env &e);

    IMPORT ~PolygonApi();

  IMPORT P solid_of_revolution(EveryApi &ev, int numfaces, float p_x, float p_y, float p_z, float p1_x, float p1_y, float p1_z, std::string deltas, std::string radiuses);

  IMPORT P prepare_cache(std::string url, P p);

  IMPORT P sphere_rays(float center_x, float center_y, float center_z, float radius,

               float delta_alfa, float delta_beta,

               FS field,

               int maxiter, float c, std::vector<PT> vec);

  IMPORT ARR sphere_rays2(EveryApi &ev, float center_x, float center_y, float center_z, float radius,

               float delta_alfa, float delta_beta,

               FS field,

               int maxiter, float c, std::vector<PT> vec);

  IMPORT PV p_array(std::vector<P> vec);

  IMPORT ARR array_p_array(std::vector<PV> vec);

  IMPORT ARR seq_p_array(std::vector<P> vec, std::vector<P> vec2);

  IMPORT P interpolate_mesh_pair(P start_p, P end_p);

  IMPORT ARR interpolate_mesh_pair_arr(std::vector<P> start_ps, std::vector<P> end_ps);

  IMPORT P sort_faces_by_area(P p);

  IMPORT ML discard_shader(EveryApi &ev, ML mainloop);

  IMPORT ML acesfilm_shader(EveryApi &ev, ML mainloop);

  IMPORT P multiply_facecoll(P p, int sx, int sy, int sz);

  IMPORT P spatial_decimate(P p, float val);

  IMPORT TF decimate_tf(TF mesh, float val);

  IMPORT TF decimate_tf_zero(TF mesh);

  IMPORT P decimate(P p, float val);

  IMPORT P decimate2(P p, float val);

  IMPORT P decimate3(P p, float val);

  IMPORT P decimate_zeros(P p);

  IMPORT P decimate3_inv(P p, float val);

  IMPORT P decimate_without_holes(EveryApi &ev, P p, float, int, float, std::vector<BM>);

  IMPORT bool ready_to_prepare(ML p);

  IMPORT DS tf_ds_inv(TF tf, int flags);

  IMPORT void load_glb_from_temp(std::string filename, void (*fptr)(void*), void*, bool &success);

  IMPORT TF load_glb_from_temp2(std::string filename);

  IMPORT void load_glb_from_temp3(std::string filename);

  IMPORT TF tf_glb_tf(EveryApi &ev, TF tf, std::string url);

  IMPORT TF meshy(EveryApi &ev, std::string prompt, std::string filename);

  IMPORT P p_ds2(EveryApi &ev, DS ds2);

  IMPORT P load_ds_from_temp_p(EveryApi &ev, P p, std::string url);

  IMPORT ML fade_pic(EveryApi &ev, BM bm1, float start_time, float transition_time, float end_time, float end_transition_time,

          BM bm2, float start2_time, float transition2_time, float end2_time, float end2_transition_time);

  IMPORT P no_batch_map(P p);

  IMPORT CS colourspace_sphere2();

  IMPORT CS colourspace_or_elem(CS cs, float delta_t, CS cs2, float delta_t2);

  IMPORT CS colourspace_func(std::function<unsigned int (float,float,float,float)> f, float sx, float ex, float sy, float ey, float sz, float ez, float st, float et);

  IMPORT CSI colourspace_sample(CS i, int sx, int sy, int sz);

  IMPORT P colourspace_facecoll(CSI i, float t);

  IMPORT P polygon_fetch(P p);

  IMPORT PL rect_pl(float start_x, float end_x,

         float start_y, float end_y,

         float start_z, float end_z,

         bool x_or_z,

         bool start_or_end_higher);

  IMPORT PL or_elem_pl(PL pl1, PL pl2);

  IMPORT PL array_pl(std::vector<PL> vec);


  IMPORT P render_pl(PL pl);

  IMPORT P material_face_collection(P base, P material);

  IMPORT ML mixshader_shader(EveryApi &ev, ML ml, float mix=0.5);

  IMPORT P extract_large_polygons(P p, float minimum_size, bool reverse);

  IMPORT P x_split(P p, float x, float x_0, float x_1);

  IMPORT P y_split(P p, float y, float y_0, float y_1);

  IMPORT P z_split(P p, float z, float z_0, float z_1);

  IMPORT P optimize_mesh(P p);

  IMPORT P ambient_occulsion_color(P p);

  IMPORT P face_cutter(P p, float start, float end);

  IMPORT P heightmap2(FB bm, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z);

  IMPORT FB fractal_mountain(int level, int sx, int sy);

  IMPORT P combine_anim(P p1, P p2, float start_time, float end_time);

  IMPORT P sphere_anim(float c_x, float c_y, float c_z,

        float c2_x, float c2_y, float c2_z,

        float r, float r2, float start_time, float end_time, int numfaces1, int numfaces2);

  IMPORT P cone_anim(float c_x, float c_y, float c_z,

          float d_x, float d_y, float d_z,

          float c2_x, float c2_y, float c2_z,

          float d2_x, float d2_y, float d2_z,

          float r1, float r2,

          float r1_2, float r2_2, int numfaces, float start_time, float end_time);

  IMPORT P cube_anim(float start_x, float end_x,

          float start_y, float end_y,

          float start_z, float end_z,

          float start_x2, float end_x2,

          float start_y2, float end_y2,

          float start_z2, float end_z2,

          float start_time, float end_time);

  IMPORT ARR or_elem_anim(P p1, P p2, float time);

  IMPORT ML anim_render(AA, float delta);

  IMPORT ML p_mtl2_prepare(P p);

  IMPORT ARR material_choose(std::vector<MT> mat, std::vector<P> p);

  IMPORT ARR comb_mat(GameApi::EveryApi &ev, std::vector<MT> vec1, std::vector<MT> vec2);

  IMPORT ARR p_mtl_materials(EveryApi &ev, P P);

  IMPORT ARR p_mtl2_materials(EveryApi &ev, P p);

  IMPORT P get_face_count(P p);

  IMPORT P transparent_separate2(P p, std::vector<BM> vec, bool opaque);

  IMPORT P transparent_separate(P p, BM bm, bool opaque, bool force_transparent, bool force_opaque);

  IMPORT void sort_vertices(VA va, M m);

  IMPORT P remove_faces(P p);

  IMPORT P combine_textures(P p1, P p2);

  IMPORT P slow_calc_lights(P p, float light_dir_x, float light_dir_y, float light_dir_z);

  IMPORT MS identity_pose(int li_size);

  IMPORT ARR gltf_split_faces2(EveryApi &ev, TF model0, int mesh_index, int prim_index, int max_attach);


  IMPORT ARR split_faces(P p, ATT att, int max_attach);

  IMPORT std::vector<P> orig_pose(EveryApi &ev, P p, LI li, int li_size);

  IMPORT std::vector<P> orig_pose2(EveryApi &ev, std::vector<P> vec, LI li, int li_size);

  IMPORT MS new_pose(EveryApi &ev, LI li_orig, LI li);

  IMPORT ML ske_anim(EveryApi &ev, P mesh, LI orig_pose, int li_size, std::string url, std::vector<LI> new_poses, MT mat);

  IMPORT ML ske_anim2(EveryApi &ev, std::vector<P> mesh, LI orig_pose, int li_size, std::string url, std::vector<LI> new_poses, MT mat);

  IMPORT ATT find_attach2(P p, LI li);

  IMPORT ATT attach_cache(ATT a, P p);


  IMPORT P convex_hull(PTS pts);

  IMPORT P optimize_mesh(P p, float max);

  IMPORT P toon_outline(P p, float border_width);

  IMPORT ML cullface(ML ml, bool b, bool is_gltf);

  IMPORT P substitute(P p1, P p2, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, float normal);

  IMPORT ARR block_divide(P p, float pos_x, float pos_z, int sx, int sz, float delta_x, float delta_z);

  IMPORT ARR block_render(GameApi::EveryApi &ev, std::vector<P> vec, MT mat);

  IMPORT ARR block_render2(GameApi::EveryApi &ev, std::vector<P> vec, std::vector<MT> mat);

  IMPORT ML block_draw(std::vector<ML> vec, float pos_x, float pos_z, int sx, int sz, float delta_x, float delta_z, int view);

  IMPORT P bitmapsized_quad(BM bm);

  // Array functions

  IMPORT PTS voxelarray_to_pts(AV arr, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z);

  IMPORT AV pts_to_voxel(PTS pts, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, int sx, int sy, int sz);

  IMPORT AV av_unique(AV arr);

  IMPORT ML quad_tree(P p);

  IMPORT P mix_mesh(P p, PTS points, float val);

  IMPORT ARR poly_array(std::vector<P> vec);

  IMPORT P poly_index(ARR arr, int idx);

  IMPORT int poly_size(ARR arr);

  IMPORT ARR poly_execute(EveryApi &ev, ARR arr, std::string gameapi_script);

  IMPORT P normal_darkness(P p, float dark);

  IMPORT P gltf_load( EveryApi &ev, TF model, int mesh_index, int prim_index, TRR resize_transfer_id );

  IMPORT P gltf_load_nr( EveryApi &ev, TF model, int mesh_index, int prim_index , TRR resize_transfer_id);

  IMPORT BM gltf_load_bitmap( GameApi::EveryApi &ev, TF model, int image_index );

  IMPORT ARR material_extractor_p(P p, int start_index, int end_index, int num_slots, int current_slot);

  IMPORT ARR material_extractor_bm(P p, int start_index, int end_index);

  IMPORT ARR material_extractor_mt(EveryApi &ev, P p, float mix, int start_index, int end_index);

  IMPORT MT material_index(EveryApi &ev, std::vector<MT> vec, int index);

  IMPORT ARR material_arr(std::vector<MT> vec, int start_range, int end_range);

  IMPORT ML mesh_anim_display_inst(EveryApi &ev, P p, FF val, MN move, MT mat, MS inst);

  IMPORT ML mesh_anim_display_inst2(EveryApi &ev, P p, FF val, MN mn, MT mat, PTS inst);

  IMPORT ML mesh_anim(EveryApi &ev, std::vector<P> vec, std::vector<MN> move, std::vector<MT> mat, std::vector<MS> inst, std::vector<IF> states, std::string url);

  IMPORT P mesh_elem(P start, P end);

  IMPORT P bar_chart( GameApi::EveryApi &ev, std::string url, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, float per );

  IMPORT P bar_chart2( GameApi::EveryApi &ev, std::string url, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, float per, float per2 );

  IMPORT LI li_piechart(float c_x, float c_y, float c_z, float start_angle, float end_angle, float radius, int numsteps);

  IMPORT P p_piechart(EveryApi &ev, float c_x, float c_y, float start_angle, float end_angle, float radius, int numsteps, float start_z, float end_z);

  IMPORT ML piechart_full(EveryApi &ev, float c_x, float c_y, std::string url, float radius, int numsteps, float start_z, float end_z);

  IMPORT P li_polygon(LI li, float width);

  IMPORT P gradient_color(P p, float p_x, float p_y, float p_z, float v_x, float v_y, float v_z, unsigned int start_color, unsigned int end_color);

  IMPORT P texture_add(P p, BM bm);

  IMPORT P stl_load(std::string url);

  IMPORT P fix_vertex_order(P p);

  IMPORT P filter_invisible(P p, float size);

  IMPORT std::vector<TXID> mtl_parse(EveryApi&ev, std::vector<unsigned char> mtlfilecontents, std::string url_prefix, int delta=0);


  IMPORT ML m_bind_inst_many(EveryApi &ev, std::vector<P> vec, std::vector<MT> materials, PTS pts, int ticks);

  IMPORT ML m_bind_many(EveryApi &ev, std::vector<P> vec, std::vector<MT> materials, int ticks);

  IMPORT ML load_scene(EveryApi &ev, std::string url, int sx, int sy);


  IMPORT CG curve_group_from_anim(MA ma, float start_time, float end_time);

  IMPORT MA meshanim(std::vector<P> vec, float start_time, float end_time);

  IMPORT P meshanim_mesh(MA ma, float time);

  IMPORT P meshanim_mesh2(MA ma, float time1, float time2);

  IMPORT ARR meshanim_anim_meshes(MA ma, float start_time, float delta_time, int count);


  IMPORT P lod_choose(std::vector<P> vec, std::string name);

  IMPORT P lod_set(P p, std::string name, int value);

  IMPORT IF lod_select(float start_dist, float dist_step, int max_value);


  IMPORT BM shadow_map(EveryApi &ev, P p, float p_x, float p_y, float p_z, int sx, int sy);

  IMPORT BB shadow_map2(P p, float p_x, float p_y, float p_z, int sx, int sy, P quad);

  IMPORT BM shadow_map3(EveryApi &ev, P objs, float p_x, float p_Y, float p_z, int sx, int sy, P quad);

  IMPORT ML choose_time(ML next, std::vector<ML> vec, float delta_time);

  IMPORT ML anim(EveryApi &ev, ML next, MA anim, float start_time, float delta_time, int count);

  IMPORT ML anim_bind(EveryApi &ev, ML next, MA anim, MT material, float start_time, float delta_time, int count);


  // normal functions

  IMPORT void print_stat(P p);

  IMPORT void print_data(P p);

  IMPORT void print_data2(P p);

  IMPORT void print_stat(VA p);

    IMPORT P p_empty();

        IMPORT P load_model(std::string filename, int obj_num);

  IMPORT P load_model_all(std::string filename, int count);

  IMPORT P load_model_all_no_cache(std::string filename, int count, bool nr);

  IMPORT P load_model_all_no_cache(LoadStream * file_data, int count, bool nr);

  IMPORT P load_model_all_no_cache_mtl(std::string filename, int count, std::vector<std::string> material_names, bool nr);

  IMPORT P load_model_all_no_cache_mtl(LoadStream * file_data, int count, std::vector<std::string> material_names, bool nr);

  IMPORT P p_url(EveryApi &ev, std::string url, int count);

  IMPORT P ds_cache_url(EveryApi &ev, P input, int count);

  IMPORT P p_url_nr(EveryApi &ev, std::string url, int count);

  IMPORT P p_mtl(EveryApi &ev, std::string obj_url, std::string mtl_url, std::string prefix, int count);

  IMPORT P ds_cache_mtl(EveryApi &ev, P input, int count, std::string mtl_url, std::string url_prefix);

  IMPORT P p_mtl_nr(EveryApi &ev, std::string obj_url, std::string mtl_url, std::string prefix, int count);

  IMPORT ARR p_mtl2(EveryApi &ev, std::string obj_url, std::string mtl_url, std::string prefix, int count, int start_index, int end_index, float mix);

  IMPORT ARR p_mtl2_nr(EveryApi &ev, std::string obj_url, std::string mtl_url, std::string prefix, int count, int start_index, int end_index, float mix);

  IMPORT ARR p_mtl_d(P p);

  IMPORT ARR p_mtl_bump(P p);

  IMPORT P p_url_mtl(EveryApi &ev, std::string url, int count, std::vector<std::string> material_names);

  IMPORT P p_ds(EveryApi &ev, const unsigned char *beg, const unsigned char *end);

  IMPORT P p_ds_url(EveryApi &ev, std::string url);

  IMPORT DS p_ds_inv(P model, int flags=-1); // flags at GameApi_pl.cc/DSFlags

  IMPORT P file_cache(P model, std::string filename, int obj_num);

  IMPORT P resize_to_correct_size(P model);

  IMPORT P resize_to_correct_size_g(P model, TRR resize_transfer_id);

        IMPORT void save_model(P poly, std::string filename);

  IMPORT ML save_model_ml(P poly, std::string filename);

  IMPORT P prepare_cut(P p);

  IMPORT P mesh_resize(P p, float start_x, float end_x, float start_y, float end_Y, float start_z, float end_z);


  IMPORT P texture_splitter(P p, int start_index, int end_index);

  IMPORT P texture_splitter2(P p, int num, int num_slots, int current_slot);

  IMPORT P replace_texture(P p, BM bm, int num);

  IMPORT P texture_storage(P p, int texture_sx, int texture_sy);

  IMPORT P light_transport(P p, int num, float light_dir_x, float light_dir_y, float light_dir_z);

  IMPORT BM texture_from_p(P p, int num);


  IMPORT P smooth_normals2(P p);

  IMPORT P from_normal_to_texcoord(P p);


  //IMPORT P line(PT p1, PT p2);

    IMPORT P triangle(PT p1, PT p2, PT p3);

    IMPORT P quad(PT p1, PT p2, PT p3, PT p4);

  IMPORT P quad_x(float x,float y1, float y2,float z1, float z2);

    IMPORT P quad_y(float x1, float x2,float y,float z1, float z2);

    IMPORT P quad_z(float x1, float x2,float y1, float y2,float z);

        IMPORT P fullscreen_quad(EveryApi &ev);

  IMPORT ML bg_image(EveryApi &ev, BM bm);

  IMPORT P vr_fullscreen_quad(EveryApi &ev, bool is_right);

  IMPORT P tri_strip(PT *array, int size);

        IMPORT P polygon2(std::vector<PT> vec);

        IMPORT P polygon(PT *array, int size); // use render_dynamic with this.

        IMPORT P polygon3(PTS points);

    IMPORT P tri_vertex_array(float *v_array, int v_size,

             float *n_array, int n_size,

             unsigned int *c_array, int c_size,

             float *tex_array, int tex_size,

             float **attrib_array, int a_size1, int a_size2);

    IMPORT P cube(float start_x, float end_x,

     float start_y, float end_y,

     float start_z, float end_z);

    IMPORT P cube(PT *p); // 8 points needed

  IMPORT P rounded_cube(EveryApi &ev, float start_x, float end_x,float start_y, float end_y,float start_z, float end_z,float round_radius);

  IMPORT P repeat_xy_p(EveryApi &ev, P p, float start_x, float start_y, float dx, float dy, int sx, int sy);

  IMPORT P repeat_xz_p(EveryApi &ev, P p, float start_x, float start_z, float dx, float dz, int sx, int sz);

  IMPORT P repeat_yz_p(EveryApi &ev, P p, float start_y, float start_z, float dy, float dz, int sy, int sz);

  IMPORT P deform(P obj, O bools, float dx, float dy, float dz);

  IMPORT P flip_normals(P obj);

  IMPORT P color_map2(BM bm, PT pos, V u_x, V u_y);

  IMPORT P color_map(BM bm, float start_x, float end_x, float start_y, float end_y, float z);

  IMPORT P color_map3(BM bm, FB height, PT pos, V u_x, V u_y);

  IMPORT P color_map3(BM bm, FB height, float sx, float sy, float z);

  IMPORT P color_map3_cyl(BM bm, FB height, PT pos, V u_x, V u_y);

  IMPORT P color_map3_cyl(BM bm, FB height, float sx, float sy, float z);

  IMPORT P color_map3_sph(BM bm, FB height, PT pos, V u_x, V u_y);

  IMPORT P color_map3_sph(BM bm, FB height, float sx, float sy, float z);

  IMPORT P color_map4(BM bm, FB height, float sx, float sy, float z);

  IMPORT P cube_map(float start_x, float end_x,float stary_y, float end_y,float start_z, float end_z,BM bm_front, BM bm_back, BM bm_left, BM bm_right, BM bm_top, BM bm_bottom);

    IMPORT P sphere(PT center, float radius, int numfaces1, int numfaces2);

  IMPORT P sphere_map(float c_x, float c_y, float c_z, FB fb, float start_radius, float end_radius, float start_values, float end_values, int sx, int sy);

  IMPORT P plane_map(float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, float start_values, float end_values, FB fb, int sx, int sy);

    IMPORT P cone(int numfaces, PT p1, PT p2, float rad1, float rad2);

  IMPORT P torus2(EveryApi &ev, int numfaces1, int numfacesw2, PT center, float radius1, float radius2);

  IMPORT P torus(int numfaces1, int numfaces2, PT center, V u_x, V u_y, float radius1, V uu_x, V uu_y, float radius2);

    IMPORT P ring(float sx, float sy, float x, int steps); // use RingEffect::Init() to implement

  IMPORT P disc(EveryApi &ev, int numfaces, float center_x, float center_y, float center_z, float normal_x, float normal_y, float normal_z, float radius);

  enum HeightMapType { EQuad, ETriangle };

  IMPORT P heightmap(BM bm, HeightMapType t,

          float min_x, float max_x,

          float min_y, float max_y,

          float min_z, float max_z);

  IMPORT P heightmap(FB fb, std::function<P (float)> f, float dx, float dz);

  IMPORT P circular_span(EveryApi &ev, LI li, float delta_angle_around_y_axis, int num_steps);

  IMPORT P linear_span(EveryApi &ev, LI li, float dx, float dy, float dz, int num_steps);

  IMPORT P cut_faces(P p, O o, CT cutter);

  IMPORT P tri_to_quad(P p);

  IMPORT P curve_to_poly(C c, float start_x, float end_x, float start_y, float end_y, float start_angle, float end_angle, int numinstances);


  IMPORT P split_p(P p, int start_face, int end_face);

  IMPORT P subpoly_change(P p, P p2, O choose);


  IMPORT P span(LI li, M matrix, int num_steps);

  IMPORT P fromsurface(S s, float thickness);

  IMPORT P fromsurface(S s1, S s2, C curve); // surfacebetweensurfaces


  IMPORT P sprite_bind(P p, TX tx, int id);

  IMPORT P sprite_bind(P p, Q bm, TX tx);

  P sprite_bind_1(P p, Q bm, TX tx);

  IMPORT P texture(P orig, BM bm, int bm_choose = -1); // all quads


  IMPORT P line_to_cone(EveryApi &ev, LI li, float size, int numfaces);

  IMPORT ML line_to_cone2(EveryApi &ev, LI li, float size, int numfaces, MT mt);

  IMPORT ML line_to_cone3(EveryApi &ev, LI li, float size, int numfaces, MT mt, unsigned int color);

  IMPORT P static_instancing(EveryApi &ev, P obj, PTS pos);

  IMPORT P static_instancing_array(EveryApi &ev, std::vector<P> vec, PTS pos);

  IMPORT P static_instancing_vertex_color(EveryApi &ev, P obj, PTS pos);

  IMPORT P static_instancing_matrix(EveryApi &ev, P obj, MS matrix_array);

  IMPORT LI li_static_instancing_matrix(EveryApi &ev, LI obj, MS matrix_array);

  IMPORT P static_instancing_with_color(EveryApi &ev, P obj, BM bm, float start_x, float end_x, float start_y, float end_y, float z);


  IMPORT P color_distance(P faces, float center_x, float center_y, float center_z, unsigned int color_center, unsigned int color_dist, float dist_center, float dist_dist);

  IMPORT P color(P orig, unsigned int color);

  IMPORT P color_voxel(P orig, VX colours, PT p, V u_x, V u_y, V u_z);

  IMPORT P mix_color(P orig, P orig2, float val);

  IMPORT P min_color(P orig, P orig2);

  IMPORT P max_color(P orig, P orig2);

  IMPORT P color_lambert(P orig, unsigned int color, float light_dir_x, float light_dir_y, float light_dir_z, float pow, float intensity);

  IMPORT P texcoord_cube(P orig,PT o, PT u_x, PT u_y, PT u_z, PT tex_o, PT tex_x, PT tex_y, PT tex_z); // tex_* are 2d

  IMPORT P texcoord_default(P orig);

  IMPORT P texcoord_manual(P orig, float p1_x, float p1_y,float p2_x, float p2_y,float p3_x, float p3_y,float p4_x, float p4_y);

  IMPORT P texcoord_spherical(PT center, P orig);

  IMPORT P texcoord_spherical2(EveryApi &ev, PT center, float r, P orig);

  IMPORT P texcoord_cylindar(P orig, float start_y, float end_y);

  IMPORT P texcoord_from_normal(P p);

  IMPORT P texcoord_from_normal2(P p);

  IMPORT P texcoord_plane(P p, float start_x, float end_x, float start_y, float end_y);

  IMPORT P texcoord_subarea(P p, float start_x, float end_x, float start_y, float end_y);

  IMPORT P fix_texcoord(P p);

  IMPORT P color_cube(P orig,

           PT o, PT u_x, PT u_y, PT u_z,

           unsigned int color_o, unsigned int color_x, unsigned int color_y, unsigned int color_z);

  IMPORT P color_faces(P orig,unsigned int color_1, unsigned int color_2,unsigned int color_3, unsigned int color_4);

  IMPORT P color_from_normals(P orig);

  IMPORT P color_alpha(P orig, unsigned int alpha);

  IMPORT P color_grayscale(P orig);

  IMPORT P color_from_texcoord(P orig,unsigned int color_1, unsigned int color_2,unsigned int color_3, unsigned int color_4);

  IMPORT P color_range(P orig, unsigned int source_upper, unsigned int source_lower, unsigned int upper_range, unsigned int lower_range);


  IMPORT P texcoord_poly(P orig, int facenum, PT *array, int size);

  IMPORT P choose_texture(P orig, int num);

  IMPORT P color_poly(P orig, int facenum, unsigned int *array, int size);


  IMPORT P quads_to_triangles(P p);

  IMPORT P flip_polygon_order(P p);


  IMPORT P skeletal_anim(P p, PT p_0, PT p_1, PT n_0, PT n_1);


  IMPORT P build_offsets(P p, std::vector<PT> vec);


  IMPORT P or_elem(P p1, P p2);

  IMPORT P or_array(P *array, int size);

  IMPORT P or_array2(std::vector<P> vec);

  IMPORT P or_array3(std::vector<P> vec); // no memory usage.

  P or_array_1(P *array, int size);

  IMPORT P and_not_elem(EveryApi &ev, P p1, P p_not,

            O o1, O o_not,

            CT cutter1, CT cutter_not);

  IMPORT P intersect(EveryApi &ev, P p1, P p2,

             O o1, O o2,

             CT cutter1, CT cutter2);

  IMPORT P alt(std::vector<P> vec, int index);

  //P and_not_elem(P p1, P p_not);


  IMPORT P grid(PT o, PT u_x, PT u_y, int num_x, int num_y);

  IMPORT P grid(PT o, PT u_x, PT u_y, int num_x, int num_y, P *grid);


  IMPORT P translate(P orig, float dx, float dy, float dz);

  P translate_1(P orig, float dx, float dy, float dz);

  IMPORT P rotatex(P orig, float angle);

  IMPORT P rotatey(P orig, float angle);

  IMPORT P rotatez(P orig, float angle);

  IMPORT P rotate(P orig, PT pt, V axis, float angle);

  IMPORT P scale(P orig, float sx, float sy, float sz);

  IMPORT P matrix(P orig, M mat);

  IMPORT P matrix44(P orig, M mat); // otherwise the same as matrix, but doesnt do normals.


  IMPORT P log_coords(P p);

  IMPORT P log_coords2(P p, int x_count, int y_count, float sx, float sy, float sz);

  IMPORT P spherical_wave(P p, float r1, float fr_1, float r2, float fr_2);


  IMPORT P unit_cube(P orig, PT pos, V u_x, V u_y, V u_z);

  IMPORT P unit_to_cube(P orig, PT pos, V u_x, V u_y, V u_z);

  IMPORT P unit_to_flex(P orig,

            PT bTL, PT bTR, PT bBL, PT bBR,

            PT fTL, PT fTR, PT fBL, PT fBR);


  IMPORT P move(P orig, PT obj_0, V obj_x, V obj_y, V obj_z,

     PT world_0, V world_x, V world_y, V world_z);


  IMPORT L color_lighting(float dx, float dy, float dz,

           int r, int g, int b, int a);

  IMPORT L radial_lighting(float dx, float dy, float dz,

            int r, int g, int b, int a,

            int r2, int g2, int b2, int a2,

            float dist);

  IMPORT L array_lighting(L *array, int size);

  IMPORT P lighting(P orig, L lighting);

  IMPORT BM light_bm(L lighting, P poly);


  IMPORT P shadow(P orig, PT pos, V u_x, V u_y, V light_vec);

  IMPORT P reflection(P orig, PT pos, V u_x, V u_y, V ref_vec); // note, requires transparent object, which are not yet implemented.


  IMPORT P single_texture(P orig, BM texture);


  IMPORT P anim_array(P *array, int size); // OLD


  IMPORT P splitquads(P orig, int x_count, int y_count);

  IMPORT P change_positions(P orig, std::function<PT(PT p, int face, int point)> f);

  IMPORT P change_normals(P orig, std::function<V(V orig, int face, int point)> f);

  //P change_attrib(P orig, float (*fptr)(float orig, int face, int point, void *data), void *data=0);

  //P change_attribI(P orig, int (*fptr)(int orig, int face, int point, void *data), void *data=0);

  IMPORT P change_colors(P orig, std::function<unsigned int(unsigned int orig, int face, int point)> f);

  IMPORT P change_texture(P orig, std::function<int(int face)> f, BM *array, int size);


  IMPORT P recalculate_normals(P orig);

  IMPORT P spherical_normals(P p, float p_x, float p_y, float p_z);

  IMPORT P average_normals(P orig, int sx, int sy);

  IMPORT P smooth_normals(P orig);

  IMPORT P memoize(P orig);

  IMPORT P memoize_all(P orig);

  IMPORT P persistent_cache(P orig, std::string filename);


  IMPORT S s_spherical(float c_x, float c_y, float c_z, FB fb, float start_radius, float end_radius, float start_values, float end_values);

  IMPORT P s_sample(S surf, int sx, int sy);


  IMPORT ID find_point_id(P p, int facenum, int pointnum); // save id's to ENV.

  IMPORT ID find_normal_id(P p, int facenum, int pointnum);

  IMPORT ID find_color_id(P p, int facenum, int pointnum);

  IMPORT ID find_texcoord_id(P p, int facenum, int pointnum);

  IMPORT ID id_array(ID *array, int size);

  IMPORT void preparepoly(P p, int bbm_choose = -1);

  IMPORT void renderpoly(P p, float x, float y, float z);

  IMPORT void renderpoly(P p, PT pos);

  IMPORT void renderpoly(P p, int choose, float x, float y, float z);

  IMPORT void prepare(P p, int bbm_choose = -1);

  IMPORT void render(P p, int choose, float x, float y, float z);

  IMPORT void update(VA va);

  IMPORT bool is_texture(VA va);

  IMPORT bool is_array_texture(VA va);


  IMPORT void update_vertex_array(VA va, P p, bool keep=false);

  IMPORT void update_vertex_array_no_memory(VA va, P p);

  IMPORT ML update_vertex_array_ml(VA va, P p, bool keep=false);

  IMPORT VA create_vertex_array(P p, bool keep=false); // slow

  IMPORT void create_vertex_array_hw(VA va);

  IMPORT void delete_vertex_array(VA arr);

  IMPORT VA create_vertex_array_attribs(P p, bool keep,std::vector<int> attribs, std::vector<int> attribi); // slow

  IMPORT void render_vertex_array(VA va); // fast

  IMPORT void clone(VA va);

  IMPORT void render_vertex_array_dyn(VA va, DC dc, MainLoopEnv &e);

  IMPORT void prepare_vertex_array_instanced(ShaderApi &ev, VA va, PTA pta, SH sh);

  IMPORT void render_vertex_array_instanced(ShaderApi &ev, VA va, PTA pta, SH sh, int hide_n = -1); // fast

  IMPORT void prepare_vertex_array_instanced_matrix(ShaderApi &ev, VA va, MSA pta, SH sh);

  IMPORT void render_vertex_array_instanced_matrix(ShaderApi &ev, VA va, MSA pta, SH sh, int hide_n = -1); // fast

  IMPORT ML render_vertex_array_ml(EveryApi &ev, VA va);

  IMPORT ML render_vertex_array_ml2(EveryApi &ev, P va);

  IMPORT ML render_vertex_array_ml2_texture(EveryApi &ev, P va, std::vector<BM> vec, std::vector<int> types=std::vector<int>(), std::vector<std::string> id_labels=std::vector<std::string>(), std::vector<bool> is_srgb=std::vector<bool>());

  IMPORT ML render_vertex_array_ml2_texture_id(EveryApi &ev, P va, std::vector<TXID> *vec);

  IMPORT ML render_vertex_array_ml2_cubemap(EveryApi &ev, P va, std::vector<BM> vec);

  IMPORT ML render_vertex_array_ml2_texture2(EveryApi &ev, P p);

  IMPORT SBM texture_sbm();

  IMPORT SBM sbm_circle(float start_time, float end_time, float start_pos_x, float start_pos_y, float end_pos_x, float end_pos_y, float start_radius, float end_radius);

  IMPORT SBM sfo_sbm(EveryApi &ev, SFO sfo);

  IMPORT SBM combine_sbm(SBM texture1, SBM texture2);

  IMPORT SBM bloom_cut_sbm(SBM texture, float r, float g, float b);

  IMPORT SBM blur_sbm(SBM texture, float pixel_x, float pixel_y);

  IMPORT ML sbm_texture(EveryApi &ev, ML mainloop, SBM bitmap);

  IMPORT ML render_dynamic_ml(EveryApi &ev, P p, DC dyn);

  IMPORT ML dist_field_mesh_shader(EveryApi &ev, ML mainloop, SFO sfo);

  IMPORT ML mesh_color_shader(EveryApi &ev, ML mainloop, SFO sfo);

  IMPORT ML sfo_sandbox_shader(EveryApi &ev, ML mainloop, SFO sfo);

  IMPORT ML water_shader(EveryApi &ev, ML mainloop, unsigned int color1, unsigned int color2, unsigned int color3, float center_x, float center_y, float center_z, float wave_mult, float time_mult);

  IMPORT ML glowedge_shader(EveryApi &ev, ML mainloop, float white_level, float gray_level, float edge_pos);

  IMPORT ML newshadow_shader_1(EveryApi &ev, ML ml, float light_dir_x, float light_dir_y, float light_dir_z, float scale);

  IMPORT ML newshadow_shader_2_phong(EveryApi &ev, ML ml, float light_dir_x, float light_dir_y, float light_dir_z, float dark_level, float light_level, float scale);

  IMPORT ML newshadow_shader_2_gltf(EveryApi &ev, ML ml, float light_dir_x, float light_dir_y, float light_dir_z, float dark_level, float light_level, float scale, int texindex);

  IMPORT ML adjust_shader(EveryApi &ev, ML mainloop, unsigned int ad_color, float ad_dark, float ad_light);

  IMPORT ML blurred_render_shader(EveryApi &ev, ML mainloop, int numsamples, float blur_radius);

  IMPORT ML phong_shader(EveryApi &ev, ML mainloop, float light_dir_x, float light_dir_y, float light_dir_z, unsigned int ambient, unsigned int specular, unsigned int highlight, float pow);

  IMPORT ML phong_shader2(EveryApi &ev, ML mainloop, float light_dir_x, float light_dir_y, float light_dir_z, unsigned int ambient, unsigned int specular, unsigned int highlight, float pow);

  IMPORT ML vertex_phong_shader(EveryApi &ev, ML mainloop, float light_dir_x, float light_dir_y, float light_dir_z, unsigned int ambient, unsigned int highlight, float pow, float mix);

  IMPORT ML edge_shader(EveryApi &ev, ML mainloop, float edge_width, unsigned int edge_color);

  IMPORT ML gltf_anim_shader(GameApi::EveryApi &ev, ML ml_orig, std::vector<GameApi::ML> mls, int key, int mode, int timeid, TRA anim_transfer_id, int frame_skip);

  IMPORT ML globe_shader(EveryApi &ev, ML mainloop, float globe_r);

  //IMPORT ML ao_shader(EveryApi &ev, ML mainloop, float radius, int kernelsize, int noisesize);

  IMPORT ML colour_shader(EveryApi &ev, ML mainloop, float mix);

  IMPORT ML gi_shader(EveryApi &ev, ML mainloop, PTS points, float obj_size);

  IMPORT ML bump_phong_shader(EveryApi &ev, ML mainloop, float light_dir_x, float light_dir_y, float light_dir_z, unsigned int ambient, unsigned int highlight, float pow);

  IMPORT ML fog_shader(EveryApi &ev, ML mainloop, float fog_dist, unsigned int dark_color, unsigned int light_color);

  IMPORT ML shadow_shader(EveryApi &ev, ML mainloop, int tex_num, float p_x, float p_y, float p_z, unsigned int dark_color, float mix);

  IMPORT ML dyn_lights_shader(EveryApi &ev, ML mainloop, float light_pos_x, float light_pos_y, float light_pos_z, float dist, MN dyn_point);

  IMPORT ML shading_shader(EveryApi &ev, ML mainloop,unsigned int level1,unsigned int level2,unsigned int level3, float spec_size=5.0f, bool ambient=true, bool diffuse=true, bool specular=false);

  IMPORT ML spotlight_shader(EveryApi &ev, ML mainloop,int light_color_id, MN move);

  IMPORT ML coloured_lights_shader(EveryApi &ev, ML mainloop, float scale,

                   unsigned int color_1, unsigned int color_2, unsigned int color_3, unsigned int color_4, unsigned int color_5, unsigned int color_6, unsigned int color_7, unsigned int color_8,

                   PT pos_1, PT pos_2, PT pos_3, PT pos_4, PT pos_5, PT pos_6, PT pos_7, PT pos_8,

                   float dist_1, float dist_2, float dist_3, float dist_4, float dist_5, float dist_6, float dist_7, float dist_8);

  IMPORT ML ambient_shader(EveryApi &ev, ML mainloop,int ambient_color_id,float ambient_level);

  IMPORT ML noise_shader(EveryApi &ev, ML mainloop);

  IMPORT ML custom_shader(EveryApi &ev, ML mainloop, std::string v_shader, std::string f_shader, std::string v_funcname, std::string f_funcname);

  IMPORT ML dither_shader(EveryApi &ev, ML mainloop);

  IMPORT ML light_shader(EveryApi &ev, ML mainloop);

  IMPORT ML choose_color_shader(EveryApi &ev, ML mainloop, unsigned int color, float mix_val);

  IMPORT ML blur_shader(EveryApi &ev, ML mainloop, float x_val, float y_val);

  IMPORT ML bloom1_shader(EveryApi &ev, ML mainloop, float r_val, float g_val, float b_val);

  IMPORT ML wave_shader(EveryApi &ev, ML mainloop, float radius, float t_mult, float x_mult, float y_mult);

  IMPORT ML toon_shader(EveryApi &ev, ML mainloop);

  IMPORT ML fade_shader(EveryApi &ev, ML mainloop, float start_time, float end_time, float start_time2, float end_time2);

  IMPORT ML texture_shader(EveryApi &ev, ML mainloop, float mix);

  IMPORT ML colormix_shader(EveryApi &ev, ML mainloop, float mix);

  IMPORT ML texture_many_shader(EveryApi &ev, ML mainloop, float mix);

  IMPORT ML texture_cubemap_shader(EveryApi &ev, ML mainloop, float mix, float mix2);

  IMPORT ML texture_arr_shader(EveryApi &ev, ML mainloop, float mix);

  IMPORT ML skeletal_shader(EveryApi &ev, ML mainloop, std::vector<SA> vec);

  IMPORT ML gltf_shader(EveryApi &ev, ML mainloop, float mix, bool tex0, bool tex1, bool tex2, bool tex3, bool tex4, bool tex5, bool tex6, bool tex7, float roughness, float metallic, float basecolor0, float basecolor1, float basecolor2, float basecolor3, float occul, float emiss, bool spec, float diff_factor_r=1.0, float diff_factor_g=1.0, float diff_factor_b=1.0, float spec_factor_r=1.0, float spec_factor_g=1.0, float spec_factor_b=1.0, float glossi_factor=1.0, bool unlit=false, float emis2_r=0.0, float emis2_g=0.0, float emis2_b=0.0, float light_dir_x=0.0, float light_dir_y=0.0, float light_dir_z=-400.0, std::string cache_id="gltf", float self_mult=1.0, float rest_mult=0.0, bool emissive=false);

  IMPORT void explode(VA va, PT pos, float dist);

  //IMPORT int accexss_point_count(VA va, bool triangle);

  //IMPORT float *access_points(VA va, bool triangle, int face, int point);

  //IMPORT float *access_color(VA va, bool triangle, int face, int point);

  //IMPORT float *access_normals(VA va, bool triangle, int face, int point);

  //IMPORT float *access_texcoord(VA va, bool triangle, int face, int point);

  //IMPORT void update(VA va);


  IMPORT ML sprite_render(EveryApi &ev, BM bm, float start_x, float end_x, float start_y, float end_y, float z);

  IMPORT ML sprite_render_inst(EveryApi &ev, BM bm, PTS pts, float start_x, float end_x, float start_y, float end_y, float z);

  IMPORT ML sprite_render_fade(EveryApi &ev, BM bm, PTS pts, float start_x, float end_x, float start_y, float end_y, float z, bool flip, float start_time, float end_time);


  IMPORT P anim_target_vector(P p, V v);

  IMPORT P anim_target_scale(P p, PT center, float scale_x, float scale_y, float scale_z);

  IMPORT P anim_target_matrix(P p, M matrix);

  IMPORT P anim_endpoints(P p1, P p2); // must have similar 3d objects/same number of faces.

  IMPORT P anim_interpolate(P p, float val);


  IMPORT P counts(P p1, int numfaces);

  IMPORT P count_function(P p1, std::function<int(int face)> f);

  IMPORT P point_function(P p1, std::function<PT(int face, int point)> f);

  IMPORT P color_function(P p1, std::function<unsigned int(int face, int point)> f);

  IMPORT P texcoord_function(P p1, std::function<PT(int face, int point)> f);

  IMPORT P normal_function(P p1, std::function<V(int face, int point)> f);

  IMPORT P attrib_function(P p1, std::function<float(int face, int point, int idx)> f, int idx);

  IMPORT P attribi_function(P p1, std::function<int(int face, int point, int idx)> f, int idx);


  // must call prepare for P before these.

  IMPORT int get_tri_vertex_array_frames(P p);

  IMPORT int get_tri_vertex_array_rows(P p);

  IMPORT void get_tri_vertex_array(P p, int choose, int row,

                int *v_size, float **v_array,

                int *n_size, float **n_array,

                int *c_size, unsigned int **c_array,

                int *tex_size, float **tex_array,

                int *attrib_size1, int *attrib_size2, float ***attrib_array);


  // this is for better animations, separates modified and non-modified parts

  IMPORT P create_static_geometry(P *array, int size);

  IMPORT P create_dynamic_geometry(P *array, int size);

  IMPORT void render_dynamic(P p, int array_elem, bool textures); // use memoize_all for p before calling this.


  IMPORT P world_from_bitmap(std::function<P (int c)> f, BM int_bm, float dx, float dy, int max_c);

  IMPORT P world_from_bitmap(EveryApi &ev, std::vector<P> vec, std::string filename, std::string chars, float dx, float dy, int sx, int sy);

  IMPORT P world_from_bitmap2(EveryApi &ev, std::function<P (int c, PT tl, PT tr, PT bl, PT br)> f, BM int_bm, FB float_bm, float dx, float dz, float height);

  IMPORT P world_from_voxel(std::function<P (unsigned int c)> f, VX voxel, float dx, float dy, float dz, int max_c);


  IMPORT P from_points(PTS p, std::function<P (int i, float x,float y,float z, unsigned int color)> f);

  IMPORT P from_lines(LI li, std::function<P (int i, float sx, float sy, float sz, float ex, float ey, float ez, unsigned int scolor, unsigned int ecolor)> f);

  IMPORT P from_polygon(P p, std::function<P (int face,

                          PT p1, PT p2, PT p3, PT p4)> f);

  P from_polygon_1(P p, std::function<P (int face,

                     PT p1, PT p2, PT p3, PT p4)> f);


  IMPORT P dist_from_lines(LI li, float d1, float d2, PT center);


  IMPORT BM renderpolytobitmap(EveryApi &ev, P p, SH sh, float x, float y, float z, int sx, int sy);

  IMPORT ML position_based_on_screen(ML obj);


  IMPORT std::vector<MaterialDef> parse_mtl(std::string filename);

  IMPORT std::string output_ml(std::string objfileurl, int count, std::string prefix, std::vector<MaterialDef> filenames);


  IMPORT int p_num_textures(P p);

  IMPORT void p_gen_texture(P p, int i);

  IMPORT BM p_texture(P p, int i);

  IMPORT void preparedone(P p);

private:

  PolygonApi(const PolygonApi&);

  void operator=(const PolygonApi&);


  void *priv;

  Env &e;

};


#endif


#ifdef F_WAVEFORM_API


class WaveformApi

{ // [0..length] -> [-1..1]

public:

    IMPORT WaveformApi(Env &e);

    IMPORT WV wv_empty(float length);

    IMPORT WV function(std::function<float(float)> f, float length, float min_value, float max_value);

    IMPORT WV sinwave(float length, float freq);

  IMPORT WV gaussian(float start_x, float end_x, float start_y, float end_y);

  IMPORT WV sum(WV w1, WV w2);

  IMPORT WV move(WV w1, float delta);

  IMPORT WV scale(WV w1, float scale);

        IMPORT WV repeat(WV wave, int num);

    IMPORT WV sample(float *array, int length, float samplelength);

    IMPORT WV int_sample(int *array, int length, float samplelength, int min_value, int max_value);

    IMPORT WV mix(WV orig, float pos, WV sample);

    IMPORT WV volume_ramp(WV orig, float old_y_value, float x_pos1, float x_pos2, float y_pos1, float y_pos2);

    IMPORT WV freq_change(WV orig, float old_freq, float new_freq);

    IMPORT float length(WV orig);

    IMPORT float get_value(WV orig, float val);

    IMPORT WV length_change(WV orig, float new_length);

  IMPORT WV step(bool b);

  IMPORT WV cubic(float f_0, float f_1, float df_0, float df_1, float min_y, float max_y);

    IMPORT BM waveform_bitmap(WV wave, int sx, int sy, unsigned int true_color, unsigned int false_color);

  IMPORT P waveform_rotated_polygon(WV wave, float start_angle, float end_angle, float radius, int num_samples, int num_waves);


  IMPORT PN std_polynomial(float x_5, float x_4, float x_3, float x_2, float x_1, float c);

  IMPORT PN df_dx(PN poly);

  IMPORT WV polynomial_wave(PN pn, float start_x, float end_x, float start_y, float end_y);


private:

  WaveformApi(const WaveformApi&);

  void operator=(const WaveformApi&);

  Env &e;

};


#endif

#ifdef F_SAMPLE_COLLECTION_API


class SampleCollectionApi

{

public:

  IMPORT SampleCollectionApi(Env &e);

  IMPORT SM empty();

  IMPORT SM add(SM orig, WV wave, int sample_rate, int id);

  //WV find_wave(SM orig, int id);

  //int find_rate(SM orig, int id);

  IMPORT void init_audio();

  IMPORT WAV prepare(SM samples);

  IMPORT void play_sample(int channel, WAV w, int id);

  void play_sample_1(int channel, WAV w, int id);

private:

  Env &e;

};


#endif

#ifdef F_TRACKER_API


class TrackerApi

{

public:

  IMPORT TrackerApi(Env &e);

  IMPORT TRK empty(int numchannels, int numslots);

  IMPORT TRK audio_slot(TRK orig, int channel, int slot, int duration, int sample);

  IMPORT TRK array(TRK *array, int size);

  IMPORT TBUF prepare(TRK trk);

  IMPORT void play_song(EveryApi &ev, TBUF buf, WAV samples, int framenum, int speed);

  IMPORT void play_mp3(std::string filename);

  IMPORT void play_ogg(std::string filename);

  IMPORT void play_ogg(const std::vector<unsigned char> &vec);

  IMPORT void play_ogg(void*);

  IMPORT void* setup_ogg(const std::vector<unsigned char> &data, int type);

  IMPORT void stop_music_playing();

  IMPORT ML play_wave_via_keypress(EveryApi &ev, ML ml, std::string url, int key);

private:

  Env &e;

};


#endif


class ShaderApi;


#ifdef F_STATE_CHANGE_API


class StateChangeApi

{

public:

    IMPORT StateChangeApi(Env &e, ShaderApi &api);

    IMPORT TR init(int paths);

    IMPORT TR linear(TR s, int path_num, std::function<P(float val)> f, float start_v, float end_v, float duration);

    TR linear_1(TR s, int path_num, std::function<P(float val)> f, float start_v, float end_v, float duration);

    IMPORT VV prepare(TR sc);

    VV prepare_1(TR sc);

    IMPORT VV prepareloop(float *array, int arraysize,

         std::function<P (float val)> f,

         float step_duration);

    IMPORT void render(VV sc, float time, SH shadero);

    IMPORT void render(VV sc, float time, SH shadero, float(*fptr)(int path, std::string name));

private:

  StateChangeApi(const StateChangeApi&);

  void operator=(const StateChangeApi&);

  Env &e;

  ShaderApi &api;

};


#endif


#ifdef F_NEW_PLANE_API


class NewPlaneApi

{

public:

  IMPORT NewPlaneApi(Env &e);

  IMPORT PP function(std::function<PT (int idx)> f, int num_points, float px, float py, float sx, float sy);

  IMPORT PP color_function(PP pl, std::function<unsigned int (int idx)> f);

  IMPORT PP polygon(std::vector<PT> vec);

  IMPORT PP polygon2(PTS pts); // kills z

  IMPORT PP color(PP p, unsigned int color);

  IMPORT PP trans(PP pl, float dx, float dy);

  IMPORT std::vector<PP> single_elem(PP p1);

  IMPORT std::vector<PP> or_elem(PP p1, PP p2);

  IMPORT std::vector<PP> or_elem(std::vector<PP> p1, std::vector<PP> p2);

  IMPORT PP cicle(PT center, float radius, int numpoints);

  IMPORT PP star(PT center, float radius_1, float radius_2, int numpoints);


  IMPORT LI to_lines(PP pl, float z);

  IMPORT P to_poly(PP pl, float z);


  //

  // new plane

  //

  PLF reverse_faces(PLF faces); // if triangulate doesnt work, use reverse_faces first

  PLF triangulate(PLF faces);

  P to_polygon(PLF faces);

private:

  Env &e;

};


#endif


#ifdef F_PLANE_API


class PlaneApi

{ // 2d coordinates in PT

  // could be array of pointcollections

  // but colours etc and textures still needed.

  // so really it's P type with 2d points.

  // int->PT

public:

  IMPORT PlaneApi(Env &e);

  IMPORT PL function(PT (*fptr)(EveryApi &e, int idx, void *data), int num_points, float sx, float sy, void *data);

  IMPORT PL color_function(PL pl, CO (*fptr)(EveryApi &ev, int idx, PT pos, void *data), void *data);

  IMPORT PL empty_plane(float sx, float sy);

  IMPORT PL flip_y(PL pl);

  IMPORT PL move(PL pl, float dx, float dy);

  PL or_plane(PL p1, PL p2);


  IMPORT PL circle(PT center, float radius, int numpoints);

  IMPORT PL star(PT center, float radius_1, float radius_2, int numpoints);


  IMPORT PL floodfill_border(BB bitmap, int x, int y);

  // TODO: how to represent/load fonts to this type.

  IMPORT PL empty(float sx, float sy);

  IMPORT PL circle(PL bg, PT center, float radius, int numpoints);

  IMPORT PL rectangle(PL bg, PT p1, PT p2);

  IMPORT PL rectangle(PL bg, PT p1, PT p2, PT p3, PT p4);

  IMPORT PL sprite(PL bg, BM bitmap, PT pos, float size_x, float size_y);

  IMPORT PL polygon(PL bg, PT *points, int size);

  IMPORT PL color(PL orig, unsigned int new_color);

  IMPORT PL plane_elem(PL p1, PL p2);

  IMPORT PL plane_array(PL *array, int size);

  IMPORT PL move_plane(PL p1, V delta);


  IMPORT PL and_not(PL p1, PL not_p); // needed in fonts for the holes

                               // draw to bitmap, do and_not, put to texture


  IMPORT PL render_p(P p, M proj_matrix, float sx, float sy);

  IMPORT PL remove_splines(PL pl, float xdelta);


  IMPORT std::pair<PL,PL> triangulate(EveryApi &ev, PL pl, int obj);

  IMPORT PL triangulate_all(EveryApi &ev, PL pl, int point_count, int max_obj);

  IMPORT PL remove_empty_faces(PL pl);


  IMPORT P to_polygon_face(PL triangulated_pl, PT pos, V u_x, V u_y);

  IMPORT P to_polygon_lines(PL pl, PT pos, V u_x, V u_y, V u_z, float z_mult);

  P to_polygon_lines_1(PL pl, PT pos, V u_x, V u_y, V u_z, float z_mult);

  IMPORT P to_polygon(EveryApi &ev, PL pl, PT pos, V u_x, V u_y, V u_z, float z_mult);


  IMPORT P to_polygon_strip(EveryApi &ev, PL pl, PT pos, V u_x, V u_y);


  // 1) get black bitmap

  // 2) draw white polygon

  // 3) draw more black

  // 4) blit to screen, take only white pixels

  // PRoblem: How to change from black pixels to alpha pixels?


  // TODO: bezier curves in 2d.


  IMPORT P substitute_quads_with_plane(P orig, PL (*fptr)(EveryApi &ev, int face, void *data), void *data);

  IMPORT P plane_in_3d(PL plane, PT u_p, V v1, V v2);


  CBM render_continuous(PL pl, int num, unsigned int color_0, unsigned int color_1);

  IMPORT BB render_bool(PL pl, int num, int sx, int sy);


  IMPORT PLA prepare(PL pl);

  IMPORT void render(PLA pl, float x, float y, float mult_x, float mult_y);


private:

  PlaneApi(const PlaneApi&);

  void operator=(const PlaneApi&);

  Env &e;

};


#endif


#ifdef F_BOOL_BITMAP_API


class BoolBitmapApi

{ // NxN->2

public:

  IMPORT BoolBitmapApi(Env &e);

  IMPORT ~BoolBitmapApi();

  IMPORT BB bb_empty(int sx, int sy);

  BB function(std::function<bool(int, int)> f, int sx, int sy);

  IMPORT BB transform(BB orig, std::function<bool(int, int, bool)> f);

  IMPORT O to_volume(BB b, float dist);

  IMPORT BB from_float_bitmap(FB float_bm, float range_start, float range_end);

  IMPORT BB from_bitmaps_color(BM bm, int r, int g, int b);

  IMPORT BB from_bitmaps_color_area(BM bm, std::function<bool(int r, int g, int b, int a)> f);

  IMPORT BB from_bitmaps_color_area(BM bm, int r_start, int r_end,int g_start, int g_end, int b_start, int b_end, int a_start, int a_end);

  IMPORT BB line(BB bg, float p_x, float p_y, float p2_x, float p2_y, float line_width1, float line_width2);

  IMPORT BB tri(BB orig, float p1_x, float p1_y, float p2_x, float p2_y, float p3_x, float p3_y);


  IMPORT BB circle(BB bg, float center_x, float center_y, float radius);

  IMPORT BB ellipse(BB bg, float center_x, float center_y, float center2_x, float center2_y, float sum_of_distances);

  //IMPORT BB rectangle(BB bg, int x, int y, int width, int height); // for static ones

  IMPORT BB rectangle(BB bg, float x, float y, float width, float height); // for moving

  IMPORT BB sprite(BB bg, BB sprite, float x, float y, float size_multiplier_x, float size_multiplier_y);

  IMPORT BB polygon(BB bg, PT *points, int size);

  IMPORT BB text(BB bg, int x, int y, const char *string, int size,BB *glyphs, int glyphcount, int(*fptr)(EveryApi &ev, char));


  IMPORT BB part_circle(int sx, int sy, float x, float y, float start_angle, float end_angle, float start_rad, float end_rad);

  IMPORT BB sections(int sx, int sy, float x, float y, std::function<bool (float angle)> f);

  IMPORT BB rings(int sx, int sy, float center_x_start, float center_y_start, float center_x_end, float center_y_end, float start_radius, float end_radius, float start_thickness, float end_thickness, int numrings);


  IMPORT BB not_bitmap(BB b);

  IMPORT BB or_bitmap(BB b1, BB b2);

  IMPORT BB andnot_bitmap(BB b1, BB not_b2);

  IMPORT BB xor_bitmap(BB b1, BB flip_b2);

  IMPORT BM choose_bitmap(BB bools, BM true_bitmap, BM false_bitmap);


  IMPORT BM to_bitmap(BB bools,int true_r, int true_g, int true_b, int true_a,int false_r, int false_g, int false_b, int false_a);

  BM to_bitmap_1(BB bools,int true_r, int true_g, int true_b, int true_a,int false_r, int false_g, int false_b, int false_a);

  IMPORT BM texture(BM bg,BB bools1, int l1, int t1,BM texturebitmap2, int l2, int t2);

  IMPORT int size_x(BB bm);

  IMPORT int size_y(BB bm);

  IMPORT bool boolvalue(BB bb, int x, int y);

  IMPORT BB black_white_dithering(FB fb);

private:

  BoolBitmapApi(const BoolBitmapApi&);

  void operator=(const BoolBitmapApi&);


  Env &e;

};


#endif


#ifdef F_FLOAT_BITMAP_API


class FloatBitmapApi

{ // NxN->R

public: // values are [0.0..1.0]

  IMPORT FloatBitmapApi(Env &e);

  IMPORT ~FloatBitmapApi();


  IMPORT FB fb_empty(int sx, int sy);

  IMPORT FB function(std::function<float(int, int)> f, int sx, int sy);

  IMPORT FB newfloatbitmap(char *array, int sx, int sy, std::function<float(char)> f);

  IMPORT FB from_bool_bitmap(BB bm, int csx, int csy);

  IMPORT FB dist(int sx, int sy, float p_x, float p_y);

  IMPORT FB blur_bitmap(FB fb, float d);

  IMPORT FB gaussian(float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, int sx, int sy);

  IMPORT FB grayscale(BM color_bm);

  IMPORT FB from_red(BM color_bm);

  IMPORT FB from_green(BM color_bm);

  IMPORT FB from_blue(BM color_bm);

  IMPORT FB from_alpha(BM color_bm);

  IMPORT FB from_grayscale(BM color_bm);


  IMPORT FB min_fb(FB fb1, FB fb2);

  IMPORT FB max_fb(FB fb1, FB fb2);


  IMPORT FB mix_fb(FB fb1, FB fb2, float val);

  IMPORT FB space_fill(PT *array, float *array2, int size, int sx, int sy);


  IMPORT BM to_grayscale(FB fb);

  IMPORT BM to_grayscale_color(FB fb,int r, int g, int b, int a,int r2, int g2, int b2, int a2);

  IMPORT BM to_color(FB r, FB g, FB b, FB a);

  IMPORT BM choose_bitmap(FB fb, BM bm1, BM bm2);

  IMPORT FB perlin_noise(FB grad_1, FB grad_2);

  IMPORT FB perlin_noise2(int sx, int sy, float key);

  IMPORT BM subfloatbitmap(EveryApi &ev, FB fb, float range_start, float range_end, unsigned int true_color, unsigned int false_color);


  IMPORT FB from_bool(BB b, float val_true, float val_false);

  IMPORT FB distance_field(FB bb, float max_value);


  IMPORT FB add_border(FB fb);


  BB to_bool(FB f, float true_range_start, float true_range_end);


  IMPORT BB to_bool_mod(FB f, float mod_value);


  IMPORT TXID to_texid(FB bm);


  IMPORT CFB C_bitmap(float sx, float sy, float val);

  IMPORT CFB X_bitmap(float sx, float sy);

  IMPORT CFB Y_bitmap(float sx, float sy);

  IMPORT CFB MulBitmap(std::vector<CFB> vec);

  IMPORT CFB AddBitmap(std::vector<CFB> vec);

  IMPORT CFB SqrtContFloat(CFB val);

  IMPORT CFB Sin(CFB val);

  IMPORT CFB Cos(CFB val);

  IMPORT CFB Tan(CFB val);

  IMPORT FB SampleContFloat(CFB a1, float start_x,float end_x,float start_y,float end_y,int sx,int sy, float mult);

  IMPORT BB SampleContBool(CBB a1, float start_x,float end_x,float start_y,float end_y,int sx,int sy);

  IMPORT CBB Equalizer(CFB,CFB);


  IMPORT int size_x(FB bm);

  IMPORT int size_y(FB bm);

  IMPORT float floatvalue(FB bm, int x, int y);

private:

  FloatBitmapApi(const FloatBitmapApi&);

  void operator=(const FloatBitmapApi&);

  Env &e;

};


#endif


#ifdef F_VECTOR_BITMAP_API


class VectorBitmapApi

{

public:

  IMPORT VectorBitmapApi(Env &e);

  VBM spheredelta(float radius1, float radius2, float x, float y, float z,

          float sx, float sy);

  VBM plane(PT pos, V u_x, V u_y, V u_z);

  P span_object(VBM vectors, FB floats); // dimensions must be the same

private:

  Env &e;

};


#endif


#ifdef F_CONTINUOUS_BITMAP_API


class ContinuousBitmapApi

{ // RxR->RGB

public:

  IMPORT ContinuousBitmapApi(Env &e);

  IMPORT CBM cbm_empty(float x, float y);

  CBM constant(unsigned int color, float x, float y);

  IMPORT CBM function(std::function<unsigned int(float, float)> f, float sx, float sy);

  IMPORT BM sample(CBM c_bitmap, int sx, int sy);

  IMPORT CBM from_bitmap(BM bm, float xsize, float ysize);

  IMPORT BM to_bitmap(CBM bm, int sx, int sy);


  IMPORT CBM rotate(CBM bm, float center_x, float center_y, float angle);

  IMPORT CBM surfacecolor(S s, COV cov);

  IMPORT CBM bicubic(float f_0, float f_1, float df_0, float df_1,

             float ff_0, float ff_1, float dff_0, float dff_1);

  IMPORT unsigned int get_pixel(CBM bitmap, float x, float y);

public: // Different rendering functions...

  CBM distance_render(FD obj, COV colours, float sx,float sy);


private:

  ContinuousBitmapApi(const ContinuousBitmapApi&);

  void operator=(const ContinuousBitmapApi&);


  Env &e;

};


#endif


#ifdef F_VOXEL_API


class VoxelApi

{ // we don't have good ways to render these. RayTraceBitmap is one way,

  // but it could be useful in other rendering systems to get colours from

  // 3d space.

  // NxNxN->RGB

public:

  IMPORT VoxelApi(Env &e);

  IMPORT OVX empty_ovx();

  IMPORT OVX remove_not_enabled(OVX vx);

  IMPORT OVX remove_colours(OVX vx);

  IMPORT OVX resize_voxels(OVX vx, VX vx2);

  IMPORT OVX vx_to_ovx(VX vx, std::vector<P> vec);

  IMPORT ML render_ovx(EveryApi &ev, OVX vx, MT mat, float sx, float sy, float sz, float border_width, unsigned int border_color);

  IMPORT VX blur(VX vx);

  IMPORT ML lod_vox(EveryApi &ev, std::string vox_url, int model, float sx, float sy, float sz, MT mat, PTS pts, int l1, int l2, int l3, int l4);

  IMPORT P render_ovx_p(EveryApi &ev, OVX vx, float sx, float sy, float sz);

  IMPORT ML vox_bind_ml(EveryApi &ev, std::string url, int model, float sx, float sy, float sz, GameApi::MT mt, int level=0);

  IMPORT ML vox_ml(EveryApi &ev, std::string url, int model, float sx, float sy, float sz, int level=0);

  IMPORT ML vox_bind_ml2(EveryApi &ev, std::string url, int model, float sx, float sy, float sz, GameApi::MT mt, float border_width, unsigned int border_color, int level=0);

  IMPORT ML vox_ml2(EveryApi &ev, std::string url, int model, float sx, float sy, float sz, float border_width, unsigned int border_color, int level=0);

  IMPORT VX vox_voxel2(EveryApi &ev, std::string url, int model, float sx, float sy, float sz);

  IMPORT P vox_voxel3(EveryApi &ev, std::string url, int model, float sx, float sy, float sz, int level=0);

  IMPORT ARR vox_cubes(EveryApi &ev, std::string url, int model, float sx, float sy, float sz);

  IMPORT P vox_voxel(EveryApi &ev, std::string url, int model, float sx, float sy, float sz, int level=0);

  IMPORT VX voxel_from_bitmaps(std::vector<BM> vec, std::string url);

  IMPORT VX function(unsigned int (*fptr)(EveryApi &ev, int x, int y, int z, void *data), int sx, int sy, int sz, void *data);

  IMPORT unsigned int get_pixel(VX v, int x, int y, int z);

  IMPORT BM sw_rays(O volume, VX colours, int sx, int sy, float vx, float vy, float vz, float z);

  IMPORT P render_boxes(VX v, float sx, float sy, float sz);

  IMPORT PTS instanced_positions(VX x, float sx, float sy, float sz, unsigned int value);


  // int voxel

  IMPORT VX empty_voxel(int sx, int sy, int sz);

  IMPORT VX subvoxel(VX voxel, int start_x, int end_x, int start_y, int end_y, int start_z, int end_z);

  IMPORT VX blit_voxel2(VX voxel, VX voxel2, int p_x, int p_y, int p_z);

  IMPORT VX blit_voxel(O object, int sx, int sy, int sz, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, int false_value, int true_value);

  IMPORT ARR voxel_instancing(VX voxel, int count, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z);

  IMPORT ML voxel_render(EveryApi &ev, std::vector<P> objs, std::vector<PTS> vec);

  IMPORT ML voxel_bind(EveryApi &ev, std::vector<P> objs, std::vector<PTS> vec, MT material);

  IMPORT P voxel_static(EveryApi &ev, std::vector<P> objs, std::vector<PTS> vec);

  IMPORT VX voxel_landscape_from_fbm(FB bitmap, int height, int false_val, int true_val);

  IMPORT VX convert_p_to_vx(P p, int sx, int sy, int sz, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, int value);

  IMPORT VX from_implicit(IM i, int sx, int sy, int sz, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, int value);

private:

  Env &e;

};


#endif


#ifdef F_COLOR_API


class ColorApi

{ // ()->RGB

public:

    IMPORT ColorApi(Env &e);

    IMPORT CO u_color(unsigned int color); // argb

    IMPORT CO rgb_color(int r, int g, int b, int a); // r,g,b,a [0..255]

    IMPORT CO rgbf_color(float r, float g, float b, float a);

private:

  ColorApi(const ColorApi&);

  void operator=(const ColorApi&);

  Env &e;

};


#endif


#ifdef F_POINT_API


class PointApi

{ // ()->PT

public:

    IMPORT PointApi(Env &e);

    IMPORT PT origo();

    IMPORT PT point(float x, float y, float z = 0.0);

    IMPORT PT move(PT p1, float dx, float dy, float dz = 0.0);

    IMPORT PT move(PT p1, V vec);


    IMPORT PT mix(PT p1, PT p2, float val); // val=[0.0..1.0]


    IMPORT PT from_angle(float radius, float angle);

    IMPORT PT from_angle(PT center, float radius, float angle);

        IMPORT PT spherical_coords(PT pos);

        IMPORT PT cartesian_coords(PT pos);


    IMPORT float pt_x(PT p);

    IMPORT float pt_y(PT p);

    IMPORT float pt_z(PT p);

    IMPORT float dist3d(PT p, PT p2);

    IMPORT float dist2d(PT p, PT p2);

    IMPORT V minus(PT p1, PT p2);

private:

  PointApi(const PointApi&);

  void operator=(const PointApi&);

  Env &e;

};


#endif


#ifdef F_POINT_COLLECTION_API


class PointCollectionApi

  { // int -> PT

public:

    IMPORT PointCollectionApi(Env &e);

    IMPORT PC function(std::function<PT (int)> f, int count);

    IMPORT PC empty();

    IMPORT PC single(PT point);

    IMPORT PC single(float x, float y, float z);

    IMPORT PC array(PT *array, int size);

    IMPORT PC bezier(PT *array, PT *control_array, int size, int iteration_count);

    IMPORT P tri_object3d(PC p);

private:

  PointCollectionApi(const PointCollectionApi&);

  void operator=(const PointCollectionApi&);

  Env &e;

};


#endif


#ifdef F_MATRICES_API


class MatricesApi

{

public:

  IMPORT MatricesApi(Env &e);

  MS mn_matrix_array2(EveryApi &ev, std::vector<MN> moves);

  MS mult_g_last_resize(EveryApi &ev, MS ms);

  MS load_matrices(std::string url);

  MS load_matrices_nr(std::string url);

  MS ms_steady(MS ms);

  ML render_ms_files2_si(EveryApi &ev, std::vector<P> p, std::vector<MT> mat, VX voxel, int start_type, int end_type, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z);

  ML render_ms_files_si(EveryApi &ev, std::vector<P> p, MT mat, VX voxel, int start_type, int end_type, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z);


  IMPORT MS mn_matrix_array(EveryApi &ev, int count, MN move);

  IMPORT MS random_time_seq(EveryApi &ev, MS inner_start, MS outer, MS inner_end, float outer_time, float inner_time);

  IMPORT MS ms_interface(VX vox, int type, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z);

  IMPORT MS ms_file(std::string url, int use_type);

  IMPORT ML render_ms_files(EveryApi &ev, std::vector<P> p, MT mat, std::string url, int start_type, int end_type);

  IMPORT ML render_ms_files2(EveryApi &ev, std::vector<P> p, std::vector<MT> mat, std::string url, int start_type, int end_type);

  IMPORT MS interpolate(MS start, MS end, float val);

  IMPORT MS inverse_ms(MS ms);

  IMPORT MS from_points(PTS pts);

  IMPORT MS mult(MS m, M mat);

  IMPORT MS mult(M mat, MS m);

  IMPORT MS apply_matrix(MS m, M mat);

  IMPORT MS trans2(MS m, float tx,float ty, float tz);

  IMPORT MS scale2(MS m, float sx,float sy, float sz);

  IMPORT MS repeat_ms(EveryApi &ev, MN mn, int val);

  IMPORT MS subarray(MS m, int start, int count);

  IMPORT MS ms_random_rot(float px, float py, float pz, int count);

  IMPORT MS mult_array(MS m1, MS m2);

  IMPORT MS from_lines_2d(LI li);

  IMPORT MS from_lines_3d(LI li);

  IMPORT MSA prepare(MS p, bool color_from_instance);


private:

  Env &e;

};


#endif


#ifdef F_POINTS_API


class PointsApi

{

public:

  IMPORT PointsApi(Env &e);

  // should use cubes at left,top,right edge to cut out rendering.

  IMPORT PTS combine_pts(PTS p1, PTS p2);

  IMPORT int colour_divisor_calc(P p);

  IMPORT PTS world_filter(PTS points); // uses DynamicCursor g_dyn_cursor

  IMPORT ML world_filter_cursor(ML ml,

                float start_delta_x, float end_delta_x,

                float start_delta_y, float end_delta_y,

                float start_delta_z, float end_delta_z);


  IMPORT ML publish_heightfield(ML ml, CFB landscape, float start_x, float end_x,

                float start_y, float end_y, float start_z, float end_z);

  IMPORT CFB cbm_to_cfb( CBM bm, float red_mult, float red_add,

             float green_mult, float green_add,

             float blue_mult, float blue_add,

             float alpha_mult, float alpha_add);

  IMPORT PTS height_field_pts(PTS points, CFB landscape, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z);

  IMPORT P height_field_p(P faces, CFB landscape, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z);


  IMPORT PTS block_pts_debug();

  IMPORT PTS random_points_in_plane(EveryApi &ev, float key,

                    float start_x, float end_x,

                    float start_z, float end_z,

                    float y,

                    int num);

  IMPORT PTS pts_lines(std::string url, float start_pos, float dist, float speed);

  IMPORT PTS block_pts(PTS pts, float d, int max_points_visible);

  IMPORT PTS block_pts_lod(PTS pts, float start_x, float end_x, float start_y, float end_y, int max_points_visible, float ncd_z_s, float ncd_z_e);

  IMPORT MS block_ms_lod(MS pts, float start_x, float end_x, float start_y, float end_y, int max_points_visible, float ncd_z_s, float ncd_z_e);

  IMPORT PTS load_points(std::string url);

  IMPORT PTS pts_alt(std::vector<PTS> vec, int index);

  IMPORT PTS points_field(float start_speed_y, float end_speed_y, int numpoints, float start_x, float end_x, float start_y, float end_y);

  IMPORT P ply_faces(std::string url);

  IMPORT PTS ply_pts(std::string url);

  IMPORT PTS iterate_points(PTS points, VFi field, FA speed);

  IMPORT VFi pressure_gradient(FFi pressure);

  IMPORT VFi matrix_field(MN start, MN end);

  IMPORT FA random_speeds(float start_speed, float end_speed, int num);

  IMPORT PTS bullet(int key, float vx, float vy, float vz, float px, float py, float pz, float dist, int max_count, float repeat_time);

  IMPORT PTS voxelarray_to_pts(AV arr);

  IMPORT PTS polygon_face_center_points(P p);

  IMPORT PTS single_pts();

  IMPORT PTS pt_array(EveryApi &ev, std::vector<PT> vec);

  IMPORT PTS function(std::function<PT(int pointnum)> f, int numpoints);

  IMPORT PTS color_function(PTS orig, std::function<unsigned int(int pointnum, PT pos)> f);

  IMPORT PTS collision_points(float start_x, float end_x, float start_y, float end_y, float start_z, float end_z);

  IMPORT ML collision_bind(EveryApi &ev, PTS bounding_box, std::string name);

  IMPORT ML collision_bind_inst(EveryApi &ev, PTS bounding_box, PTS inst_points, std::string name);

  IMPORT ML collision_collect(ML mainloop);

  IMPORT PTS from_float_volume(FO float_volume, int numpoints, float start_x, float start_y, float start_z,float end_x, float end_y, float end_z);

  IMPORT PTS color_points(PTS p, unsigned int color);

  IMPORT PTS li_pts(LI li, float pos);

  IMPORT PTS li_pts2(LI li);

  IMPORT PTS hemisphere_points(PT points, V normal, float r, int numpoints);

  IMPORT PTS pts_grid(BM bm, float start_x, float end_x, float start_y, float en_y, float z);

  IMPORT PTS pts_grid_bb(BB bb, float start_x, float end_x, float start_y, float en_y, float z);

  IMPORT PTS or_points(PTS p1, PTS p2);

  IMPORT PTS sort_pts(PTS p);

  IMPORT PTS heightmap(BM colour, FB floatbitmap, PT pos, V u_x, V u_y, V u_z, int sx, int sy);

  IMPORT PTS random_plane(PT pos, V u_x, V u_y, int numpoints);

  IMPORT PTS random_bitmap_instancing(EveryApi &ev, BB bm, int count, float start_x, float end_x, float start_y, float end_y, float z);

  IMPORT PTS random_mesh_quad_instancing(EveryApi &ev, P p, int count);

  IMPORT PTS random_mesh_quad_instancing_color(EveryApi &ev, P p, int count, std::vector<BM> textures);

  IMPORT PTS random_lattice(EveryApi &ev, int sx, int sy, int sz,

                float s_x, float s_y, float s_z,

                float px, float py, float pz,

                int count);

  IMPORT PTS surface(S surf, int sx, int sy);

  IMPORT PTS surface(std::function<PT (float,float)> surf,

             std::function<unsigned int (PT,float,float)> color,

             float start_u, float end_u,

             float start_v, float end_v,

             float step_u, float step_v);

  IMPORT PTS from_volume(O o, PT pos, V u_x, V u_y, V u_z, int sx, int sy, int sz);

  IMPORT PTS anim_mix(PTS o1, PTS o2, float start_val, float end_val, float start_time, float end_time);

  IMPORT PTS move(PTS obj, float dx, float dy, float dz);

  IMPORT PTS scale(PTS obj, float sx, float sy, float sz);

  IMPORT PTS rot_x(PTS obj, float angle);

  IMPORT PTS rot_y(PTS obj, float angle);

  IMPORT PTS rot_z(PTS obj, float angle);

  IMPORT PTS shadow_points(PTS obj, PT pos, V u_x, V u_y, V light_vec);


  IMPORT PTS unit_cube(PTS orig, PT pos, V u_x, V u_y, V u_z);

  IMPORT PTS unit_to_cube(PTS orig, PT pos, V u_x, V u_y, V u_z);

  IMPORT PTS unit_to_flex(PTS orig,

            PT bTL, PT bTR, PT bBL, PT bBR,

            PT fTL, PT fTR, PT fBL, PT fBR);

  IMPORT PTS wave_points(WV wave, int num_samples,

             float pos_x, float pos_y, float pos_z,

             float u_x_x, float u_x_y, float u_x_z,

             float u_y_x, float u_y_y, float u_y_z);

  IMPORT PTS filter_component(PTS pts, int comp, float val);

  IMPORT PTS anim_rot_pts(PTS pts, float start_time, float end_time, float v_x, float v_y, float v_z, float rotate_amount);


  IMPORT PTA prepare(PTS p, bool color_from_instance);

  IMPORT int num_points(PTA pta);

  IMPORT int num_points(MSA pta);

  float *point_access(PTA pta, int pointnum); // use ptr[0], ptr[1] and ptr[2] to access the x,y,z coordinate

  IMPORT void set_point(PTA pta, int pointnum, float x, float y, float z);

  //unsigned int *color_access(PTA pta, int pointnum);

  void update_from_data(PTA array, PTS p, bool draw=true);

  void update_from_data(MSA array, MS p, bool draw=true);

  void update(PTA array, GameApi::P pp, bool slow=false);

  IMPORT void render(PTA array);

  IMPORT ML render_ml(EveryApi &ev, PTA array);

  IMPORT void explode(PTA array, float x, float y, float z, float dist);


  IMPORT PTS standard_box(int sx, int sy, int sz, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z);

  IMPORT PTS matrix_points(PTS orig, M matrix);

  IMPORT LI matrix_display(EveryApi &ev, M matrix);

  IMPORT LI matrix2_display(EveryApi &ev, M matrix1, M matrix2, int sx,int sy,int sz, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z);

  IMPORT ML movement_display(EveryApi &ev, ML ml, MN mn, int count, int sx, int sy, int sz, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z);


  IMPORT int NumPoints(PTS p);

  IMPORT int NumPoints(MS p);

  IMPORT float pos_x(PTS p, int index);

  IMPORT float pos_y(PTS p, int index);

  IMPORT float pos_z(PTS p, int index);

  IMPORT ML pts_render(EveryApi &ev, PTS pts);

  IMPORT LI li_from_pts(PTS pts, float dx, float dy, float dz);

  IMPORT PTS memoize_pts(PTS pts);

private:

  PointsApi(const PointsApi&);

  void operator=(const PointsApi&);


  Env &e;

};


#endif


#ifdef F_LINES_API


class LinesApi

{

public:

    IMPORT LinesApi(Env &e);

  IMPORT LI pos_choose(EveryApi &ev, FB bm, float pos, float start_x, float end_x, float start_y, float end_y, float z);

  IMPORT LI alt(std::vector<LI> v, int index);

  IMPORT LI li_empty();

  IMPORT LI li_url(std::string url);

  IMPORT LI li_url_nr(std::string url);

  IMPORT LI function(std::function<PT(int linenum, bool id)> f,

          int numlines);

  IMPORT LI line_pos_mult(float val, LI li);

  IMPORT LI point_array(std::vector<PT> vec);

  IMPORT LI li_or_array(std::vector<LI> vec);

  IMPORT LI li_bevel(LI li, P p, float mix);

  IMPORT P p_towards_normal(P p, float amount);

  IMPORT LI li_matrix(LI lines, M matrix);

  IMPORT LI color_function(LI lines, std::function<unsigned int(int linenum, bool id)> f);

  IMPORT LI change_color(LI li, unsigned int color);

  IMPORT LI change_color2(LI li, unsigned int color_1, unsigned int color_2);

    IMPORT LI from_points(PC points, bool loops);

        IMPORT LI from_points2(PTS start_points, PTS end_points);

        IMPORT LI from_plane(PL plane);

    IMPORT LI from_polygon(P poly);

        IMPORT LI from_polygon2(P poly1, P poly2);

  IMPORT LI normals_from_polygon(P poly, float length);

        IMPORT P line_anim(P poly, LI lines_from_polygon2, float val);

        IMPORT PTS pts_line_anim(LI lines, float val);

  IMPORT PTS pts_line_anim2(LI lines, std::function<float (int)> f);

    IMPORT LI border_from_bool_bitmap(BB b, float start_x, float end_x,

                 float start_y, float end_y, float z);

  IMPORT LI render_slice_2d(P p, PT pos, V u_x, V u_y);

  IMPORT LI translate(LI lines, float dx, float dy, float dz);

  IMPORT LI scale(LI lines, float m_x, float m_y, float m_z);

  IMPORT LI li_or_elem(LI li1, LI li2);

  IMPORT LI rotx(LI lines, float angle);

  IMPORT LI roty(LI lines, float angle);

  IMPORT LI rotz(LI lines, float angle);

  IMPORT P line_product(LI lines1, LI lines2);

  IMPORT LI fur(PTS pts, PT center, float dist);

  IMPORT LI split_lines(LI lines, float dist);

  IMPORT LI twist_y(LI lines, float y_0, float angle_per_y_unit);

  IMPORT LI random_angle(LI lines, float max_angle);


  IMPORT LI unit_cube(LI orig, PT pos, V u_x, V u_y, V u_z);

  IMPORT LI unit_to_cube(LI orig, PT pos, V u_x, V u_y, V u_z);

  IMPORT LI unit_to_flex(LI orig,

            PT bTL, PT bTR, PT bBL, PT bBR,

            PT fTL, PT fTR, PT fBL, PT fBR);

  IMPORT LI random_mesh_quad_lines(EveryApi &ev, P p, int count);

  IMPORT LI lines_from_quads(P p, int sx, int sy);


  IMPORT ML ml_li_render(EveryApi &ev, LI l, float linewidth);

  IMPORT LLA prepare(LI l);

  IMPORT void update(LLA la, LI l);

  IMPORT ML update_ml(LLA la, LI l);

  //IMPORT int line_count(LLA l);

  //      IMPORT float *line_access(LLA lines, int line, bool b);

  //IMPORT unsigned int *color_access(LLA lines, int line, bool b);

  //IMPORT void update(LLA lines);

    IMPORT void render(LLA array);

  IMPORT void prepare_inst(LLA array, PTA instances);

  IMPORT void render_inst(LLA array, PTA instances);

  IMPORT void prepare_inst_matrix(LLA array, MSA instances);

  IMPORT void render_inst_matrix(LLA array, MSA instances);

  IMPORT ML render_ml(EveryApi &ev, LLA array, float linewidth);

  IMPORT ML render_ml2(EveryApi &ev, LI array, float linewidth);

  IMPORT ML render_inst_ml(EveryApi &ev, LLA array, PTA pta, float linewidth);

  IMPORT ML render_inst_ml2(EveryApi &ev, LI array, PTA pta, float linewidth);

  IMPORT ML render_inst_ml3(EveryApi &ev, LI array, PTS pts, float linewidth);

  IMPORT ML render_inst_ml3_matrix(EveryApi &ev, LI array, MS pts, float linewidth);

  IMPORT LI import_ifc(EveryApi &ev, std::string url);

private:

  LinesApi(const LinesApi&);

  void operator=(const LinesApi&);

  Env &e;

};


#endif


#ifdef F_VECTOR_API


class VectorApi

{ // to be implemented via virtual Vector vec() const=0;

  // ()->V

public:

    IMPORT VectorApi(Env &e);

    IMPORT V null_vector();

    IMPORT V vector(float delta_x, float delta_y, float delta_z);

    IMPORT V sum(V v1, V v2);

    IMPORT V mul(V v1, float scalar);

    IMPORT float dot(V v1, V v2);

    IMPORT V cross(V v1, V v2);

    IMPORT float projection_length(V u, V u_x);

    IMPORT V projection_1(V u, V u_x);

    IMPORT V projection_2(V u, V u_x);

    IMPORT V neg(V v);

    IMPORT float dist3d(V v);

    IMPORT float dist2d(V v);

private:

  VectorApi(const VectorApi&);

  void operator=(const VectorApi&);

 Env &e;

};


#endif


#ifdef F_SPACE_VECTOR_API


class SpaceVectorApi

{ // f : PT->V

public:

  IMPORT SpaceVectorApi(Env &e);

  SV function(std::function<V (float x, float y, float z)> f); // TODO

  SV from_points(PC coll); // choose poly(nearest points), linear interpoate, ensure no failures

  PT flow_next_point(SV v, PT p, float mult);

private:

  SpaceVectorApi(const SpaceVectorApi&);

  void operator=(const SpaceVectorApi&);

  Env &e;

};


#endif


#ifdef F_MATRIX_API


class MatrixApi

{

public:

    IMPORT MatrixApi(Env &e);

    IMPORT M identity();

        IMPORT M transpose(M m);

    IMPORT M xrot(float rot);

    IMPORT M yrot(float rot);

    IMPORT M zrot(float rot);

    IMPORT M trans(float x, float y, float z);

    IMPORT M trans(V vec);

    IMPORT M scale(float sx, float sy, float sz);

    IMPORT M projection(float z_min);

    IMPORT M perspective_projection(float dist);

    IMPORT M perspective(float fovy, float aspect, float near, float far);

        IMPORT M ortho( float left, float right, float bottom, float top, float near, float far);

    IMPORT M inverse(M m1);

    IMPORT M mult(M m1, M m2);

    IMPORT M rotate_around_axis(V v, float angle);

    IMPORT M rotate_around_axis(PT point, V v, float angle);

        IMPORT M keep_rotation(M m);

    IMPORT PT mult(PT point, M matrix);

private:

  MatrixApi(const MatrixApi&);

  void operator=(const MatrixApi&);

  Env &e;

};


#endif

#ifdef F_OBJECT_MOVE_API


class ObjectMoveApi

{

public:

  IMPORT ObjectMoveApi(Env &e);

  OM empty(int numobjects);

  OM add_object(OM orig, int index, P obj);

  OM clear_object(OM orig, int index);

  OM change_pos(OM orig, int index, M mat);

  VAA prepare_all(OM orig);

  void render_all(VAA orig);

private:

  ObjectMoveApi(const ObjectMoveApi&);

  void operator=(const ObjectMoveApi&);


  Env &e;

};


#endif


#ifdef F_VBO_API


class VBOApi

{

public:

  IMPORT VBOApi(Env &e);

  ~VBOApi();

  // preparing

  Vb alloc(int obj_count);

  void sprite(Vb v, int obj_num, BM bm, float x, float y);

  void polygon(Vb v, int obj_num, P p, float x, float y, float z);

  void grid(Vb v, int obj_num, BM tile_bitmap, BM grid, float top_x, float top_y);

  void heightmap(Vb v, int obj_num, BM bitmap_float);

  void prepare(Vb v);

  // rendering

  void swapframe(Vb v, int obj_num, int type, int frame);

  void move(Vb v, int obj_num, float x, float y, float z);

  void render(Vb v);

private:

  VBOApi(const VBOApi&);

  void operator=(const VBOApi&);


  void *priv;

  Env &e;

};


#endif


#ifdef F_PATH_API


class PathApi

{

public:

  IMPORT PathApi(Env &e);

  ~PathApi();

  PA point(PT p);

  PA next_point(PA pa, PT p);

  LA loop(PA p);

  P object(LA l, PT o, float dx, float dy, float dz);


  PA line(PT p1, PT p2, int splitnum);

  PA cross(PT pos, PA p1, PA p2);

  PA grid(PT pos, PT p_x, PT p_y, int sx, int sy);

  PA cube(PT pos, PT p_x, PT p_y, PT p_z, int sx, int sy, int sz);

private:

  void *priv;

  Env &e;

};


#endif


#ifdef F_UBER_SHADER_API


class UberShaderApi

{

public:

  IMPORT UberShaderApi(Env &e);

  IMPORT US v_empty();

  IMPORT US v_water(US us);

  IMPORT US v_edge(US us);

  IMPORT US v_gltf_anim(US us);

  IMPORT US v_globe(US us);

  IMPORT US v_color_from_normals(US us);

  IMPORT US v_recalc_normal(US us);

  IMPORT US v_diffuse(US us);

  IMPORT US v_ambient(US us);

  IMPORT US v_specular(US us);

  IMPORT US v_inst(US us);

  IMPORT US v_inst_matrix(US us);

  IMPORT US v_passall(US us);

  IMPORT US v_pass_position(US us);

  IMPORT US v_point_light(US us);

  IMPORT US v_coloured_lights(US us);

  IMPORT US v_snoise(US us);

  IMPORT US v_light(US us);

  IMPORT US v_ref(US us);

  IMPORT US v_wave(US us);

  IMPORT US v_toon(US us);

  IMPORT US v_texture(US us);

  IMPORT US v_manytexture(US us);

  IMPORT US v_cubemaptexture(US us);

  IMPORT US v_texture_arr(US us);

  IMPORT US v_colour(US us);

  IMPORT US v_blur(US us); // dangerous operation

  IMPORT US v_dist_field_mesh(US us, SFO sfo);

  IMPORT US v_skeletal(US us);

  IMPORT US v_custom(US us, std::string v_funcname);

  IMPORT US v_newshadow_1(US us);

  IMPORT US v_newshadow_2(US us);

  IMPORT US v_phong(US us);

  IMPORT US v_blurred_render(US us);

  IMPORT US v_adjust(US us);

  IMPORT US v_generic(US us, std::string name, std::string flags);

  IMPORT US v_vertexphong(US us);

  IMPORT US v_glowedge(US us);

  IMPORT US v_bump_phong(US us);

  IMPORT US v_fog(US us);

  IMPORT US v_shadow(US us);

  IMPORT US v_mix(US us);

  IMPORT US v_dyn_lights(US us);

  IMPORT US v_gi(US us);

  IMPORT US v_gltf(US us, std::string cache_id);

  IMPORT US v_colour_with_mix(US us);

  IMPORT US v_fade(US us);

  IMPORT US f_water(US us);

  IMPORT US f_acesfilm(US us);

  IMPORT US f_discard(US us);

  IMPORT US f_edge(US us);

  IMPORT US f_gltf_anim(US us);

  IMPORT US f_mesh_color(US us, SFO sfo); // this requires v_pass_position() in vertex shader

  IMPORT US f_sandbox(US us, SFO sfo); // this requires texture coordinates

  IMPORT US f_empty(bool transparent);

  IMPORT US f_diffuse(US us);

  IMPORT US f_ambient(US us);

  IMPORT US f_specular(US us);

  IMPORT US f_newshadow_1(US us);

  IMPORT US f_newshadow_2(US us, bool is_phong);

  IMPORT US f_adjust(US us);

  IMPORT US f_phong(US us);

  IMPORT US f_blurred_render(US us);

  IMPORT US f_phong2(US us);

  IMPORT US f_generic(US us, std::string name, std::string flags);

  IMPORT US f_generic_flip(US us, std::string name, std::string flags);

  IMPORT US f_vertexphong(US us);

  IMPORT US f_glowedge(US us);

  IMPORT US f_bump_phong(US us);

  IMPORT US f_fog(US us);

  IMPORT US f_shadow(US us);

  IMPORT US f_mix(US us);

  IMPORT US f_dyn_lights(US us);

  IMPORT US f_color_from_normals(US us);

  IMPORT US f_color_from_id(US us, int id); // id = [0..9]

  IMPORT US f_point_light(US us);

  IMPORT US f_coloured_lights(US us);

  IMPORT US f_bands(US us);

  IMPORT US f_snoise(US us);

  IMPORT US f_blur(US us); // dangerous operation

  IMPORT US f_ref(US us);

  IMPORT US f_light(US us);

  IMPORT US f_toon(US us);

  IMPORT US f_texture(US us);

  IMPORT US f_manytexture(US us);

  IMPORT US f_cubemaptexture(US us);

  IMPORT US f_texture_arr(US us);

  IMPORT US f_colour(US us);

  IMPORT US f_mix_color(US us, US us2, float val); // TODO

  IMPORT US f_choose_color(US us);

  IMPORT US f_custom(US us, std::string f_funcname);

  IMPORT US f_gi(US us);

  IMPORT US f_colour_with_mix(US us);

  IMPORT US f_gltf(US us, bool tex0, bool tex1, bool tex2, bool tex3, bool tex4, bool tex5, bool tex6, bool tex7, bool spec, bool unlit, std::string cache_id, bool emissive);

  IMPORT US f_fade(US us);

  IMPORT US f_flip(US us, US us2);

private:

  Env &e;

};


#endif


#ifdef F_SHADER_API


class ShaderApi

{

public:

  IMPORT ShaderApi(Env &e);

  IMPORT ~ShaderApi();

  IMPORT void load_default();

  IMPORT void load(std::string filename);

  IMPORT SH get_shader(std::string v_format, std::string f_format, std::string g_format,std::string v_comb="", std::string f_comb="", bool trans=true, SFO module={-1} );

  IMPORT SH get_normal_shader(std::string v_format, std::string f_format, std::string g_format,std::string v_comb="", std::string f_comb="", bool trans=true, SFO mod={-1}, std::string v_defines="IN_NORMAL IN_COLOR IN_TEXCOORD IN_POSITION EX_COLOR EX_NORMAL EX_POSITION EX_TEXCOORD", std::string f_defines="EX_COLOR EX_NORMAL EX_POSITION EX_TEXCOORD", bool is_new=false);

  IMPORT SH get_normal_shader(std::string v_format, std::string f_format, std::string g_format,US v_comb, US f_comb, bool trans=true, SFO mod={-1}, std::string v_defines="", std::string f_defines="", bool is_new=false);

  IMPORT SH get_normal_shader(std::string v_format, std::string f_format, std::string g_format, US v_comb, US f_comb, std::string v_shader, std::string f_shader, bool trans=true, SFO mod={-1}, std::string v_defines="", std::string f_defines="", bool is_new=false);

  SH get_shader_1(std::string v_format, std::string f_format, std::string g_format,

          std::string v_comb="", std::string f_comb="", bool trans=true, SFO mod={-1}, US v_c={-1}, US f_c={-1}, std::string v_defines="IN_NORMAL IN_COLOR IN_TEXCOORD IN_POSITION EX_COLOR EX_NORMAL EX_POSITION EX_TEXCOORD EX_POSITION", std::string f_defines="EX_COLOR EX_NORMAL EX_POSITION EX_TEXCOORD", std::string v_shader="", std::string f_shader="");

  SH get_normal_shader_1(std::string v_format, std::string f_format, std::string g_format,

             std::string v_comb="", std::string f_comb="", bool trans=true, SFO mod = { -1 }, US v_c = { -1 }, US f_c = { -1 }, std::string v_defines="IN_NORMAL IN_POSITION IN_COLOR IN_TEXCOORD EX_COLOR EX_NORMAL EX_POSITION EX_TEXCOORD", std::string f_defines="EX_COLOR EX_NORMAL EX_POSITION EX_TEXCOORD", std::string v_shader="", std::string f_shader="");

    SH get_normal_shader_1_new(std::string v_format, std::string f_format, std::string g_format,

             std::string v_comb="", std::string f_comb="", bool trans=true, SFO mod = { -1 }, US v_c = { -1 }, US f_c = { -1 }, std::string v_defines="IN_NORMAL IN_POSITION IN_COLOR IN_TEXCOORD EX_COLOR EX_NORMAL EX_POSITION EX_TEXCOORD", std::string f_defines="EX_COLOR EX_NORMAL EX_POSITION EX_TEXCOORD", std::string v_shader="", std::string f_shader="");

  IMPORT SH texture_shader(bool text_draw=false);

  IMPORT SH texture_array_shader();

  IMPORT SH texture_many_shader();

  IMPORT SH colour_shader();

  IMPORT SH colour_texture_shader();

  IMPORT SH shader_choice(EveryApi &ev, int i);

  IMPORT PinIn link(SH shader);

  IMPORT PinIn use(SH shader);

  IMPORT void print_log(SH shader);

  void link_1(SH shader);

  void use_1(SH shader);

  IMPORT PinIn unuse(SH shader);

  IMPORT void bindnames(GameApi::SH shader,

            std::string s_vertex,

            std::string s_normal,

            std::string s_color,

            std::string s_texcoord);

  IMPORT void set_default_projection(GameApi::SH shader, std::string name);

  void set_default_projection_1(GameApi::SH shader, std::string name);

  IMPORT void set_y_rotation(SH shader, std::string name, float angle);

  IMPORT void bind_attrib(GameApi::SH shader, int num, std::string name);

  void bind_attrib_1(GameApi::SH shader, int num, std::string name);

  IMPORT void bind_frag(GameApi::SH shader, int attachment_num, std::string name);

  IMPORT PinIn set_var(GameApi::SH shader, const char * name, float val);

  IMPORT PinIn set_var(GameApi::SH shader, const char * name, float x, float y, float z);

  IMPORT PinIn set_var(GameApi::SH shader, const char *name, float x, float y, float z, float k);

  IMPORT PinIn set_var(GameApi::SH shader, const char * name, int val);

  IMPORT PinIn set_var(GameApi::SH shader, const char * name, M matrix);

  IMPORT PinIn set_var(GameApi::SH shader, const char * name, const std::vector<M> &m, int start, int end);

  IMPORT PinIn set_var(GameApi::SH shader, const char * name, const std::vector<M> &m, int num);

  IMPORT PinIn set_var(GameApi::SH shader, const char * name, const std::vector<PT> &v);

  IMPORT PinOut<M> get_matrix_var(GameApi::SH shader, std::string name);

private:

  ShaderApi(const ShaderApi&);

  void operator=(const ShaderApi&);


  friend class StateChangeApi;

  void *priv;

  Env &e;

};


#endif


class LowFrameBufferApi

{

public:

  IMPORT LowFrameBufferApi(Env &e);

  IMPORT RUN low_framebuffer_run(EveryApi &ev, FBU buffer, int mode, int scr_x, int scr_y);

  IMPORT FBU low_framebuffer(FML mainloop, int format, int width, int height, int depth);

  IMPORT FML low_sprite_draw(std::string name, BM bm, MN mn, int x, int y, int fmt, float start_time);

  IMPORT FML low_poly_draw(std::string name, P p,MN mn);

  IMPORT FML low_sprite_array(std::string name, std::string url, std::vector<BM> bms, MN mn, int x, int y, int fmt, float start_time);

  IMPORT FML low_render_world(std::vector<BM> blocks, int screen_width, int screen_height, int fmt);

  IMPORT FML low_scroll_world(FML ml, float speed_x, float speed_y, float p_x, float p_y, float left_offset, float right_offset, float height, float height2, int mode, int jump_frames);

  IMPORT FML low_build_world(FML ml, std::string url, std::string chars,int x, int y);

  IMPORT FML low_enemy_draw(BM bm, std::string url, int fmt, float speed);

  IMPORT FML low_enemy_draw2(std::vector<BM> bm, std::string url, int fmt, float speed, int time_delta, int time_duration);

  IMPORT FML low_collision(FML ml, float start_x, float end_x, float start_y, float end_y, int key);

  IMPORT BM low_frame_bitmap(FML ml, int sx, int sy);

  IMPORT FML low_key_bm_prepare(FML ml, BM bm, int key,FML normal, float duration, FML next);

  IMPORT FML low_activate_snapshot(EveryApi &ev, FML ml, int key, MN move, float duration, FML next);

  IMPORT FML qml_print(std::string url);

  IMPORT FML qml_create_node(std::string url);

  IMPORT FML w_root(GameApi::EveryApi &ev, GameApi::W wd);

  IMPORT W w_layout(std::vector<W> vec, std::string url);

  IMPORT W w_rect(unsigned int color);

  IMPORT W w_bitmap(BM bm);

  IMPORT W w_text(EveryApi &ev, Ft font, std::string str, int x_gap, float baseline);

private:

  LowFrameBufferApi(const LowFrameBufferApi &);

  void operator=(const LowFrameBufferApi&);

  Env &e;

};


#ifdef F_FRAMEBUFFER_API


class FrameBufferApi

{

public:

  struct vp { int viewport[4]; };

  IMPORT FrameBufferApi(Env &e);

  IMPORT FBO create_fbo(EveryApi &ev, int sx, int sy);

  IMPORT void config_fbo(FBO buffer);

  IMPORT void unconfig_fbo(FBO buffer);

  IMPORT vp bind_fbo(FBO buffer);

  IMPORT void bind_screen(vp viewport);

  IMPORT TXID tex_id(FBO buffer);

  IMPORT TXID depth_id(FBO buffer);

  IMPORT bool fbo_status(FBO buffer);

  IMPORT BM fbo_to_bitmap(EveryApi &ev, FBO buffer);

  IMPORT TXID fbo_ml(EveryApi &ev, ML mainloop, int sx, int sy, bool translate);

  IMPORT TXID depth_ml(EveryApi &ev, ML mainloop, int sx, int sy, bool translate);

  IMPORT ML fbo_ml_blit(EveryApi &ev, TXID id, float start_x, float end_x, float start_y, float end_y, float z);

private:

  FrameBufferApi(const FrameBufferApi &);

  void operator=(const FrameBufferApi&);

  Env &e;

};


#endif


#ifdef F_LAYOUT_API


class LayoutApi

{

public:

  IMPORT LayoutApi(Env &e);

  LAY root(int sx, int sy); // id = {0}

  LAY split_y(LAY l, int id, int num); // id = {0..num-1}

  LAY split_x(LAY l, int id, int num); // id = {0..num-1}

  LAY split_xy(LAY l, int id, int num_x, int num_y); // id={0..(num_x*num_y-1)}

  LAY margin(LAY l, int id, int lx, int rx, int ty, int by); // id={ 0 }

  LAY size(LAY l, int id, int lx, int size_x, int ty, int size_y); // id = { 0 }

  LAY center(LAY l, int id, int content_size_x, int content_size_y); // id={0}

  LAY array(LAY *array, int *id, int size); // id = { 0..size }


  int root_sx(LAY l);

  int root_sy(LAY l);


  int count(LAY l);

  int pos_x(LAY l, int id);

  int pos_y(LAY l, int id);

  int size_x(LAY l, int id);

  int size_y(LAY l, int id);


private:

  Env &e;

};


#endif


#ifdef F_DRAW_API


class DrawApi

{

public:

  IMPORT DrawApi(Env &e);

  DR label(LAY l, int id, std::string str, Ft font);

  DR icon(LAY l, int id, BM bm);

  DR rect(LAY l, int id, unsigned int color);

  DR scroll(DR dr, int delta_x, int delta_y);

  DR scroll_area(DR dr, LAY l, int id);

  DR cliprect(DR cmds, LAY l, int id);


  DR array(DR *array, int size);

  DR alternatives_array(std::string id, DR *array, int size);

  DR choose_alternative(DR dr, std::string id, int val);


  DR deep_copy(DR d);

  bool is_specific_alternative(DR d, std::string id);

  int array_count(DR d);

  int alternative_array_count(DR d);

  DR array_index(DR d, int index);

  DR alternative_array_index(DR d, int index);

  bool is_array(DR d);

  bool is_alternative_array(DR d);

  bool is_primitive(DR d);


  BM render_to_bm(DR dr);

  std::string render_to_html_canvas(DR dr);

  std::string generate_java_code(DR dr);

private:

  Env &e;

};


#endif


struct EveryApi

{

  IMPORT EveryApi(Env &e);

  IMPORT Env &get_env();

  IMPORT ~EveryApi();

  MainLoopApi mainloop_api;

  PointApi point_api;

  VectorApi vector_api;

  MatrixApi matrix_api;

  SpriteApi sprite_api;

  GridApi grid_api;

  BitmapApi bitmap_api;

  PolygonApi polygon_api;

  BoolBitmapApi bool_bitmap_api;

  FloatBitmapApi float_bitmap_api;

  ContinuousBitmapApi cont_bitmap_api;

  FontApi font_api;

  AnimApi anim_api;

  EventApi event_api;

  //CurveApi curve_api;

  FunctionApi function_api;

  VolumeApi volume_api;

  FloatVolumeApi float_volume_api;

  ColorVolumeApi color_volume_api;

  DistanceFloatVolumeApi dist_api;

  VectorVolumeApi vector_volume_api;

  ShaderApi shader_api;

  StateChangeApi state_change_api;

  TextureApi texture_api;

  SeparateApi separate_api;

  WaveformApi waveform_api;

  ColorApi color_api;

  LinesApi lines_api;

  PlaneApi plane_api;

  PointsApi points_api;

  VoxelApi voxel_api;

  FrameBufferApi fbo_api;

  SampleCollectionApi sample_api;

  TrackerApi tracker_api;

  ShaderModuleApi sh_api;

  WModApi mod_api;

  PhysicsApi physics_api;

  TriStripApi ts_api;

  CutterApi cutter_api;

  BooleanOps bool_api;

  CollisionPlane collision_api;

  MovementNode move_api;

  ImplicitApi implicit_api;

  PickingApi picking_api;

  TreeApi tree_api;

  MaterialsApi materials_api;

  UberShaderApi uber_api;

  CurveApi curve_api;

  MatricesApi matrices_api;

  Skeletal skeletal_api;

  PolygonArrayApi polygon_arr_api;

  PolygonDistanceField polygon_dist_api;

  BlockerApi blocker_api;

  VertexAnimApi vertex_anim_api;

  NewPlaneApi newplane_api;

  SurfaceApi surface_api;

  LowFrameBufferApi low_frame_api;

  FloatSceneApi float_scene_api;

private:

  Env &env;

  EveryApi(const EveryApi&);

  void operator=(const EveryApi&);


};


#ifdef F_GAMES_API


class GamesApi

{

public:

  IMPORT GamesApi(Env &e);

  IMPORT ~GamesApi();

  IMPORT void register_game(int game_id, void (*fptr)(EveryApi &e));

  IMPORT void modify_map(int event, int game_id);

  IMPORT void start_game(int event);

private:

  Env &e;

  //void *priv;

};


#endif


  //

  // Object-Oriented API

  //


  class RenderObject

  {

  public:

    virtual ~RenderObject() { }

    virtual void prepare(bool keep=false)=0;

    virtual void render()=0;

    virtual void set_var(std::string name, float r, float g, float b, float a)=0;

  };


  void prepare(RenderObject &o);


  class MoveScaleObject2d

  {

  public:

    virtual ~MoveScaleObject2d() { }

    virtual void set_pos(float pos_x, float pos_y)=0;

    virtual void set_scale(float mult_x, float mult_y)=0;

  };


  class MoveScaleObject3d

  {

  public:

    virtual ~MoveScaleObject3d() { }

    virtual void set_pos(float pos_x, float pos_y, float pos_z)=0;

    virtual void set_scale(float mult_x, float mult_y, float mult_z)=0;

    virtual void set_rotation_matrix(M m)=0;

    virtual void set_rotation_matrix2(M m)=0;

  };


  class ArrayObj3d : public RenderObject, public MoveScaleObject3d

  {

  public:


    ArrayObj3d(EveryApi &ev) : ev(ev), p_x(0.0), p_y(0.0), p_z(0.0), s_x(1.0), s_y(1.0), s_z(1.0)

    {

      current_rot_matrix = ev.matrix_api.identity();

      current_rot_matrix2 = ev.matrix_api.identity();

   }


    void push_back(RenderObject *obj, MoveScaleObject3d *obj2)

    {

      render_vec.push_back(obj);

      move_scale_vec.push_back(obj2);

      pos_x.push_back(0.0);

      pos_y.push_back(0.0);

      pos_z.push_back(0.0);

      scale_x.push_back(1.0);

      scale_y.push_back(1.0);

      scale_z.push_back(1.0);

      rot_matrix.push_back(ev.matrix_api.identity());

    }


    void prepare(bool keep=false) {

      int s = render_vec.size();

      for(int i=0;i<s;i++) {

    render_vec[i]->prepare();

      }

    }


    void render() {

      int s = render_vec.size();

      for(int i=0;i<s;i++) {

    int ss = child_var.size();

    for(int j=0;j<ss;j++)

      {

        ChildVar &v = child_var[j];

        if (v.i==i)

          render_vec[i]->set_var(v.name, v.r, v.g, v.b,v.a);

      }

    render_vec[i]->render();

      }

    }


    int size() const { return render_vec.size(); }


    void set_child_pos(int i, float cpos_x, float cpos_y, float cpos_z)

    {

      pos_x[i] = cpos_x;

      pos_y[i] = cpos_y;

      pos_z[i] = cpos_z;

      setup_one(i);

    }


    void set_child_scale(int i, float mult_x, float mult_y, float mult_z)

    {

      scale_x[i] = mult_x;

      scale_y[i] = mult_y;

      scale_z[i] = mult_z;

      setup_one(i);

    }


    M rot_y(float c_x, float c_y, float c_z, float angle)

    {

      M m1 = ev.matrix_api.trans(c_x, c_y, c_z);

      M m2 = ev.matrix_api.yrot(angle);

      M m3 = ev.matrix_api.trans(-c_x, -c_y, -c_z);

      M mm = ev.matrix_api.mult(m1,m2);

      M mmm = ev.matrix_api.mult(mm, m3);

      return mmm;

    }


    M rot_x(float c_x, float c_y, float c_z, float angle)

    {

      M m1 = ev.matrix_api.trans(c_x, c_y, c_z);

      M m2 = ev.matrix_api.xrot(angle);

      M m3 = ev.matrix_api.trans(-c_x, -c_y, -c_z);

      M mm = ev.matrix_api.mult(m1,m2);

      M mmm = ev.matrix_api.mult(mm, m3);

      return mmm;

    }


    M rot_z(float c_x, float c_y, float c_z, float angle)

    {

      M m1 = ev.matrix_api.trans(c_x, c_y, c_z);

      M m2 = ev.matrix_api.zrot(angle);

      M m3 = ev.matrix_api.trans(-c_x, -c_y, -c_z);

      M mm = ev.matrix_api.mult(m1,m2);

      M mmm = ev.matrix_api.mult(mm, m3);

      return mmm;

    }


    void set_child_rot_matrix(int i, M m)

    {

      rot_matrix[i] = m;

      setup_one(i);

    }


    struct ChildVar

    {

      int i;

      std::string name;

      float r,g,b,a;

    };


    void set_var(std::string name, float r, float g, float b, float a)

    {

      int s = render_vec.size();

      for(int i=0;i<s;i++)

    {

      set_child_shader_var(i, name, r,g,b,a);

    }

    }


    void set_child_shader_var(int i, std::string name, float r, float g, float b, float a)

    {

      ChildVar v;

      v.i = i;

      v.name = name;

      v.r = r; v.g = g; v.b=b; v.a=a;

      child_var.push_back(v);

    }


    void set_pos(float pos_x, float pos_y, float pos_z)

    {

      p_x = pos_x;

      p_y = pos_y;

      p_z = pos_z;

      setup();

    }


    void set_scale(float mult_x, float mult_y, float mult_z)

    {

      s_x = mult_x;

      s_y = mult_y;

      s_z = mult_z;

      setup();

    }


    void set_rotation_matrix(M m)

    {

      current_rot_matrix = m;

      setup();

    }


    void set_rotation_matrix2(M m)

    {

      current_rot_matrix2 = m;

    }


  private:

    void setup_one(int i)

    {

      float ap_x = pos_x[i];

      float ap_y = pos_y[i];

      float ap_z = pos_z[i];

      float as_x = scale_x[i];

      float as_y = scale_y[i];

      float as_z = scale_z[i];

      M m = rot_matrix[i];

      ap_x += p_x;

      ap_y += p_y;

      ap_z += p_z;

      as_x*=s_x;

      as_y*=s_y;

      as_z*=s_z;

      m = ev.matrix_api.mult(m, current_rot_matrix);

      move_scale_vec[i]->set_pos(ap_x,ap_y,ap_z);

      move_scale_vec[i]->set_scale(as_x,as_y,as_z);

      move_scale_vec[i]->set_rotation_matrix(m);

      move_scale_vec[i]->set_rotation_matrix2(current_rot_matrix2);

    }

    void setup()

    {

      int s = pos_x.size();

      for(int i=0;i<s;i++)

    {

      setup_one(i);

    }

    }

  private:

    EveryApi &ev;

    std::vector<RenderObject *> render_vec;

    std::vector<MoveScaleObject3d *> move_scale_vec;

    std::vector<float> pos_x;

    std::vector<float> pos_y;

    std::vector<float> pos_z;

    std::vector<float> scale_x;

    std::vector<float> scale_y;

    std::vector<float> scale_z;

    std::vector<M> rot_matrix;

    std::vector<M> rot_matrix2;

    std::vector<ChildVar> child_var;

    float p_x, p_y, p_z;

    float s_x, s_y, s_z;

    M current_rot_matrix;

    M current_rot_matrix2;

  };


  class SpriteObj : public RenderObject, public MoveScaleObject2d

  {

  public:


    SpriteObj(EveryApi &ev, BM bm_, SH sh) : sp(ev.sprite_api), matrix_api(ev.matrix_api), shader_api(ev.shader_api), sh(sh)

    {

      bm.push_back(bm_);

      pos_x = 0.0; pos_y = 0.0;

      mult_x = 1.0; mult_y = 1.0;

      anim_id = 0;

      m = matrix_api.identity();

      prepared=false;

    }


    SpriteObj(EveryApi &ev, std::vector<BM> anim, SH sh) : sp(ev.sprite_api), matrix_api(ev.matrix_api), shader_api(ev.shader_api), bm(anim), sh(sh)

    {

      pos_x = 0.0; pos_y = 0.0;

      mult_x = 1.0; mult_y = 1.0;

      anim_id = 0;

      m = matrix_api.identity();

      prepared=false;

    }


    void prepare(bool keep=false)

    {

      va.clear();

      for(int i=0;i<(int)bm.size();i++)

    va.push_back(sp.create_vertex_array(bm[i]));

      prepared=true;

    }


    void render()

    {

      if (prepared)

    {

      shader_api.set_var(sh, "in_MV", matrix_api.mult(m,matrix_api.mult(matrix_api.scale(mult_x, mult_y, 1.0), matrix_api.trans(pos_x+0.5, pos_y+0.5, 0.0))));

      sp.render_sprite_vertex_array(va[anim_id]);

    }

      //sp.rendersprite(bm[anim_id], sh, pos_x, pos_y, mult_x, mult_y);

    }


    void set_pos(float p_x, float p_y) { pos_x=p_x; pos_y=p_y; }

    void set_scale(float m_x, float m_y) { mult_x = m_x; mult_y=m_y; }

    void set_matrix(M m1) { m = m1; }


    void set_anim_frame(int id)

    {

      if (id>=0 && id<(int)bm.size())

    anim_id = id;

    }


    void set_var(std::string name, float r, float g, float b, float a)

    {

      shader_api.set_var(sh, name.c_str(), r,g,b,a);

    }


  private:

    float pos_x, pos_y;

    float mult_x, mult_y;

    SpriteApi &sp;

    MatrixApi &matrix_api;

    ShaderApi &shader_api;

    std::vector<BM> bm;

    std::vector<VA> va;

    M m;

    int anim_id;

    SH sh;

    bool prepared;

  };


  class SpriteWorldObj : public RenderObject, public MoveScaleObject2d

  {

  public:


    SpriteWorldObj(EveryApi &ev, std::function<BM(int)> f, int numvalues, BM int_bm, int dx, int dy, SH sh) : bmapi(ev.bitmap_api), sp(ev.sprite_api), matrix_api(ev.matrix_api), shader_api(ev.shader_api), sh(sh), f(f), numvalues(numvalues), int_bm(int_bm), dx(dx), dy(dy)

    {

      m_t = 0;

      m_l = 0;

      m_width = bmapi.size_x(int_bm);

      m_height = bmapi.size_y(int_bm);

      mult_x = 1.0;

      mult_y = 1.0;

      bitmap = new int[m_width*m_height];

      for(int y=0;y<m_height;y++)

    for(int x=0;x<m_width;x++)

      {

        bitmap[x+y*m_width] = bmapi.intvalue(int_bm, x,y);

      }

    }


    ~SpriteWorldObj() { delete [] bitmap; }


    void set_block(int x, int y, int c)

    {

      if (x>=0&&x<m_width)

    if (y>=0&&y<m_height)

      bitmap[x+y*m_width] = c;

    }


    int read_block(int x, int y)

    {

      if (x>=0&&x<m_width)

    if (y>=0&&y<m_height)

      return bitmap[x+y*m_width];

      return 0;

    }


    void set_range(int l, int t, int width, int height)

    {

      m_l = l;

      m_t = t;

      m_width = width;

      m_height = height;

    }


    void prepare(bool keep=false)

    {

      va.clear();

      for(int i=0;i<(int)numvalues;i++)

    va.push_back(sp.create_vertex_array(f(i)));

      prepared=true;

    }


    void render()

    {

      if (prepared)

    {

      M m = matrix_api.mult(matrix_api.scale(mult_x, mult_y, 1.0), matrix_api.trans(pos_x, pos_y, 0.0));

      for(int y=m_t;y<m_height;y++)

        for(int x=m_l;x<m_width;x++)

          {

        M m2 = matrix_api.mult(matrix_api.trans(x*dx+0.5, y*dy+0.5, 0.0),m);

        shader_api.set_var(sh, "in_MV", m2);

        int index = bitmap[x+y*m_width]; //bmapi.intvalue(int_bm, x,y);

        sp.render_sprite_vertex_array(va[index]);

          }

    }

      //sp.rendersprite(bm[anim_id], sh, pos_x, pos_y, mult_x, mult_y);

    }


    void set_pos(float p_x, float p_y) { pos_x=p_x; pos_y=p_y; }

    void set_scale(float m_x, float m_y) { mult_x = m_x; mult_y=m_y; }


    int get_pos_x(float mouse_x) const

    {

      mouse_x-=pos_x;

      mouse_x/=mult_x;

      mouse_x/=dx;

      return (int)mouse_x;

    }


    int get_pos_y(float mouse_y) const

    {

      mouse_y-=pos_y;

      mouse_y/=mult_y;

      mouse_y/=dy;

      return (int)mouse_y;

    }


    void set_var(std::string name, float r, float g, float b, float a)

    {

      shader_api.set_var(sh, name.c_str(), r,g,b,a);

    }


  private:

    BitmapApi &bmapi;

    SpriteApi &sp;

    MatrixApi &matrix_api;

    ShaderApi &shader_api;

    SH sh;

    std::function<BM(int)> f;

    std::vector<VA> va;

    int *bitmap;

    int numvalues;

    BM int_bm;

    float dx,dy;

    int m_t, m_l, m_width, m_height;

    bool prepared;

    float mult_x,mult_y;

    float pos_x, pos_y;

  };


  class PolygonObj : public RenderObject, public MoveScaleObject3d

  {

  public:


    PolygonObj(EveryApi &ev, P p, SH sh) : ev(ev), api(ev.polygon_api), shapi(ev.shader_api), mat(ev.matrix_api), tex(ev.texture_api), sh(sh)

    {

      m_p.push_back(ev.polygon_arr_api.split_p(ev,p,500000));

      id.resize(1);

      m_va2.resize(1);

      current_pos = mat.identity();

      current_scale = mat.identity();

      current_rot = mat.identity();

      current_rot2 = mat.identity();

      setup_m();

      //id.id = 0;

      //va.id = 0;

      anim_id = 0;

      anim_time = 0.0;

      txa_id.id = 0;

      first = true;

    }


    PolygonObj(EveryApi &ev, std::vector<P> anim_p, SH sh) : ev(ev), api(ev.polygon_api), shapi(ev.shader_api), mat(ev.matrix_api), tex(ev.texture_api), sh(sh)

    {

      int s = anim_p.size();

      for(int i=0;i<s;i++)

    {

      m_p.push_back(ev.polygon_arr_api.split_p(ev,anim_p[i],500000));

    }

      id.resize(anim_p.size());

      m_va2.resize(anim_p.size());

      current_pos = mat.identity();

      current_scale = mat.identity();

      current_rot = mat.identity();

      current_rot2 = mat.identity();

      setup_m();

      //id.id = 0;

      //va.id = 0;

      anim_id = 0;

      anim_time = 0.0;

      first = true;

    }


#if 0

    PolygonObj(PolygonApi &api, ShaderApi &shapi, MatrixApi &mat, TextureApi &tex,P p, SH sh) : api(api), shapi(shapi), mat(mat), tex(tex), sh(sh)

    {

      m_p.push_back(p);

      id.resize(1);

      m_va2.resize(1);

      current_pos = mat.identity();

      current_scale = mat.identity();

      current_rot = mat.identity();

      current_rot2 = mat.identity();

      setup_m();

      //id.id=0;

      //va.id =0;

      anim_id = 0;

      anim_time = 0.0;

      first = true;

    }

#endif


    ~PolygonObj() {

      int s = va_mem.size();

      for(int i=0;i<s;i++)

    {

      ev.polygon_arr_api.delete_vertex_array(ev,va_mem[i]);

    }

    }


    void prepare(bool keep=false)

    {

      m_va2.clear();

      for(int i=0;i<(int)m_p.size();i++)

    {

      Va va = ev.polygon_arr_api.create_vertex_array(ev,m_p[i], id[i].id!=0||keep);

      va_mem.push_back(va);

      Va va2;

#ifdef TODO

      if (id[i].id!=0) {

        va2 = tex.bind(va, id[i]);

      } else {

        if (txa_id.id!=0) {

          va2 = tex.bind_arr(va, txa_id);

        }

        else

#endif

          va2 = va;

#ifdef TODO

      }

#endif

      m_va2.push_back(va2);

    }

    }


    void render() {

      shapi.use(sh);

      shapi.set_var(sh, "in_MV", m);

      shapi.set_var(sh, "in_N", normal_matrix);

      //shapi.set_var(sh, "in_T", m2);

      shapi.set_var(sh, "in_POS", anim_time);

      ev.polygon_arr_api.render_vertex_array(ev,m_va2[anim_id]);

      shapi.set_var(sh, "in_POS", 0.0f);

    }


    void render_instanced(PTA pta) {

      shapi.use(sh);

      shapi.set_var(sh, "in_MV", m);

      shapi.set_var(sh, "in_N", normal_matrix);

      //shapi.set_var(sh, "in_T", m2);

      shapi.set_var(sh, "in_POS", anim_time);

      if (first)

    {

      ev.polygon_arr_api.prepare_vertex_array_instanced(ev,shapi, m_va2[anim_id], pta,sh);

      first = false;

    }

      ev.polygon_arr_api.render_vertex_array_instanced(ev,shapi, m_va2[anim_id], pta, sh);

      shapi.set_var(sh, "in_POS", 0.0f);

    }


    void set_pos(float pos_x, float pos_y, float pos_z)

    {

      current_pos = mat.trans(pos_x, pos_y, pos_z);

      setup_m();

    }


    void set_scale(float mult_x, float mult_y, float mult_z)

    {

      current_scale = mat.scale(mult_x, mult_y, mult_z);

      setup_m();

    }


    void set_rotation_y(float angle)

    {

      current_rot = mat.yrot(angle);

      setup_m();

    }


    void set_rotation_matrix(M m)

    {

      current_rot = m;

      setup_m();

    }


    void set_rotation_matrix2(M m)

    {

      current_rot2 = m;

      setup_m();

    }


    void bind_texture(int anim_id, TXID id_)

    {

      id[anim_id] = id_;

    }


    void bind_texarray(TXA id)

    {

      txa_id = id;

    }


    void set_anim_frame(int id)

    {

      if (id>=0&&id<(int)m_va2.size())

    anim_id = id;

    }


    void set_anim_time(float time)

    {

      anim_time = time;

    }


#if 0

    void explode(PT pos, float val)

    {

      api.explode(m_va2[anim_id], pos, val);

      api.update(m_va2[anim_id]);

    }

#endif


    void set_var(std::string name, float r, float g, float b, float a)

    {

      shapi.set_var(sh, name.c_str(), r,g,b,a);

    }


  private:

    void setup_m() {

      m = mat.mult(mat.mult(mat.mult(current_rot,current_scale), current_pos), current_rot2);

      normal_matrix = mat.keep_rotation(m);

      //m2 = mat.mult(mat.mult(current_rot, current_scale), current_rot2);

    }

  private:

    EveryApi &ev;

    PolygonApi &api;

    ShaderApi &shapi;

    MatrixApi &mat;

    TextureApi &tex;

    M current_pos;

    M current_scale;

    M current_rot;

    M current_rot2;

    M m;

    M normal_matrix;

    M m2;

    std::vector<Pa> m_p;

    SH sh;

    //VA va;

    std::vector<Va> m_va2;

    std::vector<Va> va_mem;

    std::vector<TXID> id;

    TXA txa_id;

    int anim_id;

    float anim_time;

    bool first;

  };


  class WorldObj : public RenderObject, public MoveScaleObject3d

  {

  public:


    WorldObj(EveryApi &ev, std::function<P(int)> f, int numvalues, BM bm, float dx, float dy, SH sh) : ev(ev), bmapi(ev.bitmap_api), api(ev.polygon_api), shapi(ev.shader_api), mat(ev.matrix_api), tex(ev.texture_api), pts(ev.point_api), numvalues(numvalues), bm(bm), f(f), dx(dx), dy(dy), sh(sh)

    {

      int sx = bmapi.size_x(bm);

      int sy = bmapi.size_y(bm);

      bitmap = new int[sx*sy];

      var_bitmap = new std::vector<Var>[sx*sy];

      outline_bitmap = new bool[sx*sy];

      anim_time = new float[sx*sy];

      for(int y=0;y<sy;y++)

    {

      for(int x=0;x<sx;x++)

        {

          int val = bmapi.intvalue(bm, x,y);

          bitmap[x+y*sx] = val;

          var_bitmap[x+y*sx] = std::vector<Var>();

          outline_bitmap[x+y*sx] = false;

          anim_time[x+y*sx] = 0.0f;

        }

    }


      m_x = 0;

      m_y = 0;

      m_sx = sx;

      m_sy = sy;


      id.resize(numvalues);

      current_pos = mat.identity();

      current_scale = mat.identity();

      current_rot = mat.identity();

      current_rot2 = mat.identity();

      setup_m();

      //id.id = 0;

      //va.id = 0;

      anim_id = 0;

      txa_id.id = 0;

    }


    ~WorldObj() { delete [] bitmap; }


    void set_block(int x, int y, int c) {

      int sx=m_sx; //bmapi.size_x(bm);

      bitmap[x+y*sx] = c;

    }


    int read_block(int x, int y) const {

      int sx=m_sx; //bmapi.size_x(bm);

      return bitmap[x+y*sx];

    }


    void set_anim_time(int x, int y, float time)

    {

      int sx = m_sx; //bmapi.size_x(bm);

      anim_time[x+y*sx] = time;

    }


    void prepare(bool keep=false)

    {

      m_va2.clear();

      for(int i=0;i<numvalues;i++)

    {

      P p = f(i);

      VA va = api.create_vertex_array(p);

      VA va2;

      if (id[i].id!=0) {

        va2 = tex.bind(va, id[i]);

      } else {

        if (txa_id.id!=0)

          {

        va2 = tex.bind_arr(va, txa_id);

          }

        else

          va2 = va;

      }

      m_va2[i] = va2;

    }

    }


    void set_range(int x, int y, int sx, int sy)

    {

      m_x = x;

      m_y = y;

      m_sx = sx;

      m_sy = sy;

    }


    P collect() {

      std::vector<P> vec2;

      int sx = m_sx; //bmapi.size_x(bm);

      for(int y=m_y;y<m_y+m_sy;y++) {

    std::vector<P> vec1;

    for(int x=m_x;x<m_x+m_sx;x++) {

      P p = f(bitmap[x+y*sx]);

      P p2 = api.translate(p, dx*x,0.0,dy*y);

      vec1.push_back(p2);

    }

    vec2.push_back(api.or_array(&vec1[0], vec1.size()));

      }

      return api.or_array(&vec2[0], vec2.size());

    }


    void render_outline(SH sh_new)

    {

#ifndef EMSCRIPTEN

      SH sh2 = sh;

      ev.mainloop_api.outline_first();

      render();

      sh = sh_new;

      ev.mainloop_api.outline_second();

      render();

      ev.mainloop_api.outline_first();

      render();

      sh = sh2;

      ev.mainloop_api.outline_third();

      //render();

      ev.mainloop_api.outline_disable();

#else

      render();

#endif

    }


    void render() {

      shapi.use(sh);

      int sx = m_sx; //bmapi.size_x(bm);

      for(int y=m_y;y<m_y+m_sy;y++) {

    for(int x=m_x;x<m_x+m_sx;x++) {

      M t = mat.trans(dx*x,0.0,dy*y);

      M t2 = mat.mult(t,m);

      shapi.set_var(sh, "in_MV", t2);

      shapi.set_var(sh, "in_POS", anim_time[x+y*sx]);

      if (outline_bitmap[x+y*m_sx])

        {

          shapi.use(m_sh3);

          shapi.set_var(m_sh3, "in_MV", t2);

          shapi.set_var(m_sh3, "in_POS", anim_time[x+y*sx]);

          shapi.use(sh);

        }

      //std::cout << x << " " << y << " " << anim_time[x+y*sx] << std::endl;

      std::vector<Var> &v = var_bitmap[x+y*sx];

      int s = v.size();

      for(int i=0;i<s;i++)

        {

          Var &vv = v[i];

          shapi.set_var(sh, vv.name.c_str(), vv.r, vv.g, vv.b, vv.a);

          //std::cout << i << ":" << vv.name << " " << vv.r << " " << vv.g << " " << vv.b <<" " << vv.a << std::endl;

          if (outline_bitmap[x+y*m_sx])

        {

          shapi.use(m_sh3);

          shapi.set_var(m_sh3, vv.name.c_str(), vv.r, vv.g, vv.b, vv.a);

          shapi.use(sh);

        }


        }


      if (outline_bitmap[x+y*m_sx])

        render_one_outline(x,y,m_sh3);

        else

          render_one(x,y);

      //api.render_vertex_array(m_va2[bitmap[x+y*sx]]);

      shapi.set_var(sh, "in_POS", 0.0f);

    }

      }

    }


  private:

    void render_one(int x, int y)

    {

      api.render_vertex_array(m_va2[bitmap[x+y*m_sx]]);

    }

    void render_one_outline(int x, int y, SH sh_new)

    {

#ifndef EMSCRIPTEN

      ev.mainloop_api.outline_first();

      render_one(x,y);

      ev.shader_api.use(sh_new);

      ev.mainloop_api.outline_second();

      render_one(x,y);

      ev.shader_api.use(sh);

      ev.mainloop_api.outline_third();

      ev.mainloop_api.outline_disable();

#else

      render_one(x,y);

#endif

    }

  public:


    void set_pos(float pos_x, float pos_y, float pos_z)

    {

      current_pos = mat.trans(pos_x, pos_y, pos_z);

      setup_m();

    }


    void set_scale(float mult_x, float mult_y, float mult_z)

    {

      current_scale = mat.scale(mult_x, mult_y, mult_z);

      setup_m();

    }


    void set_rotation_y(float angle)

    {

      current_rot = mat.yrot(angle);

      setup_m();

    }


    void set_rotation_matrix(M m)

    {

      current_rot = m;

      setup_m();

    }


    void set_rotation_matrix2(M m)

    {

      current_rot2 = m;

      setup_m();

    }


    void bind_texture(int num_id, TXID id_)

    {

      id[num_id] = id_;

    }


    void bind_texarray(TXA id)

    {

      txa_id = id;

    }


    void set_anim_frame(int id)

    {

      if (id>=0&&id<(int)m_va2.size())

    anim_id = id;

    }


    void pick_object1(float x, float y, float &xx, float &yy, float &zz)

    {

      PT point = pts.point(x,y,0.0f);


      PinOut<M> mp = shapi.get_matrix_var(sh, "in_P");

      M m3 = mat.inverse(mp.data);

      PT point1 = mat.mult(point, m3);


      PinOut<M> mp2 = shapi.get_matrix_var(sh, "in_T");

      M m4 = mat.inverse(mp2.data);

      PT point2 = mat.mult(point1, m4);


      M m2 = mat.inverse(m);

      PT point3 = mat.mult(point2, m2);


      xx = pts.pt_x(point3);

      yy = pts.pt_y(point3);

      zz = pts.pt_z(point3);


    }


    bool pick_object2(float mouse_x, float mouse_y, float radius, int scr_x, int scr_y, M in_P, int x, int y)

    {

      float pos_x = dx*x + radius/2;

      float pos_y = 0.0;

      float pos_z = dy*y + radius/2;

      BB area = ev.picking_api.pick_area(ev, mouse_x, mouse_y, radius, scr_x, scr_y);

      O vol = ev.picking_api.pick_volume(in_P, area);

      bool b = ev.picking_api.picked(vol, pos_x, pos_y, pos_z);

      return b;

    }


    void set_var(std::string name, float r, float g, float b, float a)

    {

      shapi.set_var(sh, name.c_str(), r,g,b,a);

    }


    struct Var

    {

      std::string name;

      float r,g,b,a;

    };


    void clear_child_var(int x, int y)

    {

      var_bitmap[x+y*m_sx]=std::vector<Var>();

    }


    void set_child_var(int x, int y, std::string name, float r, float g, float b, float a)

    {

      Var v;

      v.name = name;

      v.r = r;

      v.g = g;

      v.b = b;

      v.a = a;

      var_bitmap[x+y*m_sx].push_back(v);

    }


    void set_outline(int x, int y, bool b, SH sh3)

    {

      m_sh3 = sh3;

      outline_bitmap[x+y*m_sx] = b;

    }


  private:

    void setup_m() {

      m = mat.mult(mat.mult(mat.mult(current_rot,current_scale), current_pos), current_rot2);

    }


  private:

    EveryApi &ev;

    BitmapApi &bmapi;

    PolygonApi &api;

    ShaderApi &shapi;

    MatrixApi &mat;

    TextureApi &tex;

    PointApi &pts;

    M current_pos;

    M current_scale;

    M current_rot;

    M current_rot2;

    M m;

    //std::vector<P> m_p;

    int numvalues;

    BM bm;

    std::function<P(int)> f;

    float dx,dy;

    int *bitmap;

    std::vector<Var> *var_bitmap;

    bool *outline_bitmap;

    float *anim_time;

    SH sh;

    SH m_sh3;

    int m_x, m_y, m_sx, m_sy;

    //VA va;

    //std::vector<VA> m_va2;

    std::map<int, VA> m_va2;

    std::vector<TXID> id;

    TXA txa_id;

    int anim_id;

  };


  class PointsObj : public RenderObject, public MoveScaleObject3d

  {

  public:


    PointsObj(EveryApi &ev, PTS fo, SH sh, P pp, float mix) : points_api(ev.points_api), mat(ev.matrix_api), shapi(ev.shader_api), fo(fo), sh(sh),pp(pp),mix(mix)

    {

      numpoints = 5000;

      start_x = -1.0;

      start_y = -1.0;

      start_z = -1.0;

      end_x = 1.0;

      end_y = 1.0;

      end_z = 1.0;

      current_pos = mat.identity();

      current_scale = mat.identity();

      current_rot = mat.identity();

      setup_m();

    }


    void set_numpoints(int count) { numpoints = count; }


    void set_bounds(float s_x, float s_y, float s_z,

            float e_x, float e_y, float e_z)

    {

      start_x = s_x;

      start_y = s_y;

      start_z = s_z;

      end_x = e_x;

      end_y = e_y;

      end_z = e_z;

    }


    void prepare(bool keep=false) {

      array = points_api.prepare(fo,false);

      //array = floatvolume.prepare(fo, numpoints, start_x, start_y, start_z, end_x, end_y, end_z);

    }


    void render() {

      shapi.use(sh);

      shapi.set_var(sh, "in_MV", m);

      points_api.render(array);

      //floatvolume.render(array);

    }


    void set_pos(float pos_x, float pos_y, float pos_z)

    {

      current_pos = mat.trans(pos_x, pos_y, pos_z);

      setup_m();

    }


    void set_scale(float mult_x, float mult_y, float mult_z)

    {

      current_scale = mat.scale(mult_x, mult_y, mult_z);

      setup_m();

    }


    void set_rotation_matrix(M m)

    {

      current_rot = m;

      setup_m();

    }


    void set_rotation_matrix2(M m) { }


    void set_var(std::string name, float r, float g, float b, float a)

    {

      shapi.set_var(sh, name.c_str(), r,g,b,a);

    }


  private:

    void setup_m() {

      m = mat.mult(current_rot, mat.mult(current_scale, current_pos));

    }


  private:

    PointsApi &points_api;

    MatrixApi &mat;

    ShaderApi &shapi;

    PTS fo;

    //PTS fo2;

    PTA array;

    SH sh;

    M current_pos;

    M current_scale;

    M current_rot;

    M m;

    int numpoints;

    float start_x, start_y, start_z;

    float end_x, end_y, end_z;

    P pp;

    float mix;

  };


  class LinesObj : public RenderObject, public MoveScaleObject3d

  {

  public:


    LinesObj(EveryApi &ev, LI li, SH sh) : lines(ev.lines_api), mat(ev.matrix_api), shapi(ev.shader_api), li(li), sh(sh)

    {

      current_pos = mat.identity();

      current_scale = mat.identity();

      current_rot = mat.identity();

      current_rot2 = mat.identity();

      setup_m();

    }


    //LinesObj(LinesApi &lines, MatrixApi &mat, ShaderApi &shapi, LI li, SH sh) : lines(lines), mat(mat), shapi(shapi), li(li), sh(sh) { }

    void prepare(bool keep=false) { li2 = lines.prepare(li); }


    void render() {

      shapi.use(sh);

      shapi.set_var(sh, "in_MV", m);

      lines.render(li2);

    }


    void set_pos(float pos_x, float pos_y, float pos_z)

    {

      current_pos = mat.trans(pos_x, pos_y, pos_z);

      setup_m();

    }


    void set_scale(float mult_x, float mult_y, float mult_z)

    {

      current_scale = mat.scale(mult_x, mult_y, mult_z);

      setup_m();

    }


    void set_rotation_matrix(M m)

    {

      current_rot = m;

      setup_m();

    }


    void set_rotation_matrix2(M m)

    {

      current_rot2 = m;

      setup_m();

    }


    void set_var(std::string name, float r, float g, float b, float a)

    {

      shapi.set_var(sh, name.c_str(), r,g,b,a);

    }


  private:

    void setup_m() {

      m = mat.mult(mat.mult(current_rot, mat.mult(current_scale, current_pos)),current_rot2);

    }

  private:

    LinesApi &lines;

    MatrixApi &mat;

    ShaderApi &shapi;

    LI li;

    SH sh;

    LLA li2;

    M current_pos;

    M current_scale;

    M current_rot;

    M current_rot2;

    M m;

  };


  void append_url_map(const char* url, const unsigned char* data, const unsigned char *data_end);


}; // GameApi namespace


#endif

world
char world[]
Definition test.cpp:7

chars
char chars[]
Definition test.cpp:102

env
struct Envi env

blocks
P blocks(int c, EveryApi &ev)
Definition test.cpp:19

mainloop
ML mainloop(EveryApi &ev, MN &move)
Definition test.cpp:851

Buffer.hh

e
Env e
Definition Common.cc:2

ev
EveryApi ev(e)

colors
Color2 colors[]
Definition Effect.cc:56

pt
Point2d pt(const FT_Vector *v)
Definition FreeType2.cc:459

matrix
void matrix(BoxableFaceCollection &coll, Matrix m, FaceStore &s)
Definition Functions.cc:56

n_0
BirdNode n_0
Definition GameApi.cc:44227

print
void print(const VoxFrame &f)
Definition GameApi.cc:22580

part
GameApi::ML part(GameApi::EveryApi &ev, GameApi::ML ml, float x_trans, float y_rot, int x, int y, int mode=0)
Definition GameApi.cc:38016

n_1
BirdNode n_1
Definition GameApi.cc:44228

score
int score
Definition GameApi.cc:19119

MB
std::string MB(long num)
Definition GameApi.cc:43586

ELayoutEmpty
int ELayoutEmpty
Definition GameApi_gui.cc:2662

IMPORT
#define IMPORT
Definition GameApi.hh:332

clear_block
void clear_block(int id)
Definition GameApi_dep_add_find.cc:114

MAC
#define MAC(name)
Definition GameApi.hh:58

add_block
int add_block()
Definition GameApi_dep_add_find.cc:33

set_current_block
void set_current_block(int id)
Definition GameApi_dep_add_find.cc:65

get_current_block
int get_current_block()
Definition GameApi_dep_add_find.cc:110

process
void * process(void *ptr)
Definition GameApi_dep_env.cc:2773

event_time
float event_time(Sequencer2 &seq, int e1)
Definition GameApi_ev.cc:54

dy
size dy
Definition GameApi_gui.cc:1727

render
EditorGuiWidgetAtlas GuiWidgetForward render()
Definition GameApi_gui.cc:1412

GameApi_low.hh

Low_GLuint
unsigned int Low_GLuint
Definition GameApi_low.hh:42

delta_time
float delta_time
Definition GameApi_main.cc:967

mul
Complex mul(Complex x, Complex y)
Definition GameApi_pl.cc:31400

cache_id
std::string cache_id(std::string filename, int obj_count)
Definition GameApi_pl.cc:14795

cmds
char * cmds[]
Definition Interpreter.hh:5

cs
float cs(float x, float m)
Definition VectorTools.cc:1167

color_1
unsigned int color_1(int pointnum, PT pos)
Definition test.cpp:7

ASyncTask
Definition test.cpp:3163

Array
Definition EffectI.hh:22

CX
Definition Effect.hh:10323

CodeGenPositions
Definition GameApi_wmod.cc:1144

GameApi::ASyncVec
Definition GraphI.hh:690

GameApi::AnimApi
Definition GameApi.hh:1377

GameApi::AnimApi::seq_line
IMPORT IS seq_line(IS *array, int size)
Definition GameApi_an.cc:200

GameApi::AnimApi::timeline_obj
IMPORT P timeline_obj(IS i, int choose_par, float time)

GameApi::AnimApi::timed_value_point
IMPORT PT timed_value_point(IS i, float time)
Definition GameApi_an.cc:263

GameApi::AnimApi::timeline_obj
IMPORT P timeline_obj(IS i, float time)

GameApi::AnimApi::repeat
IMPORT IS repeat(IS i, int count)
Definition GameApi_an.cc:209

GameApi::AnimApi::AnimApi
IMPORT AnimApi(Env &e)
Definition GameApi_bm.cc:35

GameApi::AnimApi::single
IMPORT IS single(int val, float duration)
Definition GameApi_bm.cc:1663

GameApi::AnimApi::par_line
IMPORT IS par_line(IS *array, int arraysize)

GameApi::AnimApi::line_obj
IMPORT IS line_obj(P p, P p2, float duration)

GameApi::AnimApi::timed_value_repeat_num
IMPORT int timed_value_repeat_num(IS i, float time)
Definition GameApi_an.cc:227

GameApi::AnimApi::timeline_float
IMPORT float timeline_float(IS i, int choose_par, float time)

GameApi::AnimApi::~AnimApi
IMPORT ~AnimApi()
Definition GameApi_bm.cc:39

GameApi::AnimApi::timed_value
IMPORT int timed_value(IS i, float time)
Definition GameApi_an.cc:252

GameApi::AnimApi::timed_value_float
IMPORT float timed_value_float(IS i, float time)
Definition GameApi_an.cc:274

GameApi::AnimApi::line
IMPORT IS line(int val1, int val2, float duration)
Definition GameApi_an.cc:118

GameApi::AnimApi::repeat_infinite
IMPORT IS repeat_infinite(IS i)
Definition GameApi_an.cc:218

GameApi::AnimApi::timeline_int
IMPORT int timeline_int(IS l, int choose_par, float time)

GameApi::AnimApi::timeline_point
IMPORT PT timeline_point(IS l, int choose_par, float time)

GameApi::ArrayApi::ArrayApi
IMPORT ArrayApi(Env &e)
Definition GameApi.cc:44483

GameApi::ArrayApi::array
A< T > array(std::vector< T > vec)
Definition GameApi_h.hh:1593

GameApi::ArrayObj3d::prepare
void prepare(bool keep=false)
Definition GameApi.hh:4800

GameApi::ArrayObj3d::set_rotation_matrix
void set_rotation_matrix(M m)
Definition GameApi.hh:4906

GameApi::ArrayObj3d::rot_x
M rot_x(float c_x, float c_y, float c_z, float angle)
Definition GameApi.hh:4844

GameApi::ArrayObj3d::set_pos
void set_pos(float pos_x, float pos_y, float pos_z)
Definition GameApi.hh:4892

GameApi::ArrayObj3d::rot_y
M rot_y(float c_x, float c_y, float c_z, float angle)
Definition GameApi.hh:4835

GameApi::ArrayObj3d::ArrayObj3d
ArrayObj3d(EveryApi &ev)
Definition GameApi.hh:4783

GameApi::ArrayObj3d::set_child_scale
void set_child_scale(int i, float mult_x, float mult_y, float mult_z)
Definition GameApi.hh:4828

GameApi::ArrayObj3d::rot_z
M rot_z(float c_x, float c_y, float c_z, float angle)
Definition GameApi.hh:4853

GameApi::ArrayObj3d::set_var
void set_var(std::string name, float r, float g, float b, float a)
Definition GameApi.hh:4875

GameApi::ArrayObj3d::set_rotation_matrix2
void set_rotation_matrix2(M m)
Definition GameApi.hh:4911

GameApi::ArrayObj3d::size
int size() const
Definition GameApi.hh:4819

GameApi::ArrayObj3d::push_back
void push_back(RenderObject *obj, MoveScaleObject3d *obj2)
Definition GameApi.hh:4788

GameApi::ArrayObj3d::set_child_shader_var
void set_child_shader_var(int i, std::string name, float r, float g, float b, float a)
Definition GameApi.hh:4884

GameApi::ArrayObj3d::set_child_rot_matrix
void set_child_rot_matrix(int i, M m)
Definition GameApi.hh:4863

GameApi::ArrayObj3d::render
void render()
Definition GameApi.hh:4806

GameApi::ArrayObj3d::set_child_pos
void set_child_pos(int i, float cpos_x, float cpos_y, float cpos_z)
Definition GameApi.hh:4821

GameApi::ArrayObj3d::set_scale
void set_scale(float mult_x, float mult_y, float mult_z)
Definition GameApi.hh:4899

GameApi::BitmapApi
Definition GameApi.hh:1082

GameApi::BitmapApi::world_from_bitmap
IMPORT BM world_from_bitmap(std::function< BM(int)> f, BM int_bm, int dx, int dy)
Definition GameApi_bm.cc:1839

GameApi::BitmapApi::plus_bitmap
IMPORT BM plus_bitmap(BM bm, BM bm2)
Definition GameApi_bm.cc:4753

GameApi::BitmapApi::isoline_render
IMPORT BB isoline_render(EveryApi &ev, FB bm, float start_range, float end_range, float delta_range, int num)
Definition GameApi_bm.cc:9858

GameApi::BitmapApi::txidarray_from_heavy
IMPORT ML txidarray_from_heavy(EveryApi &ev, H heavy, std::vector< TXID > *vec, ML ml, int start_range, int end_range, int heavycount)
Definition GameApi.cc:37679

GameApi::BitmapApi::loadbitmapfromurl
IMPORT BM loadbitmapfromurl(std::string url)
Definition GameApi_gltf.cc:2704

GameApi::BitmapApi::fix_edges
IMPORT BM fix_edges(BM bm)
Definition GameApi_bm.cc:4435

GameApi::BitmapApi::load_png_from_temp
IMPORT void load_png_from_temp(std::string filename, void(*fptr)(void *), void *data, bool &success)
Definition GameApi.cc:31951

GameApi::BitmapApi::interpolate_bitmap
IMPORT BM interpolate_bitmap(BM orig1, BM orig2, float x)
Definition GameApi_bm.cc:1556

GameApi::BitmapApi::flip_x
IMPORT BM flip_x(BM orig)
Definition GameApi_bm.cc:1767

GameApi::BitmapApi::repeat_bitmap
IMPORT BM repeat_bitmap(BM orig, int xcount, int ycount)
Definition GameApi_bm.cc:1795

GameApi::BitmapApi::save_png
IMPORT void save_png(BM bm, std::string filename)
Definition GameApi_bm.cc:4330

GameApi::BitmapApi::choose_color
IMPORT BB choose_color(BM bm, unsigned int c1, unsigned int c2)
Definition GameApi_bm.cc:5472

GameApi::BitmapApi::size_x
IMPORT int size_x(BM bm)
Definition GameApi_bm.cc:1481

GameApi::BitmapApi::bitmap_prepare_heavy
IMPORT H bitmap_prepare_heavy(EveryApi &ev, H bitmap_gen, int scanlines_per_slot)
Definition GameApi.cc:37421

GameApi::BitmapApi::flip_y
IMPORT BM flip_y(BM orig)
Definition GameApi_bm.cc:1776

GameApi::BitmapApi::scale_bitmap_fullscreen
IMPORT BM scale_bitmap_fullscreen(EveryApi &ev, BM orig)
Definition GameApi_bm.cc:167

GameApi::BitmapApi::radial_fb
IMPORT FB radial_fb(int sx, int sy, float x, float y, float r, float val_at_zero, float val_at_r)
Definition GameApi_bm.cc:4827

GameApi::BitmapApi::load_png_from_temp3
IMPORT void load_png_from_temp3(std::string filename)
Definition GameApi.cc:31964

GameApi::BitmapApi::persistent_cache
IMPORT BM persistent_cache(BM orig, std::string filename)
Definition GameApi_bm.cc:3779

GameApi::BitmapApi::range_choose
IMPORT BB range_choose(FB bm, float start_range, float end_range)
Definition GameApi_bm.cc:9578

GameApi::BitmapApi::create_ibm
IMPORT IBM create_ibm(std::vector< BB > vec)
Definition GameApi_bm.cc:5313

GameApi::BitmapApi::video_source
IMPORT TXID video_source(std::string filename, int sx, int sy)

GameApi::BitmapApi::vertical_bitmap_display
IMPORT ML vertical_bitmap_display(EveryApi &ev, std::vector< BM > vec, float y_delta)
Definition GameApi_bm.cc:9239

GameApi::BitmapApi::color_bm
IMPORT BM color_bm(BM bm, unsigned int color)
Definition GameApi_bm.cc:5400

GameApi::BitmapApi::space
IMPORT SP space(BM bm)

GameApi::BitmapApi::intbitmap_loader
IMPORT IBM intbitmap_loader(std::string url)
Definition GameApi_bm.cc:4674

GameApi::BitmapApi::convert_fb_to_ibm_bitmap
IMPORT IBM convert_fb_to_ibm_bitmap(FB fb, float start, float d)
Definition GameApi_bm.cc:4538

GameApi::BitmapApi::anim_array
IMPORT BM anim_array(BM *array, int size)
Definition GameApi_bm.cc:1637

GameApi::BitmapApi::Indicator
IMPORT BM Indicator(int sx, int sy, int g_ind)
Definition GameApi_bm.cc:4321

GameApi::BitmapApi::colorvalue
IMPORT unsigned int colorvalue(BM bm, int x, int y)
Definition GameApi_bm.cc:1540

GameApi::BitmapApi::network_heavy
IMPORT H network_heavy(std::string url, std::string homepageurl, H timing_heavy)
Definition GameApi.cc:37416

GameApi::BitmapApi::mul_fb
IMPORT FB mul_fb(FB f, float mul)
Definition GameApi_bm.cc:4910

GameApi::BitmapApi::scale_bitmap
IMPORT BM scale_bitmap(EveryApi &ev, BM orig, int sx, int sy)
Definition GameApi_bm.cc:160

GameApi::BitmapApi::array
IMPORT BMA array(BM *array, int size)
Definition GameApi_bm.cc:130

GameApi::BitmapApi::mandelbrot
IMPORT BM mandelbrot(bool julia, float start_x, float end_x, float start_y, float end_y, float xx, float yy, int sx, int sy, int count)
Definition GameApi_bm.cc:560

GameApi::BitmapApi::thread_heavy
IMPORT H thread_heavy(H threaded)
Definition GameApi.cc:37410

GameApi::BitmapApi::png_heavy2
IMPORT H png_heavy2(EveryApi &ev, H net, std::string url, int texture_unit, int sx, int sy)
Definition GameApi.cc:37394

GameApi::BitmapApi::scale_bitmap2
IMPORT CBM scale_bitmap2(BM bm)

GameApi::BitmapApi::intbitmap_bm
IMPORT BM intbitmap_bm(IBM ibm)
Definition GameApi_bm.cc:4708

GameApi::BitmapApi::sample_bitmap
IMPORT BM sample_bitmap(BM orig, float xmult, float ymult, float x, float y)

GameApi::BitmapApi::dyn_fetch_bitmap
IMPORT TXID dyn_fetch_bitmap(EveryApi &ev, std::string url, int time, int texture_unit)
Definition GameApi.cc:37706

GameApi::BitmapApi::ready_to_prepare
IMPORT bool ready_to_prepare(BM bm)
Definition GameApi_bm.cc:1450

GameApi::BitmapApi::median_filter
IMPORT BM median_filter(BM bm, int sx, int sy)
Definition GameApi_bm.cc:5550

GameApi::BitmapApi::flood_fill
IMPORT FB flood_fill(FB fb, float percentage, int x, int y, bool inv)
Definition GameApi_bm.cc:6950

GameApi::BitmapApi::gif_anim
IMPORT ML gif_anim(EveryApi &ev, ML ml3, int key, float time_delta, int num, std::string filename, int delay)
Definition GameApi_bm.cc:7153

GameApi::BitmapApi::newcolorbitmap
IMPORT BM newcolorbitmap(char *array, int sz, int sy, std::function< unsigned int(char)> f)
Definition GameApi_bm.cc:1619

GameApi::BitmapApi::avg
IMPORT BM avg(BM bm1, BM bm2)
Definition GameApi_bm.cc:4420

GameApi::BitmapApi::random_int_bitmap
IMPORT IBM random_int_bitmap(int sx, int sy, int min_value, int max_value)
Definition GameApi.cc:32225

GameApi::BitmapApi::plus_fb
IMPORT FB plus_fb(FB f1, FB f2)
Definition GameApi_bm.cc:4884

GameApi::BitmapApi::display_bitmaps
IMPORT ML display_bitmaps(EveryApi &ev, std::vector< BM > vec, float start_time, float delta_time)
Definition GameApi_bm.cc:9324

GameApi::BitmapApi::flood_fill_color
IMPORT BM flood_fill_color(EveryApi &ev, BM bm, float percentage, int x, int y, unsigned int color)
Definition GameApi_bm.cc:6957

GameApi::BitmapApi::alt
IMPORT BM alt(std::vector< BM > vec, int index)
Definition GameApi_bm.cc:3604

GameApi::BitmapApi::mandelbrot2
IMPORT BM mandelbrot2(bool julia, float start_x, float end_x, float start_y, float end_y, float xx, float yy, int sx, int sy, int count)
Definition GameApi_bm.cc:584

GameApi::BitmapApi::convert_ibm_to_vx
IMPORT VX convert_ibm_to_vx(IBM bm)
Definition GameApi_bm.cc:4573

GameApi::BitmapApi::newbitmap_bb
IMPORT BM newbitmap_bb(BB bb, unsigned int color)
Definition GameApi_bm.cc:413

GameApi::BitmapApi::write_gif_anim
IMPORT ML write_gif_anim(std::vector< BM > vec, std::string filename, int delay)
Definition GameApi_bm.cc:7137

GameApi::BitmapApi::alpha_color
IMPORT BM alpha_color(BM orig, unsigned int color_key)
Definition GameApi_bm.cc:190

GameApi::BitmapApi::cubemap
IMPORT ARR cubemap(BM bm)
Definition GameApi_bm.cc:5052

GameApi::BitmapApi::newtilebitmap
IMPORT BM newtilebitmap(int sx, int sy, int tile_sx, int tile_sy)
Definition GameApi_bm.cc:608

GameApi::BitmapApi::save_raw
IMPORT ML save_raw(BM bm, std::string filename)
Definition GameApi_bm.cc:6624

GameApi::BitmapApi::savebitmap
IMPORT void savebitmap(BM orig, std::string filename, bool alpha=false)
Definition GameApi_bm.cc:622

GameApi::BitmapApi::color_range
IMPORT BM color_range(BM orig, unsigned int source_upper, unsigned int source_lower, unsigned int target_upper, unsigned int target_lower)
Definition GameApi_bm.cc:228

GameApi::BitmapApi::memoize_all
IMPORT BM memoize_all(BM orig)
Definition GameApi_bm.cc:516

GameApi::BitmapApi::BitmapApi
IMPORT BitmapApi(Env &e)
Definition GameApi_bm.cc:27

GameApi::BitmapApi::timing_heavy
IMPORT H timing_heavy(int num_frames)
Definition GameApi.cc:37377

GameApi::BitmapApi::progressive_heavy
IMPORT H progressive_heavy(EveryApi &ev, std::string url, std::string url2)

GameApi::BitmapApi::sin_fb
IMPORT FB sin_fb(FB gradient)
Definition GameApi_bm.cc:4854

GameApi::BitmapApi::blitbitmap_fb
IMPORT BM blitbitmap_fb(BM bg, BM orig, int x, int y, FB mask)
Definition GameApi_bm.cc:1417

GameApi::BitmapApi::border
IMPORT BM border(BM, int left, int right, int top, int bottom)
Definition GameApi_bm.cc:3790

GameApi::BitmapApi::modify_bitmap
IMPORT BM modify_bitmap(BM orig, BM bm, int x, int y)
Definition GameApi_bm.cc:1400

GameApi::BitmapApi::transform
IMPORT BM transform(BM orig, std::function< unsigned int(int, int, unsigned int)> f)
Definition GameApi_bm.cc:480

GameApi::BitmapApi::compose_x
IMPORT BM compose_x(BM bm1, BM bm2)
Definition GameApi.cc:21042

GameApi::BitmapApi::stable_diffusion
IMPORT BM stable_diffusion(EveryApi &ev, std::string prompt, std::string filename)
Definition GameApi.cc:31167

GameApi::BitmapApi::load_png_from_temp2
IMPORT BM load_png_from_temp2(std::string filename)
Definition GameApi.cc:31955

GameApi::BitmapApi::array_heavy
IMPORT H array_heavy(std::vector< H > vec)
Definition GameApi.cc:37399

GameApi::BitmapApi::flip_tile_bitmap
IMPORT BM flip_tile_bitmap(BM bm, int sx, int sy, bool is_x)
Definition GameApi_bm.cc:7235

GameApi::BitmapApi::simple_blur
IMPORT BM simple_blur(BM bm, float center, float left, float right, float top, float bottom)
Definition GameApi_bm.cc:3865

GameApi::BitmapApi::gradient_y
IMPORT BM gradient_y(unsigned int color_1, unsigned int color_2, int sx, int sy)
Definition GameApi_bm.cc:322

GameApi::BitmapApi::rot90
IMPORT BM rot90(BM orig)
Definition GameApi_bm.cc:1786

GameApi::BitmapApi::add_shape_border
IMPORT BM add_shape_border(EveryApi &ev, BM bm, float dist_field_size, float start_range, float end_range, int r, int g, int b, int a, int border_size)
Definition GameApi_bm.cc:3804

GameApi::BitmapApi::growbitmap
IMPORT BM growbitmap(BM small_orig_bitmap, int l, int t, int r, int b)
Definition GameApi_bm.cc:1335

GameApi::BitmapApi::loadtilebitmap
IMPORT BM loadtilebitmap(std::string filename, int tile_sx, int tile_sy)
Definition GameApi_bm.cc:1136

GameApi::BitmapApi::blitbitmap
IMPORT BM blitbitmap(BM bg, BM orig, int x, int y)
Definition GameApi_bm.cc:1408

GameApi::BitmapApi::addsubrects
IMPORT BM addsubrects(BM orig)

GameApi::BitmapApi::bump_map
IMPORT BM bump_map(FB fb, float h)
Definition GameApi_bm.cc:5251

GameApi::BitmapApi::dup_x
IMPORT BM dup_x(BM orig)
Definition GameApi_bm.cc:1753

GameApi::BitmapApi::world_from_bitmap2
IMPORT BM world_from_bitmap2(EveryApi &ev, std::vector< BM > v, std::string filename, std::string chars, int dx, int dy, int sx, int sy)
Definition GameApi_bm.cc:1806

GameApi::BitmapApi::debug_number
IMPORT BM debug_number(EveryApi &ev, BM bm0, int num, bool disable, std::string url)
Definition GameApi_bm.cc:9397

GameApi::BitmapApi::radial_gradient
IMPORT BM radial_gradient(int sx, int sy, PT pos, float r1, float r2, unsigned int color_1, unsigned int color_2)
Definition GameApi_bm.cc:363

GameApi::BitmapApi::chessboard
IMPORT BM chessboard(int tile_sx, int tile_sy, int count_x, int count_y, unsigned int c1, unsigned int c2)
Definition GameApi_bm.cc:552

GameApi::BitmapApi::empty_array
IMPORT BMA empty_array()
Definition GameApi_bm.cc:91

GameApi::BitmapApi::mtl_heavy
IMPORT H mtl_heavy(EveryApi &ev, H net, std::string url_prefix, int texture_unit_delta)
Definition GameApi.cc:37372

GameApi::BitmapApi::blitbitmap_bb
IMPORT BM blitbitmap_bb(BM bg, BM orig, int x, int y, BB mask)
Definition GameApi_bm.cc:1428

GameApi::BitmapApi::loadposbitmap
IMPORT BM loadposbitmap(std::string filename)
Definition GameApi_bm.cc:1156

GameApi::BitmapApi::newintbitmap
IMPORT BM newintbitmap(char *array, int sx, int sy, std::function< int(char)> f)
Definition GameApi_bm.cc:1609

GameApi::BitmapApi::intvalue
IMPORT int intvalue(BM bm, int x, int y)
Definition GameApi_bm.cc:1439

GameApi::BitmapApi::lightmap_bitmap
IMPORT BM lightmap_bitmap(int sx, int sy, P faces, P faces2, int face, float light_dir_x, float light_dir_y, float light_dir_z)
Definition GameApi_pl.cc:25840

GameApi::BitmapApi::gradient
IMPORT BM gradient(PT pos_1, PT pos_2, unsigned int color_1, unsigned int color_2, int sx, int sy)
Definition GameApi_bm.cc:313

GameApi::BitmapApi::bitmap_heavy
IMPORT H bitmap_heavy(BM bm, H timing)
Definition GameApi.cc:37381

GameApi::BitmapApi::dyn_fetch_bitmap2
IMPORT TXID dyn_fetch_bitmap2(EveryApi &ev, std::string url, std::string url2, int time, int texture_unit, int sx, int sy, int sx2, int sy2)
Definition GameApi.cc:37686

GameApi::BitmapApi::savepng_array_ml
IMPORT ML savepng_array_ml(EveryApi &ev, std::vector< BM > bms, std::string filename_start, std::string filename_end, bool alpha, float time)
Definition GameApi_bm.cc:714

GameApi::BitmapApi::memoize
IMPORT BM memoize(BM orig)
Definition GameApi_bm.cc:509

GameApi::BitmapApi::circular_gradient
IMPORT BM circular_gradient(int sx, int sy, unsigned int center_color, unsigned int edge_color)
Definition GameApi_bm.cc:6784

GameApi::BitmapApi::savebitmap_ml
IMPORT ML savebitmap_ml(EveryApi &ev, BM bm, std::string filename, bool alpha, float time)
Definition GameApi_bm.cc:674

GameApi::BitmapApi::flood_fill_color_inv
IMPORT BM flood_fill_color_inv(EveryApi &ev, BM bm, float percentage, int x, int y, unsigned int color)
Definition GameApi_bm.cc:6966

GameApi::BitmapApi::scale_to_size
IMPORT BM scale_to_size(BM bm, int sz)
Definition GameApi_bm.cc:5807

GameApi::BitmapApi::save_png_ml
IMPORT ML save_png_ml(EveryApi &ev, BM bm, std::string filename)
Definition GameApi_bm.cc:4386

GameApi::BitmapApi::newbitmap_bm
IMPORT BM newbitmap_bm(BM bm, unsigned int color)
Definition GameApi_bm.cc:394

GameApi::BitmapApi::choose_ints
IMPORT ARR choose_ints(IBM bm, int count)
Definition GameApi_bm.cc:5355

GameApi::BitmapApi::world_from_bitmap3
IMPORT BM world_from_bitmap3(EveryApi &ev, std::vector< BM > v, std::string url, std::string chars, int dx, int dy)
Definition GameApi_bm.cc:1944

GameApi::BitmapApi::bm_cubemap
IMPORT BM bm_cubemap(EveryApi &ev, BM left, BM top, BM middle, BM right, BM back, BM down, int sx, int sy)
Definition GameApi_bm.cc:4973

GameApi::BitmapApi::bm_png_bm
IMPORT BM bm_png_bm(EveryApi &ev, BM bm, std::string url)
Definition GameApi.cc:31729

GameApi::BitmapApi::sphere_rays_bitmap
IMPORT BM sphere_rays_bitmap(float center_x, float center_y, float center_z, float radius, float delta_alfa, float delta_beta, FS field, int maxiter, float c, int fptr_enum, std::vector< PT > vec, int vec_choose)
Definition GameApi_ff.cc:136

GameApi::BitmapApi::newbitmap_fb
IMPORT BM newbitmap_fb(FB fb, unsigned int color)
Definition GameApi_bm.cc:404

GameApi::BitmapApi::~BitmapApi
IMPORT ~BitmapApi()
Definition GameApi_bm.cc:31

GameApi::BitmapApi::png_heavy
IMPORT H png_heavy(EveryApi &ev, H data, std::string url, int texture_unit)
Definition GameApi.cc:37389

GameApi::BitmapApi::loadbitmap
IMPORT BM loadbitmap(std::string filename)
Definition GameApi_bm.cc:1088

GameApi::BitmapApi::calculate_baked_light
IMPORT BM calculate_baked_light(P p, P p2, BM texture, int count, float light_pos_x, float light_pos_y, float light_pos_z, float shadow_darkness, float softness)
Definition GameApi_bm.cc:5752

GameApi::BitmapApi::newbitmap
IMPORT BM newbitmap(int sx, int sy, unsigned int color=0x00000000)
Definition GameApi_bm.cc:423

GameApi::BitmapApi::size_y
IMPORT int size_y(BM bm)
Definition GameApi_bm.cc:1509

GameApi::BitmapApi::subbitmapimage
IMPORT BM subbitmapimage(BM orig, int r_start_range, int r_end_range, int g_start_range, int g_end_range, int b_start_range, int b_end_range, unsigned int empty_color)

GameApi::BitmapApi::dyn_fetch_mtl
IMPORT std::vector< TXID > dyn_fetch_mtl(EveryApi &ev, std::string mtl_url, ML ml2)
Definition GameApi.cc:37716

GameApi::BitmapApi::chai_bm
IMPORT BM chai_bm(std::string url, int sx, int sy)

GameApi::BitmapApi::noise_vectors
IMPORT BM noise_vectors(int sx, int sy)
Definition GameApi_bm.cc:5159

GameApi::BitmapApi::compose_y
IMPORT BM compose_y(BM bm1, BM bm2)
Definition GameApi.cc:21055

GameApi::BitmapApi::subbitmap
IMPORT BM subbitmap(BM orig, int x, int y, int width, int height)
Definition GameApi_bm.cc:1252

GameApi::BitmapApi::script_bitmap
IMPORT BM script_bitmap(std::string url, int sx, int sy)
Definition GameApi_bm.cc:6518

GameApi::BitmapApi::findtile
IMPORT BM findtile(BM tile_bitmap, int x, int y)
Definition GameApi_bm.cc:1171

GameApi::BitmapApi::isoline_render2
IMPORT ML isoline_render2(EveryApi &ev, FB fb, float pos, float delta_pos, int num)
Definition GameApi_bm.cc:9870

GameApi::BitmapApi::choose_neg_zero_positive
IMPORT ARR choose_neg_zero_positive(EveryApi &ev, FB fb, float pos)
Definition GameApi_bm.cc:9671

GameApi::BitmapApi::grid_ml
IMPORT ML grid_ml(EveryApi &ev, ML next, IBM map, float y, float pos_x, float pos_z, float x_vec_x, float x_vec_z, float z_vec_x, float z_vec_z, int start_x, int start_z, float frame_inc)
Definition GameApi_bm.cc:5984

GameApi::BitmapApi::prepare
IMPORT void prepare(BM bm)
Definition GameApi_bm.cc:3723

GameApi::BitmapApi::p_world_from_bitmap
IMPORT P p_world_from_bitmap(EveryApi &ev, std::vector< P > vec, IBM world, float pos_x, float pos_y, float pos_z, float dx, float dz, float y)
Definition GameApi_bm.cc:6122

GameApi::BitmapApi::render_volume_object
IMPORT BM render_volume_object(O o, float start_x, float end_x, float start_y, float end_y, float z, int sx, int sy, float ray_length, int sample_count)
Definition GameApi_bm.cc:9846

GameApi::BitmapApi::gradient_fb
IMPORT FB gradient_fb(int sx, int sy, float val, float val2, bool flip)
Definition GameApi_bm.cc:4790

GameApi::BitmapApi::choose_bool
IMPORT BB choose_bool(IBM bm, int val)
Definition GameApi_bm.cc:5349

GameApi::BitmapApi::txid_from_heavy
IMPORT TXID txid_from_heavy(H heavy)
Definition GameApi.cc:37544

GameApi::BitmapApi::write_gif_anim2
IMPORT ML write_gif_anim2(Array< int, int > *vec, std::string filename, int delay)
Definition GameApi_bm.cc:7148

GameApi::BitmapApi::gray_to_black
IMPORT BM gray_to_black(BM bm, float val)
Definition GameApi_bm.cc:7002

GameApi::BitmapApi::conical_gradient
IMPORT BM conical_gradient(int sx, int sy, float x, float y, float angle1, float angle2, unsigned int color_1, unsigned int color_2)
Definition GameApi_bm.cc:2521

GameApi::BitmapApi::array_elem
IMPORT BM array_elem(BMA array, int i)
Definition GameApi_bm.cc:180

GameApi::BlockerApi
Definition GameApi.hh:422

GameApi::BlockerApi::run2
IMPORT void run2(EveryApi &ev, RUN spl)
Definition GameApi.cc:19541

GameApi::BlockerApi::vr_submit_ml
IMPORT ML vr_submit_ml(EveryApi &ev, ML ml, TXID left, TXID right, bool invert, bool translate)
Definition GameApi_vr.cc:388

GameApi::BlockerApi::run
IMPORT void run(BLK blk)
Definition GameApi.cc:19362

GameApi::BlockerApi::game_seq
IMPORT BLK game_seq(EveryApi &ev, std::vector< BLK > vec)
Definition GameApi.cc:19347

GameApi::BlockerApi::game_window
IMPORT BLK game_window(EveryApi &ev, ML ml, bool logo, bool fpscounter, float start_time, float duration)
Definition GameApi.cc:19247

GameApi::BlockerApi::game_window2
IMPORT RUN game_window2(EveryApi &ev, ML ml, bool logo, bool fpscounter, float start_time, float duration)
Definition GameApi.cc:19260

GameApi::BlockerApi::run_seq
IMPORT RUN run_seq(EveryApi &ev, std::vector< RUN > vec)
Definition GameApi.cc:19311

GameApi::BlockerApi::vr_window
IMPORT RUN vr_window(EveryApi &ev, ML ml, bool logo, bool fpscounter, float start_time, float dura, bool invert, bool translate)
Definition GameApi_vr.cc:62

GameApi::BlockerApi::webgpu_window
IMPORT RUN webgpu_window(EveryApi &ev, GML ml)
Definition webgpu.cc:140

GameApi::BlockerApi::BlockerApi
IMPORT BlockerApi(Env &e)
Definition GameApi.cc:44480

GameApi::BlockerApi::game_window_2nd_display
IMPORT RUN game_window_2nd_display(EveryApi &ev, ML ml, bool logo, bool fpscounter, float start_time, float duration)
Definition GameApi.cc:38723

GameApi::BlockerApi::vr_submit
IMPORT ML vr_submit(EveryApi &ev, TXID left, TXID right)
Definition GameApi_vr.cc:400

GameApi::BoolBitmapApi
Definition GameApi.hh:3717

GameApi::BoolBitmapApi::BoolBitmapApi
IMPORT BoolBitmapApi(Env &e)
Definition GameApi_bm.cc:2687

GameApi::BoolBitmapApi::xor_bitmap
IMPORT BB xor_bitmap(BB b1, BB flip_b2)
Definition GameApi_bm.cc:2664

GameApi::BoolBitmapApi::tri
IMPORT BB tri(BB orig, float p1_x, float p1_y, float p2_x, float p2_y, float p3_x, float p3_y)
Definition GameApi_bm.cc:2262

GameApi::BoolBitmapApi::from_bitmaps_color_area
IMPORT BB from_bitmaps_color_area(BM bm, std::function< bool(int r, int g, int b, int a)> f)

GameApi::BoolBitmapApi::bb_empty
IMPORT BB bb_empty(int sx, int sy)
Definition GameApi_bm.cc:2303

GameApi::BoolBitmapApi::sprite
IMPORT BB sprite(BB bg, BB sprite, float x, float y, float size_multiplier_x, float size_multiplier_y)
Definition GameApi_bm.cc:2646

GameApi::BoolBitmapApi::to_volume
IMPORT O to_volume(BB b, float dist)
Definition GameApi_bm.cc:1965

GameApi::BoolBitmapApi::polygon
IMPORT BB polygon(BB bg, PT *points, int size)
Definition GameApi_bm.cc:3312

GameApi::BoolBitmapApi::to_bitmap
IMPORT BM to_bitmap(BB bools, int true_r, int true_g, int true_b, int true_a, int false_r, int false_g, int false_b, int false_a)
Definition GameApi_bm.cc:2676

GameApi::BoolBitmapApi::or_bitmap
IMPORT BB or_bitmap(BB b1, BB b2)
Definition GameApi_bm.cc:2658

GameApi::BoolBitmapApi::not_bitmap
IMPORT BB not_bitmap(BB b)
Definition GameApi_bm.cc:2652

GameApi::BoolBitmapApi::black_white_dithering
IMPORT BB black_white_dithering(FB fb)
Definition GameApi_bm.cc:3923

GameApi::BoolBitmapApi::to_bitmap_1
BM to_bitmap_1(BB bools, int true_r, int true_g, int true_b, int true_a, int false_r, int false_g, int false_b, int false_a)
Definition GameApi_bm.cc:2681

GameApi::BoolBitmapApi::size_y
IMPORT int size_y(BB bm)
Definition GameApi_bm.cc:2510

GameApi::BoolBitmapApi::ellipse
IMPORT BB ellipse(BB bg, float center_x, float center_y, float center2_x, float center2_y, float sum_of_distances)
Definition GameApi_bm.cc:2467

GameApi::BoolBitmapApi::transform
IMPORT BB transform(BB orig, std::function< bool(int, int, bool)> f)
Definition GameApi_bm.cc:2290

GameApi::BoolBitmapApi::choose_bitmap
IMPORT BM choose_bitmap(BB bools, BM true_bitmap, BM false_bitmap)
Definition GameApi_bm.cc:2217

GameApi::BoolBitmapApi::rectangle
IMPORT BB rectangle(BB bg, float x, float y, float width, float height)
Definition GameApi_bm.cc:2589

GameApi::BoolBitmapApi::from_bitmaps_color
IMPORT BB from_bitmaps_color(BM bm, int r, int g, int b)
Definition GameApi_bm.cc:2312

GameApi::BoolBitmapApi::size_x
IMPORT int size_x(BB bm)
Definition GameApi_bm.cc:2505

GameApi::BoolBitmapApi::from_float_bitmap
IMPORT BB from_float_bitmap(FB float_bm, float range_start, float range_end)
Definition GameApi_bm.cc:2345

GameApi::BoolBitmapApi::text
IMPORT BB text(BB bg, int x, int y, const char *string, int size, BB *glyphs, int glyphcount, int(*fptr)(EveryApi &ev, char))

GameApi::BoolBitmapApi::~BoolBitmapApi
IMPORT ~BoolBitmapApi()
Definition GameApi_bm.cc:2688

GameApi::BoolBitmapApi::sections
IMPORT BB sections(int sx, int sy, float x, float y, std::function< bool(float angle)> f)
Definition GameApi_bm.cc:2530

GameApi::BoolBitmapApi::line
IMPORT BB line(BB bg, float p_x, float p_y, float p2_x, float p2_y, float line_width1, float line_width2)
Definition GameApi_bm.cc:2460

GameApi::BoolBitmapApi::part_circle
IMPORT BB part_circle(int sx, int sy, float x, float y, float start_angle, float end_angle, float start_rad, float end_rad)
Definition GameApi_bm.cc:2538

GameApi::BoolBitmapApi::circle
IMPORT BB circle(BB bg, float center_x, float center_y, float radius)
Definition GameApi_bm.cc:2478

GameApi::BoolBitmapApi::andnot_bitmap
IMPORT BB andnot_bitmap(BB b1, BB not_b2)
Definition GameApi_bm.cc:2670

GameApi::BoolBitmapApi::rings
IMPORT BB rings(int sx, int sy, float center_x_start, float center_y_start, float center_x_end, float center_y_end, float start_radius, float end_radius, float start_thickness, float end_thickness, int numrings)
Definition GameApi_bm.cc:2270

GameApi::BoolBitmapApi::boolvalue
IMPORT bool boolvalue(BB bb, int x, int y)
Definition GameApi_bm.cc:2515

GameApi::BoolBitmapApi::texture
IMPORT BM texture(BM bg, BB bools1, int l1, int t1, BM texturebitmap2, int l2, int t2)

GameApi::BooleanOps
Definition GameApi.hh:2771

GameApi::BooleanOps::cube_bo
IMPORT BO cube_bo(EveryApi &ev, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, int split_x, int split_y)
Definition GameApi.cc:984

GameApi::BooleanOps::or_elem_bo
IMPORT BO or_elem_bo(EveryApi &ev, BO obj, BO obj2)
Definition GameApi.cc:1009

GameApi::BooleanOps::sphere_bo
IMPORT BO sphere_bo(EveryApi &ev, PT center, float radius, int numfaces1, int numfaces2)
Definition GameApi.cc:1000

GameApi::BooleanOps::to_polygon
IMPORT P to_polygon(BO obj)
Definition GameApi.cc:1056

GameApi::BooleanOps::to_volume
IMPORT O to_volume(BO obj)
Definition GameApi.cc:1062

GameApi::BooleanOps::BooleanOps
IMPORT BooleanOps(Env &e)
Definition GameApi.cc:44508

GameApi::BooleanOps::to_dist
IMPORT FD to_dist(BO obj)
Definition GameApi.cc:1068

GameApi::BooleanOps::intersect_bo
IMPORT BO intersect_bo(EveryApi &ev, BO obj, BO obj2)
Definition GameApi.cc:1038

GameApi::BooleanOps::create_bo
IMPORT BO create_bo(P mesh, O bools, FD fd)
Definition GameApi.cc:970

GameApi::BooleanOps::and_not_bo
IMPORT BO and_not_bo(EveryApi &ev, BO obj, BO not_obj)
Definition GameApi.cc:1021

GameApi::CollisionPlane
Definition GameApi.hh:2038

GameApi::CollisionPlane::check_collision
IMPORT bool check_collision(CP plane, float x, float y)
Definition GameApi.cc:1183

GameApi::CollisionPlane::set_pos
IMPORT void set_pos(CP plane, int id, float x, float y)
Definition GameApi.cc:1178

GameApi::CollisionPlane::CollisionPlane
IMPORT CollisionPlane(Env &e)
Definition GameApi.cc:44494

GameApi::CollisionPlane::or_elem
IMPORT CP or_elem(int id, std::vector< CP > vec)
Definition GameApi.cc:1164

GameApi::CollisionPlane::rectangle
IMPORT CP rectangle(int id, float x, float y, float sx, float sy)
Definition GameApi.cc:1148

GameApi::CollisionPlane::circle
IMPORT CP circle(int id, float radius)
Definition GameApi.cc:1156

GameApi::ColorApi
Definition GameApi.hh:3928

GameApi::ColorApi::u_color
IMPORT CO u_color(unsigned int color)
Definition GameApi_co.cc:6

GameApi::ColorApi::ColorApi
IMPORT ColorApi(Env &e)
Definition GameApi_co.cc:4

GameApi::ColorApi::rgbf_color
IMPORT CO rgbf_color(float r, float g, float b, float a)
Definition GameApi_co.cc:18

GameApi::ColorApi::rgb_color
IMPORT CO rgb_color(int r, int g, int b, int a)
Definition GameApi_co.cc:14

GameApi::ColorVolumeApi
Definition GameApi.hh:2574

GameApi::ColorVolumeApi::array_bm
IMPORT BM array_bm(COV colours, int sx, int sy, float ssx, float ssy, float z)
Definition GameApi_vo.cc:994

GameApi::ColorVolumeApi::phong
IMPORT COV phong(VO normal, PT light_pos, CO i_s, CO i_d, CO i_a, float k_s, float k_d, float k_a, float alfa)
Definition GameApi_vo.cc:1167

GameApi::ColorVolumeApi::from_float_volume
IMPORT COV from_float_volume(FO obj, unsigned int col0, unsigned int col1)
Definition GameApi_vo.cc:877

GameApi::ColorVolumeApi::texture_bm
IMPORT BM texture_bm(P obj, COV colors, int face, int sx, int sy)
Definition GameApi_vo.cc:957

GameApi::ColorVolumeApi::texture
IMPORT P texture(P obj, COV colors)

GameApi::ColorVolumeApi::directcolor
IMPORT COV directcolor(VO normal)
Definition GameApi_vo.cc:1176

GameApi::ColorVolumeApi::from_continuous_bitmap
IMPORT COV from_continuous_bitmap(CBM bm)
Definition GameApi_vo.cc:895

GameApi::ColorVolumeApi::mix
IMPORT COV mix(COV p1, COV p2, float value)
Definition GameApi_vo.cc:1160

GameApi::ColorVolumeApi::from_volume
IMPORT COV from_volume(O obj, unsigned int col_true, unsigned int col_false)
Definition GameApi_vo.cc:1005

GameApi::ColorVolumeApi::or_cov
IMPORT COV or_cov(COV p1, COV p2)

GameApi::ColorVolumeApi::ColorVolumeApi
IMPORT ColorVolumeApi(Env &e)
Definition GameApi.cc:44502

GameApi::ContinuousBitmapApi
Definition GameApi.hh:3851

GameApi::ContinuousBitmapApi::surfacecolor
IMPORT CBM surfacecolor(S s, COV cov)
Definition GameApi_bm.cc:3587

GameApi::ContinuousBitmapApi::from_bitmap
IMPORT CBM from_bitmap(BM bm, float xsize, float ysize)
Definition GameApi_bm.cc:3597

GameApi::ContinuousBitmapApi::bicubic
IMPORT CBM bicubic(float f_0, float f_1, float df_0, float df_1, float ff_0, float ff_1, float dff_0, float dff_1)
Definition GameApi_bm.cc:3493

GameApi::ContinuousBitmapApi::constant
CBM constant(unsigned int color, float x, float y)
Definition GameApi_bm.cc:3396

GameApi::ContinuousBitmapApi::sample
IMPORT BM sample(CBM c_bitmap, int sx, int sy)
Definition GameApi_bm.cc:3541

GameApi::ContinuousBitmapApi::rotate
IMPORT CBM rotate(CBM bm, float center_x, float center_y, float angle)
Definition GameApi_bm.cc:3548

GameApi::ContinuousBitmapApi::to_bitmap
IMPORT BM to_bitmap(CBM bm, int sx, int sy)
Definition GameApi_bm.cc:3556

GameApi::ContinuousBitmapApi::get_pixel
IMPORT unsigned int get_pixel(CBM bitmap, float x, float y)
Definition GameApi_bm.cc:3524

GameApi::ContinuousBitmapApi::distance_render
CBM distance_render(FD obj, COV colours, float sx, float sy)
Definition GameApi_bm.cc:3386

GameApi::ContinuousBitmapApi::ContinuousBitmapApi
IMPORT ContinuousBitmapApi(Env &e)
Definition GameApi_bm.cc:3346

GameApi::ContinuousBitmapApi::cbm_empty
IMPORT CBM cbm_empty(float x, float y)
Definition GameApi_bm.cc:3348

GameApi::CurveApi
Definition GameApi.hh:1481

GameApi::CurveApi::sample
IMPORT PTS sample(C input_curve, int num_samples)
Definition GameApi.cc:16350

GameApi::CurveApi::lines_from_curve_group
IMPORT LI lines_from_curve_group(CG curvegroup, int split)
Definition GameApi.cc:33250

GameApi::CurveApi::compose
IMPORT C compose(std::vector< C > vec)
Definition GameApi.cc:16266

GameApi::CurveApi::bezier
IMPORT C bezier(std::vector< PT > vec)
Definition GameApi.cc:16204

GameApi::CurveApi::linear
IMPORT C linear(std::vector< PT > vec)
Definition GameApi.cc:16180

GameApi::CurveApi::patch_sample
IMPORT P patch_sample(PA patch, int sx, int sy)
Definition GameApi.cc:16483

GameApi::CurveApi::change_length
IMPORT C change_length(C curve, float new_length)
Definition GameApi.cc:16294

GameApi::CurveApi::curve_product
IMPORT PA curve_product(C c1, C c2, PT c2_center)
Definition GameApi.cc:16403

GameApi::CurveApi::trans
IMPORT C trans(C curve, float dx, float dy, float dz)
Definition GameApi.cc:16237

GameApi::CurveApi::to_lines
IMPORT LI to_lines(C curve, int num_lines)
Definition GameApi.cc:16375

GameApi::CurveApi::x_curve
IMPORT C x_curve(PA patch, float y)
Definition GameApi.cc:16517

GameApi::CurveApi::line
IMPORT C line(PT p1, PT p2)
Definition GameApi.cc:16135

GameApi::CurveApi::split
IMPORT C split(C orig_curve, float start_var, float end_var)
Definition GameApi.cc:16314

GameApi::CurveApi::curve_group_from_lines
IMPORT CG curve_group_from_lines(LI li)
Definition GameApi.cc:33095

GameApi::CurveApi::xy_sum
IMPORT CPP xy_sum()
Definition GameApi.cc:16117

GameApi::CurveApi::circle_xy_wave
IMPORT C circle_xy_wave(float start_r, float end_r, WV wave, float length)
Definition GameApi.cc:16165

GameApi::CurveApi::scale
IMPORT C scale(C curve, float mx, float my, float mz)
Definition GameApi.cc:16231

GameApi::CurveApi::circle_xy
IMPORT C circle_xy(PT center, float r)
Definition GameApi.cc:16170

GameApi::CurveApi::y_curve
IMPORT C y_curve(PA patch, float x)
Definition GameApi.cc:16522

GameApi::CurveApi::circle_xz
IMPORT C circle_xz(PT center, float r)
Definition GameApi.cc:16175

GameApi::CurveApi::pos
IMPORT PT pos(C curve, float p)
Definition GameApi.cc:16320

GameApi::CurveApi::xy_sum2
IMPORT CPP xy_sum2(float xmult, float ymult, float zmult)
Definition GameApi.cc:16130

GameApi::CurveApi::CurveApi
IMPORT CurveApi(Env &e)
Definition GameApi.cc:44484

GameApi::CurvesApi::start
CC start(PTS points)

GameApi::CurvesApi::comb
CC comb(CC prev, PTS points)

GameApi::CurvesApi::extract
PTS extract(CC curves, int block, float val)

GameApi::CurvesApi::CurvesApi
IMPORT CurvesApi(Env &e)
Definition GameApi.cc:44486

GameApi::CutterApi
Definition GameApi.hh:2754

GameApi::CutterApi::distance_cut
IMPORT CT distance_cut(FD dist)
Definition GameApi_cut.cc:89

GameApi::CutterApi::CutterApi
IMPORT CutterApi(Env &e)
Definition GameApi.cc:44507

GameApi::CutterApi::function
IMPORT CT function(std::function< PT(PT, PT)> f)

GameApi::CutterApi::cutter_volume
IMPORT O cutter_volume(CT c, PT point_from_inside, float outside_dist)
Definition GameApi_cut.cc:116

GameApi::CutterApi::plane_cut
IMPORT CT plane_cut(PT pos, V u_x, V u_y)
Definition GameApi_cut.cc:24

GameApi::DistanceFloatVolumeApi
Definition GameApi.hh:2616

GameApi::DistanceFloatVolumeApi::fd_triangle
IMPORT FD fd_triangle(PT a, PT b, PT c)

GameApi::DistanceFloatVolumeApi::ray_shape_intersect
IMPORT PT ray_shape_intersect(FD shape, PT pos, V vec)
Definition GameApi_vo.cc:1849

GameApi::DistanceFloatVolumeApi::render2
IMPORT BM render2(EveryApi &ev, FD obj, int sx, int sy)
Definition GameApi_vo.cc:1866

GameApi::DistanceFloatVolumeApi::fd_max
IMPORT FD fd_max(FD a1, FD a2)
Definition GameApi_vo.cc:1795

GameApi::DistanceFloatVolumeApi::fd_line
IMPORT FD fd_line(PT start, PT end, float dist)
Definition GameApi_vo.cc:1492

GameApi::DistanceFloatVolumeApi::ambient_occulsion
IMPORT FD ambient_occulsion(FD fd, float d, float i)
Definition GameApi_vo.cc:1722

GameApi::DistanceFloatVolumeApi::fd_torus
IMPORT FD fd_torus(float radius_1, float radius_2)
Definition GameApi_vo.cc:1769

GameApi::DistanceFloatVolumeApi::shader_func
IMPORT std::string shader_func(std::string name, FD obj, COV color)

GameApi::DistanceFloatVolumeApi::fd_rot_x
IMPORT FD fd_rot_x(FD fd, float angle)
Definition GameApi_vo.cc:1754

GameApi::DistanceFloatVolumeApi::fd_quad
IMPORT FD fd_quad(PT a, PT b, PT c, PT d)

GameApi::DistanceFloatVolumeApi::fd_blend
IMPORT FD fd_blend(FD a1, FD a2, float k)
Definition GameApi_vo.cc:1963

GameApi::DistanceFloatVolumeApi::fd_and_not
IMPORT FD fd_and_not(FD a1, FD a2)
Definition GameApi_vo.cc:1803

GameApi::DistanceFloatVolumeApi::fd_cone
IMPORT FD fd_cone(float c_x, float c_y)

GameApi::DistanceFloatVolumeApi::distance_poly_cyl
IMPORT P distance_poly_cyl(EveryApi &ev, FD fd, float pos_x, float pos_y, float pos_z, float dx, float dy, float dz, int sx, int sy, float ssx, float ssy, int ssxi, int ssyi, float ssx2, float ssy2)
Definition GameApi_vo.cc:1998

GameApi::DistanceFloatVolumeApi::fd_round_cube
IMPORT FD fd_round_cube(float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, float r)
Definition GameApi_vo.cc:1773

GameApi::DistanceFloatVolumeApi::fd_rot_z
IMPORT FD fd_rot_z(FD fd, float angle)
Definition GameApi_vo.cc:1764

GameApi::DistanceFloatVolumeApi::fd_trans
IMPORT FD fd_trans(FD fd, float dx, float dy, float dz)
Definition GameApi_vo.cc:1906

GameApi::DistanceFloatVolumeApi::fd_hex_prism
IMPORT FD fd_hex_prism(float h_x, float h_y)

GameApi::DistanceFloatVolumeApi::fd_min
IMPORT FD fd_min(FD a1, FD a2)
Definition GameApi_vo.cc:1784

GameApi::DistanceFloatVolumeApi::fd_rot_y
IMPORT FD fd_rot_y(FD fd, float angle)
Definition GameApi_vo.cc:1759

GameApi::DistanceFloatVolumeApi::fd_cube
IMPORT FD fd_cube(float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)
Definition GameApi_vo.cc:1488

GameApi::DistanceFloatVolumeApi::distance_poly
IMPORT P distance_poly(EveryApi &ev, FD fd, float dx, float dy, float dz, int sx, int sy, float ssx, float ssy, int ssxi, int ssyi, float ssx2, float ssy2)
Definition GameApi_vo.cc:1969

GameApi::DistanceFloatVolumeApi::distance_poly_sph
IMPORT P distance_poly_sph(EveryApi &ev, FD fd, float dx, float dy, float dz, int sx, int sy, float ssx, float ssy, int ssxi, int ssyi, float ssx2, float ssy2)
Definition GameApi_vo.cc:2028

GameApi::DistanceFloatVolumeApi::fd_plane
IMPORT FD fd_plane(float n_x, float n_y, float n_z, float n_w)

GameApi::DistanceFloatVolumeApi::recalculate_normals
IMPORT FD recalculate_normals(FD fd)
Definition GameApi_vo.cc:1717

GameApi::DistanceFloatVolumeApi::fd_sphere
IMPORT FD fd_sphere(PT center, float radius)
Definition GameApi_vo.cc:1452

GameApi::DistanceFloatVolumeApi::fd_tri_prism
IMPORT FD fd_tri_prism(float h_x, float h_y)

GameApi::DistanceFloatVolumeApi::fd_color
IMPORT FD fd_color(FD fd, float r, float g, float b, float a)
Definition GameApi_vo.cc:1727

GameApi::DistanceFloatVolumeApi::DistanceFloatVolumeApi
IMPORT DistanceFloatVolumeApi(Env &e)
Definition GameApi.cc:44504

GameApi::DistanceFloatVolumeApi::function
IMPORT FD function(std::function< float(float x, float y, float z)> f)

GameApi::DrawApi::is_alternative_array
bool is_alternative_array(DR d)

GameApi::DrawApi::array_count
int array_count(DR d)

GameApi::DrawApi::alternative_array_count
int alternative_array_count(DR d)

GameApi::DrawApi::choose_alternative
DR choose_alternative(DR dr, std::string id, int val)

GameApi::DrawApi::scroll
DR scroll(DR dr, int delta_x, int delta_y)

GameApi::DrawApi::is_specific_alternative
bool is_specific_alternative(DR d, std::string id)

GameApi::DrawApi::alternative_array_index
DR alternative_array_index(DR d, int index)

GameApi::DrawApi::generate_java_code
std::string generate_java_code(DR dr)

GameApi::DrawApi::DrawApi
IMPORT DrawApi(Env &e)
Definition GameApi.cc:44526

GameApi::DrawApi::is_array
bool is_array(DR d)

GameApi::DrawApi::icon
DR icon(LAY l, int id, BM bm)

GameApi::DrawApi::alternatives_array
DR alternatives_array(std::string id, DR *array, int size)

GameApi::DrawApi::render_to_bm
BM render_to_bm(DR dr)

GameApi::DrawApi::array_index
DR array_index(DR d, int index)

GameApi::DrawApi::is_primitive
bool is_primitive(DR d)

GameApi::DrawApi::rect
DR rect(LAY l, int id, unsigned int color)

GameApi::DrawApi::render_to_html_canvas
std::string render_to_html_canvas(DR dr)

GameApi::DrawApi::scroll_area
DR scroll_area(DR dr, LAY l, int id)

GameApi::DrawApi::array
DR array(DR *array, int size)

GameApi::DrawApi::label
DR label(LAY l, int id, std::string str, Ft font)

GameApi::DrawApi::cliprect
DR cliprect(DR cmds, LAY l, int id)

GameApi::DrawApi::deep_copy
DR deep_copy(DR d)

GameApi::DupApi::dup_is
IS dup_is(IS i)

GameApi::DupApi::DupApi
IMPORT DupApi(Env &e)

GameApi::DupApi::dup_rm
RM dup_rm(RM r)

GameApi::DupApi::dup_ln
LN dup_ln(LN l)

GameApi::DupApi::dup_pt
PT dup_pt(PT p)

GameApi::DupApi::~DupApi
~DupApi()

GameApi::DupApi::dup_bm
BM dup_bm(BM b)

GameApi::DupApi::dup_sp
SP dup_sp(SP s)

GameApi::EditNode
Definition GraphI.hh:2078

GameApi::Env
Definition GameApi.hh:362

GameApi::Env::async_load_url
IMPORT void async_load_url(std::string url, std::string homepage, bool nosize=false)
Definition GameApi_dep_env.cc:2402

GameApi::Env::async_load_all_urls
IMPORT void async_load_all_urls(std::vector< std::string > urls, std::string homepage)
Definition GameApi_dep_env.cc:2410

GameApi::Env::store_counts
IMPORT std::vector< int > store_counts()
Definition GameApi_dep_env.cc:2262

GameApi::Env::store_file_exists
IMPORT bool store_file_exists(std::string filename)
Definition GameApi_dep_store.cc:11

GameApi::Env::set_download_ready
IMPORT void set_download_ready(int i)
Definition GameApi_dep_env.cc:2303

GameApi::Env::download_index_mapping
IMPORT int download_index_mapping(int index)
Definition GameApi_dep_env.cc:2283

GameApi::Env::EnvImpl
friend struct EnvImpl
Definition GameApi.hh:408

GameApi::Env::envimpl
void * envimpl
Definition GameApi.hh:407

GameApi::Env::free_temp_memory
IMPORT void free_temp_memory()
Definition GameApi_dep_env.cc:2272

GameApi::Env::free_to_counts
IMPORT void free_to_counts(std::vector< int > vec)
Definition GameApi_dep_env.cc:2267

GameApi::Env::Latest_Env
static IMPORT Env * Latest_Env()
Definition GameApi_dep_env.cc:2241

GameApi::Env::async_scheduler
IMPORT void async_scheduler()
Definition GameApi_dep_env.cc:2345

GameApi::Env::async_rem_callback
IMPORT void async_rem_callback(std::string url)
Definition GameApi_dep_env.cc:2434

GameApi::Env::load_file_result
IMPORT ASyncVec * load_file_result(std::string filename)
Definition GameApi_dep_store.cc:223

GameApi::Env::set_download_progress
IMPORT void set_download_progress(int i, float percentage)
Definition GameApi_dep_env.cc:2298

GameApi::Env::get_download_bar_progress
IMPORT float get_download_bar_progress(int i) const
Definition GameApi_dep_env.cc:2313

GameApi::Env::get_download_bar_ready
IMPORT bool get_download_bar_ready(int i) const
Definition GameApi_dep_env.cc:2318

GameApi::Env::Env
IMPORT Env()
Definition GameApi_dep_env.cc:2245

GameApi::Env::add_to_download_bar
IMPORT int add_to_download_bar(std::string filename)
Definition GameApi_dep_env.cc:2278

GameApi::Env::remove_download_bar_item
IMPORT void remove_download_bar_item(int i)
Definition GameApi_dep_env.cc:2323

GameApi::Env::async_load_callback
IMPORT void async_load_callback(std::string url, void(*fptr)(void *), void *data)
Definition GameApi_dep_env.cc:2418

GameApi::Env::get_loaded_async_url
IMPORT ASyncVec * get_loaded_async_url(std::string url)
Definition GameApi_dep_env.cc:2440

GameApi::Env::count_async_callbacks_still_pending
IMPORT int count_async_callbacks_still_pending()
Definition GameApi_dep_env.cc:2424

GameApi::Env::~Env
IMPORT ~Env()
Definition GameApi_dep_env.cc:2447

GameApi::Env::async_mapping
IMPORT int async_mapping(int index)
Definition GameApi_dep_env.cc:2334

GameApi::Env::load_file_clean
IMPORT void load_file_clean(std::string filename)
Definition GameApi_dep_store.cc:236

GameApi::Env::remove_async
IMPORT void remove_async(int i)
Definition GameApi_dep_env.cc:2340

GameApi::Env::load_file
IMPORT void load_file(std::string filename, void(*fptr)(void *), void *, bool &success)
Definition GameApi_dep_store.cc:147

GameApi::Env::print_callbacks_pending
IMPORT void print_callbacks_pending()
Definition GameApi_dep_env.cc:2429

GameApi::Env::get_download_bar_filename
IMPORT std::string get_download_bar_filename(int i) const
Definition GameApi_dep_env.cc:2308

GameApi::Env::free_memory
IMPORT void free_memory()
Definition GameApi_dep_env.cc:2257

GameApi::Env::store_file
IMPORT void store_file(std::string filename, ASyncVec *vec)
Definition GameApi_dep_store.cc:54

GameApi::Env::set_download_data
IMPORT void set_download_data(int i, const std::vector< unsigned char > &file)
Definition GameApi_dep_env.cc:2293

GameApi::Env::download_bar_count
IMPORT int download_bar_count() const
Definition GameApi_dep_env.cc:2288

GameApi::Env::print_dependencies
IMPORT void print_dependencies(int num)
Definition GameApi_dep_env.cc:2251

GameApi::Env::start_async
IMPORT int start_async(ASyncTask *task)
Definition GameApi_dep_env.cc:2328

GameApi::EventApi
Definition GameApi.hh:1416

GameApi::EventApi::pair
E pair(E e1, E e2)

GameApi::EventApi::polygon
L polygon(E start, E end, P polygon)
Definition GameApi_ev.cc:20

GameApi::EventApi::root_event
E root_event()
Definition GameApi_ev.cc:9

GameApi::EventApi::mouse_rectangle
M mouse_rectangle(MP m, int x, int y, int width, int height)

GameApi::EventApi::run_game
void run_game(ST states, int start_state)
Definition GameApi_ev.cc:104

GameApi::EventApi::link
LL link(L obj, MV point)

GameApi::EventApi::activate_event
ST activate_event(ST states, int state, E event)

GameApi::EventApi::activate_mouse_plane
E activate_mouse_plane(E activation_event, MP m)

GameApi::EventApi::array
L array(L *array, int size)

GameApi::EventApi::UnSerialize
ST UnSerialize(std::string s)

GameApi::EventApi::array
M array(M *array, int size)

GameApi::EventApi::state_change
E state_change(E event, int old_state, int new_state)

GameApi::EventApi::~EventApi
IMPORT ~EventApi()
Definition GameApi_ev.cc:205

GameApi::EventApi::key_down_event
E key_down_event(int key, E start_time, E end_time)

GameApi::EventApi::polygon
L polygon(E start, E end, P start_polygon, P end_polygon)

GameApi::EventApi::timer
E timer(E activation_event, float time)
Definition GameApi_ev.cc:14

GameApi::EventApi::link
LL link(L obj, ID pointnum, MV point)

GameApi::EventApi::array
LL array(LL *array, int size)

GameApi::EventApi::EventApi
IMPORT EventApi(Env &e)
Definition GameApi_ev.cc:4

GameApi::EventApi::enable_obj
ST enable_obj(ST states, int state, LL link)
Definition GameApi.cc:507

GameApi::EventApi::array
E array(E *array, int size)

GameApi::EventApi::Serialize
std::string Serialize(ST states, int start_state)

GameApi::EventApi::states
ST states(int count_states)
Definition GameApi_ev.cc:210

GameApi::EventApi::line
MV line(E start, E end, MV start_mv, MV end_mv, int start_choose, int end_choose)

GameApi::EventApi::disable_obj
ST disable_obj(ST states, int state, LL link)

GameApi::EventApi::deactivate_mouse_plane
E deactivate_mouse_plane(E deactivation_event, MP m)

GameApi::EventApi::point
MV point(float x, float y, float z)

GameApi::EventApi::mouse_plane
M mouse_plane()

GameApi::EventApi::key_up_event
E key_up_event(int key, E start_time, E end_time)

GameApi::EventApi::bitmap
L bitmap(E start, E end, BM bitmap)

GameApi::EventApi::mouse_plane
ST mouse_plane(ST states, int state, M mouse)

GameApi::EventNode::choose_ml_action
AC choose_ml_action(AC action, ML alternative)

GameApi::EventNode::empty_event
EV empty_event()

GameApi::EventNode::delta_timer
EV delta_timer(EV next, EV event, float delta_time)

GameApi::EventNode::event_bind
ML event_bind(ML next, EV event, AC action)

GameApi::EventNode::timer_event
EV timer_event(EV next, float time)

GameApi::EventNode::send_key_action
AC send_key_action(AC action, int key_id, int key_type)

GameApi::EventNode::key_event
EV key_event(EV next, int key_id, int key_type)

GameApi::EventNode::sequence_action
AC sequence_action(std::vector< AC > arr, float time_step)

GameApi::EventNode::EventNode
IMPORT EventNode(Env &e)
Definition GameApi.cc:44497

GameApi::EventNode::move_ml_action
AC move_ml_action(AC action, MN movement, float start_time, float end_time)

GameApi::EventNode::change_time_action
AC change_time_action(AC action, float new_time)

GameApi::EventNode::color_ml_action
AC color_ml_action(AC action, int color_num, CC cc)

GameApi::EventNode::array_action
AC array_action(std::vector< AC > arr)

GameApi::EventNode::skip_time_action
AC skip_time_action(AC action, float delta_time)

GameApi::EventNode::empty_action
AC empty_action()

GameApi::ExprApi::expr_float
IMPORT EX expr_float(std::string expr, bool &success)
Definition GameApi_ex.cc:594

GameApi::ExprApi::minus
IMPORT EX minus(EX e1, EX e2)
Definition GameApi_ex.cc:196

GameApi::ExprApi::sin
IMPORT EX sin(EX e1)
Definition GameApi_ex.cc:312

GameApi::ExprApi::int_constant
IMPORT EX int_constant(int val)
Definition GameApi_ex.cc:358

GameApi::ExprApi::div
IMPORT EX div(EX e1, EX e2)
Definition GameApi_ex.cc:236

GameApi::ExprApi::expr_eval_float
IMPORT float expr_eval_float(EX expr, std::vector< FloatExprEnv > env)
Definition GameApi_ex.cc:363

GameApi::ExprApi::ExprApi
IMPORT ExprApi(Env &e)
Definition GameApi.cc:44499

GameApi::ExprApi::plus
IMPORT EX plus(EX e1, EX e2)
Definition GameApi_ex.cc:113

GameApi::ExprApi::float_constant
IMPORT EX float_constant(float val)
Definition GameApi_ex.cc:354

GameApi::ExprApi::variable
IMPORT EX variable(std::string name)
Definition GameApi_ex.cc:77

GameApi::ExprApi::cos
IMPORT EX cos(EX e1)
Definition GameApi_ex.cc:317

GameApi::ExprApi::mul
IMPORT EX mul(EX e1, EX e2)
Definition GameApi_ex.cc:154

GameApi::ExprApi::expr_int
IMPORT EX expr_int(std::string expr, bool &success)
Definition GameApi_ex.cc:598

GameApi::ExprApi::expr_eval_int
IMPORT int expr_eval_int(EX expr, std::vector< IntExprEnv > env)
Definition GameApi_ex.cc:377

GameApi::FloatApi::value
IMPORT F value(float v)
Definition GameApi_f.cc:34

GameApi::FloatApi::array_index
IMPORT F array_index(float *array, int pos)
Definition GameApi_f.cc:50

GameApi::FloatApi::FloatApi
IMPORT FloatApi(Env &e)
Definition GameApi_f.cc:4

GameApi::FloatApi::ref
IMPORT F ref(float *v)
Definition GameApi_f.cc:42

GameApi::FloatApi::get_value
IMPORT float get_value(F f)
Definition GameApi_f.cc:58

GameApi::FloatArrayApi::ramp
FA ramp(float start_value, float end_value, int steps)
Definition GameApi_f.cc:136

GameApi::FloatArrayApi::FloatArrayApi
IMPORT FloatArrayApi(Env &e)
Definition GameApi_f.cc:66

GameApi::FloatArrayApi::duparray
FA duparray(float value, int size)
Definition GameApi_f.cc:153

GameApi::FloatArrayApi::array
FA array(float *array, int size)
Definition GameApi_f.cc:67

GameApi::FloatArrayApi::span_arrays
BM span_arrays(FA fa1, FA fa2, CBM f)
Definition GameApi_f.cc:125

GameApi::FloatArrayApi::subarray
FA subarray(FA fa, int start_index, int length)
Definition GameApi_f.cc:162

GameApi::FloatArrayApi::array_index
F array_index(FA fa, int index)
Definition GameApi_f.cc:176

GameApi::FloatArrayApi::f_array
FA f_array(F *array, int size)
Definition GameApi_f.cc:144

GameApi::FloatBitmapApi
Definition GameApi.hh:3767

GameApi::FloatBitmapApi::SampleContFloat
IMPORT FB SampleContFloat(CFB a1, float start_x, float end_x, float start_y, float end_y, int sx, int sy, float mult)
Definition GameApi_bm.cc:4248

GameApi::FloatBitmapApi::Y_bitmap
IMPORT CFB Y_bitmap(float sx, float sy)
Definition GameApi_bm.cc:3995

GameApi::FloatBitmapApi::SqrtContFloat
IMPORT CFB SqrtContFloat(CFB val)
Definition GameApi_bm.cc:4242

GameApi::FloatBitmapApi::min_fb
IMPORT FB min_fb(FB fb1, FB fb2)

GameApi::FloatBitmapApi::to_grayscale
IMPORT BM to_grayscale(FB fb)
Definition GameApi_bm.cc:3284

GameApi::FloatBitmapApi::to_bool
BB to_bool(FB f, float true_range_start, float true_range_end)
Definition GameApi_bm.cc:3237

GameApi::FloatBitmapApi::size_x
IMPORT int size_x(FB bm)
Definition GameApi_bm.cc:2543

GameApi::FloatBitmapApi::Tan
IMPORT CFB Tan(CFB val)
Definition GameApi_bm.cc:4292

GameApi::FloatBitmapApi::subfloatbitmap
IMPORT BM subfloatbitmap(EveryApi &ev, FB fb, float range_start, float range_end, unsigned int true_color, unsigned int false_color)
Definition GameApi_bm.cc:1952

GameApi::FloatBitmapApi::Equalizer
IMPORT CBB Equalizer(CFB, CFB)
Definition GameApi_bm.cc:4152

GameApi::FloatBitmapApi::to_grayscale_color
IMPORT BM to_grayscale_color(FB fb, int r, int g, int b, int a, int r2, int g2, int b2, int a2)
Definition GameApi_bm.cc:3290

GameApi::FloatBitmapApi::from_green
IMPORT FB from_green(BM color_bm)
Definition GameApi_bm.cc:2845

GameApi::FloatBitmapApi::fb_empty
IMPORT FB fb_empty(int sx, int sy)
Definition GameApi_bm.cc:2308

GameApi::FloatBitmapApi::perlin_noise
IMPORT FB perlin_noise(FB grad_1, FB grad_2)
Definition GameApi_bm.cc:2194

GameApi::FloatBitmapApi::SampleContBool
IMPORT BB SampleContBool(CBB a1, float start_x, float end_x, float start_y, float end_y, int sx, int sy)
Definition GameApi_bm.cc:4253

GameApi::FloatBitmapApi::perlin_noise2
IMPORT FB perlin_noise2(int sx, int sy, float key)
Definition GameApi_bm.cc:2200

GameApi::FloatBitmapApi::from_bool
IMPORT FB from_bool(BB b, float val_true, float val_false)
Definition GameApi_bm.cc:3179

GameApi::FloatBitmapApi::C_bitmap
IMPORT CFB C_bitmap(float sx, float sy, float val)
Definition GameApi_bm.cc:3966

GameApi::FloatBitmapApi::space_fill
IMPORT FB space_fill(PT *array, float *array2, int size, int sx, int sy)
Definition GameApi_bm.cc:2834

GameApi::FloatBitmapApi::grayscale
IMPORT FB grayscale(BM color_bm)

GameApi::FloatBitmapApi::to_color
IMPORT BM to_color(FB r, FB g, FB b, FB a)
Definition GameApi_bm.cc:3224

GameApi::FloatBitmapApi::distance_field
IMPORT FB distance_field(FB bb, float max_value)
Definition GameApi_bm.cc:3169

GameApi::FloatBitmapApi::FloatBitmapApi
IMPORT FloatBitmapApi(Env &e)
Definition GameApi_bm.cc:2690

GameApi::FloatBitmapApi::AddBitmap
IMPORT CFB AddBitmap(std::vector< CFB > vec)
Definition GameApi_bm.cc:4112

GameApi::FloatBitmapApi::size_y
IMPORT int size_y(FB bm)
Definition GameApi_bm.cc:2548

GameApi::FloatBitmapApi::add_border
IMPORT FB add_border(FB fb)
Definition GameApi_bm.cc:3174

GameApi::FloatBitmapApi::X_bitmap
IMPORT CFB X_bitmap(float sx, float sy)
Definition GameApi_bm.cc:3970

GameApi::FloatBitmapApi::from_grayscale
IMPORT FB from_grayscale(BM color_bm)
Definition GameApi_bm.cc:2906

GameApi::FloatBitmapApi::to_texid
IMPORT TXID to_texid(FB bm)
Definition GameApi_bm.cc:3686

GameApi::FloatBitmapApi::gaussian
IMPORT FB gaussian(float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, int sx, int sy)
Definition GameApi_bm.cc:2762

GameApi::FloatBitmapApi::to_bool_mod
IMPORT BB to_bool_mod(FB f, float mod_value)
Definition GameApi_bm.cc:3269

GameApi::FloatBitmapApi::floatvalue
IMPORT float floatvalue(FB bm, int x, int y)
Definition GameApi_bm.cc:2553

GameApi::FloatBitmapApi::MulBitmap
IMPORT CFB MulBitmap(std::vector< CFB > vec)
Definition GameApi_bm.cc:4102

GameApi::FloatBitmapApi::from_bool_bitmap
IMPORT FB from_bool_bitmap(BB bm, int csx, int csy)
Definition GameApi_bm.cc:3278

GameApi::FloatBitmapApi::from_red
IMPORT FB from_red(BM color_bm)
Definition GameApi_bm.cc:2766

GameApi::FloatBitmapApi::Sin
IMPORT CFB Sin(CFB val)
Definition GameApi_bm.cc:4282

GameApi::FloatBitmapApi::max_fb
IMPORT FB max_fb(FB fb1, FB fb2)

GameApi::FloatBitmapApi::from_alpha
IMPORT FB from_alpha(BM color_bm)
Definition GameApi_bm.cc:2947

GameApi::FloatBitmapApi::from_blue
IMPORT FB from_blue(BM color_bm)
Definition GameApi_bm.cc:2914

GameApi::FloatBitmapApi::Cos
IMPORT CFB Cos(CFB val)
Definition GameApi_bm.cc:4287

GameApi::FloatBitmapApi::mix_fb
IMPORT FB mix_fb(FB fb1, FB fb2, float val)

GameApi::FloatBitmapApi::choose_bitmap
IMPORT BM choose_bitmap(FB fb, BM bm1, BM bm2)
Definition GameApi_bm.cc:2207

GameApi::FloatBitmapApi::dist
IMPORT FB dist(int sx, int sy, float p_x, float p_y)
Definition GameApi_bm.cc:4467

GameApi::FloatBitmapApi::newfloatbitmap
IMPORT FB newfloatbitmap(char *array, int sx, int sy, std::function< float(char)> f)
Definition GameApi_bm.cc:1605

GameApi::FloatBitmapApi::blur_bitmap
IMPORT FB blur_bitmap(FB fb, float d)
Definition GameApi_bm.cc:4501

GameApi::FloatBitmapApi::~FloatBitmapApi
IMPORT ~FloatBitmapApi()
Definition GameApi_bm.cc:2691

GameApi::FloatSceneApi
Definition GameApi.hh:2860

GameApi::FloatSceneApi::fs_bound_x
FS fs_bound_x(FS left, FS right, float x)
Definition GameApi_ff.cc:1203

GameApi::FloatSceneApi::fs_bound_z
FS fs_bound_z(FS left, FS right, float z)
Definition GameApi_ff.cc:1276

GameApi::FloatSceneApi::fs_to_ml4
ML fs_to_ml4(EveryApi &ev, int sx, int sy, int sz, float ssx, float ssy, float ssz, FS obj, float pos, float sx1, float sy1, float sz1, float border_width, unsigned int border_color)
Definition GameApi_ff.cc:680

GameApi::FloatSceneApi::render_with_lipschitz_and_forallexists
BM render_with_lipschitz_and_forallexists(EveryApi &ev, FS bounding_spheres, O obj, float z, float z_dist, unsigned int bg_color, float per_pixel_sample_rate, float start_x, float end_x, float start_y, float end_y, int sx, int sy)
Definition GameApi_ff.cc:1171

GameApi::FloatSceneApi::fs_to_vx
VX fs_to_vx(EveryApi &ev, int sx, int sy, int sz, float ssx, float ssy, float ssz, FS obj, float pos)
Definition GameApi_ff.cc:602

GameApi::FloatSceneApi::fs_to_o
O fs_to_o(FS obj, float val)
Definition GameApi_ff.cc:551

GameApi::FloatSceneApi::o_to_ml4
ML o_to_ml4(EveryApi &ev, int sx, int sy, int sz, float ssx, float ssy, float ssz, O obj, float pos, float sx1, float sy1, float sz1, float border_width, unsigned int border_color)
Definition GameApi_ff.cc:691

GameApi::FloatSceneApi::o_to_ml3
ML o_to_ml3(EveryApi &ev, int sx, int sy, int sz, float ssx, float ssy, float ssz, O obj, float pos, MT mat, float sx1, float sy1, float sz1, float border_width, unsigned int border_color)
Definition GameApi_ff.cc:703

GameApi::FloatSceneApi::fs_min
FS fs_min(FS a1, FS a2)
Definition GameApi_ff.cc:1307

GameApi::FloatSceneApi::FloatSceneApi
IMPORT FloatSceneApi(Env &e)
Definition GameApi_ff.cc:4

GameApi::FloatSceneApi::fs_min_arr
FS fs_min_arr(std::vector< FS > arr)
Definition GameApi_ff.cc:1313

GameApi::FloatSceneApi::fs_sphere
FS fs_sphere(float center_x, float center_y, float center_z, float radius)
Definition GameApi_ff.cc:500

GameApi::FloatSceneApi::fd_to_fs
FS fd_to_fs(EveryApi &ev, FD fd)
Definition GameApi_ff.cc:528

GameApi::FloatSceneApi::color_scene
FS color_scene(FS scene, unsigned int color, int fptr_enum)
Definition GameApi_ff.cc:469

GameApi::FloatSceneApi::fs_to_ml2
ML fs_to_ml2(EveryApi &ev, int sx, int sy, int sz, float ssx, float ssy, float ssz, FS obj, float pos, MT mat, float sx1, float sy1, float sz1, float border_width, unsigned int border_color)
Definition GameApi_ff.cc:845

GameApi::FloatSceneApi::fs_bound_y
FS fs_bound_y(FS left, FS right, float y)
Definition GameApi_ff.cc:1240

GameApi::FloatSceneApi::fs_to_ml
ML fs_to_ml(EveryApi &ev, int sx, int sy, int sz, float ssx, float ssy, float ssz, FS obj, float pos, MT mat, float sx1, float sy1, float sz1)
Definition GameApi_ff.cc:800

GameApi::FloatSceneApi::fs_to_ml3
ML fs_to_ml3(EveryApi &ev, int sx, int sy, int sz, float ssx, float ssy, float ssz, FS obj, float pos, MT mat, float sx1, float sy1, float sz1, float border_width, unsigned int border_color)
Definition GameApi_ff.cc:754

GameApi::FloatVolumeApi
Definition GameApi.hh:2533

GameApi::FloatVolumeApi::maximum
IMPORT FO maximum(FO f1, FO f2)
Definition GameApi_vo.cc:1369

GameApi::FloatVolumeApi::prepare
IMPORT FOA prepare(FO object, int numpoints, float start_x, float start_y, float start_z, float end_x, float end_y, float end_z)
Definition GameApi_vo.cc:696

GameApi::FloatVolumeApi::light
IMPORT FO light(float dist)
Definition GameApi_vo.cc:734

GameApi::FloatVolumeApi::subvolume
IMPORT O subvolume(FO f, float start_range, float end_range)
Definition GameApi_vo.cc:785

GameApi::FloatVolumeApi::mandelbrot
IMPORT FO mandelbrot(float x_x, float x_y, float limit)
Definition GameApi_vo.cc:776

GameApi::FloatVolumeApi::min_distance
IMPORT FO min_distance(C curve)
Definition GameApi_vo.cc:1139

GameApi::FloatVolumeApi::julia
IMPORT FO julia(float c_x, float c_y, float limit)
Definition GameApi_vo.cc:768

GameApi::FloatVolumeApi::distance
IMPORT FO distance()
Definition GameApi_vo.cc:1315

GameApi::FloatVolumeApi::from_float_bitmap
IMPORT FO from_float_bitmap(FB bm, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)
Definition GameApi_vo.cc:1246

GameApi::FloatVolumeApi::move
IMPORT FO move(FO f1, float dx, float dy, float dz)
Definition GameApi_vo.cc:1383

GameApi::FloatVolumeApi::from_volume
IMPORT FO from_volume(O o, float false_val, float true_val)
Definition GameApi_vo.cc:1206

GameApi::FloatVolumeApi::waveform_sphere
IMPORT FO waveform_sphere(WV wav, float r)
Definition GameApi_integrator.cc:321

GameApi::FloatVolumeApi::shadow
IMPORT FO shadow(FD fd, V light_dir, float mint, float maxt, float k)
Definition GameApi_vo.cc:1133

GameApi::FloatVolumeApi::smooth
IMPORT FO smooth(std::vector< FO > vec, float val)
Definition GameApi_vo.cc:830

GameApi::FloatVolumeApi::FloatVolumeApi
IMPORT FloatVolumeApi(Env &e)
Definition GameApi.cc:44501

GameApi::FloatVolumeApi::interpolate
IMPORT FO interpolate(FO f1, FO f2, float val)
Definition GameApi_vo.cc:805

GameApi::FloatVolumeApi::raytrace
IMPORT BM raytrace(FO object, int sx, int sy, PT ray_0, PT ray_x, PT ray_y, PT ray_z, float surface_value)
Definition GameApi_vo.cc:1389

GameApi::FloatVolumeApi::minimum
IMPORT FO minimum(FO f1, FO f2)
Definition GameApi_vo.cc:1363

GameApi::FloatVolumeApi::torusdistance
IMPORT FO torusdistance(PT center, V u_x, V u_y, float radius)
Definition GameApi_vo.cc:1345

GameApi::FloatVolumeApi::integrate_render
IMPORT FB integrate_render(FO obj, int sx, int sy, int numsamples)
Definition GameApi_integrator.cc:278

GameApi::FloatVolumeApi::wave_move_y
IMPORT WV wave_move_y(WV wav, float delta)
Definition GameApi_integrator.cc:342

GameApi::FontApi
Definition GameApi.hh:1287

GameApi::FontApi::point_fetcher_part
IMPORT PF point_fetcher_part(PF point_fetcher, int component, FF float_fetcher)
Definition GameApi_fnt.cc:2228

GameApi::FontApi::int_to_string_fetcher
IMPORT SF int_to_string_fetcher(IF fetcher)
Definition GameApi_fnt.cc:2077

GameApi::FontApi::z_comp
IMPORT IF z_comp(PF point_fetcher, float start_z, float end_z, int num_steps)
Definition GameApi_fnt.cc:2219

GameApi::FontApi::render_glyph
IMPORT BM render_glyph(GI glyph)
Definition GameApi.cc:20581

GameApi::FontApi::hmd_request_presenting
IMPORT IF hmd_request_presenting(IF i)
Definition GameApi_vr.cc:935

GameApi::FontApi::font_atlas_info
IMPORT FtA font_atlas_info(EveryApi &ev, Ft font, std::string chars, float sx, float sy, int y_delta)
Definition GameApi_fnt.cc:363

GameApi::FontApi::hmd_state_fetcher
IMPORT IF hmd_state_fetcher()
Definition GameApi_vr.cc:972

GameApi::FontApi::font_string_from_atlas_opengl_pipeline
IMPORT P font_string_from_atlas_opengl_pipeline(EveryApi &ev, FtA atlas, BM atlas_bm, std::string str, int x_gap)
Definition GameApi_fnt.cc:491

GameApi::FontApi::choose_glyph_from_font
IMPORT GI choose_glyph_from_font(FI font, long idx)
Definition GameApi.cc:20591

GameApi::FontApi::load_font
IMPORT FI load_font(std::string ttf_filename, int sx, int sy)
Definition GameApi.cc:21069

GameApi::FontApi::outline_bm
IMPORT BM outline_bm(FI font, std::string glyph)
Definition GameApi.cc:21198

GameApi::FontApi::key_move_2_area_fetcher
IMPORT IF key_move_2_area_fetcher(float start_x, float end_x, float start_z, float end_z)
Definition GameApi_fnt.cc:1228

GameApi::FontApi::newfont
IMPORT Ft newfont(std::string filename, int sx, int sy)
Definition GameApi_fnt.cc:24

GameApi::FontApi::string_display_to_bitmap
IMPORT BM string_display_to_bitmap(SD sd, int def)
Definition GameApi.cc:20521

GameApi::FontApi::outline_string
IMPORT BM outline_string(EveryApi &ev, FI font, std::string str)
Definition GameApi.cc:21281

GameApi::FontApi::~FontApi
IMPORT ~FontApi()
Definition GameApi_fnt.cc:19

GameApi::FontApi::time_range_fetcher_state
IMPORT FF time_range_fetcher_state(int state, IF states, float start_time, float end_time, float before_start, float start_value, float end_value, float after_end, float repeat)
Definition GameApi_fnt.cc:1847

GameApi::FontApi::save_font_dump
IMPORT ML save_font_dump(FI font, std::string chars, std::string filename)
Definition GameApi.cc:38288

GameApi::FontApi::ready_fetcher
IMPORT IF ready_fetcher(P p)
Definition GameApi_fnt.cc:1200

GameApi::FontApi::choose_float_fetcher
IMPORT FF choose_float_fetcher(IF int_fetcher, float a_1, float a_2, float a_3, float a_4, float a_5, float a_6, float a_7)
Definition GameApi_fnt.cc:1612

GameApi::FontApi::save_atlas
IMPORT void save_atlas(FtA atlas, std::string filename)
Definition GameApi_fnt.cc:778

GameApi::FontApi::repeat_int_fetcher
IMPORT IF repeat_int_fetcher(IF fetcher, float duration)
Definition GameApi_fnt.cc:2319

GameApi::FontApi::font_atlas_engine2
IMPORT BM font_atlas_engine2(EveryApi &ev, FI font, FtA atlas, float sx, float sy)
Definition GameApi_fnt.cc:176

GameApi::FontApi::x_comp
IMPORT IF x_comp(PF point_fetcher, float start_x, float end_x, int num_steps)
Definition GameApi_fnt.cc:2209

GameApi::FontApi::fps_fetcher
IMPORT FF fps_fetcher(EveryApi &ev)
Definition GameApi_fnt.cc:1647

GameApi::FontApi::choose_screen
IMPORT ARR choose_screen(float left_x, float right_x, int min_screen, int max_screen)
Definition GameApi_fnt.cc:1998

GameApi::FontApi::FontApi
IMPORT FontApi(Env &e)
Definition GameApi_fnt.cc:15

GameApi::FontApi::float_to_string_fetcher
IMPORT SF float_to_string_fetcher(FF fetcher)
Definition GameApi_fnt.cc:2047

GameApi::FontApi::y_comp
IMPORT IF y_comp(PF point_fetcher, float start_y, float end_y, int num_steps)
Definition GameApi_fnt.cc:2214

GameApi::FontApi::glyph_plane
IMPORT PL glyph_plane(Ft font, long idx, float sx, float sy, float dx, float dy)
Definition GameApi_fnt.cc:59

GameApi::FontApi::FI_sprite_atlas
IMPORT ARR FI_sprite_atlas(EveryApi &ev, FI font, std::string chars, int sx, int sy, int y_delta)
Definition GameApi_fnt.cc:254

GameApi::FontApi::dynamic_string
IMPORT ML dynamic_string(EveryApi &ev, Ft font, std::string alternative_chars, SF fetcher, int x, int y, int numchars)
Definition GameApi_fnt.cc:1133

GameApi::FontApi::time_fetcher
IMPORT IF time_fetcher(EveryApi &ev, float start_time)
Definition GameApi_fnt.cc:1927

GameApi::FontApi::glyph_fb
IMPORT FB glyph_fb(Ft font, long idx)

GameApi::FontApi::point_fetcher_constant
IMPORT PF point_fetcher_constant(float x, float y, float z)
Definition GameApi_fnt.cc:2224

GameApi::FontApi::mouse_fetcher
IMPORT PF mouse_fetcher()
Definition GameApi_fnt.cc:2136

GameApi::FontApi::large_string_from_atlas
IMPORT BM large_string_from_atlas(EveryApi &ev, FtA atlas, BM atlas_bm, std::string url, int x_gap, int empty_line_height, int baseline_separation)
Definition GameApi_fnt.cc:604

GameApi::FontApi::span_key_fetcher
IMPORT FF span_key_fetcher(float start_x, float end_x, float speed_x, int down_key, int up_key)
Definition GameApi_fnt.cc:1354

GameApi::FontApi::timed_int_fetcher
IMPORT IF timed_int_fetcher(EveryApi &ev, int start, int end, float start_time, float end_time)
Definition GameApi_fnt.cc:2315

GameApi::FontApi::ml_chooser
IMPORT ML ml_chooser(std::vector< ML > vec, IF fetcher)
Definition GameApi_fnt.cc:2378

GameApi::FontApi::combine_glyphs
IMPORT GI combine_glyphs(GI glyph1, GI glyph2)
Definition GameApi_fnt.cc:169

GameApi::FontApi::bm_array_id
IMPORT ARR bm_array_id(std::vector< BM > vec)
Definition GameApi_fnt.cc:2488

GameApi::FontApi::draw_text_string_sd
IMPORT SD draw_text_string_sd(std::vector< GI > glyphs, std::string str, int gap_x, int empty_line_height)
Definition GameApi.cc:20798

GameApi::FontApi::time_fetcher2
IMPORT FF time_fetcher2(EveryApi &ev)
Definition GameApi_fnt.cc:1875

GameApi::FontApi::toggle_button_fetcher
IMPORT IF toggle_button_fetcher(float start_x, float end_x, float start_y, float end_y)
Definition GameApi_fnt.cc:2016

GameApi::FontApi::glyph_bb
IMPORT BB glyph_bb(Ft font, long idx)

GameApi::FontApi::dynamic_character
IMPORT ML dynamic_character(EveryApi &ev, std::vector< BM > vec, IF fetcher, int x, int y)
Definition GameApi_fnt.cc:1116

GameApi::FontApi::score_fetcher
IMPORT IF score_fetcher(EveryApi &ev)
Definition GameApi_fnt.cc:2012

GameApi::FontApi::movement_int_fetcher
IMPORT IF movement_int_fetcher(int count, float x_mult, float y_mult, float z_mult)
Definition GameApi_fnt.cc:2020

GameApi::FontApi::bm_array_id_inv
IMPORT std::vector< GameApi::BM > bm_array_id_inv(ARR arr)
Definition GameApi_fnt.cc:2475

GameApi::FontApi::glyph_outline
IMPORT LI glyph_outline(Ft font, long idx, float sx, float sy)
Definition GameApi_fnt.cc:37

GameApi::FontApi::load_atlas_from_string
IMPORT FtA load_atlas_from_string(std::string buf)
Definition GameApi_fnt.cc:663

GameApi::FontApi::font_string_from_atlas
IMPORT BM font_string_from_atlas(EveryApi &ev, FtA atlas, BM atlas_bm, std::string str, int x_gap)
Definition GameApi_fnt.cc:617

GameApi::FontApi::load_font_dump
IMPORT FI load_font_dump(std::string url)
Definition GameApi.cc:38457

GameApi::FontApi::dynamic_character2
IMPORT ML dynamic_character2(EveryApi &ev, std::vector< GI > vec, std::string alternatives, IF fetcher, int x, int y)

GameApi::FontApi::font_atlas_info_engine2
IMPORT FtA font_atlas_info_engine2(EveryApi &ev, FI font, std::string chars, float sx, float sy, int y_delta)
Definition GameApi_fnt.cc:199

GameApi::FontApi::score_string_fetcher
IMPORT SF score_string_fetcher(std::string id, std::string label, int numdigits)
Definition GameApi_fnt.cc:2412

GameApi::FontApi::time_range_fetcher_state_key
IMPORT FF time_range_fetcher_state_key(int state, int key, IF if_state, float start_time, float end_time, float before_start, float start_value, float end_value, float after_end, float repeat)
Definition GameApi_fnt.cc:1852

GameApi::FontApi::char_fetcher_from_string
IMPORT IF char_fetcher_from_string(SF string_fetcher, std::string alternatives, int idx)
Definition GameApi_fnt.cc:2328

GameApi::FontApi::draw_text_string
IMPORT BM draw_text_string(FI font, std::string str, int x_gap, int empty_line_height)
Definition GameApi.cc:20863

GameApi::FontApi::font_string
IMPORT BM font_string(Ft font, std::string str, int x_gap)
Definition GameApi_fnt.cc:2455

GameApi::FontApi::time_range_fetcher_key
IMPORT FF time_range_fetcher_key(int key, float start_time, float end_time, float before_start, float start_value, float end_value, float after_end, float repeat)
Definition GameApi_fnt.cc:1843

GameApi::FontApi::time_range_fetcher
IMPORT FF time_range_fetcher(float start_time, float end_time, float before_start, float start_value, float end_value, float after_end, float repeat)
Definition GameApi_fnt.cc:1839

GameApi::FontApi::quake_area_fetcher
IMPORT IF quake_area_fetcher(float start_x, float end_x, float start_z, float end_z)
Definition GameApi_fnt.cc:1409

GameApi::FontApi::load_atlas
IMPORT FtA load_atlas(std::string filename)
Definition GameApi_fnt.cc:709

GameApi::FontApi::font_string_array
IMPORT ARR font_string_array(Ft font, std::string s, int x_gap)
Definition GameApi_fnt.cc:819

GameApi::FontApi::time_string_fetcher
IMPORT SF time_string_fetcher(EveryApi &ev)
Definition GameApi_fnt.cc:2450

GameApi::FontApi::dynamic_polygon
IMPORT ML dynamic_polygon(EveryApi &ev, std::vector< P > vec, MT material, IF fetcher)
Definition GameApi_fnt.cc:1128

GameApi::FontApi::save_atlas_store_file
IMPORT void save_atlas_store_file(FtA atlas, std::string filename)
Definition GameApi_fnt.cc:754

GameApi::FontApi::draw_text_large
IMPORT BM draw_text_large(EveryApi &ev, FI font, std::string url, int x_gap, int empty_line_height, int baseline_separation)
Definition GameApi.cc:20962

GameApi::FontApi::font_string_array2
IMPORT ARR font_string_array2(FI font, std::string s)
Definition GameApi_fnt.cc:800

GameApi::FontApi::glyph
IMPORT BM glyph(Ft font, long idx)
Definition GameApi_fnt.cc:101

GameApi::FontApi::keypress_int_fetcher
IMPORT IF keypress_int_fetcher(int key, int key_down_value, int key_up_value)
Definition GameApi_fnt.cc:2324

GameApi::FontApi::FI_sprite_atlas_persistent_cache
IMPORT ARR FI_sprite_atlas_persistent_cache(EveryApi &ev, FtA atlas, BM atlas_bm, std::string atlas_filename, std::string atlas_bm_filename)
Definition GameApi_fnt.cc:317

GameApi::FontApi::dynamic_character_frame
IMPORT FML dynamic_character_frame(EveryApi &ev, std::vector< BM > vec, IF fetcher, int x, int y, int fmt, MN mn)
Definition GameApi_fnt.cc:1121

GameApi::FontApi::font_atlas
IMPORT BM font_atlas(EveryApi &ev, Ft font, FtA atlas, float sx, float sy)
Definition GameApi_fnt.cc:407

GameApi::FrameBufferApi
Definition GameApi.hh:4577

GameApi::FrameBufferApi::depth_ml
IMPORT TXID depth_ml(EveryApi &ev, ML mainloop, int sx, int sy, bool translate)
Definition GameApi_fbo.cc:396

GameApi::FrameBufferApi::tex_id
IMPORT TXID tex_id(FBO buffer)
Definition GameApi_fbo.cc:6

GameApi::FrameBufferApi::config_fbo
IMPORT void config_fbo(FBO buffer)
Definition GameApi_fbo.cc:74

GameApi::FrameBufferApi::fbo_status
IMPORT bool fbo_status(FBO buffer)
Definition GameApi_fbo.cc:125

GameApi::FrameBufferApi::unconfig_fbo
IMPORT void unconfig_fbo(FBO buffer)
Definition GameApi_fbo.cc:93

GameApi::FrameBufferApi::FrameBufferApi
IMPORT FrameBufferApi(Env &e)
Definition GameApi.cc:44524

GameApi::FrameBufferApi::bind_screen
IMPORT void bind_screen(vp viewport)
Definition GameApi_fbo.cc:116

GameApi::FrameBufferApi::fbo_ml
IMPORT TXID fbo_ml(EveryApi &ev, ML mainloop, int sx, int sy, bool translate)
Definition GameApi_fbo.cc:391

GameApi::FrameBufferApi::depth_id
IMPORT TXID depth_id(FBO buffer)
Definition GameApi_fbo.cc:13

GameApi::FrameBufferApi::create_fbo
IMPORT FBO create_fbo(EveryApi &ev, int sx, int sy)
Definition GameApi_fbo.cc:20

GameApi::FrameBufferApi::bind_fbo
IMPORT vp bind_fbo(FBO buffer)
Definition GameApi_fbo.cc:105

GameApi::FrameBufferApi::fbo_ml_blit
IMPORT ML fbo_ml_blit(EveryApi &ev, TXID id, float start_x, float end_x, float start_y, float end_y, float z)
Definition GameApi_fbo.cc:482

GameApi::FrameBufferApi::fbo_to_bitmap
IMPORT BM fbo_to_bitmap(EveryApi &ev, FBO buffer)
Definition GameApi_fbo.cc:136

GameApi::FunctionApi
Definition GameApi.hh:1548

GameApi::FunctionApi::min
F min(F orig, F orig2)

GameApi::FunctionApi::curve_y
F curve_y(C c)

GameApi::FunctionApi::deriv
F deriv(F f)

GameApi::FunctionApi::line_from_bm_y
F line_from_bm_y(BM bm, int bm_y, float length)

GameApi::FunctionApi::~FunctionApi
IMPORT ~FunctionApi()
Definition GameApi_fn.cc:13

GameApi::FunctionApi::scale_y
F scale_y(F orig, float old_min_y, float old_max_y, float new_min_y, float new_max_y)

GameApi::FunctionApi::cos
F cos()
Definition GameApi_fn.cc:37

GameApi::FunctionApi::FunctionApi
IMPORT FunctionApi(Env &e)
Definition GameApi_fn.cc:9

GameApi::FunctionApi::line
F line(float x, float y, float x2, float y2, float begin_y, float end_y)

GameApi::FunctionApi::equalizer
std::vector< PT > equalizer(F f1, F f2, float start, float length)

GameApi::FunctionApi::curve_z
F curve_z(C c)

GameApi::FunctionApi::sin
F sin()
Definition GameApi_fn.cc:33

GameApi::FunctionApi::constant
F constant(float y)
Definition GameApi_fn.cc:25

GameApi::FunctionApi::move_x
F move_x(F orig, float delta)

GameApi::FunctionApi::move_y
F move_y(F orig, float delta)

GameApi::FunctionApi::max
F max(F orig, F orig2)

GameApi::FunctionApi::get_value
float get_value(F f, float x)
Definition GameApi_fn.cc:17

GameApi::FunctionApi::curve_x
F curve_x(C c)

GameApi::FunctionApi::integrate
F integrate(F f)

GameApi::FunctionApi::change_range
F change_range(F orig, F replace, float x_start, float x_end)

GameApi::FunctionApi::line_from_bm_x
F line_from_bm_x(BM bm, int bm_x, float length)

GameApi::FunctionCb
Definition GameApi.hh:312

GameApi::FunctionCb::Map
virtual R Map(P p) const =0

GameApi::GamesApi::start_game
IMPORT void start_game(int event)
Definition GameApi.cc:572

GameApi::GamesApi::GamesApi
IMPORT GamesApi(Env &e)
Definition GameApi.cc:558

GameApi::GamesApi::modify_map
IMPORT void modify_map(int event, int game_id)
Definition GameApi.cc:568

GameApi::GamesApi::register_game
IMPORT void register_game(int game_id, void(*fptr)(EveryApi &e))
Definition GameApi.cc:564

GameApi::GamesApi::~GamesApi
IMPORT ~GamesApi()
Definition GameApi.cc:561

GameApi::GridApi
Definition GameApi.hh:1061

GameApi::GridApi::~GridApi
IMPORT ~GridApi()
Definition GameApi.cc:532

GameApi::GridApi::GridApi
IMPORT GridApi(Env &e)
Definition GameApi.cc:528

GameApi::GridApi::gridtilespace
IMPORT SP gridtilespace(BM tilebm, int sx, int sy, int x, int y)

GameApi::GridApi::preparegrid
IMPORT void preparegrid(BM tile_bitmap, int tile_choose=-1)
Definition GameApi_gr.cc:6

GameApi::GridApi::rendergrid
IMPORT void rendergrid(BM grid, int grid_choose, float top_x, float top_y)
Definition GameApi_gr.cc:32

GameApi::GridApi::wholegridspace
IMPORT SP wholegridspace(int sx, int sy, BM grid)

GameApi::GuiApi
Definition GameApi.hh:2254

GameApi::GuiApi::generic_editor
IMPORT W generic_editor(EveryApi &ev, EditTypes &target, FtA atlas, BM atlas_bm, std::string type, int x_gap, FtA atlas_tiny, BM atlas_tiny_bm, int sy, W &click_target)
Definition GameApi_gui.cc:5981

GameApi::GuiApi::colorvolumeapi_functions_list_item
IMPORT W colorvolumeapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer)
Definition GameApi_gui.cc:8976

GameApi::GuiApi::bounding_box
IMPORT W bounding_box(W w)
Definition GameApi_gui.cc:2377

GameApi::GuiApi::or_elem
IMPORT W or_elem(W(*w1_func)(void *), W(*w2_func)(void *), void *data)
Definition GameApi_gui.cc:6727

GameApi::GuiApi::boolbitmapapi_functions_item_label
IMPORT std::string boolbitmapapi_functions_item_label(int i)
Definition GameApi_gui.cc:8798

GameApi::GuiApi::size_x
IMPORT int size_x(W w)
Definition GameApi_gui.cc:6845

GameApi::GuiApi::multiline_string_editor
IMPORT W multiline_string_editor(std::string allowed_chars, std::string &target, FI font, int x_gap, int line_height)
Definition GameApi_gui.cc:4740

GameApi::GuiApi::click_hide
IMPORT W click_hide(W widget)
Definition GameApi.cc:17418

GameApi::GuiApi::submenu
IMPORT W submenu(W menu, int menu_pane_id, std::vector< std::string > labels, FtA atlas, BM atlas_bm)

GameApi::GuiApi::ml
IMPORT W ml(ML p, SH sh, SH sh2, SH sh_2d, SH sh_arr, int sx, int sy, int screen_size_x, int screen_size_y)
Definition GameApi_gui.cc:4706

GameApi::GuiApi::pos_y
IMPORT int pos_y(W w)
Definition GameApi_gui.cc:6840

GameApi::GuiApi::textureapi_functions_item_label
IMPORT std::string textureapi_functions_item_label(int i)
Definition GameApi_gui.cc:8708

GameApi::GuiApi::fontapi_functions_item_label
IMPORT std::string fontapi_functions_item_label(int i)
Definition GameApi_gui.cc:8716

GameApi::GuiApi::pts_dialog
IMPORT W pts_dialog(PTS p, SH sh, int screen_size_x, int screen_size_y, W &close_button, FtA atlas, BM atlas_bm, W &codegen_button, W &collect_button)
Definition GameApi_gui.cc:5447

GameApi::GuiApi::layout_lh
IMPORT W layout_lh(W item, int left, int top, int width, int height, int right, int bottom, int(*fptr_l)(void *), int(*fptr_H)(void *), void *ctx1, void *ctx2)
Definition GameApi_gui.cc:6104

GameApi::GuiApi::linesapi_functions_item_label
IMPORT std::string linesapi_functions_item_label(int i)
Definition GameApi_gui.cc:8752

GameApi::GuiApi::floatvolumeapi_functions_list_item
IMPORT W floatvolumeapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer)
Definition GameApi_gui.cc:8972

GameApi::GuiApi::set_dynamic_param
IMPORT void set_dynamic_param(W w, int id, float val)
Definition GameApi_gui.cc:6942

GameApi::GuiApi::canvas
IMPORT W canvas(int sx, int sy)
Definition GameApi_gui.cc:3735

GameApi::GuiApi::insert_widget_activate
IMPORT void insert_widget_activate(W w, bool b)

GameApi::GuiApi::directory_view
IMPORT W directory_view(std::vector< std::string > dir_items, int &selection, std::vector< W > &clicks, FtA atlas, BM atlas_bm)
Definition GameApi_gui.cc:5002

GameApi::GuiApi::top_right_corner_match
IMPORT W top_right_corner_match(W wid, W floating)
Definition GameApi.cc:17487

GameApi::GuiApi::floatbitmapapi_functions_list_item
IMPORT W floatbitmapapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer)
Definition GameApi_gui.cc:9015

GameApi::GuiApi::get_size2
IMPORT int get_size2(W w)
Definition GameApi_gui.cc:6957

GameApi::GuiApi::overlap
IMPORT W overlap(EveryApi &ev, std::vector< W > vec)
Definition GameApi_gui.cc:4571

GameApi::GuiApi::array_y
IMPORT W array_y(std::vector< W > arr, int y_gap, bool heavy=false)
Definition GameApi_gui.cc:6139

GameApi::GuiApi::license_item
IMPORT W license_item(std::string filename, std::string &license_url, std::string &author, FtA atlas, BM atlas_bm, FtA atlas2, BM atlas_bm2)
Definition GameApi_gui.cc:4152

GameApi::GuiApi::list_item_opened
IMPORT W list_item_opened(int sx, std::string label, FtA atlas, BM atlas_bm, std::vector< std::string > subitems, std::vector< std::string > subitems_tooltip, FtA atlas2, BM atlas_bm2, W insert, bool hide, W *redraw_w, std::vector< std::string > subitems_funcname)
Definition GameApi_gui.cc:3823

GameApi::GuiApi::fontapi_functions_list_item
IMPORT W fontapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer)
Definition GameApi_gui.cc:8963

GameApi::GuiApi::line
IMPORT W line(W target1, int delta_x, int delta_y, W target2, int delta2_x, int delta2_y, SH sh, SH old_sh)
Definition GameApi_gui.cc:3727

GameApi::GuiApi::bitmapapi_functions_list_item
IMPORT W bitmapapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer)
Definition GameApi_gui.cc:8933

GameApi::GuiApi::linesapi_functions_list_item
IMPORT W linesapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer)
Definition GameApi_gui.cc:8994

GameApi::GuiApi::gradient
IMPORT W gradient(int sx, int sy, PT pos_1, PT pos_2, unsigned int colot_1, unsigned int color_2)
Definition GameApi_gui.cc:6621

GameApi::GuiApi::polygon_dialog
IMPORT W polygon_dialog(P p, SH sh, int screen_size_x, int screen_size_y, W &close_button, FtA atlas, BM atlas_bm, W &codegen_button, W &collect_button, W &mem)
Definition GameApi_gui.cc:5175

GameApi::GuiApi::set_index
IMPORT void set_index(W w, int j)
Definition GameApi_gui.cc:6967

GameApi::GuiApi::download_bar
IMPORT W download_bar(GameApi::EveryApi &ev, std::vector< std::string > titles, std::vector< W > &close_button, std::vector< W > &buttons, FtA atlas, BM atlas_bm, int active_tab, std::vector< float > progress)
Definition GameApi_gui.cc:5025

GameApi::GuiApi::size_y
IMPORT int size_y(W w)
Definition GameApi_gui.cc:6850

GameApi::GuiApi::hide_nonsearchable
IMPORT W hide_nonsearchable(W w, std::string label, W *redraw_w)
Definition GameApi_gui.cc:4605

GameApi::GuiApi::boolbitmapapi_functions_list_item
IMPORT W boolbitmapapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer)
Definition GameApi_gui.cc:9011

GameApi::GuiApi::lines_dialog
IMPORT W lines_dialog(LI p, SH sh, int screen_size_x, int screen_size_y, W &close_button, FtA atlas, BM atlas_bm, W &codegen_button, W &collect_button)
Definition GameApi_gui.cc:5404

GameApi::GuiApi::pointapi_functions_item_label
IMPORT std::string pointapi_functions_item_label(int i)
Definition GameApi_gui.cc:8812

GameApi::GuiApi::blockerapi_functions_list_item
IMPORT W blockerapi_functions_list_item(GameApi::EveryApi &ev, FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer)
Definition GameApi_gui.cc:8941

GameApi::GuiApi::moveapi_functions_list_item
IMPORT W moveapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer)
Definition GameApi_gui.cc:8956

GameApi::GuiApi::progress_dialog
IMPORT W progress_dialog(int sx, int sy, FtA atlas, BM atlas_bm, std::vector< std::string > vec, int val, int max)
Definition GameApi_gui.cc:4326

GameApi::GuiApi::framebuffermoduleapi_functions_list_item
IMPORT W framebuffermoduleapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer)
Definition GameApi_gui.cc:8990

GameApi::GuiApi::pos_x
IMPORT int pos_x(W w)
Definition GameApi_gui.cc:6835

GameApi::GuiApi::booleanopsapi_functions_list_item
IMPORT W booleanopsapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer)
Definition GameApi_gui.cc:8951

GameApi::GuiApi::icon_shared_noscale
IMPORT W icon_shared_noscale(BM bitmap, int key)
Definition GameApi_gui.cc:4674

GameApi::GuiApi::click_visibility
IMPORT W click_visibility(W area_widget, W hidden_widget)
Definition GameApi.cc:17410

GameApi::GuiApi::layer
IMPORT W layer(W w1, W w2)
Definition GameApi_gui.cc:6123

GameApi::GuiApi::navi_bar
IMPORT W navi_bar(EveryApi &ev, std::vector< std::string > titles, W &back_button, W &forward_button, W &save_button, std::string &url, W &url_button, std::vector< W > &close_button, std::vector< W > &tab_change_button, W &new_tab_button, std::vector< std::string > bookmark_labels, std::vector< std::string > bookmark_urls, FtA atlas, BM atlas_bm, int &active_tab)
Definition GameApi_gui.cc:5082

GameApi::GuiApi::insert_widget
IMPORT W insert_widget(W item, std::function< void(int, int)> f)
Definition GameApi_gui.cc:9069

GameApi::GuiApi::layout_wh
IMPORT W layout_wh(W item, int left, int top, int width, int height, int right, int bottom, int(*fptr_W)(void *), int(*fptr_H)(void *), void *ctx1, void *ctx2)
Definition GameApi_gui.cc:6090

GameApi::GuiApi::window_decoration
IMPORT W window_decoration(int sx, int sy, std::string label, FtA atlas, BM atlas_bm)
Definition GameApi_gui.cc:5366

GameApi::GuiApi::vectorapi_functions_list_item
IMPORT W vectorapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer)
Definition GameApi_gui.cc:9006

GameApi::GuiApi::colorvolumeapi_functions_item_label
IMPORT std::string colorvolumeapi_functions_item_label(int i)
Definition GameApi_gui.cc:8789

GameApi::GuiApi::polygonapi_functions_item_label
IMPORT std::string polygonapi_functions_item_label(int i)
Definition GameApi_gui.cc:8760

GameApi::GuiApi::button_with_icon
IMPORT W button_with_icon(BM bitmap)

GameApi::GuiApi::va_dialog
IMPORT W va_dialog(VA p, SH sh, int screen_size_x, int screen_size_y, W &close_button, FtA atlas, BM atlas_bm, W &codegen_button, W &collect_button)
Definition GameApi_gui.cc:5232

GameApi::GuiApi::update_progress_dialog
IMPORT void update_progress_dialog(volatile W &w, int sx, int sy, FtA atlas, BM atlas_bm, std::vector< std::string > vec, int val, int max, int process)
Definition GameApi_gui.cc:4438

GameApi::GuiApi::GuiApi
GuiApi(Env &e, EveryApi &ev, SH sh)
Definition GameApi.hh:2256

GameApi::GuiApi::shadermoduleapi_functions_list_item
IMPORT W shadermoduleapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer)
Definition GameApi_gui.cc:8982

GameApi::GuiApi::point_editor
IMPORT W point_editor(float &x, float &y, float &z, FtA atlas, BM atlas_bm, int x_gap)
Definition GameApi_gui.cc:6054

GameApi::GuiApi::set_pos
IMPORT void set_pos(W w, float px, float py)
Definition GameApi_gui.cc:6855

GameApi::GuiApi::scrollbar_x
IMPORT W scrollbar_x(int sx, int sy, int area_x)
Definition GameApi_gui.cc:6737

GameApi::GuiApi::scrollbar_y
IMPORT W scrollbar_y(int sx, int sy, int area_y)
Definition GameApi_gui.cc:6733

GameApi::GuiApi::framebuffermoduleapi_functions_item_label
IMPORT std::string framebuffermoduleapi_functions_item_label(int i)
Definition GameApi_gui.cc:8738

GameApi::GuiApi::vectorapi_functions_item_label
IMPORT std::string vectorapi_functions_item_label(int i)
Definition GameApi_gui.cc:8819

GameApi::GuiApi::timed_visibility
IMPORT W timed_visibility(W orig, W(*timed_widget_func)(void *), void *data, W insert, float start_duration, float duration, float dx)
Definition GameApi_gui.cc:3669

GameApi::GuiApi::layout
IMPORT W layout(W item, int left, int top, int width, int height, int right, int bottom)
Definition GameApi_gui.cc:6080

GameApi::GuiApi::get_index
IMPORT int get_index(W w)
Definition GameApi_gui.cc:6952

GameApi::GuiApi::alt
IMPORT W alt(std::vector< W > vec, int *choose)
Definition GameApi_gui.cc:4626

GameApi::GuiApi::dialog_border
IMPORT W dialog_border(W item)

GameApi::GuiApi::right_align
IMPORT W right_align(W item, int sx)
Definition GameApi_gui.cc:5793

GameApi::GuiApi::va
IMPORT W va(VA p, SH sh, int sx, int sy, int screen_size_x, int screen_size_y)
Definition GameApi_gui.cc:4699

GameApi::GuiApi::pointapi_functions_list_item
IMPORT W pointapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer)
Definition GameApi_gui.cc:9002

GameApi::GuiApi::int_editor
IMPORT W int_editor(int &target, std::string &target_expr, FtA atlas, BM atlas_bm, int x_gap, int noneditnum=0)
Definition GameApi_gui.cc:4923

GameApi::GuiApi::copy_paste_dialog
IMPORT W copy_paste_dialog(SH sh, W &close_button, FI font, FtA atlas, BM atlas_bm, std::string &edit)
Definition GameApi_gui.cc:4961

GameApi::GuiApi::alt
IMPORT W alt(GameApi::EveryApi &ev, std::vector< W > vec, int *choose)

GameApi::GuiApi::bitmapapi_functions_item_label
IMPORT std::string bitmapapi_functions_item_label(int i)
Definition GameApi_gui.cc:8686

GameApi::GuiApi::polygonapi_functions_list_item
IMPORT W polygonapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer)
Definition GameApi_gui.cc:9020

GameApi::GuiApi::set_size2
IMPORT void set_size2(W w, int sz)
Definition GameApi_gui.cc:6962

GameApi::GuiApi::editor_mouse_tweak
IMPORT W editor_mouse_tweak(W inner, W outer, W outerouter)
Definition GameApi_gui.cc:390

GameApi::GuiApi::tooltip
IMPORT W tooltip(W orig, W insert, std::string label, FtA atlas, BM atlas_bm, int x_gap=2, float dx=40.0)
Definition GameApi_gui.cc:3712

GameApi::GuiApi::get_id
IMPORT std::string get_id(W w)
Definition GameApi_gui.cc:6947

GameApi::GuiApi::list_item
IMPORT W list_item(BM icon, std::string label, int sx, int sy)

GameApi::GuiApi::dynamic_param
IMPORT float dynamic_param(W w, int id)
Definition GameApi_gui.cc:6897

GameApi::GuiApi::pointsapi_functions_item_label
IMPORT std::string pointsapi_functions_item_label(int i)
Definition GameApi_gui.cc:8745

GameApi::GuiApi::waveform
IMPORT W waveform(std::function< float(float)> f, float start_range, float end_range, float min_value, float max_value, int sx, int sy, unsigned int true_color, unsigned int false_color)
Definition GameApi_gui.cc:6756

GameApi::GuiApi::window_move
IMPORT W window_move(W widget, int area_x, int area_y, int area_width, int area_height)
Definition GameApi_gui.cc:4110

GameApi::GuiApi::scroll_area2
IMPORT W scroll_area2(W orig, int sx, int sy, int screen_y)
Definition GameApi_gui.cc:6746

GameApi::GuiApi::asset_view
IMPORT W asset_view(std::string url_or_filename)
Definition GameApi_gui.cc:5018

GameApi::GuiApi::select_item
IMPORT void select_item(W w, int item)
Definition GameApi_gui.cc:6892

GameApi::GuiApi::shader_plane
IMPORT W shader_plane(SFO p, int sx, int sy, int screen_size_x, int screen_size_y)
Definition GameApi_gui.cc:4717

GameApi::GuiApi::scroll_area
IMPORT W scroll_area(W orig, int sx, int sy, int screen_y)
Definition GameApi_gui.cc:6741

GameApi::GuiApi::get_functions_mapping
IMPORT std::vector< std::pair< std::string, std::string > > get_functions_mapping(GameApi::EveryApi &ev)
Definition GameApi_gui.cc:9081

GameApi::GuiApi::dynamic_text
IMPORT W dynamic_text(std::string need_letters, std::string *dyn_text, void(*fptr)(void *, float mouse_x, float mouse_y, int button, int ch, int type, int mouse_wheel_y), void *user_ptr, GameApi::FtA atlas, GameApi::BM atlas_bm, int x_gap)
Definition GameApi_gui.cc:4646

GameApi::GuiApi::shaderapi_functions_item_label
IMPORT std::string shaderapi_functions_item_label(int i)
Definition GameApi_gui.cc:8731

GameApi::GuiApi::rectangle
IMPORT W rectangle(int start_x, int end_x, int start_y, int end_y, unsigned int color)
Definition GameApi_gui.cc:4014

GameApi::GuiApi::lines
IMPORT W lines(LI p, SH sh, int sx, int sy, int screen_size_x, int screen_size_y)
Definition GameApi_gui.cc:4722

GameApi::GuiApi::booleanopsapi_functions_item_label
IMPORT std::string booleanopsapi_functions_item_label(int i)
Definition GameApi_gui.cc:8827

GameApi::GuiApi::main_menu
IMPORT W main_menu(std::vector< std::string > labels, FtA atlas, BM atlas_bm)
Definition GameApi_gui.cc:6150

GameApi::GuiApi::waveformapi_functions_list_item
IMPORT W waveformapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer)
Definition GameApi_gui.cc:8937

GameApi::GuiApi::list_item_title
IMPORT W list_item_title(int sx, std::string label, FtA atlas, BM atlas_bm)
Definition GameApi_gui.cc:3812

GameApi::GuiApi::canvas_item_index
IMPORT int canvas_item_index(W canvas, W item)
Definition GameApi_gui.cc:3800

GameApi::GuiApi::icon_shared
IMPORT W icon_shared(BM bitmap, int key)
Definition GameApi_gui.cc:4685

GameApi::GuiApi::polygondistapi_functions_list_item
IMPORT W polygondistapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer)
Definition GameApi_gui.cc:9024

GameApi::GuiApi::search_panel
IMPORT W search_panel(int sx, FtA atlas, BM atlas_bm, int x_gap, W *redraw_w)
Definition GameApi_gui.cc:4590

GameApi::GuiApi::num_childs
IMPORT int num_childs(W w)
Definition GameApi_gui.cc:6904

GameApi::GuiApi::pts
IMPORT W pts(PTS p, SH sh, int sx, int sy, int screen_size_x, int screen_size_y)
Definition GameApi_gui.cc:4726

GameApi::GuiApi::long_editor
IMPORT W long_editor(long &target, FtA atlas, BM atlas_bm, int x_gap, int noneditnum, std::string &expr)
Definition GameApi_gui.cc:4936

GameApi::GuiApi::volumeapi_functions_item_label
IMPORT std::string volumeapi_functions_item_label(int i)
Definition GameApi_gui.cc:8774

GameApi::GuiApi::popup_menu
IMPORT W popup_menu(int x, int y, std::vector< std::string > labels, FtA atlas, BM atlas_bm, std::vector< W > &areas)
Definition GameApi_gui.cc:6790

GameApi::GuiApi::update
IMPORT void update(W w, PT mouse_cursor_pos, int button, int ch, int type, int mouse_wheel_y)
Definition GameApi_gui.cc:6869

GameApi::GuiApi::size
IMPORT W size(W item, int sx, int sy)
Definition GameApi_gui.cc:6118

GameApi::GuiApi::dialog_item
IMPORT W dialog_item(std::string text, BM icon, int sx, int sy)

GameApi::GuiApi::blockerapi_functions_item_label
IMPORT std::string blockerapi_functions_item_label(GameApi::EveryApi &ev, int i)
Definition GameApi_gui.cc:8700

GameApi::GuiApi::volumeapi_functions_list_item
IMPORT W volumeapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer)
Definition GameApi_gui.cc:8968

GameApi::GuiApi::mouse_move
IMPORT W mouse_move(W widget, int area_x, int area_y, int area_width, int area_height)
Definition GameApi_gui.cc:4104

GameApi::GuiApi::array_x
IMPORT W array_x(W *arr, int size, int x_gap)
Definition GameApi_gui.cc:6129

GameApi::GuiApi::list
IMPORT W list(W *array, int size, int sx, int sy)

GameApi::GuiApi::shaderapi_functions_list_item
IMPORT W shaderapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer)
Definition GameApi_gui.cc:8986

GameApi::GuiApi::shader_dialog
IMPORT W shader_dialog(SFO p, W &close_button, FtA atlas, BM atlas_bm, int screen_size_x, int screen_size_y, W &codegen_button, W &collect_button)
Definition GameApi_gui.cc:5322

GameApi::GuiApi::asset_item
IMPORT W asset_item(EveryApi &ev, std::string jpg_url, std::string jpg_display_name, FtA atlas, BM atlas_bm)
Definition GameApi_gui.cc:4177

GameApi::GuiApi::floatbitmapapi_functions_item_label
IMPORT std::string floatbitmapapi_functions_item_label(int i)
Definition GameApi_gui.cc:8805

GameApi::GuiApi::text
IMPORT W text(std::string label, FtA atlas, BM atlas_bm, int x_gap=3)
Definition GameApi_gui.cc:4658

GameApi::GuiApi::center_y
IMPORT W center_y(W item, int sy)
Definition GameApi_gui.cc:5808

GameApi::GuiApi::edit_dialog
IMPORT W edit_dialog(const std::vector< std::string > &labels, const std::vector< EditTypes * > &vec, Ft font, const std::vector< std::string > &types, W &cancel_button, W &ok_button)

GameApi::GuiApi::canvas_item
IMPORT int canvas_item(W canvas, W item, int x, int y)
Definition GameApi_gui.cc:3776

GameApi::GuiApi::set_size
IMPORT void set_size(W ow, float sx, float sy)
Definition GameApi_gui.cc:6863

GameApi::GuiApi::license_dialog
IMPORT W license_dialog(std::vector< std::string > filename, std::vector< std::string > &license_url, std::vector< std::string > &author_names, FtA atlas, BM atlas_bm, FtA atlas2, BM atlas_bm2, FtA atlas3, BM atlas_bm3, W &next_button, W &cancel_button, W &canvas2, W &canvas_area, W &scroll_bar)
Definition GameApi_gui.cc:4256

GameApi::GuiApi::window_decoration2
IMPORT W window_decoration2(int sx, int sy, std::string label, FtA atlas, BM atlas_bm, bool move)
Definition GameApi_gui.cc:5371

GameApi::GuiApi::button_with_text
IMPORT W button_with_text(std::string label)

GameApi::GuiApi::button
IMPORT W button(int sx, int sy, unsigned int color_1, unsigned int color_2)
Definition GameApi_gui.cc:6650

GameApi::GuiApi::asset_dialog
IMPORT W asset_dialog(EveryApi &ev, std::vector< std::string > jpg_urls, std::vector< std::string > jpg_display_names, W &select_button, W &cancel_button, FtA atlas, BM atlas_bm)
Definition GameApi_gui.cc:4192

GameApi::GuiApi::hide_if_array_empty
IMPORT W hide_if_array_empty(W w, std::vector< W > items, W *redraw_w)
Definition GameApi_gui.cc:4612

GameApi::GuiApi::bitmap_dialog
IMPORT W bitmap_dialog(BM bm, W &close_button, FtA atlas, BM atlas_bm, W &codegen_button, W &collect_button, FtA atlas_tiny, BM atlas_tiny_bm)
Definition GameApi_gui.cc:5526

GameApi::GuiApi::delete_widget
IMPORT void delete_widget(W w)
Definition GameApi_gui.cc:9075

GameApi::GuiApi::canvas_item_gameapi_node
IMPORT W canvas_item_gameapi_node(int sx, int sy, std::string label, std::vector< std::string > param_types, std::vector< std::string > param_tooltips, std::string return_type, FtA atlas, BM atlas_bm, std::vector< W * > connect_click, std::string uid, std::vector< W > &params, std::string symbol, std::string comment)
Definition GameApi_gui.cc:4454

GameApi::GuiApi::floatvolumeapi_functions_item_label
IMPORT std::string floatvolumeapi_functions_item_label(int i)
Definition GameApi_gui.cc:8781

GameApi::GuiApi::center_align
IMPORT W center_align(W item, int sx)
Definition GameApi_gui.cc:5803

GameApi::GuiApi::poly
IMPORT W poly(P p, SH sh, int sx, int sy, int screen_size_x, int screen_size_y)
Definition GameApi_gui.cc:4695

GameApi::GuiApi::menu
IMPORT W menu(W main_menu, int menu_id, std::vector< std::string > labels, FtA atlas, BM atlas_bm)
Definition GameApi_gui.cc:6760

GameApi::GuiApi::set_id
IMPORT void set_id(W w, std::string id)
Definition GameApi_gui.cc:6972

GameApi::GuiApi::icon
IMPORT W icon(BM bitmap)
Definition GameApi_gui.cc:4670

GameApi::GuiApi::opengl_wrapper
IMPORT W opengl_wrapper(W widget)

GameApi::GuiApi::waveformapi_functions_item_label
IMPORT std::string waveformapi_functions_item_label(int i)
Definition GameApi_gui.cc:8693

GameApi::GuiApi::pointsapi_functions_list_item
IMPORT W pointsapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer)
Definition GameApi_gui.cc:8998

GameApi::GuiApi::get_child
IMPORT W get_child(W w, int i)
Definition GameApi_gui.cc:6914

GameApi::GuiApi::key_area
IMPORT W key_area(W widget, int area_x, int area_y, int area_width, int area_height, int key)
Definition GameApi_gui.cc:4097

GameApi::GuiApi::click_area
IMPORT W click_area(W widget, int area_x, int area_y, int area_width, int area_height, int button_id)
Definition GameApi_gui.cc:4091

GameApi::GuiApi::layout_rb
IMPORT W layout_rb(W item, int left, int top, int width, int height, int right, int bottom, int(*fptr_r)(void *), int(*fptr_b)(void *), void *ctx1, void *ctx2)
Definition GameApi_gui.cc:6095

GameApi::GuiApi::textureapi_functions_list_item
IMPORT W textureapi_functions_list_item(FtA font1, BM font1_bm, FtA font2, BM font2_bm, W insert, W *outer)
Definition GameApi_gui.cc:8946

GameApi::GuiApi::polygondistapi_functions_item_label
IMPORT std::string polygondistapi_functions_item_label(int i)
Definition GameApi_gui.cc:8767

GameApi::GuiApi::moveapi_functions_item_label
IMPORT std::string moveapi_functions_item_label(int i)
Definition GameApi_gui.cc:8834

GameApi::GuiApi::empty
IMPORT W empty()
Definition GameApi_gui.cc:3682

GameApi::GuiApi::generic_to_string
IMPORT void generic_to_string(const EditTypes &source, std::string type, std::string &target, std::string &expr)
Definition GameApi_gui.cc:5890

GameApi::GuiApi::float_editor
IMPORT W float_editor(float &target, std::string &target_expr, FtA atlas, BM atlas_bm, int x_gap, int noneditnum=0)
Definition GameApi_gui.cc:4748

GameApi::GuiApi::popup_box_menu
IMPORT W popup_box_menu(std::vector< std::string > options, FtA atlas, BM atlas_bm)
Definition GameApi.cc:17494

GameApi::GuiApi::highlight
IMPORT W highlight(int sx, int sy)
Definition GameApi_gui.cc:6071

GameApi::GuiApi::shadermoduleapi_functions_item_label
IMPORT std::string shadermoduleapi_functions_item_label(int i)
Definition GameApi_gui.cc:8724

GameApi::GuiApi::string_to_generic
IMPORT void string_to_generic(EditTypes &target, std::string type, const std::string &source, const std::string &expr)
Definition GameApi_gui.cc:5824

GameApi::GuiApi::color_editor
IMPORT W color_editor(std::string &col, FtA atlas, BM atlas_bm, int x_gap, int noneditnum, std::string &expr)
Definition GameApi_gui.cc:4951

GameApi::GuiApi::layout_lt
IMPORT W layout_lt(W item, int left, int top, int width, int height, int right, int bottom, int(*fptr_l)(void *), int(*fptr_t)(void *), void *ctx1, void *ctx2)
Definition GameApi_gui.cc:6085

GameApi::GuiApi::find_canvas_item
IMPORT W find_canvas_item(W canvas, std::string id)
Definition GameApi_gui.cc:3739

GameApi::GuiApi::string_editor
IMPORT W string_editor(std::string allowed_chars, std::string &target, std::string &target_expr, FtA atlas, BM atlas_bm, int x_gap, int non_editable, W *redraw_w, bool allow_expr=true)
Definition GameApi_gui.cc:4731

GameApi::GuiApi::left_align
IMPORT W left_align(W item, int sx)
Definition GameApi_gui.cc:5798

GameApi::GuiApi::popup_box
IMPORT W popup_box(std::string label, std::vector< std::string > options, FtA atlas, BM atlas_bm)
Definition GameApi.cc:17425

GameApi::GuiApi::chosen_item
IMPORT int chosen_item(W w)
Definition GameApi_gui.cc:6886

GameApi::GuiApi::url_editor
IMPORT W url_editor(std::string &target, FtA atlas, BM atlas_bm, int x_gap, std::string &expr, int noneditnum=0)
Definition GameApi_gui.cc:4759

GameApi::GuiApi::ml_dialog
IMPORT W ml_dialog(ML p, SH sh, SH sh2, SH sh_2d, SH sh_arr, int screen_size_x, int screen_size_y, W &close_button, FtA atlas, BM atlas_bm, W &codegen_button, W &collect_button)
Definition GameApi_gui.cc:5275

GameApi::GuiApi::enum_editor
IMPORT W enum_editor(EveryApi &ev, W &click_target, int &target, FtA atlas, BM atlas_bm, int x_gap, std::string type, std::string &expr, int noneditnum=0)
Definition GameApi_gui.cc:4793

GameApi::GuiApi::del_canvas_item
IMPORT void del_canvas_item(W canvas, int id)
Definition GameApi_gui.cc:3789

GameApi::ImplicitApi
Definition GameApi.hh:1649

GameApi::ImplicitApi::im_sphere
IMPORT IM im_sphere(float r)
Definition GameApi_imp.cc:42

GameApi::ImplicitApi::render_lower
IMPORT FB render_lower(IM obj, float size_x, float size_y, int sx, int sy, float dx, float dy)
Definition GameApi_imp.cc:270

GameApi::ImplicitApi::render_upper_color
IMPORT BM render_upper_color(IM obj, float size_x, float size_y, int sx, int sy, float dx, float dy)
Definition GameApi_imp.cc:286

GameApi::ImplicitApi::im_translate
IMPORT IM im_translate(IM obj, float dx, float dy, float dz)
Definition GameApi_imp.cc:131

GameApi::ImplicitApi::ImplicitApi
IMPORT ImplicitApi(Env &e)
Definition GameApi.cc:44487

GameApi::ImplicitApi::render_lower_color
IMPORT BM render_lower_color(IM obj, float size_x, float size_y, int sx, int sy, float dx, float dy)
Definition GameApi_imp.cc:281

GameApi::ImplicitApi::blob
IMPORT IM blob(float c, float c_x, float c_y, float cc_x, float cc_y)
Definition GameApi_imp.cc:85

GameApi::ImplicitApi::from_distance
IMPORT IM from_distance(FD fd, float pos_x, float pos_y, float pos_z, float u_x, float u_y, float u_z, float sx, float sy)
Definition GameApi_imp.cc:611

GameApi::ImplicitApi::from_distance_cyl
IMPORT IM from_distance_cyl(FD fd, float pos_x, float pos_y, float pos_z, float u_x, float u_y, float u_z, float sx, float sy)
Definition GameApi_imp.cc:616

GameApi::ImplicitApi::render_upper
IMPORT FB render_upper(IM obj, float size_x, float size_y, int sx, int sy, float dx, float dy)
Definition GameApi_imp.cc:275

GameApi::ImplicitApi::from_distance_sph
IMPORT IM from_distance_sph(FD fd, float pos_x, float pos_y, float pos_z, float u_x, float u_y, float u_z, float sx, float sy)
Definition GameApi_imp.cc:622

GameApi::InputApi::InputApi
IMPORT InputApi(Env &e)
Definition GameApi.cc:44492

GameApi::InteractionApi
Definition GameApi.hh:1803

GameApi::InteractionApi::wasd_movement_event
static IMPORT void wasd_movement_event(MainLoopApi::Event &e, float &pos_x, float &pos_y, Wasd_data &data, float speed_x, float speed_y)
Definition GameApi_in.cc:10

GameApi::InteractionApi::wasd_movement_frame
static IMPORT void wasd_movement_frame(MainLoopApi::Event &e, float &pos_x, float &pos_y, Wasd_data &data, float speed_x, float speed_y)
Definition GameApi_in.cc:23

GameApi::InteractionApi::quake_movement_frame
static IMPORT void quake_movement_frame(GameApi::EveryApi &ev, float &pos_x, float &pos_y, float &rot_y, Quake_data &data, float &speed_x, float &speed_y, float speed, float rot_speed)
Definition GameApi_in.cc:144

GameApi::InteractionApi::quake_movement_event
static IMPORT void quake_movement_event(GameApi::EveryApi &ev, MainLoopApi::Event &e, float &pos_x, float &pos_y, float &rot_y, Quake_data &data, float &speed_x, float &speed_y, float speed, float rot_speed)
Definition GameApi_in.cc:34

GameApi::LayoutApi::split_xy
LAY split_xy(LAY l, int id, int num_x, int num_y)
Definition GameApi_lay.cc:30

GameApi::LayoutApi::pos_y
int pos_y(LAY l, int id)
Definition GameApi_lay.cc:81

GameApi::LayoutApi::split_y
LAY split_y(LAY l, int id, int num)
Definition GameApi_lay.cc:12

GameApi::LayoutApi::LayoutApi
IMPORT LayoutApi(Env &e)
Definition GameApi.cc:44525

GameApi::LayoutApi::array
LAY array(LAY *array, int *id, int size)
Definition GameApi_lay.cc:57

GameApi::LayoutApi::root
LAY root(int sx, int sy)
Definition GameApi_lay.cc:4

GameApi::LayoutApi::count
int count(LAY l)
Definition GameApi_lay.cc:71

GameApi::LayoutApi::size_y
int size_y(LAY l, int id)
Definition GameApi_lay.cc:92

GameApi::LayoutApi::size_x
int size_x(LAY l, int id)
Definition GameApi_lay.cc:87

GameApi::LayoutApi::center
LAY center(LAY l, int id, int content_size_x, int content_size_y)
Definition GameApi_lay.cc:48

GameApi::LayoutApi::size
LAY size(LAY l, int id, int lx, int size_x, int ty, int size_y)

GameApi::LayoutApi::root_sx
int root_sx(LAY l)

GameApi::LayoutApi::pos_x
int pos_x(LAY l, int id)
Definition GameApi_lay.cc:76

GameApi::LayoutApi::split_x
LAY split_x(LAY l, int id, int num)
Definition GameApi_lay.cc:21

GameApi::LayoutApi::root_sy
int root_sy(LAY l)

GameApi::LinesApi
Definition GameApi.hh:4165

GameApi::LinesApi::change_color2
IMPORT LI change_color2(LI li, unsigned int color_1, unsigned int color_2)
Definition GameApi_li.cc:33

GameApi::LinesApi::render_inst_ml2
IMPORT ML render_inst_ml2(EveryApi &ev, LI array, PTA pta, float linewidth)
Definition GameApi_li.cc:999

GameApi::LinesApi::point_array
IMPORT LI point_array(std::vector< PT > vec)
Definition GameApi_li.cc:1753

GameApi::LinesApi::prepare_inst_matrix
IMPORT void prepare_inst_matrix(LLA array, MSA instances)
Definition GameApi_li.cc:1035

GameApi::LinesApi::lines_from_quads
IMPORT LI lines_from_quads(P p, int sx, int sy)
Definition GameApi.cc:33161

GameApi::LinesApi::li_url
IMPORT LI li_url(std::string url)
Definition GameApi_li.cc:2713

GameApi::LinesApi::border_from_bool_bitmap
IMPORT LI border_from_bool_bitmap(BB b, float start_x, float end_x, float start_y, float end_y, float z)
Definition GameApi_li.cc:450

GameApi::LinesApi::from_points2
IMPORT LI from_points2(PTS start_points, PTS end_points)
Definition GameApi_li.cc:1659

GameApi::LinesApi::render_slice_2d
IMPORT LI render_slice_2d(P p, PT pos, V u_x, V u_y)
Definition GameApi_li.cc:328

GameApi::LinesApi::render_ml
IMPORT ML render_ml(EveryApi &ev, LLA array, float linewidth)
Definition GameApi_li.cc:987

GameApi::LinesApi::li_url_nr
IMPORT LI li_url_nr(std::string url)
Definition GameApi_li.cc:2719

GameApi::LinesApi::li_empty
IMPORT LI li_empty()
Definition GameApi_li.cc:883

GameApi::LinesApi::split_lines
IMPORT LI split_lines(LI lines, float dist)
Definition GameApi_li.cc:1893

GameApi::LinesApi::li_or_elem
IMPORT LI li_or_elem(LI li1, LI li2)
Definition GameApi_li.cc:2388

GameApi::LinesApi::update_ml
IMPORT ML update_ml(LLA la, LI l)
Definition GameApi_li.cc:1313

GameApi::LinesApi::pts_line_anim2
IMPORT PTS pts_line_anim2(LI lines, std::function< float(int)> f)
Definition GameApi_li.cc:1389

GameApi::LinesApi::twist_y
IMPORT LI twist_y(LI lines, float y_0, float angle_per_y_unit)
Definition GameApi_li.cc:1922

GameApi::LinesApi::pos_choose
IMPORT LI pos_choose(EveryApi &ev, FB bm, float pos, float start_x, float end_x, float start_y, float end_y, float z)
Definition GameApi_bm.cc:9604

GameApi::LinesApi::li_or_array
IMPORT LI li_or_array(std::vector< LI > vec)
Definition GameApi_li.cc:2158

GameApi::LinesApi::from_points
IMPORT LI from_points(PC points, bool loops)
Definition GameApi_li.cc:174

GameApi::LinesApi::render_inst
IMPORT void render_inst(LLA array, PTA instances)
Definition GameApi_li.cc:1060

GameApi::LinesApi::render_ml2
IMPORT ML render_ml2(EveryApi &ev, LI array, float linewidth)
Definition GameApi_li.cc:991

GameApi::LinesApi::prepare
IMPORT LLA prepare(LI l)
Definition GameApi_li.cc:1534

GameApi::LinesApi::random_angle
IMPORT LI random_angle(LI lines, float max_angle)
Definition GameApi_li.cc:2074

GameApi::LinesApi::render_inst_ml3_matrix
IMPORT ML render_inst_ml3_matrix(EveryApi &ev, LI array, MS pts, float linewidth)
Definition GameApi_li.cc:1007

GameApi::LinesApi::import_ifc
IMPORT LI import_ifc(EveryApi &ev, std::string url)

GameApi::LinesApi::prepare_inst
IMPORT void prepare_inst(LLA array, PTA instances)
Definition GameApi_li.cc:1012

GameApi::LinesApi::update
IMPORT void update(LLA la, LI l)
Definition GameApi_li.cc:1399

GameApi::LinesApi::translate
IMPORT LI translate(LI lines, float dx, float dy, float dz)
Definition GameApi_li.cc:303

GameApi::LinesApi::random_mesh_quad_lines
IMPORT LI random_mesh_quad_lines(EveryApi &ev, P p, int count)
Definition GameApi_li.cc:1989

GameApi::LinesApi::rotz
IMPORT LI rotz(LI lines, float angle)
Definition GameApi_li.cc:318

GameApi::LinesApi::from_plane
IMPORT LI from_plane(PL plane)
Definition GameApi_li.cc:165

GameApi::LinesApi::render_inst_ml
IMPORT ML render_inst_ml(EveryApi &ev, LLA array, PTA pta, float linewidth)
Definition GameApi_li.cc:995

GameApi::LinesApi::color_function
IMPORT LI color_function(LI lines, std::function< unsigned int(int linenum, bool id)> f)
Definition GameApi_li.cc:58

GameApi::LinesApi::from_polygon
IMPORT LI from_polygon(P poly)
Definition GameApi_li.cc:377

GameApi::LinesApi::render_inst_ml3
IMPORT ML render_inst_ml3(EveryApi &ev, LI array, PTS pts, float linewidth)
Definition GameApi_li.cc:1003

GameApi::LinesApi::change_color
IMPORT LI change_color(LI li, unsigned int color)
Definition GameApi_li.cc:28

GameApi::LinesApi::from_polygon2
IMPORT LI from_polygon2(P poly1, P poly2)
Definition GameApi_li.cc:183

GameApi::LinesApi::rotx
IMPORT LI rotx(LI lines, float angle)
Definition GameApi_li.cc:308

GameApi::LinesApi::fur
IMPORT LI fur(PTS pts, PT center, float dist)
Definition GameApi_li.cc:1982

GameApi::LinesApi::unit_to_flex
IMPORT LI unit_to_flex(LI orig, PT bTL, PT bTR, PT bBL, PT bBR, PT fTL, PT fTR, PT fBL, PT fBR)

GameApi::LinesApi::scale
IMPORT LI scale(LI lines, float m_x, float m_y, float m_z)
Definition GameApi_li.cc:323

GameApi::LinesApi::roty
IMPORT LI roty(LI lines, float angle)
Definition GameApi_li.cc:313

GameApi::LinesApi::p_towards_normal
IMPORT P p_towards_normal(P p, float amount)
Definition GameApi_li.cc:2521

GameApi::LinesApi::line_pos_mult
IMPORT LI line_pos_mult(float val, LI li)
Definition GameApi_li.cc:2335

GameApi::LinesApi::li_bevel
IMPORT LI li_bevel(LI li, P p, float mix)
Definition GameApi_li.cc:2442

GameApi::LinesApi::normals_from_polygon
IMPORT LI normals_from_polygon(P poly, float length)
Definition GameApi_li.cc:269

GameApi::LinesApi::render_inst_matrix
IMPORT void render_inst_matrix(LLA array, MSA instances)
Definition GameApi_li.cc:1125

GameApi::LinesApi::li_matrix
IMPORT LI li_matrix(LI lines, M matrix)
Definition GameApi_li.cc:297

GameApi::LinesApi::alt
IMPORT LI alt(std::vector< LI > v, int index)
Definition GameApi_pl.cc:14372

GameApi::LinesApi::LinesApi
IMPORT LinesApi(Env &e)
Definition GameApi.cc:44519

GameApi::LinesApi::ml_li_render
IMPORT ML ml_li_render(EveryApi &ev, LI l, float linewidth)
Definition GameApi_li.cc:1526

GameApi::LinesApi::line_anim
IMPORT P line_anim(P poly, LI lines_from_polygon2, float val)
Definition GameApi_li.cc:367

GameApi::LinesApi::pts_line_anim
IMPORT PTS pts_line_anim(LI lines, float val)
Definition GameApi_li.cc:1379

GameApi::LinesApi::unit_to_cube
IMPORT LI unit_to_cube(LI orig, PT pos, V u_x, V u_y, V u_z)

GameApi::LinesApi::line_product
IMPORT P line_product(LI lines1, LI lines2)
Definition GameApi_li.cc:1726

GameApi::LinesApi::unit_cube
IMPORT LI unit_cube(LI orig, PT pos, V u_x, V u_y, V u_z)

GameApi::LinesObj::set_scale
void set_scale(float mult_x, float mult_y, float mult_z)
Definition GameApi.hh:5738

GameApi::LinesObj::set_var
void set_var(std::string name, float r, float g, float b, float a)
Definition GameApi.hh:5753

GameApi::LinesObj::prepare
void prepare(bool keep=false)
Definition GameApi.hh:5727

GameApi::LinesObj::render
void render()
Definition GameApi.hh:5728

GameApi::LinesObj::LinesObj
LinesObj(EveryApi &ev, LI li, SH sh)
Definition GameApi.hh:5718

GameApi::LinesObj::set_rotation_matrix2
void set_rotation_matrix2(M m)
Definition GameApi.hh:5748

GameApi::LinesObj::set_rotation_matrix
void set_rotation_matrix(M m)
Definition GameApi.hh:5743

GameApi::LinesObj::set_pos
void set_pos(float pos_x, float pos_y, float pos_z)
Definition GameApi.hh:5733

GameApi::LowFrameBufferApi
Definition GameApi.hh:4545

GameApi::LowFrameBufferApi::low_activate_snapshot
IMPORT FML low_activate_snapshot(EveryApi &ev, FML ml, int key, MN move, float duration, FML next)
Definition GameApi.cc:36642

GameApi::LowFrameBufferApi::qml_create_node
IMPORT FML qml_create_node(std::string url)
Definition GameApi_qt.cc:429

GameApi::LowFrameBufferApi::w_bitmap
IMPORT W w_bitmap(BM bm)
Definition GameApi.cc:39043

GameApi::LowFrameBufferApi::LowFrameBufferApi
IMPORT LowFrameBufferApi(Env &e)
Definition GameApi.cc:44523

GameApi::LowFrameBufferApi::low_frame_bitmap
IMPORT BM low_frame_bitmap(FML ml, int sx, int sy)
Definition GameApi.cc:36567

GameApi::LowFrameBufferApi::low_sprite_array
IMPORT FML low_sprite_array(std::string name, std::string url, std::vector< BM > bms, MN mn, int x, int y, int fmt, float start_time)
Definition GameApi.cc:35313

GameApi::LowFrameBufferApi::w_root
IMPORT FML w_root(GameApi::EveryApi &ev, GameApi::W wd)
Definition GameApi.cc:38859

GameApi::LowFrameBufferApi::w_text
IMPORT W w_text(EveryApi &ev, Ft font, std::string str, int x_gap, float baseline)
Definition GameApi.cc:39094

GameApi::LowFrameBufferApi::w_layout
IMPORT W w_layout(std::vector< W > vec, std::string url)
Definition GameApi.cc:38866

GameApi::LowFrameBufferApi::low_poly_draw
IMPORT FML low_poly_draw(std::string name, P p, MN mn)
Definition GameApi.cc:33923

GameApi::LowFrameBufferApi::low_collision
IMPORT FML low_collision(FML ml, float start_x, float end_x, float start_y, float end_y, int key)
Definition GameApi.cc:36531

GameApi::LowFrameBufferApi::qml_print
IMPORT FML qml_print(std::string url)
Definition GameApi_qt.cc:382

GameApi::LowFrameBufferApi::w_rect
IMPORT W w_rect(unsigned int color)
Definition GameApi.cc:38966

GameApi::LowFrameBufferApi::low_build_world
IMPORT FML low_build_world(FML ml, std::string url, std::string chars, int x, int y)
Definition GameApi.cc:35877

GameApi::LowFrameBufferApi::low_scroll_world
IMPORT FML low_scroll_world(FML ml, float speed_x, float speed_y, float p_x, float p_y, float left_offset, float right_offset, float height, float height2, int mode, int jump_frames)
Definition GameApi.cc:35765

GameApi::LowFrameBufferApi::low_render_world
IMPORT FML low_render_world(std::vector< BM > blocks, int screen_width, int screen_height, int fmt)
Definition GameApi.cc:35551

GameApi::LowFrameBufferApi::low_sprite_draw
IMPORT FML low_sprite_draw(std::string name, BM bm, MN mn, int x, int y, int fmt, float start_time)
Definition GameApi.cc:33741

GameApi::LowFrameBufferApi::low_key_bm_prepare
IMPORT FML low_key_bm_prepare(FML ml, BM bm, int key, FML normal, float duration, FML next)
Definition GameApi.cc:36633

GameApi::LowFrameBufferApi::low_enemy_draw
IMPORT FML low_enemy_draw(BM bm, std::string url, int fmt, float speed)
Definition GameApi.cc:36339

GameApi::LowFrameBufferApi::low_enemy_draw2
IMPORT FML low_enemy_draw2(std::vector< BM > bm, std::string url, int fmt, float speed, int time_delta, int time_duration)
Definition GameApi.cc:36458

GameApi::LowFrameBufferApi::low_framebuffer
IMPORT FBU low_framebuffer(FML mainloop, int format, int width, int height, int depth)
Definition GameApi.cc:36233

GameApi::LowFrameBufferApi::low_framebuffer_run
IMPORT RUN low_framebuffer_run(EveryApi &ev, FBU buffer, int mode, int scr_x, int scr_y)
Definition GameApi.cc:33593

GameApi::MainLoopApi
Definition GameApi.hh:442

GameApi::MainLoopApi::mouse_roll_zoom
IMPORT ML mouse_roll_zoom(EveryApi &ev, ML next)
Definition GameApi_pl.cc:26419

GameApi::MainLoopApi::timed_shp_p3d
IMPORT SHP timed_shp_p3d(float start_time, float end_time, SHP next, int num, PT start_value, PT end_value)
Definition cpushader.cc:327

GameApi::MainLoopApi::random_point_3d
IMPORT PT random_point_3d(float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)
Definition GameApi_main.cc:314

GameApi::MainLoopApi::mouse_roll_zoom2
IMPORT ML mouse_roll_zoom2(EveryApi &ev, ML nect)
Definition GameApi_pl.cc:26424

GameApi::MainLoopApi::lod_gpu_matrix
GameApi::ML lod_gpu_matrix(GameApi::EveryApi &ev, GameApi::P p, GameApi::MT mat, GameApi::MS ms, float level1_tri, float level1_quad, float level1_polygon, float level2_tri, float level2_quad, float level2_polygon, float level3_tri, float level3_quad, float level3_polygon, float level4_tri, float level4_quad, float level4_polygon, int l1, int l2, int l3, int l4)
Definition GameApi.cc:44656

GameApi::MainLoopApi::~MainLoopApi
IMPORT ~MainLoopApi()
Definition GameApi_main.cc:31

GameApi::MainLoopApi::save_script
IMPORT ML save_script(HML h, std::string filename)
Definition GameApi.cc:26906

GameApi::MainLoopApi::activate_array
IMPORT ML activate_array(std::vector< ML > vec)
Definition GameApi.cc:39604

GameApi::MainLoopApi::score_hide_pts
IMPORT PTS score_hide_pts(PTS pts)
Definition GameApi.cc:32987

GameApi::MainLoopApi::array_timing_chain_key_ml
IMPORT ML array_timing_chain_key_ml(EveryApi &ev, int key, float time_after_key, std::string durations, std::vector< ML > vec, int repeat)
Definition GameApi_main.cc:4550

GameApi::MainLoopApi::concurrent_download
IMPORT ML concurrent_download(ML ml)
Definition GameApi_main.cc:4870

GameApi::MainLoopApi::load_ds_from_temp3
IMPORT void load_ds_from_temp3(std::string filename)
Definition GameApi.cc:31979

GameApi::MainLoopApi::flip_scene_x_if_mobile
IMPORT ML flip_scene_x_if_mobile(EveryApi &ev, ML ml)
Definition GameApi.cc:39770

GameApi::MainLoopApi::outline_disable
IMPORT void outline_disable()
Definition GameApi_main.cc:1255

GameApi::MainLoopApi::slow_activate_item
IMPORT ML slow_activate_item(ML ml, int i)
Definition GameApi.cc:39665

GameApi::MainLoopApi::outline_first
IMPORT void outline_first()
Definition GameApi_main.cc:1223

GameApi::MainLoopApi::display_background
IMPORT ML display_background(EveryApi &ev, ML ml, bool is_logo=false)
Definition GameApi_main.cc:2975

GameApi::MainLoopApi::get_screen_rect_sx
IMPORT int get_screen_rect_sx()
Definition GameApi_main.cc:746

GameApi::MainLoopApi::gltf_anim_skeleton
IMPORT ARR gltf_anim_skeleton(EveryApi &ev, TF model0, int skin_num, int animation, int channelk, int num_keyframes)

GameApi::MainLoopApi::cache_one
IMPORT CX cache_one(P p, MT mt)
Definition GameApi_pl.cc:27476

GameApi::MainLoopApi::depthmask
IMPORT ML depthmask(ML ml, bool b)
Definition GameApi_main.cc:3694

GameApi::MainLoopApi::framebuffer_bitmap
IMPORT BM framebuffer_bitmap(FBU framebuffer)
Definition GameApi.cc:35912

GameApi::MainLoopApi::save_gltf
IMPORT ML save_gltf(TF tf, std::string filename)
Definition GameApi_gltf.cc:15650

GameApi::MainLoopApi::move_collision
IMPORT INP move_collision(IBM scene, float start_x, float end_x, float start_y, float end_y, float s_x, float m_x, float e_x, float s_y, float m_y, float e_y, float speed_up, float speed_down, float speed_left, float speed_right, float speed_gravity)
Definition GameApi.cc:32491

GameApi::MainLoopApi::load_ds_from_mem
IMPORT DS load_ds_from_mem(const unsigned char *buf, const unsigned char *end)
Definition GameApi.cc:32000

GameApi::MainLoopApi::timing_start
IMPORT TT timing_start()
Definition GameApi_main.cc:4499

GameApi::MainLoopApi::random_dir_vector_2d_xz
IMPORT V random_dir_vector_2d_xz(float length)
Definition GameApi_main.cc:348

GameApi::MainLoopApi::setup_hmd_projection
IMPORT ML setup_hmd_projection(EveryApi &ev, ML ml, bool eye, bool is_standard, float n, float f, bool translate)
Definition GameApi_vr.cc:724

GameApi::MainLoopApi::timed_tmp_seq_ml
IMPORT ML timed_tmp_seq_ml(ML curr, ML end, float start_time, float end_time, float show_duration, int key)
Definition GameApi_main.cc:2036

GameApi::MainLoopApi::tf_join
IMPORT TF tf_join(EveryApi &ev, TF tf)
Definition GameApi_gltf.cc:17457

GameApi::MainLoopApi::delay
IMPORT void delay(int ms)
Definition GameApi_main.cc:300

GameApi::MainLoopApi::tunnel_tree
IMPORT ML tunnel_tree(EveryApi &ev, std::vector< P > faces, std::vector< MN > moves, std::string url, MT mat2)
Definition GameApi.cc:43838

GameApi::MainLoopApi::save_png_store
IMPORT void save_png_store(std::string filename, BM bm)
Definition Main.cc:1746

GameApi::MainLoopApi::timing
IMPORT TT timing(float duration, TT link, ML show)
Definition GameApi_main.cc:4812

GameApi::MainLoopApi::waittof
IMPORT void waittof()

GameApi::MainLoopApi::activate_arr_arr
IMPORT ARR activate_arr_arr(std::vector< ML > arr)
Definition GameApi.cc:39675

GameApi::MainLoopApi::timing_event
IMPORT TT timing_event(IF fetch, TT timing, ML show)
Definition GameApi_main.cc:4804

GameApi::MainLoopApi::print_deps
IMPORT ML print_deps(ML ml, int num)
Definition GameApi.cc:44341

GameApi::MainLoopApi::img_decode
IMPORT BM img_decode(MB memblock)
Definition GameApi.cc:42407

GameApi::MainLoopApi::emscripten_frame
IMPORT HML emscripten_frame(EveryApi &ev, RUN r, std::string homepage)

GameApi::MainLoopApi::get_time
IMPORT float get_time()
Definition GameApi_main.cc:1004

GameApi::MainLoopApi::gltf_anim4
IMPORT ML gltf_anim4(EveryApi &ev, TF model0, int animation, int channel, float mix, float self_mult, float rest_mult, int mode, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool acesfilm, bool emissive, int frame_skip, int lod_level)
Definition GameApi_gltf.cc:13610

GameApi::MainLoopApi::disable_z_buffer
IMPORT ML disable_z_buffer(ML ml)
Definition GameApi_main.cc:4148

GameApi::MainLoopApi::cursorkeys_to_wasd
IMPORT ML cursorkeys_to_wasd(ML ml)
Definition GameApi.cc:44474

GameApi::MainLoopApi::load_midi
IMPORT ML load_midi(EveryApi &ev, ML next, std::string url, std::string url_patchset)
Definition GameApi_main.cc:3527

GameApi::MainLoopApi::generic_shader_fragment_only
IMPORT ML generic_shader_fragment_only(EveryApi &ev, ML ml, SHI fragment, std::vector< TXID > vec)
Definition cpushader.cc:912

GameApi::MainLoopApi::lod_anim
GameApi::ML lod_anim(GameApi::EveryApi &ev, GameApi::TF tf, GameApi::PTS pts, float level1, float level2, float level3, float level4, int l1, int l2, int l3, int l4, float mix, float self_mult, float rest_mult, int mode, std::string keys, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, int start_anim_seq, bool emissive, int frame_skip)
Definition GameApi.cc:44552

GameApi::MainLoopApi::read_obj_pos
IMPORT ML read_obj_pos(std::string url)
Definition GameApi.cc:41412

GameApi::MainLoopApi::load_BM_script_array
IMPORT ARR load_BM_script_array(EveryApi &ev, std::string url, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5)
Definition GameApi.cc:30439

GameApi::MainLoopApi::time_display
IMPORT ML time_display(EveryApi &ev, ML ml, std::string font, float start_time)
Definition GameApi.cc:26504

GameApi::MainLoopApi::lod_matrix
IMPORT ML lod_matrix(EveryApi &ev, P p, MT mat, MS ms, float level1, float level2, float level3, float level4, int l1, int l2, int l3, int l4)
Definition GameApi.cc:44662

GameApi::MainLoopApi::drag_drop_area
IMPORT ML drag_drop_area(EveryApi &ev, ML mainloop, RUN(*fptr)(Env &e, EveryApi &ev, std::string filename))
Definition GameApi.cc:38770

GameApi::MainLoopApi::emscripten_frame2_MN
IMPORT HML emscripten_frame2_MN(EveryApi &ev, MN mn, std::string homepage)
Definition GameApi.cc:40127

GameApi::MainLoopApi::create_objs
IMPORT ML create_objs(EveryApi &ev, int area_id)
Definition GameApi.cc:41645

GameApi::MainLoopApi::gltf_mesh_all_anim
IMPORT ML gltf_mesh_all_anim(EveryApi &ev, TF model0, float mix, float self_mult, float rest_mult, int mode, std::string keys, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, int start_anim_seq, bool emissive, int frame_skip, int lod_level)
Definition GameApi_gltf.cc:11966

GameApi::MainLoopApi::alpha_1
void alpha_1(bool enabled)
Definition GameApi_main.cc:926

GameApi::MainLoopApi::matrix_range_check
IMPORT ML matrix_range_check(EveryApi &ev, ML ml, ML ml2, std::string url)
Definition GameApi.cc:39929

GameApi::MainLoopApi::scale_2d_screen
IMPORT ML scale_2d_screen(EveryApi &ev, ML orig, float sx, float sy)
Definition GameApi.cc:26277

GameApi::MainLoopApi::check_glerrors
IMPORT void check_glerrors(std::string context)
Definition GameApi_main.cc:1082

GameApi::MainLoopApi::hires_ml
IMPORT ML hires_ml(EveryApi &ev, ML I3, int size, int numsamples, float blur_radius)
Definition GameApi.cc:8905

GameApi::MainLoopApi::clear
IMPORT void clear(unsigned int col=0xff000000)
Definition GameApi_main.cc:829

GameApi::MainLoopApi::lod
IMPORT ML lod(EveryApi &ev, P p, MT mat, PTS pts, float level1, float level2, float level3, float level4, int l1, int l2, int l3, int l4)
Definition GameApi.cc:44638

GameApi::MainLoopApi::gs_obj_pos
IMPORT ML gs_obj_pos(GS gs, ML ml, int x, int y, int z)
Definition GameApi.cc:44144

GameApi::MainLoopApi::bytestore_pts
IMPORT PTS bytestore_pts(BS bs, PTS pts, char disable_char, char enable_char, bool default_is_enable)
Definition GameApi_pl.cc:29691

GameApi::MainLoopApi::set_viewport
IMPORT void set_viewport(int x, int y, int sx, int sy)
Definition GameApi_main.cc:2750

GameApi::MainLoopApi::fpscounter_swapbuffersready
IMPORT void fpscounter_swapbuffersready()
Definition GameApi_main.cc:451

GameApi::MainLoopApi::generic_anim_shader
IMPORT SHI generic_anim_shader(SHP, std::string, std::string, std::vector< SHI > children)
Definition cpushader.cc:1572

GameApi::MainLoopApi::screenshot
IMPORT BM screenshot()
Definition GameApi_main.cc:1041

GameApi::MainLoopApi::right_mouse_pan
IMPORT ML right_mouse_pan(EveryApi &ev, ML next)
Definition GameApi_pl.cc:26489

GameApi::MainLoopApi::perspective
IMPORT ML perspective(EveryApi &ev, ML next, float mult, float front_plane, float end_plane)
Definition GameApi_pl.cc:26251

GameApi::MainLoopApi::fpscounter_frameready
IMPORT void fpscounter_frameready()
Definition GameApi_main.cc:441

GameApi::MainLoopApi::load_zip_assets
IMPORT ML load_zip_assets(std::string zip_url)
Definition GameApi_gltf.cc:16432

GameApi::MainLoopApi::score_adder
IMPORT ML score_adder(EveryApi &ev, ML ml, O o, MN transform, int enter_score, int leave_score, int dyn_point, float timeout)
Definition GameApi.cc:32911

GameApi::MainLoopApi::is_gltf_animated
IMPORT bool is_gltf_animated(EveryApi &ev, TF tf)
Definition GameApi.cc:45734

GameApi::MainLoopApi::gltf_mesh_all_parr
IMPORT ARR gltf_mesh_all_parr(EveryApi &ev, TF model0, float mix, float light_dir_x, float light_dir_y, float light_dir_z, int skin_num)

GameApi::MainLoopApi::array_fml
IMPORT FML array_fml(std::vector< FML > vec)
Definition GameApi_main.cc:2811

GameApi::MainLoopApi::antialias
IMPORT void antialias(bool enabled)
Definition GameApi_main.cc:948

GameApi::MainLoopApi::gltf_loadKK
IMPORT TF gltf_loadKK(std::string base_url, std::string url)
Definition GameApi_gltf.cc:15666

GameApi::MainLoopApi::state_int_fetcher
IMPORT IF state_int_fetcher(std::string url, std::string states)
Definition GameApi.cc:35049

GameApi::MainLoopApi::init_window
IMPORT void init_window(int screen_width=800, int screen_height=600, std::string window_title="meshpage.org -- the next technology level for web", bool vr_init=false)
Definition GameApi_main.cc:96

GameApi::MainLoopApi::gltf_mesh_all_parr_mat
IMPORT std::vector< GameApi::MT > gltf_mesh_all_parr_mat(EveryApi &ev, TF model0, float mix, float light_x, float light_y, float light_z, int skin_num)

GameApi::MainLoopApi::send_key_at_time
IMPORT ML send_key_at_time(ML ml, float time, int key)
Definition GameApi_main.cc:4188

GameApi::MainLoopApi::gltf_mesh_all_p_arr
IMPORT ARR gltf_mesh_all_p_arr(GameApi::EveryApi &ev, TF model0, float light_dir_x, float light_dir_y, float light_dir_z, bool transparent, bool emissive, int lod_level)
Definition GameApi_gltf.cc:11786

GameApi::MainLoopApi::random_dir_vector_2d_xy
IMPORT V random_dir_vector_2d_xy(float length)
Definition GameApi_main.cc:337

GameApi::MainLoopApi::load_MN_script
IMPORT MN load_MN_script(EveryApi &ev, std::string url, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5)
Definition GameApi.cc:30199

GameApi::MainLoopApi::double_instancing_matrix
IMPORT ML double_instancing_matrix(EveryApi &ev, P p, MS static_ms, MS real_ms, MT mat)
Definition GameApi_pl.cc:31708

GameApi::MainLoopApi::turn_to_meters
IMPORT ML turn_to_meters(EveryApi &ev, ML ml, float sx1, float sx2, float sy1, float sy2, float sz1, float sz2)
Definition GameApi_sp.cc:422

GameApi::MainLoopApi::gravity
IMPORT INP gravity(INP im, IBM bitmap, float start_x, float end_x, float start_y, float end_y, float speed)
Definition GameApi.cc:32610

GameApi::MainLoopApi::random_point_2d
IMPORT PT random_point_2d(float start_x, float end_x, float start_y, float end_y, float z)
Definition GameApi_main.cc:326

GameApi::MainLoopApi::load_ML_script2
IMPORT ML load_ML_script2(EveryApi &ev, HML h, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5)
Definition GameApi.cc:30188

GameApi::MainLoopApi::load_um
IMPORT PKG load_um(DS st)
Definition GameApi.cc:42498

GameApi::MainLoopApi::call_execute_hack
IMPORT void call_execute_hack(ML ml)
Definition GameApi.cc:32005

GameApi::MainLoopApi::bytestore_array
IMPORT ML bytestore_array(EveryApi &ev, BS store, std::string url, float delta_time)
Definition GameApi_pl.cc:29528

GameApi::MainLoopApi::ml_empty
IMPORT ML ml_empty()
Definition GameApi_gltf.cc:11931

GameApi::MainLoopApi::clear_3d_transparent
IMPORT void clear_3d_transparent()
Definition GameApi_main.cc:853

GameApi::MainLoopApi::random_dir_vector_3d
IMPORT V random_dir_vector_3d(float length)
Definition GameApi_main.cc:360

GameApi::MainLoopApi::get_delta_time
IMPORT float get_delta_time()
Definition GameApi_main.cc:1011

GameApi::MainLoopApi::fullscreen_button
IMPORT ML fullscreen_button(EveryApi &ev)
Definition GameApi_fnt.cc:2869

GameApi::MainLoopApi::gltf_mesh_all_msarr
IMPORT ARR gltf_mesh_all_msarr(EveryApi &ev, TF model0, int skin_num)

GameApi::MainLoopApi::start_editor_state
IMPORT void start_editor_state()
Definition GameApi_main.cc:525

GameApi::MainLoopApi::event_ml
IMPORT void event_ml(ML ml, const Event &e)
Definition GameApi_main.cc:2220

GameApi::MainLoopApi::in_P
IMPORT M in_P(EveryApi &ev, bool is_3d)
Definition GameApi_main.cc:3303

GameApi::MainLoopApi::print_profile
IMPORT void print_profile()
Definition GameApi_main.cc:406

GameApi::MainLoopApi::restart_game
IMPORT ML restart_game(EveryApi &ev, ML ml, int key)
Definition GameApi.cc:39820

GameApi::MainLoopApi::choose_ml_from_status
IMPORT ML choose_ml_from_status(ML connect, ML download, ML prepare)
Definition GameApi_main.cc:3038

GameApi::MainLoopApi::get_screen_sx
IMPORT int get_screen_sx()
Definition GameApi_main.cc:762

GameApi::MainLoopApi::game
IMPORT ML game(EveryApi &ev, int tile_sx, int tile_sy, std::string url, std::string url2, std::string url3, std::string url4, std::string tiles_string, std::string tiles_string2, int start_pos_x, int start_pos_y, int player_start_tile, int player_end_tile, BM tile_bm, BM player_bm, BM ruohikko_bm, BM corn_bm, BM vesisade_bm, BM jump_bm, FI font, BM status_bm, BM splash, std::vector< BM > item_types, std::vector< BM > enemy_types, BM weapon_bm, std::vector< BM > enemy_child_death, BM aku_death)
Definition GameApi_bm.cc:8981

GameApi::MainLoopApi::switch_to_3d
IMPORT void switch_to_3d(bool b, SH sh, int screen_width=800., int screen_height=600)
Definition GameApi_main.cc:773

GameApi::MainLoopApi::gltf_scene_p
IMPORT P gltf_scene_p(GameApi::EveryApi &ev, TF model0, int scene_id)
Definition GameApi_gltf.cc:13505

GameApi::MainLoopApi::collision_detection
IMPORT ML collision_detection(EveryApi &ev, float player_size, float enemy_size, ML normal_game_screen, ML gameover_screen)
Definition GameApi_main.cc:2054

GameApi::MainLoopApi::in_MV
IMPORT M in_MV(EveryApi &ev, bool is_3d)
Definition GameApi_main.cc:3346

GameApi::MainLoopApi::whack_a_mole_collision
IMPORT ML whack_a_mole_collision(ML ml)
Definition GameApi.cc:42042

GameApi::MainLoopApi::transfer_id
IMPORT TRB transfer_id()
Definition GameApi_pl.cc:15330

GameApi::MainLoopApi::clear_3d
IMPORT void clear_3d(unsigned int col=0xff000000)
Definition GameApi_main.cc:862

GameApi::MainLoopApi::save_ds_store
IMPORT void save_ds_store(std::string filename, DS ds)
Definition GameApi.cc:32158

GameApi::MainLoopApi::gltf_mesh_all_anim_inst_matrix
IMPORT ML gltf_mesh_all_anim_inst_matrix(EveryApi &ev, TF model0, TF resize_obj, MS ms, float mix, float self_mult, float rest_mult, int mode, std::string keys, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, bool emissive, int anim_skip, int lod_level)
Definition GameApi_gltf.cc:11999

GameApi::MainLoopApi::phong_fragment
IMPORT SHI phong_fragment(SHI next, unsigned int ambient, unsigned int highlight, float pow)
Definition cpushader.cc:579

GameApi::MainLoopApi::load_P_script
IMPORT P load_P_script(EveryApi &ev, std::string url, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5)

GameApi::MainLoopApi::load_shader2
IMPORT ARR load_shader2(std::string vertex_url, std::string fragment_url)
Definition cpushader.cc:1461

GameApi::MainLoopApi::async_url
IMPORT ML async_url(std::string url, ML ml)
Definition GameApi_gui.cc:7922

GameApi::MainLoopApi::load_ds_from_disk_incrementally
IMPORT DS load_ds_from_disk_incrementally(std::string filename)
Definition GameApi.cc:30616

GameApi::MainLoopApi::score_hidder
IMPORT ML score_hidder(EveryApi &ev, ML ml, O o, int max_count)
Definition GameApi.cc:33048

GameApi::MainLoopApi::constant_shp_uvw
IMPORT SHP constant_shp_uvw(SHP next, int num, PT value)
Definition cpushader.cc:305

GameApi::MainLoopApi::load_song
IMPORT ML load_song(EveryApi &ev, ML next, std::string url)
Definition GameApi_main.cc:3444

GameApi::MainLoopApi::memmap_window2
IMPORT ML memmap_window2(EveryApi &ev, std::string url)
Definition GameApi.cc:43434

GameApi::MainLoopApi::load_ds_from_temp2
IMPORT DS load_ds_from_temp2(std::string filename)
Definition GameApi.cc:31974

GameApi::MainLoopApi::gs_mouse_pos
IMPORT ML gs_mouse_pos(GS gs, ML ml, int x, int y)
Definition GameApi.cc:44138

GameApi::MainLoopApi::gltf_anim2
IMPORT ML gltf_anim2(EveryApi &ev, TF model0, int animation, int channel)

GameApi::MainLoopApi::state_speed_movement
IMPORT MN state_speed_movement(MN mn, std::string url, std::string states, std::string x_speeds, std::string y_speeds, std::string z_speeds)
Definition GameApi.cc:35140

GameApi::MainLoopApi::lod_anim_matrix
GameApi::ML lod_anim_matrix(GameApi::EveryApi &ev, GameApi::TF tf, GameApi::MS ms, float level1, float level2, float level3, float level4, int l1, int l2, int l3, int l4, float mix, float self_mult, float rest_mult, int mode, std::string keys, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, int start_anim_seq, bool emissive, int frame_skip)
Definition GameApi.cc:44576

GameApi::MainLoopApi::chai_mainloop
IMPORT ML chai_mainloop(EveryApi &ev, std::string url)

GameApi::MainLoopApi::load_zip2
IMPORT HML load_zip2(EveryApi &ev, std::string zip_url)
Definition GameApi_gltf.cc:16829

GameApi::MainLoopApi::lod_matrix_tf
GameApi::ML lod_matrix_tf(GameApi::EveryApi &ev, GameApi::TF p, GameApi::MS ms, float level1, float level2, float level3, float level4, int l1, int l2, int l3, int l4, float mix, float selt_mult, float rest_mult, int mode, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, float start_brightness, float end_brightness, bool emissive)
Definition GameApi.cc:44813

GameApi::MainLoopApi::disable_resize
IMPORT ML disable_resize(ML ml)
Definition GameApi_pl.cc:14842

GameApi::MainLoopApi::gltf_load_sketchfab_zip
IMPORT TF gltf_load_sketchfab_zip(std::string url_to_zip)
Definition GameApi_gltf.cc:16872

GameApi::MainLoopApi::gltf_mesh_all_inst_matrix
IMPORT ML gltf_mesh_all_inst_matrix(EveryApi &ev, TF model0, TF resize_obj, MS ms, float mix, float self_mult, float rest_mult, int mode, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, std::string keys, bool emissive, int lod_level)
Definition GameApi_gltf.cc:11954

GameApi::MainLoopApi::swapbuffers
IMPORT void swapbuffers()
Definition GameApi_main.cc:1112

GameApi::MainLoopApi::save_logo
IMPORT void save_logo(EveryApi &ev)
Definition GameApi_main.cc:2824

GameApi::MainLoopApi::empty_shaderI
IMPORT SHI empty_shaderI()
Definition cpushader.cc:362

GameApi::MainLoopApi::lod_gpu
GameApi::ML lod_gpu(GameApi::EveryApi &ev, GameApi::P p, GameApi::MT mat, GameApi::PTS pts, float level1_tri, float level2_tri, float level3_tri, float level4_tri, int l1, int l2, int l3, int l4)
Definition GameApi.cc:44618

GameApi::MainLoopApi::timing_switch
IMPORT TT timing_switch(EveryApi &ev, float duration, TT link, ML show, ML show2, int switch_dir)
Definition GameApi_main.cc:4816

GameApi::MainLoopApi::AI_modified
IMPORT ML AI_modified(EveryApi &ev, ML ml, std::string url)
Definition GameApi.cc:46215

GameApi::MainLoopApi::record_keypresses
IMPORT ML record_keypresses(ML ml, std::string output_filename)
Definition GameApi_main.cc:3889

GameApi::MainLoopApi::set_homepage_url
IMPORT void set_homepage_url(std::string url)
Definition GameApi_main.cc:3367

GameApi::MainLoopApi::android_resize
IMPORT ML android_resize(EveryApi &ev, ML ml, float mult)
Definition GameApi.cc:44422

GameApi::MainLoopApi::move_sequence
IMPORT INP move_sequence(float start_time, float time_per_char, std::string str)
Definition GameApi.cc:32378

GameApi::MainLoopApi::playback_keypresses
IMPORT ML playback_keypresses(ML ml, std::string input_url)
Definition GameApi_main.cc:3960

GameApi::MainLoopApi::emscripten_frame2_MT
IMPORT HML emscripten_frame2_MT(EveryApi &ev, MT mt, std::string homepage)
Definition GameApi.cc:40093

GameApi::MainLoopApi::edit_3d_p
IMPORT P edit_3d_p(EveryApi &ev)
Definition GameApi.cc:44020

GameApi::MainLoopApi::anim_ML
IMPORT ML anim_ML(EveryApi &ev, std::string url, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5, IF dyn)
Definition GameApi.cc:30167

GameApi::MainLoopApi::load_MT_script
IMPORT MT load_MT_script(EveryApi &ev, std::string url, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5)
Definition GameApi.cc:30208

GameApi::MainLoopApi::dyn
IMPORT ML dyn(D d)
Definition GameApi_main.cc:4019

GameApi::MainLoopApi::timed_shp_u
IMPORT SHP timed_shp_u(float start_time, float end_time, SHP next, int num, unsigned int start_value, unsigned int end_value)
Definition cpushader.cc:322

GameApi::MainLoopApi::restart_screen
IMPORT ML restart_screen(EveryApi &ev, ML ml, std::string fontname)
Definition GameApi_main.cc:3808

GameApi::MainLoopApi::get_screen_sy
IMPORT int get_screen_sy()
Definition GameApi_main.cc:767

GameApi::MainLoopApi::gltf_mesh_all_inst
IMPORT ML gltf_mesh_all_inst(EveryApi &ev, TF model0, float mix, float light_dir_x, float light_dir_y, float light_dir_z, int skin_id)

GameApi::MainLoopApi::android_landscape_scale
IMPORT ML android_landscape_scale(EveryApi &ev, ML ml)
Definition GameApi_main.cc:2955

GameApi::MainLoopApi::memmap_window
IMPORT ML memmap_window(EveryApi &ev, PKG p)
Definition GameApi.cc:43099

GameApi::MainLoopApi::glb_to_download_bar
GameApi::ML glb_to_download_bar(TF tf, std::string filename)
Definition GameApi_gltf.cc:17265

GameApi::MainLoopApi::save_deploy
IMPORT ML save_deploy(HML h, std::string filename, GameApi::EveryApi &ev)
Definition GameApi.cc:28914

GameApi::MainLoopApi::load_shader
IMPORT SHC load_shader(std::string shader_url)
Definition cpushader.cc:1457

GameApi::MainLoopApi::double_instancing
IMPORT ML double_instancing(EveryApi &ev, P p, PTS static_inst, PTS real_inst, MT mat)
Definition GameApi_pl.cc:31701

GameApi::MainLoopApi::gltf_mesh_all_mt_arr
IMPORT ARR gltf_mesh_all_mt_arr(EveryApi &ev, TF model0, float mix, float self_mult, float rest_mult, float light_dir_x, float light_dir_y, float light_dir_z, bool transparent, bool emissive, int lod_level)
Definition GameApi_gltf.cc:11903

GameApi::MainLoopApi::constant_shp_i
IMPORT SHP constant_shp_i(SHP next, int num, int value)
Definition cpushader.cc:289

GameApi::MainLoopApi::emscripten_frame2
IMPORT HML emscripten_frame2(EveryApi &ev, RUN r, std::string homepage, bool is_envparams_arr=false)
Definition GameApi.cc:40232

GameApi::MainLoopApi::whack_a_mole_explosion
IMPORT PTS whack_a_mole_explosion(EveryApi &ev)
Definition GameApi.cc:42178

GameApi::MainLoopApi::get_event
IMPORT Event get_event()
Definition GameApi_main.cc:1350

GameApi::MainLoopApi::score_display
IMPORT ML score_display(EveryApi &ev, ML ml, std::string font)
Definition GameApi.cc:26439

GameApi::MainLoopApi::ds_to_string
IMPORT std::string ds_to_string(DS ds)
Definition GameApi.cc:32075

GameApi::MainLoopApi::face_fetcher
IMPORT UV face_fetcher(P p, int facenum)
Definition GameApi_fnt.cc:1581

GameApi::MainLoopApi::reset_time
IMPORT void reset_time()
Definition GameApi_main.cc:1024

GameApi::MainLoopApi::vr_scale
IMPORT ML vr_scale(ML ml, float)
Definition GameApi_vr.cc:51

GameApi::MainLoopApi::fpscounter_framestart
IMPORT void fpscounter_framestart()
Definition GameApi_main.cc:433

GameApi::MainLoopApi::fps_display
IMPORT ML fps_display(EveryApi &ev, ML ml, std::string font)
Definition GameApi.cc:26570

GameApi::MainLoopApi::emscripten_frame2_ML
IMPORT HML emscripten_frame2_ML(EveryApi &ev, ML ml, std::string homepage)
Definition GameApi.cc:40196

GameApi::MainLoopApi::phong_shader3
IMPORT ML phong_shader3(EveryApi &ev, ML ml, unsigned int ambient, unsigned int highlight, float pow)
Definition cpushader.cc:927

GameApi::MainLoopApi::progress_bar_config
IMPORT ML progress_bar_config(ML ml, bool progress_impl, bool max_impl, bool install_impl, float mult_ems0, float mult_ems1, float mult_ems2, float mult_builder)
Definition GameApi.cc:45924

GameApi::MainLoopApi::touch_rotate
IMPORT ML touch_rotate(EveryApi &ev, ML ml, bool leftright, bool topdown, float x_speed, float y_speed)
Definition GameApi.cc:26433

GameApi::MainLoopApi::in_T
IMPORT M in_T(EveryApi &ev, bool is_3d)
Definition GameApi_main.cc:3335

GameApi::MainLoopApi::dyn_points
IMPORT ML dyn_points(EveryApi &ev, ML ml, MN move, int pointnum, float pos_x, float pos_y, float pos_z)
Definition GameApi.cc:32696

GameApi::MainLoopApi::gltf_mesh_all_inst2
IMPORT ML gltf_mesh_all_inst2(EveryApi &ev, TF model0, TF resize_obj, PTS pts, float mix, float self_mult, float rest_mult, int mode, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, std::string keys, bool emissive, int lod_level)
Definition GameApi_gltf.cc:11948

GameApi::MainLoopApi::finish
IMPORT void finish()
Definition GameApi_main.cc:1077

GameApi::MainLoopApi::transparent
IMPORT ML transparent(ML ml)
Definition GameApi.cc:6285

GameApi::MainLoopApi::small_window
IMPORT ML small_window(EveryApi &ev, ML ml, int x, int y, int sx, int sy)
Definition GameApi.cc:38010

GameApi::MainLoopApi::get_frame_time
IMPORT float get_frame_time() const
Definition GameApi_main.cc:2573

GameApi::MainLoopApi::mesh_anim_2
ML mesh_anim_2(std::vector< P > time_range_start_mesh_array, std::vector< P > time_range_end_mesh_array, std::vector< MN > moves_array, std::vector< MT > materials_array, std::vector< MS > matrix_array_arrays, std::vector< IF > state_machines, std::string optional_time_range_duration_array_with_separators_float, std::string url_to_mp_file)
Definition GameApi.cc:45625

GameApi::MainLoopApi::depthfunc
IMPORT ML depthfunc(ML ml, int val)
Definition GameApi_main.cc:3688

GameApi::MainLoopApi::bytestore_render
IMPORT ML bytestore_render(EveryApi &ev, BS bs, std::vector< ML > mls, std::string url, float delta_x, float delta_y)
Definition GameApi_pl.cc:29646

GameApi::MainLoopApi::get_corner_x
IMPORT int get_corner_x()
Definition GameApi_main.cc:736

GameApi::MainLoopApi::joystick_printer
IMPORT ML joystick_printer(ML ml)
Definition GameApi_main.cc:2088

GameApi::MainLoopApi::end_editor_state
IMPORT void end_editor_state()
Definition GameApi_main.cc:531

GameApi::MainLoopApi::load_zip
IMPORT ML load_zip(EveryApi &ev, std::string zip_url)
Definition GameApi_gltf.cc:16856

GameApi::MainLoopApi::ml_load_um
IMPORT ML ml_load_um(EveryApi &ev, std::string url)
Definition GameApi.cc:42547

GameApi::MainLoopApi::cursor_keys_rotate_move
IMPORT INP cursor_keys_rotate_move(float speed_rot, float pos_forward, float pos_normal, float pos_backward)
Definition GameApi.cc:32374

GameApi::MainLoopApi::collision_gen_key
IMPORT ML collision_gen_key(ML curr, std::string obj1, std::string obj2, int key, float duration)
Definition GameApi_main.cc:2048

GameApi::MainLoopApi::async_gltf
IMPORT ML async_gltf(ML ml, TF tf)
Definition GameApi_gltf.cc:15468

GameApi::MainLoopApi::load_ML_script_array
IMPORT ARR load_ML_script_array(EveryApi &ev, std::string url, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5)
Definition GameApi.cc:30218

GameApi::MainLoopApi::screenspace_rendering
IMPORT ML screenspace_rendering(EveryApi &ev, ML scene, SMT screenspace_material)
Definition GameApi_main.cc:4283

GameApi::MainLoopApi::prepare_pts
IMPORT ML prepare_pts(ML ml, PTS pts)
Definition GameApi_main.cc:3615

GameApi::MainLoopApi::load_P_script_array
IMPORT ARR load_P_script_array(EveryApi &ev, HML hml, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5)
Definition GameApi.cc:29263

GameApi::MainLoopApi::lod_gpu_matrix_tf
GameApi::ML lod_gpu_matrix_tf(GameApi::EveryApi &ev, GameApi::P p, GameApi::MT mat, GameApi::MS pts, float level1_tri, float level2_tri, float level3_tri, float level4_tri, int l1, int l2, int l3, int l4, float mix, float self_mult, float rest_mult, int mode, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfil, float start_brightness, float end_brightness)
Definition GameApi.cc:44807

GameApi::MainLoopApi::keyboard_toggle
IMPORT ML keyboard_toggle(ML m1, ML m2, int key)
Definition GameApi_main.cc:3579

GameApi::MainLoopApi::array_timing_chain
IMPORT TT array_timing_chain(TT prev, float start_time, std::string durations, std::vector< ML > vec)
Definition GameApi_main.cc:4505

GameApi::MainLoopApi::gltf_mesh_all_p
IMPORT P gltf_mesh_all_p(GameApi::EveryApi &ev, TF model0)
Definition GameApi_gltf.cc:11051

GameApi::MainLoopApi::bytestore_timing
IMPORT ML bytestore_timing(BS store, int ch, std::string s, float time_delta)
Definition GameApi_pl.cc:29466

GameApi::MainLoopApi::constant_shp_f
IMPORT SHP constant_shp_f(SHP next, int num, float value)
Definition cpushader.cc:284

GameApi::MainLoopApi::timed_shp_i
IMPORT SHP timed_shp_i(float start_time, float end_time, SHP next, int num, int start_value, int end_value)
Definition cpushader.cc:317

GameApi::MainLoopApi::set_corner
IMPORT void set_corner(int x, int y, int screen_sx, int screen_sy)
Definition GameApi_main.cc:728

GameApi::MainLoopApi::random
IMPORT unsigned int random()
Definition GameApi_main.cc:309

GameApi::MainLoopApi::init_3d
IMPORT void init_3d(SH sh, int screen_width=800, int screen_heigth=600)
Definition GameApi_main.cc:540

GameApi::MainLoopApi::set_seamless_url
IMPORT void set_seamless_url(std::string url)
Definition GameApi_main.cc:3363

GameApi::MainLoopApi::create_landscape
IMPORT ML create_landscape(EveryApi &ev, std::string url)
Definition GameApi.cc:41317

GameApi::MainLoopApi::AI_generated
IMPORT ML AI_generated(EveryApi &ev, ML ml, std::string url)
Definition GameApi.cc:46239

GameApi::MainLoopApi::blendfunc
IMPORT ML blendfunc(ML ml, int val, int val2)
Definition GameApi_main.cc:3802

GameApi::MainLoopApi::empty_shp
IMPORT SHP empty_shp()
Definition cpushader.cc:280

GameApi::MainLoopApi::gltf_mesh_all_anim_inst
IMPORT ML gltf_mesh_all_anim_inst(EveryApi &ev, TF model0, TF resize_obj, PTS ms, float mix, float self_mult, float rest_mult, int mode, std::string keys, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, bool emissive, int frame_skip, int lod_level)
Definition GameApi_gltf.cc:11989

GameApi::MainLoopApi::glClear
IMPORT ML glClear(EveryApi &ev, unsigned int color)
Definition GameApi_main.cc:2948

GameApi::MainLoopApi::key_press_print_time_sync
IMPORT ML key_press_print_time_sync(ML ml)
Definition GameApi.cc:46092

GameApi::MainLoopApi::load_ds_from_temp
IMPORT void load_ds_from_temp(std::string filename, void(*fptr)(void *), void *data, bool &success)
Definition GameApi.cc:31970

GameApi::MainLoopApi::save_glb_store
IMPORT void save_glb_store(EveryApi &ev, std::string filename, TF tf)
Definition GameApi_gltf.cc:15752

GameApi::MainLoopApi::make_current
IMPORT void make_current()
Definition GameApi_main.cc:37

GameApi::MainLoopApi::logo_iter
IMPORT bool logo_iter()
Definition GameApi_main.cc:2847

GameApi::MainLoopApi::outline_third
IMPORT void outline_third()
Definition GameApi_main.cc:1246

GameApi::MainLoopApi::p_script2
IMPORT P p_script2(EveryApi &ev, HML h, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5)
Definition GameApi.cc:29095

GameApi::MainLoopApi::load_MT_script2
IMPORT MT load_MT_script2(EveryApi &ev, HML h, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5)
Definition GameApi.cc:30212

GameApi::MainLoopApi::shader_cache_disable
IMPORT ML shader_cache_disable(ML ml, bool disable)
Definition GameApi_main.cc:80

GameApi::MainLoopApi::print_time_sync
IMPORT ML print_time_sync(ML ml)
Definition GameApi.cc:46065

GameApi::MainLoopApi::load_BM_script_array_comb
IMPORT ARR load_BM_script_array_comb(EveryApi &ev, std::string url, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5)
Definition GameApi.cc:30386

GameApi::MainLoopApi::ch_doubletap_detect
IMPORT bool ch_doubletap_detect(Event &e, int exprire_timer_count, int ch, DoubleTapState &state)
Definition GameApi_main.cc:1260

GameApi::MainLoopApi::joystick_to_wasd
IMPORT ML joystick_to_wasd(ML ml)
Definition GameApi_main.cc:4120

GameApi::MainLoopApi::load_ds_from_disk
IMPORT DS load_ds_from_disk(std::string filename)
Definition GameApi.cc:31986

GameApi::MainLoopApi::constant_shp_p3d
IMPORT SHP constant_shp_p3d(SHP next, int num, PT value)
Definition cpushader.cc:299

GameApi::MainLoopApi::cursor_keys_normal_move
IMPORT INP cursor_keys_normal_move()
Definition GameApi.cc:32282

GameApi::MainLoopApi::pts_world
IMPORT W pts_world(PTS p, int type)
Definition GameApi_pl.cc:27452

GameApi::MainLoopApi::advance_time
IMPORT void advance_time(float val)
Definition GameApi_main.cc:1033

GameApi::MainLoopApi::parse_areatype
IMPORT ML parse_areatype(EveryApi &ev, std::string url, GameApi::FB heightmap, GameApi::BM top_texture, GameApi::BM side_texture)
Definition GameApi.cc:41215

GameApi::MainLoopApi::score_adder2
IMPORT ML score_adder2(EveryApi &ev, ML ml, O o, PTS points, MN transform, int enter_score, int leave_score, int dyn_point, float timeout, IF fetcher)
Definition GameApi.cc:32919

GameApi::MainLoopApi::no_concurrent_download
IMPORT ML no_concurrent_download(ML ml)
Definition GameApi_main.cc:4895

GameApi::MainLoopApi::gltf_scene
IMPORT ML gltf_scene(EveryApi &ev, TF model0, int scene_id, std::string keys, float mix, float self_mult, float rest_mult, int mode, float light_dir_x, float light_dir_y, float light_dir_z, int animation, float border_width, unsigned int border_color, bool transparent, bool acesfilm, bool emissive, int frame_skip, int lod_level)
Definition GameApi_gltf.cc:10332

GameApi::MainLoopApi::no_concurrent_download_run
IMPORT RUN no_concurrent_download_run(RUN r)

GameApi::MainLoopApi::bind_obj_type
IMPORT ML bind_obj_type(std::string name, GameApi::P obj, GameApi::MN move, GameApi::MT mat, float radius)
Definition GameApi.cc:41349

GameApi::MainLoopApi::cmb_2____
ML cmb_2____(GameApi::EveryApi &ev, std::string a_script_url, std::string a_param1, std::string a_param2, std::string a_param3, std::string a_param4, std::string a_param5, std::string b_script_url, std::string b_param1, std::string b_param2, std::string b_param3, std::string b_param4, std::string b_param5, std::vector< float > *optional_time_range_duration)
Definition GameApi.cc:45638

GameApi::MainLoopApi::subworld
IMPORT CX subworld(CX c, W w, int start_block, int end_block)
Definition GameApi_pl.cc:27573

GameApi::MainLoopApi::alpha
IMPORT void alpha(bool enabled)
Definition GameApi_main.cc:922

GameApi::MainLoopApi::nvidia_init
IMPORT void nvidia_init()
Definition GameApi_main.cc:715

GameApi::MainLoopApi::save_deploy2
IMPORT ML save_deploy2(EveryApi &ev, RUN run, std::string homepage, bool is_in_arr, std::string filename)
Definition GameApi.cc:28920

GameApi::MainLoopApi::outline_second
IMPORT void outline_second()
Definition GameApi_main.cc:1235

GameApi::MainLoopApi::current_time
IMPORT TT current_time(TT prev)
Definition GameApi_main.cc:4605

GameApi::MainLoopApi::lod_pts_tf
GameApi::ML lod_pts_tf(GameApi::EveryApi &ev, GameApi::TF p, GameApi::PTS pts, float level1, float level2, float level3, float level4, int l1, int l2, int l3, int l4, float mix, float selt_mult, float rest_mult, int mode, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, float start_brightness, float end_brightness, bool emissive)
Definition GameApi.cc:44687

GameApi::MainLoopApi::set_screen_size
IMPORT void set_screen_size(int sx, int sy)
Definition GameApi_main.cc:756

GameApi::MainLoopApi::step
IMPORT void step()
Definition GameApi_main.cc:971

GameApi::MainLoopApi::random_instantiate
IMPORT ML random_instantiate(EveryApi &ev, ML ml, std::vector< MN > vec, float start_time, float time_step, float random_chance)
Definition GameApi.cc:41954

GameApi::MainLoopApi::get_homepage_url
IMPORT std::string get_homepage_url()
Definition GameApi_main.cc:3358

GameApi::MainLoopApi::get_screen_height
IMPORT int get_screen_height()
Definition GameApi_main.cc:2745

GameApi::MainLoopApi::seq_ml
IMPORT ML seq_ml(std::vector< ML > vec, float time)
Definition GameApi_main.cc:2093

GameApi::MainLoopApi::score_set_hide
IMPORT IF score_set_hide()
Definition GameApi.cc:32992

GameApi::MainLoopApi::emscripten_frame2_P
IMPORT HML emscripten_frame2_P(EveryApi &ev, P p, std::string homepage)
Definition GameApi.cc:40162

GameApi::MainLoopApi::gltf_loadKK2
IMPORT TF gltf_loadKK2(std::string url)
Definition GameApi_gltf.cc:15659

GameApi::MainLoopApi::isometric
IMPORT ML isometric(ML ml, float y_angle, float x_angle, float translate)
Definition GameApi.cc:41744

GameApi::MainLoopApi::glb_load_sketchfab_zip
IMPORT TF glb_load_sketchfab_zip(std::string url_to_zip)

GameApi::MainLoopApi::in_N
IMPORT M in_N(EveryApi &ev, bool is_3d)
Definition GameApi_main.cc:3324

GameApi::MainLoopApi::MainLoopApi
IMPORT MainLoopApi(Env &e)
Definition GameApi_main.cc:19

GameApi::MainLoopApi::resize_and_anim_transfer_id
IMPORT ARR resize_and_anim_transfer_id()
Definition GameApi_pl.cc:15350

GameApi::MainLoopApi::gltf_mesh_all
IMPORT ML gltf_mesh_all(EveryApi &ev, TF model0, float mix, float self_mult, float rest_mult, int mode, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, bool emissive, int lod_level)
Definition GameApi_gltf.cc:11938

GameApi::MainLoopApi::slow_start_array_ml
IMPORT ML slow_start_array_ml(GameApi::EveryApi &ev, std::vector< ML > vec, int max_ticks)
Definition GameApi_main.cc:2774

GameApi::MainLoopApi::print_stats
IMPORT ML print_stats(P p)
Definition GameApi_main.cc:2214

GameApi::MainLoopApi::activate_item
IMPORT ML activate_item(ML ml, ML def)
Definition GameApi.cc:39594

GameApi::MainLoopApi::web_link
IMPORT ML web_link(EveryApi &ev, ML item, ML highlighted_item, float pt_x, float pt_y, float pt_z, float radius, std::string url)
Definition GameApi_pl.cc:31691

GameApi::MainLoopApi::fpscounter
IMPORT float fpscounter(bool print=true)
Definition GameApi_main.cc:463

GameApi::MainLoopApi::get_movement_from_MV
GameApi::ML get_movement_from_MV(GameApi::ML ml)
Definition GameApi_pl.cc:31182

GameApi::MainLoopApi::logo_change
GameApi::ML logo_change(ML ml, BM conn, BM download, BM prepare)
Definition GameApi_main.cc:3096

GameApi::MainLoopApi::transfer_sdl_surface
IMPORT void transfer_sdl_surface(MainLoopApi &orig)
Definition GameApi_main.cc:294

GameApi::MainLoopApi::save_ds_ml
IMPORT ML save_ds_ml(EveryApi &ev, std::string output_filename, P p, bool disable_normal, bool disable_color, bool disable_texcoord, bool disable_texcoord3, bool disable_objects)
Definition GameApi.cc:32070

GameApi::MainLoopApi::generic_anim_shader2
IMPORT SHI generic_anim_shader2(EveryApi &ev, SHP params, std::string funcname, SHC code, std::vector< SHI > children)
Definition cpushader.cc:1567

GameApi::MainLoopApi::timing_exit
IMPORT ML timing_exit(TT link)
Definition GameApi_main.cc:4837

GameApi::MainLoopApi::ogl_set_frame_rate
IMPORT ML ogl_set_frame_rate(ML ml, int fps)
Definition GameApi_main.cc:2683

GameApi::MainLoopApi::memmap_window3
IMPORT ML memmap_window3(EveryApi &ev, std::string url_1, std::string url_2, std::string url_3, std::string url_4, std::string url_5, std::string url_6)
Definition GameApi.cc:43439

GameApi::MainLoopApi::array_world
IMPORT W array_world(std::vector< W > vec)
Definition GameApi_pl.cc:27639

GameApi::MainLoopApi::scene_transparency
IMPORT ML scene_transparency(ML scene)
Definition GameApi_main.cc:4326

GameApi::MainLoopApi::render_txid
IMPORT ML render_txid(EveryApi &ev, P p1, TXID I7, int size)
Definition GameApi.cc:8809

GameApi::MainLoopApi::gs_time
IMPORT ML gs_time(GS gs, ML ml, int t)
Definition GameApi.cc:44158

GameApi::MainLoopApi::html_url
IMPORT HML html_url(std::string url)
Definition GameApi.cc:26864

GameApi::MainLoopApi::timed_shp_f
IMPORT SHP timed_shp_f(float start_time, float end_time, SHP next, int num, float start_value, float end_value)
Definition cpushader.cc:312

GameApi::MainLoopApi::gltf_node
IMPORT ML gltf_node(EveryApi &ev, TF model0, int node_id, std::string keys, float mix, float self_mult, float rest_mult, int mode, float light_dir_x, float light_dir_y, float light_dir_z, int animation, float border_width, unsigned int border_color, bool transparent, bool acesfilm, bool emissive, int frame_skip, int lod_level)
Definition GameApi_gltf.cc:10238

GameApi::MainLoopApi::or_elem_ml
IMPORT ML or_elem_ml(GameApi::EveryApi &ev, ML m1, ML m2)
Definition GameApi_main.cc:2767

GameApi::MainLoopApi::edit_3d
IMPORT ML edit_3d(EveryApi &ev, P p, float radius)
Definition GameApi.cc:44009

GameApi::MainLoopApi::resize_transfer_id
IMPORT TRR resize_transfer_id(TRB id)
Definition GameApi_pl.cc:15338

GameApi::MainLoopApi::depth_test
IMPORT void depth_test(bool enabled)
Definition GameApi_main.cc:910

GameApi::MainLoopApi::looking_glass_full
IMPORT ML looking_glass_full(EveryApi &ev, ML ml, float amount, int mode, int start, int end)
Definition GameApi.cc:38222

GameApi::MainLoopApi::cmb_glb_3d_interpolate
ML cmb_glb_3d_interpolate(GameApi::EveryApi &ev, std::vector< GameApi::TF > tf_arr, int material_id, float mix, float self_mult, float rest_mult, float light_dir_x, float light_dir_y, float light_dir_z, int skin_num, int animation, int num_timeindexes, MT next, int key, std::string keys, int mode, int inst, int timeid)
Definition GameApi.cc:45681

GameApi::MainLoopApi::gltf_mesh
IMPORT ML gltf_mesh(EveryApi &ev, TF model0, int mesh_id, int skin_id, std::string keys, float mix, float self_mult, float rest_mult, int mode, float light_dir_x, float light_dir_y, float light_dir_z, int animation, float border_width, unsigned int border_color, bool acesfilm, bool emissive, int frame_skip, int lod_level)
Definition GameApi_gltf.cc:10139

GameApi::MainLoopApi::key_ml
IMPORT ML key_ml(std::vector< ML > vec, std::string keys)
Definition GameApi.cc:43576

GameApi::MainLoopApi::if_keys
IMPORT ML if_keys(ML ml, IF fetcher, std::string keys)
Definition GameApi_fnt.cc:1305

GameApi::MainLoopApi::move_in
IMPORT ML move_in(EveryApi &ev, ML ml, INP in)
Definition GameApi.cc:32565

GameApi::MainLoopApi::constant_shp_u
IMPORT SHP constant_shp_u(SHP next, int num, unsigned int value)
Definition cpushader.cc:294

GameApi::MainLoopApi::get_corner_y
IMPORT int get_corner_y()
Definition GameApi_main.cc:741

GameApi::MainLoopApi::disable_polygons
IMPORT ML disable_polygons(ML ml)
Definition GameApi_pl.cc:27044

GameApi::MainLoopApi::load_BM_script
IMPORT BM load_BM_script(EveryApi &ev, std::string url, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5)
Definition GameApi.cc:30376

GameApi::MainLoopApi::seamless_iter
IMPORT bool seamless_iter()
Definition GameApi_main.cc:2875

GameApi::MainLoopApi::transparency
IMPORT void transparency(bool enabled)
Definition GameApi_main.cc:895

GameApi::MainLoopApi::flip_bitmap_if_mobile
IMPORT BM flip_bitmap_if_mobile(EveryApi &ev, BM bm)
Definition GameApi.cc:39723

GameApi::MainLoopApi::display_logo
IMPORT void display_logo(EveryApi &ev)
Definition GameApi_main.cc:3102

GameApi::MainLoopApi::array_ml
IMPORT ML array_ml(GameApi::EveryApi &ev, std::vector< ML > vec)
Definition GameApi_main.cc:2797

GameApi::MainLoopApi::t_repeat
IMPORT TT t_repeat(TT prev, TT curr_to_repeated, int count)
Definition GameApi_main.cc:4701

GameApi::MainLoopApi::lod_gpu_pts_tf
GameApi::ML lod_gpu_pts_tf(GameApi::EveryApi &ev, GameApi::P p, GameApi::MT mat, GameApi::PTS pts, float level1_tri, float level2_tri, float level3_tri, float level4_tri, int l1, int l2, int l3, int l4, float mix, float self_mult, float rest_mult, int mode, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfil, float start_brightness, float end_brightness)
Definition GameApi.cc:44680

GameApi::MainLoopApi::chai_mainloop2
IMPORT ML chai_mainloop2(EveryApi &ev, std::string url, GameApi::ML ml)

GameApi::MainLoopApi::generic_shader
IMPORT ML generic_shader(EveryApi &ev, ML ml, SHI vertex, SHI fragment, std::vector< TXID > vec)
Definition cpushader.cc:919

GameApi::MainLoopApi::get_screen_rect_sy
IMPORT int get_screen_rect_sy()
Definition GameApi_main.cc:751

GameApi::MainLoopApi::seq_ml_score
IMPORT ML seq_ml_score(ML ml1, ML ml2, int score)
Definition GameApi_main.cc:2104

GameApi::MainLoopApi::move_speed
IMPORT INP move_speed(INP orig, float speed)
Definition GameApi.cc:32496

GameApi::MainLoopApi::profile
IMPORT void profile(std::string label, bool start)
Definition GameApi_main.cc:374

GameApi::MainLoopApi::execute_ml
IMPORT void execute_ml(EveryApi &ev, ML ml, SH color, SH texture, SH texture_2d, SH arr_texture, M in_MV, M in_T, M in_N, int screen_width, int screen_height)
Definition GameApi_main.cc:2114

GameApi::MainLoopApi::bindinst_parr_msarr
IMPORT ML bindinst_parr_msarr(EveryApi &ev, std::vector< P > parr, std::vector< MS > msarr, std::vector< MT > mat)

GameApi::MainLoopApi::skybox
IMPORT ML skybox(EveryApi &ev, BM land, BM sky)
Definition GameApi_main.cc:3535

GameApi::MainLoopApi::rand_max
IMPORT unsigned int rand_max()
Definition GameApi_main.cc:304

GameApi::MainLoopApi::cullface
IMPORT ML cullface(ML ml, bool b, bool is_gltf)
Definition GameApi_main.cc:3796

GameApi::MainLoopApi::fpscounter_init
IMPORT void fpscounter_init()
Definition GameApi_main.cc:429

GameApi::MainLoopApi::string_bytestore
IMPORT BS string_bytestore(std::string s)
Definition GameApi_pl.cc:29431

GameApi::MainLoopApi::turn_to_meters_default
IMPORT ML turn_to_meters_default(EveryApi &ev, ML ml, P p)
Definition GameApi_sp.cc:528

GameApi::MainLoopApi::array_timing_chain_ml
IMPORT ML array_timing_chain_ml(float start_time, std::string durations, std::vector< ML > vec, int repeat)
Definition GameApi_main.cc:4529

GameApi::MainLoopApi::load_ML_script3
IMPORT ML load_ML_script3(EveryApi &ev, std::string url)
Definition GameApi.cc:30193

GameApi::MainLoopApi::gltf_scene_anim
IMPORT ML gltf_scene_anim(EveryApi &ev, TF model0, int scene_id, int animation, std::string keys, float mix, float self_mult, float rest_mult, int mode, float light_dir_x, float light_dir_y, float light_dir_z, float border_width, unsigned int border_color, bool transparent, bool acesfilm, bool emissive, int frame_skip, int lod_level)
Definition GameApi_gltf.cc:13602

GameApi::MainLoopApi::get_screen_width
IMPORT int get_screen_width()
Definition GameApi_main.cc:2740

GameApi::MainLoopApi::cmb_____
ML cmb_____(GameApi::EveryApi &ev, std::string script_url, std::string param1, std::string param2, std::string param3, std::string param4, std::string param5)
Definition GameApi.cc:45665

GameApi::MainLoopApi::cursor_visible
IMPORT void cursor_visible(bool enabled)
Definition GameApi_main.cc:86

GameApi::MainLoopApi::mainloop_material
IMPORT MT mainloop_material(EveryApi &ev, ML ml)
Definition GameApi.cc:44384

GameApi::MainLoopApi::filter_execute_array_ml
IMPORT ML filter_execute_array_ml(GameApi::EveryApi &ev, std::vector< ML > vec)
Definition GameApi_main.cc:2785

GameApi::MainLoopApi::whack_a_mole_flag_bmchooser
IMPORT ML whack_a_mole_flag_bmchooser(ML ml)
Definition GameApi.cc:42075

GameApi::MainLoopApi::anim_transfer_id
IMPORT TRA anim_transfer_id(TRB id)
Definition GameApi_pl.cc:15344

GameApi::MainLoopApi::load_zip_assets2
IMPORT HML load_zip_assets2(std::string zip_url)
Definition GameApi_gltf.cc:16571

GameApi::MainLoopApi::save_ds
IMPORT void save_ds(std::string output_filename, DS ds)
Definition GameApi.cc:32117

GameApi::MainLoopApi::gltf_mesh_all_parr_msarr
IMPORT ARR gltf_mesh_all_parr_msarr(EveryApi &ev, TF model0, float mix, float light_dir_x, float light_dir_y, float light_dir_z, int skin_num)

GameApi::MainLoopApi::load_ML_script
IMPORT ML load_ML_script(EveryApi &ev, std::string url, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5)
Definition GameApi.cc:30184

GameApi::MainLoopApi::timed_shp_uvw
IMPORT SHP timed_shp_uvw(float start_time, float end_time, SHP next, int num, PT start_value, PT end_value)
Definition cpushader.cc:334

GameApi::MainLoopApi::phong_vertex
IMPORT SHI phong_vertex(SHI next)
Definition cpushader.cc:436

GameApi::MainLoopApi::collision_seq_ml
IMPORT ML collision_seq_ml(ML curr, ML end, std::string obj1, std::string obj2, float show_duration)
Definition GameApi_main.cc:2042

GameApi::MainLoopApi::init
IMPORT void init(SH sh, int screen_width=800, int screen_height=600)
Definition GameApi_main.cc:127

GameApi::MainLoopApi::network
IMPORT MB network(std::string url, std::string homapge)
Definition GameApi.cc:42361

GameApi::MainLoopApi::screenspace
IMPORT SP screenspace()
Definition GameApi_main.cc:1202

GameApi::MainLoopApi::gltf_skeleton
IMPORT LI gltf_skeleton(EveryApi &ev, TF model0, int start_node)

GameApi::MainLoopApi::display_seamless
IMPORT void display_seamless(EveryApi &ev)
Definition GameApi_main.cc:2896

GameApi::MainLoopApi::array_cache
IMPORT CX array_cache(std::vector< CX > vec)
Definition GameApi_pl.cc:27528

GameApi::MainLoopApi::disable_matrices
IMPORT ML disable_matrices(EveryApi &ev, ML ml, int size)
Definition GameApi.cc:8803

GameApi::MainLoopApi::flip_scene_if_mobile
IMPORT ML flip_scene_if_mobile(EveryApi &ev, ML ml)
Definition GameApi.cc:39733

GameApi::MainLoopApi::load_MN_script2
IMPORT MN load_MN_script2(EveryApi &ev, HML h, std::string p1, std::string p2, std::string p3, std::string p4, std::string p5)
Definition GameApi.cc:30203

GameApi::MainLoopApi::get_framenum
IMPORT int get_framenum()
Definition GameApi_main.cc:1037

GameApi::MainLoopApi::game_state
IMPORT GS game_state()
Definition GameApi.cc:44192

GameApi::MainLoopApi::debug_obj
IMPORT ML debug_obj(EveryApi &ev)
Definition GameApi.cc:32891

GameApi::MainLoopApi::gs_delta
IMPORT ML gs_delta(GS gs, ML ml, int p, int n, float delta)
Definition GameApi.cc:44151

GameApi::MainLoopApi::random_game_seq
IMPORT ML random_game_seq(float time_step, MN mn, std::vector< ML > true_vec, std::vector< ML > false_vec, float perc, int num_levels)
Definition GameApi_ff.cc:1065

GameApi::MainLoopApi::gltf_mesh_all_env
IMPORT ML gltf_mesh_all_env(EveryApi &ev, TF model0, BM diffuse, BM specular, BM bfrd, float mix)
Definition GameApi_gltf.cc:12088

GameApi::MaterialsApi
Definition GameApi.hh:1869

GameApi::MaterialsApi::hires
IMPORT MT hires(EveryApi &ev, MT mat, int size, int numsampled, float blur_radius)
Definition GameApi.cc:8899

GameApi::MaterialsApi::render_instanced_ml_texture2_matrix
IMPORT ML render_instanced_ml_texture2_matrix(EveryApi &ev, P p, MS pts)
Definition GameApi.cc:15063

GameApi::MaterialsApi::sfo_sandbox
IMPORT MT sfo_sandbox(EveryApi &ev, SFO sfo, MT next)
Definition GameApi.cc:17077

GameApi::MaterialsApi::bump_phong
IMPORT MT bump_phong(EveryApi &ev, float light_dir_x, float light_dir_y, float light_dir_z, unsigned int ambient, unsigned int highlight, float pow, FB bm, float bump_width)
Definition GameApi.cc:11221

GameApi::MaterialsApi::texture_many
IMPORT MT texture_many(EveryApi &ev, std::vector< BM > vec, float mix)
Definition GameApi.cc:10982

GameApi::MaterialsApi::m_apply_phong
IMPORT ARR m_apply_phong(EveryApi &ev, std::vector< MT > vec, float light_dir_x, float light_dir_y, float light_dir_z, unsigned int ambient, unsigned int specular, unsigned int highlight, float pow)
Definition GameApi.cc:10571

GameApi::MaterialsApi::fur
IMPORT MT fur(EveryApi &ev, MT nxt, PT center, float dist, float max_angle, int count, float size, int cone_numfaces)
Definition GameApi.cc:10956

GameApi::MaterialsApi::bevel
IMPORT MT bevel(EveryApi &ev, MT nxt, float dir, float linewidth)
Definition GameApi.cc:11481

GameApi::MaterialsApi::bind_inst_fade
IMPORT ML bind_inst_fade(P p, PTS pts, MT mat, bool flip, float start_time, float end_time)
Definition GameApi.cc:12055

GameApi::MaterialsApi::screenspace_bloom
IMPORT SMT screenspace_bloom(EveryApi &ev, SMT next, float cut_x, float cut_y, float cut_z, float x_amount, float y_amount)
Definition GameApi.cc:6693

GameApi::MaterialsApi::render_instanced2_ml_texture
IMPORT ML render_instanced2_ml_texture(EveryApi &ev, VA va, PTA pta, std::vector< BM > vec)
Definition GameApi.cc:15046

GameApi::MaterialsApi::vertex_phong
IMPORT MT vertex_phong(EveryApi &ev, MT nxt, float light_dir_x, float light_dir_y, float light_dir_z, unsigned int ambient, unsigned int highlight, float pow, float mix)
Definition GameApi.cc:11202

GameApi::MaterialsApi::gltf_newshadow2
IMPORT ML gltf_newshadow2(EveryApi &ev, P models, MT model_mt, P shadow_mesh, MT shadow_mt, float light_dir_x, float light_dir_y, float light_dir_z, float dark_level, float light_level, float scale, int size, TF tf)
Definition GameApi.cc:11155

GameApi::MaterialsApi::render_instanced_ml_texture_id
IMPORT ML render_instanced_ml_texture_id(EveryApi &ev, P p, PTS pts, std::vector< TXID > *vec)
Definition GameApi.cc:15004

GameApi::MaterialsApi::transparent_material
IMPORT MT transparent_material(EveryApi &ev, BM bm, MT next, bool is_transparent)
Definition GameApi.cc:6639

GameApi::MaterialsApi::m_dup
IMPORT ARR m_dup(EveryApi &ev, MT mat, int count)
Definition GameApi.cc:10540

GameApi::MaterialsApi::render_instanced_ml_texture2
IMPORT ML render_instanced_ml_texture2(EveryApi &ev, P p, PTS pts)
Definition GameApi.cc:15023

GameApi::MaterialsApi::phong3_material
IMPORT MT phong3_material(EveryApi &ev, MT next, unsigned int ambient, unsigned int highlight, float pow)
Definition cpushader.cc:1152

GameApi::MaterialsApi::fade
IMPORT MT fade(EveryApi &ev, MT next, float start_time, float end_time, float start_time2, float end_time2)
Definition GameApi.cc:10977

GameApi::MaterialsApi::render_instanced_ml_texture
IMPORT ML render_instanced_ml_texture(EveryApi &ev, P p, PTS pts, std::vector< BM > vec, std::vector< int > types=std::vector< int >(), std::vector< std::string > id_labels=std::vector< std::string >(), std::vector< bool > is_srgb=std::vector< bool >())
Definition GameApi.cc:15000

GameApi::MaterialsApi::marble
IMPORT MT marble(EveryApi &ev, MT nxt, int count, float cubesize)
Definition GameApi.cc:11288

GameApi::MaterialsApi::render_instanced2_ml
IMPORT ML render_instanced2_ml(EveryApi &ev, VA va, PTA pta, bool color_from_pts=false)
Definition GameApi.cc:15091

GameApi::MaterialsApi::shading2
IMPORT MT shading2(EveryApi &ev, MT nxt, unsigned int color1, unsigned int colo2, unsigned int color3)
Definition GameApi.cc:11268

GameApi::MaterialsApi::edge
IMPORT MT edge(EveryApi &ev, MT nxt, float edge_width, unsigned int edge_color)
Definition GameApi.cc:11207

GameApi::MaterialsApi::choose_color
IMPORT MT choose_color(EveryApi &ev, MT nxt, unsigned int color, float mix_val)
Definition GameApi.cc:11278

GameApi::MaterialsApi::gltf_material_from_file
IMPORT MT gltf_material_from_file(EveryApi &ev, std::string url, float light_dir_x, float light_dir_y, float light_dir_z)
Definition GameApi_gltf.cc:7834

GameApi::MaterialsApi::many_texture_id_material
IMPORT MT many_texture_id_material(EveryApi &ev, std::string mtl_url, std::string url_prefix, float mix, int start_range, int end_range)
Definition GameApi.cc:37847

GameApi::MaterialsApi::web
IMPORT MT web(EveryApi &ev, MT nxt, float val=1.01, float linewidth=2.0, unsigned int color=0xff000000)
Definition GameApi.cc:11475

GameApi::MaterialsApi::textureid
IMPORT MT textureid(EveryApi &ev, TXID txid, float mix)
Definition GameApi.cc:10973

GameApi::MaterialsApi::adjust
IMPORT MT adjust(EveryApi &ev, MT nxt, unsigned int ad_color, float ad_dark, float ad_light)
Definition GameApi.cc:11187

GameApi::MaterialsApi::discard_material
IMPORT MT discard_material(EveryApi &ev, MT next)
Definition GameApi.cc:10995

GameApi::MaterialsApi::colour_material
IMPORT MT colour_material(EveryApi &ev, float mix, bool color_from_pts=false)
Definition GameApi.cc:10986

GameApi::MaterialsApi::phong2
IMPORT MT phong2(EveryApi &ev, MT nxt, float light_dir_x, float light_dir_y, float light_dir_z, unsigned int ambient, unsigned int specular, unsigned int highlight, float pow)
Definition GameApi.cc:11197

GameApi::MaterialsApi::mesh_color_from_sfo
IMPORT MT mesh_color_from_sfo(EveryApi &ev, SFO sfo, MT next)
Definition GameApi.cc:17086

GameApi::MaterialsApi::render_instanced_ml_texture_id_matrix
IMPORT ML render_instanced_ml_texture_id_matrix(EveryApi &ev, P p, MS pts, std::vector< TXID > *vec)
Definition GameApi.cc:15054

GameApi::MaterialsApi::combine_materials
IMPORT MT combine_materials(EveryApi &ev, MT mat1, MT mat2)
Definition GameApi.cc:37945

GameApi::MaterialsApi::gltf_anim_material2
IMPORT MT gltf_anim_material2(EveryApi &e, TF model0, int skin_num, int num_timeindexes, MT next, std::string keys, int mode, TRA anim_transfer_id, int frame_skip)
Definition GameApi_gltf.cc:14836

GameApi::MaterialsApi::gltf_material_env
IMPORT MT gltf_material_env(EveryApi &ev, TF model0, int material_id, float mix, BM diffuse_env, BM specular_env, BM bfrd)
Definition GameApi_gltf.cc:7884

GameApi::MaterialsApi::mt_empty
IMPORT MT mt_empty(EveryApi &ev)
Definition GameApi.cc:256

GameApi::MaterialsApi::generic_shader_material0
IMPORT MT generic_shader_material0(EveryApi &ev, MT next, std::string, std::string, std::string)
Definition cpushader.cc:1906

GameApi::MaterialsApi::gltf_anim_material
IMPORT MT gltf_anim_material(EveryApi &ev, TF model0, int skin_num, int animation, int num_timeindexes, MT next, int key, int mode, TRA anim_transfer_id, int frame_skip)
Definition GameApi_gltf.cc:14849

GameApi::MaterialsApi::gi
IMPORT MT gi(EveryApi &ev, MT nxt, PTS points, float obj_size)
Definition GameApi.cc:11216

GameApi::MaterialsApi::texture
IMPORT MT texture(EveryApi &ev, BM bm, float mix)
Definition GameApi.cc:10969

GameApi::MaterialsApi::generic_shader_material1
IMPORT MT generic_shader_material1(EveryApi &ev, MT next, SHP params, std::string, std::string, std::string)
Definition cpushader.cc:1911

GameApi::MaterialsApi::m_keys
IMPORT MT m_keys(EveryApi &ev, std::vector< MT > vec, std::string keys)
Definition GameApi_gltf.cc:14802

GameApi::MaterialsApi::material_pack_1
IMPORT ARR material_pack_1(EveryApi &ev)
Definition GameApi.cc:41694

GameApi::MaterialsApi::noise
IMPORT MT noise(EveryApi &ev, int sx, int sy, int r, int g, int b, int a, int r2, int g2, int b2, int a2, float mix)
Definition GameApi.cc:33055

GameApi::MaterialsApi::gltf_material
IMPORT MT gltf_material(EveryApi &ev, TF model0, int material_id, float mix, float self_mult, float rest_mult, float light_dir_x, float light_dir_y, float light_dir_z, bool emissive, int lod_level=-1)
Definition GameApi_gltf.cc:7839

GameApi::MaterialsApi::snow
IMPORT MT snow(EveryApi &ev, MT nxt, unsigned int color1=0xffaaaaaa, unsigned int color2=0xffeeeeee, unsigned int color3=0xffffffff, float mix_val=0.5f)
Definition GameApi.cc:11014

GameApi::MaterialsApi::skeletal
IMPORT MT skeletal(EveryApi &ev)
Definition GameApi.cc:10952

GameApi::MaterialsApi::render_instanced_ml_cubemap_matrix
IMPORT ML render_instanced_ml_cubemap_matrix(EveryApi &ev, P p, MS pts, std::vector< BM > vec)
Definition GameApi.cc:15058

GameApi::MaterialsApi::choose_material
IMPORT MT choose_material(EveryApi &ev, int i)
Definition GameApi.cc:46350

GameApi::MaterialsApi::render_instanced2_ml_texture_id
IMPORT ML render_instanced2_ml_texture_id(EveryApi &ev, VA va, PTA pta, std::vector< TXID > *vec)
Definition GameApi.cc:15042

GameApi::MaterialsApi::generic_shader_material00
IMPORT MT generic_shader_material00(EveryApi &ev, MT next, SHI vertex, SHI fragment, std::vector< TXID > vec)
Definition cpushader.cc:1900

GameApi::MaterialsApi::bind_inst_matrix
IMPORT ML bind_inst_matrix(P p, MS ms, MT mat)
Definition GameApi.cc:12011

GameApi::MaterialsApi::m_apply_phong_color
IMPORT ARR m_apply_phong_color(EveryApi &ev, std::vector< MT > vec, std::vector< P > vec2, float light_dir_x, float light_dir_y, float light_dir_z, float ambient_mult, float specular_mult, float highlight_mult, float pow)
Definition GameApi.cc:10548

GameApi::MaterialsApi::flat
IMPORT MT flat(EveryApi &ev, MT nxt, unsigned int color1, unsigned int color2, unsigned int color3)
Definition GameApi.cc:11273

GameApi::MaterialsApi::fog
IMPORT MT fog(EveryApi &ev, MT nxt, float fog_dist, unsigned int dark_color, unsigned int light_color)
Definition GameApi.cc:11225

GameApi::MaterialsApi::generic_shader_material2
IMPORT MT generic_shader_material2(EveryApi &ev, MT next, SHP params, std::string, std::string, std::string, std::vector< SHI >)
Definition cpushader.cc:1915

GameApi::MaterialsApi::render_instanced2_ml_fade
IMPORT ML render_instanced2_ml_fade(EveryApi &ev, VA va, PTA pta, bool flip, float start_time, float end_time)
Definition GameApi.cc:15101

GameApi::MaterialsApi::m_def
IMPORT MT m_def(EveryApi &ev)
Definition GameApi.cc:10528

GameApi::MaterialsApi::newshadow2_gltf
IMPORT ML newshadow2_gltf(EveryApi &ev, TF I1, P shadow_p, MT shadow_mt, float light_dir_x, float light_dir_y, float light_dir_z, float dark_level, float light_level, unsigned int ambient_color, unsigned int dark_color, unsigned int light_color, float scale, int size, MT shadow2_mt, bool emissive)
Definition GameApi.cc:11141

GameApi::MaterialsApi::mt_alt
IMPORT MT mt_alt(EveryApi &ev, std::vector< MT > v, int index)
Definition GameApi_pl.cc:14381

GameApi::MaterialsApi::phong
IMPORT MT phong(EveryApi &ev, MT nxt, float light_dir_x, float light_dir_y, float light_dir_z, unsigned int ambient, unsigned int specular, unsigned int highlight, float pow)
Definition GameApi.cc:11192

GameApi::MaterialsApi::render_instanced2_ml_texture2
IMPORT ML render_instanced2_ml_texture2(EveryApi &ev, VA va, PTA pta)
Definition GameApi.cc:15013

GameApi::MaterialsApi::shading1
IMPORT MT shading1(EveryApi &ev, MT nxt, float mix_val, float mix_val2)
Definition GameApi.cc:11263

GameApi::MaterialsApi::render_instanced_ml
IMPORT ML render_instanced_ml(EveryApi &ev, P p, PTS pts, bool color_from_pts=false)
Definition GameApi.cc:14987

GameApi::MaterialsApi::glow_edge
IMPORT MT glow_edge(EveryApi &ev, MT next, float light_level, float gray_level, float edge_pos)
Definition GameApi.cc:10935

GameApi::MaterialsApi::render_instanced_ml_cubemap
IMPORT ML render_instanced_ml_cubemap(EveryApi &ev, P p, PTS pts, std::vector< BM > vec)
Definition GameApi.cc:15008

GameApi::MaterialsApi::MaterialsApi
IMPORT MaterialsApi(Env &e)
Definition GameApi.cc:44491

GameApi::MaterialsApi::render_instanced_ml_fade
IMPORT ML render_instanced_ml_fade(EveryApi &ev, P p, PTS pts, bool flip, float start_time, float end_time, bool color_from_pts=false)
Definition GameApi.cc:15073

GameApi::MaterialsApi::shadow2
IMPORT MT shadow2(EveryApi &ev, P p, float p_x, float p_y, float p_z, int sx, int sy, unsigned int dark_color, float mix, float mix2, int numtextures)
Definition GameApi.cc:11238

GameApi::MaterialsApi::render_instanced2_ml_matrix
IMPORT ML render_instanced2_ml_matrix(EveryApi &ev, VA va, MSA pta)
Definition GameApi.cc:15095

GameApi::MaterialsApi::shadow
IMPORT MT shadow(EveryApi &ev, P p, std::vector< BM > vec, float p_x, float p_y, float p_z, int sx, int sy, unsigned int dark_color, float mix, float mix2)
Definition GameApi.cc:11230

GameApi::MaterialsApi::reload_material
IMPORT MT reload_material(EveryApi &ev, MT next, std::string name, P default_p, MT default_mat)
Definition GameApi_reload.cc:425

GameApi::MaterialsApi::bloom
IMPORT MT bloom(EveryApi &ev, MT nxt, BM bm, float r_cut, float g_cut, float b_cut, float pixel_x, float pixel_y)
Definition GameApi.cc:10962

GameApi::MaterialsApi::bind_inst2
IMPORT ML bind_inst2(P p, PTA pta, MT mat)
Definition GameApi.cc:11997

GameApi::MaterialsApi::brashmetal
IMPORT MT brashmetal(EveryApi &ev, MT nxt, int count, bool web)
Definition GameApi.cc:11283

GameApi::MaterialsApi::acesfilm_material
IMPORT MT acesfilm_material(EveryApi &ev, MT next)
Definition GameApi.cc:10990

GameApi::MaterialsApi::dyn_lights
IMPORT MT dyn_lights(EveryApi &ev, MT nxt, float light_pos_x, float light_pos_y, float light_pos_z, float dist, MN dyn_point)
Definition GameApi.cc:11246

GameApi::MaterialsApi::bind_inst_va
IMPORT ML bind_inst_va(VA va, PTS pts, MT mat, float level)
Definition GameApi.cc:12035

GameApi::MaterialsApi::render_instanced_ml_matrix
IMPORT ML render_instanced_ml_matrix(EveryApi &ev, P p, MS pts, bool color_from_matrix=false)
Definition GameApi.cc:15029

GameApi::MaterialsApi::coloured_lights
IMPORT MT coloured_lights(EveryApi &ev, MT nxt, float scale, unsigned int color_1, unsigned int color_2, unsigned int color_3, unsigned int color_4, unsigned int color_5, unsigned int color_6, unsigned int color_7, unsigned int color_8, PT pos_1, PT pos_2, PT pos_3, PT pos_4, PT pos_5, PT pos_6, PT pos_7, PT pos_8, float dist_1, float dist_2, float dist_3, float dist_4, float dist_5, float dist_6, float dist_7, float dist_8)
Definition GameApi.cc:11251

GameApi::MaterialsApi::render_instanced_ml_fade_texture
IMPORT ML render_instanced_ml_fade_texture(EveryApi &ev, P p, PTS pts, bool flip, float start_time, float end_time, std::vector< BM > vec)
Definition GameApi.cc:15085

GameApi::MaterialsApi::texture_many2
IMPORT MT texture_many2(EveryApi &ev, float mix)
Definition GameApi.cc:11004

GameApi::MaterialsApi::newshadow2_phong
IMPORT ML newshadow2_phong(EveryApi &ev, P models, MT model_mt, P shadow_mesh, MT shadow_mt, float light_dir_x, float light_dir_y, float light_dir_z, float dark_level, float light_level, unsigned int ambient_color, unsigned int dark_color, unsigned int light_color, float scale, int size, bool draw_model, MT shadow2_mt)
Definition GameApi.cc:11026

GameApi::MaterialsApi::render_instanced_ml_texture_matrix
IMPORT ML render_instanced_ml_texture_matrix(EveryApi &ev, P p, MS pts, std::vector< BM > vec, std::vector< int > types=std::vector< int >(), std::vector< std::string > id_labels=std::vector< std::string >(), std::vector< bool > is_srgb=std::vector< bool >())
Definition GameApi.cc:15050

GameApi::MaterialsApi::bind_inst_va_prepare
IMPORT VA bind_inst_va_prepare(P p, MT mat)
Definition GameApi.cc:12027

GameApi::MaterialsApi::gltf_material_manual
IMPORT MT gltf_material_manual(EveryApi &ev, float mix, float self_mult, float rest_mult, BM, BM, BM, BM, BM, bool, bool, bool, bool, bool, float, float, float, float, float, float, float, float light_dir_x, float light_dir_y, float light_dir_z)
Definition GameApi_gltf.cc:7856

GameApi::MaterialsApi::water
IMPORT MT water(EveryApi &ev, MT next, unsigned int color1, unsigned int color2, unsigned int color3, float center_x, float center_y, float center_z, float wave_mult, float time_mult)
Definition GameApi.cc:10940

GameApi::MaterialsApi::texture_cubemap
IMPORT MT texture_cubemap(EveryApi &ev, std::vector< BM > vec, float mix, float mix2)
Definition GameApi.cc:11000

GameApi::MaterialsApi::bind_inst
IMPORT ML bind_inst(P p, PTS pts, MT mat)
Definition GameApi.cc:12041

GameApi::MaterialsApi::dist_field_mesh
IMPORT MT dist_field_mesh(EveryApi &ev, SFO sfo, MT next)
Definition GameApi.cc:17071

GameApi::MaterialsApi::newshadow
IMPORT MT newshadow(EveryApi &ev, MT nxt, P models, float light_dir_x, float light_dir_y, float light_dir_z, float dark_level, float light_level, float scale, int size, bool is_phong, int texindex, MT shadow_mt)
Definition GameApi.cc:11020

GameApi::MaterialsApi::texture_arr
IMPORT MT texture_arr(EveryApi &ev, std::vector< BM > vec, int sx, int sy, float mix)
Definition GameApi.cc:11010

GameApi::MaterialsApi::bind
IMPORT ML bind(P p, MT mat)
Definition GameApi.cc:11983

GameApi::MaterialsApi::ss_def
IMPORT SMT ss_def(EveryApi &ev)
Definition GameApi.cc:6665

GameApi::MaterialsApi::generic_screenspace_material00
IMPORT SMT generic_screenspace_material00(EveryApi &ev, SMT next, SHI vertex, SHI fragment)
Definition cpushader.cc:1920

GameApi::MaterialsApi::toon_border
IMPORT MT toon_border(EveryApi &ev, MT next, float border_width, unsigned int color, bool is_gltf)
Definition GameApi.cc:10946

GameApi::MaterialsApi::gltf_material3
IMPORT MT gltf_material3(EveryApi &ev, float roughness, float metallic, float base_r, float base_g, float base_b, float base_a, float mix, float self_mult, float rest_mult, float light_dir_x, float light_dir_y, float light_dir_z, bool emissive)
Definition GameApi_gltf.cc:7829

GameApi::MaterialsApi::progressmaterial
IMPORT MT progressmaterial(MT nxt, void(*fptr)(void *), void *data)
Definition GameApi.cc:6765

GameApi::MaterialsApi::p_dup
IMPORT ARR p_dup(EveryApi &ev, P obj, int count)
Definition GameApi.cc:10532

GameApi::MatricesApi
Definition GameApi.hh:3992

GameApi::MatricesApi::mn_matrix_array2
MS mn_matrix_array2(EveryApi &ev, std::vector< MN > moves)
Definition GameApi.cc:4593

GameApi::MatricesApi::from_lines_2d
IMPORT MS from_lines_2d(LI li)
Definition GameApi.cc:16625

GameApi::MatricesApi::render_ms_files
IMPORT ML render_ms_files(EveryApi &ev, std::vector< P > p, MT mat, std::string url, int start_type, int end_type)
Definition GameApi.cc:5325

GameApi::MatricesApi::ms_interface
IMPORT MS ms_interface(VX vox, int type, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)
Definition GameApi.cc:4956

GameApi::MatricesApi::mult_array
IMPORT MS mult_array(MS m1, MS m2)
Definition GameApi.cc:16740

GameApi::MatricesApi::render_ms_files2
IMPORT ML render_ms_files2(EveryApi &ev, std::vector< P > p, std::vector< MT > mat, std::string url, int start_type, int end_type)
Definition GameApi.cc:5329

GameApi::MatricesApi::ms_file
IMPORT MS ms_file(std::string url, int use_type)
Definition GameApi.cc:5191

GameApi::MatricesApi::subarray
IMPORT MS subarray(MS m, int start, int count)
Definition GameApi.cc:16772

GameApi::MatricesApi::load_matrices_nr
MS load_matrices_nr(std::string url)
Definition GameApi_pts.cc:196

GameApi::MatricesApi::MatricesApi
IMPORT MatricesApi(Env &e)
Definition GameApi.cc:44517

GameApi::MatricesApi::from_points
IMPORT MS from_points(PTS pts)
Definition GameApi.cc:16585

GameApi::MatricesApi::trans2
IMPORT MS trans2(MS m, float tx, float ty, float tz)
Definition GameApi.cc:5476

GameApi::MatricesApi::ms_steady
MS ms_steady(MS ms)
Definition GameApi.cc:4996

GameApi::MatricesApi::render_ms_files2_si
ML render_ms_files2_si(EveryApi &ev, std::vector< P > p, std::vector< MT > mat, VX voxel, int start_type, int end_type, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)
Definition GameApi.cc:4901

GameApi::MatricesApi::mult
IMPORT MS mult(MS m, M mat)
Definition GameApi.cc:16712

GameApi::MatricesApi::ms_random_rot
IMPORT MS ms_random_rot(float px, float py, float pz, int count)
Definition GameApi.cc:16580

GameApi::MatricesApi::inverse_ms
IMPORT MS inverse_ms(MS ms)
Definition GameApi.cc:5467

GameApi::MatricesApi::from_lines_3d
IMPORT MS from_lines_3d(LI li)
Definition GameApi.cc:16665

GameApi::MatricesApi::mn_matrix_array
IMPORT MS mn_matrix_array(EveryApi &ev, int count, MN move)
Definition GameApi.cc:4525

GameApi::MatricesApi::apply_matrix
IMPORT MS apply_matrix(MS m, M mat)
Definition GameApi.cc:5509

GameApi::MatricesApi::mult_g_last_resize
MS mult_g_last_resize(EveryApi &ev, MS ms)
Definition GameApi.cc:4559

GameApi::MatricesApi::repeat_ms
IMPORT MS repeat_ms(EveryApi &ev, MN mn, int val)
Definition GameApi.cc:5435

GameApi::MatricesApi::prepare
IMPORT MSA prepare(MS p, bool color_from_instance)
Definition GameApi_pts.cc:881

GameApi::MatricesApi::interpolate
IMPORT MS interpolate(MS start, MS end, float val)
Definition GameApi.cc:5549

GameApi::MatricesApi::render_ms_files_si
ML render_ms_files_si(EveryApi &ev, std::vector< P > p, MT mat, VX voxel, int start_type, int end_type, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)
Definition GameApi.cc:4805

GameApi::MatricesApi::load_matrices
MS load_matrices(std::string url)
Definition GameApi_pts.cc:192

GameApi::MatricesApi::scale2
IMPORT MS scale2(MS m, float sx, float sy, float sz)
Definition GameApi.cc:5472

GameApi::MatricesApi::random_time_seq
IMPORT MS random_time_seq(EveryApi &ev, MS inner_start, MS outer, MS inner_end, float outer_time, float inner_time)
Definition GameApi.cc:4674

GameApi::MatrixApi
Definition GameApi.hh:4285

GameApi::MatrixApi::trans
IMPORT M trans(V vec)

GameApi::MatrixApi::rotate_around_axis
IMPORT M rotate_around_axis(V v, float angle)

GameApi::MatrixApi::mult
IMPORT M mult(M m1, M m2)
Definition GameApi_mx.cc:46

GameApi::MatrixApi::projection
IMPORT M projection(float z_min)

GameApi::MatrixApi::perspective
IMPORT M perspective(float fovy, float aspect, float near, float far)
Definition GameApi_mx.cc:57

GameApi::MatrixApi::trans
IMPORT M trans(float x, float y, float z)
Definition GameApi_mx.cc:27

GameApi::MatrixApi::xrot
IMPORT M xrot(float rot)
Definition GameApi_mx.cc:15

GameApi::MatrixApi::rotate_around_axis
IMPORT M rotate_around_axis(PT point, V v, float angle)

GameApi::MatrixApi::MatrixApi
IMPORT MatrixApi(Env &e)
Definition GameApi_mx.cc:4

GameApi::MatrixApi::inverse
IMPORT M inverse(M m1)
Definition GameApi_mx.cc:35

GameApi::MatrixApi::perspective_projection
IMPORT M perspective_projection(float dist)

GameApi::MatrixApi::keep_rotation
IMPORT M keep_rotation(M m)
Definition GameApi_mx.cc:40

GameApi::MatrixApi::zrot
IMPORT M zrot(float rot)
Definition GameApi_mx.cc:23

GameApi::MatrixApi::ortho
IMPORT M ortho(float left, float right, float bottom, float top, float near, float far)
Definition GameApi_mx.cc:52

GameApi::MatrixApi::scale
IMPORT M scale(float sx, float sy, float sz)
Definition GameApi_mx.cc:31

GameApi::MatrixApi::yrot
IMPORT M yrot(float rot)
Definition GameApi_mx.cc:19

GameApi::MatrixApi::transpose
IMPORT M transpose(M m)
Definition GameApi_mx.cc:10

GameApi::MatrixApi::identity
IMPORT M identity()
Definition GameApi_mx.cc:6

GameApi::MatrixCurveApi::MatrixCurveApi
IMPORT MatrixCurveApi(Env &e)
Definition GameApi.cc:44485

GameApi::MatrixCurveApi::circle_xz
IMPORT MC circle_xz(float radius)
Definition GameApi.cc:16838

GameApi::MatrixCurveApi::from_curve
IMPORT MC from_curve(C curve)
Definition GameApi.cc:16793

GameApi::MatrixCurveApi::circle_xy
IMPORT MC circle_xy(float radius)
Definition GameApi.cc:16832

GameApi::MatrixCurveApi::sample
IMPORT MS sample(MC m_curve, int num)
Definition GameApi.cc:16875

GameApi::MixedApi::mx_find
IMPORT MX mx_find(MX arr, std::string name)
Definition GameApi.cc:17689

GameApi::MixedApi::mx_pair
IMPORT MX mx_pair(std::string name, MX val)
Definition GameApi.cc:17623

GameApi::MixedApi::mx_color
IMPORT MX mx_color(int r, int g, int b, int a)
Definition GameApi.cc:17619

GameApi::MixedApi::mx_string
IMPORT MX mx_string(std::string value)
Definition GameApi.cc:17632

GameApi::MixedApi::mx_bool
IMPORT MX mx_bool(bool val)
Definition GameApi.cc:17605

GameApi::MixedApi::mx_to_int
IMPORT int mx_to_int(MX val, int def=-1)
Definition GameApi.cc:17724

GameApi::MixedApi::mx_array
IMPORT MX mx_array(std::vector< MX > vec)
Definition GameApi.cc:17636

GameApi::MixedApi::mx_names
IMPORT std::vector< std::string > mx_names(MX val)
Definition GameApi.cc:17736

GameApi::MixedApi::mx_index
IMPORT MX mx_index(MX arr, int idx)
Definition GameApi.cc:17667

GameApi::MixedApi::mx_to_float
IMPORT float mx_to_float(MX val, float def=0.0)
Definition GameApi.cc:17713

GameApi::MixedApi::MixedApi
IMPORT MixedApi(Env &e)
Definition GameApi.cc:44481

GameApi::MixedApi::mx_int
IMPORT MX mx_int(int val)
Definition GameApi.cc:17601

GameApi::MixedApi::mx_float
IMPORT MX mx_float(float val)
Definition GameApi.cc:17597

GameApi::MixedApi::mx_size
IMPORT int mx_size(MX arr)
Definition GameApi.cc:17651

GameApi::MixedApi::mx_vector
IMPORT MX mx_vector(float dx, float dy, float dz)
Definition GameApi.cc:17614

GameApi::MixedApi::mx_point
IMPORT MX mx_point(float x, float y, float z)
Definition GameApi.cc:17609

GameApi::MixedApi::mx_values
IMPORT std::vector< MX > mx_values(MX val)
Definition GameApi.cc:17744

GameApi::MoveScaleObject2d
Definition GameApi.hh:4764

GameApi::MoveScaleObject2d::~MoveScaleObject2d
virtual ~MoveScaleObject2d()
Definition GameApi.hh:4766

GameApi::MoveScaleObject2d::set_scale
virtual void set_scale(float mult_x, float mult_y)=0

GameApi::MoveScaleObject2d::set_pos
virtual void set_pos(float pos_x, float pos_y)=0

GameApi::MoveScaleObject3d
Definition GameApi.hh:4771

GameApi::MoveScaleObject3d::set_rotation_matrix
virtual void set_rotation_matrix(M m)=0

GameApi::MoveScaleObject3d::set_scale
virtual void set_scale(float mult_x, float mult_y, float mult_z)=0

GameApi::MoveScaleObject3d::~MoveScaleObject3d
virtual ~MoveScaleObject3d()
Definition GameApi.hh:4773

GameApi::MoveScaleObject3d::set_rotation_matrix2
virtual void set_rotation_matrix2(M m)=0

GameApi::MoveScaleObject3d::set_pos
virtual void set_pos(float pos_x, float pos_y, float pos_z)=0

GameApi::MovementNode
Definition GameApi.hh:2125

GameApi::MovementNode::translate_wave
IMPORT MN translate_wave(MN next, float start_time, float end_time, WV wave, float dx, float dy, float dz)
Definition GameApi.cc:1522

GameApi::MovementNode::mn_last_resize
IMPORT MN mn_last_resize(MN mn)
Definition GameApi_pts.cc:118

GameApi::MovementNode::android_landscape_rotate
IMPORT MN android_landscape_rotate(MN next)
Definition GameApi.cc:1982

GameApi::MovementNode::rotatez
IMPORT MN rotatez(MN next, float angle)
Definition GameApi.cc:2266

GameApi::MovementNode::wave
IMPORT DC wave(float r, float speed1, float speed2, float dist1, float dist2, int sx, int sy)
Definition GameApi.cc:26089

GameApi::MovementNode::temp_key_activate_ml
IMPORT ML temp_key_activate_ml(EveryApi &ev, ML ml, MN mn, int key, float duration)
Definition GameApi.cc:4089

GameApi::MovementNode::translate
IMPORT MN translate(MN next, float start_time, float end_time, float dx, float dy, float dz)
Definition GameApi.cc:1593

GameApi::MovementNode::anim_choose
IMPORT MN anim_choose(std::vector< MN > vec, float start_time, float duration)
Definition GameApi.cc:2123

GameApi::MovementNode::interpolate
IMPORT MN interpolate(MN n1, MN n2, float start_time, float end_time, float start_value, float end_value)
Definition GameApi.cc:2380

GameApi::MovementNode::cmd_rotate
IMPORT CMD cmd_rotate(CMD cmds, float v_x, float v_y, float v_z, float angle, float delta_angle)
Definition GameApi.cc:21457

GameApi::MovementNode::rot_y_ml
IMPORT ML rot_y_ml(EveryApi &ev, ML ml, int key_forward, int key_backward, float speed, float start_y, float end_y)
Definition GameApi.cc:4120

GameApi::MovementNode::identity
IMPORT DC identity()
Definition GameApi.cc:26081

GameApi::MovementNode::whack_a_mole_exit
IMPORT MN whack_a_mole_exit(EveryApi &ev, MN prev, int exit_num, float &time)
Definition GameApi.cc:41816

GameApi::MovementNode::matrix
IMPORT MN matrix(MN next, M mat)
Definition GameApi.cc:2245

GameApi::MovementNode::whack_a_mole_rotate_around
IMPORT MN whack_a_mole_rotate_around(EveryApi &ev, MN prev, int num, float &time)
Definition GameApi.cc:41804

GameApi::MovementNode::move_ml_projection
IMPORT ML move_ml_projection(EveryApi &ev, ML ml, MN mn, int clone_count=1, float time_delta=10.0)
Definition GameApi.cc:4063

GameApi::MovementNode::move_y_ml
IMPORT ML move_y_ml(EveryApi &ev, ML ml, int key_forward, int key_backward, float speed, float start_y, float end_y)
Definition GameApi.cc:4104

GameApi::MovementNode::whack_a_mole_all
IMPORT MN whack_a_mole_all(EveryApi &ev, int cycle_count, int exit_num)
Definition GameApi.cc:41868

GameApi::MovementNode::key_event
IMPORT ML key_event(EveryApi &ev, ML ml, MN mn, int type, int ch, int button, float duration)
Definition GameApi.cc:4157

GameApi::MovementNode::rot_z_ml
IMPORT ML rot_z_ml(EveryApi &ev, ML ml, int key_forward, int key_backward, float speed, float start_z, float end_z)
Definition GameApi.cc:4125

GameApi::MovementNode::scale_wave
IMPORT MN scale_wave(MN next, float start_time, float end_time, WV wave, float sx, float sy, float sz)
Definition GameApi.cc:1866

GameApi::MovementNode::move_ml
IMPORT ML move_ml(EveryApi &ev, ML ml, MN mn, int clone_count=1, float time_delta=10.0)
Definition GameApi.cc:4053

GameApi::MovementNode::jump_ml
IMPORT ML jump_ml(EveryApi &ev, ML ml, int key_jump, float height, float jump_duration)
Definition GameApi.cc:4099

GameApi::MovementNode::local_move_matrix
IMPORT ML local_move_matrix(EveryApi &ev, ML inner_ml, MS center_points)
Definition GameApi.cc:25921

GameApi::MovementNode::set_matrix
IMPORT void set_matrix(MN n, M m)
Definition GameApi.cc:2387

GameApi::MovementNode::cmd_to_li
IMPORT LI cmd_to_li(CMD cmds, std::string commands)
Definition GameApi.cc:21572

GameApi::MovementNode::player
IMPORT ML player(ML prev)
Definition GameApi.cc:21656

GameApi::MovementNode::scale
IMPORT MN scale(MN next, float start_time, float end_time, float sx, float sy, float sz)
Definition GameApi.cc:1882

GameApi::MovementNode::get_matrix
IMPORT M get_matrix(MN n, float time, float delta_time)
Definition GameApi.cc:2393

GameApi::MovementNode::scale_progress_max
IMPORT MN scale_progress_max(MN next, bool is_x, bool is_y, bool is_z, int state)
Definition GameApi.cc:1758

GameApi::MovementNode::mn_interpolate2
IMPORT MN mn_interpolate2(MN n1, MN n2, float start_time, float end_time)
Definition GameApi.cc:1334

GameApi::MovementNode::sphwave
IMPORT DC sphwave(float r1, float fr_1, float t_1, float r2, float fr_2, float t_2)
Definition GameApi.cc:26093

GameApi::MovementNode::trans2
IMPORT MN trans2(MN next, float dx, float dy, float dz)
Definition GameApi.cc:2231

GameApi::MovementNode::MovementNode
IMPORT MovementNode(Env &e)
Definition GameApi.cc:44498

GameApi::MovementNode::quake_ml2
IMPORT ML quake_ml2(EveryApi &ev, ML ml, float speed, float rot_speed)
Definition GameApi.cc:25563

GameApi::MovementNode::whack_a_mole_start
IMPORT MN whack_a_mole_start(EveryApi &ev, MN prev, float &time)
Definition GameApi.cc:41796

GameApi::MovementNode::fix_root
IMPORT MN fix_root(EveryApi &ev, MN mn)
Definition GameApi.cc:1230

GameApi::MovementNode::rotate_wave
IMPORT MN rotate_wave(MN next, float start_time, float end_time, WV wave, float p_x, float p_y, float p_z, float v_x, float v_y, float v_z, float angle)
Definition GameApi.cc:1973

GameApi::MovementNode::enemy_pos
IMPORT ML enemy_pos(ML prev, PTS pos)
Definition GameApi.cc:21765

GameApi::MovementNode::change_time
IMPORT MN change_time(MN next, float d_time)
Definition GameApi.cc:2315

GameApi::MovementNode::debug_translate
IMPORT MN debug_translate(MN next)
Definition GameApi.cc:1512

GameApi::MovementNode::quake_ml3
IMPORT ML quake_ml3(EveryApi &ev, ML ml, ML ml2, float speed, float rot_speed, float p_x, float p_y, float p_z)
Definition GameApi.cc:25757

GameApi::MovementNode::key_move_ml
IMPORT ML key_move_ml(EveryApi &ev, ML ml, int key_forward, int key_backward, int key_rotate_minus, int key_rotate_plus, float speed, float rot_speed, float start_angle, float start_x, float end_x, float start_z, float end_z)
Definition GameApi.cc:4131

GameApi::MovementNode::mn_empty
IMPORT MN mn_empty()
Definition GameApi.cc:1203

GameApi::MovementNode::rot_x_ml
IMPORT ML rot_x_ml(EveryApi &ev, ML ml, int key_forward, int key_backward, float speed, float start_x, float end_x)
Definition GameApi.cc:4115

GameApi::MovementNode::mn_interpolate
IMPORT MN mn_interpolate(MN n1, MN n2, FF fetcher)
Definition GameApi.cc:1319

GameApi::MovementNode::anim_enable
IMPORT MN anim_enable(MN next, float start_time, float end_time)
Definition GameApi.cc:2113

GameApi::MovementNode::move_z_ml
IMPORT ML move_z_ml(EveryApi &ev, ML ml, int key_forward, int key_backward, float speed, float start_z, float end_z)
Definition GameApi.cc:4109

GameApi::MovementNode::cursor_keys
IMPORT ML cursor_keys(EveryApi &ev, ML ml, int key_up, int key_left, int key_down, int key_right, float speed, float duration)
Definition GameApi.cc:25222

GameApi::MovementNode::cmd_to_plf
IMPORT PLF cmd_to_plf(CMD cmds, std::string commands)
Definition GameApi.cc:21577

GameApi::MovementNode::scale_progress
IMPORT MN scale_progress(MN next, bool is_x, bool is_y, bool is_z, int state)
Definition GameApi.cc:1753

GameApi::MovementNode::compose
IMPORT DC compose(DC d1, DC d2)

GameApi::MovementNode::pose
IMPORT MN pose(MN next, bool pose_in_screen)
Definition GameApi_vr.cc:455

GameApi::MovementNode::color_interpolate
IMPORT CC color_interpolate(CC next, unsigned int color, unsigned int color2, float start_time, float end_time)
Definition GameApi.cc:1380

GameApi::MovementNode::rotatex
IMPORT MN rotatex(MN next, float angle)
Definition GameApi.cc:2256

GameApi::MovementNode::color_start
IMPORT CC color_start(unsigned int color)
Definition GameApi.cc:1376

GameApi::MovementNode::scale2
IMPORT MN scale2(MN next, float sx, float sy, float sz)
Definition GameApi.cc:2251

GameApi::MovementNode::all_cursor_keys
IMPORT ML all_cursor_keys(EveryApi &ev, ML ml, float speed, float duration)
Definition GameApi.cc:25214

GameApi::MovementNode::repeat_ml
IMPORT ML repeat_ml(EveryApi &ev, ML ml, float duration)
Definition GameApi.cc:4048

GameApi::MovementNode::local_move
IMPORT ML local_move(EveryApi &ev, ML inner_ml, PTS center_points)
Definition GameApi.cc:25846

GameApi::MovementNode::move_ml_array
IMPORT ML move_ml_array(EveryApi &ev, std::vector< ML > ml, std::vector< MN > mn)
Definition GameApi.cc:4143

GameApi::MovementNode::default_cmds
IMPORT CMD default_cmds(float dx, float dy, float dz)
Definition GameApi.cc:21448

GameApi::MovementNode::move_ml_p
IMPORT P move_ml_p(EveryApi &ev, P p, MN move, float time)
Definition GameApi.cc:4068

GameApi::MovementNode::cmd_repeat
IMPORT CMD cmd_repeat(CMD cmds, std::string repeat, float dx, float dy, float dz)
Definition GameApi.cc:21452

GameApi::MovementNode::cmd_to_pts
IMPORT PTS cmd_to_pts(CMD cmds, std::string commands)
Definition GameApi.cc:21491

GameApi::MovementNode::enable_ml
IMPORT ML enable_ml(EveryApi &ev, ML ml, float start_time, float end_time)
Definition GameApi.cc:4137

GameApi::MovementNode::quake_ml
IMPORT ML quake_ml(EveryApi &ev, ML ml, float speed, float rot_speed)
Definition GameApi.cc:25397

GameApi::MovementNode::keypress_move_ml
IMPORT ML keypress_move_ml(EveryApi &ev, ML ml, MN mn, int clone_count=1, float time_delta=10.0, int key=32, bool flipenabled=false)
Definition GameApi.cc:4058

GameApi::MovementNode::mn_fetcher
IMPORT MN mn_fetcher(PF pf)
Definition GameApi.cc:1781

GameApi::MovementNode::android_landscape_rotate_inv
IMPORT MN android_landscape_rotate_inv(MN next)
Definition GameApi.cc:1992

GameApi::MovementNode::mn_mouse_y
IMPORT MN mn_mouse_y(FF fetcher, MN move, float start_x, float end_x, float start_y, float end_y, float start_val, float end_val)
Definition GameApi.cc:1327

GameApi::MovementNode::event_activate
IMPORT MN event_activate(MN next, MN event, float event_time, float duration)
Definition GameApi.cc:2225

GameApi::MovementNode::color_ml
IMPORT ML color_ml(EveryApi &ev, int color_num, ML ml, CC cc)
Definition GameApi.cc:4073

GameApi::MovementNode::explosion
IMPORT DC explosion(float center_x, float center_y, float center_z, float start_val, float end_val, float start_time, float end_time)
Definition GameApi.cc:26085

GameApi::MovementNode::comb_key_activate_ml
IMPORT ML comb_key_activate_ml(EveryApi &ev, ML ml, MN mn, int key, int key_2, float duration)
Definition GameApi.cc:4084

GameApi::MovementNode::split
IMPORT DC split(DC d1, DC d2, float val)
Definition GameApi.cc:26118

GameApi::MovementNode::rotate
IMPORT MN rotate(MN next, float start_time, float end_time, float p_x, float p_y, float p_z, float v_x, float v_y, float v_z, float angle)
Definition GameApi.cc:2003

GameApi::MovementNode::time_repeat
IMPORT MN time_repeat(MN next, float start_time, float repeat_duration)
Definition GameApi.cc:2308

GameApi::MovementNode::rotatey
IMPORT MN rotatey(MN next, float angle)
Definition GameApi.cc:2261

GameApi::MovementNode::anim_disable
IMPORT MN anim_disable(MN next, float start_time, float end_time)
Definition GameApi.cc:2118

GameApi::MovementNode::player_pos
IMPORT ML player_pos(ML prev, PT pos)
Definition GameApi.cc:21701

GameApi::MovementNode::rotate_around_axis
IMPORT MN rotate_around_axis(MN next, float p_x, float p_y, float p_z, float v_x, float v_y, float v_z, float angle)
Definition GameApi.cc:2271

GameApi::MovementNode::key_printer_ml
IMPORT ML key_printer_ml(ML ml)
Definition GameApi.cc:4015

GameApi::MovementNode::key_activate_ml
IMPORT ML key_activate_ml(EveryApi &ev, ML ml, MN mn, int key, float duration)
Definition GameApi.cc:4079

GameApi::MovementNode::wasd
IMPORT ML wasd(EveryApi &ev, ML ml, MN w, MN a, MN s, MN d, float duration)
Definition GameApi.cc:4163

GameApi::MovementNode::level
IMPORT MN level(MN next)
Definition GameApi.cc:1402

GameApi::MovementNode::enemy
IMPORT ML enemy(ML prev)
Definition GameApi.cc:21661

GameApi::MovementNode::move_x_ml
IMPORT ML move_x_ml(EveryApi &ev, ML ml, int key_forward, int key_backward, float speed, float start_x, float end_x)
Definition GameApi.cc:4094

GameApi::NewPlaneApi
Definition GameApi.hh:3613

GameApi::NewPlaneApi::trans
IMPORT PP trans(PP pl, float dx, float dy)

GameApi::NewPlaneApi::reverse_faces
PLF reverse_faces(PLF faces)
Definition GameApi_plane.cc:429

GameApi::NewPlaneApi::single_elem
IMPORT std::vector< PP > single_elem(PP p1)

GameApi::NewPlaneApi::or_elem
IMPORT std::vector< PP > or_elem(PP p1, PP p2)

GameApi::NewPlaneApi::cicle
IMPORT PP cicle(PT center, float radius, int numpoints)

GameApi::NewPlaneApi::triangulate
PLF triangulate(PLF faces)
Definition GameApi_plane.cc:381

GameApi::NewPlaneApi::to_lines
IMPORT LI to_lines(PP pl, float z)

GameApi::NewPlaneApi::NewPlaneApi
IMPORT NewPlaneApi(Env &e)
Definition GameApi.cc:44514

GameApi::NewPlaneApi::to_poly
IMPORT P to_poly(PP pl, float z)

GameApi::NewPlaneApi::color_function
IMPORT PP color_function(PP pl, std::function< unsigned int(int idx)> f)

GameApi::NewPlaneApi::to_polygon
P to_polygon(PLF faces)
Definition GameApi_plane.cc:435

GameApi::NewPlaneApi::function
IMPORT PP function(std::function< PT(int idx)> f, int num_points, float px, float py, float sx, float sy)

GameApi::NewPlaneApi::polygon
IMPORT PP polygon(std::vector< PT > vec)

GameApi::NewPlaneApi::star
IMPORT PP star(PT center, float radius_1, float radius_2, int numpoints)

GameApi::NewPlaneApi::polygon2
IMPORT PP polygon2(PTS pts)

GameApi::NewPlaneApi::color
IMPORT PP color(PP p, unsigned int color)

GameApi::NewPlaneApi::or_elem
IMPORT std::vector< PP > or_elem(std::vector< PP > p1, std::vector< PP > p2)

GameApi::ObjectMoveApi::render_all
void render_all(VAA orig)
Definition GameApi.cc:829

GameApi::ObjectMoveApi::add_object
OM add_object(OM orig, int index, P obj)
Definition GameApi.cc:783

GameApi::ObjectMoveApi::change_pos
OM change_pos(OM orig, int index, M mat)
Definition GameApi.cc:803

GameApi::ObjectMoveApi::ObjectMoveApi
IMPORT ObjectMoveApi(Env &e)
Definition GameApi.cc:44521

GameApi::ObjectMoveApi::clear_object
OM clear_object(OM orig, int index)
Definition GameApi.cc:792

GameApi::ObjectMoveApi::prepare_all
VAA prepare_all(OM orig)
Definition GameApi.cc:812

GameApi::PathApi::PathApi
IMPORT PathApi(Env &e)

GameApi::PathApi::loop
LA loop(PA p)

GameApi::PathApi::object
P object(LA l, PT o, float dx, float dy, float dz)

GameApi::PathApi::cube
PA cube(PT pos, PT p_x, PT p_y, PT p_z, int sx, int sy, int sz)

GameApi::PathApi::cross
PA cross(PT pos, PA p1, PA p2)

GameApi::PathApi::grid
PA grid(PT pos, PT p_x, PT p_y, int sx, int sy)

GameApi::PathApi::line
PA line(PT p1, PT p2, int splitnum)

GameApi::PathApi::point
PA point(PT p)

GameApi::PathApi::~PathApi
~PathApi()

GameApi::PathApi::next_point
PA next_point(PA pa, PT p)

GameApi::PhysicsApi
Definition GameApi.hh:2006

GameApi::PhysicsApi::ext_force_all
IMPORT PH ext_force_all(PH phy, V dir)
Definition GameApi_phy.cc:105

GameApi::PhysicsApi::phy_empty
IMPORT PH phy_empty()
Definition GameApi_phy.cc:21

GameApi::PhysicsApi::init_points
IMPORT PTS init_points(PH pos)
Definition GameApi_phy.cc:281

GameApi::PhysicsApi::phy_from_p
IMPORT PH phy_from_p(P p)
Definition GameApi_phy.cc:236

GameApi::PhysicsApi::num_links
IMPORT int num_links(PH phy)
Definition GameApi_phy.cc:257

GameApi::PhysicsApi::anchor_point
IMPORT PHI anchor_point(PH phy, PT pos)
Definition GameApi_phy.cc:41

GameApi::PhysicsApi::force_obj
IMPORT PH force_obj(PH phy, O obj, V dir)
Definition GameApi_phy.cc:163

GameApi::PhysicsApi::num_anchors
IMPORT int num_anchors(PH phy)
Definition GameApi_phy.cc:246

GameApi::PhysicsApi::anchor_point2
PH anchor_point2(PH phy, PT pos)
Definition GameApi.hh:2012

GameApi::PhysicsApi::anchor_link
IMPORT PH anchor_link(PH phy, int p1, int p2, float dist)
Definition GameApi_phy.cc:137

GameApi::PhysicsApi::num_force_volumes
IMPORT int num_force_volumes(PH phy)
Definition GameApi_phy.cc:262

GameApi::PhysicsApi::physics_action
IMPORT PTS physics_action(EveryApi &ev, PH phy)
Definition GameApi_phy.cc:330

GameApi::PhysicsApi::PhysicsApi
IMPORT PhysicsApi(Env &e)
Definition GameApi.cc:44493

GameApi::PhysicsApi::step_points
IMPORT void step_points(PH phy, PTA prev_frame, float timestep)
Definition GameApi_phy.cc:336

GameApi::PhysicsApi::ext_force
IMPORT PH ext_force(PH phy, int point, V dir)
Definition GameApi_phy.cc:78

GameApi::PhysicsApi::num_forces
IMPORT int num_forces(PH phy, int anchor)
Definition GameApi_phy.cc:252

GameApi::PickingApi
Definition GameApi.hh:1841

GameApi::PickingApi::PickingApi
IMPORT PickingApi(Env &e)
Definition GameApi.cc:44489

GameApi::PickingApi::picked
bool picked(O o, float x, float y, float z)
Definition GameApi.cc:4221

GameApi::PickingApi::pick_volume
O pick_volume(M in_P, BB pick)
Definition GameApi.cc:4209

GameApi::PickingApi::pick_area
BB pick_area(EveryApi &ev, float mouse_x, float mouse_y, float radius, int scr_size_x, int scr_size_y)
Definition GameApi.cc:4175

GameApi::PlaneApi
Definition GameApi.hh:3644

GameApi::PlaneApi::to_polygon_face
IMPORT P to_polygon_face(PL triangulated_pl, PT pos, V u_x, V u_y)

GameApi::PlaneApi::render
IMPORT void render(PLA pl, float x, float y, float mult_x, float mult_y)

GameApi::PlaneApi::empty
IMPORT PL empty(float sx, float sy)

GameApi::PlaneApi::or_plane
PL or_plane(PL p1, PL p2)

GameApi::PlaneApi::substitute_quads_with_plane
IMPORT P substitute_quads_with_plane(P orig, PL(*fptr)(EveryApi &ev, int face, void *data), void *data)

GameApi::PlaneApi::circle
IMPORT PL circle(PL bg, PT center, float radius, int numpoints)

GameApi::PlaneApi::render_p
IMPORT PL render_p(P p, M proj_matrix, float sx, float sy)

GameApi::PlaneApi::empty_plane
IMPORT PL empty_plane(float sx, float sy)

GameApi::PlaneApi::to_polygon_lines_1
P to_polygon_lines_1(PL pl, PT pos, V u_x, V u_y, V u_z, float z_mult)

GameApi::PlaneApi::move
IMPORT PL move(PL pl, float dx, float dy)

GameApi::PlaneApi::color_function
IMPORT PL color_function(PL pl, CO(*fptr)(EveryApi &ev, int idx, PT pos, void *data), void *data)

GameApi::PlaneApi::rectangle
IMPORT PL rectangle(PL bg, PT p1, PT p2)

GameApi::PlaneApi::prepare
IMPORT PLA prepare(PL pl)

GameApi::PlaneApi::to_polygon_strip
IMPORT P to_polygon_strip(EveryApi &ev, PL pl, PT pos, V u_x, V u_y)

GameApi::PlaneApi::plane_in_3d
IMPORT P plane_in_3d(PL plane, PT u_p, V v1, V v2)

GameApi::PlaneApi::function
IMPORT PL function(PT(*fptr)(EveryApi &e, int idx, void *data), int num_points, float sx, float sy, void *data)

GameApi::PlaneApi::star
IMPORT PL star(PT center, float radius_1, float radius_2, int numpoints)

GameApi::PlaneApi::triangulate
IMPORT std::pair< PL, PL > triangulate(EveryApi &ev, PL pl, int obj)

GameApi::PlaneApi::floodfill_border
IMPORT PL floodfill_border(BB bitmap, int x, int y)

GameApi::PlaneApi::to_polygon_lines
IMPORT P to_polygon_lines(PL pl, PT pos, V u_x, V u_y, V u_z, float z_mult)

GameApi::PlaneApi::render_bool
IMPORT BB render_bool(PL pl, int num, int sx, int sy)

GameApi::PlaneApi::flip_y
IMPORT PL flip_y(PL pl)

GameApi::PlaneApi::plane_array
IMPORT PL plane_array(PL *array, int size)

GameApi::PlaneApi::polygon
IMPORT PL polygon(PL bg, PT *points, int size)

GameApi::PlaneApi::PlaneApi
IMPORT PlaneApi(Env &e)
Definition GameApi_pla.cc:4

GameApi::PlaneApi::plane_elem
IMPORT PL plane_elem(PL p1, PL p2)

GameApi::PlaneApi::render_continuous
CBM render_continuous(PL pl, int num, unsigned int color_0, unsigned int color_1)

GameApi::PlaneApi::and_not
IMPORT PL and_not(PL p1, PL not_p)

GameApi::PlaneApi::color
IMPORT PL color(PL orig, unsigned int new_color)

GameApi::PlaneApi::sprite
IMPORT PL sprite(PL bg, BM bitmap, PT pos, float size_x, float size_y)

GameApi::PlaneApi::circle
IMPORT PL circle(PT center, float radius, int numpoints)

GameApi::PlaneApi::rectangle
IMPORT PL rectangle(PL bg, PT p1, PT p2, PT p3, PT p4)

GameApi::PlaneApi::remove_empty_faces
IMPORT PL remove_empty_faces(PL pl)

GameApi::PlaneApi::triangulate_all
IMPORT PL triangulate_all(EveryApi &ev, PL pl, int point_count, int max_obj)

GameApi::PlaneApi::to_polygon
IMPORT P to_polygon(EveryApi &ev, PL pl, PT pos, V u_x, V u_y, V u_z, float z_mult)

GameApi::PlaneApi::remove_splines
IMPORT PL remove_splines(PL pl, float xdelta)

GameApi::PlaneApi::move_plane
IMPORT PL move_plane(PL p1, V delta)

GameApi::PointApi
Definition GameApi.hh:3943

GameApi::PointApi::move
IMPORT PT move(PT p1, float dx, float dy, float dz=0.0)
Definition GameApi_pt.cc:12

GameApi::PointApi::point
IMPORT PT point(float x, float y, float z=0.0)
Definition GameApi_pt.cc:8

GameApi::PointApi::from_angle
IMPORT PT from_angle(float radius, float angle)
Definition GameApi_pt.cc:70

GameApi::PointApi::dist3d
IMPORT float dist3d(PT p, PT p2)
Definition GameApi_pt.cc:43

GameApi::PointApi::spherical_coords
IMPORT PT spherical_coords(PT pos)
Definition GameApi_pt.cc:82

GameApi::PointApi::pt_x
IMPORT float pt_x(PT p)
Definition GameApi_pt.cc:31

GameApi::PointApi::cartesian_coords
IMPORT PT cartesian_coords(PT pos)
Definition GameApi_pt.cc:94

GameApi::PointApi::minus
IMPORT V minus(PT p1, PT p2)
Definition GameApi_pt.cc:60

GameApi::PointApi::dist2d
IMPORT float dist2d(PT p, PT p2)
Definition GameApi_pt.cc:50

GameApi::PointApi::pt_z
IMPORT float pt_z(PT p)
Definition GameApi_pt.cc:39

GameApi::PointApi::pt_y
IMPORT float pt_y(PT p)
Definition GameApi_pt.cc:35

GameApi::PointApi::mix
IMPORT PT mix(PT p1, PT p2, float val)
Definition GameApi_pt.cc:24

GameApi::PointApi::origo
IMPORT PT origo()
Definition GameApi_pt.cc:4

GameApi::PointApi::PointApi
IMPORT PointApi(Env &e)
Definition GameApi_pt.cc:68

GameApi::PointCollectionApi::array
IMPORT PC array(PT *array, int size)

GameApi::PointCollectionApi::empty
IMPORT PC empty()

GameApi::PointCollectionApi::single
IMPORT PC single(PT point)

GameApi::PointCollectionApi::single
IMPORT PC single(float x, float y, float z)

GameApi::PointCollectionApi::bezier
IMPORT PC bezier(PT *array, PT *control_array, int size, int iteration_count)

GameApi::PointCollectionApi::tri_object3d
IMPORT P tri_object3d(PC p)

GameApi::PointCollectionApi::PointCollectionApi
IMPORT PointCollectionApi(Env &e)
Definition GameApi.cc:44516

GameApi::PointsApi
Definition GameApi.hh:4032

GameApi::PointsApi::movement_display
IMPORT ML movement_display(EveryApi &ev, ML ml, MN mn, int count, int sx, int sy, int sz, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)
Definition GameApi_pts.cc:1623

GameApi::PointsApi::update_from_data
void update_from_data(MSA array, MS p, bool draw=true)

GameApi::PointsApi::wave_points
IMPORT PTS wave_points(WV wave, int num_samples, float pos_x, float pos_y, float pos_z, float u_x_x, float u_x_y, float u_x_z, float u_y_x, float u_y_y, float u_y_z)
Definition GameApi.cc:26154

GameApi::PointsApi::collision_bind_inst
IMPORT ML collision_bind_inst(EveryApi &ev, PTS bounding_box, PTS inst_points, std::string name)
Definition GameApi_pts.cc:2272

GameApi::PointsApi::random_bitmap_instancing
IMPORT PTS random_bitmap_instancing(EveryApi &ev, BB bm, int count, float start_x, float end_x, float start_y, float end_y, float z)
Definition GameApi_pts.cc:1475

GameApi::PointsApi::pressure_gradient
IMPORT VFi pressure_gradient(FFi pressure)
Definition GameApi_pts.cc:2936

GameApi::PointsApi::matrix_points
IMPORT PTS matrix_points(PTS orig, M matrix)
Definition GameApi_pts.cc:1550

GameApi::PointsApi::world_filter
IMPORT PTS world_filter(PTS points)
Definition GameApi.cc:45496

GameApi::PointsApi::matrix_display
IMPORT LI matrix_display(EveryApi &ev, M matrix)
Definition GameApi_pts.cc:1556

GameApi::PointsApi::surface
IMPORT PTS surface(S surf, int sx, int sy)
Definition GameApi_pts.cc:1292

GameApi::PointsApi::rot_y
IMPORT PTS rot_y(PTS obj, float angle)
Definition GameApi_pts.cc:494

GameApi::PointsApi::pos_z
IMPORT float pos_z(PTS p, int index)
Definition GameApi_pts.cc:1322

GameApi::PointsApi::update
void update(PTA array, GameApi::P pp, bool slow=false)
Definition GameApi_pts.cc:738

GameApi::PointsApi::hemisphere_points
IMPORT PTS hemisphere_points(PT points, V normal, float r, int numpoints)
Definition GameApi_pts.cc:2609

GameApi::PointsApi::PointsApi
IMPORT PointsApi(Env &e)
Definition GameApi.cc:44518

GameApi::PointsApi::pts_render
IMPORT ML pts_render(EveryApi &ev, PTS pts)
Definition GameApi_pts.cc:2078

GameApi::PointsApi::prepare
IMPORT PTA prepare(PTS p, bool color_from_instance)
Definition GameApi_pts.cc:937

GameApi::PointsApi::iterate_points
IMPORT PTS iterate_points(PTS points, VFi field, FA speed)
Definition GameApi_pts.cc:2877

GameApi::PointsApi::unit_cube
IMPORT PTS unit_cube(PTS orig, PT pos, V u_x, V u_y, V u_z)

GameApi::PointsApi::pts_grid
IMPORT PTS pts_grid(BM bm, float start_x, float end_x, float start_y, float en_y, float z)
Definition GameApi_pts.cc:1965

GameApi::PointsApi::or_points
IMPORT PTS or_points(PTS p1, PTS p2)
Definition GameApi_pts.cc:507

GameApi::PointsApi::combine_pts
IMPORT PTS combine_pts(PTS p1, PTS p2)
Definition GameApi_pts.cc:90

GameApi::PointsApi::random_plane
IMPORT PTS random_plane(PT pos, V u_x, V u_y, int numpoints)
Definition GameApi_pts.cc:344

GameApi::PointsApi::height_field_p
IMPORT P height_field_p(P faces, CFB landscape, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)
Definition GameApi_pts.cc:3918

GameApi::PointsApi::pts_lines
IMPORT PTS pts_lines(std::string url, float start_pos, float dist, float speed)
Definition GameApi_pts.cc:3747

GameApi::PointsApi::scale
IMPORT PTS scale(PTS obj, float sx, float sy, float sz)
Definition GameApi_pts.cc:386

GameApi::PointsApi::pts_grid_bb
IMPORT PTS pts_grid_bb(BB bb, float start_x, float end_x, float start_y, float en_y, float z)
Definition GameApi_pts.cc:2024

GameApi::PointsApi::random_lattice
IMPORT PTS random_lattice(EveryApi &ev, int sx, int sy, int sz, float s_x, float s_y, float s_z, float px, float py, float pz, int count)
Definition GameApi_pts.cc:1916

GameApi::PointsApi::polygon_face_center_points
IMPORT PTS polygon_face_center_points(P p)
Definition GameApi_pts.cc:2700

GameApi::PointsApi::random_mesh_quad_instancing
IMPORT PTS random_mesh_quad_instancing(EveryApi &ev, P p, int count)
Definition GameApi_pts.cc:1922

GameApi::PointsApi::unit_to_flex
IMPORT PTS unit_to_flex(PTS orig, PT bTL, PT bTR, PT bBL, PT bBR, PT fTL, PT fTR, PT fBL, PT fBR)

GameApi::PointsApi::render_ml
IMPORT ML render_ml(EveryApi &ev, PTA array)
Definition GameApi_pts.cc:1463

GameApi::PointsApi::random_mesh_quad_instancing_color
IMPORT PTS random_mesh_quad_instancing_color(EveryApi &ev, P p, int count, std::vector< BM > textures)
Definition GameApi_pts.cc:1838

GameApi::PointsApi::collision_collect
IMPORT ML collision_collect(ML mainloop)
Definition GameApi_pts.cc:2428

GameApi::PointsApi::random_speeds
IMPORT FA random_speeds(float start_speed, float end_speed, int num)
Definition GameApi_pts.cc:2910

GameApi::PointsApi::points_field
IMPORT PTS points_field(float start_speed_y, float end_speed_y, int numpoints, float start_x, float end_x, float start_y, float end_y)
Definition GameApi_pts.cc:3599

GameApi::PointsApi::explode
IMPORT void explode(PTA array, float x, float y, float z, float dist)
Definition GameApi_pts.cc:1129

GameApi::PointsApi::ply_faces
IMPORT P ply_faces(std::string url)
Definition GameApi_pts.cc:3538

GameApi::PointsApi::collision_points
IMPORT PTS collision_points(float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)
Definition GameApi_pts.cc:2172

GameApi::PointsApi::point_access
float * point_access(PTA pta, int pointnum)
Definition GameApi_pts.cc:577

GameApi::PointsApi::sort_pts
IMPORT PTS sort_pts(PTS p)
Definition GameApi_pts.cc:2559

GameApi::PointsApi::from_volume
IMPORT PTS from_volume(O o, PT pos, V u_x, V u_y, V u_z, int sx, int sy, int sz)
Definition GameApi_pts.cc:409

GameApi::PointsApi::random_points_in_plane
IMPORT PTS random_points_in_plane(EveryApi &ev, float key, float start_x, float end_x, float start_z, float end_z, float y, int num)
Definition GameApi_pts.cc:3752

GameApi::PointsApi::color_function
IMPORT PTS color_function(PTS orig, std::function< unsigned int(int pointnum, PT pos)> f)
Definition GameApi_pts.cc:1248

GameApi::PointsApi::pos_x
IMPORT float pos_x(PTS p, int index)
Definition GameApi_pts.cc:1312

GameApi::PointsApi::li_pts2
IMPORT PTS li_pts2(LI li)
Definition GameApi_pts.cc:2497

GameApi::PointsApi::pts_alt
IMPORT PTS pts_alt(std::vector< PTS > vec, int index)
Definition GameApi_pts.cc:3631

GameApi::PointsApi::update_from_data
void update_from_data(PTA array, PTS p, bool draw=true)
Definition GameApi_pts.cc:679

GameApi::PointsApi::unit_to_cube
IMPORT PTS unit_to_cube(PTS orig, PT pos, V u_x, V u_y, V u_z)

GameApi::PointsApi::block_ms_lod
IMPORT MS block_ms_lod(MS pts, float start_x, float end_x, float start_y, float end_y, int max_points_visible, float ncd_z_s, float ncd_z_e)
Definition GameApi_pl.cc:23930

GameApi::PointsApi::move
IMPORT PTS move(PTS obj, float dx, float dy, float dz)
Definition GameApi_pts.cc:423

GameApi::PointsApi::bullet
IMPORT PTS bullet(int key, float vx, float vy, float vz, float px, float py, float pz, float dist, int max_count, float repeat_time)
Definition GameApi_pts.cc:2808

GameApi::PointsApi::rot_x
IMPORT PTS rot_x(PTS obj, float angle)
Definition GameApi_pts.cc:488

GameApi::PointsApi::set_point
IMPORT void set_point(PTA pta, int pointnum, float x, float y, float z)
Definition GameApi_pts.cc:582

GameApi::PointsApi::world_filter_cursor
IMPORT ML world_filter_cursor(ML ml, float start_delta_x, float end_delta_x, float start_delta_y, float end_delta_y, float start_delta_z, float end_delta_z)
Definition GameApi.cc:45614

GameApi::PointsApi::publish_heightfield
IMPORT ML publish_heightfield(ML ml, CFB landscape, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)
Definition GameApi_pts.cc:3905

GameApi::PointsApi::color_points
IMPORT PTS color_points(PTS p, unsigned int color)
Definition GameApi_pts.cc:1370

GameApi::PointsApi::collision_bind
IMPORT ML collision_bind(EveryApi &ev, PTS bounding_box, std::string name)
Definition GameApi_pts.cc:2255

GameApi::PointsApi::li_pts
IMPORT PTS li_pts(LI li, float pos)
Definition GameApi_pts.cc:2492

GameApi::PointsApi::num_points
IMPORT int num_points(PTA pta)
Definition GameApi_pts.cc:567

GameApi::PointsApi::pos_y
IMPORT float pos_y(PTS p, int index)
Definition GameApi_pts.cc:1317

GameApi::PointsApi::block_pts_debug
IMPORT PTS block_pts_debug()
Definition GameApi_pl.cc:23925

GameApi::PointsApi::anim_rot_pts
IMPORT PTS anim_rot_pts(PTS pts, float start_time, float end_time, float v_x, float v_y, float v_z, float rotate_amount)
Definition GameApi.cc:26235

GameApi::PointsApi::cbm_to_cfb
IMPORT CFB cbm_to_cfb(CBM bm, float red_mult, float red_add, float green_mult, float green_add, float blue_mult, float blue_add, float alpha_mult, float alpha_add)
Definition GameApi_pts.cc:3960

GameApi::PointsApi::shadow_points
IMPORT PTS shadow_points(PTS obj, PT pos, V u_x, V u_y, V light_vec)
Definition GameApi_pts.cc:551

GameApi::PointsApi::matrix_field
IMPORT VFi matrix_field(MN start, MN end)
Definition GameApi_pts.cc:2958

GameApi::PointsApi::block_pts_lod
IMPORT PTS block_pts_lod(PTS pts, float start_x, float end_x, float start_y, float end_y, int max_points_visible, float ncd_z_s, float ncd_z_e)
Definition GameApi_pl.cc:23919

GameApi::PointsApi::filter_component
IMPORT PTS filter_component(PTS pts, int comp, float val)
Definition GameApi.cc:26192

GameApi::PointsApi::li_from_pts
IMPORT LI li_from_pts(PTS pts, float dx, float dy, float dz)
Definition GameApi_pts.cc:2072

GameApi::PointsApi::single_pts
IMPORT PTS single_pts()
Definition GameApi_pts.cc:2041

GameApi::PointsApi::voxelarray_to_pts
IMPORT PTS voxelarray_to_pts(AV arr)

GameApi::PointsApi::ply_pts
IMPORT PTS ply_pts(std::string url)
Definition GameApi_pts.cc:3372

GameApi::PointsApi::load_points
IMPORT PTS load_points(std::string url)
Definition GameApi_pts.cc:259

GameApi::PointsApi::from_float_volume
IMPORT PTS from_float_volume(FO float_volume, int numpoints, float start_x, float start_y, float start_z, float end_x, float end_y, float end_z)
Definition GameApi_pts.cc:1115

GameApi::PointsApi::colour_divisor_calc
IMPORT int colour_divisor_calc(P p)
Definition GameApi_pts.cc:656

GameApi::PointsApi::block_pts
IMPORT PTS block_pts(PTS pts, float d, int max_points_visible)
Definition GameApi_pl.cc:23530

GameApi::PointsApi::NumPoints
IMPORT int NumPoints(PTS p)
Definition GameApi_pts.cc:1302

GameApi::PointsApi::heightmap
IMPORT PTS heightmap(BM colour, FB floatbitmap, PT pos, V u_x, V u_y, V u_z, int sx, int sy)
Definition GameApi_pts.cc:393

GameApi::PointsApi::standard_box
IMPORT PTS standard_box(int sx, int sy, int sz, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)
Definition GameApi_pts.cc:1536

GameApi::PointsApi::pt_array
IMPORT PTS pt_array(EveryApi &ev, std::vector< PT > vec)
Definition GameApi_pts.cc:2451

GameApi::PointsApi::anim_mix
IMPORT PTS anim_mix(PTS o1, PTS o2, float start_val, float end_val, float start_time, float end_time)
Definition GameApi_pts.cc:482

GameApi::PointsApi::rot_z
IMPORT PTS rot_z(PTS obj, float angle)
Definition GameApi_pts.cc:500

GameApi::PointsApi::height_field_pts
IMPORT PTS height_field_pts(PTS points, CFB landscape, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)
Definition GameApi_pts.cc:3911

GameApi::PointsApi::memoize_pts
IMPORT PTS memoize_pts(PTS pts)
Definition GameApi_pts.cc:2130

GameApi::PointsApi::matrix2_display
IMPORT LI matrix2_display(EveryApi &ev, M matrix1, M matrix2, int sx, int sy, int sz, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)
Definition GameApi_pts.cc:1563

GameApi::PointsObj::set_bounds
void set_bounds(float s_x, float s_y, float s_z, float e_x, float e_y, float e_z)
Definition GameApi.hh:5652

GameApi::PointsObj::set_numpoints
void set_numpoints(int count)
Definition GameApi.hh:5651

GameApi::PointsObj::PointsObj
PointsObj(EveryApi &ev, PTS fo, SH sh, P pp, float mix)
Definition GameApi.hh:5637

GameApi::PointsObj::set_rotation_matrix2
void set_rotation_matrix2(M m)
Definition GameApi.hh:5687

GameApi::PointsObj::render
void render()
Definition GameApi.hh:5666

GameApi::PointsObj::set_pos
void set_pos(float pos_x, float pos_y, float pos_z)
Definition GameApi.hh:5672

GameApi::PointsObj::set_rotation_matrix
void set_rotation_matrix(M m)
Definition GameApi.hh:5682

GameApi::PointsObj::set_scale
void set_scale(float mult_x, float mult_y, float mult_z)
Definition GameApi.hh:5677

GameApi::PointsObj::prepare
void prepare(bool keep=false)
Definition GameApi.hh:5662

GameApi::PointsObj::set_var
void set_var(std::string name, float r, float g, float b, float a)
Definition GameApi.hh:5688

GameApi::PolygonApi
Definition GameApi.hh:2922

GameApi::PolygonApi::p_ds_inv
IMPORT DS p_ds_inv(P model, int flags=-1)
Definition GameApi_pl.cc:18074

GameApi::PolygonApi::spatial_decimate
IMPORT P spatial_decimate(P p, float val)
Definition GameApi_pl.cc:31367

GameApi::PolygonApi::unit_to_flex
IMPORT P unit_to_flex(P orig, PT bTL, PT bTR, PT bBL, PT bBR, PT fTL, PT fTR, PT fBL, PT fBR)
Definition GameApi_pl.cc:1112

GameApi::PolygonApi::anim_target_scale
IMPORT P anim_target_scale(P p, PT center, float scale_x, float scale_y, float scale_z)
Definition GameApi_pl.cc:13652

GameApi::PolygonApi::bg_image
IMPORT ML bg_image(EveryApi &ev, BM bm)
Definition GameApi_pl.cc:3391

GameApi::PolygonApi::substitute
IMPORT P substitute(P p1, P p2, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, float normal)
Definition GameApi_pl.cc:24136

GameApi::PolygonApi::color_distance
IMPORT P color_distance(P faces, float center_x, float center_y, float center_z, unsigned int color_center, unsigned int color_dist, float dist_center, float dist_dist)
Definition GameApi_pl.cc:933

GameApi::PolygonApi::material_index
IMPORT MT material_index(EveryApi &ev, std::vector< MT > vec, int index)
Definition GameApi_pl.cc:18476

GameApi::PolygonApi::file_cache
IMPORT P file_cache(P model, std::string filename, int obj_num)
Definition GameApi_pl.cc:14813

GameApi::PolygonApi::ske_anim
IMPORT ML ske_anim(EveryApi &ev, P mesh, LI orig_pose, int li_size, std::string url, std::vector< LI > new_poses, MT mat)
Definition GameApi_pl.cc:25449

GameApi::PolygonApi::log_coords2
IMPORT P log_coords2(P p, int x_count, int y_count, float sx, float sy, float sz)
Definition GameApi_pl.cc:16635

GameApi::PolygonApi::shadow_shader
IMPORT ML shadow_shader(EveryApi &ev, ML mainloop, int tex_num, float p_x, float p_y, float p_z, unsigned int dark_color, float mix)
Definition GameApi_pl.cc:12769

GameApi::PolygonApi::get_tri_vertex_array_frames
IMPORT int get_tri_vertex_array_frames(P p)
Definition GameApi_pl.cc:6092

GameApi::PolygonApi::replace_texture
IMPORT P replace_texture(P p, BM bm, int num)
Definition GameApi_pl.cc:19115

GameApi::PolygonApi::mesh_anim_display_inst
IMPORT ML mesh_anim_display_inst(EveryApi &ev, P p, FF val, MN move, MT mat, MS inst)
Definition GameApi_pl.cc:22912

GameApi::PolygonApi::texture_storage
IMPORT P texture_storage(P p, int texture_sx, int texture_sy)
Definition GameApi_pl.cc:19065

GameApi::PolygonApi::piechart_full
IMPORT ML piechart_full(EveryApi &ev, float c_x, float c_y, std::string url, float radius, int numsteps, float start_z, float end_z)
Definition GameApi_diag.cc:457

GameApi::PolygonApi::renderpoly
IMPORT void renderpoly(P p, float x, float y, float z)
Definition GameApi_pl.cc:5771

GameApi::PolygonApi::sfo_sandbox_shader
IMPORT ML sfo_sandbox_shader(EveryApi &ev, ML mainloop, SFO sfo)
Definition GameApi_pl.cc:12644

GameApi::PolygonApi::render_vertex_array_ml2_texture
IMPORT ML render_vertex_array_ml2_texture(EveryApi &ev, P va, std::vector< BM > vec, std::vector< int > types=std::vector< int >(), std::vector< std::string > id_labels=std::vector< std::string >(), std::vector< bool > is_srgb=std::vector< bool >())
Definition GameApi_pl.cc:12807

GameApi::PolygonApi::mix_mesh
IMPORT P mix_mesh(P p, PTS points, float val)
Definition GameApi_pl.cc:22411

GameApi::PolygonApi::render_dynamic_ml
IMPORT ML render_dynamic_ml(EveryApi &ev, P p, DC dyn)
Definition GameApi_pl.cc:12827

GameApi::PolygonApi::cube_map
IMPORT P cube_map(float start_x, float end_x, float stary_y, float end_y, float start_z, float end_z, BM bm_front, BM bm_back, BM bm_left, BM bm_right, BM bm_top, BM bm_bottom)

GameApi::PolygonApi::quad
IMPORT P quad(PT p1, PT p2, PT p3, PT p4)
Definition GameApi_pl.cc:3351

GameApi::PolygonApi::meshanim_anim_meshes
IMPORT ARR meshanim_anim_meshes(MA ma, float start_time, float delta_time, int count)
Definition GameApi_pl.cc:20552

GameApi::PolygonApi::or_elem_pl
IMPORT PL or_elem_pl(PL pl1, PL pl2)
Definition GameApi_pl.cc:27813

GameApi::PolygonApi::p_mtl2_prepare
IMPORT ML p_mtl2_prepare(P p)
Definition GameApi_pl.cc:18700

GameApi::PolygonApi::print_stat
IMPORT void print_stat(P p)
Definition GameApi_pl.cc:682

GameApi::PolygonApi::colourspace_or_elem
IMPORT CS colourspace_or_elem(CS cs, float delta_t, CS cs2, float delta_t2)
Definition GameApi_pl.cc:28230

GameApi::PolygonApi::texture_add
IMPORT P texture_add(P p, BM bm)
Definition GameApi_pl.cc:21082

GameApi::PolygonApi::gradient_color
IMPORT P gradient_color(P p, float p_x, float p_y, float p_z, float v_x, float v_y, float v_z, unsigned int start_color, unsigned int end_color)
Definition GameApi_pl.cc:22313

GameApi::PolygonApi::decimate3
IMPORT P decimate3(P p, float val)
Definition GameApi_pl.cc:30042

GameApi::PolygonApi::parse_mtl
IMPORT std::vector< MaterialDef > parse_mtl(std::string filename)
Definition GameApi_pl.cc:18258

GameApi::PolygonApi::cube_anim
IMPORT P cube_anim(float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, float start_x2, float end_x2, float start_y2, float end_y2, float start_z2, float end_z2, float start_time, float end_time)
Definition GameApi_pl.cc:26747

GameApi::PolygonApi::lod_set
IMPORT P lod_set(P p, std::string name, int value)
Definition GameApi_pl.cc:21759

GameApi::PolygonApi::colour_shader
IMPORT ML colour_shader(EveryApi &ev, ML mainloop, float mix)
Definition GameApi_pl.cc:12744

GameApi::PolygonApi::convex_hull
IMPORT P convex_hull(PTS pts)
Definition GameApi_pl.cc:24643

GameApi::PolygonApi::combine_sbm
IMPORT SBM combine_sbm(SBM texture1, SBM texture2)
Definition GameApi_pl.cc:16458

GameApi::PolygonApi::shading_shader
IMPORT ML shading_shader(EveryApi &ev, ML mainloop, unsigned int level1, unsigned int level2, unsigned int level3, float spec_size=5.0f, bool ambient=true, bool diffuse=true, bool specular=false)
Definition GameApi_pl.cc:12784

GameApi::PolygonApi::decimate2
IMPORT P decimate2(P p, float val)
Definition GameApi_pl.cc:29327

GameApi::PolygonApi::z_split
IMPORT P z_split(P p, float z, float z_0, float z_1)
Definition GameApi_pl.cc:27011

GameApi::PolygonApi::filter_invisible
IMPORT P filter_invisible(P p, float size)
Definition GameApi_pl.cc:21508

GameApi::PolygonApi::shadow
IMPORT P shadow(P orig, PT pos, V u_x, V u_y, V light_vec)
Definition GameApi_pl.cc:3701

GameApi::PolygonApi::poly_execute
IMPORT ARR poly_execute(EveryApi &ev, ARR arr, std::string gameapi_script)
Definition GameApi_pl.cc:16046

GameApi::PolygonApi::tri_vertex_array
IMPORT P tri_vertex_array(float *v_array, int v_size, float *n_array, int n_size, unsigned int *c_array, int c_size, float *tex_array, int tex_size, float **attrib_array, int a_size1, int a_size2)
Definition GameApi_pl.cc:6072

GameApi::PolygonApi::transparent_separate
IMPORT P transparent_separate(P p, BM bm, bool opaque, bool force_transparent, bool force_opaque)
Definition GameApi.cc:5976

GameApi::PolygonApi::and_not_elem
IMPORT P and_not_elem(EveryApi &ev, P p1, P p_not, O o1, O o_not, CT cutter1, CT cutter_not)
Definition GameApi_pl.cc:14686

GameApi::PolygonApi::ske_anim2
IMPORT ML ske_anim2(EveryApi &ev, std::vector< P > mesh, LI orig_pose, int li_size, std::string url, std::vector< LI > new_poses, MT mat)
Definition GameApi_pl.cc:25433

GameApi::PolygonApi::explode
IMPORT void explode(VA va, PT pos, float dist)
Definition GameApi_pl.cc:6535

GameApi::PolygonApi::split_faces
IMPORT ARR split_faces(P p, ATT att, int max_attach)
Definition GameApi_pl.cc:24908

GameApi::PolygonApi::color_from_normals
IMPORT P color_from_normals(P orig)
Definition GameApi_pl.cc:4854

GameApi::PolygonApi::voxelarray_to_pts
IMPORT PTS voxelarray_to_pts(AV arr, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)
Definition GameApi_pl.cc:22161

GameApi::PolygonApi::max_color
IMPORT P max_color(P orig, P orig2)
Definition GameApi_pl.cc:4361

GameApi::PolygonApi::toon_shader
IMPORT ML toon_shader(EveryApi &ev, ML mainloop)
Definition GameApi_pl.cc:12624

GameApi::PolygonApi::render_dynamic
IMPORT void render_dynamic(P p, int array_elem, bool textures)
Definition GameApi_pl.cc:6245

GameApi::PolygonApi::color_from_texcoord
IMPORT P color_from_texcoord(P orig, unsigned int color_1, unsigned int color_2, unsigned int color_3, unsigned int color_4)
Definition GameApi_pl.cc:14653

GameApi::PolygonApi::move
IMPORT P move(P orig, PT obj_0, V obj_x, V obj_y, V obj_z, PT world_0, V world_x, V world_y, V world_z)
Definition GameApi_pl.cc:5049

GameApi::PolygonApi::color_map
IMPORT P color_map(BM bm, float start_x, float end_x, float start_y, float end_y, float z)
Definition GameApi_pl.cc:14258

GameApi::PolygonApi::cone_anim
IMPORT P cone_anim(float c_x, float c_y, float c_z, float d_x, float d_y, float d_z, float c2_x, float c2_y, float c2_z, float d2_x, float d2_y, float d2_z, float r1, float r2, float r1_2, float r2_2, int numfaces, float start_time, float end_time)
Definition GameApi_pl.cc:26730

GameApi::PolygonApi::y_split
IMPORT P y_split(P p, float y, float y_0, float y_1)
Definition GameApi_pl.cc:27006

GameApi::PolygonApi::texcoord_manual
IMPORT P texcoord_manual(P orig, float p1_x, float p1_y, float p2_x, float p2_y, float p3_x, float p3_y, float p4_x, float p4_y)
Definition GameApi_pl.cc:3311

GameApi::PolygonApi::memoize
IMPORT P memoize(P orig)
Definition GameApi_pl.cc:5371

GameApi::PolygonApi::splitquads
IMPORT P splitquads(P orig, int x_count, int y_count)
Definition GameApi_pl.cc:5082

GameApi::PolygonApi::update_vertex_array_ml
IMPORT ML update_vertex_array_ml(VA va, P p, bool keep=false)
Definition GameApi_pl.cc:6315

GameApi::PolygonApi::lighting
IMPORT P lighting(P orig, L lighting)

GameApi::PolygonApi::load_glb_from_temp
IMPORT void load_glb_from_temp(std::string filename, void(*fptr)(void *), void *, bool &success)
Definition GameApi.cc:31930

GameApi::PolygonApi::optimize_mesh
IMPORT P optimize_mesh(P p)

GameApi::PolygonApi::from_lines
IMPORT P from_lines(LI li, std::function< P(int i, float sx, float sy, float sz, float ex, float ey, float ez, unsigned int scolor, unsigned int ecolor)> f)
Definition GameApi_pl.cc:719

GameApi::PolygonApi::meshanim_mesh
IMPORT P meshanim_mesh(MA ma, float time)
Definition GameApi_pl.cc:20487

GameApi::PolygonApi::colourspace_func
IMPORT CS colourspace_func(std::function< unsigned int(float, float, float, float)> f, float sx, float ex, float sy, float ey, float sz, float ez, float st, float et)
Definition GameApi_pl.cc:28237

GameApi::PolygonApi::newshadow_shader_2_gltf
IMPORT ML newshadow_shader_2_gltf(EveryApi &ev, ML ml, float light_dir_x, float light_dir_y, float light_dir_z, float dark_level, float light_level, float scale, int texindex)
Definition GameApi_pl.cc:12684

GameApi::PolygonApi::tf_ds_inv
IMPORT DS tf_ds_inv(TF tf, int flags)
Definition GameApi_pl.cc:18188

GameApi::PolygonApi::s_sample
IMPORT P s_sample(S surf, int sx, int sy)
Definition GameApi_pl.cc:16828

GameApi::PolygonApi::tri_strip
IMPORT P tri_strip(PT *array, int size)
Definition GameApi_pl.cc:6187

GameApi::PolygonApi::min_color
IMPORT P min_color(P orig, P orig2)
Definition GameApi_pl.cc:4355

GameApi::PolygonApi::scale
IMPORT P scale(P orig, float sx, float sy, float sz)
Definition GameApi_pl.cc:5041

GameApi::PolygonApi::m_bind_inst_many
IMPORT ML m_bind_inst_many(EveryApi &ev, std::vector< P > vec, std::vector< MT > materials, PTS pts, int ticks)
Definition GameApi_pl.cc:21930

GameApi::PolygonApi::acesfilm_shader
IMPORT ML acesfilm_shader(EveryApi &ev, ML mainloop)
Definition GameApi_pl.cc:12749

GameApi::PolygonApi::quad_y
IMPORT P quad_y(float x1, float x2, float y, float z1, float z2)
Definition GameApi_pl.cc:3371

GameApi::PolygonApi::fix_vertex_order
IMPORT P fix_vertex_order(P p)
Definition GameApi_pl.cc:21422

GameApi::PolygonApi::single_texture
IMPORT P single_texture(P orig, BM texture)

GameApi::PolygonApi::delete_vertex_array
IMPORT void delete_vertex_array(VA arr)
Definition GameApi_pl.cc:6331

GameApi::PolygonApi::texcoord_spherical2
IMPORT P texcoord_spherical2(EveryApi &ev, PT center, float r, P orig)
Definition GameApi_pl.cc:14617

GameApi::PolygonApi::color_voxel
IMPORT P color_voxel(P orig, VX colours, PT p, V u_x, V u_y, V u_z)
Definition GameApi_pl.cc:6277

GameApi::PolygonApi::print_data
IMPORT void print_data(P p)
Definition GameApi_pl.cc:643

GameApi::PolygonApi::mesh_resize
IMPORT P mesh_resize(P p, float start_x, float end_x, float start_y, float end_Y, float start_z, float end_z)
Definition GameApi_pl.cc:19245

GameApi::PolygonApi::blur_shader
IMPORT ML blur_shader(EveryApi &ev, ML mainloop, float x_val, float y_val)
Definition GameApi_pl.cc:16175

GameApi::PolygonApi::p_array
IMPORT PV p_array(std::vector< P > vec)
Definition GameApi_main.cc:2516

GameApi::PolygonApi::color
IMPORT P color(P orig, unsigned int color)
Definition GameApi_pl.cc:4470

GameApi::PolygonApi::render_vertex_array_ml
IMPORT ML render_vertex_array_ml(EveryApi &ev, VA va)
Definition GameApi_pl.cc:12790

GameApi::PolygonApi::load_glb_from_temp3
IMPORT void load_glb_from_temp3(std::string filename)
Definition GameApi.cc:31945

GameApi::PolygonApi::identity_pose
IMPORT MS identity_pose(int li_size)
Definition GameApi_pl.cc:25186

GameApi::PolygonApi::from_normal_to_texcoord
IMPORT P from_normal_to_texcoord(P p)
Definition GameApi_pl.cc:20312

GameApi::PolygonApi::count_function
IMPORT P count_function(P p1, std::function< int(int face)> f)
Definition GameApi_pl.cc:5966

GameApi::PolygonApi::recalculate_normals
IMPORT P recalculate_normals(P orig)
Definition GameApi_pl.cc:5356

GameApi::PolygonApi::unit_cube
IMPORT P unit_cube(P orig, PT pos, V u_x, V u_y, V u_z)
Definition GameApi_pl.cc:1051

GameApi::PolygonApi::anim_interpolate
IMPORT P anim_interpolate(P p, float val)
Definition GameApi_pl.cc:13623

GameApi::PolygonApi::radial_lighting
IMPORT L radial_lighting(float dx, float dy, float dz, int r, int g, int b, int a, int r2, int g2, int b2, int a2, float dist)

GameApi::PolygonApi::phong_shader
IMPORT ML phong_shader(EveryApi &ev, ML mainloop, float light_dir_x, float light_dir_y, float light_dir_z, unsigned int ambient, unsigned int specular, unsigned int highlight, float pow)
Definition GameApi_pl.cc:12697

GameApi::PolygonApi::material_extractor_p
IMPORT ARR material_extractor_p(P p, int start_index, int end_index, int num_slots, int current_slot)
Definition GameApi_pl.cc:18664

GameApi::PolygonApi::change_texture
IMPORT P change_texture(P orig, std::function< int(int face)> f, BM *array, int size)
Definition GameApi_pl.cc:5329

GameApi::PolygonApi::color_lighting
IMPORT L color_lighting(float dx, float dy, float dz, int r, int g, int b, int a)

GameApi::PolygonApi::color_function
IMPORT P color_function(P p1, std::function< unsigned int(int face, int point)> f)
Definition GameApi_pl.cc:5994

GameApi::PolygonApi::flip_normals
IMPORT P flip_normals(P obj)
Definition GameApi_pl.cc:16013

GameApi::PolygonApi::color_map3_sph
IMPORT P color_map3_sph(BM bm, FB height, PT pos, V u_x, V u_y)
Definition GameApi_pl.cc:14303

GameApi::PolygonApi::gltf_split_faces2
IMPORT ARR gltf_split_faces2(EveryApi &ev, TF model0, int mesh_index, int prim_index, int max_attach)
Definition GameApi_gltf.cc:14157

GameApi::PolygonApi::blurred_render_shader
IMPORT ML blurred_render_shader(EveryApi &ev, ML mainloop, int numsamples, float blur_radius)
Definition GameApi_pl.cc:12690

GameApi::PolygonApi::resize_to_correct_size
IMPORT P resize_to_correct_size(P model)
Definition GameApi_pl.cc:15368

GameApi::PolygonApi::change_normals
IMPORT P change_normals(P orig, std::function< V(V orig, int face, int point)> f)
Definition GameApi_pl.cc:5221

GameApi::PolygonApi::translate_1
P translate_1(P orig, float dx, float dy, float dz)
Definition GameApi_pl.cc:4983

GameApi::PolygonApi::sprite_render_inst
IMPORT ML sprite_render_inst(EveryApi &ev, BM bm, PTS pts, float start_x, float end_x, float start_y, float end_y, float z)
Definition GameApi_pl.cc:14241

GameApi::PolygonApi::torus2
IMPORT P torus2(EveryApi &ev, int numfaces1, int numfacesw2, PT center, float radius1, float radius2)
Definition GameApi_pl.cc:3650

GameApi::PolygonApi::shadow_map3
IMPORT BM shadow_map3(EveryApi &ev, P objs, float p_x, float p_Y, float p_z, int sx, int sy, P quad)
Definition GameApi_pl.cc:20956

GameApi::PolygonApi::rounded_cube
IMPORT P rounded_cube(EveryApi &ev, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, float round_radius)
Definition GameApi_pl.cc:3553

GameApi::PolygonApi::mesh_anim_display_inst2
IMPORT ML mesh_anim_display_inst2(EveryApi &ev, P p, FF val, MN mn, MT mat, PTS inst)
Definition GameApi_pl.cc:22922

GameApi::PolygonApi::p_num_textures
IMPORT int p_num_textures(P p)
Definition GameApi_pl.cc:18314

GameApi::PolygonApi::block_draw
IMPORT ML block_draw(std::vector< ML > vec, float pos_x, float pos_z, int sx, int sz, float delta_x, float delta_z, int view)
Definition GameApi_pl.cc:24027

GameApi::PolygonApi::normal_darkness
IMPORT P normal_darkness(P p, float dark)
Definition GameApi_pl.cc:22281

GameApi::PolygonApi::multiply_facecoll
IMPORT P multiply_facecoll(P p, int sx, int sy, int sz)
Definition GameApi.cc:23127

GameApi::PolygonApi::attrib_function
IMPORT P attrib_function(P p1, std::function< float(int face, int point, int idx)> f, int idx)
Definition GameApi_pl.cc:6012

GameApi::PolygonApi::no_batch_map
IMPORT P no_batch_map(P p)
Definition GameApi_pl.cc:28315

GameApi::PolygonApi::from_polygon
IMPORT P from_polygon(P p, std::function< P(int face, PT p1, PT p2, PT p3, PT p4)> f)
Definition GameApi_pl.cc:637

GameApi::PolygonApi::gltf_load_nr
IMPORT P gltf_load_nr(EveryApi &ev, TF model, int mesh_index, int prim_index, TRR resize_transfer_id)
Definition GameApi_gltf.cc:6141

GameApi::PolygonApi::load_ds_from_temp_p
IMPORT P load_ds_from_temp_p(EveryApi &ev, P p, std::string url)
Definition GameApi.cc:31921

GameApi::PolygonApi::polygon_fetch
IMPORT P polygon_fetch(P p)
Definition VertexArray.cc:4833

GameApi::PolygonApi::smooth_normals
IMPORT P smooth_normals(P orig)

GameApi::PolygonApi::fog_shader
IMPORT ML fog_shader(EveryApi &ev, ML mainloop, float fog_dist, unsigned int dark_color, unsigned int light_color)
Definition GameApi_pl.cc:12764

GameApi::PolygonApi::anim_render
IMPORT ML anim_render(AA, float delta)

GameApi::PolygonApi::persistent_cache
IMPORT P persistent_cache(P orig, std::string filename)
Definition GameApi_pl.cc:15523

GameApi::PolygonApi::sprite_render_fade
IMPORT ML sprite_render_fade(EveryApi &ev, BM bm, PTS pts, float start_x, float end_x, float start_y, float end_y, float z, bool flip, float start_time, float end_time)
Definition GameApi_pl.cc:14249

GameApi::PolygonApi::world_from_bitmap
IMPORT P world_from_bitmap(std::function< P(int c)> f, BM int_bm, float dx, float dy, int max_c)
Definition GameApi_pl.cc:878

GameApi::PolygonApi::color_map3_cyl
IMPORT P color_map3_cyl(BM bm, FB height, PT pos, V u_x, V u_y)
Definition GameApi_pl.cc:14292

GameApi::PolygonApi::matrix
IMPORT P matrix(P orig, M mat)
Definition GameApi_pl.cc:4971

GameApi::PolygonApi::save_model
IMPORT void save_model(P poly, std::string filename)
Definition GameApi_pl.cc:3001

GameApi::PolygonApi::texcoord_from_normal2
IMPORT P texcoord_from_normal2(P p)
Definition GameApi_pl.cc:15698

GameApi::PolygonApi::print_data2
IMPORT void print_data2(P p)
Definition GameApi_pl.cc:663

GameApi::PolygonApi::line_to_cone2
IMPORT ML line_to_cone2(EveryApi &ev, LI li, float size, int numfaces, MT mt)
Definition GameApi_pl.cc:15893

GameApi::PolygonApi::fix_texcoord
IMPORT P fix_texcoord(P p)
Definition GameApi_pl.cc:15756

GameApi::PolygonApi::bloom1_shader
IMPORT ML bloom1_shader(EveryApi &ev, ML mainloop, float r_val, float g_val, float b_val)
Definition GameApi_pl.cc:16581

GameApi::PolygonApi::skeletal_shader
IMPORT ML skeletal_shader(EveryApi &ev, ML mainloop, std::vector< SA > vec)
Definition GameApi_pl.cc:12651

GameApi::PolygonApi::attach_cache
IMPORT ATT attach_cache(ATT a, P p)
Definition GameApi_pl.cc:24773

GameApi::PolygonApi::spherical_normals
IMPORT P spherical_normals(P p, float p_x, float p_y, float p_z)
Definition GameApi_pl.cc:16093

GameApi::PolygonApi::dyn_lights_shader
IMPORT ML dyn_lights_shader(EveryApi &ev, ML mainloop, float light_pos_x, float light_pos_y, float light_pos_z, float dist, MN dyn_point)
Definition GameApi_pl.cc:12777

GameApi::PolygonApi::repeat_xy_p
IMPORT P repeat_xy_p(EveryApi &ev, P p, float start_x, float start_y, float dx, float dy, int sx, int sy)
Definition GameApi_pl.cc:19123

GameApi::PolygonApi::renderpolytobitmap
IMPORT BM renderpolytobitmap(EveryApi &ev, P p, SH sh, float x, float y, float z, int sx, int sy)
Definition GameApi_pl.cc:14706

GameApi::PolygonApi::sphere
IMPORT P sphere(PT center, float radius, int numfaces1, int numfaces2)
Definition GameApi_pl.cc:3644

GameApi::PolygonApi::anim
IMPORT ML anim(EveryApi &ev, ML next, MA anim, float start_time, float delta_time, int count)
Definition GameApi_pl.cc:20640

GameApi::PolygonApi::update_vertex_array
IMPORT void update_vertex_array(VA va, P p, bool keep=false)
Definition GameApi_pl.cc:6353

GameApi::PolygonApi::sphere_rays2
IMPORT ARR sphere_rays2(EveryApi &ev, float center_x, float center_y, float center_z, float radius, float delta_alfa, float delta_beta, FS field, int maxiter, float c, std::vector< PT > vec)
Definition GameApi_ff.cc:386

GameApi::PolygonApi::li_static_instancing_matrix
IMPORT LI li_static_instancing_matrix(EveryApi &ev, LI obj, MS matrix_array)
Definition GameApi_pl.cc:15922

GameApi::PolygonApi::color_range
IMPORT P color_range(P orig, unsigned int source_upper, unsigned int source_lower, unsigned int upper_range, unsigned int lower_range)
Definition GameApi_pl.cc:4590

GameApi::PolygonApi::bump_phong_shader
IMPORT ML bump_phong_shader(EveryApi &ev, ML mainloop, float light_dir_x, float light_dir_y, float light_dir_z, unsigned int ambient, unsigned int highlight, float pow)
Definition GameApi_pl.cc:12759

GameApi::PolygonApi::prepare_cache
IMPORT P prepare_cache(std::string url, P p)
Definition GameApi_pl.cc:2607

GameApi::PolygonApi::decimate_without_holes
IMPORT P decimate_without_holes(EveryApi &ev, P p, float, int, float, std::vector< BM >)
Definition GameApi_pl.cc:30053

GameApi::PolygonApi::static_instancing_vertex_color
IMPORT P static_instancing_vertex_color(EveryApi &ev, P obj, PTS pos)
Definition GameApi_pl.cc:15967

GameApi::PolygonApi::render_vertex_array_instanced_matrix
IMPORT void render_vertex_array_instanced_matrix(ShaderApi &ev, VA va, MSA pta, SH sh, int hide_n=-1)
Definition GameApi_pl.cc:13311

GameApi::PolygonApi::stl_load
IMPORT P stl_load(std::string url)
Definition GameApi_pl.cc:21352

GameApi::PolygonApi::coloured_lights_shader
IMPORT ML coloured_lights_shader(EveryApi &ev, ML mainloop, float scale, unsigned int color_1, unsigned int color_2, unsigned int color_3, unsigned int color_4, unsigned int color_5, unsigned int color_6, unsigned int color_7, unsigned int color_8, PT pos_1, PT pos_2, PT pos_3, PT pos_4, PT pos_5, PT pos_6, PT pos_7, PT pos_8, float dist_1, float dist_2, float dist_3, float dist_4, float dist_5, float dist_6, float dist_7, float dist_8)
Definition GameApi_pl.cc:12549

GameApi::PolygonApi::face_cutter
IMPORT P face_cutter(P p, float start, float end)
Definition GameApi_pl.cc:26858

GameApi::PolygonApi::color_map2
IMPORT P color_map2(BM bm, PT pos, V u_x, V u_y)
Definition GameApi_pl.cc:14269

GameApi::PolygonApi::deform
IMPORT P deform(P obj, O bools, float dx, float dy, float dz)
Definition GameApi_pl.cc:14680

GameApi::PolygonApi::prepare_vertex_array_instanced
IMPORT void prepare_vertex_array_instanced(ShaderApi &ev, VA va, PTA pta, SH sh)
Definition GameApi_pl.cc:13072

GameApi::PolygonApi::p_mtl2
IMPORT ARR p_mtl2(EveryApi &ev, std::string obj_url, std::string mtl_url, std::string prefix, int count, int start_index, int end_index, float mix)
Definition GameApi_pl.cc:18709

GameApi::PolygonApi::spotlight_shader
IMPORT ML spotlight_shader(EveryApi &ev, ML mainloop, int light_color_id, MN move)
Definition GameApi_pl.cc:12541

GameApi::PolygonApi::color_map3
IMPORT P color_map3(BM bm, FB height, PT pos, V u_x, V u_y)
Definition GameApi_pl.cc:14280

GameApi::PolygonApi::position_based_on_screen
IMPORT ML position_based_on_screen(ML obj)
Definition GameApi_pl.cc:16702

GameApi::PolygonApi::sbm_texture
IMPORT ML sbm_texture(EveryApi &ev, ML mainloop, SBM bitmap)
Definition GameApi_pl.cc:16565

GameApi::PolygonApi::HeightMapType
HeightMapType
Definition GameApi.hh:3192

GameApi::PolygonApi::EQuad
@ EQuad
Definition GameApi.hh:3192

GameApi::PolygonApi::ETriangle
@ ETriangle
Definition GameApi.hh:3192

GameApi::PolygonApi::custom_shader
IMPORT ML custom_shader(EveryApi &ev, ML mainloop, std::string v_shader, std::string f_shader, std::string v_funcname, std::string f_funcname)
Definition GameApi_pl.cc:12532

GameApi::PolygonApi::create_vertex_array_attribs
IMPORT VA create_vertex_array_attribs(P p, bool keep, std::vector< int > attribs, std::vector< int > attribi)
Definition GameApi_pl.cc:7160

GameApi::PolygonApi::adjust_shader
IMPORT ML adjust_shader(EveryApi &ev, ML mainloop, unsigned int ad_color, float ad_dark, float ad_light)
Definition GameApi_pl.cc:12703

GameApi::PolygonApi::p_mtl2_materials
IMPORT ARR p_mtl2_materials(EveryApi &ev, P p)
Definition GameApi_pl.cc:2381

GameApi::PolygonApi::find_texcoord_id
IMPORT ID find_texcoord_id(P p, int facenum, int pointnum)

GameApi::PolygonApi::combine_textures
IMPORT P combine_textures(P p1, P p2)
Definition GameApi_pl.cc:26129

GameApi::PolygonApi::fade_pic
IMPORT ML fade_pic(EveryApi &ev, BM bm1, float start_time, float transition_time, float end_time, float end_transition_time, BM bm2, float start2_time, float transition2_time, float end2_time, float end2_transition_time)
Definition GameApi_pl.cc:28321

GameApi::PolygonApi::anim_target_matrix
IMPORT P anim_target_matrix(P p, M matrix)

GameApi::PolygonApi::sphere_anim
IMPORT P sphere_anim(float c_x, float c_y, float c_z, float c2_x, float c2_y, float c2_z, float r, float r2, float start_time, float end_time, int numfaces1, int numfaces2)
Definition GameApi_pl.cc:26719

GameApi::PolygonApi::world_from_bitmap2
IMPORT P world_from_bitmap2(EveryApi &ev, std::function< P(int c, PT tl, PT tr, PT bl, PT br)> f, BM int_bm, FB float_bm, float dx, float dz, float height)
Definition GameApi_pl.cc:793

GameApi::PolygonApi::texture_from_p
IMPORT BM texture_from_p(P p, int num)
Definition GameApi_pl.cc:20275

GameApi::PolygonApi::fullscreen_quad
IMPORT P fullscreen_quad(EveryApi &ev)
Definition GameApi_pl.cc:3383

GameApi::PolygonApi::p_url_mtl
IMPORT P p_url_mtl(EveryApi &ev, std::string url, int count, std::vector< std::string > material_names)
Definition GameApi_pl.cc:2628

GameApi::PolygonApi::smooth_normals2
IMPORT P smooth_normals2(P p)
Definition GameApi_pl.cc:19348

GameApi::PolygonApi::texture
IMPORT P texture(P orig, BM bm, int bm_choose=-1)
Definition GameApi_pl.cc:3735

GameApi::PolygonApi::water_shader
IMPORT ML water_shader(EveryApi &ev, ML mainloop, unsigned int color1, unsigned int color2, unsigned int color3, float center_x, float center_y, float center_z, float wave_mult, float time_mult)
Definition GameApi_pl.cc:12667

GameApi::PolygonApi::find_normal_id
IMPORT ID find_normal_id(P p, int facenum, int pointnum)

GameApi::PolygonApi::load_model
IMPORT P load_model(std::string filename, int obj_num)
Definition GameApi_pl.cc:2922

GameApi::PolygonApi::sprite_render
IMPORT ML sprite_render(EveryApi &ev, BM bm, float start_x, float end_x, float start_y, float end_y, float z)
Definition GameApi_pl.cc:14233

GameApi::PolygonApi::color_alpha
IMPORT P color_alpha(P orig, unsigned int alpha)
Definition GameApi_pl.cc:4860

GameApi::PolygonApi::dither_shader
IMPORT ML dither_shader(EveryApi &ev, ML mainloop)
Definition GameApi_pl.cc:16123

GameApi::PolygonApi::poly_array
IMPORT ARR poly_array(std::vector< P > vec)
Definition GameApi_pl.cc:16018

GameApi::PolygonApi::ambient_shader
IMPORT ML ambient_shader(EveryApi &ev, ML mainloop, int ambient_color_id, float ambient_level)

GameApi::PolygonApi::color_cube
IMPORT P color_cube(P orig, PT o, PT u_x, PT u_y, PT u_z, unsigned int color_o, unsigned int color_x, unsigned int color_y, unsigned int color_z)
Definition GameApi_pl.cc:4928

GameApi::PolygonApi::sprite_bind_1
P sprite_bind_1(P p, Q bm, TX tx)
Definition GameApi_pl.cc:3341

GameApi::PolygonApi::flip_polygon_order
IMPORT P flip_polygon_order(P p)
Definition GameApi_pl.cc:4807

GameApi::PolygonApi::resize_to_correct_size_g
IMPORT P resize_to_correct_size_g(P model, TRR resize_transfer_id)
Definition GameApi_pl.cc:15373

GameApi::PolygonApi::cut_faces
IMPORT P cut_faces(P p, O o, CT cutter)
Definition GameApi_pl.cc:13851

GameApi::PolygonApi::transparent_separate2
IMPORT P transparent_separate2(P p, std::vector< BM > vec, bool opaque)
Definition GameApi.cc:6237

GameApi::PolygonApi::update_vertex_array_no_memory
IMPORT void update_vertex_array_no_memory(VA va, P p)
Definition GameApi_pl.cc:6321

GameApi::PolygonApi::or_array2
IMPORT P or_array2(std::vector< P > vec)
Definition GameApi_pl.cc:4245

GameApi::PolygonApi::p_piechart
IMPORT P p_piechart(EveryApi &ev, float c_x, float c_y, float start_angle, float end_angle, float radius, int numsteps, float start_z, float end_z)
Definition GameApi_diag.cc:286

GameApi::PolygonApi::colourspace_sphere2
IMPORT CS colourspace_sphere2()
Definition GameApi_pl.cc:28189

GameApi::PolygonApi::dist_from_lines
IMPORT P dist_from_lines(LI li, float d1, float d2, PT center)
Definition GameApi_pl.cc:1017

GameApi::PolygonApi::PolygonApi
IMPORT PolygonApi(Env &e)
Definition GameApi_pl.cc:627

GameApi::PolygonApi::load_model_all_no_cache_mtl
IMPORT P load_model_all_no_cache_mtl(std::string filename, int count, std::vector< std::string > material_names, bool nr)
Definition GameApi_pl.cc:1175

GameApi::PolygonApi::prepare_vertex_array_instanced_matrix
IMPORT void prepare_vertex_array_instanced_matrix(ShaderApi &ev, VA va, MSA pta, SH sh)
Definition GameApi_pl.cc:13081

GameApi::PolygonApi::update
IMPORT void update(VA va)
Definition GameApi_pl.cc:7330

GameApi::PolygonApi::find_color_id
IMPORT ID find_color_id(P p, int facenum, int pointnum)

GameApi::PolygonApi::load_model_all_no_cache
IMPORT P load_model_all_no_cache(std::string filename, int count, bool nr)
Definition GameApi_pl.cc:1139

GameApi::PolygonApi::decimate_tf_zero
IMPORT TF decimate_tf_zero(TF mesh)
Definition GameApi_pl.cc:31151

GameApi::PolygonApi::create_dynamic_geometry
IMPORT P create_dynamic_geometry(P *array, int size)
Definition GameApi_pl.cc:6049

GameApi::PolygonApi::counts
IMPORT P counts(P p1, int numfaces)
Definition GameApi_pl.cc:5959

GameApi::PolygonApi::create_static_geometry
IMPORT P create_static_geometry(P *array, int size)
Definition GameApi_pl.cc:6033

GameApi::PolygonApi::texture_cubemap_shader
IMPORT ML texture_cubemap_shader(EveryApi &ev, ML mainloop, float mix, float mix2)
Definition GameApi_pl.cc:12606

GameApi::PolygonApi::change_colors
IMPORT P change_colors(P orig, std::function< unsigned int(unsigned int orig, int face, int point)> f)
Definition GameApi_pl.cc:5279

GameApi::PolygonApi::glowedge_shader
IMPORT ML glowedge_shader(EveryApi &ev, ML mainloop, float white_level, float gray_level, float edge_pos)
Definition GameApi_pl.cc:12662

GameApi::PolygonApi::p_mtl
IMPORT P p_mtl(EveryApi &ev, std::string obj_url, std::string mtl_url, std::string prefix, int count)
Definition GameApi_pl.cc:2641

GameApi::PolygonApi::light_transport
IMPORT P light_transport(P p, int num, float light_dir_x, float light_dir_y, float light_dir_z)
Definition GameApi_pl.cc:20219

GameApi::PolygonApi::preparepoly
IMPORT void preparepoly(P p, int bbm_choose=-1)
Definition GameApi_pl.cc:5703

GameApi::PolygonApi::render_vertex_array_ml2_cubemap
IMPORT ML render_vertex_array_ml2_cubemap(EveryApi &ev, P va, std::vector< BM > vec)
Definition GameApi_pl.cc:12817

GameApi::PolygonApi::gi_shader
IMPORT ML gi_shader(EveryApi &ev, ML mainloop, PTS points, float obj_size)
Definition GameApi_pl.cc:12737

GameApi::PolygonApi::orig_pose
IMPORT std::vector< P > orig_pose(EveryApi &ev, P p, LI li, int li_size)
Definition GameApi_pl.cc:25070

GameApi::PolygonApi::preparedone
IMPORT void preparedone(P p)
Definition GameApi_pl.cc:21346

GameApi::PolygonApi::intersect
IMPORT P intersect(EveryApi &ev, P p1, P p2, O o1, O o2, CT cutter1, CT cutter2)
Definition GameApi_pl.cc:13859

GameApi::PolygonApi::grid
IMPORT P grid(PT o, PT u_x, PT u_y, int num_x, int num_y)

GameApi::PolygonApi::p_mtl_d
IMPORT ARR p_mtl_d(P p)
Definition GameApi_pl.cc:2426

GameApi::PolygonApi::p_ds_url
IMPORT P p_ds_url(EveryApi &ev, std::string url)
Definition GameApi_pl.cc:2674

GameApi::PolygonApi::block_divide
IMPORT ARR block_divide(P p, float pos_x, float pos_z, int sx, int sz, float delta_x, float delta_z)
Definition GameApi_pl.cc:23185

GameApi::PolygonApi::p_url
IMPORT P p_url(EveryApi &ev, std::string url, int count)
Definition GameApi_pl.cc:2595

GameApi::PolygonApi::wave_shader
IMPORT ML wave_shader(EveryApi &ev, ML mainloop, float radius, float t_mult, float x_mult, float y_mult)
Definition GameApi_pl.cc:16143

GameApi::PolygonApi::fractal_mountain
IMPORT FB fractal_mountain(int level, int sx, int sy)
Definition GameApi_bm.cc:5196

GameApi::PolygonApi::render_vertex_array_ml2_texture2
IMPORT ML render_vertex_array_ml2_texture2(EveryApi &ev, P p)
Definition GameApi_pl.cc:12822

GameApi::PolygonApi::phong_shader2
IMPORT ML phong_shader2(EveryApi &ev, ML mainloop, float light_dir_x, float light_dir_y, float light_dir_z, unsigned int ambient, unsigned int specular, unsigned int highlight, float pow)
Definition GameApi_pl.cc:12709

GameApi::PolygonApi::comb_mat
IMPORT ARR comb_mat(GameApi::EveryApi &ev, std::vector< MT > vec1, std::vector< MT > vec2)
Definition GameApi_pl.cc:2326

GameApi::PolygonApi::or_elem_anim
IMPORT ARR or_elem_anim(P p1, P p2, float time)

GameApi::PolygonApi::ambient_occulsion_color
IMPORT P ambient_occulsion_color(P p)
Definition GameApi_pl.cc:26922

GameApi::PolygonApi::texture_shader
IMPORT ML texture_shader(EveryApi &ev, ML mainloop, float mix)
Definition GameApi_pl.cc:12584

GameApi::PolygonApi::torus
IMPORT P torus(int numfaces1, int numfaces2, PT center, V u_x, V u_y, float radius1, V uu_x, V uu_y, float radius2)
Definition GameApi_pl.cc:3658

GameApi::PolygonApi::texcoord_from_normal
IMPORT P texcoord_from_normal(P p)
Definition GameApi_pl.cc:15665

GameApi::PolygonApi::combine_anim
IMPORT P combine_anim(P p1, P p2, float start_time, float end_time)
Definition GameApi_pl.cc:26708

GameApi::PolygonApi::unit_to_cube
IMPORT P unit_to_cube(P orig, PT pos, V u_x, V u_y, V u_z)
Definition GameApi_pl.cc:1080

GameApi::PolygonApi::quads_to_triangles
IMPORT P quads_to_triangles(P p)
Definition GameApi_pl.cc:4813

GameApi::PolygonApi::prepare_cut
IMPORT P prepare_cut(P p)
Definition GameApi_pl.cc:14787

GameApi::PolygonApi::blur_sbm
IMPORT SBM blur_sbm(SBM texture, float pixel_x, float pixel_y)
Definition GameApi_pl.cc:16415

GameApi::PolygonApi::rect_pl
IMPORT PL rect_pl(float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, bool x_or_z, bool start_or_end_higher)
Definition GameApi_pl.cc:27821

GameApi::PolygonApi::tri_to_quad
IMPORT P tri_to_quad(P p)
Definition GameApi_pl.cc:13927

GameApi::PolygonApi::cube
IMPORT P cube(float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)
Definition GameApi_pl.cc:3613

GameApi::PolygonApi::sbm_circle
IMPORT SBM sbm_circle(float start_time, float end_time, float start_pos_x, float start_pos_y, float end_pos_x, float end_pos_y, float start_radius, float end_radius)
Definition GameApi_pl.cc:16523

GameApi::PolygonApi::p_texture
IMPORT BM p_texture(P p, int i)
Definition GameApi_pl.cc:18326

GameApi::PolygonApi::texcoord_cube
IMPORT P texcoord_cube(P orig, PT o, PT u_x, PT u_y, PT u_z, PT tex_o, PT tex_x, PT tex_y, PT tex_z)

GameApi::PolygonApi::mix_color
IMPORT P mix_color(P orig, P orig2, float val)
Definition GameApi_pl.cc:4349

GameApi::PolygonApi::static_instancing_matrix
IMPORT P static_instancing_matrix(EveryApi &ev, P obj, MS matrix_array)
Definition GameApi_pl.cc:15908

GameApi::PolygonApi::color_grayscale
IMPORT P color_grayscale(P orig)
Definition GameApi_pl.cc:4596

GameApi::PolygonApi::quad_x
IMPORT P quad_x(float x, float y1, float y2, float z1, float z2)
Definition GameApi_pl.cc:3360

GameApi::PolygonApi::decimate3_inv
IMPORT P decimate3_inv(P p, float val)
Definition GameApi_pl.cc:30047

GameApi::PolygonApi::vertex_phong_shader
IMPORT ML vertex_phong_shader(EveryApi &ev, ML mainloop, float light_dir_x, float light_dir_y, float light_dir_z, unsigned int ambient, unsigned int highlight, float pow, float mix)
Definition GameApi_pl.cc:12714

GameApi::PolygonApi::meshanim_mesh2
IMPORT P meshanim_mesh2(MA ma, float time1, float time2)
Definition GameApi_pl.cc:20546

GameApi::PolygonApi::subpoly_change
IMPORT P subpoly_change(P p, P p2, O choose)
Definition GameApi_pl.cc:14504

GameApi::PolygonApi::material_extractor_bm
IMPORT ARR material_extractor_bm(P p, int start_index, int end_index)
Definition GameApi_pl.cc:18854

GameApi::PolygonApi::fromsurface
IMPORT P fromsurface(S s1, S s2, C curve)

GameApi::PolygonApi::meshanim
IMPORT MA meshanim(std::vector< P > vec, float start_time, float end_time)
Definition GameApi_pl.cc:20429

GameApi::PolygonApi::world_from_voxel
IMPORT P world_from_voxel(std::function< P(unsigned int c)> f, VX voxel, float dx, float dy, float dz, int max_c)
Definition GameApi_pl.cc:751

GameApi::PolygonApi::ready_to_prepare
IMPORT bool ready_to_prepare(ML p)
Definition GameApi_pl.cc:22

GameApi::PolygonApi::change_positions
IMPORT P change_positions(P orig, std::function< PT(PT p, int face, int point)> f)
Definition GameApi_pl.cc:5167

GameApi::PolygonApi::build_offsets
IMPORT P build_offsets(P p, std::vector< PT > vec)
Definition GameApi_pl.cc:15562

GameApi::PolygonApi::ds_cache_url
IMPORT P ds_cache_url(EveryApi &ev, P input, int count)
Definition GameApi_pl.cc:2785

GameApi::PolygonApi::dist_field_mesh_shader
IMPORT ML dist_field_mesh_shader(EveryApi &ev, ML mainloop, SFO sfo)
Definition GameApi_pl.cc:12634

GameApi::PolygonApi::ring
IMPORT P ring(float sx, float sy, float x, int steps)
Definition GameApi_pl.cc:3681

GameApi::PolygonApi::gltf_load_bitmap
IMPORT BM gltf_load_bitmap(GameApi::EveryApi &ev, TF model, int image_index)
Definition GameApi_gltf.cc:6011

GameApi::PolygonApi::curve_to_poly
IMPORT P curve_to_poly(C c, float start_x, float end_x, float start_y, float end_y, float start_angle, float end_angle, int numinstances)
Definition GameApi_pl.cc:16904

GameApi::PolygonApi::sort_faces_by_area
IMPORT P sort_faces_by_area(P p)
Definition GameApi_pl.cc:29890

GameApi::PolygonApi::rotatez
IMPORT P rotatez(P orig, float angle)
Definition GameApi_pl.cc:5016

GameApi::PolygonApi::texture_many_shader
IMPORT ML texture_many_shader(EveryApi &ev, ML mainloop, float mix)
Definition GameApi_pl.cc:12596

GameApi::PolygonApi::line_to_cone3
IMPORT ML line_to_cone3(EveryApi &ev, LI li, float size, int numfaces, MT mt, unsigned int color)
Definition GameApi_pl.cc:15882

GameApi::PolygonApi::p_empty
IMPORT P p_empty()
Definition GameApi_pl.cc:1133

GameApi::PolygonApi::orig_pose2
IMPORT std::vector< P > orig_pose2(EveryApi &ev, std::vector< P > vec, LI li, int li_size)
Definition GameApi_pl.cc:25053

GameApi::PolygonApi::render_vertex_array_ml2
IMPORT ML render_vertex_array_ml2(EveryApi &ev, P va)
Definition GameApi_pl.cc:12794

GameApi::PolygonApi::grid
IMPORT P grid(PT o, PT u_x, PT u_y, int num_x, int num_y, P *grid)

GameApi::PolygonApi::circular_span
IMPORT P circular_span(EveryApi &ev, LI li, float delta_angle_around_y_axis, int num_steps)
Definition GameApi_pl.cc:5386

GameApi::PolygonApi::texture_splitter2
IMPORT P texture_splitter2(P p, int num, int num_slots, int current_slot)
Definition GameApi_pl.cc:18658

GameApi::PolygonApi::log_coords
IMPORT P log_coords(P p)
Definition GameApi_pl.cc:16627

GameApi::PolygonApi::p_ds
IMPORT P p_ds(EveryApi &ev, const unsigned char *beg, const unsigned char *end)
Definition GameApi_pl.cc:17839

GameApi::PolygonApi::texcoord_spherical
IMPORT P texcoord_spherical(PT center, P orig)
Definition GameApi_pl.cc:3317

GameApi::PolygonApi::render_vertex_array_instanced
IMPORT void render_vertex_array_instanced(ShaderApi &ev, VA va, PTA pta, SH sh, int hide_n=-1)
Definition GameApi_pl.cc:13089

GameApi::PolygonApi::mesh_anim
IMPORT ML mesh_anim(EveryApi &ev, std::vector< P > vec, std::vector< MN > move, std::vector< MT > mat, std::vector< MS > inst, std::vector< IF > states, std::string url)
Definition GameApi_pl.cc:22733

GameApi::PolygonApi::attribi_function
IMPORT P attribi_function(P p1, std::function< int(int face, int point, int idx)> f, int idx)
Definition GameApi_pl.cc:6022

GameApi::PolygonApi::texcoord_default
IMPORT P texcoord_default(P orig)
Definition GameApi_pl.cc:7318

GameApi::PolygonApi::s_spherical
IMPORT S s_spherical(float c_x, float c_y, float c_z, FB fb, float start_radius, float end_radius, float start_values, float end_values)
Definition GameApi_pl.cc:16819

GameApi::PolygonApi::texture_sbm
IMPORT SBM texture_sbm()
Definition GameApi_pl.cc:16297

GameApi::PolygonApi::create_vertex_array
IMPORT VA create_vertex_array(P p, bool keep=false)
Definition GameApi_pl.cc:6557

GameApi::PolygonApi::memoize_all
IMPORT P memoize_all(P orig)
Definition GameApi_pl.cc:5378

GameApi::PolygonApi::repeat_yz_p
IMPORT P repeat_yz_p(EveryApi &ev, P p, float start_y, float start_z, float dy, float dz, int sy, int sz)
Definition GameApi_pl.cc:19139

GameApi::PolygonApi::disc
IMPORT P disc(EveryApi &ev, int numfaces, float center_x, float center_y, float center_z, float normal_x, float normal_y, float normal_z, float radius)
Definition GameApi_pl.cc:16063

GameApi::PolygonApi::material_choose
IMPORT ARR material_choose(std::vector< MT > mat, std::vector< P > p)
Definition GameApi_pl.cc:18784

GameApi::PolygonApi::create_vertex_array_hw
IMPORT void create_vertex_array_hw(VA va)
Definition GameApi_pl.cc:6542

GameApi::PolygonApi::heightmap2
IMPORT P heightmap2(FB bm, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)
Definition GameApi_pl.cc:5578

GameApi::PolygonApi::render_vertex_array_dyn
IMPORT void render_vertex_array_dyn(VA va, DC dc, MainLoopEnv &e)
Definition GameApi_pl.cc:12983

GameApi::PolygonApi::point_function
IMPORT P point_function(P p1, std::function< PT(int face, int point)> f)
Definition GameApi_pl.cc:5976

GameApi::PolygonApi::block_render
IMPORT ARR block_render(GameApi::EveryApi &ev, std::vector< P > vec, MT mat)
Definition GameApi_pl.cc:23201

GameApi::PolygonApi::or_array
IMPORT P or_array(P *array, int size)
Definition GameApi_pl.cc:4254

GameApi::PolygonApi::new_pose
IMPORT MS new_pose(EveryApi &ev, LI li_orig, LI li)
Definition GameApi_pl.cc:25174

GameApi::PolygonApi::choose_time
IMPORT ML choose_time(ML next, std::vector< ML > vec, float delta_time)
Definition GameApi_pl.cc:20622

GameApi::PolygonApi::load_scene
IMPORT ML load_scene(EveryApi &ev, std::string url, int sx, int sy)
Definition GameApi_pl.cc:22045

GameApi::PolygonApi::static_instancing_array
IMPORT P static_instancing_array(EveryApi &ev, std::vector< P > vec, PTS pos)
Definition GameApi_pl.cc:15937

GameApi::PolygonApi::decimate
IMPORT P decimate(P p, float val)
Definition GameApi_pl.cc:28967

GameApi::PolygonApi::average_normals
IMPORT P average_normals(P orig, int sx, int sy)
Definition GameApi_pl.cc:5362

GameApi::PolygonApi::normal_function
IMPORT P normal_function(P p1, std::function< V(int face, int point)> f)
Definition GameApi_pl.cc:5986

GameApi::PolygonApi::matrix44
IMPORT P matrix44(P orig, M mat)
Definition GameApi_pl.cc:25419

GameApi::PolygonApi::span
IMPORT P span(LI li, M matrix, int num_steps)
Definition GameApi_pl.cc:5493

GameApi::PolygonApi::is_texture
IMPORT bool is_texture(VA va)
Definition GameApi_pl.cc:12836

GameApi::PolygonApi::gltf_shader
IMPORT ML gltf_shader(EveryApi &ev, ML mainloop, float mix, bool tex0, bool tex1, bool tex2, bool tex3, bool tex4, bool tex5, bool tex6, bool tex7, float roughness, float metallic, float basecolor0, float basecolor1, float basecolor2, float basecolor3, float occul, float emiss, bool spec, float diff_factor_r=1.0, float diff_factor_g=1.0, float diff_factor_b=1.0, float spec_factor_r=1.0, float spec_factor_g=1.0, float spec_factor_b=1.0, float glossi_factor=1.0, bool unlit=false, float emis2_r=0.0, float emis2_g=0.0, float emis2_b=0.0, float light_dir_x=0.0, float light_dir_y=0.0, float light_dir_z=-400.0, std::string cache_id="gltf", float self_mult=1.0, float rest_mult=0.0, bool emissive=false)
Definition GameApi_pl.cc:12601

GameApi::PolygonApi::choose_texture
IMPORT P choose_texture(P orig, int num)
Definition GameApi_pl.cc:7325

GameApi::PolygonApi::interpolate_mesh_pair
IMPORT P interpolate_mesh_pair(P start_p, P end_p)
Definition GameApi_pl.cc:31593

GameApi::PolygonApi::p_gen_texture
IMPORT void p_gen_texture(P p, int i)
Definition GameApi_pl.cc:18320

GameApi::PolygonApi::curve_group_from_anim
IMPORT CG curve_group_from_anim(MA ma, float start_time, float end_time)
Definition GameApi.cc:33202

GameApi::PolygonApi::prepare
IMPORT void prepare(P p, int bbm_choose=-1)
Definition GameApi_pl.cc:5695

GameApi::PolygonApi::find_attach2
IMPORT ATT find_attach2(P p, LI li)
Definition GameApi_pl.cc:24761

GameApi::PolygonApi::material_extractor_mt
IMPORT ARR material_extractor_mt(EveryApi &ev, P p, float mix, int start_index, int end_index)
Definition GameApi_pl.cc:18870

GameApi::PolygonApi::colourspace_facecoll
IMPORT P colourspace_facecoll(CSI i, float t)
Definition GameApi_pl.cc:28248

GameApi::PolygonApi::output_ml
IMPORT std::string output_ml(std::string objfileurl, int count, std::string prefix, std::vector< MaterialDef > filenames)
Definition GameApi_pl.cc:18275

GameApi::PolygonApi::translate
IMPORT P translate(P orig, float dx, float dy, float dz)
Definition GameApi_pl.cc:4967

GameApi::PolygonApi::clone
IMPORT void clone(VA va)
Definition GameApi_pl.cc:12978

GameApi::PolygonApi::id_array
IMPORT ID id_array(ID *array, int size)

GameApi::PolygonApi::decimate_zeros
IMPORT P decimate_zeros(P p)

GameApi::PolygonApi::seq_p_array
IMPORT ARR seq_p_array(std::vector< P > vec, std::vector< P > vec2)
Definition GameApi_main.cc:2552

GameApi::PolygonApi::fade_shader
IMPORT ML fade_shader(EveryApi &ev, ML mainloop, float start_time, float end_time, float start_time2, float end_time2)
Definition GameApi_pl.cc:12629

GameApi::PolygonApi::mtl_parse
IMPORT std::vector< TXID > mtl_parse(EveryApi &ev, std::vector< unsigned char > mtlfilecontents, std::string url_prefix, int delta=0)
Definition GameApi_pl.cc:1652

GameApi::PolygonApi::quad_z
IMPORT P quad_z(float x1, float x2, float y1, float y2, float z)
Definition GameApi_pl.cc:3540

GameApi::PolygonApi::get_tri_vertex_array
IMPORT void get_tri_vertex_array(P p, int choose, int row, int *v_size, float **v_array, int *n_size, float **n_array, int *c_size, unsigned int **c_array, int *tex_size, float **tex_array, int *attrib_size1, int *attrib_size2, float ***attrib_array)
Definition GameApi_pl.cc:6111

GameApi::PolygonApi::material_face_collection
IMPORT P material_face_collection(P base, P material)
Definition GameApi_pl.cc:27329

GameApi::PolygonApi::linear_span
IMPORT P linear_span(EveryApi &ev, LI li, float dx, float dy, float dz, int num_steps)
Definition GameApi_pl.cc:5504

GameApi::PolygonApi::or_array3
IMPORT P or_array3(std::vector< P > vec)
Definition GameApi_pl.cc:4226

GameApi::PolygonApi::pts_to_voxel
IMPORT AV pts_to_voxel(PTS pts, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, int sx, int sy, int sz)
Definition GameApi_pl.cc:22104

GameApi::PolygonApi::decimate_tf
IMPORT TF decimate_tf(TF mesh, float val)
Definition GameApi_pl.cc:30763

GameApi::PolygonApi::sphere_map
IMPORT P sphere_map(float c_x, float c_y, float c_z, FB fb, float start_radius, float end_radius, float start_values, float end_values, int sx, int sy)
Definition GameApi_pl.cc:16835

GameApi::PolygonApi::sprite_bind
IMPORT P sprite_bind(P p, TX tx, int id)
Definition GameApi_pl.cc:3331

GameApi::PolygonApi::anim_array
IMPORT P anim_array(P *array, int size)
Definition GameApi_pl.cc:5635

GameApi::PolygonApi::texture_splitter
IMPORT P texture_splitter(P p, int start_index, int end_index)
Definition GameApi_pl.cc:18470

GameApi::PolygonApi::color_poly
IMPORT P color_poly(P orig, int facenum, unsigned int *array, int size)

GameApi::PolygonApi::av_unique
IMPORT AV av_unique(AV arr)
Definition GameApi_pl.cc:22242

GameApi::PolygonApi::m_bind_many
IMPORT ML m_bind_many(EveryApi &ev, std::vector< P > vec, std::vector< MT > materials, int ticks)
Definition GameApi_pl.cc:21952

GameApi::PolygonApi::load_model_all
IMPORT P load_model_all(std::string filename, int count)
Definition GameApi_pl.cc:1232

GameApi::PolygonApi::bitmapsized_quad
IMPORT P bitmapsized_quad(BM bm)
Definition GameApi_pl.cc:3516

GameApi::PolygonApi::cullface
IMPORT ML cullface(ML ml, bool b, bool is_gltf)
Definition GameApi.cc:42306

GameApi::PolygonApi::gltf_load
IMPORT P gltf_load(EveryApi &ev, TF model, int mesh_index, int prim_index, TRR resize_transfer_id)
Definition GameApi_gltf.cc:6206

GameApi::PolygonApi::plane_map
IMPORT P plane_map(float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, float start_values, float end_values, FB fb, int sx, int sy)
Definition GameApi_pl.cc:16845

GameApi::PolygonApi::anim_bind
IMPORT ML anim_bind(EveryApi &ev, ML next, MA anim, MT material, float start_time, float delta_time, int count)
Definition GameApi_pl.cc:20743

GameApi::PolygonApi::interpolate_mesh_pair_arr
IMPORT ARR interpolate_mesh_pair_arr(std::vector< P > start_ps, std::vector< P > end_ps)
Definition GameApi_pl.cc:31599

GameApi::PolygonApi::p_ds2
IMPORT P p_ds2(EveryApi &ev, DS ds2)
Definition GameApi_pl.cc:17833

GameApi::PolygonApi::rotatey
IMPORT P rotatey(P orig, float angle)
Definition GameApi_pl.cc:5005

GameApi::PolygonApi::fromsurface
IMPORT P fromsurface(S s, float thickness)

GameApi::PolygonApi::remove_faces
IMPORT P remove_faces(P p)
Definition GameApi_pl.cc:25581

GameApi::PolygonApi::vr_fullscreen_quad
IMPORT P vr_fullscreen_quad(EveryApi &ev, bool is_right)
Definition GameApi_pl.cc:3522

GameApi::PolygonApi::ds_cache_mtl
IMPORT P ds_cache_mtl(EveryApi &ev, P input, int count, std::string mtl_url, std::string url_prefix)
Definition GameApi_pl.cc:2900

GameApi::PolygonApi::newshadow_shader_1
IMPORT ML newshadow_shader_1(EveryApi &ev, ML ml, float light_dir_x, float light_dir_y, float light_dir_z, float scale)
Definition GameApi_pl.cc:12673

GameApi::PolygonApi::poly_size
IMPORT int poly_size(ARR arr)
Definition GameApi_pl.cc:16026

GameApi::PolygonApi::edge_shader
IMPORT ML edge_shader(EveryApi &ev, ML mainloop, float edge_width, unsigned int edge_color)
Definition GameApi_pl.cc:12719

GameApi::PolygonApi::spherical_wave
IMPORT P spherical_wave(P p, float r1, float fr_1, float r2, float fr_2)
Definition GameApi_pl.cc:16666

GameApi::PolygonApi::block_render2
IMPORT ARR block_render2(GameApi::EveryApi &ev, std::vector< P > vec, std::vector< MT > mat)
Definition GameApi_pl.cc:23214

GameApi::PolygonApi::mesh_color_shader
IMPORT ML mesh_color_shader(EveryApi &ev, ML mainloop, SFO sfo)
Definition GameApi_pl.cc:12639

GameApi::PolygonApi::rotatex
IMPORT P rotatex(P orig, float angle)
Definition GameApi_pl.cc:4994

GameApi::PolygonApi::texcoord_plane
IMPORT P texcoord_plane(P p, float start_x, float end_x, float start_y, float end_y)
Definition GameApi_pl.cc:3304

GameApi::PolygonApi::repeat_xz_p
IMPORT P repeat_xz_p(EveryApi &ev, P p, float start_x, float start_z, float dx, float dz, int sx, int sz)
Definition GameApi_pl.cc:19130

GameApi::PolygonApi::poly_index
IMPORT P poly_index(ARR arr, int idx)
Definition GameApi_pl.cc:16031

GameApi::PolygonApi::from_polygon_1
P from_polygon_1(P p, std::function< P(int face, PT p1, PT p2, PT p3, PT p4)> f)
Definition GameApi_pl.cc:696

GameApi::PolygonApi::get_tri_vertex_array_rows
IMPORT int get_tri_vertex_array_rows(P p)
Definition GameApi_pl.cc:6103

GameApi::PolygonApi::bar_chart2
IMPORT P bar_chart2(GameApi::EveryApi &ev, std::string url, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, float per, float per2)
Definition GameApi_diag.cc:235

GameApi::PolygonApi::p_url_nr
IMPORT P p_url_nr(EveryApi &ev, std::string url, int count)
Definition GameApi_pl.cc:2616

GameApi::PolygonApi::array_lighting
IMPORT L array_lighting(L *array, int size)

GameApi::PolygonApi::colourspace_sample
IMPORT CSI colourspace_sample(CS i, int sx, int sy, int sz)
Definition GameApi_pl.cc:28242

GameApi::PolygonApi::get_face_count
IMPORT P get_face_count(P p)
Definition GameApi_pl.cc:26531

GameApi::PolygonApi::texcoord_subarea
IMPORT P texcoord_subarea(P p, float start_x, float end_x, float start_y, float end_y)
Definition GameApi_pl.cc:21822

GameApi::PolygonApi::cone
IMPORT P cone(int numfaces, PT p1, PT p2, float rad1, float rad2)
Definition GameApi_pl.cc:3673

GameApi::PolygonApi::mesh_elem
IMPORT P mesh_elem(P start, P end)
Definition GameApi_pl.cc:22803

GameApi::PolygonApi::x_split
IMPORT P x_split(P p, float x, float x_0, float x_1)
Definition GameApi_pl.cc:27001

GameApi::PolygonApi::colormix_shader
IMPORT ML colormix_shader(EveryApi &ev, ML mainloop, float mix)

GameApi::PolygonApi::static_instancing
IMPORT P static_instancing(EveryApi &ev, P obj, PTS pos)
Definition GameApi_pl.cc:15953

GameApi::PolygonApi::sort_vertices
IMPORT void sort_vertices(VA va, M m)
Definition GameApi_pl.cc:12846

GameApi::PolygonApi::bar_chart
IMPORT P bar_chart(GameApi::EveryApi &ev, std::string url, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, float per)
Definition GameApi_diag.cc:230

GameApi::PolygonApi::p_mtl_bump
IMPORT ARR p_mtl_bump(P p)
Definition GameApi_pl.cc:2465

GameApi::PolygonApi::li_polygon
IMPORT P li_polygon(LI li, float width)
Definition GameApi_pl.cc:22376

GameApi::PolygonApi::li_piechart
IMPORT LI li_piechart(float c_x, float c_y, float c_z, float start_angle, float end_angle, float radius, int numsteps)
Definition GameApi_diag.cc:281

GameApi::PolygonApi::static_instancing_with_color
IMPORT P static_instancing_with_color(EveryApi &ev, P obj, BM bm, float start_x, float end_x, float start_y, float end_y, float z)
Definition GameApi_pl.cc:15985

GameApi::PolygonApi::texture_arr_shader
IMPORT ML texture_arr_shader(EveryApi &ev, ML mainloop, float mix)
Definition GameApi_pl.cc:12611

GameApi::PolygonApi::solid_of_revolution
IMPORT P solid_of_revolution(EveryApi &ev, int numfaces, float p_x, float p_y, float p_z, float p1_x, float p1_y, float p1_z, std::string deltas, std::string radiuses)
Definition GameApi_pl.cc:31722

GameApi::PolygonApi::color_faces
IMPORT P color_faces(P orig, unsigned int color_1, unsigned int color_2, unsigned int color_3, unsigned int color_4)
Definition GameApi_pl.cc:4952

GameApi::PolygonApi::p_mtl_nr
IMPORT P p_mtl_nr(EveryApi &ev, std::string obj_url, std::string mtl_url, std::string prefix, int count)
Definition GameApi_pl.cc:2657

GameApi::PolygonApi::globe_shader
IMPORT ML globe_shader(EveryApi &ev, ML mainloop, float globe_r)
Definition GameApi_pl.cc:12726

GameApi::PolygonApi::extract_large_polygons
IMPORT P extract_large_polygons(P p, float minimum_size, bool reverse)
Definition GameApi_pl.cc:27190

GameApi::PolygonApi::quad_tree
IMPORT ML quad_tree(P p)
Definition GameApi.cc:39464

GameApi::PolygonApi::render_vertex_array_ml2_texture_id
IMPORT ML render_vertex_array_ml2_texture_id(EveryApi &ev, P va, std::vector< TXID > *vec)
Definition GameApi_pl.cc:12812

GameApi::PolygonApi::toon_outline
IMPORT P toon_outline(P p, float border_width)
Definition GameApi.cc:42259

GameApi::PolygonApi::material_arr
IMPORT ARR material_arr(std::vector< MT > vec, int start_range, int end_range)
Definition GameApi_pl.cc:18485

GameApi::PolygonApi::choose_color_shader
IMPORT ML choose_color_shader(EveryApi &ev, ML mainloop, unsigned int color, float mix_val)
Definition GameApi_pl.cc:12579

GameApi::PolygonApi::alt
IMPORT P alt(std::vector< P > vec, int index)
Definition GameApi_pl.cc:14389

GameApi::PolygonApi::rotate
IMPORT P rotate(P orig, PT pt, V axis, float angle)
Definition GameApi_pl.cc:5027

GameApi::PolygonApi::skeletal_anim
IMPORT P skeletal_anim(P p, PT p_0, PT p_1, PT n_0, PT n_1)
Definition GameApi_pl.cc:4841

GameApi::PolygonApi::polygon
IMPORT P polygon(PT *array, int size)
Definition GameApi_pl.cc:6225

GameApi::PolygonApi::array_pl
IMPORT PL array_pl(std::vector< PL > vec)
Definition GameApi_pl.cc:27802

GameApi::PolygonApi::polygon2
IMPORT P polygon2(std::vector< PT > vec)
Definition GameApi_pl.cc:6198

GameApi::PolygonApi::save_model_ml
IMPORT ML save_model_ml(P poly, std::string filename)
Definition GameApi_pl.cc:2997

GameApi::PolygonApi::tf_glb_tf
IMPORT TF tf_glb_tf(EveryApi &ev, TF tf, std::string url)
Definition GameApi.cc:31734

GameApi::PolygonApi::newshadow_shader_2_phong
IMPORT ML newshadow_shader_2_phong(EveryApi &ev, ML ml, float light_dir_x, float light_dir_y, float light_dir_z, float dark_level, float light_level, float scale)
Definition GameApi_pl.cc:12679

GameApi::PolygonApi::noise_shader
IMPORT ML noise_shader(EveryApi &ev, ML mainloop)
Definition GameApi_pl.cc:12527

GameApi::PolygonApi::bloom_cut_sbm
IMPORT SBM bloom_cut_sbm(SBM texture, float r, float g, float b)
Definition GameApi_pl.cc:16346

GameApi::PolygonApi::p_mtl_materials
IMPORT ARR p_mtl_materials(EveryApi &ev, P P)
Definition GameApi_pl.cc:2339

GameApi::PolygonApi::light_bm
IMPORT BM light_bm(L lighting, P poly)

GameApi::PolygonApi::anim_endpoints
IMPORT P anim_endpoints(P p1, P p2)
Definition GameApi_pl.cc:13565

GameApi::PolygonApi::color_map4
IMPORT P color_map4(BM bm, FB height, float sx, float sy, float z)

GameApi::PolygonApi::heightmap
IMPORT P heightmap(BM bm, HeightMapType t, float min_x, float max_x, float min_y, float max_y, float min_z, float max_z)
Definition GameApi_pl.cc:5610

GameApi::PolygonApi::p_mtl2_nr
IMPORT ARR p_mtl2_nr(EveryApi &ev, std::string obj_url, std::string mtl_url, std::string prefix, int count, int start_index, int end_index, float mix)
Definition GameApi_pl.cc:18726

GameApi::PolygonApi::polygon3
IMPORT P polygon3(PTS points)
Definition GameApi_pl.cc:6202

GameApi::PolygonApi::from_points
IMPORT P from_points(PTS p, std::function< P(int i, float x, float y, float z, unsigned int color)> f)
Definition GameApi_pl.cc:736

GameApi::PolygonApi::shadow_map
IMPORT BM shadow_map(EveryApi &ev, P p, float p_x, float p_y, float p_z, int sx, int sy)
Definition GameApi_pl.cc:20811

GameApi::PolygonApi::line_to_cone
IMPORT P line_to_cone(EveryApi &ev, LI li, float size, int numfaces)
Definition GameApi_pl.cc:15903

GameApi::PolygonApi::slow_calc_lights
IMPORT P slow_calc_lights(P p, float light_dir_x, float light_dir_y, float light_dir_z)
Definition GameApi_pl.cc:26034

GameApi::PolygonApi::lod_choose
IMPORT P lod_choose(std::vector< P > vec, std::string name)
Definition GameApi_pl.cc:21641

GameApi::PolygonApi::discard_shader
IMPORT ML discard_shader(EveryApi &ev, ML mainloop)
Definition GameApi_pl.cc:12754

GameApi::PolygonApi::anim_target_vector
IMPORT P anim_target_vector(P p, V v)
Definition GameApi_pl.cc:13540

GameApi::PolygonApi::meshy
IMPORT TF meshy(EveryApi &ev, std::string prompt, std::string filename)
Definition GameApi.cc:31029

GameApi::PolygonApi::texcoord_poly
IMPORT P texcoord_poly(P orig, int facenum, PT *array, int size)

GameApi::PolygonApi::or_elem
IMPORT P or_elem(P p1, P p2)
Definition GameApi_pl.cc:3722

GameApi::PolygonApi::gltf_anim_shader
IMPORT ML gltf_anim_shader(GameApi::EveryApi &ev, ML ml_orig, std::vector< GameApi::ML > mls, int key, int mode, int timeid, TRA anim_transfer_id, int frame_skip)
Definition GameApi_gltf.cc:15359

GameApi::PolygonApi::or_array_1
P or_array_1(P *array, int size)
Definition GameApi_pl.cc:4258

GameApi::PolygonApi::sphere_rays
IMPORT P sphere_rays(float center_x, float center_y, float center_z, float radius, float delta_alfa, float delta_beta, FS field, int maxiter, float c, std::vector< PT > vec)
Definition GameApi_ff.cc:412

GameApi::PolygonApi::lod_select
IMPORT IF lod_select(float start_dist, float dist_step, int max_value)
Definition GameApi_pl.cc:21792

GameApi::PolygonApi::triangle
IMPORT P triangle(PT p1, PT p2, PT p3)
Definition GameApi_pl.cc:1025

GameApi::PolygonApi::shadow_map2
IMPORT BB shadow_map2(P p, float p_x, float p_y, float p_z, int sx, int sy, P quad)
Definition GameApi_pl.cc:20891

GameApi::PolygonApi::~PolygonApi
IMPORT ~PolygonApi()
Definition GameApi_pl.cc:632

GameApi::PolygonApi::sfo_sbm
IMPORT SBM sfo_sbm(EveryApi &ev, SFO sfo)
Definition GameApi_pl.cc:16558

GameApi::PolygonApi::light_shader
IMPORT ML light_shader(EveryApi &ev, ML mainloop)
Definition GameApi_pl.cc:12617

GameApi::PolygonApi::split_p
IMPORT P split_p(P p, int start_face, int end_face)
Definition GameApi_pl.cc:15764

GameApi::PolygonApi::render_vertex_array
IMPORT void render_vertex_array(VA va)
Definition GameApi_pl.cc:12852

GameApi::PolygonApi::texcoord_cylindar
IMPORT P texcoord_cylindar(P orig, float start_y, float end_y)
Definition GameApi_pl.cc:3324

GameApi::PolygonApi::reflection
IMPORT P reflection(P orig, PT pos, V u_x, V u_y, V ref_vec)
Definition GameApi_pl.cc:3711

GameApi::PolygonApi::load_glb_from_temp2
IMPORT TF load_glb_from_temp2(std::string filename)
Definition GameApi.cc:31936

GameApi::PolygonApi::render_pl
IMPORT P render_pl(PL pl)
Definition GameApi_pl.cc:27834

GameApi::PolygonApi::color_lambert
IMPORT P color_lambert(P orig, unsigned int color, float light_dir_x, float light_dir_y, float light_dir_z, float pow, float intensity)
Definition GameApi_pl.cc:4403

GameApi::PolygonApi::find_point_id
IMPORT ID find_point_id(P p, int facenum, int pointnum)

GameApi::PolygonApi::mixshader_shader
IMPORT ML mixshader_shader(EveryApi &ev, ML ml, float mix=0.5)
Definition GameApi_pl.cc:12589

GameApi::PolygonApi::array_p_array
IMPORT ARR array_p_array(std::vector< PV > vec)
Definition GameApi_main.cc:2530

GameApi::PolygonApi::is_array_texture
IMPORT bool is_array_texture(VA va)
Definition GameApi_pl.cc:12841

GameApi::PolygonApi::texcoord_function
IMPORT P texcoord_function(P p1, std::function< PT(int face, int point)> f)
Definition GameApi_pl.cc:6004

GameApi::PolygonArrayApi
Definition GameApi.hh:2824

GameApi::PolygonArrayApi::PolygonArrayApi
IMPORT PolygonArrayApi(Env &e)
Definition GameApi.cc:44510

GameApi::PolygonArrayApi::create_vertex_array
Va create_vertex_array(EveryApi &ev, Pa p, bool keep=false)
Definition GameApi.cc:908

GameApi::PolygonArrayApi::delete_vertex_array
void delete_vertex_array(EveryApi &ev, Va va)
Definition GameApi.cc:958

GameApi::PolygonArrayApi::render_vertex_array_instanced
void render_vertex_array_instanced(EveryApi &ev, ShaderApi &sha, Va va, PTA pta, SH sh)
Definition GameApi.cc:947

GameApi::PolygonArrayApi::render_vertex_array
void render_vertex_array(EveryApi &ev, Va p)
Definition GameApi.cc:925

GameApi::PolygonArrayApi::split_p
Pa split_p(EveryApi &ev, P p, int max_chunk)
Definition GameApi.cc:883

GameApi::PolygonArrayApi::prepare_vertex_array_instanced_matrix
void prepare_vertex_array_instanced_matrix(EveryApi &ev, ShaderApi &sha, Va va, MSA pta, SH sh)

GameApi::PolygonArrayApi::prepare_vertex_array_instanced
void prepare_vertex_array_instanced(EveryApi &ev, ShaderApi &sha, Va va, PTA pta, SH sh)
Definition GameApi.cc:936

GameApi::PolygonDistanceField
Definition GameApi.hh:2793

GameApi::PolygonDistanceField::mesh_color_from_sfo
IMPORT MT mesh_color_from_sfo(EveryApi &ev, PD orig, MT next)
Definition GameApi.cc:17291

GameApi::PolygonDistanceField::render_scene_array
IMPORT std::vector< ML > render_scene_array(EveryApi &ev, std::vector< PD > vec)
Definition GameApi.cc:17306

GameApi::PolygonDistanceField::colormod_from_position
IMPORT PD colormod_from_position(EveryApi &ev, PD obj, float px, float py, float pz, float sx, float sy, float sz)
Definition GameApi.cc:17272

GameApi::PolygonDistanceField::rotatex_pd
IMPORT PD rotatex_pd(EveryApi &ev, PD orig, float angle)

GameApi::PolygonDistanceField::scale_pd
IMPORT PD scale_pd(EveryApi &ev, PD orig, float sx, float sy, float sz)

GameApi::PolygonDistanceField::translate_pd
IMPORT PD translate_pd(EveryApi &ev, PD orig, float dx, float dy, float dz)

GameApi::PolygonDistanceField::cone_pd
IMPORT PD cone_pd(EveryApi &ev, int numfaces, PT p1, PT p2, float rad1, float rad2)

GameApi::PolygonDistanceField::ambient_occulsion_sfo
IMPORT PD ambient_occulsion_sfo(EveryApi &ev, PD obj, float d, float i)
Definition GameApi.cc:17264

GameApi::PolygonDistanceField::create_pd
IMPORT PD create_pd(P mesh, SFO distance_field)
Definition GameApi.cc:17184

GameApi::PolygonDistanceField::get_polygon
IMPORT P get_polygon(PD p)
Definition GameApi.cc:17285

GameApi::PolygonDistanceField::cube_pd
IMPORT PD cube_pd(EveryApi &ev, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)
Definition GameApi.cc:17195

GameApi::PolygonDistanceField::or_array_pd
IMPORT PD or_array_pd(EveryApi &ev, std::vector< PD > vec)
Definition GameApi.cc:17237

GameApi::PolygonDistanceField::rotatey_pd
IMPORT PD rotatey_pd(EveryApi &ev, PD orig, float angle)

GameApi::PolygonDistanceField::color_from_normal_pd
IMPORT PD color_from_normal_pd(EveryApi &ev, PD obj)
Definition GameApi.cc:17257

GameApi::PolygonDistanceField::get_distance_field
IMPORT SFO get_distance_field(PD p)
Definition GameApi.cc:17280

GameApi::PolygonDistanceField::PolygonDistanceField
IMPORT PolygonDistanceField(Env &e)
Definition GameApi.cc:44509

GameApi::PolygonDistanceField::sphere_pd
IMPORT PD sphere_pd(EveryApi &ev, PT center, float radius, int numfaces1, int numfaces2)
Definition GameApi.cc:17225

GameApi::PolygonDistanceField::rotatez_pd
IMPORT PD rotatez_pd(EveryApi &ev, PD orig, float angle)

GameApi::PolygonDistanceField::rounded_cube_pd
IMPORT PD rounded_cube_pd(EveryApi &ev, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, float radius)
Definition GameApi.cc:17208

GameApi::PolygonDistanceField::render_scene
IMPORT ML render_scene(EveryApi &ev, PD object, PD world)
Definition GameApi.cc:17296

GameApi::PolygonObj::~PolygonObj
~PolygonObj()
Definition GameApi.hh:5184

GameApi::PolygonObj::set_rotation_matrix2
void set_rotation_matrix2(M m)
Definition GameApi.hh:5258

GameApi::PolygonObj::set_var
void set_var(std::string name, float r, float g, float b, float a)
Definition GameApi.hh:5287

GameApi::PolygonObj::set_anim_time
void set_anim_time(float time)
Definition GameApi.hh:5276

GameApi::PolygonObj::render
void render()
Definition GameApi.hh:5215

GameApi::PolygonObj::PolygonObj
PolygonObj(EveryApi &ev, P p, SH sh)
Definition GameApi.hh:5128

GameApi::PolygonObj::bind_texture
void bind_texture(int anim_id, TXID id_)
Definition GameApi.hh:5263

GameApi::PolygonObj::set_rotation_matrix
void set_rotation_matrix(M m)
Definition GameApi.hh:5253

GameApi::PolygonObj::set_anim_frame
void set_anim_frame(int id)
Definition GameApi.hh:5271

GameApi::PolygonObj::set_scale
void set_scale(float mult_x, float mult_y, float mult_z)
Definition GameApi.hh:5243

GameApi::PolygonObj::bind_texarray
void bind_texarray(TXA id)
Definition GameApi.hh:5267

GameApi::PolygonObj::PolygonObj
PolygonObj(EveryApi &ev, std::vector< P > anim_p, SH sh)
Definition GameApi.hh:5146

GameApi::PolygonObj::set_rotation_y
void set_rotation_y(float angle)
Definition GameApi.hh:5248

GameApi::PolygonObj::set_pos
void set_pos(float pos_x, float pos_y, float pos_z)
Definition GameApi.hh:5238

GameApi::PolygonObj::prepare
void prepare(bool keep=false)
Definition GameApi.hh:5191

GameApi::PolygonObj::render_instanced
void render_instanced(PTA pta)
Definition GameApi.hh:5224

GameApi::RenderObject
Definition GameApi.hh:4755

GameApi::RenderObject::set_var
virtual void set_var(std::string name, float r, float g, float b, float a)=0

GameApi::RenderObject::prepare
virtual void prepare(bool keep=false)=0

GameApi::RenderObject::~RenderObject
virtual ~RenderObject()
Definition GameApi.hh:4757

GameApi::RenderObject::render
virtual void render()=0

GameApi::SampleCollectionApi
Definition GameApi.hh:3549

GameApi::SampleCollectionApi::SampleCollectionApi
IMPORT SampleCollectionApi(Env &e)
Definition GameApi.cc:44512

GameApi::SampleCollectionApi::play_sample_1
void play_sample_1(int channel, WAV w, int id)
Definition GameApi_sm.cc:75

GameApi::SampleCollectionApi::init_audio
IMPORT void init_audio()
Definition GameApi_sm.cc:63

GameApi::SampleCollectionApi::play_sample
IMPORT void play_sample(int channel, WAV w, int id)
Definition GameApi_sm.cc:72

GameApi::SampleCollectionApi::prepare
IMPORT WAV prepare(SM samples)
Definition GameApi_sm.cc:95

GameApi::SampleCollectionApi::add
IMPORT SM add(SM orig, WV wave, int sample_rate, int id)
Definition GameApi_sm.cc:53

GameApi::SampleCollectionApi::empty
IMPORT SM empty()
Definition GameApi_sm.cc:15

GameApi::SeparateApi
Definition GameApi.hh:2676

GameApi::SeparateApi::u_sep
SA u_sep(SA orig, float(*sep_u)(float x, float y, float z, void *data), void *data)
Definition GameApi.cc:642

GameApi::SeparateApi::SeparateApi
IMPORT SeparateApi(Env &e)
Definition GameApi.cc:44505

GameApi::SeparateApi::empty
SA empty()
Definition GameApi.cc:637

GameApi::SeparateApi::surf_sep
SA surf_sep(SA orig, float(*sep_dist)(float x, float y, float z, void *data), void *data)
Definition GameApi.cc:660

GameApi::SeparateApi::v_sep
SA v_sep(SA orig, float(*sep_v)(float x, float y, float z, void *data), void *data)
Definition GameApi.cc:651

GameApi::SeparateApi::create_quads
P create_quads(SA object, float dist, float dist_accuracy, float x_range_start, float x_range_end, float x_step, float y_range_start, float y_range_end, float y_step, float z_range_start, float z_range_end, float z_step, float u_range_start, float u_range_end, float u_step, float v_range_start, float v_range_end, float v_step)
Definition GameApi.cc:670

GameApi::ShaderApi
Definition GameApi.hh:4486

GameApi::ShaderApi::bind_attrib_1
void bind_attrib_1(GameApi::SH shader, int num, std::string name)
Definition GameApi_sh.cc:338

GameApi::ShaderApi::colour_texture_shader
IMPORT SH colour_texture_shader()
Definition GameApi_sh.cc:132

GameApi::ShaderApi::get_normal_shader_1_new
SH get_normal_shader_1_new(std::string v_format, std::string f_format, std::string g_format, std::string v_comb="", std::string f_comb="", bool trans=true, SFO mod={ -1 }, US v_c={ -1 }, US f_c={ -1 }, std::string v_defines="IN_NORMAL IN_POSITION IN_COLOR IN_TEXCOORD EX_COLOR EX_NORMAL EX_POSITION EX_TEXCOORD", std::string f_defines="EX_COLOR EX_NORMAL EX_POSITION EX_TEXCOORD", std::string v_shader="", std::string f_shader="")
Definition GameApi_sh.cc:195

GameApi::ShaderApi::texture_many_shader
IMPORT SH texture_many_shader()
Definition GameApi_sh.cc:107

GameApi::ShaderApi::use_1
void use_1(SH shader)
Definition GameApi_sh.cc:305

GameApi::ShaderApi::texture_array_shader
IMPORT SH texture_array_shader()
Definition GameApi_sh.cc:103

GameApi::ShaderApi::get_shader
IMPORT SH get_shader(std::string v_format, std::string f_format, std::string g_format, std::string v_comb="", std::string f_comb="", bool trans=true, SFO module={-1})
Definition GameApi_sh.cc:252

GameApi::ShaderApi::print_log
IMPORT void print_log(SH shader)
Definition GameApi_sh.cc:75

GameApi::ShaderApi::bind_attrib
IMPORT void bind_attrib(GameApi::SH shader, int num, std::string name)
Definition GameApi_sh.cc:325

GameApi::ShaderApi::use
IMPORT PinIn use(SH shader)
Definition GameApi_sh.cc:300

GameApi::ShaderApi::get_normal_shader
IMPORT SH get_normal_shader(std::string v_format, std::string f_format, std::string g_format, std::string v_comb="", std::string f_comb="", bool trans=true, SFO mod={-1}, std::string v_defines="IN_NORMAL IN_COLOR IN_TEXCOORD IN_POSITION EX_COLOR EX_NORMAL EX_POSITION EX_TEXCOORD", std::string f_defines="EX_COLOR EX_NORMAL EX_POSITION EX_TEXCOORD", bool is_new=false)
Definition GameApi_sh.cc:136

GameApi::ShaderApi::shader_choice
IMPORT SH shader_choice(EveryApi &ev, int i)
Definition GameApi_sh.cc:116

GameApi::ShaderApi::get_shader_1
SH get_shader_1(std::string v_format, std::string f_format, std::string g_format, std::string v_comb="", std::string f_comb="", bool trans=true, SFO mod={-1}, US v_c={-1}, US f_c={-1}, std::string v_defines="IN_NORMAL IN_COLOR IN_TEXCOORD IN_POSITION EX_COLOR EX_NORMAL EX_POSITION EX_TEXCOORD EX_POSITION", std::string f_defines="EX_COLOR EX_NORMAL EX_POSITION EX_TEXCOORD", std::string v_shader="", std::string f_shader="")
Definition GameApi_sh.cc:259

GameApi::ShaderApi::set_y_rotation
IMPORT void set_y_rotation(SH shader, std::string name, float angle)
Definition GameApi_sh.cc:59

GameApi::ShaderApi::load_default
IMPORT void load_default()
Definition GameApi_sh.cc:29

GameApi::ShaderApi::ShaderApi
IMPORT ShaderApi(Env &e)
Definition GameApi_sh.cc:5

GameApi::ShaderApi::get_matrix_var
IMPORT PinOut< M > get_matrix_var(GameApi::SH shader, std::string name)
Definition GameApi_sh.cc:347

GameApi::ShaderApi::texture_shader
IMPORT SH texture_shader(bool text_draw=false)
Definition GameApi_sh.cc:93

GameApi::ShaderApi::set_var
IMPORT PinIn set_var(GameApi::SH shader, const char *name, float val)
Definition GameApi_sh.cc:359

GameApi::ShaderApi::link_1
void link_1(SH shader)
Definition GameApi_sh.cc:84

GameApi::ShaderApi::unuse
IMPORT PinIn unuse(SH shader)
Definition GameApi_sh.cc:316

GameApi::ShaderApi::set_default_projection_1
void set_default_projection_1(GameApi::SH shader, std::string name)
Definition GameApi_sh.cc:45

GameApi::ShaderApi::~ShaderApi
IMPORT ~ShaderApi()
Definition GameApi_sh.cc:13

GameApi::ShaderApi::get_normal_shader_1
SH get_normal_shader_1(std::string v_format, std::string f_format, std::string g_format, std::string v_comb="", std::string f_comb="", bool trans=true, SFO mod={ -1 }, US v_c={ -1 }, US f_c={ -1 }, std::string v_defines="IN_NORMAL IN_POSITION IN_COLOR IN_TEXCOORD EX_COLOR EX_NORMAL EX_POSITION EX_TEXCOORD", std::string f_defines="EX_COLOR EX_NORMAL EX_POSITION EX_TEXCOORD", std::string v_shader="", std::string f_shader="")
Definition GameApi_sh.cc:165

GameApi::ShaderApi::bind_frag
IMPORT void bind_frag(GameApi::SH shader, int attachment_num, std::string name)
Definition GameApi_sh.cc:330

GameApi::ShaderApi::bindnames
IMPORT void bindnames(GameApi::SH shader, std::string s_vertex, std::string s_normal, std::string s_color, std::string s_texcoord)
Definition GameApi_sh.cc:520

GameApi::ShaderApi::colour_shader
IMPORT SH colour_shader()
Definition GameApi_sh.cc:112

GameApi::ShaderApi::load
IMPORT void load(std::string filename)
Definition GameApi_sh.cc:21

GameApi::ShaderApi::link
IMPORT PinIn link(SH shader)
Definition GameApi_sh.cc:69

GameApi::ShaderApi::set_default_projection
IMPORT void set_default_projection(GameApi::SH shader, std::string name)
Definition GameApi_sh.cc:38

GameApi::ShaderApi::StateChangeApi
friend class StateChangeApi
Definition GameApi.hh:4538

GameApi::ShaderModuleApi
Definition GameApi.hh:1742

GameApi::ShaderModuleApi::cube
IMPORT SFO cube()
Definition GameApi_shm.cc:324

GameApi::ShaderModuleApi::mix_color
IMPORT SFO mix_color(SFO col1, SFO col2, float t)

GameApi::ShaderModuleApi::sphere
IMPORT SFO sphere()
Definition GameApi_shm.cc:333

GameApi::ShaderModuleApi::soft_shadow
IMPORT SFO soft_shadow(SFO scene, V light_dir, float mint, float maxt, float k, float strong)

GameApi::ShaderModuleApi::mod_z
IMPORT SFO mod_z(SFO obj, float dz)

GameApi::ShaderModuleApi::torus
IMPORT SFO torus(float radius_1, float radius_2)

GameApi::ShaderModuleApi::rot_y
IMPORT SFO rot_y(SFO obj, float angle, PT center)

GameApi::ShaderModuleApi::bind_arg
IMPORT SFO bind_arg(SFO obj, std::string name, std::string value)

GameApi::ShaderModuleApi::rot_x
IMPORT SFO rot_x(SFO obj, float angle, PT center)

GameApi::ShaderModuleApi::color_from_position
IMPORT SFO color_from_position(SFO obj, float sx, float sy, float sz)

GameApi::ShaderModuleApi::trans
IMPORT SFO trans(SFO obj, float dx, float dy, float dz)

GameApi::ShaderModuleApi::rot_y
IMPORT SFO rot_y(SFO obj, float angle)

GameApi::ShaderModuleApi::rot_x
IMPORT SFO rot_x(SFO obj, float angle)

GameApi::ShaderModuleApi::ShaderModuleApi
IMPORT ShaderModuleApi(Env &e)
Definition GameApi.cc:44488

GameApi::ShaderModuleApi::mod_x
IMPORT SFO mod_x(SFO obj, float dx)

GameApi::ShaderModuleApi::color_function
IMPORT SFO color_function(SFO orig, std::function< std::string(std::string)> function, std::string function_name)

GameApi::ShaderModuleApi::rot_z
IMPORT SFO rot_z(SFO obj, float angle, PT center)

GameApi::ShaderModuleApi::from_lines
IMPORT SFO from_lines(LI li, SFO obj)

GameApi::ShaderModuleApi::bounding_primitive
IMPORT SFO bounding_primitive(SFO prim, SFO inside, SFO outside)

GameApi::ShaderModuleApi::rounded_cube
IMPORT SFO rounded_cube(float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, float r)
Definition GameApi_shm.cc:1789

GameApi::ShaderModuleApi::stop_generation
IMPORT SFO stop_generation(SFO obj)

GameApi::ShaderModuleApi::v_render
IMPORT SFO v_render(SFO obj)
Definition GameApi_shm.cc:698

GameApi::ShaderModuleApi::and_not
IMPORT SFO and_not(SFO obj, SFO not_obj)

GameApi::ShaderModuleApi::texture_box
IMPORT SFO texture_box(float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)

GameApi::ShaderModuleApi::f_render_color
IMPORT SFO f_render_color(SFO obj)

GameApi::ShaderModuleApi::empty
IMPORT SFO empty()

GameApi::ShaderModuleApi::grayscale_from_distance
IMPORT SFO grayscale_from_distance(SFO obj, SFO dist, float length)

GameApi::ShaderModuleApi::ambient_occulsion
IMPORT SFO ambient_occulsion(SFO obj, float d, float i)
Definition GameApi_shm.cc:1776

GameApi::ShaderModuleApi::color
IMPORT SFO color(SFO obj, float r, float g, float b, float a)

GameApi::ShaderModuleApi::plane
IMPORT SFO plane(PT center, V u_x, V u_y)

GameApi::ShaderModuleApi::blend
IMPORT SFO blend(SFO obj1, SFO obj2, float k)

GameApi::ShaderModuleApi::scale
IMPORT SFO scale(SFO obj)

GameApi::ShaderModuleApi::scale
IMPORT SFO scale(SFO obj, float sx, float sy, float sz)

GameApi::ShaderModuleApi::spherical
IMPORT SFO spherical(SFO obj, PT tl, PT br, float rr, float rp)

GameApi::ShaderModuleApi::texture
IMPORT SFO texture(SFO obj)

GameApi::ShaderModuleApi::from_points
IMPORT SFO from_points(PTS p, SFO obj)

GameApi::ShaderModuleApi::colormod_from_position
IMPORT SFO colormod_from_position(SFO obj, float px, float py, float pz, float sx, float sy, float sz)
Definition GameApi_shm.cc:2278

GameApi::ShaderModuleApi::color_from_normal
IMPORT SFO color_from_normal(SFO obj)
Definition GameApi_shm.cc:677

GameApi::ShaderModuleApi::function
IMPORT SFO function(std::function< std::string(std::string id)> function, std::string function_name, std::vector< std::string > param_names=std::vector< std::string >(), std::vector< std::string > arg_values=std::vector< std::string >())

GameApi::ShaderModuleApi::noise
IMPORT SFO noise(SFO obj, float strength)

GameApi::ShaderModuleApi::line
IMPORT SFO line()

GameApi::ShaderModuleApi::grayscale
IMPORT SFO grayscale(SFO obj)

GameApi::ShaderModuleApi::line
IMPORT SFO line(float start_x, float start_y, float start_z, float end_x, float end_y, float end_z, float line_width1, float line_width2)

GameApi::ShaderModuleApi::trans
IMPORT SFO trans(SFO obj)

GameApi::ShaderModuleApi::sfo_to_ml
IMPORT ML sfo_to_ml(EveryApi &ev, SFO sfo, float sx, float sy)
Definition GameApi_shm.cc:2390

GameApi::ShaderModuleApi::rot_z
IMPORT SFO rot_z(SFO obj, float angle)

GameApi::ShaderModuleApi::mod_y
IMPORT SFO mod_y(SFO obj, float dy)

GameApi::ShaderModuleApi::or_elem
IMPORT SFO or_elem(SFO obj1, SFO obj2)
Definition GameApi_shm.cc:985

GameApi::Skeletal
Definition GameApi.hh:2053

GameApi::Skeletal::skeletal_bind_material
ML skeletal_bind_material(EveryApi &ev, std::vector< P > vec, std::vector< PT > vec2, std::vector< SA > sa_vec, MT material)
Definition GameApi.cc:17147

GameApi::Skeletal::skeletal_bind
ML skeletal_bind(EveryApi &ev, std::vector< P > vec, std::vector< PT > vec2, std::vector< SA > sa_vec)
Definition GameApi.cc:17134

GameApi::Skeletal::node
SA node(SA parent, MN matrix, PT point_offset)
Definition GameApi.cc:17127

GameApi::Skeletal::Skeletal
IMPORT Skeletal(Env &e)
Definition GameApi.cc:44495

GameApi::Skeletal::root
SA root(PT absolute_pos)
Definition GameApi.cc:17102

GameApi::SpaceApi::pt_x
float pt_x(PT p)
Definition GameApi_spa.cc:25

GameApi::SpaceApi::SpaceApi
IMPORT SpaceApi(Env &e)
Definition GameApi.cc:543

GameApi::SpaceApi::sizex
float sizex(SP s)

GameApi::SpaceApi::plus
PT plus(PT p1, PT p2)
Definition GameApi_su.cc:32

GameApi::SpaceApi::origo_x
float origo_x(SP s)

GameApi::SpaceApi::origo_y
float origo_y(SP s)

GameApi::SpaceApi::sizey
float sizey(SP s)

GameApi::SpaceApi::scalespace
SP scalespace(SP s, float scale_x, float scale_y)

GameApi::SpaceApi::translatespace
SP translatespace(SP s, float x, float y)

GameApi::SpaceApi::moveorigo
SP moveorigo(SP s, float x, float y)

GameApi::SpaceApi::rotatespace
SP rotatespace(SP s, float angle)

GameApi::SpaceApi::rotatespace
SP rotatespace(SP s, PT center, float angle)

GameApi::SpaceApi::~SpaceApi
~SpaceApi()
Definition GameApi.cc:545

GameApi::SpaceApi::pt_y
float pt_y(PT p)
Definition GameApi_spa.cc:31

GameApi::SpaceApi::pos
PT pos(SP sp, float x, float y, float z=0.0)
Definition GameApi_spa.cc:4

GameApi::SpaceApi::pt_z
float pt_z(PT p)
Definition GameApi_spa.cc:37

GameApi::SpaceApi::posN
PT posN(SP sp, float x, float y, float z=0.0)
Definition GameApi_spa.cc:16

GameApi::SpaceVectorApi::flow_next_point
PT flow_next_point(SV v, PT p, float mult)
Definition GameApi.cc:630

GameApi::SpaceVectorApi::from_points
SV from_points(PC coll)
Definition GameApi.cc:619

GameApi::SpaceVectorApi::function
SV function(std::function< V(float x, float y, float z)> f)

GameApi::SpaceVectorApi::SpaceVectorApi
IMPORT SpaceVectorApi(Env &e)
Definition GameApi.cc:44520

GameApi::SpriteApi
Definition GameApi.hh:951

GameApi::SpriteApi::SpriteApi
IMPORT SpriteApi(Env &e)
Definition GameApi_sp.cc:177

GameApi::SpriteApi::rendersprite3_1
void rendersprite3_1(BM bm, int bm_choose, SH sh, float x, float y, float mult_x, float mult_y)
Definition GameApi_sp.cc:807

GameApi::SpriteApi::pixelpos
IMPORT PT pixelpos(BM bm, int x, int y)
Definition GameApi_sp.cc:871

GameApi::SpriteApi::render_sprite_vertex_array_ml
IMPORT ML render_sprite_vertex_array_ml(EveryApi &ev, BM bm)
Definition GameApi_sp.cc:606

GameApi::SpriteApi::rendersprite4
IMPORT void rendersprite4(BM bm, int bm_choose, SH sh, PT pos)
Definition GameApi_sp.cc:824

GameApi::SpriteApi::delete_vertex_array
IMPORT void delete_vertex_array(VA va)

GameApi::SpriteApi::clipping_sprite
IMPORT void clipping_sprite(VA va, int sx, int sy, float tex_l, float tex_t, float tex_r, float teb_b)
Definition GameApi_sp.cc:657

GameApi::SpriteApi::bitmap_anim
IMPORT std::vector< BM > bitmap_anim(std::function< BM(float)> f, std::vector< float > key_frames)
Definition GameApi_bm.cc:3612

GameApi::SpriteApi::render_sprite_vertex_array
IMPORT void render_sprite_vertex_array(VA va)
Definition GameApi_sp.cc:613

GameApi::SpriteApi::preparesprite
IMPORT void preparesprite(BM bm, int bbm_choose=-1)
Definition GameApi_sp.cc:766

GameApi::SpriteApi::~SpriteApi
IMPORT ~SpriteApi()
Definition GameApi_sp.cc:535

GameApi::SpriteApi::rendersprite5
IMPORT void rendersprite5(BM bm, int bm_choose, SH sh, SP move_space, SP sprite_space, float x, float y)
Definition GameApi_sp.cc:838

GameApi::SpriteApi::spritepos
IMPORT void spritepos(BM bm, float x, float y)
Definition GameApi_sp.cc:539

GameApi::SpriteApi::clear_arrays
IMPORT void clear_arrays(VA va)
Definition GameApi_sp.cc:759

GameApi::SpriteApi::bitmap_anim_ml
IMPORT ML bitmap_anim_ml(EveryApi &ev, std::vector< BM > vec, std::vector< float > key_frames, float repeat_time)
Definition GameApi_bm.cc:3674

GameApi::SpriteApi::rendersprite2
IMPORT void rendersprite2(BM bm, SH sh, PT pos)
Definition GameApi_sp.cc:781

GameApi::SpriteApi::sprite_atlas_x
IMPORT ARR sprite_atlas_x(EveryApi &ev, BM orig, int start_x, int end_x, int start_y, int end_y, int delta_x, int count)
Definition GameApi_sp.cc:878

GameApi::SpriteApi::sprite_atlas_y
IMPORT ARR sprite_atlas_y(EveryApi &ev, BM orig, int start_x, int end_x, int start_y, int end_y, int delta_y, int count)
Definition GameApi_sp.cc:891

GameApi::SpriteApi::sprite_atlas_xy
IMPORT ARR sprite_atlas_xy(EveryApi &ev, BM orig, int start_x, int end_x, int start_y, int end_y, int delta_x, int delta_y, int count_x, int count_y)
Definition GameApi_sp.cc:905

GameApi::SpriteApi::rendersprite6
IMPORT void rendersprite6(BM bm, int bm_choose, SH sh, SP move_space, SP sprite_space, PT pos)
Definition GameApi_sp.cc:862

GameApi::SpriteApi::rendersprite
IMPORT void rendersprite(BM bm, SH sh, float x, float y, float mult_x=1.0, float mult_y=1.0)
Definition GameApi_sp.cc:777

GameApi::SpriteApi::vertex_array_render
IMPORT ML vertex_array_render(EveryApi &ev, BM bm)
Definition GameApi_sp.cc:733

GameApi::SpriteApi::update_vertex_array
IMPORT void update_vertex_array(VA va, BM bm)
Definition GameApi_sp.cc:711

GameApi::SpriteApi::turn_to_2d
IMPORT ML turn_to_2d(EveryApi &ev, ML ml, float tl_x, float tl_y, float br_x, float br_y)
Definition GameApi_sp.cc:414

GameApi::SpriteApi::create_vertex_array
IMPORT VA create_vertex_array(BM bm, bool progress=false, bool textrender=false)
Definition GameApi_sp.cc:739

GameApi::SpriteApi::rendersprite3
IMPORT void rendersprite3(BM bm, int bm_choose, SH sh, float x, float y, float mult_x, float mult_y)
Definition GameApi_sp.cc:803

GameApi::SpriteApi::spritespace
IMPORT SP spritespace(BM bm)
Definition GameApi_sp.cc:865

GameApi::SpriteApi::update_vertex_array_ml
IMPORT ML update_vertex_array_ml(VA va, BM bm)
Definition GameApi_sp.cc:707

GameApi::SpriteApi::alt_ml_array
IMPORT ML alt_ml_array(EveryApi &ev, std::vector< ML > vec, float start_time, float time_delta, bool repeat)
Definition GameApi_sp.cc:401

GameApi::SpriteObj::set_var
void set_var(std::string name, float r, float g, float b, float a)
Definition GameApi.hh:5007

GameApi::SpriteObj::render
void render()
Definition GameApi.hh:4990

GameApi::SpriteObj::prepare
void prepare(bool keep=false)
Definition GameApi.hh:4983

GameApi::SpriteObj::set_anim_frame
void set_anim_frame(int id)
Definition GameApi.hh:5002

GameApi::SpriteObj::set_matrix
void set_matrix(M m1)
Definition GameApi.hh:5001

GameApi::SpriteObj::SpriteObj
SpriteObj(EveryApi &ev, BM bm_, SH sh)
Definition GameApi.hh:4966

GameApi::SpriteObj::set_pos
void set_pos(float p_x, float p_y)
Definition GameApi.hh:4999

GameApi::SpriteObj::set_scale
void set_scale(float m_x, float m_y)
Definition GameApi.hh:5000

GameApi::SpriteObj::SpriteObj
SpriteObj(EveryApi &ev, std::vector< BM > anim, SH sh)
Definition GameApi.hh:4975

GameApi::SpriteWorldObj::get_pos_x
int get_pos_x(float mouse_x) const
Definition GameApi.hh:5088

GameApi::SpriteWorldObj::render
void render()
Definition GameApi.hh:5070

GameApi::SpriteWorldObj::set_scale
void set_scale(float m_x, float m_y)
Definition GameApi.hh:5087

GameApi::SpriteWorldObj::SpriteWorldObj
SpriteWorldObj(EveryApi &ev, std::function< BM(int)> f, int numvalues, BM int_bm, int dx, int dy, SH sh)
Definition GameApi.hh:5027

GameApi::SpriteWorldObj::set_pos
void set_pos(float p_x, float p_y)
Definition GameApi.hh:5086

GameApi::SpriteWorldObj::set_range
void set_range(int l, int t, int width, int height)
Definition GameApi.hh:5056

GameApi::SpriteWorldObj::prepare
void prepare(bool keep=false)
Definition GameApi.hh:5063

GameApi::SpriteWorldObj::get_pos_y
int get_pos_y(float mouse_y) const
Definition GameApi.hh:5095

GameApi::SpriteWorldObj::set_block
void set_block(int x, int y, int c)
Definition GameApi.hh:5043

GameApi::SpriteWorldObj::read_block
int read_block(int x, int y)
Definition GameApi.hh:5049

GameApi::SpriteWorldObj::set_var
void set_var(std::string name, float r, float g, float b, float a)
Definition GameApi.hh:5102

GameApi::SpriteWorldObj::~SpriteWorldObj
~SpriteWorldObj()
Definition GameApi.hh:5042

GameApi::StateChangeApi
Definition GameApi.hh:3590

GameApi::StateChangeApi::StateChangeApi
IMPORT StateChangeApi(Env &e, ShaderApi &api)
Definition GameApi_st.cc:82

GameApi::StateChangeApi::prepareloop
IMPORT VV prepareloop(float *array, int arraysize, std::function< P(float val)> f, float step_duration)
Definition GameApi_st.cc:23

GameApi::StateChangeApi::linear_1
TR linear_1(TR s, int path_num, std::function< P(float val)> f, float start_v, float end_v, float duration)
Definition GameApi_st.cc:42

GameApi::StateChangeApi::linear
IMPORT TR linear(TR s, int path_num, std::function< P(float val)> f, float start_v, float end_v, float duration)
Definition GameApi_st.cc:38

GameApi::StateChangeApi::init
IMPORT TR init(int paths)
Definition GameApi_st.cc:3

GameApi::StateChangeApi::prepare_1
VV prepare_1(TR sc)
Definition GameApi_st.cc:61

GameApi::StateChangeApi::prepare
IMPORT VV prepare(TR sc)
Definition GameApi_st.cc:57

GameApi::SurfaceApi
Definition GameApi.hh:2697

GameApi::SurfaceApi::SurfaceApi
IMPORT SurfaceApi(Env &e)
Definition GameApi_su.cc:3

GameApi::SurfaceApi::texture
S texture(S orig, BM texture)
Definition GameApi_su.cc:93

GameApi::SurfaceApi::interpolate
S interpolate(S s1, S s2, float val)

GameApi::SurfaceApi::torus
S torus(PT center, float dist1, float dist2, PT pos, PT u_x, PT u_y)

GameApi::SurfaceApi::sphere
S sphere(PT center, float radius)
Definition GameApi_su.cc:81

GameApi::SurfaceApi::~SurfaceApi
IMPORT ~SurfaceApi()
Definition GameApi_su.cc:7

GameApi::SurfaceApi::color
S color(S orig, unsigned int color)

GameApi::SurfaceApi::bitmapsphere
S bitmapsphere(PT center, float radius0, float radius1, BM height)
Definition GameApi_su.cc:11

GameApi::SurfaceApi::plane
S plane(PT pos, V u_x, V u_y)
Definition GameApi_su.cc:66

GameApi::SurfaceApi::betweensurface
S betweensurface(C curve1, C curve2)

GameApi::SurfaceApi::surface_points
PTS surface_points(S surf, int sx, int sy)

GameApi::TextApi
Definition GameApi.hh:1630

GameApi::TextApi::~TextApi
IMPORT ~TextApi()
Definition GameApi_tx.cc:4

GameApi::TextApi::TextApi
TextApi(BitmapApi &bm, SpriteApi &sp)
Definition GameApi.hh:1632

GameApi::TextApi::draw_text
IMPORT void draw_text(std::string text, int x, int y, SH sh)
Definition GameApi_tx.cc:29

GameApi::TextApi::load_font
IMPORT void load_font(std::string filename, int sx, int sy, int x, int y, char start_char, char end_char)
Definition GameApi_tx.cc:9

GameApi::TextureApi
Definition GameApi.hh:995

GameApi::TextureApi::prepare_key
IMPORT ML prepare_key(ML next, ML keyed, int key)
Definition GameApi_tex.cc:1246

GameApi::TextureApi::pbo_to_txid
IMPORT TXID pbo_to_txid(PBO p)
Definition GameApi_tex.cc:1755

GameApi::TextureApi::webcam_txid
IMPORT TXID webcam_txid(int num)

GameApi::TextureApi::grab_to_server
IMPORT ML grab_to_server(BM bm, int id, int num)
Definition GameApi_tex.cc:1483

GameApi::TextureApi::pbo_to_bitmap
IMPORT BM pbo_to_bitmap(PBO p)
Definition GameApi_tex.cc:1711

GameApi::TextureApi::prepare_cubemap
IMPORT TXID prepare_cubemap(EveryApi &ev, BM right, BM left, BM top, BM bottom, BM back, BM front)
Definition GameApi_tex.cc:113

GameApi::TextureApi::vr_overlay
IMPORT ML vr_overlay(TXID id, std::string key, std::string name, int sx, int sy)

GameApi::TextureApi::prepare_many_buf
IMPORT std::vector< BufferRef > prepare_many_buf(EveryApi &ev, std::vector< BM > vec, std::vector< int > types, bool mipmaps, std::vector< std::string > id_labels, std::vector< Low_GLuint > &res)
Definition GameApi_tex.cc:300

GameApi::TextureApi::prepare_many
IMPORT std::vector< TXID > prepare_many(EveryApi &ev, std::vector< BM > vec, std::vector< int > types=std::vector< int >(), bool mipmaps=true, std::vector< std::string > id_labels=std::vector< std::string >(), std::vector< bool > is_srgb=std::vector< bool >())
Definition GameApi_tex.cc:436

GameApi::TextureApi::unique_id
IMPORT int unique_id()
Definition GameApi_tex.cc:75

GameApi::TextureApi::unuse
IMPORT void unuse(TXID tx)
Definition GameApi_tex.cc:870

GameApi::TextureApi::prepare_many_txid
IMPORT std::vector< TXID > prepare_many_txid(EveryApi &ev, std::vector< BufferRef > vec, std::vector< Low_GLuint > ids, std::vector< int > types, bool mipmaps, std::vector< std::string > id_labels)
Definition GameApi_tex.cc:365

GameApi::TextureApi::webcam_txid_generic
IMPORT TXID webcam_txid_generic(EveryApi &ev, int sx, int sy, int num)
Definition GameApi_webcam.cc:1184

GameApi::TextureApi::videofile_txid_generic
IMPORT TXID videofile_txid_generic(EveryApi &ev, int sx, int sy, std::string url)
Definition GameApi_webcam.cc:1196

GameApi::TextureApi::webcam_txid_win
IMPORT TXID webcam_txid_win(EveryApi &ev, int sx, int sy, int num)
Definition GameApi_webcam.cc:380

GameApi::TextureApi::send_fb_to_gpu
IMPORT TXID send_fb_to_gpu(BufferRefF ref, Low_GLuint id)
Definition GameApi_tex.cc:257

GameApi::TextureApi::bind_many
IMPORT VA bind_many(VA va, std::vector< TXID > tx, std::vector< int > types=std::vector< int >())
Definition GameApi_tex.cc:41

GameApi::TextureApi::get_tex_coord_1
Q get_tex_coord_1(TX tx, int id)
Definition GameApi_tex.cc:99

GameApi::TextureApi::tex_assign
IMPORT TX tex_assign(TX tx, int id, int x, int y, BM bm)
Definition GameApi_tex.cc:80

GameApi::TextureApi::webcam_txid_linux
IMPORT TXID webcam_txid_linux(EveryApi &ev, int sx, int sy, int num)

GameApi::TextureApi::grab_screen
IMPORT ARR grab_screen(EveryApi &ev, RUN r)
Definition GameApi_tex.cc:1037

GameApi::TextureApi::tex_plane
IMPORT TX tex_plane(int sx, int sy)
Definition GameApi_tex.cc:11

GameApi::TextureApi::get_tex_coord
IMPORT Q get_tex_coord(TX tx, int id)
Definition GameApi_tex.cc:91

GameApi::TextureApi::prepare_fb
IMPORT BufferRefF prepare_fb(FB bitmap, Low_GLuint &id)
Definition GameApi_tex.cc:228

GameApi::TextureApi::use_many
IMPORT void use_many(std::vector< TXID > vec, int i=0)
Definition GameApi_tex.cc:851

GameApi::TextureApi::bufferref_to_txid
IMPORT TXID bufferref_to_txid(TXID old, const BufferRef &buf)
Definition GameApi_tex.cc:1154

GameApi::TextureApi::tex_coord
IMPORT TX tex_coord(TX tx, int id, int x, int y, int width, int height)
Definition GameApi_tex.cc:87

GameApi::TextureApi::prepare
IMPORT TXID prepare(TX tx, bool is_srgb=true, bool text_render=false)
Definition GameApi_tex.cc:760

GameApi::TextureApi::prepare_key_anim
IMPORT ML prepare_key_anim(ML next, std::vector< ML > keyed, int key, float time_delta, std::vector< std::string > filenames)
Definition GameApi_tex.cc:1311

GameApi::TextureApi::save_screenshot_via_key
IMPORT ML save_screenshot_via_key(EveryApi &ev, ML ml3, int key, std::string filename)
Definition GameApi_tex.cc:1403

GameApi::TextureApi::forward_to_txid
IMPORT ML forward_to_txid(VA va, ML mainloop, TXID id)
Definition GameApi.cc:7642

GameApi::TextureApi::upload_txid_to_pbo
IMPORT ML upload_txid_to_pbo(TXID tx, PBO p)
Definition GameApi_tex.cc:1653

GameApi::TextureApi::grab_to_bm_array
IMPORT ARR grab_to_bm_array(BM bm)
Definition GameApi_tex.cc:1463

GameApi::TextureApi::upload_bm_to_pbo
IMPORT ML upload_bm_to_pbo(BM bm, PBO p)
Definition GameApi_tex.cc:1643

GameApi::TextureApi::save_screenshots_via_key
IMPORT ML save_screenshots_via_key(EveryApi &ev, ML ml3, int key, float time_delta, int num)
Definition GameApi_tex.cc:1541

GameApi::TextureApi::webcam_txid_slow
IMPORT TXID webcam_txid_slow(EveryApi &ev, int num)

GameApi::TextureApi::create_pbo
IMPORT PBO create_pbo(int sx, int sy)
Definition GameApi_tex.cc:1588

GameApi::TextureApi::send_screenshots_via_key_array
IMPORT ARR send_screenshots_via_key_array(EveryApi &ev, ML ml3, int key, float time_delta, int num)
Definition GameApi_tex.cc:1511

GameApi::TextureApi::send_screenshots_via_key_to_server
IMPORT ML send_screenshots_via_key_to_server(EveryApi &ev, ML ml3, int key, float time_delta, int num)
Definition GameApi_tex.cc:1492

GameApi::TextureApi::videofile_txid_emscripten
IMPORT TXID videofile_txid_emscripten(EveryApi &ev, int sx, int sy, std::string url, int num)

GameApi::TextureApi::webcam_txid_emscripten
IMPORT TXID webcam_txid_emscripten(EveryApi &ev, int sx, int sy, int num)

GameApi::TextureApi::grab_screen_bitmap
IMPORT BM grab_screen_bitmap(EveryApi &ev)
Definition GameApi_tex.cc:1390

GameApi::TextureApi::TextureApi
IMPORT TextureApi(Env &e)
Definition GameApi_tex.cc:9

GameApi::TextureApi::videofile_txid_win32
IMPORT TXID videofile_txid_win32(EveryApi &ev, int sx, int sy, std::string url)

GameApi::TextureApi::tex_bitmap
IMPORT TX tex_bitmap(BM bm)
Definition GameApi_tex.cc:15

GameApi::TextureApi::combine_screens
IMPORT RUN combine_screens(RUN r1, RUN r2)
Definition GameApi_tex.cc:1026

GameApi::TextureApi::bind
IMPORT VA bind(VA va, TXID tx)
Definition GameApi_tex.cc:21

GameApi::TextureApi::bind_arr
IMPORT VA bind_arr(VA va, TXA tx)
Definition GameApi_tex.cc:65

GameApi::TextureApi::use
IMPORT void use(TXID tx, int i=0)
Definition GameApi_tex.cc:841

GameApi::TextureApi::bind_cubemap
IMPORT VA bind_cubemap(VA va, TXID id)
Definition GameApi_tex.cc:31

GameApi::TextureApi::to_bitmap
IMPORT BM to_bitmap(EveryApi &ev, TXID id)
Definition GameApi_tex.cc:1062

GameApi::TextureApi::delete_texid
IMPORT void delete_texid(TXID tx)
Definition GameApi_tex.cc:877

GameApi::TextureApi::prepare_arr
IMPORT TXA prepare_arr(EveryApi &ev, std::vector< BM > vec, int sx, int sy)
Definition GameApi_tex.cc:713

GameApi::TrackerApi
Definition GameApi.hh:3566

GameApi::TrackerApi::setup_ogg
IMPORT void * setup_ogg(const std::vector< unsigned char > &data, int type)
Definition GameApi_trk.cc:271

GameApi::TrackerApi::play_wave_via_keypress
IMPORT ML play_wave_via_keypress(EveryApi &ev, ML ml, std::string url, int key)
Definition GameApi_trk.cc:500

GameApi::TrackerApi::play_song
IMPORT void play_song(EveryApi &ev, TBUF buf, WAV samples, int framenum, int speed)
Definition GameApi_trk.cc:197

GameApi::TrackerApi::TrackerApi
IMPORT TrackerApi(Env &e)
Definition GameApi.cc:44513

GameApi::TrackerApi::stop_music_playing
IMPORT void stop_music_playing()
Definition GameApi_trk.cc:345

GameApi::TrackerApi::play_ogg
IMPORT void play_ogg(std::string filename)
Definition GameApi_trk.cc:237

GameApi::TrackerApi::array
IMPORT TRK array(TRK *array, int size)
Definition GameApi_trk.cc:155

GameApi::TrackerApi::audio_slot
IMPORT TRK audio_slot(TRK orig, int channel, int slot, int duration, int sample)
Definition GameApi_trk.cc:77

GameApi::TrackerApi::play_mp3
IMPORT void play_mp3(std::string filename)
Definition GameApi_trk.cc:218

GameApi::TrackerApi::prepare
IMPORT TBUF prepare(TRK trk)
Definition GameApi_trk.cc:170

GameApi::TreeApi
Definition GameApi.hh:1854

GameApi::TreeApi::tree_ml
IMPORT ML tree_ml(EveryApi &ev, T tree, std::vector< ML > vec)
Definition GameApi.cc:4383

GameApi::TreeApi::tree_ms
IMPORT MS tree_ms(EveryApi &ev, T tree, float time)
Definition GameApi.cc:5381

GameApi::TreeApi::level
IMPORT TL level(std::vector< MN > vec)
Definition GameApi.cc:4244

GameApi::TreeApi::TreeApi
IMPORT TreeApi(Env &e)
Definition GameApi.cc:44490

GameApi::TreeApi::tree
IMPORT T tree(std::vector< TL > vec)
Definition GameApi.cc:4269

GameApi::TreeApi::tree_p
IMPORT P tree_p(EveryApi &ev, T tree, std::vector< P > vec, float time, float percentage)
Definition GameApi.cc:5388

GameApi::TriStripApi
Definition GameApi.hh:2723

GameApi::TriStripApi::or_elem
IMPORT TS or_elem(TS t1, TS t2)

GameApi::TriStripApi::or_array
IMPORT TS or_array(TS *array, int size)

GameApi::TriStripApi::rectangle_xz
IMPORT TS rectangle_xz(float start_x, float end_x, float y, float start_z, float end_z)

GameApi::TriStripApi::rectangle_xy
IMPORT TS rectangle_xy(float start_x, float end_x, float start_y, float end_y, float z, int sx, int sy)

GameApi::TriStripApi::~TriStripApi
~TriStripApi()
Definition GameApi.hh:2726

GameApi::TriStripApi::save
IMPORT void save(TS tris, std::string filename)

GameApi::TriStripApi::transform
IMPORT TS transform(TS orig, std::function< PT(PT)> trans)

GameApi::TriStripApi::normal_function
IMPORT TS normal_function(TS ts, std::function< V(int i)> normal)

GameApi::TriStripApi::color_function
IMPORT TS color_function(TS ts, std::function< unsigned int(int i)> f)

GameApi::TriStripApi::to_poly
IMPORT P to_poly(TS strip)
Definition GameApi_tr.cc:417

GameApi::TriStripApi::function
IMPORT TS function(std::function< PT(int i)> f, int count)

GameApi::TriStripApi::from_poly
IMPORT TS from_poly(P poly)
Definition GameApi_tr.cc:168

GameApi::TriStripApi::TriStripApi
IMPORT TriStripApi(Env &e)
Definition GameApi.cc:44506

GameApi::TriStripApi::from_array
IMPORT TS from_array(PT *arr, int size)

GameApi::TriStripApi::load
IMPORT TS load(std::string filename)

GameApi::TriStripApi::span_3d_object
IMPORT TS span_3d_object(TS orig, float z_dist)

GameApi::TriStripApi::from_convex_plane
IMPORT TS from_convex_plane(PL pl, PT pos, V u_x, V u_y)

GameApi::TriStripApi::texcoord_function
IMPORT TS texcoord_function(TS ts, std::function< PT(int i)> texcoord)

GameApi::TriStripApi::circle
IMPORT TS circle(float center_x, float center_y, float center_z, float radius, int count)

GameApi::UberShaderApi
Definition GameApi.hh:4380

GameApi::UberShaderApi::v_passall
IMPORT US v_passall(US us)
Definition GameApi.cc:15524

GameApi::UberShaderApi::f_choose_color
IMPORT US f_choose_color(US us)
Definition GameApi.cc:16053

GameApi::UberShaderApi::f_coloured_lights
IMPORT US f_coloured_lights(US us)
Definition GameApi.cc:15957

GameApi::UberShaderApi::v_fade
IMPORT US v_fade(US us)
Definition GameApi.cc:15476

GameApi::UberShaderApi::f_texture_arr
IMPORT US f_texture_arr(US us)
Definition GameApi.cc:16038

GameApi::UberShaderApi::f_custom
IMPORT US f_custom(US us, std::string f_funcname)
Definition GameApi.cc:16003

GameApi::UberShaderApi::f_color_from_id
IMPORT US f_color_from_id(US us, int id)
Definition GameApi.cc:15937

GameApi::UberShaderApi::v_light
IMPORT US v_light(US us)
Definition GameApi.cc:15553

GameApi::UberShaderApi::f_manytexture
IMPORT US f_manytexture(US us)
Definition GameApi.cc:16027

GameApi::UberShaderApi::f_dyn_lights
IMPORT US f_dyn_lights(US us)
Definition GameApi.cc:15925

GameApi::UberShaderApi::v_inst
IMPORT US v_inst(US us)
Definition GameApi.cc:15408

GameApi::UberShaderApi::f_cubemaptexture
IMPORT US f_cubemaptexture(US us)
Definition GameApi.cc:16032

GameApi::UberShaderApi::v_colour_with_mix
IMPORT US v_colour_with_mix(US us)
Definition GameApi.cc:15481

GameApi::UberShaderApi::f_phong2
IMPORT US f_phong2(US us)
Definition GameApi.cc:15852

GameApi::UberShaderApi::v_gltf_anim
IMPORT US v_gltf_anim(US us)
Definition GameApi.cc:15387

GameApi::UberShaderApi::f_empty
IMPORT US f_empty(bool transparent)
Definition GameApi.cc:15796

GameApi::UberShaderApi::f_flip
IMPORT US f_flip(US us, US us2)

GameApi::UberShaderApi::f_newshadow_2
IMPORT US f_newshadow_2(US us, bool is_phong)
Definition GameApi.cc:15816

GameApi::UberShaderApi::f_gltf_anim
IMPORT US f_gltf_anim(US us)
Definition GameApi.cc:15772

GameApi::UberShaderApi::f_color_from_normals
IMPORT US f_color_from_normals(US us)
Definition GameApi.cc:15951

GameApi::UberShaderApi::v_texture
IMPORT US v_texture(US us)
Definition GameApi.cc:15577

GameApi::UberShaderApi::f_fog
IMPORT US f_fog(US us)
Definition GameApi.cc:15911

GameApi::UberShaderApi::v_gi
IMPORT US v_gi(US us)
Definition GameApi.cc:15466

GameApi::UberShaderApi::v_newshadow_2
IMPORT US v_newshadow_2(US us)
Definition GameApi.cc:15431

GameApi::UberShaderApi::f_glowedge
IMPORT US f_glowedge(US us)
Definition GameApi.cc:15806

GameApi::UberShaderApi::f_sandbox
IMPORT US f_sandbox(US us, SFO sfo)
Definition GameApi.cc:15783

GameApi::UberShaderApi::f_point_light
IMPORT US f_point_light(US us)
Definition GameApi.cc:15963

GameApi::UberShaderApi::v_skeletal
IMPORT US v_skeletal(US us)
Definition GameApi.cc:15789

GameApi::UberShaderApi::f_diffuse
IMPORT US f_diffuse(US us)
Definition GameApi.cc:15801

GameApi::UberShaderApi::v_dyn_lights
IMPORT US v_dyn_lights(US us)
Definition GameApi.cc:15506

GameApi::UberShaderApi::f_mix_color
IMPORT US f_mix_color(US us, US us2, float val)

GameApi::UberShaderApi::v_vertexphong
IMPORT US v_vertexphong(US us)
Definition GameApi.cc:15456

GameApi::UberShaderApi::f_shadow
IMPORT US f_shadow(US us)
Definition GameApi.cc:15920

GameApi::UberShaderApi::f_blur
IMPORT US f_blur(US us)
Definition GameApi.cc:15986

GameApi::UberShaderApi::v_point_light
IMPORT US v_point_light(US us)
Definition GameApi.cc:15535

GameApi::UberShaderApi::v_adjust
IMPORT US v_adjust(US us)
Definition GameApi.cc:15436

GameApi::UberShaderApi::f_mesh_color
IMPORT US f_mesh_color(US us, SFO sfo)
Definition GameApi.cc:15777

GameApi::UberShaderApi::f_specular
IMPORT US f_specular(US us)
Definition GameApi.cc:15945

GameApi::UberShaderApi::v_coloured_lights
IMPORT US v_coloured_lights(US us)
Definition GameApi.cc:15541

GameApi::UberShaderApi::f_ambient
IMPORT US f_ambient(US us)
Definition GameApi.cc:15932

GameApi::UberShaderApi::v_diffuse
IMPORT US v_diffuse(US us)
Definition GameApi.cc:15512

GameApi::UberShaderApi::f_toon
IMPORT US f_toon(US us)
Definition GameApi.cc:16015

GameApi::UberShaderApi::v_glowedge
IMPORT US v_glowedge(US us)
Definition GameApi.cc:15461

GameApi::UberShaderApi::v_blurred_render
IMPORT US v_blurred_render(US us)
Definition GameApi.cc:15441

GameApi::UberShaderApi::v_shadow
IMPORT US v_shadow(US us)
Definition GameApi.cc:15501

GameApi::UberShaderApi::f_mix
IMPORT US f_mix(US us)
Definition GameApi.cc:15916

GameApi::UberShaderApi::v_newshadow_1
IMPORT US v_newshadow_1(US us)
Definition GameApi.cc:15426

GameApi::UberShaderApi::f_fade
IMPORT US f_fade(US us)
Definition GameApi.cc:15869

GameApi::UberShaderApi::v_inst_matrix
IMPORT US v_inst_matrix(US us)
Definition GameApi.cc:15414

GameApi::UberShaderApi::v_pass_position
IMPORT US v_pass_position(US us)
Definition GameApi.cc:15529

GameApi::UberShaderApi::v_phong
IMPORT US v_phong(US us)
Definition GameApi.cc:15446

GameApi::UberShaderApi::f_newshadow_1
IMPORT US f_newshadow_1(US us)
Definition GameApi.cc:15811

GameApi::UberShaderApi::f_adjust
IMPORT US f_adjust(US us)
Definition GameApi.cc:15837

GameApi::UberShaderApi::v_edge
IMPORT US v_edge(US us)
Definition GameApi.cc:15381

GameApi::UberShaderApi::v_ref
IMPORT US v_ref(US us)
Definition GameApi.cc:15559

GameApi::UberShaderApi::f_acesfilm
IMPORT US f_acesfilm(US us)
Definition GameApi.cc:15757

GameApi::UberShaderApi::UberShaderApi
IMPORT UberShaderApi(Env &e)
Definition GameApi.cc:44522

GameApi::UberShaderApi::v_empty
IMPORT US v_empty()
Definition GameApi.cc:15371

GameApi::UberShaderApi::f_texture
IMPORT US f_texture(US us)
Definition GameApi.cc:16021

GameApi::UberShaderApi::v_wave
IMPORT US v_wave(US us)
Definition GameApi.cc:15565

GameApi::UberShaderApi::f_gi
IMPORT US f_gi(US us)
Definition GameApi.cc:15864

GameApi::UberShaderApi::f_generic_flip
IMPORT US f_generic_flip(US us, std::string name, std::string flags)
Definition GameApi.cc:15847

GameApi::UberShaderApi::f_blurred_render
IMPORT US f_blurred_render(US us)
Definition GameApi.cc:15831

GameApi::UberShaderApi::f_bands
IMPORT US f_bands(US us)
Definition GameApi.cc:15974

GameApi::UberShaderApi::v_water
IMPORT US v_water(US us)
Definition GameApi.cc:15375

GameApi::UberShaderApi::v_cubemaptexture
IMPORT US v_cubemaptexture(US us)
Definition GameApi.cc:15587

GameApi::UberShaderApi::v_fog
IMPORT US v_fog(US us)
Definition GameApi.cc:15491

GameApi::UberShaderApi::f_colour
IMPORT US f_colour(US us)
Definition GameApi.cc:16048

GameApi::UberShaderApi::f_edge
IMPORT US f_edge(US us)
Definition GameApi.cc:15767

GameApi::UberShaderApi::f_colour_with_mix
IMPORT US f_colour_with_mix(US us)
Definition GameApi.cc:15900

GameApi::UberShaderApi::f_discard
IMPORT US f_discard(US us)
Definition GameApi.cc:15762

GameApi::UberShaderApi::v_gltf
IMPORT US v_gltf(US us, std::string cache_id)
Definition GameApi.cc:15471

GameApi::UberShaderApi::v_snoise
IMPORT US v_snoise(US us)
Definition GameApi.cc:15547

GameApi::UberShaderApi::f_light
IMPORT US f_light(US us)
Definition GameApi.cc:16009

GameApi::UberShaderApi::v_globe
IMPORT US v_globe(US us)
Definition GameApi.cc:15392

GameApi::UberShaderApi::f_snoise
IMPORT US f_snoise(US us)
Definition GameApi.cc:15980

GameApi::UberShaderApi::v_mix
IMPORT US v_mix(US us)
Definition GameApi.cc:15496

GameApi::UberShaderApi::v_colour
IMPORT US v_colour(US us)
Definition GameApi.cc:15603

GameApi::UberShaderApi::v_bump_phong
IMPORT US v_bump_phong(US us)
Definition GameApi.cc:15486

GameApi::UberShaderApi::f_gltf
IMPORT US f_gltf(US us, bool tex0, bool tex1, bool tex2, bool tex3, bool tex4, bool tex5, bool tex6, bool tex7, bool spec, bool unlit, std::string cache_id, bool emissive)
Definition GameApi.cc:15878

GameApi::UberShaderApi::v_custom
IMPORT US v_custom(US us, std::string v_funcname)
Definition GameApi.cc:15997

GameApi::UberShaderApi::f_water
IMPORT US f_water(US us)
Definition GameApi.cc:15752

GameApi::UberShaderApi::v_generic
IMPORT US v_generic(US us, std::string name, std::string flags)
Definition GameApi.cc:15451

GameApi::UberShaderApi::f_generic
IMPORT US f_generic(US us, std::string name, std::string flags)
Definition GameApi.cc:15842

GameApi::UberShaderApi::v_blur
IMPORT US v_blur(US us)
Definition GameApi.cc:15609

GameApi::UberShaderApi::v_manytexture
IMPORT US v_manytexture(US us)
Definition GameApi.cc:15582

GameApi::UberShaderApi::f_bump_phong
IMPORT US f_bump_phong(US us)
Definition GameApi.cc:15906

GameApi::UberShaderApi::v_specular
IMPORT US v_specular(US us)
Definition GameApi.cc:15518

GameApi::UberShaderApi::v_texture_arr
IMPORT US v_texture_arr(US us)
Definition GameApi.cc:15593

GameApi::UberShaderApi::f_phong
IMPORT US f_phong(US us)
Definition GameApi.cc:15825

GameApi::UberShaderApi::v_dist_field_mesh
IMPORT US v_dist_field_mesh(US us, SFO sfo)
Definition GameApi.cc:15746

GameApi::UberShaderApi::v_recalc_normal
IMPORT US v_recalc_normal(US us)
Definition GameApi.cc:15402

GameApi::UberShaderApi::v_color_from_normals
IMPORT US v_color_from_normals(US us)
Definition GameApi.cc:15397

GameApi::UberShaderApi::v_toon
IMPORT US v_toon(US us)
Definition GameApi.cc:15571

GameApi::UberShaderApi::v_ambient
IMPORT US v_ambient(US us)
Definition GameApi.cc:15421

GameApi::UberShaderApi::f_vertexphong
IMPORT US f_vertexphong(US us)
Definition GameApi.cc:15857

GameApi::UberShaderApi::f_ref
IMPORT US f_ref(US us)
Definition GameApi.cc:15992

GameApi::VBOApi::polygon
void polygon(Vb v, int obj_num, P p, float x, float y, float z)
Definition GameApi_vbo.cc:63

GameApi::VBOApi::alloc
Vb alloc(int obj_count)
Definition GameApi_vbo.cc:27

GameApi::VBOApi::move
void move(Vb v, int obj_num, float x, float y, float z)
Definition GameApi_vbo.cc:103

GameApi::VBOApi::heightmap
void heightmap(Vb v, int obj_num, BM bitmap_float)

GameApi::VBOApi::VBOApi
IMPORT VBOApi(Env &e)
Definition GameApi_vbo.cc:18

GameApi::VBOApi::sprite
void sprite(Vb v, int obj_num, BM bm, float x, float y)
Definition GameApi_vbo.cc:43

GameApi::VBOApi::prepare
void prepare(Vb v)
Definition GameApi_vbo.cc:70

GameApi::VBOApi::~VBOApi
~VBOApi()
Definition GameApi_vbo.cc:22

GameApi::VBOApi::swapframe
void swapframe(Vb v, int obj_num, int type, int frame)
Definition GameApi_vbo.cc:84

GameApi::VBOApi::grid
void grid(Vb v, int obj_num, BM tile_bitmap, BM grid, float top_x, float top_y)
Definition GameApi_vbo.cc:66

GameApi::VectorApi
Definition GameApi.hh:4245

GameApi::VectorApi::sum
IMPORT V sum(V v1, V v2)
Definition GameApi_ve.cc:15

GameApi::VectorApi::dot
IMPORT float dot(V v1, V v2)
Definition GameApi_ve.cc:28

GameApi::VectorApi::dist2d
IMPORT float dist2d(V v)

GameApi::VectorApi::cross
IMPORT V cross(V v1, V v2)
Definition GameApi_ve.cc:34

GameApi::VectorApi::vector
IMPORT V vector(float delta_x, float delta_y, float delta_z)
Definition GameApi_ve.cc:11

GameApi::VectorApi::dist3d
IMPORT float dist3d(V v)

GameApi::VectorApi::VectorApi
IMPORT VectorApi(Env &e)
Definition GameApi_ve.cc:5

GameApi::VectorApi::neg
IMPORT V neg(V v)
Definition GameApi_ve.cc:67

GameApi::VectorApi::projection_length
IMPORT float projection_length(V u, V u_x)
Definition GameApi_ve.cc:42

GameApi::VectorApi::projection_2
IMPORT V projection_2(V u, V u_x)
Definition GameApi_ve.cc:58

GameApi::VectorApi::projection_1
IMPORT V projection_1(V u, V u_x)
Definition GameApi_ve.cc:49

GameApi::VectorApi::null_vector
IMPORT V null_vector()
Definition GameApi_ve.cc:7

GameApi::VectorApi::mul
IMPORT V mul(V v1, float scalar)
Definition GameApi_ve.cc:22

GameApi::VectorBitmapApi::plane
VBM plane(PT pos, V u_x, V u_y, V u_z)

GameApi::VectorBitmapApi::spheredelta
VBM spheredelta(float radius1, float radius2, float x, float y, float z, float sx, float sy)

GameApi::VectorBitmapApi::VectorBitmapApi
IMPORT VectorBitmapApi(Env &e)
Definition GameApi.cc:44515

GameApi::VectorBitmapApi::span_object
P span_object(VBM vectors, FB floats)

GameApi::VectorVolumeApi
Definition GameApi.hh:2599

GameApi::VectorVolumeApi::VectorVolumeApi
IMPORT VectorVolumeApi(Env &e)
Definition GameApi.cc:44503

GameApi::VectorVolumeApi::normal
IMPORT VO normal(FD fd)
Definition GameApi_vo.cc:1181

GameApi::VectorVolumeApi::setup_normal
IMPORT P setup_normal(P orig, VO v)
Definition GameApi_vo.cc:1900

GameApi::VectorVolumeApi::normal2
IMPORT VO normal2(FO fo, float stepsize)
Definition GameApi_vo.cc:1186

GameApi::VectorVolumeApi::function
IMPORT VO function(std::function< V(float x, float y, float z)> f)

GameApi::VertexAnimApi
Definition GameApi.hh:2066

GameApi::VertexAnimApi::vertex_anim_render
IMPORT ML vertex_anim_render(EveryApi &ev, KF kf)
Definition GameApi.cc:20334

GameApi::VertexAnimApi::repeat_keyframes
IMPORT KF repeat_keyframes(KF rep, int count)
Definition GameApi.cc:20367

GameApi::VertexAnimApi::rotate_trans
IMPORT PTT rotate_trans(PTT prev, float nx, float ny, float nz, float speed_angle)
Definition GameApi.cc:20027

GameApi::VertexAnimApi::change_pos_li
IMPORT LI change_pos_li(LI p, LI orig, PTT transform, float delta_time, bool dif)
Definition GameApi.cc:19751

GameApi::VertexAnimApi::scale_trans2
IMPORT PTT scale_trans2(PTT prev, float duration, float scale_dist_x, float scale_dist_y, float scale_dist_z)
Definition GameApi.cc:20052

GameApi::VertexAnimApi::VertexAnimApi
IMPORT VertexAnimApi(Env &e)
Definition GameApi.cc:44496

GameApi::VertexAnimApi::curve_accessor
IMPORT PTT curve_accessor(C curve, CPP pos, float start_pos, float time_mult)
Definition GameApi.cc:19801

GameApi::VertexAnimApi::keyframe_bind2
IMPORT KF keyframe_bind2(EveryApi &ev, KF keyframe, PTT pointtransform, float delta_time, bool dif)
Definition GameApi.cc:19907

GameApi::VertexAnimApi::keyframe_bind
IMPORT KF keyframe_bind(EveryApi &ev, KF keyframe, PTT pointtransform, float delta_time)
Definition GameApi.cc:19902

GameApi::VertexAnimApi::curve_trans
IMPORT KF curve_trans(EveryApi &ev, KF kf, C curve, CPP pos, int numsamples, float duration)
Definition GameApi.cc:19822

GameApi::VertexAnimApi::translate_trans
IMPORT PTT translate_trans(PTT prev, float speed_x, float speed_y, float speed_z)
Definition GameApi.cc:20015

GameApi::VertexAnimApi::translate_trans2
IMPORT PTT translate_trans2(PTT prev, float duration, float dist_x, float dist_y, float dist_z)
Definition GameApi.cc:20020

GameApi::VertexAnimApi::keyframe_mesh
IMPORT KF keyframe_mesh(P part)
Definition GameApi.cc:19660

GameApi::VertexAnimApi::rot_accessor
IMPORT PTT rot_accessor(float start_time, float time_mult, float nx, float ny, float nz, float dist_angle)
Definition GameApi.cc:19814

GameApi::VertexAnimApi::scale_trans
IMPORT PTT scale_trans(PTT prev, float scale_speed_x, float scale_speed_y, float scale_speed_z)
Definition GameApi.cc:20045

GameApi::VertexAnimApi::rotate_trans2
IMPORT PTT rotate_trans2(PTT prev, float duration, float nx, float ny, float nz, float dist_angle)
Definition GameApi.cc:20036

GameApi::VertexAnimApi::change_pos
IMPORT P change_pos(P p, P orig, PTT transform, float delta_time, bool dif)
Definition GameApi.cc:19759

GameApi::VertexAnimApi::keyframe_lines
IMPORT KF keyframe_lines(LI part)
Definition GameApi.cc:19664

GameApi::VertexAnimApi::empty_trans
IMPORT PTT empty_trans()
Definition GameApi.cc:19953

GameApi::VertexAnimApi::sample_rot
IMPORT KF sample_rot(EveryApi &ev, KF kf, float nx, float ny, float nz, float angle, int numsamples, float duration)
Definition GameApi.cc:19836

GameApi::VolumeApi
Definition GameApi.hh:1670

GameApi::VolumeApi::bounding_z
IMPORT O bounding_z(O next, O next2, float z)
Definition GameApi_vo.cc:20

GameApi::VolumeApi::render
IMPORT BM render(O object, int sx, int sy, PT ray_0, PT ray_x, PT ray_y, PT ray_z)

GameApi::VolumeApi::subvolume
IMPORT O subvolume(std::function< float(float x, float y, float z)> f, float start_range, float end_range)
Definition GameApi_vo.cc:293

GameApi::VolumeApi::o_torus
IMPORT O o_torus(PT center, PT u_x, PT u_y, float dist1, float dist2)
Definition GameApi_vo.cc:112

GameApi::VolumeApi::from_bool_bitmap
IMPORT O from_bool_bitmap(BB b, float dist)
Definition GameApi_vo.cc:32

GameApi::VolumeApi::andnot_op
IMPORT O andnot_op(O object1, O object2)
Definition GameApi_vo.cc:177

GameApi::VolumeApi::bounding_x
IMPORT O bounding_x(O next, O next2, float x)
Definition GameApi_vo.cc:8

GameApi::VolumeApi::bounding_sphere
IMPORT O bounding_sphere(O next, float cx, float cy, float cz, float radius)
Definition GameApi_vo.cc:27

GameApi::VolumeApi::subset_color
IMPORT O subset_color(O model, O color_subset, unsigned int color)
Definition GameApi_vo.cc:58

GameApi::VolumeApi::rotatey
IMPORT O rotatey(O object, float angle)
Definition GameApi_vo.cc:69

GameApi::VolumeApi::spheretexture
IMPORT O spheretexture(O object, PT center, BM texture, float multx, float multy)

GameApi::VolumeApi::cubetexture
IMPORT O cubetexture(O object, PT origo, PT u_x, PT u_y, PT u_z, BM bm)

GameApi::VolumeApi::rotatex
IMPORT O rotatex(O object, float angle)
Definition GameApi_vo.cc:64

GameApi::VolumeApi::link_areas
IMPORT O link_areas(O o, PT p1, PT p2, float d)

GameApi::VolumeApi::rendercubes
IMPORT P rendercubes(O object, fptrtype fptr, int size, float wholesize)
Definition GameApi_vo.cc:651

GameApi::VolumeApi::min_op
IMPORT O min_op(O object1, O object2)
Definition GameApi_vo.cc:135

GameApi::VolumeApi::rotatez
IMPORT O rotatez(O object, float angle)
Definition GameApi_vo.cc:74

GameApi::VolumeApi::reflect
IMPORT O reflect(O object, float val)

GameApi::VolumeApi::rendercubes2
IMPORT P rendercubes2(EveryApi &ev, O object, fptrtype fptr, int sx, int sy, int sz, float world_x, float world_y, float world_z)
Definition GameApi_vo.cc:593

GameApi::VolumeApi::from_polygon
IMPORT O from_polygon(P p, float x, float y, float z)
Definition GameApi_vo.cc:310

GameApi::VolumeApi::instancing_volume
IMPORT O instancing_volume(O o, PTS p)
Definition GameApi_vo.cc:2076

GameApi::VolumeApi::rendercubes3
IMPORT P rendercubes3(O object, int sx, int sy, int sz, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)
Definition GameApi_vo.cc:588

GameApi::VolumeApi::fptrtype
std::function< P(float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, unsigned int color)> fptrtype
Definition GameApi.hh:1719

GameApi::VolumeApi::random_vol_object
IMPORT PTS random_vol_object(O o, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, int numpoints)
Definition GameApi_vo.cc:2130

GameApi::VolumeApi::volumeprojection
IMPORT BB volumeprojection(O o, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, int sx, int sy, int numsamples)
Definition GameApi.cc:41790

GameApi::VolumeApi::bounding_y
IMPORT O bounding_y(O next, O next2, float y)
Definition GameApi_vo.cc:14

GameApi::VolumeApi::~VolumeApi
IMPORT ~VolumeApi()
Definition GameApi_vo.cc:86

GameApi::VolumeApi::max_op
IMPORT O max_op(O object1, O object2)
Definition GameApi_vo.cc:143

GameApi::VolumeApi::colour
IMPORT O colour(O object, unsigned int col)
Definition GameApi_vo.cc:119

GameApi::VolumeApi::not_op
IMPORT O not_op(O object1)
Definition GameApi_vo.cc:125

GameApi::VolumeApi::move
IMPORT O move(O obj, float dx, float dy, float dz)
Definition GameApi_vo.cc:79

GameApi::VolumeApi::scale
IMPORT O scale(O object, float sx, float sy, float sz)
Definition GameApi_vo.cc:186

GameApi::VolumeApi::o_cube
IMPORT O o_cube(float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)
Definition GameApi_vo.cc:100

GameApi::VolumeApi::mandelbulb
IMPORT O mandelbulb(float n, float p_x, float p_y, float p_z, float c_x, float c_y, float c_z, float radius, int iterations)
Definition GameApi_vo.cc:192

GameApi::VolumeApi::VolumeApi
IMPORT VolumeApi(Env &e)
Definition GameApi_vo.cc:85

GameApi::VolumeApi::o_cone
IMPORT O o_cone(PT p1, PT p2, float rad1, float rad2)
Definition GameApi_vo.cc:94

GameApi::VolumeApi::plane
IMPORT BB plane(O o, int sx, int sy, PT u_p, V u_x, V u_y, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)
Definition GameApi_vo.cc:151

GameApi::VolumeApi::boolfunction
IMPORT O boolfunction(std::function< bool(float x, float y, float z)> f)
Definition GameApi_vo.cc:235

GameApi::VolumeApi::find_surface
IMPORT void find_surface(O object, PT p1, PT p2, PT *res1, PT *res2, int level)
Definition GameApi_vo.cc:321

GameApi::VolumeApi::o_sphere
IMPORT O o_sphere(float center_x, float center_y, float center_z, float radius)
Definition GameApi_vo.cc:88

GameApi::VolumeApi::mandelbrot_volume
IMPORT O mandelbrot_volume(bool julia, int count, float yy)
Definition GameApi_vo.cc:54

GameApi::VolumeApi::instanced_positions
IMPORT PTS instanced_positions(O object, int size, float wholesize)
Definition GameApi_vo.cc:679

GameApi::VoxelApi
Definition GameApi.hh:3879

GameApi::VoxelApi::vox_cubes
IMPORT ARR vox_cubes(EveryApi &ev, std::string url, int model, float sx, float sy, float sz)
Definition GameApi.cc:25051

GameApi::VoxelApi::vox_voxel2
IMPORT VX vox_voxel2(EveryApi &ev, std::string url, int model, float sx, float sy, float sz)
Definition GameApi.cc:25047

GameApi::VoxelApi::vox_bind_ml2
IMPORT ML vox_bind_ml2(EveryApi &ev, std::string url, int model, float sx, float sy, float sz, GameApi::MT mt, float border_width, unsigned int border_color, int level=0)
Definition GameApi.cc:25187

GameApi::VoxelApi::render_ovx_p
IMPORT P render_ovx_p(EveryApi &ev, OVX vx, float sx, float sy, float sz)
Definition GameApi.cc:24406

GameApi::VoxelApi::remove_not_enabled
IMPORT OVX remove_not_enabled(OVX vx)
Definition GameApi.cc:23703

GameApi::VoxelApi::vx_to_ovx
IMPORT OVX vx_to_ovx(VX vx, std::vector< P > vec)
Definition GameApi.cc:24621

GameApi::VoxelApi::instanced_positions
IMPORT PTS instanced_positions(VX x, float sx, float sy, float sz, unsigned int value)
Definition GameApi_vx.cc:47

GameApi::VoxelApi::voxel_static
IMPORT P voxel_static(EveryApi &ev, std::vector< P > objs, std::vector< PTS > vec)
Definition GameApi.cc:22404

GameApi::VoxelApi::from_implicit
IMPORT VX from_implicit(IM i, int sx, int sy, int sz, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, int value)
Definition GameApi.cc:33296

GameApi::VoxelApi::remove_colours
IMPORT OVX remove_colours(OVX vx)
Definition GameApi.cc:23637

GameApi::VoxelApi::vox_ml
IMPORT ML vox_ml(EveryApi &ev, std::string url, int model, float sx, float sy, float sz, int level=0)
Definition GameApi.cc:25142

GameApi::VoxelApi::render_boxes
IMPORT P render_boxes(VX v, float sx, float sy, float sz)
Definition GameApi_vx.cc:174

GameApi::VoxelApi::empty_voxel
IMPORT VX empty_voxel(int sx, int sy, int sz)
Definition GameApi.cc:21891

GameApi::VoxelApi::VoxelApi
IMPORT VoxelApi(Env &e)
Definition GameApi_vx.cc:32

GameApi::VoxelApi::vox_bind_ml
IMPORT ML vox_bind_ml(EveryApi &ev, std::string url, int model, float sx, float sy, float sz, GameApi::MT mt, int level=0)
Definition GameApi.cc:25179

GameApi::VoxelApi::voxel_landscape_from_fbm
IMPORT VX voxel_landscape_from_fbm(FB bitmap, int height, int false_val, int true_val)
Definition GameApi.cc:22072

GameApi::VoxelApi::blit_voxel
IMPORT VX blit_voxel(O object, int sx, int sy, int sz, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, int false_value, int true_value)
Definition GameApi.cc:22083

GameApi::VoxelApi::voxel_from_bitmaps
IMPORT VX voxel_from_bitmaps(std::vector< BM > vec, std::string url)
Definition GameApi.cc:21963

GameApi::VoxelApi::render_ovx
IMPORT ML render_ovx(EveryApi &ev, OVX vx, MT mat, float sx, float sy, float sz, float border_width, unsigned int border_color)
Definition GameApi.cc:24397

GameApi::VoxelApi::subvoxel
IMPORT VX subvoxel(VX voxel, int start_x, int end_x, int start_y, int end_y, int start_z, int end_z)
Definition GameApi.cc:22061

GameApi::VoxelApi::blit_voxel2
IMPORT VX blit_voxel2(VX voxel, VX voxel2, int p_x, int p_y, int p_z)
Definition GameApi.cc:22077

GameApi::VoxelApi::vox_voxel
IMPORT P vox_voxel(EveryApi &ev, std::string url, int model, float sx, float sy, float sz, int level=0)
Definition GameApi.cc:24979

GameApi::VoxelApi::vox_voxel3
IMPORT P vox_voxel3(EveryApi &ev, std::string url, int model, float sx, float sy, float sz, int level=0)
Definition GameApi.cc:25022

GameApi::VoxelApi::sw_rays
IMPORT BM sw_rays(O volume, VX colours, int sx, int sy, float vx, float vy, float vz, float z)

GameApi::VoxelApi::resize_voxels
IMPORT OVX resize_voxels(OVX vx, VX vx2)
Definition GameApi.cc:23570

GameApi::VoxelApi::blur
IMPORT VX blur(VX vx)
Definition GameApi.cc:24475

GameApi::VoxelApi::get_pixel
IMPORT unsigned int get_pixel(VX v, int x, int y, int z)
Definition GameApi_vx.cc:42

GameApi::VoxelApi::convert_p_to_vx
IMPORT VX convert_p_to_vx(P p, int sx, int sy, int sz, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z, int value)
Definition GameApi_vx.cc:310

GameApi::VoxelApi::empty_ovx
IMPORT OVX empty_ovx()
Definition GameApi.cc:24436

GameApi::VoxelApi::vox_ml2
IMPORT ML vox_ml2(EveryApi &ev, std::string url, int model, float sx, float sy, float sz, float border_width, unsigned int border_color, int level=0)
Definition GameApi.cc:25151

GameApi::VoxelApi::lod_vox
IMPORT ML lod_vox(EveryApi &ev, std::string vox_url, int model, float sx, float sy, float sz, MT mat, PTS pts, int l1, int l2, int l3, int l4)
Definition GameApi.cc:44600

GameApi::VoxelApi::voxel_instancing
IMPORT ARR voxel_instancing(VX voxel, int count, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z)
Definition GameApi.cc:22357

GameApi::VoxelApi::voxel_bind
IMPORT ML voxel_bind(EveryApi &ev, std::vector< P > objs, std::vector< PTS > vec, MT material)
Definition GameApi.cc:22393

GameApi::VoxelApi::voxel_render
IMPORT ML voxel_render(EveryApi &ev, std::vector< P > objs, std::vector< PTS > vec)
Definition GameApi.cc:22380

GameApi::WModApi
Definition GameApi.hh:2475

GameApi::WModApi::codegen_reset_counter
IMPORT void codegen_reset_counter()
Definition GameApi_wmod.cc:1055

GameApi::WModApi::extract_deps
IMPORT std::string extract_deps(std::string filename)
Definition GameApi_wmod.cc:1113

GameApi::WModApi::WModApi
IMPORT WModApi(Env &e)
Definition GameApi.cc:44500

GameApi::WModApi::change_param_is_array
IMPORT void change_param_is_array(WM mod2, int id, std::string uid, int param_index, bool is_array, int ref_line_index)
Definition GameApi_wmod.cc:2001

GameApi::WModApi::parse_param_array
IMPORT std::vector< std::string > parse_param_array(std::string s)
Definition GameApi_wmod.cc:2042

GameApi::WModApi::execute
IMPORT int execute(EveryApi &ev, WM mod2, int id, std::string line_uid, ExecuteEnv &exeenv, int level, int j)
Definition GameApi_wmod.cc:1462

GameApi::WModApi::insert_inserted_to_canvas
IMPORT void insert_inserted_to_canvas(GuiApi &gui, W canvas, W item, std::string uid, W &display_clicks, W &edit_clicks, W &delete_key, W &codegen_button, W &popup_open)
Definition GameApi_wmod.cc:2265

GameApi::WModApi::indexes_from_funcname
IMPORT std::vector< int > indexes_from_funcname(GameApi::EveryApi &ev, std::string funcname)
Definition GameApi_wmod.cc:464

GameApi::WModApi::dump_functions_for_docs
IMPORT void dump_functions_for_docs(GameApi::EveryApi &ev, int i)
Definition GameApi_wmod.cc:2418

GameApi::WModApi::change_param_multiple_return_values
IMPORT void change_param_multiple_return_values(WM mod2, int id, std::string uid, int j, int sz)
Definition GameApi_wmod.cc:1985

GameApi::WModApi::refs_from_function
IMPORT std::vector< std::string * > refs_from_function(GameApi::EveryApi &ev, WM mod, int id, std::string funcname)
Definition GameApi_wmod.cc:717

GameApi::WModApi::insert_to_mod
IMPORT void insert_to_mod(WM mod, int id, std::string modname, std::string uid, bool array_return, int x, int y, std::vector< InsertParam > params)
Definition GameApi_wmod.cc:2146

GameApi::WModApi::get_funcname
IMPORT std::string get_funcname(WM mod2, int id, std::string uid)
Definition GameApi_wmod.cc:2124

GameApi::WModApi::generate_param_array
IMPORT std::string generate_param_array(std::vector< std::string > v)
Definition GameApi_wmod.cc:2065

GameApi::WModApi::dump_functions
IMPORT std::string dump_functions(GameApi::EveryApi &ev, int i)
Definition GameApi_wmod.cc:2466

GameApi::WModApi::change_param_value
IMPORT void change_param_value(WM mod2, int id, std::string uid, int param_index, std::string newvalue, int j)
Definition GameApi_wmod.cc:2023

GameApi::WModApi::labels_from_function
IMPORT std::vector< std::string > labels_from_function(GameApi::EveryApi &ev, WM mod, int id, std::string funcname)
Definition GameApi_wmod.cc:2215

GameApi::WModApi::dump_functions_count
IMPORT int dump_functions_count()
Definition GameApi_wmod.cc:2416

GameApi::WModApi::update_lines_from_canvas
IMPORT void update_lines_from_canvas(W canvas, WM mod, int id)
Definition GameApi_wmod.cc:434

GameApi::WModApi::extract_funcname
IMPORT std::string extract_funcname(std::string line)
Definition GameApi_wmod.cc:1096

GameApi::WModApi::return_type
IMPORT std::string return_type(GameApi::EveryApi &ev, WM mod2, int id, std::string line_uid)
Definition GameApi_wmod.cc:965

GameApi::WModApi::save
IMPORT void save(WM mod, std::string ilename)
Definition GameApi_wmod.cc:345

GameApi::WModApi::parse_multiple_return_uid
IMPORT std::pair< std::string, int > parse_multiple_return_uid(std::string s, bool &success)
Definition GameApi_wmod.cc:2080

GameApi::WModApi::collect_nodes
IMPORT CollectResult collect_nodes(EveryApi &ev, WM mod2, int id, std::string line_uid, int level)

GameApi::WModApi::exprs_from_function
IMPORT std::vector< std::string * > exprs_from_function(GameApi::EveryApi &ev, WM mod, int id, std::string funcname)
Definition GameApi_wmod.cc:654

GameApi::WModApi::types_from_function
IMPORT std::vector< std::string > types_from_function(GameApi::EveryApi &ev, WM mod, int id, std::string funcname)
Definition GameApi_wmod.cc:776

GameApi::WModApi::inserted_widget
IMPORT W inserted_widget(GameApi::EveryApi &ev, GuiApi &gui, WM mod2, int id, FtA atlas, BM atlas_bm, std::string func_name, std::vector< W * > connect_click, std::string uid, std::vector< W > &params)
Definition GameApi_wmod.cc:501

GameApi::WModApi::collect_urls
IMPORT std::pair< int, std::vector< std::string > > collect_urls(EveryApi &ev, WM mod2, int id, std::string line_uid, ExecuteEnv &exeenv, int level, ASyncData *arr, int arr_size, int j, bool use_async=false)
Definition GameApi_wmod.cc:1676

GameApi::WModApi::dep_from_function
IMPORT std::string dep_from_function(EveryApi &ev, WM mod2, int id)
Definition GameApi_wmod.cc:631

GameApi::WModApi::find_line_index
IMPORT int find_line_index(WM mod2, int id, std::string uid)
Definition GameApi_wmod.cc:1969

GameApi::WModApi::load
IMPORT WM load(EveryApi &ev, std::string filename)
Definition GameApi_wmod.cc:352

GameApi::WModApi::delete_by_uid
IMPORT void delete_by_uid(WM mod2, int id, std::string line_uid)
Definition GameApi_wmod.cc:998

GameApi::WModApi::typecheck
IMPORT bool typecheck(GameApi::EveryApi &ev, WM mod2, int id, std::string uid1, std::string uid2, int param_index, int ret_index, bool &is_array, bool &is_array_return)
Definition GameApi_wmod.cc:1905

GameApi::WModApi::param_value
IMPORT std::string param_value(WM mod2, int id, std::string uid, int param_index)
Definition GameApi_wmod.cc:2104

GameApi::WModApi::insert_links
IMPORT void insert_links(EveryApi &ev, GuiApi &gui, WM mod2, int id, std::vector< W > &links, W canvas, const std::vector< W > &connect_targets, SH sh2, SH sh)
Definition GameApi_wmod.cc:826

GameApi::WModApi::defaults_from_function
IMPORT std::vector< std::pair< std::string, std::string > > defaults_from_function(GameApi::EveryApi &ev, std::string module_name)
Definition GameApi_wmod.cc:2185

GameApi::WModApi::codegen
IMPORT std::pair< std::string, std::string > codegen(EveryApi &ev, WM mod2, int id, std::string line_uid, int level, int j, CodeGenPositions *pos=0)
Definition GameApi_wmod.cc:1210

GameApi::WModApi::insert_to_canvas
IMPORT void insert_to_canvas(GameApi::EveryApi &ev, GuiApi &gui, W canvas, WM mod, int id, FtA font, BM font_bm, std::vector< W > &connect_clicks, std::vector< W > &params, std::vector< W > &diaplay_clicks, std::vector< W > &edit_clicks, std::vector< W > &delete_key, std::vector< W > &codegen_button, std::vector< W > &popup_open, void(*fptr)(void *), void *data)
Definition GameApi_wmod.cc:2581

GameApi::WModApi::deps_from_mod
IMPORT std::string deps_from_mod(EveryApi &ev, WM mod2)
Definition GameApi_wmod.cc:640

GameApi::WaveformApi
Definition GameApi.hh:3513

GameApi::WaveformApi::int_sample
IMPORT WV int_sample(int *array, int length, float samplelength, int min_value, int max_value)
Definition GameApi_wv.cc:178

GameApi::WaveformApi::sample
IMPORT WV sample(float *array, int length, float samplelength)
Definition GameApi_wv.cc:174

GameApi::WaveformApi::mix
IMPORT WV mix(WV orig, float pos, WV sample)
Definition GameApi_wv.cc:184

GameApi::WaveformApi::move
IMPORT WV move(WV w1, float delta)
Definition GameApi_wv.cc:140

GameApi::WaveformApi::waveform_rotated_polygon
IMPORT P waveform_rotated_polygon(WV wave, float start_angle, float end_angle, float radius, int num_samples, int num_waves)
Definition GameApi_wv.cc:65

GameApi::WaveformApi::step
IMPORT WV step(bool b)
Definition GameApi_wv.cc:312

GameApi::WaveformApi::gaussian
IMPORT WV gaussian(float start_x, float end_x, float start_y, float end_y)
Definition GameApi_wv.cc:170

GameApi::WaveformApi::get_value
IMPORT float get_value(WV orig, float val)
Definition GameApi_wv.cc:201

GameApi::WaveformApi::waveform_bitmap
IMPORT BM waveform_bitmap(WV wave, int sx, int sy, unsigned int true_color, unsigned int false_color)
Definition GameApi.cc:537

GameApi::WaveformApi::sum
IMPORT WV sum(WV w1, WV w2)
Definition GameApi_wv.cc:92

GameApi::WaveformApi::WaveformApi
IMPORT WaveformApi(Env &e)
Definition GameApi.cc:44511

GameApi::WaveformApi::df_dx
IMPORT PN df_dx(PN poly)
Definition GameApi.cc:26324

GameApi::WaveformApi::wv_empty
IMPORT WV wv_empty(float length)
Definition GameApi_wv.cc:72

GameApi::WaveformApi::polynomial_wave
IMPORT WV polynomial_wave(PN pn, float start_x, float end_x, float start_y, float end_y)
Definition GameApi.cc:26318

GameApi::WaveformApi::length_change
IMPORT WV length_change(WV orig, float new_length)
Definition GameApi_wv.cc:231

GameApi::WaveformApi::length
IMPORT float length(WV orig)
Definition GameApi_wv.cc:206

GameApi::WaveformApi::std_polynomial
IMPORT PN std_polynomial(float x_5, float x_4, float x_3, float x_2, float x_1, float c)
Definition GameApi.cc:26283

GameApi::WaveformApi::freq_change
IMPORT WV freq_change(WV orig, float old_freq, float new_freq)
Definition GameApi_wv.cc:195

GameApi::WaveformApi::scale
IMPORT WV scale(WV w1, float scale)
Definition GameApi_wv.cc:115

GameApi::WaveformApi::sinwave
IMPORT WV sinwave(float length, float freq)
Definition GameApi_wv.cc:147

GameApi::WaveformApi::repeat
IMPORT WV repeat(WV wave, int num)
Definition GameApi_wv.cc:306

GameApi::WaveformApi::volume_ramp
IMPORT WV volume_ramp(WV orig, float old_y_value, float x_pos1, float x_pos2, float y_pos1, float y_pos2)
Definition GameApi_wv.cc:190

GameApi::WaveformApi::cubic
IMPORT WV cubic(float f_0, float f_1, float df_0, float df_1, float min_y, float max_y)
Definition GameApi_wv.cc:335

GameApi::WorldObj::set_child_var
void set_child_var(int x, int y, std::string name, float r, float g, float b, float a)
Definition GameApi.hh:5581

GameApi::WorldObj::set_rotation_matrix2
void set_rotation_matrix2(M m)
Definition GameApi.hh:5520

GameApi::WorldObj::pick_object1
void pick_object1(float x, float y, float &xx, float &yy, float &zz)
Definition GameApi.hh:5538

GameApi::WorldObj::set_anim_frame
void set_anim_frame(int id)
Definition GameApi.hh:5533

GameApi::WorldObj::set_rotation_y
void set_rotation_y(float angle)
Definition GameApi.hh:5510

GameApi::WorldObj::set_block
void set_block(int x, int y, int c)
Definition GameApi.hh:5363

GameApi::WorldObj::set_range
void set_range(int x, int y, int sx, int sy)
Definition GameApi.hh:5397

GameApi::WorldObj::set_anim_time
void set_anim_time(int x, int y, float time)
Definition GameApi.hh:5371

GameApi::WorldObj::render_outline
void render_outline(SH sh_new)
Definition GameApi.hh:5418

GameApi::WorldObj::bind_texarray
void bind_texarray(TXA id)
Definition GameApi.hh:5529

GameApi::WorldObj::prepare
void prepare(bool keep=false)
Definition GameApi.hh:5376

GameApi::WorldObj::WorldObj
WorldObj(EveryApi &ev, std::function< P(int)> f, int numvalues, BM bm, float dx, float dy, SH sh)
Definition GameApi.hh:5325

GameApi::WorldObj::pick_object2
bool pick_object2(float mouse_x, float mouse_y, float radius, int scr_x, int scr_y, M in_P, int x, int y)
Definition GameApi.hh:5558

GameApi::WorldObj::set_scale
void set_scale(float mult_x, float mult_y, float mult_z)
Definition GameApi.hh:5505

GameApi::WorldObj::set_pos
void set_pos(float pos_x, float pos_y, float pos_z)
Definition GameApi.hh:5500

GameApi::WorldObj::clear_child_var
void clear_child_var(int x, int y)
Definition GameApi.hh:5577

GameApi::WorldObj::set_outline
void set_outline(int x, int y, bool b, SH sh3)
Definition GameApi.hh:5591

GameApi::WorldObj::read_block
int read_block(int x, int y) const
Definition GameApi.hh:5367

GameApi::WorldObj::bind_texture
void bind_texture(int num_id, TXID id_)
Definition GameApi.hh:5525

GameApi::WorldObj::set_var
void set_var(std::string name, float r, float g, float b, float a)
Definition GameApi.hh:5568

GameApi::WorldObj::render
void render()
Definition GameApi.hh:5437

GameApi::WorldObj::set_rotation_matrix
void set_rotation_matrix(M m)
Definition GameApi.hh:5515

GameApi::WorldObj::collect
P collect()
Definition GameApi.hh:5404

GameApi::WorldObj::~WorldObj
~WorldObj()
Definition GameApi.hh:5362

LoadStream
Definition GraphI.hh:3114

NewShadowShaderML_1
Definition GameApi_pl.cc:10958

code
std::string code
Definition test.cpp:145

homepageurl
std::string homepageurl
Definition test.cpp:222

deps.hh

g_start
Tabs_Gui * g_start
Definition test.cpp:4105

find_array
IMPORT ArrayType * find_array(GameApi::Env &e, GameApi::ARR arr)
Definition GameApi_dep_add_find.cc:1924

frame
frame( $arr, $width, $height, $data, $i, $homepage, $noheaders, $seamless, $transparent)
Definition emscripten_frame.php:18

wd
</style ><!-- TO CHANGE THE PARAMETERS, YOU SHOULD CHANGE:container width/height(to change what area of the page is reserved for the model) and wd/hd(to change how large the 3d model is) and delta_x and delta_y(to position the model) -->< script > let wd
Definition gameapi_example.php:60

radius
border radius
Definition gameapi_example.php:45

delta_y
let delta_y
Definition gameapi_example.php:63

delta_x
let delta_x
Definition gameapi_example.php:62

color
background color
Definition gameapi_example.php:46

sky
P sky(EveryApi &ev)
Definition test.cpp:214

function
void function(void)
Definition memory_leak_test.cpp:26

margin
left margin
Definition mesh_preview.php:76

d
d
Definition meshpage.php:3895

name
iVBORw0KGgoAAAANSUhEUgAAANcAAAB5CAMAAACdtUQZAAAA51BMVEX</div ></div >< div style="padding: 0px 0px; width: 1324px;">< div style="height: 400px; width: 1324px;"></div >< div itemscope itemtype="https: </div><div itemscope itemtype="https:</div >< div itemscope itemtype="https: </div></div><p><div style="padding:0px 0px;width:1324px;"><div></div><div itemscope itemtype="https:< ul >< li >< b > Application name
8AkrcAgqgAs9wqQ0ey2tkAo8gAuuQfeI4hPUH09fXHy8z4+fng4uNKXF/Lz9BzfoAcgpkQMTUAKjAbOT4Qr9AXhJ8Rl7ktMCwTosA...
Definition meshpage.php:1610

data
lazy data
Definition meshpage.php:1583

str
str
Definition meshpage.php:1778

format
instead of< li > Displaying models works via URL t expect full length movie as the output of this process< li > Different animation models are very limited basically just translate rotate</ul >< h2 > What to do if your hosting location has no php</h2 >< ul >< li > comment out or remove display php lines at the beginning< li > you will lose threads too< li > every zip file distributed by meshpage org has one of those display php files with this issue</ul >< h2 > What should I do to serve the files via http</h2 > I get some random triangles that do not belong to the model</h2 > The engine works correctly The obj file supports quads and polygons But some external tools that create obj files insert random polygons to the file to discourage rendering of polygons We consider polygon rendering is important and our engine should support it by default If you have we have disable_polygons() feature in the engine to get rid of the trash. But real solution is to change the tool you use to create the .obj file/check the .obj file that it doesn 't contain random(invisible) polygons that do not render in competing 3d engines. Our engine does not have the performance problems normally associated with polygons given that triangle quad polygon type change does not cause additional draw commands to the opengl rendering< p > GLTF standard organisation made significant mistake when specifying GLTF file format
Definition meshpage.php:1092

height
line height
Definition meshpage.php:3536

size
n< br > font size
Definition meshpage.php:3536

options
< h2 > I want smooth transition from jpg png webp to the engine</h2 > There s few options
Definition meshpage.php:1181

url
url
Definition meshpage.php:1781

store
store
Definition meshpage_bootstrap.php:1758

GameApi
Definition FreeType.hh:46

GameApi::prepare
void prepare(RenderObject &o)
Definition GameApi.cc:874

GameApi::collect_counter
int collect_counter(int mode)

GameApi::unregister_cache_deleter
void unregister_cache_deleter(int id)

GameApi::append_url_map
void append_url_map(const char *url, const unsigned char *data, const unsigned char *data_end)
Definition GameApi_bm.cc:723

GameApi::execute_codegen
IMPORT std::pair< int, std::string > execute_codegen(Env &e2, EveryApi &ev, std::string text, ExecuteEnv &e)
Definition GameApi_gui.cc:8557

GameApi::register_cache_deleter
int register_cache_deleter(void(*fptr)(void *), void *data)

GameApi::arr_to_pts_arr
std::vector< PTS > arr_to_pts_arr(EveryApi &ev, ARR a)
Definition GameApi.cc:22283

PL
Definition Plane.cc:5

filenames
std::string filenames[]
Definition parser.cc:237

colour
P colour(EveryApi &ev, P p1, unsigned int col)
Definition test.cpp:106

f
double f(const std::string &, double, bool) noexcept
Definition profile_cpp_calls_2.cpp:4

grid
BM grid(EveryApi &ev, int sx, int sy, int cell_x, int cell_y)
Definition test.cpp:32

f2
int f2(char c)
Definition test.cpp:51

AA
Definition GameApiTest5.cc:17

ASyncData
Definition test.cpp:815

ArrayType
Definition test.cpp:82

ArrayType::vec
std::vector< int > vec
Definition test.cpp:84

BM
Definition GameApi.h:8

BufferRefF
Definition Buffer.hh:48

BufferRef
Definition Buffer.hh:32

GameApi::AC
Definition Common.hh:54

GameApi::ARR
Definition GameApi.hh:112

GameApi::ARR::clone
ARR * clone() const
Definition GameApi.hh:119

GameApi::ARR::ARR
ARR(const ARR &i)
Definition GameApi.hh:113

GameApi::ARR::operator=
ARR & operator=(const ARR &i)
Definition GameApi.hh:117

GameApi::ARR::ARR
ARR()
Definition GameApi.hh:115

GameApi::ARR::ARR
ARR(const volatile ARR &i)
Definition GameApi.hh:114

GameApi::ARR::operator=
volatile ARR & operator=(volatile ARR &i) volatile
Definition GameApi.hh:118

GameApi::ARR::ARR
ARR(int i)
Definition GameApi.hh:116

GameApi::ARR::id
int id
Definition GameApi.hh:112

GameApi::AS
Definition Common.hh:58

GameApi::A
Definition GameApi.hh:269

GameApi::A::id
int id
Definition GameApi.hh:269

GameApi::ArrayObj3d::ChildVar
Definition GameApi.hh:4869

GameApi::ArrayObj3d::ChildVar::b
float b
Definition GameApi.hh:4872

GameApi::ArrayObj3d::ChildVar::a
float a
Definition GameApi.hh:4872

GameApi::ArrayObj3d::ChildVar::g
float g
Definition GameApi.hh:4872

GameApi::ArrayObj3d::ChildVar::r
float r
Definition GameApi.hh:4872

GameApi::ArrayObj3d::ChildVar::i
int i
Definition GameApi.hh:4870

GameApi::ArrayObj3d::ChildVar::name
std::string name
Definition GameApi.hh:4871

GameApi::BB
Definition Common.hh:74

GameApi::BF
Definition Common.hh:123

GameApi::BLK
Definition Common.hh:51

GameApi::BMA
Definition Common.hh:72

GameApi::BM
Definition Common.hh:71

GameApi::BM::id
int id
Definition Common.hh:71

GameApi::BO
Definition GameApi.hh:2767

GameApi::BO::id
int id
Definition GameApi.hh:2767

GameApi::CBB
Definition Common.hh:31

GameApi::CBM
Definition Common.hh:76

GameApi::CC
Definition Common.hh:163

GameApi::CFB
Definition Common.hh:32

GameApi::CG
Definition Common.hh:24

GameApi::CMD
Definition Common.hh:38

GameApi::COV
Definition Common.hh:139

GameApi::CO
Definition Common.hh:94

GameApi::CPP
Definition Common.hh:48

GameApi::CP
Definition Common.hh:66

GameApi::CT
Definition Common.hh:162

GameApi::C
Definition Common.hh:93

GameApi::CollectResult
Definition GameApi.hh:2464

GameApi::CollectResult::p
std::string p
Definition GameApi.hh:2466

GameApi::CollectResult::pn
std::string pn
Definition GameApi.hh:2467

GameApi::CollectResult::res
std::vector< EditNode * > res
Definition GameApi.hh:2465

GameApi::DC
Definition Common.hh:30

GameApi::DO
Definition Common.hh:135

GameApi::DR
Definition Common.hh:67

GameApi::DS
Definition Common.hh:27

GameApi::D
Definition Common.hh:121

GameApi::EV
Definition Common.hh:53

GameApi::EX
Definition Common.hh:159

GameApi::E
Definition Common.hh:107

GameApi::EveryApi
Definition GameApi.hh:4664

GameApi::EveryApi::sample_api
SampleCollectionApi sample_api
Definition GameApi.hh:4700

GameApi::EveryApi::plane_api
PlaneApi plane_api
Definition GameApi.hh:4696

GameApi::EveryApi::collision_api
CollisionPlane collision_api
Definition GameApi.hh:4708

GameApi::EveryApi::polygon_arr_api
PolygonArrayApi polygon_arr_api
Definition GameApi.hh:4718

GameApi::EveryApi::event_api
EventApi event_api
Definition GameApi.hh:4681

GameApi::EveryApi::surface_api
SurfaceApi surface_api
Definition GameApi.hh:4723

GameApi::EveryApi::skeletal_api
Skeletal skeletal_api
Definition GameApi.hh:4717

GameApi::EveryApi::bitmap_api
BitmapApi bitmap_api
Definition GameApi.hh:4674

GameApi::EveryApi::separate_api
SeparateApi separate_api
Definition GameApi.hh:4692

GameApi::EveryApi::fbo_api
FrameBufferApi fbo_api
Definition GameApi.hh:4699

GameApi::EveryApi::anim_api
AnimApi anim_api
Definition GameApi.hh:4680

GameApi::EveryApi::float_volume_api
FloatVolumeApi float_volume_api
Definition GameApi.hh:4685

GameApi::EveryApi::~EveryApi
IMPORT ~EveryApi()
Definition GameApi.cc:44536

GameApi::EveryApi::lines_api
LinesApi lines_api
Definition GameApi.hh:4695

GameApi::EveryApi::state_change_api
StateChangeApi state_change_api
Definition GameApi.hh:4690

GameApi::EveryApi::ts_api
TriStripApi ts_api
Definition GameApi.hh:4705

GameApi::EveryApi::matrix_api
MatrixApi matrix_api
Definition GameApi.hh:4671

GameApi::EveryApi::matrices_api
MatricesApi matrices_api
Definition GameApi.hh:4716

GameApi::EveryApi::waveform_api
WaveformApi waveform_api
Definition GameApi.hh:4693

GameApi::EveryApi::tree_api
TreeApi tree_api
Definition GameApi.hh:4712

GameApi::EveryApi::uber_api
UberShaderApi uber_api
Definition GameApi.hh:4714

GameApi::EveryApi::bool_api
BooleanOps bool_api
Definition GameApi.hh:4707

GameApi::EveryApi::mainloop_api
MainLoopApi mainloop_api
Definition GameApi.hh:4668

GameApi::EveryApi::get_env
IMPORT Env & get_env()
Definition GameApi.cc:44533

GameApi::EveryApi::shader_api
ShaderApi shader_api
Definition GameApi.hh:4689

GameApi::EveryApi::sprite_api
SpriteApi sprite_api
Definition GameApi.hh:4672

GameApi::EveryApi::curve_api
CurveApi curve_api
Definition GameApi.hh:4715

GameApi::EveryApi::grid_api
GridApi grid_api
Definition GameApi.hh:4673

GameApi::EveryApi::tracker_api
TrackerApi tracker_api
Definition GameApi.hh:4701

GameApi::EveryApi::physics_api
PhysicsApi physics_api
Definition GameApi.hh:4704

GameApi::EveryApi::mod_api
WModApi mod_api
Definition GameApi.hh:4703

GameApi::EveryApi::newplane_api
NewPlaneApi newplane_api
Definition GameApi.hh:4722

GameApi::EveryApi::points_api
PointsApi points_api
Definition GameApi.hh:4697

GameApi::EveryApi::move_api
MovementNode move_api
Definition GameApi.hh:4709

GameApi::EveryApi::sh_api
ShaderModuleApi sh_api
Definition GameApi.hh:4702

GameApi::EveryApi::vertex_anim_api
VertexAnimApi vertex_anim_api
Definition GameApi.hh:4721

GameApi::EveryApi::vector_volume_api
VectorVolumeApi vector_volume_api
Definition GameApi.hh:4688

GameApi::EveryApi::float_bitmap_api
FloatBitmapApi float_bitmap_api
Definition GameApi.hh:4677

GameApi::EveryApi::bool_bitmap_api
BoolBitmapApi bool_bitmap_api
Definition GameApi.hh:4676

GameApi::EveryApi::color_volume_api
ColorVolumeApi color_volume_api
Definition GameApi.hh:4686

GameApi::EveryApi::function_api
FunctionApi function_api
Definition GameApi.hh:4683

GameApi::EveryApi::EveryApi
IMPORT EveryApi(Env &e)
Definition GameApi.cc:44527

GameApi::EveryApi::picking_api
PickingApi picking_api
Definition GameApi.hh:4711

GameApi::EveryApi::blocker_api
BlockerApi blocker_api
Definition GameApi.hh:4720

GameApi::EveryApi::volume_api
VolumeApi volume_api
Definition GameApi.hh:4684

GameApi::EveryApi::point_api
PointApi point_api
Definition GameApi.hh:4669

GameApi::EveryApi::cutter_api
CutterApi cutter_api
Definition GameApi.hh:4706

GameApi::EveryApi::vector_api
VectorApi vector_api
Definition GameApi.hh:4670

GameApi::EveryApi::polygon_api
PolygonApi polygon_api
Definition GameApi.hh:4675

GameApi::EveryApi::font_api
FontApi font_api
Definition GameApi.hh:4679

GameApi::EveryApi::low_frame_api
LowFrameBufferApi low_frame_api
Definition GameApi.hh:4724

GameApi::EveryApi::voxel_api
VoxelApi voxel_api
Definition GameApi.hh:4698

GameApi::EveryApi::materials_api
MaterialsApi materials_api
Definition GameApi.hh:4713

GameApi::EveryApi::polygon_dist_api
PolygonDistanceField polygon_dist_api
Definition GameApi.hh:4719

GameApi::EveryApi::implicit_api
ImplicitApi implicit_api
Definition GameApi.hh:4710

GameApi::EveryApi::cont_bitmap_api
ContinuousBitmapApi cont_bitmap_api
Definition GameApi.hh:4678

GameApi::EveryApi::float_scene_api
FloatSceneApi float_scene_api
Definition GameApi.hh:4725

GameApi::EveryApi::texture_api
TextureApi texture_api
Definition GameApi.hh:4691

GameApi::EveryApi::color_api
ColorApi color_api
Definition GameApi.hh:4694

GameApi::EveryApi::dist_api
DistanceFloatVolumeApi dist_api
Definition GameApi.hh:4687

GameApi::ExecuteEnv
Definition GameApi.hh:301

GameApi::ExecuteEnv::names
std::vector< std::string > names
Definition GameApi.hh:302

GameApi::ExecuteEnv::values
std::vector< std::string > values
Definition GameApi.hh:303

GameApi::ExecuteEnv::env
std::vector< int > env
Definition GameApi.hh:305

GameApi::ExecuteEnv::envmap
std::map< std::string, int > envmap
Definition GameApi.hh:304

GameApi::ExprApi::FloatExprEnv
Definition GameApi.hh:2243

GameApi::ExprApi::FloatExprEnv::value
float value
Definition GameApi.hh:2243

GameApi::ExprApi::FloatExprEnv::name
std::string name
Definition GameApi.hh:2243

GameApi::ExprApi::IntExprEnv
Definition GameApi.hh:2244

GameApi::ExprApi::IntExprEnv::name
std::string name
Definition GameApi.hh:2244

GameApi::ExprApi::IntExprEnv::value
int value
Definition GameApi.hh:2244

GameApi::FA
Definition Common.hh:96

GameApi::FBO
Definition Common.hh:147

GameApi::FBU
Definition Common.hh:22

GameApi::FB
Definition Common.hh:75

GameApi::FD
Definition Common.hh:142

GameApi::FF
Definition Common.hh:42

GameApi::FI
Definition Common.hh:39

GameApi::FML
Definition Common.hh:23

GameApi::FOA
Definition Common.hh:138

GameApi::FO
Definition Common.hh:69

GameApi::F
Definition Common.hh:95

GameApi::Fi
Definition Common.hh:119

GameApi::FrameBufferApi::vp
Definition GameApi.hh:4579

GameApi::FrameBufferApi::vp::viewport
int viewport[4]
Definition GameApi.hh:4579

GameApi::FtA
Definition Common.hh:155

GameApi::Ft
Definition Common.hh:97

GameApi::GI
Definition Common.hh:41

GameApi::GuiApi::EditTypes
Definition GameApi.hh:2373

GameApi::GuiApi::EditTypes::f_value
float f_value
Definition GameApi.hh:2376

GameApi::GuiApi::EditTypes::s
std::string s
Definition GameApi.hh:2379

GameApi::GuiApi::EditTypes::i_value
int i_value
Definition GameApi.hh:2374

GameApi::GuiApi::EditTypes::f_z
float f_z
Definition GameApi.hh:2377

GameApi::GuiApi::EditTypes::f_x
float f_x
Definition GameApi.hh:2377

GameApi::GuiApi::EditTypes::color
std::string color
Definition GameApi.hh:2378

GameApi::GuiApi::EditTypes::f_y
float f_y
Definition GameApi.hh:2377

GameApi::GuiApi::EditTypes::expr
std::string expr
Definition GameApi.hh:2380

GameApi::GuiApi::EditTypes::l_value
long l_value
Definition GameApi.hh:2375

GameApi::H
Definition Common.hh:21

GameApi::Ht
Definition Common.hh:122

GameApi::IBM
Definition Common.hh:26

GameApi::ID
Definition Common.hh:117

GameApi::IF
Definition Common.hh:43

GameApi::IM
Definition Common.hh:164

GameApi::INP
Definition Common.hh:25

GameApi::IS
Definition Common.hh:84

GameApi::InteractionApi::Quake_data
Definition GameApi.hh:1817

GameApi::InteractionApi::Quake_data::old_pos_y
float old_pos_y
Definition GameApi.hh:1825

GameApi::InteractionApi::Quake_data::side_left
bool side_left
Definition GameApi.hh:1822

GameApi::InteractionApi::Quake_data::forward
bool forward
Definition GameApi.hh:1818

GameApi::InteractionApi::Quake_data::right
bool right
Definition GameApi.hh:1821

GameApi::InteractionApi::Quake_data::left
bool left
Definition GameApi.hh:1820

GameApi::InteractionApi::Quake_data::side_right
bool side_right
Definition GameApi.hh:1823

GameApi::InteractionApi::Quake_data::mv_mode
bool mv_mode
Definition GameApi.hh:1826

GameApi::InteractionApi::Quake_data::old_pos_x
float old_pos_x
Definition GameApi.hh:1824

GameApi::InteractionApi::Quake_data::backward
bool backward
Definition GameApi.hh:1819

GameApi::InteractionApi::Wasd_data
Definition GameApi.hh:1805

GameApi::InteractionApi::Wasd_data::up
bool up
Definition GameApi.hh:1806

GameApi::InteractionApi::Wasd_data::right
bool right
Definition GameApi.hh:1809

GameApi::InteractionApi::Wasd_data::left
bool left
Definition GameApi.hh:1808

GameApi::InteractionApi::Wasd_data::down
bool down
Definition GameApi.hh:1807

GameApi::KF
Definition Common.hh:50

GameApi::LAY
Definition Common.hh:109

GameApi::LA
Definition Common.hh:90

GameApi::LI
Definition Common.hh:140

GameApi::LLA
Definition Common.hh:141

GameApi::LL
Definition Common.hh:112

GameApi::LN
Definition Common.hh:82

GameApi::L
Definition Common.hh:108

GameApi::MA
Definition Common.hh:101

GameApi::MC
Definition Common.hh:59

GameApi::ME
Definition Common.hh:113

GameApi::ML
Definition Common.hh:156

GameApi::MN
Definition Common.hh:65

GameApi::MP
Definition Common.hh:110

GameApi::MS
Definition Common.hh:60

GameApi::MT
Definition Common.hh:62

GameApi::MV
Definition Common.hh:111

GameApi::MX
Definition Common.hh:55

GameApi::M
Definition GameApi.hh:190

GameApi::M::M
M(const M &ii)
Definition GameApi.hh:190

GameApi::M::mat
float mat[16]
Definition GameApi.hh:190

GameApi::MainLoopApi::DoubleTapState
Definition GameApi.hh:830

GameApi::MainLoopApi::DoubleTapState::DoubleTapState
DoubleTapState()
Definition GameApi.hh:830

GameApi::MainLoopApi::DoubleTapState::in_between
bool in_between
Definition GameApi.hh:830

GameApi::MainLoopApi::DoubleTapState::start_frame
int start_frame
Definition GameApi.hh:830

GameApi::MainLoopApi::Event
Definition GameApi.hh:791

GameApi::MainLoopApi::Event::type
int type
Definition GameApi.hh:792

GameApi::MainLoopApi::Event::joy1_axis2
int joy1_axis2
Definition GameApi.hh:816

GameApi::MainLoopApi::Event::joy0_button1
bool joy0_button1
Definition GameApi.hh:798

GameApi::MainLoopApi::Event::joy0_ball1
int joy0_ball1
Definition GameApi.hh:821

GameApi::MainLoopApi::Event::joy1_button1
bool joy1_button1
Definition GameApi.hh:803

GameApi::MainLoopApi::Event::joy1_ball1
int joy1_ball1
Definition GameApi.hh:823

GameApi::MainLoopApi::Event::last
bool last
Definition GameApi.hh:826

GameApi::MainLoopApi::Event::joy1_axis1
int joy1_axis1
Definition GameApi.hh:815

GameApi::MainLoopApi::Event::joy0_axis4
int joy0_axis4
Definition GameApi.hh:812

GameApi::MainLoopApi::Event::joy1_button3
bool joy1_button3
Definition GameApi.hh:805

GameApi::MainLoopApi::Event::joy0_button2
bool joy0_button2
Definition GameApi.hh:799

GameApi::MainLoopApi::Event::joy0_button3
bool joy0_button3
Definition GameApi.hh:800

GameApi::MainLoopApi::Event::joy1_axis4
int joy1_axis4
Definition GameApi.hh:818

GameApi::MainLoopApi::Event::joy0_current_axis
int joy0_current_axis
Definition GameApi.hh:807

GameApi::MainLoopApi::Event::ch
int ch
Definition GameApi.hh:793

GameApi::MainLoopApi::Event::joy0_axis2
int joy0_axis2
Definition GameApi.hh:810

GameApi::MainLoopApi::Event::mouse_wheel_y
int mouse_wheel_y
Definition GameApi.hh:796

GameApi::MainLoopApi::Event::joy1_button2
bool joy1_button2
Definition GameApi.hh:804

GameApi::MainLoopApi::Event::joy1_button0
bool joy1_button0
Definition GameApi.hh:802

GameApi::MainLoopApi::Event::joy1_axis3
int joy1_axis3
Definition GameApi.hh:817

GameApi::MainLoopApi::Event::cursor_pos
PT cursor_pos
Definition GameApi.hh:794

GameApi::MainLoopApi::Event::joy1_ball0
int joy1_ball0
Definition GameApi.hh:822

GameApi::MainLoopApi::Event::joy0_axis3
int joy0_axis3
Definition GameApi.hh:811

GameApi::MainLoopApi::Event::button
int button
Definition GameApi.hh:795

GameApi::MainLoopApi::Event::joy0_ball0
int joy0_ball0
Definition GameApi.hh:820

GameApi::MainLoopApi::Event::joy0_axis0
int joy0_axis0
Definition GameApi.hh:808

GameApi::MainLoopApi::Event::joy1_current_axis
int joy1_current_axis
Definition GameApi.hh:813

GameApi::MainLoopApi::Event::repeat
int repeat
Definition GameApi.hh:828

GameApi::MainLoopApi::Event::joy0_button0
bool joy0_button0
Definition GameApi.hh:797

GameApi::MainLoopApi::Event::joy0_axis1
int joy0_axis1
Definition GameApi.hh:809

GameApi::MainLoopApi::Event::drag_drop_filename
std::string drag_drop_filename
Definition GameApi.hh:827

GameApi::MainLoopApi::Event::joy1_axis0
int joy1_axis0
Definition GameApi.hh:814

GameApi::MaterialDef
Definition GameApi.hh:2841

GameApi::MaterialDef::map_bump
std::string map_bump
Definition GameApi.hh:2855

GameApi::MaterialDef::Kd_x
float Kd_x
Definition GameApi.hh:2849

GameApi::MaterialDef::material_name
std::string material_name
Definition GameApi.hh:2842

GameApi::MaterialDef::Ns
float Ns
Definition GameApi.hh:2843

GameApi::MaterialDef::bump
std::string bump
Definition GameApi.hh:2856

GameApi::MaterialDef::map_Kd
std::string map_Kd
Definition GameApi.hh:2853

GameApi::MaterialDef::Ke_y
float Ke_y
Definition GameApi.hh:2851

GameApi::MaterialDef::Ka_y
float Ka_y
Definition GameApi.hh:2848

GameApi::MaterialDef::Ni
float Ni
Definition GameApi.hh:2844

GameApi::MaterialDef::Kd_z
float Kd_z
Definition GameApi.hh:2849

GameApi::MaterialDef::map_Ka
std::string map_Ka
Definition GameApi.hh:2852

GameApi::MaterialDef::Ka_z
float Ka_z
Definition GameApi.hh:2848

GameApi::MaterialDef::Ke_x
float Ke_x
Definition GameApi.hh:2851

GameApi::MaterialDef::Ks_x
float Ks_x
Definition GameApi.hh:2850

GameApi::MaterialDef::d
float d
Definition GameApi.hh:2845

GameApi::MaterialDef::Ka_x
float Ka_x
Definition GameApi.hh:2848

GameApi::MaterialDef::illum
int illum
Definition GameApi.hh:2847

GameApi::MaterialDef::Ks_z
float Ks_z
Definition GameApi.hh:2850

GameApi::MaterialDef::Tr
float Tr
Definition GameApi.hh:2846

GameApi::MaterialDef::Kd_y
float Kd_y
Definition GameApi.hh:2849

GameApi::MaterialDef::Ke_z
float Ke_z
Definition GameApi.hh:2851

GameApi::MaterialDef::Ks_y
float Ks_y
Definition GameApi.hh:2850

GameApi::MaterialDef::map_d
std::string map_d
Definition GameApi.hh:2854

GameApi::OM
Definition Common.hh:68

GameApi::OO
Definition Common.hh:87

GameApi::O
Definition Common.hh:85

GameApi::Op
Definition Common.hh:120

GameApi::PAR
Definition Common.hh:47

GameApi::PA
Definition Common.hh:89

GameApi::PC
Definition Common.hh:136

GameApi::PD
Definition GameApi.hh:2789

GameApi::PD::id
int id
Definition GameApi.hh:2789

GameApi::PF
Definition Common.hh:44

GameApi::PH
Definition Common.hh:160

GameApi::PLA
Definition Common.hh:128

GameApi::PLF
Definition Common.hh:36

GameApi::PN
Definition Common.hh:29

GameApi::PPT
Definition Common.hh:99

GameApi::PP
Definition Common.hh:88

GameApi::PSP
Definition Common.hh:100

GameApi::PS
Definition Common.hh:116

GameApi::PTA
Definition Common.hh:145

GameApi::PTS
Definition Common.hh:144

GameApi::PTT
Definition Common.hh:49

GameApi::PT
Definition Common.hh:79

GameApi::P
Definition Common.hh:86

GameApi::Pa
Definition Common.hh:56

GameApi::PhysicsApi::PHI
Definition GameApi.hh:2009

GameApi::PhysicsApi::PHI::id
int id
Definition GameApi.hh:2009

GameApi::PhysicsApi::PHI::phy
PH phy
Definition GameApi.hh:2009

GameApi::PinIn
Definition GameApi.hh:46

GameApi::PinOut
Definition GameApi.hh:49

GameApi::PinOut::data
T data
Definition GameApi.hh:49

GameApi::Q
Definition Common.hh:134

GameApi::RD
Definition Common.hh:146

GameApi::RM
Definition Common.hh:83

GameApi::RUN
Definition Common.hh:52

GameApi::SA
Definition Common.hh:78

GameApi::SBM
Definition Common.hh:28

GameApi::SD
Definition Common.hh:40

GameApi::SFO
Definition Common.hh:152

GameApi::SF
Definition Common.hh:45

GameApi::SH
Definition Common.hh:92

GameApi::SM
Definition Common.hh:148

GameApi::SP
Definition Common.hh:77

GameApi::ST
Definition Common.hh:114

GameApi::SV
Definition Common.hh:137

GameApi::S
Definition Common.hh:103

GameApi::Str
Definition Common.hh:118

GameApi::TBUF
Definition Common.hh:151

GameApi::TL
Definition Common.hh:63

GameApi::TN
Definition Common.hh:91

GameApi::TRA
Definition GameApi.hh:288

GameApi::TRA::id
int id
Definition GameApi.hh:288

GameApi::TRB
Definition GameApi.hh:286

GameApi::TRB::id
int id
Definition GameApi.hh:286

GameApi::TRK
Definition Common.hh:149

GameApi::TRR
Definition GameApi.hh:287

GameApi::TRR::id
int id
Definition GameApi.hh:287

GameApi::TR
Definition Common.hh:132

GameApi::TS
Definition Common.hh:161

GameApi::TXA
Definition Common.hh:131

GameApi::TXID
Definition Common.hh:130

GameApi::TX
Definition Common.hh:129

GameApi::TY
Definition Common.hh:115

GameApi::T
Definition Common.hh:106

GameApi::US
Definition Common.hh:61

GameApi::VAA
Definition Common.hh:125

GameApi::VA
Definition Common.hh:124

GameApi::VBM
Definition Common.hh:73

GameApi::VF
Definition Common.hh:98

GameApi::VO
Definition Common.hh:143

GameApi::VV
Definition Common.hh:133

GameApi::VX
Definition Common.hh:126

GameApi::V
Definition Common.hh:80

GameApi::Va
Definition Common.hh:57

GameApi::Vb
Definition Common.hh:104

GameApi::WAV
Definition Common.hh:150

GameApi::WM
Definition Common.hh:154

GameApi::WModApi::InsertParam
Definition GameApi.hh:2497

GameApi::WModApi::InsertParam::second
std::string second
Definition GameApi.hh:2499

GameApi::WModApi::InsertParam::line_index_in_gameapi_function_lines_array
int line_index_in_gameapi_function_lines_array
Definition GameApi.hh:2501

GameApi::WModApi::InsertParam::first
std::string first
Definition GameApi.hh:2498

GameApi::WModApi::InsertParam::is_array
bool is_array
Definition GameApi.hh:2500

GameApi::WV
Definition Common.hh:70

GameApi::W
Definition Common.hh:153

GameApi::WorldObj::Var
Definition GameApi.hh:5573

GameApi::WorldObj::Var::g
float g
Definition GameApi.hh:5575

GameApi::WorldObj::Var::a
float a
Definition GameApi.hh:5575

GameApi::WorldObj::Var::b
float b
Definition GameApi.hh:5575

GameApi::WorldObj::Var::name
std::string name
Definition GameApi.hh:5574

GameApi::WorldObj::Var::r
float r
Definition GameApi.hh:5575

LI
Definition GameApi.h:76

LLA
Definition GameApi.h:77

ML
Definition GameApi.h:92

M
Definition GameApi.h:18

MainLoopEnv
Definition GraphI.hh:1502

PTA
Definition GameApi.h:81

PTS
Definition GameApi.h:80

P
Definition GameApi.h:23

SH
Definition GameApi.h:29

TXA
Definition GameApi.h:67

UV
Definition FloatVolumeObject.hh:5

link
W link(std::string url, std::string str, int size_x, int size_y, int font_size, unsigned int font_colour, int align)
Definition ui.cc:731

empty
W empty()
Definition ui.cc:634

center_y
W center_y(W item, int sy)
Definition ui.cc:947

hide
W hide(W widget)
Definition ui.cc:954

urls
you need to obtain reproduction rights and give meshpage org permission to publish the content in meshpage org While the content is available only to people who gets access to resulting urls
Definition view.php:234

num
num
Definition view.php:2821

compress
#define compress
Definition zip_file.hpp:485