GameApi 28
Library used by GameApi Builder tool
Loading...
Searching...
No Matches
GameApi::MainLoopApi Class Reference

#include <GameApi.hh>

Classes

struct  Event
struct  DoubleTapState

Public Member Functions

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 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::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, 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)
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 level2_tri, float level3_tri, float level4_tri, 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 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)
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)
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 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)
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)
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_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_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 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)
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 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)
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 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)
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)

Constructor & Destructor Documentation

◆ MainLoopApi()

EXPORT GameApi::MainLoopApi::MainLoopApi ( Env & e)
Here is the caller graph for this function:

◆ ~MainLoopApi()

EXPORT GameApi::MainLoopApi::~MainLoopApi ( )

Member Function Documentation

◆ activate_arr_arr()

GameApi::ARR GameApi::MainLoopApi::activate_arr_arr ( std::vector< ML > arr)
Here is the caller graph for this function:

◆ activate_array()

GameApi::ML GameApi::MainLoopApi::activate_array ( std::vector< ML > vec)
Here is the caller graph for this function:

◆ activate_item()

GameApi::ML GameApi::MainLoopApi::activate_item ( ML ml,
ML def )
Here is the caller graph for this function:

◆ advance_time()

EXPORT void GameApi::MainLoopApi::advance_time ( float val)

◆ AI_generated()

GameApi::ML GameApi::MainLoopApi::AI_generated ( EveryApi & ev,
GameApi::ML ml,
std::string url )
Here is the caller graph for this function:

◆ AI_modified()

GameApi::ML GameApi::MainLoopApi::AI_modified ( EveryApi & ev,
GameApi::ML ml,
std::string url )
Here is the caller graph for this function:

◆ alpha()

EXPORT void GameApi::MainLoopApi::alpha ( bool enabled)
Here is the caller graph for this function:

◆ alpha_1()

void GameApi::MainLoopApi::alpha_1 ( bool enabled)
Here is the caller graph for this function:

◆ android_landscape_scale()

GameApi::ML GameApi::MainLoopApi::android_landscape_scale ( EveryApi & ev,
ML ml )

◆ android_resize()

GameApi::ML GameApi::MainLoopApi::android_resize ( GameApi::EveryApi & ev,
ML ml,
float mult )
Here is the caller graph for this function:

◆ anim_ML()

GameApi::ML GameApi::MainLoopApi::anim_ML ( EveryApi & ev,
std::string url,
std::string p1,
std::string p2,
std::string p3,
std::string p4,
std::string p5,
IF dyn )
Here is the caller graph for this function:

◆ anim_transfer_id()

GameApi::TRA GameApi::MainLoopApi::anim_transfer_id ( GameApi::TRB id)
Here is the caller graph for this function:

◆ antialias()

EXPORT void GameApi::MainLoopApi::antialias ( bool enabled)
Here is the caller graph for this function:

◆ array_cache()

GameApi::CX GameApi::MainLoopApi::array_cache ( std::vector< CX > vec)

◆ array_fml()

EXPORT GameApi::FML GameApi::MainLoopApi::array_fml ( std::vector< FML > vec)
Here is the caller graph for this function:

◆ array_ml()

EXPORT GameApi::ML GameApi::MainLoopApi::array_ml ( GameApi::EveryApi & ev,
std::vector< ML > vec )
Here is the caller graph for this function:

◆ array_timing_chain()

GameApi::TT GameApi::MainLoopApi::array_timing_chain ( TT prev,
float start_time,
std::string durations,
std::vector< ML > vec )
Here is the caller graph for this function:

◆ array_timing_chain_key_ml()

GameApi::ML GameApi::MainLoopApi::array_timing_chain_key_ml ( EveryApi & ev,
int key,
float time_after_key,
std::string durations,
std::vector< ML > vec,
int repeat )
Here is the caller graph for this function:

◆ array_timing_chain_ml()

GameApi::ML GameApi::MainLoopApi::array_timing_chain_ml ( float start_time,
std::string durations,
std::vector< ML > vec,
int repeat )
Here is the caller graph for this function:

◆ array_world()

GameApi::W GameApi::MainLoopApi::array_world ( std::vector< W > vec)

◆ async_gltf()

GameApi::ML GameApi::MainLoopApi::async_gltf ( ML ml,
TF tf )
Here is the caller graph for this function:

◆ async_url()

GameApi::ML GameApi::MainLoopApi::async_url ( std::string url,
ML ml )
Here is the caller graph for this function:

◆ bind_obj_type() [1/2]

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

◆ bind_obj_type() [2/2]

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

◆ bindinst_parr_msarr()

IMPORT ML GameApi::MainLoopApi::bindinst_parr_msarr ( EveryApi & ev,
std::vector< P > parr,
std::vector< MS > msarr,
std::vector< MT > mat )
Here is the caller graph for this function:

◆ blendfunc()

GameApi::ML GameApi::MainLoopApi::blendfunc ( ML ml,
int val,
int val2 )
Here is the caller graph for this function:

◆ bytestore_array()

GameApi::ML GameApi::MainLoopApi::bytestore_array ( EveryApi & ev,
BS store,
std::string url,
float delta_time )
Here is the caller graph for this function:

◆ bytestore_pts()

GameApi::PTS GameApi::MainLoopApi::bytestore_pts ( BS bs,
PTS pts,
char disable_char,
char enable_char,
bool default_is_enable )
Here is the caller graph for this function:

◆ bytestore_render()

GameApi::ML GameApi::MainLoopApi::bytestore_render ( EveryApi & ev,
BS bs,
std::vector< ML > mls,
std::string url,
float delta_x,
float delta_y )
Here is the caller graph for this function:

◆ bytestore_timing()

GameApi::ML GameApi::MainLoopApi::bytestore_timing ( BS store,
int ch,
std::string s,
float time_delta )
Here is the caller graph for this function:

◆ cache_one()

GameApi::CX GameApi::MainLoopApi::cache_one ( P p,
MT mt )

◆ call_execute_hack()

void GameApi::MainLoopApi::call_execute_hack ( ML ml)

◆ ch_doubletap_detect()

EXPORT bool GameApi::MainLoopApi::ch_doubletap_detect ( Event & e,
int exprire_timer_count,
int ch,
DoubleTapState & state )

◆ chai_mainloop()

IMPORT ML GameApi::MainLoopApi::chai_mainloop ( EveryApi & ev,
std::string url )
Here is the caller graph for this function:

◆ chai_mainloop2()

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

◆ check_glerrors()

EXPORT void GameApi::MainLoopApi::check_glerrors ( std::string context)

◆ choose_ml_from_status()

GameApi::ML GameApi::MainLoopApi::choose_ml_from_status ( ML connect,
ML download,
ML prepare )

◆ clear()

EXPORT void GameApi::MainLoopApi::clear ( unsigned int col = 0xff000000)
Here is the caller graph for this function:

◆ clear_3d()

EXPORT void GameApi::MainLoopApi::clear_3d ( unsigned int col = 0xff000000)

◆ clear_3d_transparent()

EXPORT void GameApi::MainLoopApi::clear_3d_transparent ( )

◆ cmb_2____()

GameApi::ML GameApi::MainLoopApi::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 )

◆ cmb_____()

GameApi::ML GameApi::MainLoopApi::cmb_____ ( GameApi::EveryApi & ev,
std::string script_url,
std::string param1,
std::string param2,
std::string param3,
std::string param4,
std::string param5 )

◆ cmb_glb_3d_interpolate()

GameApi::ML GameApi::MainLoopApi::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 )

◆ collision_detection()

GameApi::ML GameApi::MainLoopApi::collision_detection ( EveryApi & ev,
float player_size,
float enemy_size,
ML normal_game_screen,
ML gameover_screen )
Here is the caller graph for this function:

◆ collision_gen_key()

GameApi::ML GameApi::MainLoopApi::collision_gen_key ( ML curr,
std::string obj1,
std::string obj2,
int key,
float duration )
Here is the caller graph for this function:

◆ collision_seq_ml()

GameApi::ML GameApi::MainLoopApi::collision_seq_ml ( ML curr,
ML end,
std::string obj1,
std::string obj2,
float show_duration )
Here is the caller graph for this function:

◆ concurrent_download()

GameApi::ML GameApi::MainLoopApi::concurrent_download ( ML ml)
Here is the caller graph for this function:

◆ constant_shp_f()

GameApi::SHP GameApi::MainLoopApi::constant_shp_f ( SHP next,
int num,
float value )

◆ constant_shp_i()

GameApi::SHP GameApi::MainLoopApi::constant_shp_i ( SHP next,
int num,
int value )

◆ constant_shp_p3d()

GameApi::SHP GameApi::MainLoopApi::constant_shp_p3d ( SHP next,
int num,
PT value )

◆ constant_shp_u()

GameApi::SHP GameApi::MainLoopApi::constant_shp_u ( SHP next,
int num,
unsigned int value )

◆ constant_shp_uvw()

GameApi::SHP GameApi::MainLoopApi::constant_shp_uvw ( SHP next,
int num,
PT value )

◆ create_landscape()

GameApi::ML GameApi::MainLoopApi::create_landscape ( GameApi::EveryApi & ev,
std::string url )
Here is the caller graph for this function:

◆ create_objs()

GameApi::ML GameApi::MainLoopApi::create_objs ( EveryApi & ev,
int area_id )
Here is the caller graph for this function:

◆ cullface()

GameApi::ML GameApi::MainLoopApi::cullface ( ML ml,
bool b,
bool is_gltf )

◆ current_time()

GameApi::TT GameApi::MainLoopApi::current_time ( TT prev)
Here is the caller graph for this function:

◆ cursor_keys_normal_move()

GameApi::INP GameApi::MainLoopApi::cursor_keys_normal_move ( )
Here is the caller graph for this function:

◆ cursor_keys_rotate_move()

GameApi::INP GameApi::MainLoopApi::cursor_keys_rotate_move ( float speed_rot,
float pos_forward,
float pos_normal,
float pos_backward )
Here is the caller graph for this function:

◆ cursor_visible()

EXPORT void GameApi::MainLoopApi::cursor_visible ( bool enabled)

◆ cursorkeys_to_wasd()

GameApi::ML GameApi::MainLoopApi::cursorkeys_to_wasd ( GameApi::ML ml)
Here is the caller graph for this function:

◆ debug_obj()

GameApi::ML GameApi::MainLoopApi::debug_obj ( EveryApi & ev)
Here is the caller graph for this function:

◆ delay()

EXPORT void GameApi::MainLoopApi::delay ( int ms)

◆ depth_test()

EXPORT void GameApi::MainLoopApi::depth_test ( bool enabled)

◆ depthfunc()

GameApi::ML GameApi::MainLoopApi::depthfunc ( ML ml,
int val )
Here is the caller graph for this function:

◆ depthmask()

GameApi::ML GameApi::MainLoopApi::depthmask ( ML ml,
bool b )
Here is the caller graph for this function:

◆ disable_matrices()

GameApi::ML GameApi::MainLoopApi::disable_matrices ( EveryApi & ev,
ML ml,
int size )

◆ disable_polygons()

GameApi::ML GameApi::MainLoopApi::disable_polygons ( GameApi::ML ml)
Here is the caller graph for this function:

◆ disable_resize()

GameApi::ML GameApi::MainLoopApi::disable_resize ( GameApi::ML ml)

◆ disable_z_buffer()

GameApi::ML GameApi::MainLoopApi::disable_z_buffer ( ML ml)
Here is the caller graph for this function:

◆ display_background()

GameApi::ML GameApi::MainLoopApi::display_background ( EveryApi & ev,
ML ml,
bool is_logo = false )

◆ display_logo()

void GameApi::MainLoopApi::display_logo ( EveryApi & ev)

◆ display_seamless()

void GameApi::MainLoopApi::display_seamless ( EveryApi & ev)

◆ double_instancing()

GameApi::ML GameApi::MainLoopApi::double_instancing ( EveryApi & ev,
GameApi::P p,
GameApi::PTS static_inst,
GameApi::PTS real_inst,
MT mat )
Here is the caller graph for this function:

◆ double_instancing_matrix()

GameApi::ML GameApi::MainLoopApi::double_instancing_matrix ( EveryApi & ev,
GameApi::P p,
GameApi::MS static_ms,
GameApi::MS real_ms,
MT mat )
Here is the caller graph for this function:

◆ drag_drop_area()

EXPORT GameApi::ML GameApi::MainLoopApi::drag_drop_area ( EveryApi & ev,
ML mainloop,
RUN(* fptr )(Env &e, EveryApi &ev, std::string filename) )

◆ ds_to_string()

std::string GameApi::MainLoopApi::ds_to_string ( DS ds)

◆ dyn()

GameApi::ML GameApi::MainLoopApi::dyn ( D d)
Here is the caller graph for this function:

◆ dyn_points()

GameApi::ML GameApi::MainLoopApi::dyn_points ( EveryApi & ev,
ML ml,
MN move,
int pointnum,
float pos_x,
float pos_y,
float pos_z )
Here is the caller graph for this function:

◆ edit_3d()

GameApi::ML GameApi::MainLoopApi::edit_3d ( GameApi::EveryApi & ev,
P p,
float radius )
Here is the caller graph for this function:

◆ edit_3d_p()

GameApi::P GameApi::MainLoopApi::edit_3d_p ( EveryApi & ev)
Here is the caller graph for this function:

◆ empty_shaderI()

GameApi::SHI GameApi::MainLoopApi::empty_shaderI ( )
Here is the caller graph for this function:

◆ empty_shp()

GameApi::SHP GameApi::MainLoopApi::empty_shp ( )
Here is the caller graph for this function:

◆ emscripten_frame()

IMPORT HML GameApi::MainLoopApi::emscripten_frame ( EveryApi & ev,
RUN r,
std::string homepage )
Here is the caller graph for this function:

◆ emscripten_frame2()

GameApi::HML GameApi::MainLoopApi::emscripten_frame2 ( EveryApi & ev,
RUN r,
std::string homepage,
bool is_envparams_arr = false )
Here is the caller graph for this function:

◆ emscripten_frame2_ML()

GameApi::HML GameApi::MainLoopApi::emscripten_frame2_ML ( EveryApi & ev,
ML ml,
std::string homepage )
Here is the caller graph for this function:

◆ emscripten_frame2_MN()

GameApi::HML GameApi::MainLoopApi::emscripten_frame2_MN ( EveryApi & ev,
MN mn,
std::string homepage )

◆ emscripten_frame2_MT()

GameApi::HML GameApi::MainLoopApi::emscripten_frame2_MT ( EveryApi & ev,
MT mt,
std::string homepage )
Here is the caller graph for this function:

◆ emscripten_frame2_P()

GameApi::HML GameApi::MainLoopApi::emscripten_frame2_P ( EveryApi & ev,
P p,
std::string homepage )
Here is the caller graph for this function:

◆ end_editor_state()

EXPORT void GameApi::MainLoopApi::end_editor_state ( )

◆ event_ml()

void GameApi::MainLoopApi::event_ml ( ML ml,
const Event & e )

◆ execute_ml()

void GameApi::MainLoopApi::execute_ml ( GameApi::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 )

◆ face_fetcher()

GameApi::UV GameApi::MainLoopApi::face_fetcher ( P p,
int facenum )
Here is the caller graph for this function:

◆ filter_execute_array_ml()

EXPORT GameApi::ML GameApi::MainLoopApi::filter_execute_array_ml ( GameApi::EveryApi & ev,
std::vector< ML > vec )

◆ finish()

EXPORT void GameApi::MainLoopApi::finish ( )
Here is the caller graph for this function:

◆ flip_bitmap_if_mobile()

GameApi::BM GameApi::MainLoopApi::flip_bitmap_if_mobile ( GameApi::EveryApi & ev,
GameApi::BM bm )

◆ flip_scene_if_mobile()

GameApi::ML GameApi::MainLoopApi::flip_scene_if_mobile ( GameApi::EveryApi & ev,
ML ml )

◆ flip_scene_x_if_mobile()

GameApi::ML GameApi::MainLoopApi::flip_scene_x_if_mobile ( GameApi::EveryApi & ev,
ML ml )

◆ fps_display()

GameApi::ML GameApi::MainLoopApi::fps_display ( EveryApi & ev,
ML ml,
std::string font )
Here is the caller graph for this function:

◆ fpscounter()

EXPORT float GameApi::MainLoopApi::fpscounter ( bool print = true)
Here is the caller graph for this function:

◆ fpscounter_frameready()

EXPORT void GameApi::MainLoopApi::fpscounter_frameready ( )

◆ fpscounter_framestart()

EXPORT void GameApi::MainLoopApi::fpscounter_framestart ( )

◆ fpscounter_init()

EXPORT void GameApi::MainLoopApi::fpscounter_init ( )
Here is the caller graph for this function:

◆ fpscounter_swapbuffersready()

EXPORT void GameApi::MainLoopApi::fpscounter_swapbuffersready ( )
Here is the caller graph for this function:

◆ framebuffer_bitmap()

GameApi::BM GameApi::MainLoopApi::framebuffer_bitmap ( FBU framebuffer)

◆ fullscreen_button()

GameApi::ML GameApi::MainLoopApi::fullscreen_button ( EveryApi & ev)
Here is the caller graph for this function:

◆ game()

GameApi::ML GameApi::MainLoopApi::game ( GameApi::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 )
Here is the caller graph for this function:

◆ game_state()

GameApi::GS GameApi::MainLoopApi::game_state ( )
Here is the caller graph for this function:

◆ generic_anim_shader()

GameApi::SHI GameApi::MainLoopApi::generic_anim_shader ( SHP params,
std::string funcname,
std::string shadercode,
std::vector< SHI > children )

◆ generic_anim_shader2()

GameApi::SHI GameApi::MainLoopApi::generic_anim_shader2 ( EveryApi & ev,
SHP params,
std::string funcname,
SHC code,
std::vector< SHI > children )
Here is the caller graph for this function:

◆ generic_shader()

GameApi::ML GameApi::MainLoopApi::generic_shader ( GameApi::EveryApi & ev,
ML ml,
SHI vertex,
SHI fragment,
std::vector< TXID > vec )
Here is the caller graph for this function:

◆ generic_shader_fragment_only()

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

◆ get_corner_x()

EXPORT int GameApi::MainLoopApi::get_corner_x ( )

◆ get_corner_y()

EXPORT int GameApi::MainLoopApi::get_corner_y ( )

◆ get_delta_time()

EXPORT float GameApi::MainLoopApi::get_delta_time ( )
Here is the caller graph for this function:

◆ get_event()

EXPORT GameApi::MainLoopApi::Event GameApi::MainLoopApi::get_event ( )
Here is the caller graph for this function:

◆ get_frame_time()

float GameApi::MainLoopApi::get_frame_time ( ) const

◆ get_framenum()

EXPORT int GameApi::MainLoopApi::get_framenum ( )

◆ get_homepage_url()

std::string GameApi::MainLoopApi::get_homepage_url ( )

◆ get_movement_from_MV()

GameApi::ML GameApi::MainLoopApi::get_movement_from_MV ( GameApi::ML ml)
Here is the caller graph for this function:

◆ get_screen_height()

int GameApi::MainLoopApi::get_screen_height ( )

◆ get_screen_rect_sx()

EXPORT int GameApi::MainLoopApi::get_screen_rect_sx ( )

◆ get_screen_rect_sy()

EXPORT int GameApi::MainLoopApi::get_screen_rect_sy ( )

◆ get_screen_sx()

EXPORT int GameApi::MainLoopApi::get_screen_sx ( )
Here is the caller graph for this function:

◆ get_screen_sy()

EXPORT int GameApi::MainLoopApi::get_screen_sy ( )
Here is the caller graph for this function:

◆ get_screen_width()

int GameApi::MainLoopApi::get_screen_width ( )

◆ get_time()

EXPORT float GameApi::MainLoopApi::get_time ( )
Here is the caller graph for this function:

◆ glb_load_sketchfab_zip()

IMPORT TF GameApi::MainLoopApi::glb_load_sketchfab_zip ( std::string url_to_zip)

◆ glb_to_download_bar()

GameApi::ML GameApi::MainLoopApi::glb_to_download_bar ( TF tf,
std::string filename )
Here is the caller graph for this function:

◆ glClear()

GameApi::ML GameApi::MainLoopApi::glClear ( GameApi::EveryApi & ev,
unsigned int color )

◆ gltf_anim2()

IMPORT ML GameApi::MainLoopApi::gltf_anim2 ( EveryApi & ev,
TF model0,
int animation,
int channel )

◆ gltf_anim4()

GameApi::ML GameApi::MainLoopApi::gltf_anim4 ( GameApi::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 )
Here is the caller graph for this function:

◆ gltf_anim_skeleton()

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

◆ gltf_load_sketchfab_zip()

GameApi::TF GameApi::MainLoopApi::gltf_load_sketchfab_zip ( std::string url_to_zip)
Here is the caller graph for this function:

◆ gltf_loadKK()

GameApi::TF GameApi::MainLoopApi::gltf_loadKK ( std::string base_url,
std::string url )
Here is the caller graph for this function:

◆ gltf_loadKK2()

GameApi::TF GameApi::MainLoopApi::gltf_loadKK2 ( std::string url)
Here is the caller graph for this function:

◆ gltf_mesh()

GameApi::ML GameApi::MainLoopApi::gltf_mesh ( GameApi::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 )
Here is the caller graph for this function:

◆ gltf_mesh_all()

GameApi::ML GameApi::MainLoopApi::gltf_mesh_all ( GameApi::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 )
Here is the caller graph for this function:

◆ gltf_mesh_all_anim()

GameApi::ML GameApi::MainLoopApi::gltf_mesh_all_anim ( GameApi::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 )
Here is the caller graph for this function:

◆ gltf_mesh_all_anim_inst()

GameApi::ML GameApi::MainLoopApi::gltf_mesh_all_anim_inst ( GameApi::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 )
Here is the caller graph for this function:

◆ gltf_mesh_all_anim_inst_matrix()

GameApi::ML GameApi::MainLoopApi::gltf_mesh_all_anim_inst_matrix ( GameApi::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 )
Here is the caller graph for this function:

◆ gltf_mesh_all_env()

GameApi::ML GameApi::MainLoopApi::gltf_mesh_all_env ( GameApi::EveryApi & ev,
TF model0,
BM diffuse,
BM specular,
BM bfrd,
float mix )
Here is the caller graph for this function:

◆ gltf_mesh_all_inst()

IMPORT ML GameApi::MainLoopApi::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 )
Here is the caller graph for this function:

◆ gltf_mesh_all_inst2()

GameApi::ML GameApi::MainLoopApi::gltf_mesh_all_inst2 ( GameApi::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 )
Here is the caller graph for this function:

◆ gltf_mesh_all_inst_matrix()

GameApi::ML GameApi::MainLoopApi::gltf_mesh_all_inst_matrix ( GameApi::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 )
Here is the caller graph for this function:

◆ gltf_mesh_all_msarr()

IMPORT ARR GameApi::MainLoopApi::gltf_mesh_all_msarr ( EveryApi & ev,
TF model0,
int skin_num )

◆ gltf_mesh_all_mt_arr()

GameApi::ARR GameApi::MainLoopApi::gltf_mesh_all_mt_arr ( GameApi::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 )
Here is the caller graph for this function:

◆ gltf_mesh_all_p()

GameApi::P GameApi::MainLoopApi::gltf_mesh_all_p ( GameApi::EveryApi & ev,
TF model0 )
Here is the caller graph for this function:

◆ gltf_mesh_all_p_arr()

GameApi::ARR GameApi::MainLoopApi::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 )
Here is the caller graph for this function:

◆ gltf_mesh_all_parr()

IMPORT ARR GameApi::MainLoopApi::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 )

◆ gltf_mesh_all_parr_mat()

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

◆ gltf_mesh_all_parr_msarr()

IMPORT ARR GameApi::MainLoopApi::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 )
Here is the caller graph for this function:

◆ gltf_node()

GameApi::ML GameApi::MainLoopApi::gltf_node ( GameApi::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 )
Here is the caller graph for this function:

◆ gltf_scene()

GameApi::ML GameApi::MainLoopApi::gltf_scene ( GameApi::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 )
Here is the caller graph for this function:

◆ gltf_scene_anim()

GameApi::ML GameApi::MainLoopApi::gltf_scene_anim ( GameApi::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 )
Here is the caller graph for this function:

◆ gltf_scene_p()

GameApi::P GameApi::MainLoopApi::gltf_scene_p ( GameApi::EveryApi & ev,
TF model0,
int scene_id )
Here is the caller graph for this function:

◆ gltf_skeleton()

IMPORT LI GameApi::MainLoopApi::gltf_skeleton ( EveryApi & ev,
TF model0,
int start_node )

◆ gravity()

GameApi::INP GameApi::MainLoopApi::gravity ( INP im,
IBM bitmap,
float start_x,
float end_x,
float start_y,
float end_y,
float speed )
Here is the caller graph for this function:

◆ gs_delta()

GameApi::ML GameApi::MainLoopApi::gs_delta ( GS gs,
ML ml,
int p,
int n,
float delta )
Here is the caller graph for this function:

◆ gs_mouse_pos()

GameApi::ML GameApi::MainLoopApi::gs_mouse_pos ( GS gs,
ML ml,
int x,
int y )
Here is the caller graph for this function:

◆ gs_obj_pos()

GameApi::ML GameApi::MainLoopApi::gs_obj_pos ( GS gs,
ML ml,
int x,
int y,
int z )
Here is the caller graph for this function:

◆ gs_time()

GameApi::ML GameApi::MainLoopApi::gs_time ( GS gs,
ML ml,
int t )
Here is the caller graph for this function:

◆ hires_ml()

GameApi::ML GameApi::MainLoopApi::hires_ml ( EveryApi & ev,
ML I3,
int size,
int numsamples,
float blur_radius )
Here is the caller graph for this function:

◆ html_url()

GameApi::HML GameApi::MainLoopApi::html_url ( std::string url)
Here is the caller graph for this function:

◆ if_keys()

GameApi::ML GameApi::MainLoopApi::if_keys ( ML ml,
IF fetcher,
std::string keys )
Here is the caller graph for this function:

◆ img_decode()

GameApi::BM GameApi::MainLoopApi::img_decode ( MB memblock)

◆ in_MV()

GameApi::M GameApi::MainLoopApi::in_MV ( EveryApi & ev,
bool is_3d )
Here is the caller graph for this function:

◆ in_N()

GameApi::M GameApi::MainLoopApi::in_N ( EveryApi & ev,
bool is_3d )
Here is the caller graph for this function:

◆ in_P()

GameApi::M GameApi::MainLoopApi::in_P ( EveryApi & ev,
bool is_3d )

◆ in_T()

GameApi::M GameApi::MainLoopApi::in_T ( EveryApi & ev,
bool is_3d )
Here is the caller graph for this function:

◆ init()

EXPORT void GameApi::MainLoopApi::init ( SH sh,
int screen_width = 800,
int screen_height = 600 )
Here is the caller graph for this function:

◆ init_3d()

EXPORT void GameApi::MainLoopApi::init_3d ( SH sh,
int screen_width = 800,
int screen_heigth = 600 )
Here is the caller graph for this function:

◆ init_window()

EXPORT void GameApi::MainLoopApi::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 )
Here is the caller graph for this function:

◆ is_gltf_animated()

EXPORT bool GameApi::MainLoopApi::is_gltf_animated ( EveryApi & ev,
TF tf )

◆ isometric()

GameApi::ML GameApi::MainLoopApi::isometric ( ML ml,
float y_angle,
float x_angle,
float translate )
Here is the caller graph for this function:

◆ joystick_printer()

GameApi::ML GameApi::MainLoopApi::joystick_printer ( ML ml)
Here is the caller graph for this function:

◆ joystick_to_wasd()

GameApi::ML GameApi::MainLoopApi::joystick_to_wasd ( ML ml)
Here is the caller graph for this function:

◆ key_ml()

GameApi::ML GameApi::MainLoopApi::key_ml ( std::vector< ML > vec,
std::string keys )
Here is the caller graph for this function:

◆ key_press_print_time_sync()

GameApi::ML GameApi::MainLoopApi::key_press_print_time_sync ( ML ml)
Here is the caller graph for this function:

◆ keyboard_toggle()

GameApi::ML GameApi::MainLoopApi::keyboard_toggle ( ML m1,
ML m2,
int key )
Here is the caller graph for this function:

◆ load_BM_script()

GameApi::BM GameApi::MainLoopApi::load_BM_script ( EveryApi & ev,
std::string url,
std::string p1,
std::string p2,
std::string p3,
std::string p4,
std::string p5 )
Here is the caller graph for this function:

◆ load_BM_script_array()

GameApi::ARR GameApi::MainLoopApi::load_BM_script_array ( EveryApi & ev,
std::string url,
std::string p1,
std::string p2,
std::string p3,
std::string p4,
std::string p5 )
Here is the caller graph for this function:

◆ load_BM_script_array_comb()

GameApi::ARR GameApi::MainLoopApi::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 )
Here is the caller graph for this function:

◆ load_ds_from_disk()

GameApi::DS GameApi::MainLoopApi::load_ds_from_disk ( std::string filename)

◆ load_ds_from_disk_incrementally()

GameApi::DS GameApi::MainLoopApi::load_ds_from_disk_incrementally ( std::string filename)

◆ load_ds_from_mem()

GameApi::DS GameApi::MainLoopApi::load_ds_from_mem ( const unsigned char * buf,
const unsigned char * end )

◆ load_ds_from_temp()

void GameApi::MainLoopApi::load_ds_from_temp ( std::string filename,
void(* fptr )(void *),
void * data,
bool & success )

◆ load_ds_from_temp2()

GameApi::DS GameApi::MainLoopApi::load_ds_from_temp2 ( std::string filename)

◆ load_ds_from_temp3()

void GameApi::MainLoopApi::load_ds_from_temp3 ( std::string filename)

◆ load_midi()

GameApi::ML GameApi::MainLoopApi::load_midi ( EveryApi & ev,
ML next,
std::string url,
std::string url_patchset )
Here is the caller graph for this function:

◆ load_ML_script()

GameApi::ML GameApi::MainLoopApi::load_ML_script ( EveryApi & ev,
std::string url,
std::string p1,
std::string p2,
std::string p3,
std::string p4,
std::string p5 )
Here is the caller graph for this function:

◆ load_ML_script2()

GameApi::ML GameApi::MainLoopApi::load_ML_script2 ( EveryApi & ev,
HML h,
std::string p1,
std::string p2,
std::string p3,
std::string p4,
std::string p5 )
Here is the caller graph for this function:

◆ load_ML_script3()

GameApi::ML GameApi::MainLoopApi::load_ML_script3 ( EveryApi & ev,
std::string url )
Here is the caller graph for this function:

◆ load_ML_script_array()

GameApi::ARR GameApi::MainLoopApi::load_ML_script_array ( EveryApi & ev,
std::string url,
std::string p1,
std::string p2,
std::string p3,
std::string p4,
std::string p5 )
Here is the caller graph for this function:

◆ load_MN_script()

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

◆ load_MN_script2()

GameApi::MN GameApi::MainLoopApi::load_MN_script2 ( EveryApi & ev,
HML h,
std::string p1,
std::string p2,
std::string p3,
std::string p4,
std::string p5 )
Here is the caller graph for this function:

◆ load_MT_script()

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

◆ load_MT_script2()

GameApi::MT GameApi::MainLoopApi::load_MT_script2 ( EveryApi & ev,
HML h,
std::string p1,
std::string p2,
std::string p3,
std::string p4,
std::string p5 )
Here is the caller graph for this function:

◆ load_P_script()

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

◆ load_P_script_array()

GameApi::ARR GameApi::MainLoopApi::load_P_script_array ( EveryApi & ev,
HML hml,
std::string p1,
std::string p2,
std::string p3,
std::string p4,
std::string p5 )
Here is the caller graph for this function:

◆ load_shader()

GameApi::SHC GameApi::MainLoopApi::load_shader ( std::string shader_url)
Here is the caller graph for this function:

◆ load_shader2()

GameApi::ARR GameApi::MainLoopApi::load_shader2 ( std::string vertex_url,
std::string fragment_url )
Here is the caller graph for this function:

◆ load_song()

GameApi::ML GameApi::MainLoopApi::load_song ( EveryApi & ev,
ML next,
std::string url )
Here is the caller graph for this function:

◆ load_um()

GameApi::PKG GameApi::MainLoopApi::load_um ( DS st)

◆ load_zip()

GameApi::ML GameApi::MainLoopApi::load_zip ( EveryApi & ev,
std::string zip_url )
Here is the caller graph for this function:

◆ load_zip2()

GameApi::HML GameApi::MainLoopApi::load_zip2 ( EveryApi & ev,
std::string zip_url )
Here is the caller graph for this function:

◆ load_zip_assets()

GameApi::ML GameApi::MainLoopApi::load_zip_assets ( std::string zip_url)
Here is the caller graph for this function:

◆ load_zip_assets2()

GameApi::HML GameApi::MainLoopApi::load_zip_assets2 ( std::string zip_url)
Here is the caller graph for this function:

◆ lod()

GameApi::ML GameApi::MainLoopApi::lod ( GameApi::EveryApi & ev,
GameApi::P p,
GameApi::MT mat,
GameApi::PTS pts,
float level1,
float level2,
float level3,
float level4,
int l1,
int l2,
int l3,
int l4 )
Here is the caller graph for this function:

◆ lod_anim()

GameApi::ML GameApi::MainLoopApi::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 )
Here is the caller graph for this function:

◆ lod_anim_matrix()

GameApi::ML GameApi::MainLoopApi::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 )
Here is the caller graph for this function:

◆ lod_gpu()

GameApi::ML GameApi::MainLoopApi::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 )
Here is the caller graph for this function:

◆ lod_gpu_matrix()

GameApi::ML GameApi::MainLoopApi::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 )

◆ lod_gpu_matrix_tf()

GameApi::ML GameApi::MainLoopApi::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 )

◆ lod_gpu_pts_tf()

GameApi::ML GameApi::MainLoopApi::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 )

◆ lod_matrix()

GameApi::ML GameApi::MainLoopApi::lod_matrix ( GameApi::EveryApi & ev,
GameApi::P p,
GameApi::MT mat,
GameApi::MS ms,
float level1,
float level2,
float level3,
float level4,
int l1,
int l2,
int l3,
int l4 )
Here is the caller graph for this function:

◆ lod_matrix_tf()

GameApi::ML GameApi::MainLoopApi::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 )
Here is the caller graph for this function:

◆ lod_pts_tf()

GameApi::ML GameApi::MainLoopApi::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 )
Here is the caller graph for this function:

◆ logo_change()

GameApi::ML GameApi::MainLoopApi::logo_change ( ML ml,
BM conn,
BM download,
BM prepare )
Here is the caller graph for this function:

◆ logo_iter()

bool GameApi::MainLoopApi::logo_iter ( )
Here is the caller graph for this function:

◆ looking_glass_full()

GameApi::ML GameApi::MainLoopApi::looking_glass_full ( GameApi::EveryApi & ev,
GameApi::ML ml,
float amount,
int mode,
int start,
int end )
Here is the caller graph for this function:

◆ mainloop_material()

GameApi::MT GameApi::MainLoopApi::mainloop_material ( EveryApi & ev,
ML ml )
Here is the caller graph for this function:

◆ make_current()

EXPORT void GameApi::MainLoopApi::make_current ( )

◆ matrix_range_check()

GameApi::ML GameApi::MainLoopApi::matrix_range_check ( GameApi::EveryApi & ev,
ML ml,
ML ml2,
std::string url )
Here is the caller graph for this function:

◆ memmap_window()

GameApi::ML GameApi::MainLoopApi::memmap_window ( EveryApi & ev,
PKG p )

◆ memmap_window2()

GameApi::ML GameApi::MainLoopApi::memmap_window2 ( GameApi::EveryApi & ev,
std::string url )
Here is the caller graph for this function:

◆ memmap_window3()

GameApi::ML GameApi::MainLoopApi::memmap_window3 ( GameApi::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 )
Here is the caller graph for this function:

◆ mesh_anim_2()

GameApi::ML GameApi::MainLoopApi::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 )

◆ ml_empty()

GameApi::ML GameApi::MainLoopApi::ml_empty ( )
Here is the caller graph for this function:

◆ ml_load_um()

GameApi::ML GameApi::MainLoopApi::ml_load_um ( GameApi::EveryApi & ev,
std::string url )

◆ mouse_roll_zoom()

GameApi::ML GameApi::MainLoopApi::mouse_roll_zoom ( EveryApi & ev,
ML next )
Here is the caller graph for this function:

◆ mouse_roll_zoom2()

GameApi::ML GameApi::MainLoopApi::mouse_roll_zoom2 ( EveryApi & ev,
ML nect )
Here is the caller graph for this function:

◆ move_collision()

GameApi::INP GameApi::MainLoopApi::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 )
Here is the caller graph for this function:

◆ move_in()

GameApi::ML GameApi::MainLoopApi::move_in ( EveryApi & ev,
ML ml,
INP in )
Here is the caller graph for this function:

◆ move_sequence()

GameApi::INP GameApi::MainLoopApi::move_sequence ( float start_time,
float time_per_char,
std::string str )
Here is the caller graph for this function:

◆ move_speed()

GameApi::INP GameApi::MainLoopApi::move_speed ( INP orig,
float speed )
Here is the caller graph for this function:

◆ network()

GameApi::MB GameApi::MainLoopApi::network ( std::string url,
std::string homapge )

◆ no_concurrent_download()

GameApi::ML GameApi::MainLoopApi::no_concurrent_download ( ML ml)
Here is the caller graph for this function:

◆ no_concurrent_download_run()

IMPORT RUN GameApi::MainLoopApi::no_concurrent_download_run ( RUN r)

◆ nvidia_init()

EXPORT void GameApi::MainLoopApi::nvidia_init ( )
Here is the caller graph for this function:

◆ ogl_set_frame_rate()

GameApi::ML GameApi::MainLoopApi::ogl_set_frame_rate ( GameApi::ML ml,
int fps )
Here is the caller graph for this function:

◆ or_elem_ml()

EXPORT GameApi::ML GameApi::MainLoopApi::or_elem_ml ( GameApi::EveryApi & ev,
ML m1,
ML m2 )
Here is the caller graph for this function:

◆ outline_disable()

EXPORT void GameApi::MainLoopApi::outline_disable ( )

◆ outline_first()

EXPORT void GameApi::MainLoopApi::outline_first ( )

◆ outline_second()

EXPORT void GameApi::MainLoopApi::outline_second ( )

◆ outline_third()

EXPORT void GameApi::MainLoopApi::outline_third ( )

◆ p_script2()

GameApi::P GameApi::MainLoopApi::p_script2 ( EveryApi & ev,
HML h,
std::string p1,
std::string p2,
std::string p3,
std::string p4,
std::string p5 )
Here is the caller graph for this function:

◆ parse_areatype()

GameApi::ML GameApi::MainLoopApi::parse_areatype ( GameApi::EveryApi & ev,
std::string url,
GameApi::FB heightmap,
GameApi::BM top_texture,
GameApi::BM side_texture )
Here is the caller graph for this function:

◆ perspective()

GameApi::ML GameApi::MainLoopApi::perspective ( EveryApi & ev,
ML next,
float mult,
float front_plane,
float end_plane )
Here is the caller graph for this function:

◆ phong_fragment()

GameApi::SHI GameApi::MainLoopApi::phong_fragment ( SHI next,
unsigned int ambient,
unsigned int highlight,
float pow )
Here is the caller graph for this function:

◆ phong_shader3()

GameApi::ML GameApi::MainLoopApi::phong_shader3 ( GameApi::EveryApi & ev,
ML ml,
unsigned int ambient,
unsigned int highlight,
float pow )

◆ phong_vertex()

GameApi::SHI GameApi::MainLoopApi::phong_vertex ( SHI next)
Here is the caller graph for this function:

◆ playback_keypresses()

GameApi::ML GameApi::MainLoopApi::playback_keypresses ( ML ml,
std::string input_url )
Here is the caller graph for this function:

◆ prepare_pts()

GameApi::ML GameApi::MainLoopApi::prepare_pts ( ML ml,
PTS pts )

◆ print_deps()

GameApi::ML GameApi::MainLoopApi::print_deps ( ML ml,
int num )
Here is the caller graph for this function:

◆ print_profile()

EXPORT void GameApi::MainLoopApi::print_profile ( )

◆ print_stats()

GameApi::ML GameApi::MainLoopApi::print_stats ( P p)
Here is the caller graph for this function:

◆ print_time_sync()

GameApi::ML GameApi::MainLoopApi::print_time_sync ( ML ml)
Here is the caller graph for this function:

◆ profile()

EXPORT void GameApi::MainLoopApi::profile ( std::string label,
bool start )

◆ progress_bar_config()

GameApi::ML GameApi::MainLoopApi::progress_bar_config ( GameApi::ML ml,
bool progress_impl,
bool max_impl,
bool install_impl,
float mult_ems0,
float mult_ems1,
float mult_ems2,
float mult_builder )
Here is the caller graph for this function:

◆ pts_world()

GameApi::W GameApi::MainLoopApi::pts_world ( PTS p,
int type )

◆ rand_max()

EXPORT unsigned int GameApi::MainLoopApi::rand_max ( )
Here is the caller graph for this function:

◆ random()

EXPORT unsigned int GameApi::MainLoopApi::random ( )
Here is the caller graph for this function:

◆ random_dir_vector_2d_xy()

EXPORT GameApi::V GameApi::MainLoopApi::random_dir_vector_2d_xy ( float length)

◆ random_dir_vector_2d_xz()

EXPORT GameApi::V GameApi::MainLoopApi::random_dir_vector_2d_xz ( float length)

◆ random_dir_vector_3d()

EXPORT GameApi::V GameApi::MainLoopApi::random_dir_vector_3d ( float length)

◆ random_game_seq()

GameApi::ML GameApi::MainLoopApi::random_game_seq ( float time_step,
MN mn,
std::vector< ML > true_vec,
std::vector< ML > false_vec,
float perc,
int num_levels )
Here is the caller graph for this function:

◆ random_instantiate()

GameApi::ML GameApi::MainLoopApi::random_instantiate ( GameApi::EveryApi & ev,
GameApi::ML ml,
std::vector< MN > vec,
float start_time,
float time_step,
float random_chance )
Here is the caller graph for this function:

◆ random_point_2d()

EXPORT GameApi::PT GameApi::MainLoopApi::random_point_2d ( float start_x,
float end_x,
float start_y,
float end_y,
float z )

◆ random_point_3d()

EXPORT GameApi::PT GameApi::MainLoopApi::random_point_3d ( float start_x,
float end_x,
float start_y,
float end_y,
float start_z,
float end_z )

◆ read_obj_pos()

GameApi::ML GameApi::MainLoopApi::read_obj_pos ( std::string url)
Here is the caller graph for this function:

◆ record_keypresses()

GameApi::ML GameApi::MainLoopApi::record_keypresses ( ML ml,
std::string output_filename )
Here is the caller graph for this function:

◆ render_txid()

GameApi::ML GameApi::MainLoopApi::render_txid ( EveryApi & ev,
P p1,
TXID I7,
int size )
Here is the caller graph for this function:

◆ reset_time()

EXPORT void GameApi::MainLoopApi::reset_time ( )

◆ resize_and_anim_transfer_id()

GameApi::ARR GameApi::MainLoopApi::resize_and_anim_transfer_id ( )
Here is the caller graph for this function:

◆ resize_transfer_id()

GameApi::TRR GameApi::MainLoopApi::resize_transfer_id ( GameApi::TRB id)
Here is the caller graph for this function:

◆ restart_game()

GameApi::ML GameApi::MainLoopApi::restart_game ( GameApi::EveryApi & ev,
GameApi::ML ml,
int key )
Here is the caller graph for this function:

◆ restart_screen()

GameApi::ML GameApi::MainLoopApi::restart_screen ( EveryApi & ev,
ML ml,
std::string fontname )
Here is the caller graph for this function:

◆ right_mouse_pan()

GameApi::ML GameApi::MainLoopApi::right_mouse_pan ( EveryApi & ev,
ML next )
Here is the caller graph for this function:

◆ save_deploy()

GameApi::ML GameApi::MainLoopApi::save_deploy ( HML h,
std::string filename,
GameApi::EveryApi & ev )
Here is the caller graph for this function:

◆ save_deploy2()

GameApi::ML GameApi::MainLoopApi::save_deploy2 ( EveryApi & ev,
RUN run,
std::string homepage,
bool is_in_arr,
std::string filename )
Here is the caller graph for this function:

◆ save_ds()

void GameApi::MainLoopApi::save_ds ( std::string output_filename,
DS ds )

◆ save_ds_ml()

GameApi::ML GameApi::MainLoopApi::save_ds_ml ( GameApi::EveryApi & ev,
std::string output_filename,
P p,
bool disable_normal,
bool disable_color,
bool disable_texcoord,
bool disable_texcoord3,
bool disable_objects )
Here is the caller graph for this function:

◆ save_ds_store()

void GameApi::MainLoopApi::save_ds_store ( std::string filename,
DS ds )

◆ save_glb_store()

void GameApi::MainLoopApi::save_glb_store ( GameApi::EveryApi & ev,
std::string filename,
TF tf )

◆ save_gltf()

GameApi::ML GameApi::MainLoopApi::save_gltf ( TF tf,
std::string filename )

◆ save_logo()

void GameApi::MainLoopApi::save_logo ( EveryApi & ev)

◆ save_png_store()

void GameApi::MainLoopApi::save_png_store ( std::string filename,
BM bm )

◆ save_script()

GameApi::ML GameApi::MainLoopApi::save_script ( HML h,
std::string filename )
Here is the caller graph for this function:

◆ scale_2d_screen()

GameApi::ML GameApi::MainLoopApi::scale_2d_screen ( GameApi::EveryApi & ev,
ML orig,
float sx,
float sy )
Here is the caller graph for this function:

◆ scene_transparency()

GameApi::ML GameApi::MainLoopApi::scene_transparency ( ML scene)
Here is the caller graph for this function:

◆ score_adder()

GameApi::ML GameApi::MainLoopApi::score_adder ( EveryApi & ev,
ML ml,
O o,
MN transform,
int enter_score,
int leave_score,
int dyn_point,
float timeout )
Here is the caller graph for this function:

◆ score_adder2()

GameApi::ML GameApi::MainLoopApi::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 )
Here is the caller graph for this function:

◆ score_display()

GameApi::ML GameApi::MainLoopApi::score_display ( EveryApi & ev,
ML ml,
std::string font )
Here is the caller graph for this function:

◆ score_hidder()

GameApi::ML GameApi::MainLoopApi::score_hidder ( EveryApi & ev,
ML ml,
O o,
int max_count )
Here is the caller graph for this function:

◆ score_hide_pts()

GameApi::PTS GameApi::MainLoopApi::score_hide_pts ( PTS pts)
Here is the caller graph for this function:

◆ score_set_hide()

GameApi::IF GameApi::MainLoopApi::score_set_hide ( )
Here is the caller graph for this function:

◆ screenshot()

EXPORT GameApi::BM GameApi::MainLoopApi::screenshot ( )

◆ screenspace()

GameApi::SP GameApi::MainLoopApi::screenspace ( )
Here is the caller graph for this function:

◆ screenspace_rendering()

GameApi::ML GameApi::MainLoopApi::screenspace_rendering ( EveryApi & ev,
ML scene,
SMT screenspace_material )
Here is the caller graph for this function:

◆ seamless_iter()

bool GameApi::MainLoopApi::seamless_iter ( )

◆ send_key_at_time()

GameApi::ML GameApi::MainLoopApi::send_key_at_time ( ML ml,
float time,
int key )
Here is the caller graph for this function:

◆ seq_ml()

GameApi::ML GameApi::MainLoopApi::seq_ml ( std::vector< ML > vec,
float time )
Here is the caller graph for this function:

◆ seq_ml_score()

GameApi::ML GameApi::MainLoopApi::seq_ml_score ( ML ml1,
ML ml2,
int score )
Here is the caller graph for this function:

◆ set_corner()

EXPORT void GameApi::MainLoopApi::set_corner ( int x,
int y,
int screen_sx,
int screen_sy )
Here is the caller graph for this function:

◆ set_homepage_url()

void GameApi::MainLoopApi::set_homepage_url ( std::string url)

◆ set_screen_size()

EXPORT void GameApi::MainLoopApi::set_screen_size ( int sx,
int sy )

◆ set_seamless_url()

void GameApi::MainLoopApi::set_seamless_url ( std::string url)

◆ set_viewport()

void GameApi::MainLoopApi::set_viewport ( int x,
int y,
int sx,
int sy )

◆ setup_hmd_projection()

EXPORT GameApi::ML GameApi::MainLoopApi::setup_hmd_projection ( EveryApi & ev,
ML ml,
bool eye,
bool is_standard,
float n,
float f,
bool translate )
Here is the caller graph for this function:

◆ shader_cache_disable()

EXPORT GameApi::ML GameApi::MainLoopApi::shader_cache_disable ( ML ml,
bool disable )
Here is the caller graph for this function:

◆ skybox()

GameApi::ML GameApi::MainLoopApi::skybox ( EveryApi & ev,
BM land,
BM sky )
Here is the caller graph for this function:

◆ slow_activate_item()

GameApi::ML GameApi::MainLoopApi::slow_activate_item ( ML ml,
int i )
Here is the caller graph for this function:

◆ slow_start_array_ml()

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

◆ small_window()

GameApi::ML GameApi::MainLoopApi::small_window ( EveryApi & ev,
ML ml,
int x,
int y,
int sx,
int sy )
Here is the caller graph for this function:

◆ start_editor_state()

EXPORT void GameApi::MainLoopApi::start_editor_state ( )

◆ state_int_fetcher()

GameApi::IF GameApi::MainLoopApi::state_int_fetcher ( std::string url,
std::string states )
Here is the caller graph for this function:

◆ state_speed_movement()

GameApi::MN GameApi::MainLoopApi::state_speed_movement ( MN mn,
std::string url,
std::string states,
std::string x_speeds,
std::string y_speeds,
std::string z_speeds )
Here is the caller graph for this function:

◆ step()

EXPORT void GameApi::MainLoopApi::step ( )
Here is the caller graph for this function:

◆ string_bytestore()

GameApi::BS GameApi::MainLoopApi::string_bytestore ( std::string s)
Here is the caller graph for this function:

◆ subworld()

GameApi::CX GameApi::MainLoopApi::subworld ( CX c,
W w,
int start_block,
int end_block )

◆ swapbuffers()

EXPORT void GameApi::MainLoopApi::swapbuffers ( )
Here is the caller graph for this function:

◆ switch_to_3d()

EXPORT void GameApi::MainLoopApi::switch_to_3d ( bool b,
SH sh,
int screen_width = 800.,
int screen_height = 600 )
Here is the caller graph for this function:

◆ t_repeat()

GameApi::TT GameApi::MainLoopApi::t_repeat ( TT prev,
TT curr_to_repeated,
int count )
Here is the caller graph for this function:

◆ tf_join()

GameApi::TF GameApi::MainLoopApi::tf_join ( GameApi::EveryApi & ev,
TF tf )
Here is the caller graph for this function:

◆ time_display()

GameApi::ML GameApi::MainLoopApi::time_display ( EveryApi & ev,
ML ml,
std::string font,
float start_time )
Here is the caller graph for this function:

◆ timed_shp_f()

GameApi::SHP GameApi::MainLoopApi::timed_shp_f ( float start_time,
float end_time,
SHP next,
int num,
float start_value,
float end_value )
Here is the caller graph for this function:

◆ timed_shp_i()

GameApi::SHP GameApi::MainLoopApi::timed_shp_i ( float start_time,
float end_time,
SHP next,
int num,
int start_value,
int end_value )
Here is the caller graph for this function:

◆ timed_shp_p3d()

GameApi::SHP GameApi::MainLoopApi::timed_shp_p3d ( float start_time,
float end_time,
SHP next,
int num,
PT start_value,
PT end_value )
Here is the caller graph for this function:

◆ timed_shp_u()

GameApi::SHP GameApi::MainLoopApi::timed_shp_u ( float start_time,
float end_time,
SHP next,
int num,
unsigned int start_value,
unsigned int end_value )
Here is the caller graph for this function:

◆ timed_shp_uvw()

GameApi::SHP GameApi::MainLoopApi::timed_shp_uvw ( float start_time,
float end_time,
SHP next,
int num,
PT start_value,
PT end_value )
Here is the caller graph for this function:

◆ timed_tmp_seq_ml()

GameApi::ML GameApi::MainLoopApi::timed_tmp_seq_ml ( ML curr,
ML end,
float start_time,
float end_time,
float show_duration,
int key )
Here is the caller graph for this function:

◆ timing()

GameApi::TT GameApi::MainLoopApi::timing ( float duration,
TT link,
ML show )
Here is the caller graph for this function:

◆ timing_event()

GameApi::TT GameApi::MainLoopApi::timing_event ( IF fetch,
TT timing,
ML show )
Here is the caller graph for this function:

◆ timing_exit()

GameApi::ML GameApi::MainLoopApi::timing_exit ( TT link)
Here is the caller graph for this function:

◆ timing_start()

GameApi::TT GameApi::MainLoopApi::timing_start ( )
Here is the caller graph for this function:

◆ timing_switch()

GameApi::TT GameApi::MainLoopApi::timing_switch ( EveryApi & ev,
float duration,
TT link,
ML show,
ML show2,
int switch_dir )
Here is the caller graph for this function:

◆ touch_rotate()

GameApi::ML GameApi::MainLoopApi::touch_rotate ( GameApi::EveryApi & ev,
ML ml,
bool leftright,
bool topdown,
float x_speed,
float y_speed )
Here is the caller graph for this function:

◆ transfer_id()

GameApi::TRB GameApi::MainLoopApi::transfer_id ( )
Here is the caller graph for this function:

◆ transfer_sdl_surface()

EXPORT void GameApi::MainLoopApi::transfer_sdl_surface ( MainLoopApi & orig)

◆ transparency()

EXPORT void GameApi::MainLoopApi::transparency ( bool enabled)

◆ transparent()

GameApi::ML GameApi::MainLoopApi::transparent ( ML ml)
Here is the caller graph for this function:

◆ tunnel_tree()

GameApi::ML GameApi::MainLoopApi::tunnel_tree ( EveryApi & ev,
std::vector< P > faces,
std::vector< MN > moves,
std::string url,
MT mat2 )
Here is the caller graph for this function:

◆ turn_to_meters()

EXPORT GameApi::ML GameApi::MainLoopApi::turn_to_meters ( EveryApi & ev,
ML ml,
float sx1,
float sx2,
float sy1,
float sy2,
float sz1,
float sz2 )
Here is the caller graph for this function:

◆ turn_to_meters_default()

EXPORT GameApi::ML GameApi::MainLoopApi::turn_to_meters_default ( EveryApi & ev,
ML ml,
P p )
Here is the caller graph for this function:

◆ vr_scale()

GameApi::ML GameApi::MainLoopApi::vr_scale ( GameApi::ML ml,
float box300_to_meters_scale )

◆ waittof()

IMPORT void GameApi::MainLoopApi::waittof ( )

◆ web_link()

GameApi::ML GameApi::MainLoopApi::web_link ( EveryApi & ev,
ML item,
ML highlighted_item,
float pt_x,
float pt_y,
float pt_z,
float radius,
std::string url )
Here is the caller graph for this function:

◆ whack_a_mole_collision()

GameApi::ML GameApi::MainLoopApi::whack_a_mole_collision ( GameApi::ML ml)
Here is the caller graph for this function:

◆ whack_a_mole_explosion()

GameApi::PTS GameApi::MainLoopApi::whack_a_mole_explosion ( GameApi::EveryApi & ev)
Here is the caller graph for this function:

◆ whack_a_mole_flag_bmchooser()

GameApi::ML GameApi::MainLoopApi::whack_a_mole_flag_bmchooser ( GameApi::ML ml)
Here is the caller graph for this function:
The documentation for this class was generated from the following files: