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

#include <GameApi.hh>

Public Types

enum  HeightMapType { EQuad , ETriangle }

Public Member Functions

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)
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)
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)
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 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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
IMPORT P single_texture (P orig, BM texture)
IMPORT P anim_array (P *array, int size)
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)
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)
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)
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)
IMPORT void render_vertex_array (VA va)
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)
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)
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 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 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)
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)
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)
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)
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)

Member Enumeration Documentation

◆ HeightMapType

enum GameApi::PolygonApi::HeightMapType
Enumerator
EQuad 
ETriangle 

Constructor & Destructor Documentation

◆ PolygonApi()

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

◆ ~PolygonApi()

EXPORT GameApi::PolygonApi::~PolygonApi ( )

Member Function Documentation

◆ acesfilm_shader()

EXPORT GameApi::ML GameApi::PolygonApi::acesfilm_shader ( EveryApi & ev,
ML mainloop )

◆ adjust_shader()

EXPORT GameApi::ML GameApi::PolygonApi::adjust_shader ( EveryApi & ev,
ML mainloop,
unsigned int ad_color,
float ad_dark,
float ad_light )

◆ alt()

EXPORT GameApi::P GameApi::PolygonApi::alt ( std::vector< P > vec,
int index )
Here is the caller graph for this function:

◆ ambient_occulsion_color()

GameApi::P GameApi::PolygonApi::ambient_occulsion_color ( P p)
Here is the caller graph for this function:

◆ ambient_shader()

IMPORT ML GameApi::PolygonApi::ambient_shader ( EveryApi & ev,
ML mainloop,
int ambient_color_id,
float ambient_level )

◆ and_not_elem()

EXPORT GameApi::P GameApi::PolygonApi::and_not_elem ( EveryApi & ev,
P p1,
P p_not,
O o1,
O o_not,
CT cutter1,
CT cutter_not )

◆ anim()

GameApi::ML GameApi::PolygonApi::anim ( EveryApi & ev,
ML next,
MA anim,
float start_time,
float delta_time,
int count )
Here is the caller graph for this function:

◆ anim_array()

EXPORT GameApi::P GameApi::PolygonApi::anim_array ( P * array,
int size )
Here is the caller graph for this function:

◆ anim_bind()

GameApi::ML GameApi::PolygonApi::anim_bind ( EveryApi & ev,
ML next,
MA anim,
MT material,
float start_time,
float delta_time,
int count )
Here is the caller graph for this function:

◆ anim_endpoints()

EXPORT GameApi::P GameApi::PolygonApi::anim_endpoints ( P p1,
P p2 )

◆ anim_interpolate()

EXPORT GameApi::P GameApi::PolygonApi::anim_interpolate ( P p,
float val )

◆ anim_render()

IMPORT ML GameApi::PolygonApi::anim_render ( AA ,
float delta )

◆ anim_target_matrix()

IMPORT P GameApi::PolygonApi::anim_target_matrix ( P p,
M matrix )

◆ anim_target_scale()

EXPORT GameApi::P GameApi::PolygonApi::anim_target_scale ( P p,
PT center,
float scale_x,
float scale_y,
float scale_z )

◆ anim_target_vector()

EXPORT GameApi::P GameApi::PolygonApi::anim_target_vector ( P p,
V v )

◆ array_lighting()

IMPORT L GameApi::PolygonApi::array_lighting ( L * array,
int size )

◆ array_p_array()

GameApi::ARR GameApi::PolygonApi::array_p_array ( std::vector< PV > vec)
Here is the caller graph for this function:

◆ array_pl()

GameApi::PL GameApi::PolygonApi::array_pl ( std::vector< PL > vec)
Here is the caller graph for this function:

◆ attach_cache()

GameApi::ATT GameApi::PolygonApi::attach_cache ( ATT a,
P p )
Here is the caller graph for this function:

◆ attrib_function()

EXPORT GameApi::P GameApi::PolygonApi::attrib_function ( P p1,
std::function< float(int face, int point, int idx)> f,
int idx )

◆ attribi_function()

EXPORT GameApi::P GameApi::PolygonApi::attribi_function ( P p1,
std::function< int(int face, int point, int idx)> f,
int idx )

◆ av_unique()

GameApi::AV GameApi::PolygonApi::av_unique ( AV arr)
Here is the caller graph for this function:

◆ average_normals()

EXPORT GameApi::P GameApi::PolygonApi::average_normals ( P orig,
int sx,
int sy )
Here is the caller graph for this function:

◆ bar_chart()

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

◆ bar_chart2()

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

◆ bg_image()

EXPORT GameApi::ML GameApi::PolygonApi::bg_image ( EveryApi & ev,
BM bm )
Here is the caller graph for this function:

◆ bitmapsized_quad()

EXPORT GameApi::P GameApi::PolygonApi::bitmapsized_quad ( BM bm)
Here is the caller graph for this function:

◆ block_divide()

GameApi::ARR GameApi::PolygonApi::block_divide ( P p,
float pos_x,
float pos_z,
int sx,
int sz,
float delta_x,
float delta_z )
Here is the caller graph for this function:

◆ block_draw()

GameApi::ML GameApi::PolygonApi::block_draw ( std::vector< ML > vec,
float pos_x,
float pos_z,
int sx,
int sz,
float delta_x,
float delta_z,
int view )
Here is the caller graph for this function:

◆ block_render()

GameApi::ARR GameApi::PolygonApi::block_render ( GameApi::EveryApi & ev,
std::vector< P > vec,
MT mat )
Here is the caller graph for this function:

◆ block_render2()

GameApi::ARR GameApi::PolygonApi::block_render2 ( GameApi::EveryApi & ev,
std::vector< P > vec,
std::vector< MT > mat )
Here is the caller graph for this function:

◆ bloom1_shader()

GameApi::ML GameApi::PolygonApi::bloom1_shader ( EveryApi & ev,
ML mainloop,
float r_val,
float g_val,
float b_val )
Here is the caller graph for this function:

◆ bloom_cut_sbm()

GameApi::SBM GameApi::PolygonApi::bloom_cut_sbm ( SBM texture,
float r,
float g,
float b )
Here is the caller graph for this function:

◆ blur_sbm()

GameApi::SBM GameApi::PolygonApi::blur_sbm ( SBM texture,
float pixel_x,
float pixel_y )
Here is the caller graph for this function:

◆ blur_shader()

GameApi::ML GameApi::PolygonApi::blur_shader ( EveryApi & ev,
ML mainloop,
float x_val,
float y_val )
Here is the caller graph for this function:

◆ blurred_render_shader()

EXPORT GameApi::ML GameApi::PolygonApi::blurred_render_shader ( EveryApi & ev,
ML mainloop,
int numsamples,
float blur_radius )

◆ build_offsets()

GameApi::P GameApi::PolygonApi::build_offsets ( P p,
std::vector< PT > vec )
Here is the caller graph for this function:

◆ bump_phong_shader()

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

◆ change_colors()

EXPORT GameApi::P GameApi::PolygonApi::change_colors ( P orig,
std::function< unsigned int(unsigned int orig, int face, int point)> f )

◆ change_normals()

EXPORT GameApi::P GameApi::PolygonApi::change_normals ( P orig,
std::function< V(V orig, int face, int point)> f )

◆ change_positions()

EXPORT GameApi::P GameApi::PolygonApi::change_positions ( P orig,
std::function< PT(PT p, int face, int point)> f )
Here is the caller graph for this function:

◆ change_texture()

EXPORT GameApi::P GameApi::PolygonApi::change_texture ( P orig,
std::function< int(int face)> f,
BM * array,
int size )

◆ choose_color_shader()

EXPORT GameApi::ML GameApi::PolygonApi::choose_color_shader ( EveryApi & ev,
ML mainloop,
unsigned int color,
float mix_val )
Here is the caller graph for this function:

◆ choose_texture()

EXPORT GameApi::P GameApi::PolygonApi::choose_texture ( P orig,
int num )
Here is the caller graph for this function:

◆ choose_time()

GameApi::ML GameApi::PolygonApi::choose_time ( ML next,
std::vector< ML > vec,
float delta_time )
Here is the caller graph for this function:

◆ circular_span()

EXPORT GameApi::P GameApi::PolygonApi::circular_span ( EveryApi & ev,
LI li,
float delta_angle_around_y_axis,
int num_steps )

◆ clone()

EXPORT void GameApi::PolygonApi::clone ( VA va)

◆ color()

EXPORT GameApi::P GameApi::PolygonApi::color ( P orig,
unsigned int color )
Here is the caller graph for this function:

◆ color_alpha()

EXPORT GameApi::P GameApi::PolygonApi::color_alpha ( P orig,
unsigned int alpha )
Here is the caller graph for this function:

◆ color_cube()

EXPORT GameApi::P GameApi::PolygonApi::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 )

◆ color_distance()

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

◆ color_faces()

EXPORT GameApi::P GameApi::PolygonApi::color_faces ( P orig,
unsigned int color_1,
unsigned int color_2,
unsigned int color_3,
unsigned int color_4 )
Here is the caller graph for this function:

◆ color_from_normals()

EXPORT GameApi::P GameApi::PolygonApi::color_from_normals ( P orig)
Here is the caller graph for this function:

◆ color_from_texcoord()

EXPORT GameApi::P GameApi::PolygonApi::color_from_texcoord ( P orig,
unsigned int color_1,
unsigned int color_2,
unsigned int color_3,
unsigned int color_4 )
Here is the caller graph for this function:

◆ color_function()

EXPORT GameApi::P GameApi::PolygonApi::color_function ( P p1,
std::function< unsigned int(int face, int point)> f )

◆ color_grayscale()

EXPORT GameApi::P GameApi::PolygonApi::color_grayscale ( P orig)
Here is the caller graph for this function:

◆ color_lambert()

EXPORT GameApi::P GameApi::PolygonApi::color_lambert ( P orig,
unsigned int color,
float light_dir_x,
float light_dir_y,
float light_dir_z,
float pow,
float intensity )
Here is the caller graph for this function:

◆ color_lighting()

IMPORT L GameApi::PolygonApi::color_lighting ( float dx,
float dy,
float dz,
int r,
int g,
int b,
int a )

◆ color_map()

EXPORT GameApi::P GameApi::PolygonApi::color_map ( BM bm,
float start_x,
float end_x,
float start_y,
float end_y,
float z )
Here is the caller graph for this function:

◆ color_map2()

EXPORT GameApi::P GameApi::PolygonApi::color_map2 ( BM bm,
PT pos,
V u_x,
V u_y )

◆ color_map3() [1/2]

EXPORT GameApi::P GameApi::PolygonApi::color_map3 ( BM bm,
FB height,
float sx,
float sy,
float z )

◆ color_map3() [2/2]

EXPORT GameApi::P GameApi::PolygonApi::color_map3 ( BM bm,
FB height,
PT pos,
V u_x,
V u_y )
Here is the caller graph for this function:

◆ color_map3_cyl() [1/2]

EXPORT GameApi::P GameApi::PolygonApi::color_map3_cyl ( BM bm,
FB height,
float sx,
float sy,
float z )

◆ color_map3_cyl() [2/2]

EXPORT GameApi::P GameApi::PolygonApi::color_map3_cyl ( BM bm,
FB height,
PT pos,
V u_x,
V u_y )
Here is the caller graph for this function:

◆ color_map3_sph() [1/2]

EXPORT GameApi::P GameApi::PolygonApi::color_map3_sph ( BM bm,
FB height,
float sx,
float sy,
float z )

◆ color_map3_sph() [2/2]

EXPORT GameApi::P GameApi::PolygonApi::color_map3_sph ( BM bm,
FB height,
PT pos,
V u_x,
V u_y )
Here is the caller graph for this function:

◆ color_map4()

IMPORT P GameApi::PolygonApi::color_map4 ( BM bm,
FB height,
float sx,
float sy,
float z )

◆ color_poly()

IMPORT P GameApi::PolygonApi::color_poly ( P orig,
int facenum,
unsigned int * array,
int size )

◆ color_range()

EXPORT GameApi::P GameApi::PolygonApi::color_range ( P orig,
unsigned int source_upper,
unsigned int source_lower,
unsigned int upper_range,
unsigned int lower_range )
Here is the caller graph for this function:

◆ color_voxel()

EXPORT GameApi::P GameApi::PolygonApi::color_voxel ( P orig,
VX colours,
PT p,
V u_x,
V u_y,
V u_z )

◆ colormix_shader()

IMPORT ML GameApi::PolygonApi::colormix_shader ( EveryApi & ev,
ML mainloop,
float mix )

◆ colour_shader()

EXPORT GameApi::ML GameApi::PolygonApi::colour_shader ( EveryApi & ev,
ML mainloop,
float mix )

◆ coloured_lights_shader()

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

◆ colourspace_facecoll()

GameApi::P GameApi::PolygonApi::colourspace_facecoll ( CSI i,
float t )
Here is the caller graph for this function:

◆ colourspace_func()

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

◆ colourspace_or_elem()

GameApi::CS GameApi::PolygonApi::colourspace_or_elem ( CS cs,
float delta_t,
CS cs2,
float delta_t2 )
Here is the caller graph for this function:

◆ colourspace_sample()

GameApi::CSI GameApi::PolygonApi::colourspace_sample ( CS i,
int sx,
int sy,
int sz )
Here is the caller graph for this function:

◆ colourspace_sphere2()

GameApi::CS GameApi::PolygonApi::colourspace_sphere2 ( )
Here is the caller graph for this function:

◆ comb_mat()

GameApi::ARR GameApi::PolygonApi::comb_mat ( GameApi::EveryApi & ev,
std::vector< MT > vec1,
std::vector< MT > vec2 )
Here is the caller graph for this function:

◆ combine_anim()

GameApi::P GameApi::PolygonApi::combine_anim ( P p1,
P p2,
float start_time,
float end_time )
Here is the caller graph for this function:

◆ combine_sbm()

GameApi::SBM GameApi::PolygonApi::combine_sbm ( SBM texture1,
SBM texture2 )
Here is the caller graph for this function:

◆ combine_textures()

GameApi::P GameApi::PolygonApi::combine_textures ( GameApi::P p1,
GameApi::P p2 )
Here is the caller graph for this function:

◆ cone()

EXPORT GameApi::P GameApi::PolygonApi::cone ( int numfaces,
PT p1,
PT p2,
float rad1,
float rad2 )
Here is the caller graph for this function:

◆ cone_anim()

GameApi::P GameApi::PolygonApi::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 )

◆ convex_hull()

GameApi::P GameApi::PolygonApi::convex_hull ( PTS pts)
Here is the caller graph for this function:

◆ count_function()

EXPORT GameApi::P GameApi::PolygonApi::count_function ( P p1,
std::function< int(int face)> f )

◆ counts()

EXPORT GameApi::P GameApi::PolygonApi::counts ( P p1,
int numfaces )

◆ create_dynamic_geometry()

EXPORT GameApi::P GameApi::PolygonApi::create_dynamic_geometry ( GameApi::P * array,
int size )

◆ create_static_geometry()

EXPORT GameApi::P GameApi::PolygonApi::create_static_geometry ( GameApi::P * array,
int size )

◆ create_vertex_array()

EXPORT GameApi::VA GameApi::PolygonApi::create_vertex_array ( GameApi::P p,
bool keep = false )
Here is the caller graph for this function:

◆ create_vertex_array_attribs()

EXPORT GameApi::VA GameApi::PolygonApi::create_vertex_array_attribs ( GameApi::P p,
bool keep,
std::vector< int > attribs,
std::vector< int > attribi )

◆ create_vertex_array_hw()

EXPORT void GameApi::PolygonApi::create_vertex_array_hw ( GameApi::VA va)

◆ cube() [1/2]

EXPORT GameApi::P GameApi::PolygonApi::cube ( float start_x,
float end_x,
float start_y,
float end_y,
float start_z,
float end_z )
Here is the caller graph for this function:

◆ cube() [2/2]

EXPORT GameApi::P GameApi::PolygonApi::cube ( PT * p)

◆ cube_anim()

GameApi::P GameApi::PolygonApi::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 )

◆ cube_map()

IMPORT P GameApi::PolygonApi::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 )

◆ cullface()

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

◆ curve_group_from_anim()

GameApi::CG GameApi::PolygonApi::curve_group_from_anim ( MA ma,
float start_time,
float end_time )
Here is the caller graph for this function:

◆ curve_to_poly()

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

◆ custom_shader()

EXPORT GameApi::ML GameApi::PolygonApi::custom_shader ( EveryApi & ev,
ML mainloop,
std::string v_shader,
std::string f_shader,
std::string v_funcname,
std::string f_funcname )
Here is the caller graph for this function:

◆ cut_faces()

EXPORT GameApi::P GameApi::PolygonApi::cut_faces ( P p,
O o,
CT cutter )
Here is the caller graph for this function:

◆ decimate()

GameApi::P GameApi::PolygonApi::decimate ( GameApi::P p,
float val )

◆ decimate2()

GameApi::P GameApi::PolygonApi::decimate2 ( GameApi::P p,
float val )
Here is the caller graph for this function:

◆ decimate3()

GameApi::P GameApi::PolygonApi::decimate3 ( GameApi::P faces,
float val )
Here is the caller graph for this function:

◆ decimate3_inv()

GameApi::P GameApi::PolygonApi::decimate3_inv ( GameApi::P faces,
float val )
Here is the caller graph for this function:

◆ decimate_tf()

GameApi::TF GameApi::PolygonApi::decimate_tf ( TF mesh,
float val )
Here is the caller graph for this function:

◆ decimate_tf_zero()

GameApi::TF GameApi::PolygonApi::decimate_tf_zero ( TF mesh)
Here is the caller graph for this function:

◆ decimate_without_holes()

GameApi::P GameApi::PolygonApi::decimate_without_holes ( GameApi::EveryApi & ev,
GameApi::P faces,
float val,
int count,
float cubesize,
std::vector< BM > textures )

◆ decimate_zeros()

IMPORT P GameApi::PolygonApi::decimate_zeros ( P p)
Here is the caller graph for this function:

◆ deform()

EXPORT GameApi::P GameApi::PolygonApi::deform ( P obj,
O bools,
float dx,
float dy,
float dz )
Here is the caller graph for this function:

◆ delete_vertex_array()

EXPORT void GameApi::PolygonApi::delete_vertex_array ( GameApi::VA va)

◆ disc()

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

◆ discard_shader()

EXPORT GameApi::ML GameApi::PolygonApi::discard_shader ( EveryApi & ev,
ML mainloop )

◆ dist_field_mesh_shader()

EXPORT GameApi::ML GameApi::PolygonApi::dist_field_mesh_shader ( EveryApi & ev,
ML mainloop,
SFO sfo )

◆ dist_from_lines()

EXPORT GameApi::P GameApi::PolygonApi::dist_from_lines ( LI li,
float d1,
float d2,
PT center )

◆ dither_shader()

GameApi::ML GameApi::PolygonApi::dither_shader ( EveryApi & ev,
ML mainloop )
Here is the caller graph for this function:

◆ ds_cache_mtl()

GameApi::P GameApi::PolygonApi::ds_cache_mtl ( GameApi::EveryApi & ev,
GameApi::P input,
int count,
std::string mtl_url,
std::string url_prefix )
Here is the caller graph for this function:

◆ ds_cache_url()

GameApi::P GameApi::PolygonApi::ds_cache_url ( GameApi::EveryApi & ev,
GameApi::P input,
int count )
Here is the caller graph for this function:

◆ dyn_lights_shader()

EXPORT GameApi::ML GameApi::PolygonApi::dyn_lights_shader ( EveryApi & ev,
ML mainloop,
float light_pos_x,
float light_pos_y,
float light_pos_z,
float dist,
MN dyn_point )

◆ edge_shader()

EXPORT GameApi::ML GameApi::PolygonApi::edge_shader ( EveryApi & ev,
ML mainloop,
float edge_width,
unsigned int edge_color )

◆ explode()

EXPORT void GameApi::PolygonApi::explode ( VA va,
PT pos,
float dist )

◆ extract_large_polygons()

GameApi::P GameApi::PolygonApi::extract_large_polygons ( GameApi::P p,
float minimum_size,
bool reverse )
Here is the caller graph for this function:

◆ face_cutter()

GameApi::P GameApi::PolygonApi::face_cutter ( P p,
float start,
float end )
Here is the caller graph for this function:

◆ fade_pic()

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

◆ fade_shader()

EXPORT GameApi::ML GameApi::PolygonApi::fade_shader ( EveryApi & ev,
ML mainloop,
float start_time,
float end_time,
float start_time2,
float end_time2 )

◆ file_cache()

GameApi::P GameApi::PolygonApi::file_cache ( P model,
std::string filename,
int obj_num )

◆ filter_invisible()

GameApi::P GameApi::PolygonApi::filter_invisible ( GameApi::P p,
float size )
Here is the caller graph for this function:

◆ find_attach2()

GameApi::ATT GameApi::PolygonApi::find_attach2 ( P p,
LI li )
Here is the caller graph for this function:

◆ find_color_id()

IMPORT ID GameApi::PolygonApi::find_color_id ( P p,
int facenum,
int pointnum )

◆ find_normal_id()

IMPORT ID GameApi::PolygonApi::find_normal_id ( P p,
int facenum,
int pointnum )

◆ find_point_id()

IMPORT ID GameApi::PolygonApi::find_point_id ( P p,
int facenum,
int pointnum )

◆ find_texcoord_id()

IMPORT ID GameApi::PolygonApi::find_texcoord_id ( P p,
int facenum,
int pointnum )

◆ fix_texcoord()

GameApi::P GameApi::PolygonApi::fix_texcoord ( P p)
Here is the caller graph for this function:

◆ fix_vertex_order()

GameApi::P GameApi::PolygonApi::fix_vertex_order ( GameApi::P p)
Here is the caller graph for this function:

◆ flip_normals()

GameApi::P GameApi::PolygonApi::flip_normals ( P obj)
Here is the caller graph for this function:

◆ flip_polygon_order()

EXPORT GameApi::P GameApi::PolygonApi::flip_polygon_order ( P p)

◆ fog_shader()

EXPORT GameApi::ML GameApi::PolygonApi::fog_shader ( EveryApi & ev,
ML mainloop,
float fog_dist,
unsigned int dark_color,
unsigned int light_color )
Here is the caller graph for this function:

◆ fractal_mountain()

EXPORT GameApi::FB GameApi::PolygonApi::fractal_mountain ( int level,
int sx,
int sy )
Here is the caller graph for this function:

◆ from_lines()

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

◆ from_normal_to_texcoord()

GameApi::P GameApi::PolygonApi::from_normal_to_texcoord ( P p)
Here is the caller graph for this function:

◆ from_points()

EXPORT GameApi::P GameApi::PolygonApi::from_points ( PTS p,
std::function< P(int i, float x, float y, float z, unsigned int color)> f )
Here is the caller graph for this function:

◆ from_polygon()

EXPORT GameApi::P GameApi::PolygonApi::from_polygon ( P p,
std::function< P(int face, PT p1, PT p2, PT p3, PT p4)> f )
Here is the caller graph for this function:

◆ from_polygon_1()

GameApi::P GameApi::PolygonApi::from_polygon_1 ( P p,
std::function< P(int face, PT p1, PT p2, PT p3, PT p4)> f )
Here is the caller graph for this function:

◆ fromsurface() [1/2]

IMPORT P GameApi::PolygonApi::fromsurface ( S s,
float thickness )

◆ fromsurface() [2/2]

IMPORT P GameApi::PolygonApi::fromsurface ( S s1,
S s2,
C curve )

◆ fullscreen_quad()

EXPORT GameApi::P GameApi::PolygonApi::fullscreen_quad ( EveryApi & ev)
Here is the caller graph for this function:

◆ get_face_count()

GameApi::P GameApi::PolygonApi::get_face_count ( P p)
Here is the caller graph for this function:

◆ get_tri_vertex_array()

EXPORT void GameApi::PolygonApi::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 )

◆ get_tri_vertex_array_frames()

EXPORT int GameApi::PolygonApi::get_tri_vertex_array_frames ( P p)

◆ get_tri_vertex_array_rows()

EXPORT int GameApi::PolygonApi::get_tri_vertex_array_rows ( P p)

◆ gi_shader()

EXPORT GameApi::ML GameApi::PolygonApi::gi_shader ( EveryApi & ev,
ML mainloop,
PTS points,
float obj_size )

◆ globe_shader()

EXPORT GameApi::ML GameApi::PolygonApi::globe_shader ( EveryApi & ev,
ML mainloop,
float globe_r )
Here is the caller graph for this function:

◆ glowedge_shader()

EXPORT GameApi::ML GameApi::PolygonApi::glowedge_shader ( EveryApi & ev,
ML mainloop,
float white_level,
float gray_level,
float edge_pos )

◆ gltf_anim_shader()

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

◆ gltf_load()

GameApi::P GameApi::PolygonApi::gltf_load ( EveryApi & ev,
TF model,
int mesh_index,
int prim_index,
TRR resize_transfer_id )
Here is the caller graph for this function:

◆ gltf_load_bitmap()

GameApi::BM GameApi::PolygonApi::gltf_load_bitmap ( GameApi::EveryApi & ev,
TF model,
int image_index )
Here is the caller graph for this function:

◆ gltf_load_nr()

GameApi::P GameApi::PolygonApi::gltf_load_nr ( EveryApi & ev,
TF model,
int mesh_index,
int prim_index,
TRR resize_transfer_id )
Here is the caller graph for this function:

◆ gltf_shader()

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

◆ gltf_split_faces2()

GameApi::ARR GameApi::PolygonApi::gltf_split_faces2 ( EveryApi & ev,
TF model0,
int mesh_index,
int prim_index,
int max_attach )
Here is the caller graph for this function:

◆ gradient_color()

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

◆ grid() [1/2]

IMPORT P GameApi::PolygonApi::grid ( PT o,
PT u_x,
PT u_y,
int num_x,
int num_y )
Here is the caller graph for this function:

◆ grid() [2/2]

IMPORT P GameApi::PolygonApi::grid ( PT o,
PT u_x,
PT u_y,
int num_x,
int num_y,
P * grid )

◆ heightmap() [1/2]

EXPORT GameApi::P GameApi::PolygonApi::heightmap ( BM bm,
HeightMapType t,
float min_x,
float max_x,
float min_y,
float max_y,
float min_z,
float max_z )
Here is the caller graph for this function:

◆ heightmap() [2/2]

EXPORT GameApi::P GameApi::PolygonApi::heightmap ( FB fb,
std::function< P(float)> f,
float dx,
float dz )

◆ heightmap2()

EXPORT GameApi::P GameApi::PolygonApi::heightmap2 ( FB bm,
float start_x,
float end_x,
float start_y,
float end_y,
float start_z,
float end_z )
Here is the caller graph for this function:

◆ id_array()

IMPORT ID GameApi::PolygonApi::id_array ( ID * array,
int size )

◆ identity_pose()

GameApi::MS GameApi::PolygonApi::identity_pose ( int li_size)

◆ interpolate_mesh_pair()

GameApi::P GameApi::PolygonApi::interpolate_mesh_pair ( P start_p,
P end_p )
Here is the caller graph for this function:

◆ interpolate_mesh_pair_arr()

GameApi::ARR GameApi::PolygonApi::interpolate_mesh_pair_arr ( std::vector< P > start_ps,
std::vector< P > end_ps )
Here is the caller graph for this function:

◆ intersect()

EXPORT GameApi::P GameApi::PolygonApi::intersect ( EveryApi & ev,
P p1,
P p2,
O o1,
O o2,
CT cutter1,
CT cutter2 )

◆ is_array_texture()

EXPORT bool GameApi::PolygonApi::is_array_texture ( VA va)

◆ is_texture()

EXPORT bool GameApi::PolygonApi::is_texture ( VA va)

◆ li_piechart()

GameApi::LI GameApi::PolygonApi::li_piechart ( float c_x,
float c_y,
float c_z,
float start_angle,
float end_angle,
float radius,
int numsteps )
Here is the caller graph for this function:

◆ li_polygon()

GameApi::P GameApi::PolygonApi::li_polygon ( LI li,
float width )
Here is the caller graph for this function:

◆ li_static_instancing_matrix()

EXPORT GameApi::LI GameApi::PolygonApi::li_static_instancing_matrix ( EveryApi & ev,
LI obj,
MS matrix_array )
Here is the caller graph for this function:

◆ light_bm()

IMPORT BM GameApi::PolygonApi::light_bm ( L lighting,
P poly )

◆ light_shader()

EXPORT GameApi::ML GameApi::PolygonApi::light_shader ( EveryApi & ev,
ML mainloop )
Here is the caller graph for this function:

◆ light_transport()

GameApi::P GameApi::PolygonApi::light_transport ( P p,
int num,
float light_dir_x,
float light_dir_y,
float light_dir_z )
Here is the caller graph for this function:

◆ lighting()

IMPORT P GameApi::PolygonApi::lighting ( P orig,
L lighting )
Here is the caller graph for this function:

◆ line_to_cone()

GameApi::P GameApi::PolygonApi::line_to_cone ( EveryApi & ev,
LI li,
float size,
int numfaces )
Here is the caller graph for this function:

◆ line_to_cone2()

GameApi::ML GameApi::PolygonApi::line_to_cone2 ( EveryApi & ev,
LI li,
float size,
int numfaces,
MT mt )
Here is the caller graph for this function:

◆ line_to_cone3()

GameApi::ML GameApi::PolygonApi::line_to_cone3 ( EveryApi & ev,
LI li,
float size,
int numfaces,
MT mt,
unsigned int color )
Here is the caller graph for this function:

◆ linear_span()

EXPORT GameApi::P GameApi::PolygonApi::linear_span ( EveryApi & ev,
LI li,
float dx,
float dy,
float dz,
int num_steps )
Here is the caller graph for this function:

◆ load_ds_from_temp_p()

GameApi::P GameApi::PolygonApi::load_ds_from_temp_p ( GameApi::EveryApi & ev,
GameApi::P p,
std::string url )
Here is the caller graph for this function:

◆ load_glb_from_temp()

void GameApi::PolygonApi::load_glb_from_temp ( std::string filename,
void(* fptr )(void *),
void * data,
bool & success )

◆ load_glb_from_temp2()

GameApi::TF GameApi::PolygonApi::load_glb_from_temp2 ( std::string filename)

◆ load_glb_from_temp3()

void GameApi::PolygonApi::load_glb_from_temp3 ( std::string filename)

◆ load_model()

EXPORT GameApi::P GameApi::PolygonApi::load_model ( std::string filename,
int obj_num )
Here is the caller graph for this function:

◆ load_model_all()

EXPORT GameApi::P GameApi::PolygonApi::load_model_all ( std::string filename,
int count )
Here is the caller graph for this function:

◆ load_model_all_no_cache() [1/2]

EXPORT GameApi::P GameApi::PolygonApi::load_model_all_no_cache ( LoadStream * file_data,
int count,
bool nr )

◆ load_model_all_no_cache() [2/2]

EXPORT GameApi::P GameApi::PolygonApi::load_model_all_no_cache ( std::string filename,
int count,
bool nr )
Here is the caller graph for this function:

◆ load_model_all_no_cache_mtl() [1/2]

EXPORT GameApi::P GameApi::PolygonApi::load_model_all_no_cache_mtl ( LoadStream * file_data,
int count,
std::vector< std::string > material_names,
bool nr )

◆ load_model_all_no_cache_mtl() [2/2]

EXPORT GameApi::P GameApi::PolygonApi::load_model_all_no_cache_mtl ( std::string filename,
int count,
std::vector< std::string > material_names,
bool nr )
Here is the caller graph for this function:

◆ load_scene()

GameApi::ML GameApi::PolygonApi::load_scene ( GameApi::EveryApi & ev,
std::string url,
int sx,
int sy )
Here is the caller graph for this function:

◆ lod_choose()

GameApi::P GameApi::PolygonApi::lod_choose ( std::vector< P > vec,
std::string name )
Here is the caller graph for this function:

◆ lod_select()

GameApi::IF GameApi::PolygonApi::lod_select ( float start_dist,
float dist_step,
int max_value )
Here is the caller graph for this function:

◆ lod_set()

GameApi::P GameApi::PolygonApi::lod_set ( P p,
std::string name,
int value )
Here is the caller graph for this function:

◆ log_coords()

GameApi::P GameApi::PolygonApi::log_coords ( P p)
Here is the caller graph for this function:

◆ log_coords2()

GameApi::P GameApi::PolygonApi::log_coords2 ( P p,
int x_count,
int y_count,
float sx,
float sy,
float sz )
Here is the caller graph for this function:

◆ m_bind_inst_many()

GameApi::ML GameApi::PolygonApi::m_bind_inst_many ( EveryApi & ev,
std::vector< P > vec,
std::vector< MT > materials,
PTS pts,
int ticks )
Here is the caller graph for this function:

◆ m_bind_many()

GameApi::ML GameApi::PolygonApi::m_bind_many ( EveryApi & ev,
std::vector< P > vec,
std::vector< MT > materials,
int ticks )
Here is the caller graph for this function:

◆ material_arr()

GameApi::ARR GameApi::PolygonApi::material_arr ( std::vector< MT > vec,
int start_range,
int end_range )
Here is the caller graph for this function:

◆ material_choose()

GameApi::ARR GameApi::PolygonApi::material_choose ( std::vector< MT > mat,
std::vector< P > p )
Here is the caller graph for this function:

◆ material_extractor_bm()

GameApi::ARR GameApi::PolygonApi::material_extractor_bm ( P p,
int start_index,
int end_index )
Here is the caller graph for this function:

◆ material_extractor_mt()

GameApi::ARR GameApi::PolygonApi::material_extractor_mt ( GameApi::EveryApi & ev,
P p,
float mix,
int start_index,
int end_index )
Here is the caller graph for this function:

◆ material_extractor_p()

GameApi::ARR GameApi::PolygonApi::material_extractor_p ( P p,
int start_index,
int end_index,
int num_slots,
int current_slot )
Here is the caller graph for this function:

◆ material_face_collection()

GameApi::P GameApi::PolygonApi::material_face_collection ( P base,
P material )
Here is the caller graph for this function:

◆ material_index()

GameApi::MT GameApi::PolygonApi::material_index ( GameApi::EveryApi & ev,
std::vector< MT > vec,
int index )
Here is the caller graph for this function:

◆ matrix()

GameApi::P GameApi::PolygonApi::matrix ( P orig,
M mat )
Here is the caller graph for this function:

◆ matrix44()

GameApi::P GameApi::PolygonApi::matrix44 ( P orig,
M mat )
Here is the caller graph for this function:

◆ max_color()

EXPORT GameApi::P GameApi::PolygonApi::max_color ( P orig,
P orig2 )
Here is the caller graph for this function:

◆ memoize()

EXPORT GameApi::P GameApi::PolygonApi::memoize ( P orig)
Here is the caller graph for this function:

◆ memoize_all()

EXPORT GameApi::P GameApi::PolygonApi::memoize_all ( P orig)

◆ mesh_anim()

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

◆ mesh_anim_display_inst()

GameApi::ML GameApi::PolygonApi::mesh_anim_display_inst ( GameApi::EveryApi & ev,
P p,
FF val,
MN move,
MT mat,
MS inst )
Here is the caller graph for this function:

◆ mesh_anim_display_inst2()

GameApi::ML GameApi::PolygonApi::mesh_anim_display_inst2 ( GameApi::EveryApi & ev,
P p,
FF val,
MN mn,
MT mat,
PTS inst )

◆ mesh_color_shader()

EXPORT GameApi::ML GameApi::PolygonApi::mesh_color_shader ( EveryApi & ev,
ML mainloop,
SFO sfo )

◆ mesh_elem()

GameApi::P GameApi::PolygonApi::mesh_elem ( P start,
P end )
Here is the caller graph for this function:

◆ mesh_resize()

GameApi::P GameApi::PolygonApi::mesh_resize ( P p,
float start_x,
float end_x,
float start_y,
float end_Y,
float start_z,
float end_z )
Here is the caller graph for this function:

◆ meshanim()

GameApi::MA GameApi::PolygonApi::meshanim ( std::vector< P > vec,
float start_time,
float end_time )
Here is the caller graph for this function:

◆ meshanim_anim_meshes()

GameApi::ARR GameApi::PolygonApi::meshanim_anim_meshes ( MA ma,
float start_time,
float delta_time,
int count )

◆ meshanim_mesh()

GameApi::P GameApi::PolygonApi::meshanim_mesh ( MA ma,
float time )
Here is the caller graph for this function:

◆ meshanim_mesh2()

GameApi::P GameApi::PolygonApi::meshanim_mesh2 ( MA ma,
float time1,
float time2 )
Here is the caller graph for this function:

◆ meshy()

GameApi::TF GameApi::PolygonApi::meshy ( EveryApi & ev,
std::string prompt,
std::string filename )
Here is the caller graph for this function:

◆ min_color()

EXPORT GameApi::P GameApi::PolygonApi::min_color ( P orig,
P orig2 )
Here is the caller graph for this function:

◆ mix_color()

EXPORT GameApi::P GameApi::PolygonApi::mix_color ( P orig,
P orig2,
float val )
Here is the caller graph for this function:

◆ mix_mesh()

GameApi::P GameApi::PolygonApi::mix_mesh ( P p,
PTS points,
float val )
Here is the caller graph for this function:

◆ mixshader_shader()

EXPORT GameApi::ML GameApi::PolygonApi::mixshader_shader ( EveryApi & ev,
ML ml,
float mix = 0.5 )

◆ move()

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

◆ mtl_parse()

std::vector< GameApi::TXID > GameApi::PolygonApi::mtl_parse ( EveryApi & ev,
std::vector< unsigned char > mtlfilecontents,
std::string url_prefix,
int delta = 0 )

◆ multiply_facecoll()

GameApi::P GameApi::PolygonApi::multiply_facecoll ( GameApi::P p,
int sx,
int sy,
int sz )

◆ new_pose()

GameApi::MS GameApi::PolygonApi::new_pose ( EveryApi & ev,
LI li_orig,
LI li )
Here is the caller graph for this function:

◆ newshadow_shader_1()

EXPORT GameApi::ML GameApi::PolygonApi::newshadow_shader_1 ( EveryApi & ev,
ML ml,
float light_dir_x,
float light_dir_y,
float light_dir_z,
float scale )

◆ newshadow_shader_2_gltf()

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

◆ newshadow_shader_2_phong()

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

◆ no_batch_map()

GameApi::P GameApi::PolygonApi::no_batch_map ( P p)

◆ noise_shader()

EXPORT GameApi::ML GameApi::PolygonApi::noise_shader ( EveryApi & ev,
ML mainloop )
Here is the caller graph for this function:

◆ normal_darkness()

GameApi::P GameApi::PolygonApi::normal_darkness ( P p,
float dark )
Here is the caller graph for this function:

◆ normal_function()

EXPORT GameApi::P GameApi::PolygonApi::normal_function ( P p1,
std::function< V(int face, int point)> f )

◆ optimize_mesh() [1/2]

IMPORT P GameApi::PolygonApi::optimize_mesh ( P p)
Here is the caller graph for this function:

◆ optimize_mesh() [2/2]

GameApi::P GameApi::PolygonApi::optimize_mesh ( P p,
float max )

◆ or_array()

EXPORT GameApi::P GameApi::PolygonApi::or_array ( P * array,
int size )

◆ or_array2()

EXPORT GameApi::P GameApi::PolygonApi::or_array2 ( std::vector< P > vec)
Here is the caller graph for this function:

◆ or_array3()

EXPORT GameApi::P GameApi::PolygonApi::or_array3 ( std::vector< P > vec)
Here is the caller graph for this function:

◆ or_array_1()

GameApi::P GameApi::PolygonApi::or_array_1 ( P * array,
int size )
Here is the caller graph for this function:

◆ or_elem()

EXPORT GameApi::P GameApi::PolygonApi::or_elem ( P p1,
P p2 )
Here is the caller graph for this function:

◆ or_elem_anim()

IMPORT ARR GameApi::PolygonApi::or_elem_anim ( P p1,
P p2,
float time )

◆ or_elem_pl()

GameApi::PL GameApi::PolygonApi::or_elem_pl ( PL pl1,
PL pl2 )
Here is the caller graph for this function:

◆ orig_pose()

std::vector< GameApi::P > GameApi::PolygonApi::orig_pose ( EveryApi & ev,
P p,
LI li,
int li_size )
Here is the caller graph for this function:

◆ orig_pose2()

std::vector< GameApi::P > GameApi::PolygonApi::orig_pose2 ( EveryApi & ev,
std::vector< P > vec,
LI li,
int li_size )
Here is the caller graph for this function:

◆ output_ml()

std::string GameApi::PolygonApi::output_ml ( std::string objfileurl,
int count,
std::string prefix,
std::vector< MaterialDef > filenames )

◆ p_array()

GameApi::PV GameApi::PolygonApi::p_array ( std::vector< P > vec)
Here is the caller graph for this function:

◆ p_ds()

GameApi::P GameApi::PolygonApi::p_ds ( EveryApi & ev,
const unsigned char * beg,
const unsigned char * end )

◆ p_ds2()

GameApi::P GameApi::PolygonApi::p_ds2 ( EveryApi & ev,
DS ds2 )

◆ p_ds_inv()

GameApi::DS GameApi::PolygonApi::p_ds_inv ( GameApi::P p,
int flags = -1 )

◆ p_ds_url()

EXPORT GameApi::P GameApi::PolygonApi::p_ds_url ( EveryApi & ev,
std::string url )
Here is the caller graph for this function:

◆ p_empty()

EXPORT GameApi::P GameApi::PolygonApi::p_empty ( )
Here is the caller graph for this function:

◆ p_gen_texture()

void GameApi::PolygonApi::p_gen_texture ( P p,
int i )

◆ p_mtl()

EXPORT GameApi::P GameApi::PolygonApi::p_mtl ( EveryApi & ev,
std::string obj_url,
std::string mtl_url,
std::string prefix,
int count )
Here is the caller graph for this function:

◆ p_mtl2()

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

◆ p_mtl2_materials()

GameApi::ARR GameApi::PolygonApi::p_mtl2_materials ( GameApi::EveryApi & ev,
P p )
Here is the caller graph for this function:

◆ p_mtl2_nr()

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

◆ p_mtl2_prepare()

GameApi::ML GameApi::PolygonApi::p_mtl2_prepare ( P p)
Here is the caller graph for this function:

◆ p_mtl_bump()

GameApi::ARR GameApi::PolygonApi::p_mtl_bump ( P p)
Here is the caller graph for this function:

◆ p_mtl_d()

GameApi::ARR GameApi::PolygonApi::p_mtl_d ( P p)
Here is the caller graph for this function:

◆ p_mtl_materials()

GameApi::ARR GameApi::PolygonApi::p_mtl_materials ( GameApi::EveryApi & ev,
P P )
Here is the caller graph for this function:

◆ p_mtl_nr()

EXPORT GameApi::P GameApi::PolygonApi::p_mtl_nr ( EveryApi & ev,
std::string obj_url,
std::string mtl_url,
std::string prefix,
int count )
Here is the caller graph for this function:

◆ p_num_textures()

int GameApi::PolygonApi::p_num_textures ( P p)

◆ p_piechart()

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

◆ p_texture()

GameApi::BM GameApi::PolygonApi::p_texture ( P p,
int i )

◆ p_url()

EXPORT GameApi::P GameApi::PolygonApi::p_url ( EveryApi & ev,
std::string url,
int count )
Here is the caller graph for this function:

◆ p_url_mtl()

EXPORT GameApi::P GameApi::PolygonApi::p_url_mtl ( EveryApi & ev,
std::string url,
int count,
std::vector< std::string > material_names )
Here is the caller graph for this function:

◆ p_url_nr()

EXPORT GameApi::P GameApi::PolygonApi::p_url_nr ( EveryApi & ev,
std::string url,
int count )
Here is the caller graph for this function:

◆ parse_mtl()

std::vector< GameApi::MaterialDef > GameApi::PolygonApi::parse_mtl ( std::string filename)

◆ persistent_cache()

GameApi::P GameApi::PolygonApi::persistent_cache ( P orig,
std::string filename )
Here is the caller graph for this function:

◆ phong_shader()

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

◆ phong_shader2()

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

◆ piechart_full()

GameApi::ML GameApi::PolygonApi::piechart_full ( GameApi::EveryApi & ev,
float c_x,
float c_y,
std::string url,
float radius,
int numsteps,
float start_z,
float end_z )
Here is the caller graph for this function:

◆ plane_map()

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

◆ point_function()

EXPORT GameApi::P GameApi::PolygonApi::point_function ( P p1,
std::function< PT(int face, int point)> f )

◆ poly_array()

GameApi::ARR GameApi::PolygonApi::poly_array ( std::vector< P > vec)
Here is the caller graph for this function:

◆ poly_execute()

GameApi::ARR GameApi::PolygonApi::poly_execute ( EveryApi & ev,
ARR arr,
std::string gameapi_script )

◆ poly_index()

GameApi::P GameApi::PolygonApi::poly_index ( ARR arr,
int idx )

◆ poly_size()

int GameApi::PolygonApi::poly_size ( ARR arr)

◆ polygon()

EXPORT GameApi::P GameApi::PolygonApi::polygon ( PT * array,
int size )
Here is the caller graph for this function:

◆ polygon2()

EXPORT GameApi::P GameApi::PolygonApi::polygon2 ( std::vector< PT > vec)

◆ polygon3()

EXPORT GameApi::P GameApi::PolygonApi::polygon3 ( PTS points)
Here is the caller graph for this function:

◆ polygon_fetch()

GameApi::P GameApi::PolygonApi::polygon_fetch ( P p)
Here is the caller graph for this function:

◆ position_based_on_screen()

GameApi::ML GameApi::PolygonApi::position_based_on_screen ( ML obj)
Here is the caller graph for this function:

◆ prepare()

EXPORT void GameApi::PolygonApi::prepare ( P p,
int bbm_choose = -1 )
Here is the caller graph for this function:

◆ prepare_cache()

EXPORT GameApi::P GameApi::PolygonApi::prepare_cache ( std::string url,
GameApi::P p )

◆ prepare_cut()

GameApi::P GameApi::PolygonApi::prepare_cut ( P p)
Here is the caller graph for this function:

◆ prepare_vertex_array_instanced()

EXPORT void GameApi::PolygonApi::prepare_vertex_array_instanced ( ShaderApi & ev,
VA va,
PTA pta,
SH sh )

◆ prepare_vertex_array_instanced_matrix()

EXPORT void GameApi::PolygonApi::prepare_vertex_array_instanced_matrix ( ShaderApi & ev,
VA va,
MSA pta,
SH sh )

◆ preparedone()

void GameApi::PolygonApi::preparedone ( P p)

◆ preparepoly()

EXPORT void GameApi::PolygonApi::preparepoly ( P p,
int bbm_choose = -1 )
Here is the caller graph for this function:

◆ print_data()

void GameApi::PolygonApi::print_data ( P p)

◆ print_data2()

void GameApi::PolygonApi::print_data2 ( P p)

◆ print_stat() [1/2]

void GameApi::PolygonApi::print_stat ( P p)

◆ print_stat() [2/2]

EXPORT void GameApi::PolygonApi::print_stat ( VA p)

◆ pts_to_voxel()

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

◆ quad()

EXPORT GameApi::P GameApi::PolygonApi::quad ( PT p1,
PT p2,
PT p3,
PT p4 )
Here is the caller graph for this function:

◆ quad_tree()

GameApi::ML GameApi::PolygonApi::quad_tree ( P p)

◆ quad_x()

EXPORT GameApi::P GameApi::PolygonApi::quad_x ( float x,
float y1,
float y2,
float z1,
float z2 )
Here is the caller graph for this function:

◆ quad_y()

EXPORT GameApi::P GameApi::PolygonApi::quad_y ( float x1,
float x2,
float y,
float z1,
float z2 )
Here is the caller graph for this function:

◆ quad_z()

EXPORT GameApi::P GameApi::PolygonApi::quad_z ( float x1,
float x2,
float y1,
float y2,
float z )
Here is the caller graph for this function:

◆ quads_to_triangles()

EXPORT GameApi::P GameApi::PolygonApi::quads_to_triangles ( P p)
Here is the caller graph for this function:

◆ radial_lighting()

IMPORT L GameApi::PolygonApi::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 )

◆ ready_to_prepare()

bool GameApi::PolygonApi::ready_to_prepare ( ML p)

◆ recalculate_normals()

EXPORT GameApi::P GameApi::PolygonApi::recalculate_normals ( P orig)
Here is the caller graph for this function:

◆ rect_pl()

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

◆ reflection()

EXPORT GameApi::P GameApi::PolygonApi::reflection ( P orig,
PT pos,
V u_x,
V u_y,
V ref_vec )
Here is the caller graph for this function:

◆ remove_faces()

GameApi::P GameApi::PolygonApi::remove_faces ( GameApi::P p)
Here is the caller graph for this function:

◆ render()

EXPORT void GameApi::PolygonApi::render ( P p,
int choose,
float x,
float y,
float z )
Here is the caller graph for this function:

◆ render_dynamic()

EXPORT void GameApi::PolygonApi::render_dynamic ( GameApi::P p,
int array_elem,
bool textures )

◆ render_dynamic_ml()

EXPORT GameApi::ML GameApi::PolygonApi::render_dynamic_ml ( EveryApi & ev,
P p,
DC dyn )
Here is the caller graph for this function:

◆ render_pl()

GameApi::P GameApi::PolygonApi::render_pl ( PL pl)
Here is the caller graph for this function:

◆ render_vertex_array()

EXPORT void GameApi::PolygonApi::render_vertex_array ( VA va)
Here is the caller graph for this function:

◆ render_vertex_array_dyn()

EXPORT void GameApi::PolygonApi::render_vertex_array_dyn ( VA va,
DC dc,
MainLoopEnv & e )

◆ render_vertex_array_instanced()

EXPORT void GameApi::PolygonApi::render_vertex_array_instanced ( ShaderApi & ev,
VA va,
PTA pta,
SH sh,
int hide_n = -1 )

◆ render_vertex_array_instanced_matrix()

EXPORT void GameApi::PolygonApi::render_vertex_array_instanced_matrix ( ShaderApi & ev,
VA va,
MSA pta,
SH sh,
int hide_n = -1 )

◆ render_vertex_array_ml()

EXPORT GameApi::ML GameApi::PolygonApi::render_vertex_array_ml ( EveryApi & ev,
VA va )

◆ render_vertex_array_ml2()

EXPORT GameApi::ML GameApi::PolygonApi::render_vertex_array_ml2 ( EveryApi & ev,
P va )
Here is the caller graph for this function:

◆ render_vertex_array_ml2_cubemap()

EXPORT GameApi::ML GameApi::PolygonApi::render_vertex_array_ml2_cubemap ( EveryApi & ev,
P va,
std::vector< BM > vec )

◆ render_vertex_array_ml2_texture()

EXPORT GameApi::ML GameApi::PolygonApi::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>() )

◆ render_vertex_array_ml2_texture2()

EXPORT GameApi::ML GameApi::PolygonApi::render_vertex_array_ml2_texture2 ( EveryApi & ev,
P p )

◆ render_vertex_array_ml2_texture_id()

EXPORT GameApi::ML GameApi::PolygonApi::render_vertex_array_ml2_texture_id ( EveryApi & ev,
P va,
std::vector< TXID > * vec )

◆ renderpoly() [1/3]

void GameApi::PolygonApi::renderpoly ( P p,
float x,
float y,
float z )
Here is the caller graph for this function:

◆ renderpoly() [2/3]

void GameApi::PolygonApi::renderpoly ( P p,
int choose,
float x,
float y,
float z )

◆ renderpoly() [3/3]

void GameApi::PolygonApi::renderpoly ( P p,
PT pos )

◆ renderpolytobitmap()

GameApi::BM GameApi::PolygonApi::renderpolytobitmap ( EveryApi & ev,
P p,
SH sh,
float x,
float y,
float z,
int sx,
int sy )
Here is the caller graph for this function:

◆ repeat_xy_p()

GameApi::P GameApi::PolygonApi::repeat_xy_p ( EveryApi & ev,
P p,
float start_x,
float start_y,
float dx,
float dy,
int sx,
int sy )
Here is the caller graph for this function:

◆ repeat_xz_p()

GameApi::P GameApi::PolygonApi::repeat_xz_p ( EveryApi & ev,
P p,
float start_x,
float start_z,
float dx,
float dz,
int sx,
int sz )
Here is the caller graph for this function:

◆ repeat_yz_p()

GameApi::P GameApi::PolygonApi::repeat_yz_p ( EveryApi & ev,
P p,
float start_y,
float start_z,
float dy,
float dz,
int sy,
int sz )
Here is the caller graph for this function:

◆ replace_texture()

GameApi::P GameApi::PolygonApi::replace_texture ( P p,
BM bm,
int num )
Here is the caller graph for this function:

◆ resize_to_correct_size()

GameApi::P GameApi::PolygonApi::resize_to_correct_size ( P model)
Here is the caller graph for this function:

◆ resize_to_correct_size_g()

GameApi::P GameApi::PolygonApi::resize_to_correct_size_g ( P model,
TRR resize_transfer_id )

◆ ring()

EXPORT GameApi::P GameApi::PolygonApi::ring ( float sx,
float sy,
float x,
int steps )
Here is the caller graph for this function:

◆ rotate()

EXPORT GameApi::P GameApi::PolygonApi::rotate ( P orig,
PT pt,
V axis,
float angle )

◆ rotatex()

EXPORT GameApi::P GameApi::PolygonApi::rotatex ( P orig,
float angle )
Here is the caller graph for this function:

◆ rotatey()

EXPORT GameApi::P GameApi::PolygonApi::rotatey ( P orig,
float angle )
Here is the caller graph for this function:

◆ rotatez()

EXPORT GameApi::P GameApi::PolygonApi::rotatez ( P orig,
float angle )
Here is the caller graph for this function:

◆ rounded_cube()

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

◆ s_sample()

GameApi::P GameApi::PolygonApi::s_sample ( S surf,
int sx,
int sy )
Here is the caller graph for this function:

◆ s_spherical()

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

◆ save_model()

EXPORT void GameApi::PolygonApi::save_model ( GameApi::P poly,
std::string filename )

◆ save_model_ml()

EXPORT GameApi::ML GameApi::PolygonApi::save_model_ml ( GameApi::P poly,
std::string filename )
Here is the caller graph for this function:

◆ sbm_circle()

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

◆ sbm_texture()

GameApi::ML GameApi::PolygonApi::sbm_texture ( EveryApi & ev,
ML mainloop,
SBM bitmap )
Here is the caller graph for this function:

◆ scale()

EXPORT GameApi::P GameApi::PolygonApi::scale ( P orig,
float sx,
float sy,
float sz )
Here is the caller graph for this function:

◆ seq_p_array()

GameApi::ARR GameApi::PolygonApi::seq_p_array ( std::vector< P > vec,
std::vector< P > vec2 )
Here is the caller graph for this function:

◆ sfo_sandbox_shader()

EXPORT GameApi::ML GameApi::PolygonApi::sfo_sandbox_shader ( EveryApi & ev,
ML mainloop,
SFO sfo )

◆ sfo_sbm()

GameApi::SBM GameApi::PolygonApi::sfo_sbm ( EveryApi & ev,
SFO sfo )
Here is the caller graph for this function:

◆ shading_shader()

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

◆ shadow()

EXPORT GameApi::P GameApi::PolygonApi::shadow ( P orig,
PT pos,
V u_x,
V u_y,
V light_vec )
Here is the caller graph for this function:

◆ shadow_map()

GameApi::BM GameApi::PolygonApi::shadow_map ( EveryApi & ev,
P p,
float p_x,
float p_y,
float p_z,
int sx,
int sy )
Here is the caller graph for this function:

◆ shadow_map2()

GameApi::BB GameApi::PolygonApi::shadow_map2 ( P p,
float p_x,
float p_y,
float p_z,
int sx,
int sy,
P quad )
Here is the caller graph for this function:

◆ shadow_map3()

GameApi::BM GameApi::PolygonApi::shadow_map3 ( EveryApi & ev,
P objs,
float p_x,
float p_Y,
float p_z,
int sx,
int sy,
P quad )
Here is the caller graph for this function:

◆ shadow_shader()

EXPORT GameApi::ML GameApi::PolygonApi::shadow_shader ( EveryApi & ev,
ML mainloop,
int tex_num,
float p_x,
float p_y,
float p_z,
unsigned int dark_color,
float mix )

◆ single_texture()

IMPORT P GameApi::PolygonApi::single_texture ( P orig,
BM texture )

◆ ske_anim()

GameApi::ML GameApi::PolygonApi::ske_anim ( EveryApi & ev,
P mesh,
LI orig_pose,
int li_size,
std::string url,
std::vector< LI > new_poses,
MT mat )
Here is the caller graph for this function:

◆ ske_anim2()

GameApi::ML GameApi::PolygonApi::ske_anim2 ( EveryApi & ev,
std::vector< P > mesh,
LI orig_pose,
int li_size,
std::string url,
std::vector< LI > new_poses,
MT mat )
Here is the caller graph for this function:

◆ skeletal_anim()

EXPORT GameApi::P GameApi::PolygonApi::skeletal_anim ( P p,
PT p_0,
PT p_1,
PT n_0,
PT n_1 )

◆ skeletal_shader()

EXPORT GameApi::ML GameApi::PolygonApi::skeletal_shader ( EveryApi & ev,
ML mainloop,
std::vector< SA > vec )

◆ slow_calc_lights()

GameApi::P GameApi::PolygonApi::slow_calc_lights ( GameApi::P p,
float light_dir_x,
float light_dir_y,
float light_dir_z )
Here is the caller graph for this function:

◆ smooth_normals()

IMPORT P GameApi::PolygonApi::smooth_normals ( P orig)

◆ smooth_normals2()

GameApi::P GameApi::PolygonApi::smooth_normals2 ( P p)
Here is the caller graph for this function:

◆ solid_of_revolution()

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

◆ sort_faces_by_area()

GameApi::P GameApi::PolygonApi::sort_faces_by_area ( P p)

◆ sort_vertices()

void GameApi::PolygonApi::sort_vertices ( VA va,
M m )

◆ span()

EXPORT GameApi::P GameApi::PolygonApi::span ( LI li,
M matrix,
int num_steps )
Here is the caller graph for this function:

◆ spatial_decimate()

GameApi::P GameApi::PolygonApi::spatial_decimate ( GameApi::P p,
float val )
Here is the caller graph for this function:

◆ sphere()

EXPORT GameApi::P GameApi::PolygonApi::sphere ( PT center,
float radius,
int numfaces1,
int numfaces2 )
Here is the caller graph for this function:

◆ sphere_anim()

GameApi::P GameApi::PolygonApi::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 )

◆ sphere_map()

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

◆ sphere_rays()

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

◆ sphere_rays2()

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

◆ spherical_normals()

GameApi::P GameApi::PolygonApi::spherical_normals ( P p,
float p_x,
float p_y,
float p_z )
Here is the caller graph for this function:

◆ spherical_wave()

GameApi::P GameApi::PolygonApi::spherical_wave ( P p,
float r1,
float fr_1,
float r2,
float fr_2 )
Here is the caller graph for this function:

◆ split_faces()

GameApi::ARR GameApi::PolygonApi::split_faces ( P p,
ATT att,
int max_attach )
Here is the caller graph for this function:

◆ split_p()

GameApi::P GameApi::PolygonApi::split_p ( P p,
int start_face,
int end_face )

◆ splitquads()

EXPORT GameApi::P GameApi::PolygonApi::splitquads ( P orig,
int x_count,
int y_count )
Here is the caller graph for this function:

◆ spotlight_shader()

EXPORT GameApi::ML GameApi::PolygonApi::spotlight_shader ( EveryApi & ev,
ML mainloop,
int light_color_id,
MN move )
Here is the caller graph for this function:

◆ sprite_bind() [1/2]

EXPORT GameApi::P GameApi::PolygonApi::sprite_bind ( P p,
Q bm,
TX tx )

◆ sprite_bind() [2/2]

EXPORT GameApi::P GameApi::PolygonApi::sprite_bind ( P p,
TX tx,
int id )

◆ sprite_bind_1()

GameApi::P GameApi::PolygonApi::sprite_bind_1 ( P p,
Q bm,
TX tx )
Here is the caller graph for this function:

◆ sprite_render()

EXPORT GameApi::ML GameApi::PolygonApi::sprite_render ( EveryApi & ev,
BM bm,
float start_x,
float end_x,
float start_y,
float end_y,
float z )
Here is the caller graph for this function:

◆ sprite_render_fade()

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

◆ sprite_render_inst()

EXPORT GameApi::ML GameApi::PolygonApi::sprite_render_inst ( EveryApi & ev,
BM bm,
PTS pts,
float start_x,
float end_x,
float start_y,
float end_y,
float z )
Here is the caller graph for this function:

◆ static_instancing()

GameApi::P GameApi::PolygonApi::static_instancing ( EveryApi & ev,
P obj,
PTS pos )
Here is the caller graph for this function:

◆ static_instancing_array()

GameApi::P GameApi::PolygonApi::static_instancing_array ( EveryApi & ev,
std::vector< P > vec,
PTS pos )
Here is the caller graph for this function:

◆ static_instancing_matrix()

GameApi::P GameApi::PolygonApi::static_instancing_matrix ( EveryApi & ev,
P obj,
MS matrix_array )
Here is the caller graph for this function:

◆ static_instancing_vertex_color()

GameApi::P GameApi::PolygonApi::static_instancing_vertex_color ( EveryApi & ev,
P obj,
PTS pos )
Here is the caller graph for this function:

◆ static_instancing_with_color()

GameApi::P GameApi::PolygonApi::static_instancing_with_color ( EveryApi & ev,
P obj,
BM bm,
float start_x,
float end_x,
float start_y,
float end_y,
float z )
Here is the caller graph for this function:

◆ stl_load()

GameApi::P GameApi::PolygonApi::stl_load ( std::string url)
Here is the caller graph for this function:

◆ subpoly_change()

EXPORT GameApi::P GameApi::PolygonApi::subpoly_change ( P p,
P p2,
O choose )
Here is the caller graph for this function:

◆ substitute()

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

◆ texcoord_cube()

IMPORT P GameApi::PolygonApi::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 )

◆ texcoord_cylindar()

EXPORT GameApi::P GameApi::PolygonApi::texcoord_cylindar ( P orig,
float start_y,
float end_y )

◆ texcoord_default()

EXPORT GameApi::P GameApi::PolygonApi::texcoord_default ( P orig)

◆ texcoord_from_normal()

GameApi::P GameApi::PolygonApi::texcoord_from_normal ( P p)
Here is the caller graph for this function:

◆ texcoord_from_normal2()

GameApi::P GameApi::PolygonApi::texcoord_from_normal2 ( P p)

◆ texcoord_function()

EXPORT GameApi::P GameApi::PolygonApi::texcoord_function ( P p1,
std::function< PT(int face, int point)> f )

◆ texcoord_manual()

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

◆ texcoord_plane()

EXPORT GameApi::P GameApi::PolygonApi::texcoord_plane ( P p,
float start_x,
float end_x,
float start_y,
float end_y )
Here is the caller graph for this function:

◆ texcoord_poly()

IMPORT P GameApi::PolygonApi::texcoord_poly ( P orig,
int facenum,
PT * array,
int size )

◆ texcoord_spherical()

EXPORT GameApi::P GameApi::PolygonApi::texcoord_spherical ( PT center,
P orig )

◆ texcoord_spherical2()

EXPORT GameApi::P GameApi::PolygonApi::texcoord_spherical2 ( EveryApi & ev,
PT center,
float r,
P orig )
Here is the caller graph for this function:

◆ texcoord_subarea()

GameApi::P GameApi::PolygonApi::texcoord_subarea ( P p,
float start_x,
float end_x,
float start_y,
float end_y )
Here is the caller graph for this function:

◆ texture()

EXPORT GameApi::P GameApi::PolygonApi::texture ( P orig,
BM bm,
int bm_choose = -1 )
Here is the caller graph for this function:

◆ texture_add()

GameApi::P GameApi::PolygonApi::texture_add ( P p,
BM bm )

◆ texture_arr_shader()

EXPORT GameApi::ML GameApi::PolygonApi::texture_arr_shader ( EveryApi & ev,
ML mainloop,
float mix = 0.5 )

◆ texture_cubemap_shader()

EXPORT GameApi::ML GameApi::PolygonApi::texture_cubemap_shader ( EveryApi & ev,
ML mainloop,
float mix = 0.5,
float mix2 = 0.5 )

◆ texture_from_p()

GameApi::BM GameApi::PolygonApi::texture_from_p ( P p,
int num )
Here is the caller graph for this function:

◆ texture_many_shader()

EXPORT GameApi::ML GameApi::PolygonApi::texture_many_shader ( EveryApi & ev,
ML mainloop,
float mix = 0.5 )

◆ texture_sbm()

GameApi::SBM GameApi::PolygonApi::texture_sbm ( )
Here is the caller graph for this function:

◆ texture_shader()

EXPORT GameApi::ML GameApi::PolygonApi::texture_shader ( EveryApi & ev,
ML mainloop,
float mix = 0.5 )

◆ texture_splitter()

GameApi::P GameApi::PolygonApi::texture_splitter ( P p,
int start_index,
int end_index )
Here is the caller graph for this function:

◆ texture_splitter2()

GameApi::P GameApi::PolygonApi::texture_splitter2 ( P p,
int num,
int num_slots,
int current_slot )
Here is the caller graph for this function:

◆ texture_storage()

GameApi::P GameApi::PolygonApi::texture_storage ( P p,
int texture_sx,
int texture_sy )
Here is the caller graph for this function:

◆ tf_ds_inv()

GameApi::DS GameApi::PolygonApi::tf_ds_inv ( TF tf,
int flags )

◆ tf_glb_tf()

GameApi::TF GameApi::PolygonApi::tf_glb_tf ( EveryApi & ev,
TF tf,
std::string url )
Here is the caller graph for this function:

◆ toon_outline()

GameApi::P GameApi::PolygonApi::toon_outline ( P p,
float border_width )

◆ toon_shader()

EXPORT GameApi::ML GameApi::PolygonApi::toon_shader ( EveryApi & ev,
ML mainloop )
Here is the caller graph for this function:

◆ torus()

EXPORT GameApi::P GameApi::PolygonApi::torus ( int numfaces1,
int numfaces2,
PT center,
V u_x,
V u_y,
float radius1,
V uu_x,
V uu_y,
float radius2 )
Here is the caller graph for this function:

◆ torus2()

EXPORT GameApi::P GameApi::PolygonApi::torus2 ( EveryApi & ev,
int numfaces1,
int numfacesw2,
PT center,
float radius1,
float radius2 )
Here is the caller graph for this function:

◆ translate()

EXPORT GameApi::P GameApi::PolygonApi::translate ( P orig,
float dx,
float dy,
float dz )
Here is the caller graph for this function:

◆ translate_1()

GameApi::P GameApi::PolygonApi::translate_1 ( P orig,
float dx,
float dy,
float dz )
Here is the caller graph for this function:

◆ transparent_separate()

GameApi::P GameApi::PolygonApi::transparent_separate ( P p,
BM bm,
bool opaque,
bool force_transparent,
bool force_opaque )
Here is the caller graph for this function:

◆ transparent_separate2()

GameApi::P GameApi::PolygonApi::transparent_separate2 ( P p,
std::vector< BM > vec,
bool opaque )
Here is the caller graph for this function:

◆ tri_strip()

EXPORT GameApi::P GameApi::PolygonApi::tri_strip ( PT * array,
int size )

◆ tri_to_quad()

EXPORT GameApi::P GameApi::PolygonApi::tri_to_quad ( P p)

◆ tri_vertex_array()

EXPORT GameApi::P GameApi::PolygonApi::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 )

◆ triangle()

EXPORT GameApi::P GameApi::PolygonApi::triangle ( PT p1,
PT p2,
PT p3 )
Here is the caller graph for this function:

◆ unit_cube()

EXPORT GameApi::P GameApi::PolygonApi::unit_cube ( P orig,
PT pos,
V u_x,
V u_y,
V u_z )

◆ unit_to_cube()

EXPORT GameApi::P GameApi::PolygonApi::unit_to_cube ( P orig,
PT pos,
V u_x,
V u_y,
V u_z )

◆ unit_to_flex()

EXPORT GameApi::P GameApi::PolygonApi::unit_to_flex ( P orig,
PT bTL,
PT bTR,
PT bBL,
PT bBR,
PT fTL,
PT fTR,
PT fBL,
PT fBR )

◆ update()

EXPORT void GameApi::PolygonApi::update ( VA va)

◆ update_vertex_array()

EXPORT void GameApi::PolygonApi::update_vertex_array ( GameApi::VA va,
GameApi::P p,
bool keep = false )
Here is the caller graph for this function:

◆ update_vertex_array_ml()

EXPORT GameApi::ML GameApi::PolygonApi::update_vertex_array_ml ( GameApi::VA va,
GameApi::P p,
bool keep = false )

◆ update_vertex_array_no_memory()

EXPORT void GameApi::PolygonApi::update_vertex_array_no_memory ( GameApi::VA va,
GameApi::P p )

◆ vertex_phong_shader()

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

◆ voxelarray_to_pts()

GameApi::PTS GameApi::PolygonApi::voxelarray_to_pts ( AV arr,
float start_x,
float end_x,
float start_y,
float end_y,
float start_z,
float end_z )
Here is the caller graph for this function:

◆ vr_fullscreen_quad()

EXPORT GameApi::P GameApi::PolygonApi::vr_fullscreen_quad ( EveryApi & ev,
bool is_right )
Here is the caller graph for this function:

◆ water_shader()

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

◆ wave_shader()

GameApi::ML GameApi::PolygonApi::wave_shader ( EveryApi & ev,
ML mainloop,
float radius,
float t_mult,
float x_mult,
float y_mult )
Here is the caller graph for this function:

◆ world_from_bitmap() [1/2]

EXPORT GameApi::P GameApi::PolygonApi::world_from_bitmap ( EveryApi & ev,
std::vector< P > vec,
std::string filename,
std::string chars,
float dx,
float dy,
int sx,
int sy )

◆ world_from_bitmap() [2/2]

EXPORT GameApi::P GameApi::PolygonApi::world_from_bitmap ( std::function< P(int c)> f,
BM int_bm,
float dx,
float dy,
int max_c )
Here is the caller graph for this function:

◆ world_from_bitmap2()

EXPORT GameApi::P GameApi::PolygonApi::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 )

◆ world_from_voxel()

EXPORT GameApi::P GameApi::PolygonApi::world_from_voxel ( std::function< P(unsigned int c)> f,
VX voxel,
float dx,
float dy,
float dz,
int max_c )

◆ x_split()

GameApi::P GameApi::PolygonApi::x_split ( P p,
float x,
float x_0,
float x_1 )
Here is the caller graph for this function:

◆ y_split()

GameApi::P GameApi::PolygonApi::y_split ( P p,
float y,
float y_0,
float y_1 )
Here is the caller graph for this function:

◆ z_split()

GameApi::P GameApi::PolygonApi::z_split ( P p,
float z,
float z_0,
float z_1 )
Here is the caller graph for this function:
The documentation for this class was generated from the following files: