|
GameApi 28
Library used by GameApi Builder tool
|
#include <GameApi.hh>
Public Member Functions | |
| IMPORT | PointsApi (Env &e) |
| IMPORT PTS | combine_pts (PTS p1, PTS p2) |
| IMPORT int | colour_divisor_calc (P p) |
| IMPORT PTS | world_filter (PTS points) |
| IMPORT ML | world_filter_cursor (ML ml, float start_delta_x, float end_delta_x, float start_delta_y, float end_delta_y, float start_delta_z, float end_delta_z) |
| IMPORT ML | publish_heightfield (ML ml, CFB landscape, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z) |
| IMPORT CFB | cbm_to_cfb (CBM bm, float red_mult, float red_add, float green_mult, float green_add, float blue_mult, float blue_add, float alpha_mult, float alpha_add) |
| IMPORT PTS | height_field_pts (PTS points, CFB landscape, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z) |
| IMPORT P | height_field_p (P faces, CFB landscape, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z) |
| IMPORT PTS | block_pts_debug () |
| IMPORT PTS | random_points_in_plane (EveryApi &ev, float key, float start_x, float end_x, float start_z, float end_z, float y, int num) |
| IMPORT PTS | pts_lines (std::string url, float start_pos, float dist, float speed) |
| IMPORT PTS | block_pts (PTS pts, float d, int max_points_visible) |
| IMPORT PTS | block_pts_lod (PTS pts, float start_x, float end_x, float start_y, float end_y, int max_points_visible, float ncd_z_s, float ncd_z_e) |
| IMPORT MS | block_ms_lod (MS pts, float start_x, float end_x, float start_y, float end_y, int max_points_visible, float ncd_z_s, float ncd_z_e) |
| IMPORT PTS | load_points (std::string url) |
| IMPORT PTS | pts_alt (std::vector< PTS > vec, int index) |
| IMPORT PTS | points_field (float start_speed_y, float end_speed_y, int numpoints, float start_x, float end_x, float start_y, float end_y) |
| IMPORT P | ply_faces (std::string url) |
| IMPORT PTS | ply_pts (std::string url) |
| IMPORT PTS | iterate_points (PTS points, VFi field, FA speed) |
| IMPORT VFi | pressure_gradient (FFi pressure) |
| IMPORT VFi | matrix_field (MN start, MN end) |
| IMPORT FA | random_speeds (float start_speed, float end_speed, int num) |
| IMPORT PTS | bullet (int key, float vx, float vy, float vz, float px, float py, float pz, float dist, int max_count, float repeat_time) |
| IMPORT PTS | voxelarray_to_pts (AV arr) |
| IMPORT PTS | polygon_face_center_points (P p) |
| IMPORT PTS | single_pts () |
| IMPORT PTS | pt_array (EveryApi &ev, std::vector< PT > vec) |
| IMPORT PTS | function (std::function< PT(int pointnum)> f, int numpoints) |
| IMPORT PTS | color_function (PTS orig, std::function< unsigned int(int pointnum, PT pos)> f) |
| IMPORT PTS | collision_points (float start_x, float end_x, float start_y, float end_y, float start_z, float end_z) |
| IMPORT ML | collision_bind (EveryApi &ev, PTS bounding_box, std::string name) |
| IMPORT ML | collision_bind_inst (EveryApi &ev, PTS bounding_box, PTS inst_points, std::string name) |
| IMPORT ML | collision_collect (ML mainloop) |
| IMPORT PTS | from_float_volume (FO float_volume, int numpoints, float start_x, float start_y, float start_z, float end_x, float end_y, float end_z) |
| IMPORT PTS | color_points (PTS p, unsigned int color) |
| IMPORT PTS | li_pts (LI li, float pos) |
| IMPORT PTS | li_pts2 (LI li) |
| IMPORT PTS | hemisphere_points (PT points, V normal, float r, int numpoints) |
| IMPORT PTS | pts_grid (BM bm, float start_x, float end_x, float start_y, float en_y, float z) |
| IMPORT PTS | pts_grid_bb (BB bb, float start_x, float end_x, float start_y, float en_y, float z) |
| IMPORT PTS | or_points (PTS p1, PTS p2) |
| IMPORT PTS | sort_pts (PTS p) |
| IMPORT PTS | heightmap (BM colour, FB floatbitmap, PT pos, V u_x, V u_y, V u_z, int sx, int sy) |
| IMPORT PTS | random_plane (PT pos, V u_x, V u_y, int numpoints) |
| IMPORT PTS | random_bitmap_instancing (EveryApi &ev, BB bm, int count, float start_x, float end_x, float start_y, float end_y, float z) |
| IMPORT PTS | random_mesh_quad_instancing (EveryApi &ev, P p, int count) |
| IMPORT PTS | random_mesh_quad_instancing_color (EveryApi &ev, P p, int count, std::vector< BM > textures) |
| IMPORT PTS | random_lattice (EveryApi &ev, int sx, int sy, int sz, float s_x, float s_y, float s_z, float px, float py, float pz, int count) |
| IMPORT PTS | surface (S surf, int sx, int sy) |
| IMPORT PTS | surface (std::function< PT(float, float)> surf, std::function< unsigned int(PT, float, float)> color, float start_u, float end_u, float start_v, float end_v, float step_u, float step_v) |
| IMPORT PTS | from_volume (O o, PT pos, V u_x, V u_y, V u_z, int sx, int sy, int sz) |
| IMPORT PTS | anim_mix (PTS o1, PTS o2, float start_val, float end_val, float start_time, float end_time) |
| IMPORT PTS | move (PTS obj, float dx, float dy, float dz) |
| IMPORT PTS | scale (PTS obj, float sx, float sy, float sz) |
| IMPORT PTS | rot_x (PTS obj, float angle) |
| IMPORT PTS | rot_y (PTS obj, float angle) |
| IMPORT PTS | rot_z (PTS obj, float angle) |
| IMPORT PTS | shadow_points (PTS obj, PT pos, V u_x, V u_y, V light_vec) |
| IMPORT PTS | unit_cube (PTS orig, PT pos, V u_x, V u_y, V u_z) |
| IMPORT PTS | unit_to_cube (PTS orig, PT pos, V u_x, V u_y, V u_z) |
| IMPORT PTS | unit_to_flex (PTS orig, PT bTL, PT bTR, PT bBL, PT bBR, PT fTL, PT fTR, PT fBL, PT fBR) |
| IMPORT PTS | wave_points (WV wave, int num_samples, float pos_x, float pos_y, float pos_z, float u_x_x, float u_x_y, float u_x_z, float u_y_x, float u_y_y, float u_y_z) |
| IMPORT PTS | filter_component (PTS pts, int comp, float val) |
| IMPORT PTS | anim_rot_pts (PTS pts, float start_time, float end_time, float v_x, float v_y, float v_z, float rotate_amount) |
| IMPORT PTA | prepare (PTS p, bool color_from_instance) |
| IMPORT int | num_points (PTA pta) |
| IMPORT int | num_points (MSA pta) |
| float * | point_access (PTA pta, int pointnum) |
| IMPORT void | set_point (PTA pta, int pointnum, float x, float y, float z) |
| void | update_from_data (PTA array, PTS p, bool draw=true) |
| void | update_from_data (MSA array, MS p, bool draw=true) |
| void | update (PTA array, GameApi::P pp, bool slow=false) |
| IMPORT void | render (PTA array) |
| IMPORT ML | render_ml (EveryApi &ev, PTA array) |
| IMPORT void | explode (PTA array, float x, float y, float z, float dist) |
| IMPORT PTS | standard_box (int sx, int sy, int sz, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z) |
| IMPORT PTS | matrix_points (PTS orig, M matrix) |
| IMPORT LI | matrix_display (EveryApi &ev, M matrix) |
| IMPORT LI | matrix2_display (EveryApi &ev, M matrix1, M matrix2, int sx, int sy, int sz, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z) |
| IMPORT ML | movement_display (EveryApi &ev, ML ml, MN mn, int count, int sx, int sy, int sz, float start_x, float end_x, float start_y, float end_y, float start_z, float end_z) |
| IMPORT int | NumPoints (PTS p) |
| IMPORT int | NumPoints (MS p) |
| IMPORT float | pos_x (PTS p, int index) |
| IMPORT float | pos_y (PTS p, int index) |
| IMPORT float | pos_z (PTS p, int index) |
| IMPORT ML | pts_render (EveryApi &ev, PTS pts) |
| IMPORT LI | li_from_pts (PTS pts, float dx, float dy, float dz) |
| IMPORT PTS | memoize_pts (PTS pts) |
| GameApi::PointsApi::PointsApi | ( | Env & | e | ) |

| EXPORT GameApi::PTS GameApi::PointsApi::anim_mix | ( | GameApi::PTS | obj1, |
| GameApi::PTS | obj2, | ||
| float | start_val, | ||
| float | end_val, | ||
| float | start_time, | ||
| float | end_time ) |

| GameApi::PTS GameApi::PointsApi::anim_rot_pts | ( | PTS | pts, |
| float | start_time, | ||
| float | end_time, | ||
| float | v_x, | ||
| float | v_y, | ||
| float | v_z, | ||
| float | rotate_amount ) |

| GameApi::MS GameApi::PointsApi::block_ms_lod | ( | GameApi::MS | ms, |
| float | start_x, | ||
| float | end_x, | ||
| float | start_y, | ||
| float | end_y, | ||
| int | max_points_visible, | ||
| float | ncd_z_s, | ||
| float | ncd_z_e ) |
| GameApi::PTS GameApi::PointsApi::block_pts | ( | GameApi::PTS | pts, |
| float | d, | ||
| int | max_points_visible ) |

| GameApi::PTS GameApi::PointsApi::block_pts_debug | ( | ) |

| GameApi::PTS GameApi::PointsApi::block_pts_lod | ( | GameApi::PTS | pts, |
| float | start_x, | ||
| float | end_x, | ||
| float | start_y, | ||
| float | end_y, | ||
| int | max_points_visible, | ||
| float | ncd_z_s, | ||
| float | ncd_z_e ) |

| GameApi::PTS GameApi::PointsApi::bullet | ( | int | key, |
| float | vx, | ||
| float | vy, | ||
| float | vz, | ||
| float | px, | ||
| float | py, | ||
| float | pz, | ||
| float | dist, | ||
| int | max_count, | ||
| float | repeat_time ) |

| GameApi::CFB GameApi::PointsApi::cbm_to_cfb | ( | CBM | bm, |
| float | red_mult, | ||
| float | red_add, | ||
| float | green_mult, | ||
| float | green_add, | ||
| float | blue_mult, | ||
| float | blue_add, | ||
| float | alpha_mult, | ||
| float | alpha_add ) |

| GameApi::ML GameApi::PointsApi::collision_bind | ( | EveryApi & | ev, |
| PTS | bounding_box, | ||
| std::string | name ) |

| GameApi::ML GameApi::PointsApi::collision_bind_inst | ( | EveryApi & | ev, |
| PTS | bounding_box, | ||
| PTS | inst_points, | ||
| std::string | name ) |

| GameApi::ML GameApi::PointsApi::collision_collect | ( | ML | mainloop | ) |

| GameApi::PTS GameApi::PointsApi::collision_points | ( | float | start_x, |
| float | end_x, | ||
| float | start_y, | ||
| float | end_y, | ||
| float | start_z, | ||
| float | end_z ) |

| EXPORT GameApi::PTS GameApi::PointsApi::color_function | ( | PTS | orig, |
| std::function< unsigned int(int pointnum, PT pos)> | f ) |
| GameApi::PTS GameApi::PointsApi::color_points | ( | PTS | p, |
| unsigned int | color ) |

| int GameApi::PointsApi::colour_divisor_calc | ( | GameApi::P | pp | ) |

| GameApi::PTS GameApi::PointsApi::combine_pts | ( | PTS | p1, |
| PTS | p2 ) |

| EXPORT void GameApi::PointsApi::explode | ( | GameApi::PTA | array, |
| float | x, | ||
| float | y, | ||
| float | z, | ||
| float | dist ) |
| GameApi::PTS GameApi::PointsApi::filter_component | ( | PTS | pts, |
| int | comp, | ||
| float | val ) |

| EXPORT GameApi::PTS GameApi::PointsApi::from_float_volume | ( | GameApi::FO | object, |
| int | numpoints, | ||
| float | start_x, | ||
| float | start_y, | ||
| float | start_z, | ||
| float | end_x, | ||
| float | end_y, | ||
| float | end_z ) |

| EXPORT GameApi::PTS GameApi::PointsApi::from_volume | ( | GameApi::O | o, |
| GameApi::PT | pos, | ||
| GameApi::V | u_x, | ||
| GameApi::V | u_y, | ||
| GameApi::V | u_z, | ||
| int | sx, | ||
| int | sy, | ||
| int | sz ) |

| EXPORT GameApi::PTS GameApi::PointsApi::function | ( | std::function< PT(int pointnum)> | f, |
| int | numpoints ) |
| GameApi::P GameApi::PointsApi::height_field_p | ( | P | faces, |
| CFB | landscape, | ||
| float | start_x, | ||
| float | end_x, | ||
| float | start_y, | ||
| float | end_y, | ||
| float | start_z, | ||
| float | end_z ) |

| GameApi::PTS GameApi::PointsApi::height_field_pts | ( | PTS | points, |
| CFB | landscape, | ||
| float | start_x, | ||
| float | end_x, | ||
| float | start_y, | ||
| float | end_y, | ||
| float | start_z, | ||
| float | end_z ) |

| EXPORT GameApi::PTS GameApi::PointsApi::heightmap | ( | BM | colour, |
| FB | floatbitmap, | ||
| PT | pos, | ||
| V | u_x, | ||
| V | u_y, | ||
| V | u_z, | ||
| int | sx, | ||
| int | sy ) |
| GameApi::PTS GameApi::PointsApi::hemisphere_points | ( | PT | points, |
| V | normal, | ||
| float | r, | ||
| int | numpoints ) |

| GameApi::PTS GameApi::PointsApi::iterate_points | ( | PTS | points, |
| VFi | field, | ||
| FA | speed ) |

| GameApi::LI GameApi::PointsApi::li_from_pts | ( | PTS | pts, |
| float | dx, | ||
| float | dy, | ||
| float | dz ) |

| GameApi::PTS GameApi::PointsApi::li_pts | ( | LI | li, |
| float | pos ) |

| GameApi::PTS GameApi::PointsApi::li_pts2 | ( | LI | li | ) |

| GameApi::PTS GameApi::PointsApi::load_points | ( | std::string | url | ) |

| GameApi::LI GameApi::PointsApi::matrix2_display | ( | EveryApi & | ev, |
| M | matrix1, | ||
| M | matrix2, | ||
| int | sx, | ||
| int | sy, | ||
| int | sz, | ||
| float | start_x, | ||
| float | end_x, | ||
| float | start_y, | ||
| float | end_y, | ||
| float | start_z, | ||
| float | end_z ) |
| GameApi::LI GameApi::PointsApi::matrix_display | ( | EveryApi & | ev, |
| M | matrix ) |

| GameApi::PTS GameApi::PointsApi::matrix_points | ( | PTS | orig, |
| M | matrix ) |

| GameApi::PTS GameApi::PointsApi::memoize_pts | ( | PTS | pts | ) |

| EXPORT GameApi::PTS GameApi::PointsApi::move | ( | GameApi::PTS | obj, |
| float | dx, | ||
| float | dy, | ||
| float | dz ) |

| GameApi::ML GameApi::PointsApi::movement_display | ( | EveryApi & | ev, |
| ML | ml, | ||
| MN | mn, | ||
| int | count, | ||
| int | sx, | ||
| int | sy, | ||
| int | sz, | ||
| float | start_x, | ||
| float | end_x, | ||
| float | start_y, | ||
| float | end_y, | ||
| float | start_z, | ||
| float | end_z ) |

| int GameApi::PointsApi::num_points | ( | MSA | pta | ) |
| int GameApi::PointsApi::num_points | ( | PTA | pta | ) |
| EXPORT GameApi::PTS GameApi::PointsApi::or_points | ( | GameApi::PTS | p1, |
| GameApi::PTS | p2 ) |

| GameApi::P GameApi::PointsApi::ply_faces | ( | std::string | url | ) |

| GameApi::PTS GameApi::PointsApi::ply_pts | ( | std::string | url | ) |

| float * GameApi::PointsApi::point_access | ( | GameApi::PTA | pta, |
| int | pointnum ) |

| GameApi::PTS GameApi::PointsApi::points_field | ( | float | start_speed_y, |
| float | end_speed_y, | ||
| int | numpoints, | ||
| float | start_x, | ||
| float | end_x, | ||
| float | start_y, | ||
| float | end_y ) |

| GameApi::PTS GameApi::PointsApi::polygon_face_center_points | ( | P | p | ) |




| EXPORT GameApi::PTA GameApi::PointsApi::prepare | ( | GameApi::PTS | p, |
| bool | color_from_instance ) |
color[i] = swap_color(c);

| GameApi::VFi GameApi::PointsApi::pressure_gradient | ( | FFi | pressure | ) |

| GameApi::PTS GameApi::PointsApi::pt_array | ( | EveryApi & | ev, |
| std::vector< PT > | vec ) |

| GameApi::PTS GameApi::PointsApi::pts_alt | ( | std::vector< PTS > | vec, |
| int | index ) |

| GameApi::PTS GameApi::PointsApi::pts_grid | ( | BM | bm, |
| float | start_x, | ||
| float | end_x, | ||
| float | start_y, | ||
| float | en_y, | ||
| float | z ) |

| GameApi::PTS GameApi::PointsApi::pts_grid_bb | ( | BB | bb, |
| float | start_x, | ||
| float | end_x, | ||
| float | start_y, | ||
| float | en_y, | ||
| float | z ) |

| GameApi::PTS GameApi::PointsApi::pts_lines | ( | std::string | url, |
| float | start_pos, | ||
| float | dist, | ||
| float | speed ) |

| GameApi::ML GameApi::PointsApi::pts_render | ( | EveryApi & | ev, |
| PTS | pts ) |

| GameApi::ML GameApi::PointsApi::publish_heightfield | ( | ML | ml, |
| CFB | landscape, | ||
| float | start_x, | ||
| float | end_x, | ||
| float | start_y, | ||
| float | end_y, | ||
| float | start_z, | ||
| float | end_z ) |

| GameApi::PTS GameApi::PointsApi::random_bitmap_instancing | ( | EveryApi & | ev, |
| BB | bm, | ||
| int | count, | ||
| float | start_x, | ||
| float | end_x, | ||
| float | start_y, | ||
| float | end_y, | ||
| float | z ) |

| GameApi::PTS GameApi::PointsApi::random_lattice | ( | EveryApi & | ev, |
| int | sx, | ||
| int | sy, | ||
| int | sz, | ||
| float | s_x, | ||
| float | s_y, | ||
| float | s_z, | ||
| float | px, | ||
| float | py, | ||
| float | pz, | ||
| int | count ) |

| GameApi::PTS GameApi::PointsApi::random_mesh_quad_instancing | ( | EveryApi & | ev, |
| P | p, | ||
| int | count ) |

| GameApi::PTS GameApi::PointsApi::random_mesh_quad_instancing_color | ( | EveryApi & | ev, |
| P | p, | ||
| int | count, | ||
| std::vector< BM > | textures ) |
| EXPORT GameApi::PTS GameApi::PointsApi::random_plane | ( | PT | pos, |
| V | u_x, | ||
| V | u_y, | ||
| int | numpoints ) |

| GameApi::PTS GameApi::PointsApi::random_points_in_plane | ( | EveryApi & | ev, |
| float | key, | ||
| float | start_x, | ||
| float | end_x, | ||
| float | start_z, | ||
| float | end_z, | ||
| float | y, | ||
| int | num ) |

| GameApi::FA GameApi::PointsApi::random_speeds | ( | float | start_speed, |
| float | end_speed, | ||
| int | num ) |

| EXPORT void GameApi::PointsApi::render | ( | GameApi::PTA | array | ) |
| GameApi::ML GameApi::PointsApi::render_ml | ( | EveryApi & | ev, |
| PTA | array ) |

| EXPORT GameApi::PTS GameApi::PointsApi::rot_x | ( | GameApi::PTS | obj, |
| float | angle ) |

| EXPORT GameApi::PTS GameApi::PointsApi::rot_y | ( | GameApi::PTS | obj, |
| float | angle ) |

| EXPORT GameApi::PTS GameApi::PointsApi::rot_z | ( | GameApi::PTS | obj, |
| float | angle ) |

| EXPORT GameApi::PTS GameApi::PointsApi::scale | ( | PTS | obj, |
| float | sx, | ||
| float | sy, | ||
| float | sz ) |

| EXPORT GameApi::PTS GameApi::PointsApi::shadow_points | ( | GameApi::PTS | obj, |
| PT | pos, | ||
| V | u_x, | ||
| V | u_y, | ||
| V | light_vec ) |

| GameApi::PTS GameApi::PointsApi::single_pts | ( | ) |
| GameApi::PTS GameApi::PointsApi::sort_pts | ( | PTS | p | ) |

| GameApi::PTS GameApi::PointsApi::standard_box | ( | int | sx, |
| int | sy, | ||
| int | sz, | ||
| float | start_x, | ||
| float | end_x, | ||
| float | start_y, | ||
| float | end_y, | ||
| float | start_z, | ||
| float | end_z ) |

| EXPORT GameApi::PTS GameApi::PointsApi::surface | ( | S | surf, |
| int | sx, | ||
| int | sy ) |
| EXPORT GameApi::PTS GameApi::PointsApi::surface | ( | std::function< PT(float, float)> | surf, |
| std::function< unsigned int(PT, float, float)> | color, | ||
| float | start_u, | ||
| float | end_u, | ||
| float | start_v, | ||
| float | end_v, | ||
| float | step_u, | ||
| float | step_v ) |
| IMPORT PTS GameApi::PointsApi::unit_to_flex | ( | PTS | orig, |
| PT | bTL, | ||
| PT | bTR, | ||
| PT | bBL, | ||
| PT | bBR, | ||
| PT | fTL, | ||
| PT | fTR, | ||
| PT | fBL, | ||
| PT | fBR ) |
| void GameApi::PointsApi::update | ( | GameApi::PTA | pta, |
| GameApi::P | pp, | ||
| bool | slow = false ) |
| void GameApi::PointsApi::update_from_data | ( | MSA | array, |
| MS | p, | ||
| bool | draw = true ) |
| void GameApi::PointsApi::update_from_data | ( | GameApi::PTA | pta, |
| GameApi::PTS | p, | ||
| bool | draw = true ) |
| GameApi::PTS GameApi::PointsApi::wave_points | ( | WV | wave, |
| int | num_samples, | ||
| float | pos_x, | ||
| float | pos_y, | ||
| float | pos_z, | ||
| float | u_x_x, | ||
| float | u_x_y, | ||
| float | u_x_z, | ||
| float | u_y_x, | ||
| float | u_y_y, | ||
| float | u_y_z ) |

| GameApi::PTS GameApi::PointsApi::world_filter | ( | PTS | points | ) |

| GameApi::ML GameApi::PointsApi::world_filter_cursor | ( | ML | ml, |
| float | start_delta_x, | ||
| float | end_delta_x, | ||
| float | start_delta_y, | ||
| float | end_delta_y, | ||
| float | start_delta_z, | ||
| float | end_delta_z ) |
