Created
April 25, 2013 04:54
-
-
Save graphitemaster/5457575 to your computer and use it in GitHub Desktop.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| module gmqcc_out | |
| function CSQC_Init | |
| 1 locals: | |
| i | |
| liferanges: | |
| i: float [local] locked @0 [13,30] [35,46] | |
| call0: string [value] @0 [null] | |
| call1: void [return] @0 [null] | |
| call2: string [value] callparam @0 [3,4] | |
| call3: void [return] @0 [null] | |
| call4: float [value] @0 [null] | |
| call5: float [value] @0 [null] | |
| call6: float [value] @0 [null] | |
| call7: void [return] @0 [null] | |
| call8: void [return] @0 [null] | |
| bin10: float [value] @0 [16,17] | |
| call14: string [return] @0 [22,23] | |
| bin15: float [value] @0 [23,24] | |
| binst18: float [value] @0 [null] | |
| call19: void [return] @0 [null] | |
| call20: float [return] @0 [32,32] | |
| call21: float [return] @0 [33,33] | |
| bin23: float [value] @0 [38,39] | |
| call27: string [value] callparam @0 [44,45] | |
| store28: void [return] @0 [null] | |
| binst29: float [value] @0 [null] | |
| call30: entity [value] @0 [null] | |
| call31: entity [value] @0 [null] | |
| call32: entity [return] @0 [52,52] | |
| call33: void [return] @0 [null] | |
| call34: void [return] @0 [null] | |
| call35: void [return] @0 [null] | |
| call36: void [return] @0 [null] | |
| call37: void [return] @0 [null] | |
| call38: void [return] @0 [null] | |
| call39: void [return] @0 [null] | |
| call40: void [return] @0 [null] | |
| call42: void [return] @0 [null] | |
| call43: void [return] @0 [null] | |
| call44: void [return] @0 [null] | |
| call45: void [return] @0 [null] | |
| call46: void [return] @0 [null] | |
| call48: void [return] @0 [null] | |
| call49: void [return] @0 [null] | |
| call50: void [return] @0 [null] | |
| call51: void [return] @0 [null] | |
| call52: void [return] @0 [null] | |
| call53: void [return] @0 [null] | |
| call54: void [return] @0 [null] | |
| call55: void [return] @0 [null] | |
| call56: void [return] @0 [null] | |
| call57: void [return] @0 [null] | |
| call60: string [return] @0 [84,84] | |
| call63: string [return] @0 [89,89] | |
| call66: void [return] @0 [null] | |
| call67: string [value] @0 [null] | |
| call68: string [return] @0 [97,98] | |
| bin69: float [value] @0 [98,99] | |
| call71: string [value] @0 [null] | |
| call72: string [return] @0 [102,103] | |
| bin73: float [value] @0 [103,104] | |
| call76: void [return] @0 [null] | |
| bin79: vector [value] @0 [114,115] | |
| bin79_x: @0 [114,115] | |
| bin79_y: @0 [114,115] | |
| bin79_z: @0 [114,115] | |
| bin80: vector [value] @0 [null] | |
| bin80_x: @0 | |
| bin80_y: @0 | |
| bin80_z: @0 | |
| bin81: vector [value] @0 [null] | |
| bin81_x: @0 | |
| bin81_y: @0 | |
| bin81_z: @0 | |
| call82: string [value] @0 [null] | |
| call83: void [return] @0 [null] | |
| call84: string [value] callparam @0 [119,120] | |
| call85: string [value] @0 [null] | |
| call86: string [value] callparam @0 [123,124] | |
| call87: string [value] callparam @0 [124,125] | |
| call88: string [value] @0 [null] | |
| life passes: 4 | |
| :entry | |
| (0) [entry] | |
| (1) prvm_language <- CALL1 fn:cvar_string params: #IMMEDIATE, | |
| (2) call1 <- CALL0 fn:check_unacceptable_compiler_bugs | |
| (3) call2 <- CALL2 fn:sprintf params: dotranslate_594, #IMMEDIATE, | |
| (4) call3 <- CALL1 fn:print params: call2, | |
| (5) binddb <- CALL0 fn:db_create | |
| (6) tempdb <- CALL0 fn:db_create | |
| (7) ClientProgsDB <- CALL1 fn:db_load params: #IMMEDIATE, | |
| (8) call7 <- CALL0 fn:compressShortVector_init | |
| (9) call8 <- CALL0 fn:draw_endBoldFont | |
| (10) menu_visible <- STORE_F 0 | |
| (11) menu_show <- STORE_FNC fn:menu_show_error | |
| (12) menu_action <- STORE_FNC nil | |
| (13) i <- STORE_F 0 | |
| (14) JUMP [pre_loop_cond9] | |
| :pre_loop_cond9 | |
| (15) [entry] | |
| (16) bin10 <- LT i, 255 | |
| (17) COND bin10, [loop_body13], [after_loop12] | |
| :loop_increment11 | |
| (18) [entry] | |
| (19) i <- ADD_F i, 1 | |
| (20) JUMP [pre_loop_cond9] | |
| :loop_body13 | |
| (21) [entry] | |
| (22) call14 <- CALL2 fn:getplayerkeyvalue params: i, #IMMEDIATE, | |
| (23) bin15 <- EQ_S call14, "" | |
| (24) COND bin15, [ontrue16], [endif17] | |
| :ontrue16 | |
| (25) [entry] | |
| (26) JUMP [after_loop12] | |
| :endif17 | |
| (27) [entry] | |
| (28) JUMP [loop_increment11] | |
| :after_loop12 | |
| (29) [entry] | |
| (30) maxclients <- STORE_F i | |
| (31) call19 <- CALL0 fn:ConsoleCommand_macro_init | |
| (32) call20 <- CALL2 fn:registercvar params: #IMMEDIATE, #IMMEDIATE, | |
| (33) call21 <- CALL2 fn:registercvar params: #IMMEDIATE, #IMMEDIATE, | |
| (34) gametype <- STORE_F 0 | |
| (35) i <- STORE_F 0 | |
| (36) JUMP [pre_loop_cond22] | |
| :pre_loop_cond22 | |
| (37) [entry] | |
| (38) bin23 <- LT i, 16 | |
| (39) COND bin23, [loop_body26], [after_loop25] | |
| :loop_increment24 | |
| (40) [entry] | |
| (41) i <- ADD_F i, 1 | |
| (42) JUMP [pre_loop_cond22] | |
| :loop_body26 | |
| (43) [entry] | |
| (44) call27 <- CALL1 fn:strzone params: #IMMEDIATE, | |
| (45) store28 <- CALL2 fn:hud_title##SET params: i, call27, | |
| (46) JUMP [loop_increment24] | |
| :after_loop25 | |
| (47) [entry] | |
| (48) postinit <- STORE_F 0 | |
| (49) calledhooks <- STORE_F 0 | |
| (50) teams <- CALL0 fn:Sort_Spawn | |
| (51) players <- CALL0 fn:Sort_Spawn | |
| (52) call32 <- CALL2 fn:GetTeam params: NUM_SPECTATOR, true, | |
| (53) call33 <- CALL0 fn:__merge__register_weapons_done | |
| (54) call34 <- CALL0 fn:__merge__RegisterGametypes_g_keepaway | |
| (55) call35 <- CALL0 fn:__merge__RegisterNotifications_Done | |
| (56) call36 <- CALL0 fn:__merge__RegisterDeathtype_DEATH_WEAPON | |
| (57) call37 <- CALL0 fn:WaypointSprite_Load | |
| (58) call38 <- CALL1 fn:precache_model params: #IMMEDIATE, | |
| (59) call39 <- CALL1 fn:precache_sound params: #IMMEDIATE, | |
| (60) call40 <- CALL1 fn:precache_sound params: #IMMEDIATE, | |
| (61) COND autocvar_cl_precacheplayermodels, [ontrue41], [endif47] | |
| :ontrue41 | |
| (62) [entry] | |
| (63) call42 <- CALL1 fn:precache_all_playermodels params: #IMMEDIATE, | |
| (64) call43 <- CALL1 fn:precache_all_playermodels params: #IMMEDIATE, | |
| (65) call44 <- CALL1 fn:precache_all_playermodels params: #IMMEDIATE, | |
| (66) call45 <- CALL1 fn:precache_all_playermodels params: #IMMEDIATE, | |
| (67) call46 <- CALL1 fn:precache_all_playermodels params: #IMMEDIATE, | |
| (68) JUMP [endif47] | |
| :endif47 | |
| (69) [entry] | |
| (70) call48 <- CALL0 fn:Projectile_Precache | |
| (71) call49 <- CALL0 fn:Hook_Precache | |
| (72) call50 <- CALL0 fn:GibSplash_Precache | |
| (73) call51 <- CALL0 fn:Casings_Precache | |
| (74) call52 <- CALL0 fn:DamageInfo_Precache | |
| (75) call53 <- CALL0 fn:Vehicles_Precache | |
| (76) call54 <- CALL0 fn:turrets_precache | |
| (77) call55 <- CALL0 fn:Announcer_Precache | |
| (78) call56 <- CALL0 fn:Tuba_Precache | |
| (79) call57 <- CALL0 fn:CSQCPlayer_Precache | |
| (80) COND 1, [ontrue58], [endif65] | |
| :ontrue58 | |
| (81) [entry] | |
| (82) COND autocvar_cl_reticle_item_normal, [ontrue59], [endif61] | |
| :ontrue59 | |
| (83) [entry] | |
| (84) call60 <- CALL1 fn:precache_pic params: #IMMEDIATE, | |
| (85) JUMP [endif61] | |
| :endif61 | |
| (86) [entry] | |
| (87) COND autocvar_cl_reticle_item_nex, [ontrue62], [endif64] | |
| :ontrue62 | |
| (88) [entry] | |
| (89) call63 <- CALL1 fn:precache_pic params: #IMMEDIATE, | |
| (90) JUMP [endif64] | |
| :endif64 | |
| (91) [entry] | |
| (92) JUMP [endif65] | |
| :endif65 | |
| (93) [entry] | |
| (94) call66 <- CALL1 fn:get_mi_min_max_texcoords params: #IMMEDIATE, | |
| (95) minimapname <- CALL3 fn:strcat params: #IMMEDIATE, mi_shortname, #IMMEDIATE, | |
| (96) shortmapname <- STORE_S mi_shortname | |
| (97) call68 <- CALL1 fn:precache_pic params: minimapname, | |
| (98) bin69 <- EQ_S call68, "" | |
| (99) COND bin69, [ontrue70], [endif78] | |
| :ontrue70 | |
| (100) [entry] | |
| (101) minimapname <- CALL3 fn:strcat params: #IMMEDIATE, mi_shortname, #IMMEDIATE, | |
| (102) call72 <- CALL1 fn:precache_pic params: minimapname, | |
| (103) bin73 <- EQ_S call72, "" | |
| (104) COND bin73, [ontrue74], [onfalse75] | |
| :ontrue74 | |
| (105) [entry] | |
| (106) minimapname <- STORE_S "" | |
| (107) JUMP [endif77] | |
| :onfalse75 | |
| (108) [entry] | |
| (109) call76 <- CALL1 fn:get_mi_min_max_texcoords params: #IMMEDIATE, | |
| (110) JUMP [endif77] | |
| :endif77 | |
| (111) [entry] | |
| (112) JUMP [endif78] | |
| :endif78 | |
| (113) [entry] | |
| (114) bin79 <- ADD_V mi_min, mi_max | |
| (115) mi_center <- MUL_VF bin79, 0.5 | |
| (116) mi_scale <- SUB_V mi_max, mi_min | |
| (117) minimapname <- CALL1 fn:strzone params: minimapname, | |
| (118) call83 <- CALL0 fn:WarpZone_Init | |
| (119) call84 <- CALL2 fn:strcat params: #IMMEDIATE, autocvar_hud_skin, | |
| (120) hud_skin_path <- CALL1 fn:strzone params: call84, | |
| (121) hud_configure_prev <- STORE_F -1 | |
| (122) tab_panel <- STORE_F -1 | |
| (123) call86 <- CALL1 fn:cvar_string params: #IMMEDIATE, | |
| (124) call87 <- CALL2 fn:strcat params: #IMMEDIATE, call86, | |
| (125) draw_currentSkin <- CALL1 fn:strzone params: call87, | |
| (126) RETURN | |
| endfunction CSQC_Init | |
| function CSQC_Shutdown | |
| liferanges: | |
| call1: void [return] @0 [null] | |
| call3: void [return] @0 [null] | |
| call5: float [return] @0 [10,10] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) COND shutdown_running, [ontrue0], [onfalse2] | |
| :ontrue0 | |
| (2) [entry] | |
| (3) call1 <- CALL1 fn:print params: #IMMEDIATE, | |
| (4) JUMP [endif4] | |
| :onfalse2 | |
| (5) [entry] | |
| (6) shutdown_running <- STORE_F 1 | |
| (7) call3 <- CALL0 fn:Shutdown | |
| (8) JUMP [endif4] | |
| :endif4 | |
| (9) [entry] | |
| (10) call5 <- CALL0 fn:cvar_settemp_restore | |
| (11) RETURN | |
| endfunction CSQC_Shutdown | |
| function CSQC_InputEvent | |
| 4 locals: | |
| bInputType | |
| nPrimary | |
| nSecondary | |
| bSkipKey | |
| liferanges: | |
| bInputType: float [param] locked @0 [0,3] [6,8] [11,21] | |
| nPrimary: float [param] locked @1 [0,3] [6,8] [11,21] | |
| nSecondary: float [param] locked @2 [0,3] [6,8] [11,21] | |
| bSkipKey: float [local] locked @3 [1,3] [6,8] [11,22] [25,28] | |
| call0: float [return] @0 [2,3] | |
| call3: float [return] @0 [7,8] | |
| sce_value8: float [value] @0 [12,13] [15,18] | |
| sce_bool9: float [value] @0 [18,19] | |
| call11: float [return] @0 [21,22] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bSkipKey <- STORE_F 0 | |
| (2) call0 <- CALL3 fn:HUD_Panel_InputEvent params: bInputType, nPrimary, nSecondary, | |
| (3) COND call0, [ontrue1], [endif2] | |
| :ontrue1 | |
| (4) [entry] | |
| (5) RETURN 1 | |
| :endif2 | |
| (6) [entry] | |
| (7) call3 <- CALL3 fn:MapVote_InputEvent params: bInputType, nPrimary, nSecondary, | |
| (8) COND call3, [ontrue4], [endif5] | |
| :ontrue4 | |
| (9) [entry] | |
| (10) RETURN 1 | |
| :endif5 | |
| (11) [entry] | |
| (12) sce_value8 <- STORE_F menu_visible | |
| (13) COND menu_visible, [sce_other7], [sce_merge6] | |
| :sce_other7 | |
| (14) [entry] | |
| (15) sce_value8 <- STORE_F menu_action | |
| (16) JUMP [sce_merge6] | |
| :sce_merge6 | |
| (17) [entry] | |
| (18) sce_bool9 <- AND sce_value8, sce_value8 | |
| (19) COND sce_bool9, [ontrue10], [endif14] | |
| :ontrue10 | |
| (20) [entry] | |
| (21) call11 <- CALL3 menu_action params: bInputType, nPrimary, nSecondary, | |
| (22) COND call11, [ontrue12], [endif13] | |
| :ontrue12 | |
| (23) [entry] | |
| (24) RETURN 1 | |
| :endif13 | |
| (25) [entry] | |
| (26) JUMP [endif14] | |
| :endif14 | |
| (27) [entry] | |
| (28) RETURN bSkipKey | |
| endfunction CSQC_InputEvent | |
| function CSQC_UpdateView | |
| 78 locals: | |
| w | |
| h | |
| e | |
| fov | |
| f | |
| i | |
| j | |
| v | |
| vf_size | |
| vf_min | |
| a | |
| reticle_pos | |
| reticle_size | |
| splash_pos | |
| splash_size | |
| is_dead | |
| e1 | |
| e2 | |
| checkfailv | |
| checkfailv | |
| checkfailv | |
| checkfailv | |
| checkfailv | |
| checkfailv | |
| checkfailv | |
| current_view_origin | |
| eventchase_target_origin | |
| tc_00 | |
| tc_01 | |
| tc_10 | |
| tc_11 | |
| rgb | |
| contentalpha_temp | |
| incontent | |
| liquidalpha | |
| contentfadetime | |
| liquidcolor | |
| myhealth_flash_temp | |
| pain_threshold | |
| pain_threshold_lower | |
| pain_threshold_lower_health | |
| sharpen_intensity | |
| strength_finished | |
| invincible_finished | |
| blurradius | |
| bluralpha | |
| wcross_style | |
| wcross_alpha | |
| wcross_resolution | |
| shottype | |
| wcross_color | |
| wcross_size | |
| wcross_wep | |
| wcross_name | |
| wcross_scale | |
| wcross_blur | |
| wcross_oldorigin | |
| x | |
| stat_pickup_time | |
| hitindication_color | |
| ring_value | |
| ring_scale | |
| ring_alpha | |
| ring_inner_value | |
| ring_inner_alpha | |
| ring_image | |
| ring_inner_image | |
| ring_rgb | |
| ring_inner_rgb | |
| weapon_clipload | |
| weapon_clipsize | |
| nex_charge | |
| nex_chargepool | |
| wcross_color_old | |
| w0 | |
| h0 | |
| v1 | |
| v2 | |
| liferanges: | |
| w: float [param] locked @0 [0,1337] [1340,1343] [1346,1349] [1352,1355] [1358,1422] [1425,1430] [1433,2368] | |
| h: float [param] locked @1 [0,1337] [1340,1343] [1346,1349] [1352,1355] [1358,1422] [1425,1430] [1433,2369] | |
| e: entity [local] locked @2 [427,432] [488,505] [1210,1227] [1404,1415] | |
| fov: float [local] locked @5 [364,451] | |
| f: float [local] locked @2 [388,392] [773,774] [776,809] [1656,1695] [1747,1757] [1964,1975] [2024,2092] [2094,2243] | |
| i: float [local] locked @5 [2034,2069] [2107,2141] [2184,2221] | |
| j: float [local] locked @8 [2043,2067] [2116,2139] [2193,2219] | |
| v: vector [local] @0 [1370,1373] | |
| v_x: @0 [1370,1373] | |
| v_y: @0 [1370,1373] | |
| v_z: @0 [1370,1373] | |
| vf_size: vector [local] locked @8 [113,445] | |
| vf_size_x: @0 [113,445] | |
| vf_size_y: @0 [113,445] | |
| vf_size_z: @0 [113,445] | |
| vf_min: vector [local] locked @11 [114,446] | |
| vf_min_x: @0 [114,446] | |
| vf_min_y: @0 [114,446] | |
| vf_min_z: @0 [114,446] | |
| a: float [local] locked @2 [546,583] [588,619] | |
| reticle_pos: vector [local] locked @14 [117,810] | |
| reticle_pos_x: @0 [761,763] [768,810] | |
| reticle_pos_y: @0 [762,763] [770,810] | |
| reticle_pos_z: @0 [117,810] | |
| reticle_size: vector [local] locked @17 [118,810] | |
| reticle_size_x: @0 [759,763] [765,810] | |
| reticle_size_y: @0 [760,763] [766,810] | |
| reticle_size_z: @0 [118,810] | |
| splash_pos: vector [local] locked @20 [119,980] [1011,1015] | |
| splash_pos_x: @0 [905,980] [1011,1015] | |
| splash_pos_y: @0 [907,980] [1011,1015] | |
| splash_pos_z: @0 [119,980] [1011,1015] | |
| splash_size: vector [local] locked @23 [120,980] [1011,1015] | |
| splash_size_x: @0 [902,980] [1011,1015] | |
| splash_size_y: @0 [903,980] [1011,1015] | |
| splash_size_z: @0 [120,980] [1011,1015] | |
| is_dead: float [local] locked @26 [129,628] | |
| e1: float [local] locked @2 [1045,1066] | |
| e2: float [local] locked @5 [1046,1074] | |
| checkfailv: float [local] @0 [22,28] | |
| checkfailv: float [local] @0 [35,41] | |
| checkfailv: float [local] @0 [48,54] | |
| checkfailv: float [local] @0 [61,67] | |
| checkfailv: float [local] @0 [74,80] | |
| checkfailv: float [local] @0 [87,93] | |
| checkfailv: float [local] @0 [100,106] | |
| current_view_origin: vector [local] locked @2 [205,242] | |
| current_view_origin_x: @0 [205,242] | |
| current_view_origin_y: @0 [205,242] | |
| current_view_origin_z: @0 [205,242] | |
| eventchase_target_origin: vector [local] @0 [236,237] [241,242] | |
| eventchase_target_origin_x: @0 [236,237] [241,242] | |
| eventchase_target_origin_y: @0 [236,237] [241,242] | |
| eventchase_target_origin_z: @0 [236,237] [241,242] | |
| tc_00: vector [local] locked @5 [555,575] [597,611] | |
| tc_00_x: @0 [555,575] [597,611] | |
| tc_00_y: @0 [555,575] [597,611] | |
| tc_00_z: @0 [555,575] [597,611] | |
| tc_01: vector [local] locked @8 [563,583] [602,619] | |
| tc_01_x: @0 [563,583] [602,619] | |
| tc_01_y: @0 [563,583] [602,619] | |
| tc_01_z: @0 [563,583] [602,619] | |
| tc_10: vector [local] locked @11 [571,577] [607,613] | |
| tc_10_x: @0 [571,577] [607,613] | |
| tc_10_y: @0 [571,577] [607,613] | |
| tc_10_z: @0 [571,577] [607,613] | |
| tc_11: vector [local] locked @27 [573,581] [609,617] | |
| tc_11_x: @0 [573,581] [609,617] | |
| tc_11_y: @0 [573,581] [609,617] | |
| tc_11_z: @0 [573,581] [609,617] | |
| rgb: vector [local] locked @30 [547,583] [591,619] | |
| rgb_x: @0 [522,522] [547,583] [591,619] | |
| rgb_y: @0 [523,523] [547,583] [591,619] | |
| rgb_z: @0 [524,524] [547,583] [591,619] | |
| contentalpha_temp: float [local] @0 [861,864] | |
| incontent: float [local] locked @2 [825,826] [833,834] [841,842] [846,864] | |
| liquidalpha: float [local] locked @5 [823,826] [831,834] [839,842] [844,852] | |
| contentfadetime: float [local] @0 [851,854] [856,859] | |
| liquidcolor: vector [local] @3 [824,826] [832,834] [840,842] [845,853] | |
| liquidcolor_x: @0 [824,826] [832,834] [840,842] [845,853] | |
| liquidcolor_y: @0 [824,826] [832,834] [840,842] [845,853] | |
| liquidcolor_z: @0 [824,826] [832,834] [840,842] [845,853] | |
| myhealth_flash_temp: float [local] locked @2 [941,946] [949,966] [969,1032] | |
| pain_threshold: float [local] locked @5 [915,985] | |
| pain_threshold_lower: float [local] locked @2 [916,932] | |
| pain_threshold_lower_health: float [local] locked @8 [917,934] | |
| sharpen_intensity: float [local] locked @2 [1122,1145] [1151,1172] | |
| strength_finished: float [local] locked @5 [1123,1129] | |
| invincible_finished: float [local] @0 [1124,1137] | |
| blurradius: float [local] locked @2 [1088,1105] | |
| bluralpha: float [local] locked @5 [1090,1106] | |
| wcross_style: string [local] locked @5 [1341,1343] [1346,1349] [1352,1355] [1358,1416] [1435,1444] [1446,1555] | |
| wcross_alpha: float [local] locked @11 [1353,1355] [1358,1422] [1425,1430] [1433,1752] [1755,2160] | |
| wcross_resolution: float [local] locked @14 [1347,1349] [1352,1355] [1358,1422] [1425,1430] [1433,2243] | |
| shottype: float [local] locked @8 [1366,1375] [1377,1387] [1389,1422] [1425,1430] [1433,1715] | |
| wcross_color: vector [local] locked @17 [1392,1392] [1467,1468] [1473,1495] [1500,1511] [1513,1522] [1524,1548] [1550,1756] [1759,2172] [2174,2243] [2245,2245] | |
| wcross_color_x: @0 [1467,1468] [1477,1479] [1487,1492] [1500,1508] [1513,1519] [1524,1534] [1536,1548] [1550,1756] [1759,2172] [2174,2243] | |
| wcross_color_y: @0 [1467,1468] [1478,1479] [1491,1492] [1504,1508] [1514,1519] [1528,1534] [1537,1548] [1550,1756] [1759,2172] [2174,2243] | |
| wcross_color_z: @0 [1467,1468] [1473,1495] [1507,1511] [1518,1522] [1533,1548] [1550,1756] [1759,2172] [2174,2243] | |
| wcross_size: vector [local] locked @20 [1393,1393] [1770,1998] [2026,2089] [2099,2243] | |
| wcross_size_x: @0 [1770,1998] [2026,2089] [2099,2243] | |
| wcross_size_y: @0 [2026,2089] [2099,2243] | |
| wcross_size_z: @0 [2026,2089] [2099,2243] | |
| wcross_wep: string [local] locked @17 [1394,1413] [1415,1422] [1425,1430] [1433,1465] | |
| wcross_name: string [local] locked @23 [1555,2160] | |
| wcross_scale: float [local] locked @26 [1558,1560] [1562,1748] [1751,2100] | |
| wcross_blur: float [local] locked @27 [1735,1737] [1739,2243] | |
| wcross_oldorigin: vector [local] locked @2 [1365,1384] | |
| wcross_oldorigin_x: @0 [1365,1384] | |
| wcross_oldorigin_y: @0 [1365,1384] | |
| wcross_oldorigin_z: @0 [1365,1384] | |
| x: float [local] @0 [1472,1475] [1480,1488] [1493,1505] [1509,1515] [1520,1529] | |
| stat_pickup_time: float [local] @0 [1567,1578] | |
| hitindication_color: vector [local] locked @2 [1606,1640] | |
| hitindication_color_x: @0 [1606,1634] | |
| hitindication_color_y: @0 [1606,1637] | |
| hitindication_color_z: @0 [1606,1640] | |
| ring_value: float [local] locked @5 [1790,1831] [1862,1889] [1893,1914] [1918,1935] [1938,2000] | |
| ring_scale: float [local] locked @8 [1791,1791] [1799,1935] [1939,1998] | |
| ring_alpha: float [local] locked @30 [1792,1831] [1863,1889] [1894,1914] [1919,1935] [1940,1999] | |
| ring_inner_value: float [local] locked @33 [1793,1831] [1843,1844] [1852,1993] | |
| ring_inner_alpha: float [local] locked @34 [1794,1831] [1855,1992] | |
| ring_image: string [local] locked @35 [1795,1831] [1865,1889] [1896,1914] [1921,1935] [1952,1953] [1955,2000] | |
| ring_inner_image: string [local] locked @36 [1796,1831] [1861,1993] | |
| ring_rgb: vector [local] locked @37 [1797,1831] [1864,1889] [1895,1914] [1920,1935] [1941,2000] | |
| ring_rgb_x: @0 [1797,1831] [1864,1889] [1895,1914] [1920,1935] [1941,2000] | |
| ring_rgb_y: @0 [1797,1831] [1864,1889] [1895,1914] [1920,1935] [1941,2000] | |
| ring_rgb_z: @0 [1797,1831] [1864,1889] [1895,1914] [1920,1935] [1941,2000] | |
| ring_inner_rgb: vector [local] locked @40 [1798,1831] [1860,1993] | |
| ring_inner_rgb_x: @0 [1798,1831] [1860,1993] | |
| ring_inner_rgb_y: @0 [1798,1831] [1860,1993] | |
| ring_inner_rgb_z: @0 [1798,1831] [1860,1993] | |
| weapon_clipload: float [local] locked @2 [1800,1937] | |
| weapon_clipsize: float [local] locked @43 [1801,1946] | |
| nex_charge: float [local] locked @44 [1802,1862] | |
| nex_chargepool: float [local] @0 [1803,1843] | |
| wcross_color_old: vector [local] locked @11 [2164,2245] | |
| wcross_color_old_x: @0 [2164,2245] | |
| wcross_color_old_y: @0 [2164,2245] | |
| wcross_color_old_z: @0 [2164,2245] | |
| w0: string [local] locked @2 [2286,2307] | |
| h0: string [local] locked @5 [2287,2308] | |
| v1: vector [local] locked @8 [2294,2298] | |
| v1_x: @0 [2294,2298] | |
| v1_y: @0 [2294,2298] | |
| v1_z: @0 [2294,2298] | |
| v2: vector [local] @0 [2297,2298] | |
| v2_x: @0 [2297,2298] | |
| v2_y: @0 [2297,2298] | |
| v2_z: @0 [2297,2298] | |
| call0: void [return] @0 [null] | |
| binst1: float [value] @0 [null] | |
| call2: float [value] @0 [null] | |
| call4: void [return] @0 [null] | |
| call5: float [value] @0 [null] | |
| call6: void [return] @0 [null] | |
| call8: float [return] @0 [11,12] | |
| call10: float [value] @0 [null] | |
| bin13: float [value] @0 [null] | |
| bin14: float [value] @0 [null] | |
| call15: float [value] @0 [null] | |
| bin16: float [value] @3 [23,24] | |
| call19: string [value] callparam @0 [28,29] | |
| call20: void [return] @0 [null] | |
| call23: float [value] @0 [null] | |
| bin24: float [value] @3 [36,37] | |
| call27: string [value] callparam @0 [41,42] | |
| call28: void [return] @0 [null] | |
| call31: float [value] @0 [null] | |
| bin32: float [value] @3 [49,50] | |
| call35: string [value] callparam @0 [54,55] | |
| call36: void [return] @0 [null] | |
| call39: float [value] @0 [null] | |
| bin40: float [value] @3 [62,63] | |
| call43: string [value] callparam @0 [67,68] | |
| call44: void [return] @0 [null] | |
| call47: float [value] @0 [null] | |
| bin48: float [value] @3 [75,76] | |
| call51: string [value] callparam @0 [80,81] | |
| call52: void [return] @0 [null] | |
| call55: float [value] @0 [null] | |
| bin56: float [value] @3 [88,89] | |
| call59: string [value] callparam @0 [93,94] | |
| call60: void [return] @0 [null] | |
| call63: float [value] @0 [null] | |
| bin64: float [value] @3 [101,102] | |
| call67: string [value] callparam @0 [106,107] | |
| call68: void [return] @0 [null] | |
| call71: vector [value] @0 [null] | |
| call71_x: @0 | |
| call71_y: @0 | |
| call71_z: @0 | |
| call72: vector [value] @0 [null] | |
| call72_x: @0 | |
| call72_y: @0 | |
| call72_z: @0 | |
| call73: void [return] @0 [null] | |
| call74: void [return] @0 [null] | |
| bin75: float [value] callparam @0 [123,124] | |
| call76: float [value] @0 [null] | |
| call77: float [value] locked @2 [125,127] | |
| call78: float [return] @0 [126,127] | |
| bin79: float [value] @0 [null] | |
| call80: float [return] @0 [128,129] | |
| bin81: float [value] @0 [null] | |
| call82: float [return] @0 [130,131] | |
| bin84: float [value] @0 [null] | |
| sce_value90: float [value] @0 [136,137] [139,142] | |
| sce_bool91: float [value] @0 [142,144] | |
| bin93: float [value] @0 [null] | |
| sce_value94: float [value] @3 [143,144] [146,149] | |
| sce_bool95: float [value] @0 [149,151] | |
| sce_value99: float [value] @0 [153,154] [156,159] | |
| sce_bool100: float [value] @0 [null] | |
| sce_value101: float [value] @3 [150,151] [159,162] | |
| sce_bool102: float [value] @0 [162,163] | |
| call104: void [return] @0 [null] | |
| bin107: float [value] @0 [171,172] | |
| bin111: float [value] @0 [174,176] | |
| sce_value115: float [value] @0 [178,179] [181,184] | |
| sce_bool116: float [value] @0 [null] | |
| sce_value117: float [value] @3 [175,176] [184,187] | |
| sce_bool118: float [value] @0 [187,189] | |
| sce_value120: float [value] @3 [188,189] [191,194] | |
| sce_bool121: float [value] @0 [194,195] | |
| efv124: vector [value] @0 [null] | |
| efv124_x: @0 | |
| efv124_y: @0 | |
| efv124_z: @0 | |
| phi127: vector [value] @0 [199,200] [202,205] | |
| phi127_x: @0 [199,200] [202,205] | |
| phi127_y: @0 [199,200] [202,205] | |
| phi127_z: @0 [199,200] [202,205] | |
| bin128: vector [value] @0 [null] | |
| bin128_x: @0 | |
| bin128_y: @0 | |
| bin128_z: @0 | |
| call130: void [return] @0 [null] | |
| bin134: float [value] @0 [null] | |
| sce_value135: float [value] @0 [211,212] [214,217] | |
| sce_bool136: float [value] @0 [217,218] | |
| bin138: float [value] @0 [220,221] | |
| bin139: float [value] @0 [221,222] | |
| bin140: float [value] @0 [222,223] | |
| binst141: float [value] @0 [null] | |
| bin143: float [value] @0 [226,227] | |
| call147: void [return] @0 [null] | |
| bin148: vector [value] @0 [235,236] | |
| bin148_x: @0 [235,236] | |
| bin148_y: @0 [235,236] | |
| bin148_z: @0 [235,236] | |
| bin149: vector [value] @0 [null] | |
| bin149_x: @0 | |
| bin149_y: @0 | |
| bin149_z: @0 | |
| call150: void [return] @0 [null] | |
| bin152: vector [value] @0 [240,241] | |
| bin152_x: @0 [240,241] | |
| bin152_y: @0 [240,241] | |
| bin152_z: @0 [240,241] | |
| bin153: vector [value] @0 [null] | |
| bin153_x: @0 | |
| bin153_y: @0 | |
| bin153_z: @0 | |
| call154: void [return] @0 [null] | |
| bin155: vector [value] @0 [243,244] | |
| bin155_x: @0 [243,244] | |
| bin155_y: @0 [243,244] | |
| bin155_z: @0 [243,244] | |
| bin156: vector [value] callparam @0 [244,245] | |
| bin156_x: @0 [244,245] | |
| bin156_y: @0 [244,245] | |
| bin156_z: @0 [244,245] | |
| call157: float [return] @0 [245,245] | |
| call159: float [return] @0 [248,248] | |
| call161: vector [value] callparam @0 [251,252] | |
| call161_x: @0 [251,252] | |
| call161_y: @0 [251,252] | |
| call161_z: @0 [251,252] | |
| call162: float [return] @0 [252,252] | |
| bin164: float [value] @0 [255,256] | |
| call166: void [return] @0 [null] | |
| call171: float [return] @0 [268,268] | |
| unary177: float [value] @0 [277,279] | |
| bin182: float [value] @0 [null] | |
| sce_value183: float [value] @0 [281,282] [284,287] | |
| sce_bool184: float [value] @0 [287,289] | |
| bin186: float [value] @0 [null] | |
| sce_value187: float [value] @3 [288,289] [291,294] | |
| sce_bool188: float [value] @0 [null] | |
| sce_value189: float [value] @3 [278,279] [294,297] | |
| sce_bool190: float [value] @0 [null] | |
| sce_value191: float [value] @0 [274,275] [297,300] | |
| sce_bool192: float [value] @0 [300,301] | |
| call194: float [return] @0 [303,303] | |
| call195: float [return] @0 [304,304] | |
| call197: vector [value] @0 [null] | |
| call197_x: @0 | |
| call197_y: @0 | |
| call197_z: @0 | |
| call198: vector [value] @0 [null] | |
| call198_x: @0 | |
| call198_y: @0 | |
| call198_z: @0 | |
| call200: void [return] @0 [null] | |
| call201: vector [value] @0 [null] | |
| call201_x: @0 | |
| call201_y: @0 | |
| call201_z: @0 | |
| call202: vector [value] @0 [null] | |
| call202_x: @0 | |
| call202_y: @0 | |
| call202_z: @0 | |
| call203: void [return] @0 [null] | |
| call204: void [return] @0 [null] | |
| call205: void [return] @0 [null] | |
| bin206: float [value] @0 [320,321] | |
| bin209: float [value] callparam @0 [326,327] | |
| call210: float [value] @0 [null] | |
| call213: void [return] @0 [null] | |
| call218: float [return] @0 [339,340] | |
| unary219: float [value] @0 [null] | |
| sce_value220: float [value] @0 [336,337] [340,343] | |
| sce_bool221: float [value] @0 [343,345] | |
| bin223: float [value] @0 [347,348] | |
| unary224: float [value] @0 [null] | |
| sce_value225: float [value] @3 [344,345] [348,351] | |
| sce_bool226: float [value] @0 [351,352] | |
| bin228: float [value] @0 [354,355] | |
| call230: void [return] @0 [null] | |
| binst231: float [value] @0 [null] | |
| call234: void [return] @0 [null] | |
| bin235: float [value] @0 [365,366] | |
| call238: void [return] @0 [null] | |
| call242: void [return] @0 [null] | |
| call245: float [value] @0 [null] | |
| call246: float [value] @0 [null] | |
| call247: float [value] @0 [null] | |
| bin248: float [value] @0 [null] | |
| bin249: float [value] @0 [389,390] | |
| call251: void [return] @0 [null] | |
| bin253: float [value] @0 [396,397] | |
| sce_value257: float [value] @0 [401,402] [404,407] | |
| sce_bool258: float [value] @0 [407,408] | |
| call260: void [return] @0 [null] | |
| call263: void [return] @0 [null] | |
| call264: void [return] @0 [null] | |
| bin267: float [value] @0 [423,424] | |
| call269: entity [value] @0 [null] | |
| efv270: string [value] @0 [428,429] | |
| bin271: float [value] @0 [429,430] | |
| efv273: string [value] callparam @0 [432,433] | |
| call274: string [value] callparam @0 [433,434] | |
| call275: void [return] @0 [null] | |
| call277: void [return] @0 [null] | |
| call280: void [return] @0 [null] | |
| call281: float [return] @0 [443,443] | |
| call282: float [return] @0 [444,444] | |
| call283: float [return] @0 [445,445] | |
| call284: float [return] @0 [446,446] | |
| call285: float [return] @0 [447,447] | |
| call286: vector [value] callparam @0 [451,452] | |
| call286_x: @0 [451,452] | |
| call286_y: @0 [451,452] | |
| call286_z: @0 [451,452] | |
| call287: float [return] @0 [452,452] | |
| call290: void [return] @0 [null] | |
| call292: string [value] callparam @0 [460,461] | |
| call293: void [return] @0 [null] | |
| call294: void [return] @0 [null] | |
| call299: float [value] @0 [null] | |
| sce_value300: float [value] @0 [468,469] [471,474] | |
| sce_bool301: float [value] @0 [474,475] | |
| call303: void [return] @0 [null] | |
| call304: void [return] @0 [null] | |
| call307: float [return] @0 [486,486] | |
| call308: float [return] @0 [487,487] | |
| call310: entity [return] @0 [492,494] | |
| efv313: function [value] @0 [496,497] | |
| efv315: function [value] locked @5 [499,500] | |
| call316: void [return] @0 [null] | |
| call318: void [return] @0 [null] | |
| call319: void [return] @0 [null] | |
| call320: float [return] @0 [508,508] | |
| bin322: float [value] @0 [509,511] | |
| sce_value324: float [value] @3 [510,511] [513,516] | |
| sce_bool325: float [value] @0 [516,517] | |
| bin327: float [value] @0 [519,520] | |
| unary329: float [value] @0 [null] | |
| call331: entity [value] @0 [null] | |
| efa332: pointer [value] @0 [528,529] | |
| unary334: float [value] @0 [null] | |
| call336: entity [value] @0 [null] | |
| efa337: pointer [value] @0 [535,536] | |
| bin339: vector [value] @0 [539,541] | |
| bin339_x: @0 [539,541] | |
| bin339_y: @0 [539,541] | |
| bin339_z: @0 [539,541] | |
| bin340: vector [value] @3 [540,541] | |
| bin340_x: @0 [540,541] | |
| bin340_y: @0 [540,541] | |
| bin340_z: @0 [540,541] | |
| bin341: vector [value] callparam @0 [541,542] | |
| bin341_x: @0 [541,542] | |
| bin341_y: @0 [541,542] | |
| bin341_z: @0 [541,542] | |
| call342: float [return] @0 [542,542] | |
| bin343: float [value] callparam @0 [543,544] | |
| call344: float [return] @0 [544,545] | |
| bin345: float [value] @0 [545,546] | |
| bin346: float [value] @0 [null] | |
| bin347: float [value] callparam @0 [548,549] | |
| call348: float [return] @0 [549,551] | |
| bin349: vector [value] @0 [550,551] | |
| bin349_x: @0 [550,551] | |
| bin349_y: @0 [550,551] | |
| bin349_z: @0 [550,551] | |
| bin350: vector [value] locked @5 [551,555] | |
| bin350_x: locked @0 [551,555] | |
| bin350_y: locked @0 [551,555] | |
| bin350_z: locked @0 [551,555] | |
| bin351: float [value] callparam @0 [552,553] | |
| call352: float [return] @0 [553,555] | |
| bin353: vector [value] @0 [554,555] | |
| bin353_x: @0 [554,555] | |
| bin353_y: @0 [554,555] | |
| bin353_z: @0 [554,555] | |
| bin354: vector [value] @0 [null] | |
| bin354_x: @0 | |
| bin354_y: @0 | |
| bin354_z: @0 | |
| bin355: float [value] callparam @0 [556,557] | |
| call356: float [return] @0 [557,559] | |
| bin357: vector [value] @0 [558,559] | |
| bin357_x: @0 [558,559] | |
| bin357_y: @0 [558,559] | |
| bin357_z: @0 [558,559] | |
| bin358: vector [value] locked @8 [559,563] | |
| bin358_x: locked @0 [559,563] | |
| bin358_y: locked @0 [559,563] | |
| bin358_z: locked @0 [559,563] | |
| bin359: float [value] callparam @0 [560,561] | |
| call360: float [return] @0 [561,563] | |
| bin361: vector [value] @0 [562,563] | |
| bin361_x: @0 [562,563] | |
| bin361_y: @0 [562,563] | |
| bin361_z: @0 [562,563] | |
| bin362: vector [value] @0 [null] | |
| bin362_x: @0 | |
| bin362_y: @0 | |
| bin362_z: @0 | |
| bin363: float [value] callparam @0 [564,565] | |
| call364: float [return] @0 [565,567] | |
| bin365: vector [value] @0 [566,567] | |
| bin365_x: @0 [566,567] | |
| bin365_y: @0 [566,567] | |
| bin365_z: @0 [566,567] | |
| bin366: vector [value] locked @11 [567,571] | |
| bin366_x: locked @0 [567,571] | |
| bin366_y: locked @0 [567,571] | |
| bin366_z: locked @0 [567,571] | |
| bin367: float [value] callparam @0 [568,569] | |
| call368: float [return] @0 [569,571] | |
| bin369: vector [value] @0 [570,571] | |
| bin369_x: @0 [570,571] | |
| bin369_y: @0 [570,571] | |
| bin369_z: @0 [570,571] | |
| bin370: vector [value] @0 [null] | |
| bin370_x: @0 | |
| bin370_y: @0 | |
| bin370_z: @0 | |
| bin371: vector [value] @0 [572,573] | |
| bin371_x: @0 [572,573] | |
| bin371_y: @0 [572,573] | |
| bin371_z: @0 [572,573] | |
| bin372: vector [value] @0 [null] | |
| bin372_x: @0 | |
| bin372_y: @0 | |
| bin372_z: @0 | |
| call373: void [return] @0 [null] | |
| call374: void [return] @0 [null] | |
| bin375: vector [value] callparam @0 [576,577] | |
| bin375_x: @0 [576,577] | |
| bin375_y: @0 [576,577] | |
| bin375_z: @0 [576,577] | |
| call376: void [return] @0 [null] | |
| bin377: vector [value] @0 [578,580] | |
| bin377_x: @0 [578,580] | |
| bin377_y: @0 [578,580] | |
| bin377_z: @0 [578,580] | |
| bin378: vector [value] @3 [579,580] | |
| bin378_x: @0 [579,580] | |
| bin378_y: @0 [579,580] | |
| bin378_z: @0 [579,580] | |
| bin379: vector [value] callparam @0 [580,581] | |
| bin379_x: @0 [580,581] | |
| bin379_y: @0 [580,581] | |
| bin379_z: @0 [580,581] | |
| call380: void [return] @0 [null] | |
| bin381: vector [value] callparam @0 [582,583] | |
| bin381_x: @0 [582,583] | |
| bin381_y: @0 [582,583] | |
| bin381_z: @0 [582,583] | |
| call382: void [return] @0 [null] | |
| call383: void [return] @0 [null] | |
| bin384: float [value] callparam @0 [585,586] | |
| call385: float [return] @0 [586,587] | |
| bin386: float [value] @0 [587,588] | |
| bin387: float [value] @0 [null] | |
| call388: float [return] @0 [589,591] | |
| bin389: vector [value] @0 [590,591] | |
| bin389_x: @0 [590,591] | |
| bin389_y: @0 [590,591] | |
| bin389_z: @0 [590,591] | |
| bin390: vector [value] @0 [null] | |
| bin390_x: @0 | |
| bin390_y: @0 | |
| bin390_z: @0 | |
| call391: float [return] @0 [592,594] | |
| bin392: vector [value] @0 [593,594] | |
| bin392_x: @0 [593,594] | |
| bin392_y: @0 [593,594] | |
| bin392_z: @0 [593,594] | |
| bin393: vector [value] locked @5 [594,597] | |
| bin393_x: locked @0 [594,597] | |
| bin393_y: locked @0 [594,597] | |
| bin393_z: locked @0 [594,597] | |
| call394: float [return] @0 [595,597] | |
| bin395: vector [value] @0 [596,597] | |
| bin395_x: @0 [596,597] | |
| bin395_y: @0 [596,597] | |
| bin395_z: @0 [596,597] | |
| bin396: vector [value] @0 [null] | |
| bin396_x: @0 | |
| bin396_y: @0 | |
| bin396_z: @0 | |
| call397: float [return] @0 [598,599] | |
| bin398: float [value] @0 [599,600] | |
| bin399: float [value] @0 [600,602] | |
| bin400: vector [value] @3 [601,602] | |
| bin400_x: @0 [601,602] | |
| bin400_y: @0 [601,602] | |
| bin400_z: @0 [601,602] | |
| bin401: vector [value] @0 [null] | |
| bin401_x: @0 | |
| bin401_y: @0 | |
| bin401_z: @0 | |
| call402: float [return] @0 [603,604] | |
| bin403: float [value] @0 [604,605] | |
| bin404: float [value] @0 [605,607] | |
| bin405: vector [value] @3 [606,607] | |
| bin405_x: @0 [606,607] | |
| bin405_y: @0 [606,607] | |
| bin405_z: @0 [606,607] | |
| bin406: vector [value] @0 [null] | |
| bin406_x: @0 | |
| bin406_y: @0 | |
| bin406_z: @0 | |
| bin407: vector [value] @0 [608,609] | |
| bin407_x: @0 [608,609] | |
| bin407_y: @0 [608,609] | |
| bin407_z: @0 [608,609] | |
| bin408: vector [value] @0 [null] | |
| bin408_x: @0 | |
| bin408_y: @0 | |
| bin408_z: @0 | |
| call409: void [return] @0 [null] | |
| call410: void [return] @0 [null] | |
| bin411: vector [value] callparam @0 [612,613] | |
| bin411_x: @0 [612,613] | |
| bin411_y: @0 [612,613] | |
| bin411_z: @0 [612,613] | |
| call412: void [return] @0 [null] | |
| bin413: vector [value] @0 [614,616] | |
| bin413_x: @0 [614,616] | |
| bin413_y: @0 [614,616] | |
| bin413_z: @0 [614,616] | |
| bin414: vector [value] @3 [615,616] | |
| bin414_x: @0 [615,616] | |
| bin414_y: @0 [615,616] | |
| bin414_z: @0 [615,616] | |
| bin415: vector [value] callparam @0 [616,617] | |
| bin415_x: @0 [616,617] | |
| bin415_y: @0 [616,617] | |
| bin415_z: @0 [616,617] | |
| call416: void [return] @0 [null] | |
| bin417: vector [value] callparam @0 [618,619] | |
| bin417_x: @0 [618,619] | |
| bin417_y: @0 [618,619] | |
| bin417_z: @0 [618,619] | |
| call418: void [return] @0 [null] | |
| call419: void [return] @0 [null] | |
| sce_value425: float [value] @0 [625,626] [628,631] | |
| sce_bool426: float [value] @0 [631,633] | |
| bin428: float [value] @0 [null] | |
| sce_value429: float [value] @3 [632,633] [635,638] | |
| sce_bool430: float [value] @0 [638,639] | |
| bin438: float [value] @0 [644,646] | |
| sce_value442: float [value] @0 [648,649] [651,654] | |
| sce_bool443: float [value] @0 [null] | |
| sce_value444: float [value] @3 [645,646] [654,657] | |
| sce_bool445: float [value] @0 [657,659] | |
| bin447: float [value] @0 [null] | |
| sce_value448: float [value] @3 [658,659] [661,664] | |
| sce_bool449: float [value] @0 [664,666] | |
| sce_value453: float [value] @0 [668,669] [671,674] | |
| sce_bool454: float [value] @0 [null] | |
| sce_value455: float [value] @3 [665,666] [674,677] | |
| sce_bool456: float [value] @0 [677,679] | |
| bin458: float [value] @0 [null] | |
| sce_value459: float [value] @3 [678,679] [681,684] | |
| sce_bool460: float [value] @0 [684,686] | |
| sce_value464: float [value] @0 [688,689] [691,694] | |
| sce_bool465: float [value] @0 [null] | |
| sce_value466: float [value] @3 [685,686] [694,697] | |
| sce_bool467: float [value] @0 [697,698] | |
| sce_value472: float [value] @0 [703,704] [706,709] | |
| sce_bool473: float [value] @0 [709,710] | |
| bin479: float [value] @0 [715,717] | |
| sce_value481: float [value] @3 [716,717] [719,722] | |
| sce_bool482: float [value] @0 [722,724] | |
| bin484: float [value] @0 [null] | |
| sce_value485: float [value] @3 [723,724] [726,729] | |
| sce_bool486: float [value] @0 [729,731] | |
| sce_value488: float [value] @3 [730,731] [733,736] | |
| sce_bool489: float [value] @0 [736,737] | |
| sce_value497: float [value] @0 [748,749] [751,754] | |
| sce_bool498: float [value] @0 [754,755] | |
| call502: float [value] @0 [null] | |
| call503: float [value] @0 [null] | |
| bin504: float [value] @0 [767,768] | |
| bin505: float [value] @0 [null] | |
| bin506: float [value] @0 [769,770] | |
| bin507: float [value] @0 [null] | |
| bin513: float [value] @0 [781,783] | |
| sce_value515: float [value] @3 [782,783] [785,788] | |
| sce_bool516: float [value] @0 [788,789] | |
| bin518: float [value] callparam @0 [791,792] | |
| call519: float [return] @0 [792,792] | |
| bin524: float [value] @0 [799,801] | |
| sce_value526: float [value] @3 [800,801] [803,806] | |
| sce_bool527: float [value] @0 [806,807] | |
| bin529: float [value] callparam @0 [809,810] | |
| call530: float [return] @0 [810,810] | |
| call535: float [return] @0 [819,821] [827,829] [835,836] | |
| switch_eq537: float [value] @0 [820,821] | |
| call540: vector [value] @0 [null] | |
| call540_x: @0 | |
| call540_y: @0 | |
| call540_z: @0 | |
| switch_eq541: float [value] @0 [828,829] | |
| call544: vector [value] @0 [null] | |
| call544_x: @0 | |
| call544_y: @0 | |
| call544_z: @0 | |
| switch_eq545: float [value] @0 [836,837] | |
| call548: vector [value] @0 [null] | |
| call548_x: @0 | |
| call548_y: @0 | |
| call548_z: @0 | |
| call552: float [return] @0 [859,860] | |
| bin553: float [value] callparam @0 [860,861] | |
| call554: float [value] @0 [null] | |
| bin555: float [value] @3 [862,863] | |
| bin556: float [value] @3 [863,865] | |
| bin557: float [value] @0 [864,865] | |
| bin558: float [value] @0 [null] | |
| bin560: vector [value] @0 [868,870] | |
| bin560_x: @0 [868,870] | |
| bin560_y: @0 [868,870] | |
| bin560_z: @0 [868,870] | |
| bin561: vector [value] @3 [869,870] | |
| bin561_x: @0 [869,870] | |
| bin561_y: @0 [869,870] | |
| bin561_z: @0 [869,870] | |
| bin562: vector [value] callparam @0 [870,872] | |
| bin562_x: @0 [870,872] | |
| bin562_y: @0 [870,872] | |
| bin562_z: @0 [870,872] | |
| bin563: float [value] callparam @0 [871,872] | |
| call564: float [return] @0 [872,872] | |
| sce_value569: float [value] @0 [877,878] [880,883] | |
| sce_bool570: float [value] @0 [883,884] | |
| bin572: float [value] @0 [null] | |
| bin573: float [value] @0 [null] | |
| call579: float [value] @0 [null] | |
| call580: float [value] @0 [null] | |
| bin581: float [value] @0 [904,905] | |
| bin582: float [value] @0 [null] | |
| bin583: float [value] @0 [906,907] | |
| bin584: float [value] @0 [null] | |
| call585: float [value] @0 [null] | |
| bin586: float [value] @0 [909,910] | |
| bin587: float [value] callparam @0 [910,911] | |
| call588: float [value] @0 [null] | |
| bin589: float [value] @0 [912,913] | |
| bin590: float [value] callparam @0 [913,914] | |
| call591: float [value] @0 [null] | |
| bin594: float [value] @0 [null] | |
| sce_value595: float [value] @0 [918,919] [921,924] | |
| sce_bool596: float [value] @0 [924,925] | |
| bin598: float [value] @0 [927,928] | |
| bin599: float [value] callparam @0 [928,929] | |
| call600: float [value] callparam @0 [929,930] | |
| call601: float [value] callparam @0 [930,931] | |
| call602: float [return] @0 [931,932] | |
| bin603: float [value] locked @2 [932,936] | |
| call604: float [return] @0 [933,934] | |
| bin605: float [value] @0 [934,935] | |
| bin606: float [value] @0 [935,936] | |
| bin607: float [value] @0 [936,937] | |
| bin608: float [value] @0 [null] | |
| bin610: float [value] callparam @0 [940,941] | |
| call611: float [value] @0 [null] | |
| bin612: float [value] @0 [942,943] | |
| bin614: float [value] @0 [945,946] | |
| bin617: float [value] @0 [952,953] | |
| binst618: float [value] @0 [null] | |
| bin622: float [value] @0 [958,960] | |
| sce_value624: float [value] @3 [959,960] [962,965] | |
| sce_bool625: float [value] @0 [965,966] | |
| sce_value630: float [value] @0 [973,974] [976,979] | |
| sce_bool631: float [value] @0 [979,980] | |
| bin633: float [value] @0 [982,983] | |
| bin635: float [value] @0 [985,986] | |
| call637: float [return] @0 [988,990] | |
| bin638: vector [value] locked @5 [989,992] | |
| bin638_x: locked @0 [989,992] | |
| bin638_y: locked @0 [989,992] | |
| bin638_z: locked @0 [989,992] | |
| call639: float [return] @0 [990,992] | |
| bin640: vector [value] @0 [991,992] | |
| bin640_x: @0 [991,992] | |
| bin640_y: @0 [991,992] | |
| bin640_z: @0 [991,992] | |
| bin641: vector [value] locked @5 [992,995] | |
| bin641_x: locked @0 [992,995] | |
| bin641_y: locked @0 [992,995] | |
| bin641_z: locked @0 [992,995] | |
| call642: float [return] @0 [993,995] | |
| bin643: vector [value] @0 [994,995] | |
| bin643_x: @0 [994,995] | |
| bin643_y: @0 [994,995] | |
| bin643_z: @0 [994,995] | |
| bin644: vector [value] @0 [null] | |
| bin644_x: @0 | |
| bin644_y: @0 | |
| bin644_z: @0 | |
| call647: vector [value] @0 [null] | |
| call647_x: @0 | |
| call647_y: @0 | |
| call647_z: @0 | |
| bin649: vector [value] @0 [1003,1005] | |
| bin649_x: @0 [1003,1005] | |
| bin649_y: @0 [1003,1005] | |
| bin649_z: @0 [1003,1005] | |
| bin650: vector [value] @3 [1004,1005] | |
| bin650_x: @0 [1004,1005] | |
| bin650_y: @0 [1004,1005] | |
| bin650_z: @0 [1004,1005] | |
| bin651: vector [value] locked @5 [1005,1009] | |
| bin651_x: locked @0 [1005,1009] | |
| bin651_y: locked @0 [1005,1009] | |
| bin651_z: locked @0 [1005,1009] | |
| call652: float [return] @0 [1006,1007] | |
| bin653: float [value] @0 [1007,1008] | |
| bin654: float [value] callparam @0 [1008,1009] | |
| call655: float [return] @0 [1009,1009] | |
| call657: vector [value] locked @5 [1012,1015] | |
| call657_x: locked @0 [1012,1015] | |
| call657_y: locked @0 [1012,1015] | |
| call657_z: locked @0 [1012,1015] | |
| call658: float [return] @0 [1013,1014] | |
| bin659: float [value] callparam @0 [1014,1015] | |
| call660: float [return] @0 [1015,1015] | |
| sce_value665: float [value] @0 [1020,1021] [1023,1026] | |
| sce_bool666: float [value] @0 [1026,1027] | |
| call668: float [return] @0 [1030,1031] | |
| bin669: float [value] @0 [null] | |
| call670: float [return] @0 [1032,1033] | |
| bin671: float [value] @0 [null] | |
| bin676: float [value] @0 [null] | |
| bin677: float [value] @0 [null] | |
| sce_value682: float [value] @0 [1050,1051] [1053,1056] | |
| sce_bool683: float [value] @0 [null] | |
| sce_value684: float [value] @0 [1047,1048] [1056,1059] | |
| sce_bool685: float [value] @0 [1059,1060] | |
| call687: float [return] @0 [1062,1063] | |
| bin688: float [value] @0 [1063,1064] | |
| call690: string [value] callparam @0 [1066,1067] | |
| call691: void [return] @0 [null] | |
| call693: float [return] @0 [1070,1071] | |
| bin694: float [value] @0 [1071,1072] | |
| call696: string [value] callparam @0 [1074,1075] | |
| call697: void [return] @0 [null] | |
| sce_value701: float [value] @0 [1078,1079] [1081,1084] | |
| sce_bool702: float [value] @0 [1084,1085] | |
| bin704: float [value] callparam @0 [1087,1088] | |
| call705: float [value] @0 [null] | |
| bin706: float [value] callparam @0 [1089,1090] | |
| call707: float [value] @0 [null] | |
| bin709: float [value] @0 [1091,1093] | |
| bin711: float [value] @0 [null] | |
| sce_value712: float [value] @3 [1092,1093] [1095,1098] | |
| sce_bool713: float [value] @0 [1098,1099] | |
| call715: string [value] locked @8 [1101,1103] | |
| call716: string [value] callparam @0 [1102,1103] | |
| call717: string [value] callparam @0 [1103,1104] | |
| call718: void [return] @0 [null] | |
| call721: string [return] @0 [1111,1112] | |
| bin722: float [value] @0 [1112,1113] | |
| call724: void [return] @0 [null] | |
| call727: float [value] @0 [null] | |
| call728: float [value] @0 [null] | |
| bin729: float [value] @3 [1125,1126] | |
| bin730: float [value] @3 [1126,1127] | |
| bin732: float [value] @3 [1129,1130] | |
| binst733: float [value] @0 [null] | |
| bin735: float [value] @3 [1133,1134] | |
| bin736: float [value] @3 [1134,1135] | |
| bin738: float [value] @0 [1137,1138] | |
| binst739: float [value] @0 [null] | |
| call741: float [return] @0 [1141,1142] | |
| bin742: float [value] @0 [1142,1143] | |
| phi746: float [value] @0 [1145,1146] [1148,1151] | |
| call747: float [value] @0 [null] | |
| bin750: float [value] @0 [null] | |
| sce_value751: float [value] @0 [1152,1153] [1155,1158] | |
| sce_bool752: float [value] @0 [1158,1159] | |
| bin754: float [value] @0 [1161,1162] | |
| bin756: float [value] @0 [1164,1165] | |
| bin757: float [value] callparam @0 [1165,1166] | |
| call758: string [value] locked @5 [1166,1170] | |
| bin759: float [value] @0 [1167,1168] | |
| bin760: float [value] callparam @0 [1168,1169] | |
| call761: string [value] callparam @0 [1169,1170] | |
| call762: string [value] callparam @0 [1170,1171] | |
| call763: void [return] @0 [null] | |
| call766: string [return] @0 [1177,1178] | |
| bin767: float [value] @0 [1178,1179] | |
| call769: void [return] @0 [null] | |
| call772: float [return] @0 [1187,1188] | |
| bin773: float [value] @0 [1188,1189] | |
| call775: void [return] @0 [null] | |
| call778: float [return] @0 [1196,1197] | |
| bin779: float [value] @0 [1197,1198] | |
| call781: void [return] @0 [null] | |
| call785: void [return] @0 [null] | |
| call788: entity [return] @0 [1214,1216] | |
| efv791: function [value] @0 [1218,1219] | |
| efv793: function [value] locked @5 [1221,1222] | |
| call794: void [return] @0 [null] | |
| call796: void [return] @0 [null] | |
| call797: float [value] @0 [null] | |
| call798: float [value] @0 [null] | |
| bin800: float [value] @0 [1231,1233] | |
| sce_value802: float [value] @3 [1232,1233] [1235,1238] | |
| sce_bool803: float [value] @0 [1238,1239] | |
| bin805: float [value] @0 [1241,1242] | |
| bin806: float [value] @0 [1242,1243] | |
| call808: void [return] @0 [null] | |
| bin810: float [value] @0 [null] | |
| call812: float [value] @0 [null] | |
| bin813: float [value] @0 [1252,1253] | |
| bin815: float [value] @0 [1255,1256] | |
| bin816: float [value] @0 [1256,1257] | |
| call818: void [return] @0 [null] | |
| bin820: float [value] @0 [null] | |
| bin822: float [value] @0 [1265,1266] | |
| call824: float [return] @0 [1268,1269] | |
| bin826: vector [value] @0 [1271,1273] | |
| bin826_x: @0 [1271,1273] | |
| bin826_y: @0 [1271,1273] | |
| bin826_z: @0 [1271,1273] | |
| bin827: vector [value] @3 [1272,1273] | |
| bin827_x: @0 [1272,1273] | |
| bin827_y: @0 [1272,1273] | |
| bin827_z: @0 [1272,1273] | |
| bin828: vector [value] callparam @0 [1273,1274] | |
| bin828_x: @0 [1273,1274] | |
| bin828_y: @0 [1273,1274] | |
| bin828_z: @0 [1273,1274] | |
| call829: float [return] @0 [1274,1274] | |
| call831: float [return] @0 [1277,1278] | |
| bin833: vector [value] @0 [1280,1282] | |
| bin833_x: @0 [1280,1282] | |
| bin833_y: @0 [1280,1282] | |
| bin833_z: @0 [1280,1282] | |
| bin834: vector [value] @3 [1281,1282] | |
| bin834_x: @0 [1281,1282] | |
| bin834_y: @0 [1281,1282] | |
| bin834_z: @0 [1281,1282] | |
| bin835: vector [value] locked @2 [1282,1285] | |
| bin835_x: locked @0 [1282,1285] | |
| bin835_y: locked @0 [1282,1285] | |
| bin835_z: locked @0 [1282,1285] | |
| bin836: float [value] locked @5 [1283,1285] | |
| call837: float [value] callparam @0 [1284,1285] | |
| call838: void [return] @0 [null] | |
| bin839: vector [value] callparam @0 [1286,1290] | |
| bin839_x: @0 [1286,1290] | |
| bin839_y: @0 [1286,1290] | |
| bin839_z: @0 [1286,1290] | |
| bin840: vector [value] @0 [1287,1289] | |
| bin840_x: @0 [1287,1289] | |
| bin840_y: @0 [1287,1289] | |
| bin840_z: @0 [1287,1289] | |
| bin841: vector [value] @3 [1288,1289] | |
| bin841_x: @0 [1288,1289] | |
| bin841_y: @0 [1288,1289] | |
| bin841_z: @0 [1288,1289] | |
| bin842: vector [value] callparam @0 [1289,1290] | |
| bin842_x: @0 [1289,1290] | |
| bin842_y: @0 [1289,1290] | |
| bin842_z: @0 [1289,1290] | |
| call843: void [return] @0 [null] | |
| bin846: float [value] @0 [1295,1296] | |
| bin848: float [value] @0 [1298,1299] | |
| call850: void [return] @0 [null] | |
| unary857: float [value] @0 [1306,1308] | |
| unary859: float [value] @0 [null] | |
| sce_value860: float [value] @3 [1307,1308] [1310,1313] | |
| sce_bool861: float [value] @0 [1313,1315] | |
| bin863: float [value] @0 [null] | |
| sce_value864: float [value] @3 [1314,1315] [1317,1320] | |
| sce_bool865: float [value] @0 [1320,1322] | |
| bin867: float [value] @0 [null] | |
| sce_value868: float [value] @3 [1321,1322] [1324,1327] | |
| sce_bool869: float [value] @0 [1327,1329] | |
| bin871: float [value] @0 [null] | |
| sce_value872: float [value] @3 [1328,1329] [1331,1334] | |
| sce_bool873: float [value] @0 [1334,1335] | |
| bin877: float [value] @0 [1342,1343] | |
| bin880: float [value] @0 [1348,1349] | |
| bin883: float [value] @0 [1354,1355] | |
| bin886: vector [value] @0 [1359,1360] | |
| bin886_x: @0 [1359,1360] | |
| bin886_y: @0 [1359,1360] | |
| bin886_z: @0 [1359,1360] | |
| bin887: vector [value] callparam @0 [1360,1361] | |
| bin887_x: @0 [1360,1361] | |
| bin887_y: @0 [1360,1361] | |
| bin887_z: @0 [1360,1361] | |
| call888: vector [value] @0 [null] | |
| call888_x: @0 | |
| call888_y: @0 | |
| call888_z: @0 | |
| call890: float [value] @0 [null] | |
| bin891: float [value] @0 [1367,1368] | |
| bin893: vector [value] @0 [null] | |
| bin893_x: @0 | |
| bin893_y: @0 | |
| bin893_z: @0 | |
| binst894: float [value] @0 [null] | |
| binst895: float [value] @0 [null] | |
| call896: float [return] @0 [1373,1374] | |
| bin897: float [value] @0 [1374,1375] | |
| sce_value907: float [value] @0 [1395,1396] [1398,1401] | |
| sce_bool908: float [value] @0 [1401,1402] | |
| call910: entity [value] @0 [null] | |
| efv913: string [value] @0 [1408,1409] | |
| bin914: float [value] @0 [null] | |
| sce_value915: float [value] @0 [1405,1406] [1409,1412] | |
| sce_bool916: float [value] @0 [1412,1413] | |
| efv918: string [value] @0 [null] | |
| call920: string [value] callparam @0 [1418,1419] | |
| call921: float [return] @0 [1419,1420] | |
| binst922: float [value] @0 [null] | |
| bin923: float [value] @0 [1421,1422] | |
| call926: string [value] callparam @0 [1426,1427] | |
| call927: float [return] @0 [1427,1428] | |
| binst928: float [value] @0 [null] | |
| bin929: float [value] @0 [1429,1430] | |
| call932: string [value] callparam @0 [1434,1435] | |
| call933: string [value] @0 [null] | |
| bin935: float [value] @0 [1436,1438] | |
| bin937: float [value] @0 [null] | |
| sce_value938: float [value] @3 [1437,1438] [1440,1443] | |
| sce_bool939: float [value] @0 [1443,1444] | |
| bin946: float [value] @0 [1455,1457] | |
| sce_value948: float [value] @3 [1456,1457] [1459,1462] | |
| sce_bool949: float [value] @0 [1462,1463] | |
| call951: string [value] callparam @0 [1465,1466] | |
| call952: string [value] callparam @0 [1466,1467] | |
| call953: vector [value] @0 [null] | |
| call953_x: @0 | |
| call953_y: @0 | |
| call953_z: @0 | |
| call956: float [value] @0 [null] | |
| bin957: float [value] @3 [1474,1475] | |
| bin960: float [value] @3 [1481,1482] | |
| bin962: float [value] @3 [1484,1485] | |
| bin963: float [value] @3 [1485,1486] | |
| bin964: float [value] @3 [1486,1487] | |
| bin965: float [value] @0 [null] | |
| bin966: float [value] @0 [1488,1489] | |
| bin967: float [value] @0 [1489,1490] | |
| bin968: float [value] @0 [1490,1491] | |
| bin969: float [value] @0 [null] | |
| bin971: float [value] @3 [1494,1495] | |
| bin973: float [value] @3 [1497,1498] | |
| bin974: float [value] @3 [1498,1499] | |
| bin975: float [value] @3 [1499,1500] | |
| bin976: float [value] @0 [null] | |
| bin977: float [value] @3 [1501,1502] | |
| bin978: float [value] @3 [1502,1503] | |
| bin979: float [value] @3 [1503,1504] | |
| bin980: float [value] @0 [null] | |
| bin981: float [value] @0 [1505,1506] | |
| bin982: float [value] @0 [1506,1507] | |
| bin983: float [value] @0 [null] | |
| bin985: float [value] @3 [1510,1511] | |
| bin987: float [value] @0 [1515,1516] | |
| bin988: float [value] @0 [1516,1517] | |
| bin989: float [value] @0 [1517,1518] | |
| bin990: float [value] @0 [null] | |
| bin992: float [value] @3 [1521,1522] | |
| bin994: float [value] @3 [1525,1526] | |
| bin995: float [value] @3 [1526,1527] | |
| bin996: float [value] @3 [1527,1528] | |
| bin997: float [value] @0 [null] | |
| bin998: float [value] @0 [1529,1530] | |
| bin999: float [value] @0 [1530,1531] | |
| bin1000: float [value] @0 [1531,1532] | |
| bin1001: float [value] @0 [1532,1533] | |
| bin1002: float [value] @0 [null] | |
| call1010: vector [value] @0 [null] | |
| call1010_x: @0 | |
| call1010_y: @0 | |
| call1010_z: @0 | |
| call1013: string [value] @0 [null] | |
| call1018: float [value] @0 [null] | |
| bin1019: float [value] @3 [1568,1569] | |
| bin1021: float [value] @3 [1571,1572] | |
| bin1022: float [value] @3 [1572,1573] | |
| bin1026: float [value] @0 [1581,1582] | |
| bin1028: float [value] @0 [1584,1585] | |
| binst1029: float [value] @0 [null] | |
| call1032: float [return] @0 [1591,1592] | |
| bin1033: float [value] @0 [1592,1593] | |
| binst1034: float [value] @0 [null] | |
| call1038: vector [value] @0 [null] | |
| call1038_x: @0 | |
| call1038_y: @0 | |
| call1038_z: @0 | |
| call1040: vector [value] @0 [null] | |
| call1040_x: @0 | |
| call1040_y: @0 | |
| call1040_z: @0 | |
| phi1042: vector [value] @0 [1600,1601] [1603,1606] | |
| phi1042_x: @0 [1600,1601] [1603,1606] | |
| phi1042_y: @0 [1600,1601] [1603,1606] | |
| phi1042_z: @0 [1600,1601] [1603,1606] | |
| bin1043: float [value] @0 [1607,1608] | |
| bin1045: float [value] @0 [1610,1611] | |
| bin1046: float [value] @0 [1611,1612] | |
| bin1050: float [value] @0 [1620,1621] | |
| bin1052: float [value] @0 [1623,1624] | |
| binst1053: float [value] @0 [null] | |
| call1056: float [return] @0 [1630,1631] | |
| bin1057: float [value] @0 [1631,1632] | |
| binst1058: float [value] @0 [null] | |
| call1059: float [return] @0 [1633,1634] | |
| bin1060: float [value] @0 [1634,1635] | |
| binst1061: float [value] @0 [null] | |
| call1062: float [return] @0 [1636,1637] | |
| bin1063: float [value] @0 [1637,1638] | |
| binst1064: float [value] @0 [null] | |
| call1065: float [return] @0 [1639,1640] | |
| bin1066: float [value] @0 [1640,1641] | |
| binst1067: float [value] @0 [null] | |
| bin1069: float [value] @0 [1644,1645] | |
| binst1071: float [value] @0 [null] | |
| bin1073: float [value] @0 [1650,1651] | |
| binst1075: float [value] @0 [null] | |
| bin1077: float [value] @0 [1657,1658] | |
| bin1079: float [value] @0 [1660,1661] | |
| binst1080: float [value] @0 [null] | |
| bin1084: float [value] @0 [1664,1666] | |
| bin1086: float [value] @0 [null] | |
| sce_value1087: float [value] @3 [1665,1666] [1668,1671] | |
| sce_bool1088: float [value] @0 [1671,1673] | |
| bin1090: float [value] @0 [null] | |
| sce_value1091: float [value] @3 [1672,1673] [1675,1678] | |
| sce_bool1092: float [value] @0 [1678,1679] | |
| bin1094: float [value] @0 [null] | |
| bin1097: float [value] @0 [1684,1686] | |
| bin1099: float [value] @0 [null] | |
| sce_value1100: float [value] @3 [1685,1686] [1688,1691] | |
| sce_bool1101: float [value] @0 [1691,1692] | |
| bin1103: float [value] @0 [null] | |
| call1105: void [return] @0 [null] | |
| call1107: string [value] @0 [null] | |
| bin1110: float [value] @0 [1711,1713] | |
| bin1114: float [value] @0 [1715,1717] | |
| sce_value1116: float [value] @3 [1716,1717] [1719,1722] | |
| sce_bool1117: float [value] @0 [1722,1724] | |
| unary1119: float [value] @0 [null] | |
| sce_value1120: float [value] @3 [1723,1724] [1726,1729] | |
| sce_bool1121: float [value] @0 [null] | |
| sce_value1122: float [value] @3 [1712,1713] [1729,1732] | |
| sce_bool1123: float [value] @0 [1732,1733] | |
| binst1125: float [value] @0 [null] | |
| bin1128: float [value] @0 [1742,1743] | |
| bin1130: float [value] @0 [1745,1746] | |
| bin1131: float [value] @0 [1746,1747] | |
| bin1132: float [value] @0 [null] | |
| bin1133: float [value] @0 [1748,1751] | |
| bin1134: float [value] @3 [1749,1750] | |
| bin1135: float [value] @3 [1750,1751] | |
| bin1136: float [value] @0 [null] | |
| bin1137: float [value] @0 [1752,1755] | |
| bin1138: float [value] @3 [1753,1754] | |
| bin1139: float [value] @3 [1754,1755] | |
| bin1140: float [value] @0 [null] | |
| bin1141: vector [value] @0 [1756,1759] | |
| bin1141_x: @0 [1756,1759] | |
| bin1141_y: @0 [1756,1759] | |
| bin1141_z: @0 [1756,1759] | |
| bin1142: float [value] @3 [1757,1759] | |
| bin1143: vector [value] @6 [1758,1759] | |
| bin1143_x: @0 [1758,1759] | |
| bin1143_y: @0 [1758,1759] | |
| bin1143_z: @0 [1758,1759] | |
| bin1144: vector [value] @0 [null] | |
| bin1144_x: @0 | |
| bin1144_y: @0 | |
| bin1144_z: @0 | |
| bin1146: float [value] @0 [1765,1766] | |
| binst1147: float [value] @0 [null] | |
| bin1148: float [value] @0 [1767,1768] | |
| binst1149: float [value] @0 [null] | |
| call1150: vector [return] @0 [1769,1770] | |
| call1150_x: @0 [1769,1770] | |
| call1150_y: @0 [1769,1770] | |
| call1150_z: @0 [1769,1770] | |
| bin1151: vector [value] @0 [null] | |
| bin1151_x: @0 | |
| bin1151_y: @0 | |
| bin1151_z: @0 | |
| bin1153: float [value] @0 [1771,1773] | |
| bin1155: float [value] @0 [null] | |
| sce_value1156: float [value] @3 [1772,1773] [1775,1778] | |
| sce_bool1157: float [value] @0 [1778,1779] | |
| sce_value1161: float [value] @0 [1781,1782] [1784,1787] | |
| sce_bool1162: float [value] @0 [1787,1788] | |
| call1164: float [value] @0 [null] | |
| call1165: float [value] @0 [null] | |
| call1166: float [value] @0 [null] | |
| call1167: float [value] @0 [null] | |
| bin1168: float [value] @3 [1804,1805] | |
| bin1175: float [value] @0 [null] | |
| sce_value1176: float [value] @3 [1810,1811] [1813,1816] | |
| sce_bool1177: float [value] @3 [1816,1818] | |
| sce_value1179: float [value] @6 [1817,1818] [1820,1823] | |
| sce_bool1180: float [value] @3 [1823,1825] | |
| sce_value1182: float [value] @6 [1824,1825] [1827,1830] | |
| sce_bool1183: float [value] @3 [1830,1831] | |
| sce_value1187: float [value] @3 [1833,1834] [1836,1839] | |
| sce_bool1188: float [value] @3 [1839,1840] | |
| bin1191: float [value] @0 [1846,1847] | |
| bin1192: float [value] @0 [1847,1849] | |
| bin1193: float [value] @3 [1848,1849] | |
| bin1194: float [value] @0 [null] | |
| bin1195: float [value] @0 [1850,1851] | |
| bin1196: float [value] callparam @0 [1851,1852] | |
| call1197: float [value] @0 [null] | |
| bin1199: vector [value] @0 [1856,1858] | |
| bin1199_x: @0 [1856,1858] | |
| bin1199_y: @0 [1856,1858] | |
| bin1199_z: @0 [1856,1858] | |
| bin1200: vector [value] @3 [1857,1858] | |
| bin1200_x: @0 [1857,1858] | |
| bin1200_y: @0 [1857,1858] | |
| bin1200_z: @0 [1857,1858] | |
| bin1201: vector [value] @0 [1858,1860] | |
| bin1201_x: @0 [1858,1860] | |
| bin1201_y: @0 [1858,1860] | |
| bin1201_z: @0 [1858,1860] | |
| bin1202: vector [value] @3 [1859,1860] | |
| bin1202_x: @0 [1859,1860] | |
| bin1202_y: @0 [1859,1860] | |
| bin1202_z: @0 [1859,1860] | |
| bin1203: vector [value] @0 [null] | |
| bin1203_x: @0 | |
| bin1203_y: @0 | |
| bin1203_z: @0 | |
| bin1209: float [value] @0 [null] | |
| sce_value1210: float [value] @0 [1868,1869] [1871,1874] | |
| sce_bool1211: float [value] @0 [1874,1876] | |
| sce_value1213: float [value] @3 [1875,1876] [1878,1881] | |
| sce_bool1214: float [value] @0 [1881,1883] | |
| sce_value1216: float [value] @3 [1882,1883] [1885,1888] | |
| sce_bool1217: float [value] @0 [1888,1889] | |
| call1219: float [return] @0 [1891,1892] | |
| bin1220: float [value] callparam @0 [1892,1893] | |
| call1221: float [value] @0 [null] | |
| bin1225: float [value] @0 [1899,1901] | |
| call1227: float [value] @0 [null] | |
| sce_value1228: float [value] @3 [1900,1901] [1903,1906] | |
| sce_bool1229: float [value] @0 [1906,1908] | |
| sce_value1231: float [value] @3 [1907,1908] [1910,1913] | |
| sce_bool1232: float [value] @0 [1913,1914] | |
| call1234: float [return] @0 [1916,1917] | |
| bin1235: float [value] callparam @0 [1917,1918] | |
| call1236: float [value] @0 [null] | |
| sce_value1242: float [value] @0 [1928,1929] [1931,1934] | |
| sce_bool1243: float [value] @0 [1934,1935] | |
| bin1245: float [value] callparam @0 [1937,1938] | |
| call1246: float [value] @0 [null] | |
| bin1248: float [value] @0 [1942,1944] | |
| bin1250: float [value] @0 [null] | |
| sce_value1251: float [value] @3 [1943,1944] [1946,1949] | |
| sce_bool1252: float [value] @0 [1949,1950] | |
| bin1257: float [value] @0 [1960,1961] | |
| bin1259: float [value] @0 [1963,1964] | |
| bin1260: float [value] @0 [null] | |
| bin1262: float [value] @0 [1965,1967] | |
| bin1264: float [value] @0 [null] | |
| sce_value1265: float [value] @3 [1966,1967] [1969,1972] | |
| sce_bool1266: float [value] @0 [1972,1973] | |
| bin1268: float [value] callparam @0 [1975,1976] | |
| call1269: float [return] @0 [1976,1977] | |
| binst1270: float [value] @0 [null] | |
| sce_value1275: float [value] @0 [1982,1983] [1985,1988] | |
| sce_bool1276: float [value] @0 [1988,1989] | |
| bin1278: float [value] callparam @0 [1991,1993] | |
| bin1279: float [value] callparam @0 [1992,1993] | |
| call1280: void [return] @0 [null] | |
| bin1283: float [value] callparam @0 [1998,2000] | |
| bin1284: float [value] callparam @0 [1999,2000] | |
| call1285: void [return] @0 [null] | |
| bin1290: float [value] @0 [2005,2007] | |
| bin1292: float [value] @0 [null] | |
| sce_value1293: float [value] @3 [2006,2007] [2009,2012] | |
| sce_bool1294: float [value] @0 [2012,2014] | |
| sce_value1296: float [value] @3 [2013,2014] [2016,2019] | |
| sce_bool1297: float [value] @0 [2019,2020] | |
| bin1299: float [value] @0 [2022,2024] | |
| bin1300: float [value] @3 [2023,2024] | |
| bin1301: float [value] @0 [null] | |
| call1302: vector [return] @0 [2025,2026] | |
| call1302_x: @0 [2025,2026] | |
| call1302_y: @0 [2025,2026] | |
| call1302_z: @0 [2025,2026] | |
| bin1303: vector [value] @0 [null] | |
| bin1303_x: @0 | |
| bin1303_y: @0 | |
| bin1303_z: @0 | |
| bin1307: float [value] @0 [2031,2032] | |
| bin1310: float [value] @0 [2037,2038] | |
| bin1315: float [value] @0 [2046,2047] | |
| bin1319: float [value] @0 [2052,2054] | |
| bin1320: float [value] @3 [2053,2054] | |
| bin1321: float [value] @0 [2054,2056] | |
| bin1322: vector [value] @3 [2055,2060] | |
| bin1322_x: @0 [2055,2060] | |
| bin1322_y: @0 [2055,2060] | |
| bin1322_z: @0 [2055,2060] | |
| bin1323: float [value] @0 [2056,2058] | |
| bin1324: float [value] @6 [2057,2058] | |
| bin1325: float [value] @0 [2058,2060] | |
| bin1326: vector [value] @6 [2059,2060] | |
| bin1326_x: @0 [2059,2060] | |
| bin1326_y: @0 [2059,2060] | |
| bin1326_z: @0 [2059,2060] | |
| bin1327: vector [value] @0 [2060,2061] | |
| bin1327_x: @0 [2060,2061] | |
| bin1327_y: @0 [2060,2061] | |
| bin1327_z: @0 [2060,2061] | |
| bin1328: vector [value] callparam @0 [2061,2066] | |
| bin1328_x: @0 [2061,2066] | |
| bin1328_y: @0 [2061,2066] | |
| bin1328_z: @0 [2061,2066] | |
| bin1329: vector [value] callparam @0 [2062,2066] | |
| bin1329_x: @0 [2062,2066] | |
| bin1329_y: @0 [2062,2066] | |
| bin1329_z: @0 [2062,2066] | |
| bin1330: float [value] @0 [2063,2064] | |
| bin1331: float [value] @0 [2064,2065] | |
| bin1332: float [value] callparam @0 [2065,2066] | |
| call1333: float [return] @0 [2066,2066] | |
| binst1334: float [value] @0 [null] | |
| binst1335: float [value] @0 [null] | |
| bin1337: float [value] @0 [2073,2075] | |
| bin1338: float [value] @3 [2074,2075] | |
| bin1339: float [value] @0 [2075,2077] | |
| bin1340: vector [value] @3 [2076,2081] | |
| bin1340_x: @0 [2076,2081] | |
| bin1340_y: @0 [2076,2081] | |
| bin1340_z: @0 [2076,2081] | |
| bin1341: float [value] @0 [2077,2079] | |
| bin1342: float [value] @6 [2078,2079] | |
| bin1343: float [value] @0 [2079,2081] | |
| bin1344: vector [value] @6 [2080,2081] | |
| bin1344_x: @0 [2080,2081] | |
| bin1344_y: @0 [2080,2081] | |
| bin1344_z: @0 [2080,2081] | |
| bin1345: vector [value] @0 [2081,2082] | |
| bin1345_x: @0 [2081,2082] | |
| bin1345_y: @0 [2081,2082] | |
| bin1345_z: @0 [2081,2082] | |
| bin1346: vector [value] callparam @0 [2082,2086] | |
| bin1346_x: @0 [2082,2086] | |
| bin1346_y: @0 [2082,2086] | |
| bin1346_z: @0 [2082,2086] | |
| bin1347: vector [value] callparam @0 [2083,2086] | |
| bin1347_x: @0 [2083,2086] | |
| bin1347_y: @0 [2083,2086] | |
| bin1347_z: @0 [2083,2086] | |
| bin1348: float [value] @0 [2084,2085] | |
| bin1349: float [value] callparam @0 [2085,2086] | |
| call1350: float [return] @0 [2086,2086] | |
| bin1352: float [value] @0 [null] | |
| call1355: vector [return] @0 [2098,2099] | |
| call1355_x: @0 [2098,2099] | |
| call1355_y: @0 [2098,2099] | |
| call1355_z: @0 [2098,2099] | |
| bin1356: vector [value] @0 [null] | |
| bin1356_x: @0 | |
| bin1356_y: @0 | |
| bin1356_z: @0 | |
| bin1360: float [value] @0 [2104,2105] | |
| bin1363: float [value] @0 [2110,2111] | |
| bin1368: float [value] @0 [2119,2120] | |
| bin1372: float [value] @0 [2125,2127] | |
| bin1373: float [value] @3 [2126,2127] | |
| bin1374: float [value] @0 [2127,2129] | |
| bin1375: vector [value] @3 [2128,2133] | |
| bin1375_x: @0 [2128,2133] | |
| bin1375_y: @0 [2128,2133] | |
| bin1375_z: @0 [2128,2133] | |
| bin1376: float [value] @0 [2129,2131] | |
| bin1377: float [value] @6 [2130,2131] | |
| bin1378: float [value] @0 [2131,2133] | |
| bin1379: vector [value] @6 [2132,2133] | |
| bin1379_x: @0 [2132,2133] | |
| bin1379_y: @0 [2132,2133] | |
| bin1379_z: @0 [2132,2133] | |
| bin1380: vector [value] @0 [2133,2134] | |
| bin1380_x: @0 [2133,2134] | |
| bin1380_y: @0 [2133,2134] | |
| bin1380_z: @0 [2133,2134] | |
| bin1381: vector [value] callparam @0 [2134,2138] | |
| bin1381_x: @0 [2134,2138] | |
| bin1381_y: @0 [2134,2138] | |
| bin1381_z: @0 [2134,2138] | |
| bin1382: vector [value] callparam @0 [2135,2138] | |
| bin1382_x: @0 [2135,2138] | |
| bin1382_y: @0 [2135,2138] | |
| bin1382_z: @0 [2135,2138] | |
| bin1383: float [value] @0 [2136,2137] | |
| bin1384: float [value] callparam @0 [2137,2138] | |
| call1385: float [return] @0 [2138,2138] | |
| binst1386: float [value] @0 [null] | |
| binst1387: float [value] @0 [null] | |
| bin1389: float [value] @0 [2145,2147] | |
| bin1390: float [value] @3 [2146,2147] | |
| bin1391: float [value] @0 [2147,2149] | |
| bin1392: vector [value] @3 [2148,2153] | |
| bin1392_x: @0 [2148,2153] | |
| bin1392_y: @0 [2148,2153] | |
| bin1392_z: @0 [2148,2153] | |
| bin1393: float [value] @0 [2149,2151] | |
| bin1394: float [value] @6 [2150,2151] | |
| bin1395: float [value] @0 [2151,2153] | |
| bin1396: vector [value] @6 [2152,2153] | |
| bin1396_x: @0 [2152,2153] | |
| bin1396_y: @0 [2152,2153] | |
| bin1396_z: @0 [2152,2153] | |
| bin1397: vector [value] @0 [2153,2154] | |
| bin1397_x: @0 [2153,2154] | |
| bin1397_y: @0 [2153,2154] | |
| bin1397_z: @0 [2153,2154] | |
| bin1398: vector [value] callparam @0 [2154,2157] | |
| bin1398_x: @0 [2154,2157] | |
| bin1398_y: @0 [2154,2157] | |
| bin1398_z: @0 [2154,2157] | |
| bin1399: vector [value] callparam @0 [2155,2157] | |
| bin1399_x: @0 [2155,2157] | |
| bin1399_y: @0 [2155,2157] | |
| bin1399_z: @0 [2155,2157] | |
| bin1400: float [value] callparam @0 [2156,2157] | |
| call1401: float [return] @0 [2157,2157] | |
| bin1406: float [value] @0 [null] | |
| sce_value1407: float [value] @0 [2165,2166] [2168,2171] | |
| sce_bool1408: float [value] @0 [2171,2172] | |
| call1410: vector [value] @0 [null] | |
| call1410_x: @0 | |
| call1410_y: @0 | |
| call1410_z: @0 | |
| bin1415: float [value] @0 [2181,2182] | |
| bin1418: float [value] @0 [2187,2188] | |
| bin1423: float [value] @0 [2196,2197] | |
| bin1427: float [value] @0 [2202,2203] | |
| bin1428: float [value] @0 [2203,2205] | |
| bin1429: float [value] @3 [2204,2205] | |
| bin1430: float [value] @0 [2205,2207] | |
| bin1431: vector [value] @3 [2206,2212] | |
| bin1431_x: @0 [2206,2212] | |
| bin1431_y: @0 [2206,2212] | |
| bin1431_z: @0 [2206,2212] | |
| bin1432: float [value] @0 [2207,2208] | |
| bin1433: float [value] @0 [2208,2210] | |
| bin1434: float [value] @6 [2209,2210] | |
| bin1435: float [value] @0 [2210,2212] | |
| bin1436: vector [value] @6 [2211,2212] | |
| bin1436_x: @0 [2211,2212] | |
| bin1436_y: @0 [2211,2212] | |
| bin1436_z: @0 [2211,2212] | |
| bin1437: vector [value] @0 [2212,2213] | |
| bin1437_x: @0 [2212,2213] | |
| bin1437_y: @0 [2212,2213] | |
| bin1437_z: @0 [2212,2213] | |
| bin1438: vector [value] callparam @0 [2213,2218] | |
| bin1438_x: @0 [2213,2218] | |
| bin1438_y: @0 [2213,2218] | |
| bin1438_z: @0 [2213,2218] | |
| bin1439: float [value] @0 [2214,2216] | |
| bin1440: vector [value] callparam @0 [2215,2218] | |
| bin1440_x: @0 [2215,2218] | |
| bin1440_y: @0 [2215,2218] | |
| bin1440_z: @0 [2215,2218] | |
| bin1441: float [value] @0 [2216,2217] | |
| bin1442: float [value] callparam @0 [2217,2218] | |
| call1443: float [return] @0 [2218,2218] | |
| binst1444: float [value] @0 [null] | |
| binst1445: float [value] @0 [null] | |
| bin1447: float [value] @0 [2225,2226] | |
| bin1448: float [value] @0 [2226,2228] | |
| bin1449: float [value] @3 [2227,2228] | |
| bin1450: float [value] @0 [2228,2230] | |
| bin1451: vector [value] @3 [2229,2235] | |
| bin1451_x: @0 [2229,2235] | |
| bin1451_y: @0 [2229,2235] | |
| bin1451_z: @0 [2229,2235] | |
| bin1452: float [value] @0 [2230,2231] | |
| bin1453: float [value] @0 [2231,2233] | |
| bin1454: float [value] @6 [2232,2233] | |
| bin1455: float [value] @0 [2233,2235] | |
| bin1456: vector [value] @6 [2234,2235] | |
| bin1456_x: @0 [2234,2235] | |
| bin1456_y: @0 [2234,2235] | |
| bin1456_z: @0 [2234,2235] | |
| bin1457: vector [value] @0 [2235,2236] | |
| bin1457_x: @0 [2235,2236] | |
| bin1457_y: @0 [2235,2236] | |
| bin1457_z: @0 [2235,2236] | |
| bin1458: vector [value] callparam @0 [2236,2240] | |
| bin1458_x: @0 [2236,2240] | |
| bin1458_y: @0 [2236,2240] | |
| bin1458_z: @0 [2236,2240] | |
| bin1459: float [value] @0 [2237,2239] | |
| bin1460: vector [value] callparam @0 [2238,2240] | |
| bin1460_x: @0 [2238,2240] | |
| bin1460_y: @0 [2238,2240] | |
| bin1460_z: @0 [2238,2240] | |
| bin1461: float [value] callparam @0 [2239,2240] | |
| call1462: float [return] @0 [2240,2240] | |
| call1468: void [return] @0 [null] | |
| call1471: void [return] @0 [null] | |
| call1475: void [return] @0 [null] | |
| bin1477: float [value] @0 [2283,2284] | |
| call1479: string [value] @0 [null] | |
| call1480: string [value] @0 [null] | |
| call1481: float [return] @0 [2288,2288] | |
| call1482: float [return] @0 [2289,2289] | |
| call1483: float [return] @0 [2290,2290] | |
| call1484: void [return] @0 [null] | |
| call1485: void [return] @0 [null] | |
| call1486: void [return] @0 [null] | |
| call1487: vector [value] @0 [null] | |
| call1487_x: @0 | |
| call1487_y: @0 | |
| call1487_z: @0 | |
| call1488: void [return] @0 [null] | |
| call1489: void [return] @0 [null] | |
| call1490: vector [value] @0 [null] | |
| call1490_x: @0 | |
| call1490_y: @0 | |
| call1490_z: @0 | |
| bin1491: float [value] @0 [2298,2299] | |
| call1495: void [return] @0 [null] | |
| call1496: void [return] @0 [null] | |
| call1499: void [return] @0 [null] | |
| unary1503: float [value] @0 [null] | |
| sce_value1504: float [value] @0 [2316,2317] [2319,2322] | |
| sce_bool1505: float [value] @0 [2322,2323] | |
| bin1507: float [value] @0 [2325,2326] | |
| call1509: void [return] @0 [null] | |
| bin1511: float [value] @0 [2331,2332] | |
| call1513: void [return] @0 [null] | |
| bin1515: float [value] @0 [2337,2338] | |
| call1517: void [return] @0 [null] | |
| bin1519: float [value] @0 [2343,2344] | |
| call1521: void [return] @0 [null] | |
| bin1523: float [value] @0 [2349,2350] | |
| call1525: void [return] @0 [null] | |
| call1532: float [return] @0 [2365,2365] | |
| call1533: float [return] @0 [2366,2366] | |
| bin1534: vector [value] @0 [2367,2369] | |
| bin1534_x: @0 [2367,2369] | |
| bin1534_y: @0 [2367,2369] | |
| bin1534_z: @0 [2367,2369] | |
| bin1535: vector [value] @3 [2368,2369] | |
| bin1535_x: @0 [2368,2369] | |
| bin1535_y: @0 [2368,2369] | |
| bin1535_z: @0 [2368,2369] | |
| bin1536: vector [value] callparam @0 [2369,2370] | |
| bin1536_x: @0 [2369,2370] | |
| bin1536_y: @0 [2369,2370] | |
| bin1536_z: @0 [2369,2370] | |
| call1537: float [return] @0 [2370,2370] | |
| life passes: 8 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL0 fn:execute_next_frame | |
| (2) framecount <- ADD_F framecount, 1 | |
| (3) hud <- CALL1 fn:getstati params: STAT_HUD, | |
| (4) COND autocvar__hud_showbinds_reload, [ontrue3], [endif7] | |
| :ontrue3 | |
| (5) [entry] | |
| (6) call4 <- CALL1 fn:db_close params: binddb, | |
| (7) binddb <- CALL0 fn:db_create | |
| (8) call6 <- CALL2 fn:cvar_set params: #IMMEDIATE, #IMMEDIATE, | |
| (9) JUMP [endif7] | |
| :endif7 | |
| (10) [entry] | |
| (11) call8 <- CALL1 fn:checkextension params: #IMMEDIATE, | |
| (12) COND call8, [ontrue9], [onfalse11] | |
| :ontrue9 | |
| (13) [entry] | |
| (14) view_quality <- CALL1 fn:getproperty params: VF_MINFPS_QUALITY, | |
| (15) JUMP [endif12] | |
| :onfalse11 | |
| (16) [entry] | |
| (17) view_quality <- STORE_F 1 | |
| (18) JUMP [endif12] | |
| :endif12 | |
| (19) [entry] | |
| (20) button_attack2 <- BITAND input_buttons, 4 | |
| (21) button_zoom <- BITAND input_buttons, 8 | |
| (22) checkfailv <- CALL1 fn:cvar_type params: #IMMEDIATE, | |
| (23) bin16 <- NE_F checkfailv, 0 | |
| (24) COND bin16, [ontrue17], [endif22] | |
| :ontrue17 | |
| (25) [entry] | |
| (26) COND checkfail, [endif21], [onfalse18] | |
| :onfalse18 | |
| (27) [entry] | |
| (28) call19 <- CALL5 fn:sprintf params: #IMMEDIATE, #IMMEDIATE, #IMMEDIATE, #IMMEDIATE, checkfailv, | |
| (29) call20 <- CALL1 fn:localcmd params: call19, | |
| (30) JUMP [endif21] | |
| :endif21 | |
| (31) [entry] | |
| (32) checkfail <- STORE_F 1 | |
| (33) JUMP [endif22] | |
| :endif22 | |
| (34) [entry] | |
| (35) checkfailv <- CALL1 fn:cvar_type params: #IMMEDIATE, | |
| (36) bin24 <- NE_F checkfailv, 0 | |
| (37) COND bin24, [ontrue25], [endif30] | |
| :ontrue25 | |
| (38) [entry] | |
| (39) COND checkfail[1], [endif29], [onfalse26] | |
| :onfalse26 | |
| (40) [entry] | |
| (41) call27 <- CALL5 fn:sprintf params: #IMMEDIATE, #IMMEDIATE, #IMMEDIATE, #IMMEDIATE, checkfailv, | |
| (42) call28 <- CALL1 fn:localcmd params: call27, | |
| (43) JUMP [endif29] | |
| :endif29 | |
| (44) [entry] | |
| (45) checkfail[1] <- STORE_F 1 | |
| (46) JUMP [endif30] | |
| :endif30 | |
| (47) [entry] | |
| (48) checkfailv <- CALL1 fn:cvar params: #IMMEDIATE, | |
| (49) bin32 <- NE_F checkfailv, 0 | |
| (50) COND bin32, [ontrue33], [endif38] | |
| :ontrue33 | |
| (51) [entry] | |
| (52) COND checkfail[2], [endif37], [onfalse34] | |
| :onfalse34 | |
| (53) [entry] | |
| (54) call35 <- CALL5 fn:sprintf params: #IMMEDIATE, #IMMEDIATE, #IMMEDIATE, #IMMEDIATE, checkfailv, | |
| (55) call36 <- CALL1 fn:localcmd params: call35, | |
| (56) JUMP [endif37] | |
| :endif37 | |
| (57) [entry] | |
| (58) checkfail[2] <- STORE_F 1 | |
| (59) JUMP [endif38] | |
| :endif38 | |
| (60) [entry] | |
| (61) checkfailv <- CALL1 fn:cvar params: #IMMEDIATE, | |
| (62) bin40 <- NE_F checkfailv, 0 | |
| (63) COND bin40, [ontrue41], [endif46] | |
| :ontrue41 | |
| (64) [entry] | |
| (65) COND checkfail[3], [endif45], [onfalse42] | |
| :onfalse42 | |
| (66) [entry] | |
| (67) call43 <- CALL5 fn:sprintf params: #IMMEDIATE, #IMMEDIATE, #IMMEDIATE, #IMMEDIATE, checkfailv, | |
| (68) call44 <- CALL1 fn:localcmd params: call43, | |
| (69) JUMP [endif45] | |
| :endif45 | |
| (70) [entry] | |
| (71) checkfail[3] <- STORE_F 1 | |
| (72) JUMP [endif46] | |
| :endif46 | |
| (73) [entry] | |
| (74) checkfailv <- CALL1 fn:cvar params: #IMMEDIATE, | |
| (75) bin48 <- NE_F checkfailv, 0 | |
| (76) COND bin48, [ontrue49], [endif54] | |
| :ontrue49 | |
| (77) [entry] | |
| (78) COND checkfail[4], [endif53], [onfalse50] | |
| :onfalse50 | |
| (79) [entry] | |
| (80) call51 <- CALL5 fn:sprintf params: #IMMEDIATE, #IMMEDIATE, #IMMEDIATE, #IMMEDIATE, checkfailv, | |
| (81) call52 <- CALL1 fn:localcmd params: call51, | |
| (82) JUMP [endif53] | |
| :endif53 | |
| (83) [entry] | |
| (84) checkfail[4] <- STORE_F 1 | |
| (85) JUMP [endif54] | |
| :endif54 | |
| (86) [entry] | |
| (87) checkfailv <- CALL1 fn:cvar params: #IMMEDIATE, | |
| (88) bin56 <- NE_F checkfailv, 0 | |
| (89) COND bin56, [ontrue57], [endif62] | |
| :ontrue57 | |
| (90) [entry] | |
| (91) COND checkfail[5], [endif61], [onfalse58] | |
| :onfalse58 | |
| (92) [entry] | |
| (93) call59 <- CALL5 fn:sprintf params: #IMMEDIATE, #IMMEDIATE, #IMMEDIATE, #IMMEDIATE, checkfailv, | |
| (94) call60 <- CALL1 fn:localcmd params: call59, | |
| (95) JUMP [endif61] | |
| :endif61 | |
| (96) [entry] | |
| (97) checkfail[5] <- STORE_F 1 | |
| (98) JUMP [endif62] | |
| :endif62 | |
| (99) [entry] | |
| (100) checkfailv <- CALL1 fn:cvar params: #IMMEDIATE, | |
| (101) bin64 <- NE_F checkfailv, 0 | |
| (102) COND bin64, [ontrue65], [endif70] | |
| :ontrue65 | |
| (103) [entry] | |
| (104) COND checkfail[6], [endif69], [onfalse66] | |
| :onfalse66 | |
| (105) [entry] | |
| (106) call67 <- CALL5 fn:sprintf params: #IMMEDIATE, #IMMEDIATE, #IMMEDIATE, #IMMEDIATE, checkfailv, | |
| (107) call68 <- CALL1 fn:localcmd params: call67, | |
| (108) JUMP [endif69] | |
| :endif69 | |
| (109) [entry] | |
| (110) checkfail[6] <- STORE_F 1 | |
| (111) JUMP [endif70] | |
| :endif70 | |
| (112) [entry] | |
| (113) vf_size <- CALL1 fn:getpropertyvec params: VF_SIZE, | |
| (114) vf_min <- CALL1 fn:getpropertyvec params: VF_MIN, | |
| (115) vid_width <- STORE_F vf_size_x | |
| (116) vid_height <- STORE_F vf_size_y | |
| (117) reticle_pos <- STORE_V '0 0 0' | |
| (118) reticle_size <- STORE_V '0 0 0' | |
| (119) splash_pos <- STORE_V '0 0 0' | |
| (120) splash_size <- STORE_V '0 0 0' | |
| (121) call73 <- CALL0 fn:WaypointSprite_Load | |
| (122) call74 <- CALL0 fn:CSQCPlayer_SetCamera | |
| (123) bin75 <- SUB_F player_localentnum, 1 | |
| (124) myteam <- CALL1 fn:GetPlayerColor params: bin75, | |
| (125) call77 <- CALL1 fn:getstatf params: STAT_MOVEVARS_TICRATE, | |
| (126) call78 <- CALL1 fn:getstatf params: STAT_MOVEVARS_TIMESCALE, | |
| (127) ticrate <- MUL_F call77, call78 | |
| (128) call80 <- CALL1 fn:getstati params: STAT_HEALTH, | |
| (129) is_dead <- LE call80, 0 | |
| (130) call82 <- CALL0 fn:isdemo | |
| (131) COND call82, [ontrue83], [onfalse85] | |
| :ontrue83 | |
| (132) [entry] | |
| (133) button_zoom <- EQ_S autocvar__togglezoom, "-" | |
| (134) JUMP [endif106] | |
| :onfalse85 | |
| (135) [entry] | |
| (136) sce_value90 <- STORE_F button_zoom | |
| (137) COND button_zoom, [sce_other89], [sce_merge88] | |
| :sce_other89 | |
| (138) [entry] | |
| (139) sce_value90 <- STORE_F 1 | |
| (140) JUMP [sce_merge88] | |
| :sce_merge88 | |
| (141) [entry] | |
| (142) sce_bool91 <- AND sce_value90, sce_value90 | |
| (143) sce_value94 <- STORE_F sce_bool91 | |
| (144) COND sce_bool91, [sce_other92], [sce_merge87] | |
| :sce_other92 | |
| (145) [entry] | |
| (146) sce_value94 <- GE spectatee_status, 0 | |
| (147) JUMP [sce_merge87] | |
| :sce_merge87 | |
| (148) [entry] | |
| (149) sce_bool95 <- AND sce_value94, sce_value94 | |
| (150) sce_value101 <- STORE_F sce_bool95 | |
| (151) COND sce_bool95, [sce_other96], [sce_merge86] | |
| :sce_other96 | |
| (152) [entry] | |
| (153) sce_value99 <- STORE_F is_dead | |
| (154) COND is_dead, [sce_merge97], [sce_other98] | |
| :sce_other98 | |
| (155) [entry] | |
| (156) sce_value99 <- STORE_F intermission | |
| (157) JUMP [sce_merge97] | |
| :sce_merge97 | |
| (158) [entry] | |
| (159) sce_value101 <- AND sce_value99, sce_value99 | |
| (160) JUMP [sce_merge86] | |
| :sce_merge86 | |
| (161) [entry] | |
| (162) sce_bool102 <- AND sce_value101, sce_value101 | |
| (163) COND sce_bool102, [ontrue103], [endif105] | |
| :ontrue103 | |
| (164) [entry] | |
| (165) call104 <- CALL1 fn:localcmd params: #IMMEDIATE, | |
| (166) button_zoom <- STORE_F 0 | |
| (167) JUMP [endif105] | |
| :endif105 | |
| (168) [entry] | |
| (169) JUMP [endif106] | |
| :endif106 | |
| (170) [entry] | |
| (171) bin107 <- LE autocvar_chase_active, 0 | |
| (172) COND bin107, [ontrue108], [onfalse169] | |
| :ontrue108 | |
| (173) [entry] | |
| (174) bin111 <- GE spectatee_status, 0 | |
| (175) sce_value117 <- STORE_F bin111 | |
| (176) COND bin111, [sce_other112], [sce_merge110] | |
| :sce_other112 | |
| (177) [entry] | |
| (178) sce_value115 <- STORE_F 1 | |
| (179) COND 1, [sce_other114], [sce_merge113] | |
| :sce_other114 | |
| (180) [entry] | |
| (181) sce_value115 <- STORE_F is_dead | |
| (182) JUMP [sce_merge113] | |
| :sce_merge113 | |
| (183) [entry] | |
| (184) sce_value117 <- AND sce_value115, sce_value115 | |
| (185) JUMP [sce_merge110] | |
| :sce_merge110 | |
| (186) [entry] | |
| (187) sce_bool118 <- AND sce_value117, sce_value117 | |
| (188) sce_value120 <- STORE_F sce_bool118 | |
| (189) COND sce_bool118, [sce_merge109], [sce_other119] | |
| :sce_other119 | |
| (190) [entry] | |
| (191) sce_value120 <- STORE_F intermission | |
| (192) JUMP [sce_merge109] | |
| :sce_merge109 | |
| (193) [entry] | |
| (194) sce_bool121 <- AND sce_value120, sce_value120 | |
| (195) COND sce_bool121, [ontrue122], [onfalse163] | |
| :ontrue122 | |
| (196) [entry] | |
| (197) COND csqcplayer, [tern_T123], [tern_F125] | |
| :tern_T123 | |
| (198) [entry] | |
| (199) phi127 <- FIELD_V csqcplayer, origin | |
| (200) JUMP [tern_out126] | |
| :tern_F125 | |
| (201) [entry] | |
| (202) phi127 <- STORE_V pmove_org | |
| (203) JUMP [tern_out126] | |
| :tern_out126 | |
| (204) [entry] | |
| (205) current_view_origin <- ADD_V phi127, '0 0 20' | |
| (206) COND autocvar_chase_active, [endif131], [onfalse129] | |
| :onfalse129 | |
| (207) [entry] | |
| (208) call130 <- CALL2 fn:cvar_set params: #IMMEDIATE, #IMMEDIATE, | |
| (209) JUMP [endif131] | |
| :endif131 | |
| (210) [entry] | |
| (211) sce_value135 <- STORE_F 1.3 | |
| (212) COND 1.3, [sce_other133], [sce_merge132] | |
| :sce_other133 | |
| (213) [entry] | |
| (214) sce_value135 <- LT eventchase_current_distance, 140 | |
| (215) JUMP [sce_merge132] | |
| :sce_merge132 | |
| (216) [entry] | |
| (217) sce_bool136 <- AND sce_value135, sce_value135 | |
| (218) COND sce_bool136, [ontrue137], [onfalse142] | |
| :ontrue137 | |
| (219) [entry] | |
| (220) bin138 <- SUB_F 140, eventchase_current_distance | |
| (221) bin139 <- MUL_F 1.3, bin138 | |
| (222) bin140 <- MUL_F bin139, frametime | |
| (223) eventchase_current_distance <- ADD_F eventchase_current_distance, bin140 | |
| (224) JUMP [endif146] | |
| :onfalse142 | |
| (225) [entry] | |
| (226) bin143 <- NE_F eventchase_current_distance, 140 | |
| (227) COND bin143, [ontrue144], [endif145] | |
| :ontrue144 | |
| (228) [entry] | |
| (229) eventchase_current_distance <- STORE_F 140 | |
| (230) JUMP [endif145] | |
| :endif145 | |
| (231) [entry] | |
| (232) JUMP [endif146] | |
| :endif146 | |
| (233) [entry] | |
| (234) call147 <- CALL1 fn:makevectors params: view_angles, | |
| (235) bin148 <- MUL_VF v_forward, eventchase_current_distance | |
| (236) eventchase_target_origin <- SUB_V current_view_origin, bin148 | |
| (237) call150 <- CALL6 fn:WarpZone_TraceBox params: current_view_origin, autocvar_cl_eventchase_mins, autocvar_cl_eventchase_maxs, eventchase_target_origin, MOVE_WORLDONLY, self, | |
| (238) COND trace_startsolid, [ontrue151], [onfalse158] | |
| :ontrue151 | |
| (239) [entry] | |
| (240) bin152 <- MUL_VF v_forward, eventchase_current_distance | |
| (241) eventchase_target_origin <- SUB_V current_view_origin, bin152 | |
| (242) call154 <- CALL4 fn:WarpZone_TraceLine params: current_view_origin, eventchase_target_origin, MOVE_WORLDONLY, self, | |
| (243) bin155 <- MUL_VF v_forward, autocvar_cl_eventchase_mins_z | |
| (244) bin156 <- SUB_V trace_endpos, bin155 | |
| (245) call157 <- CALL2 fn:setproperty params: VF_ORIGIN, bin156, | |
| (246) JUMP [endif160] | |
| :onfalse158 | |
| (247) [entry] | |
| (248) call159 <- CALL2 fn:setproperty params: VF_ORIGIN, trace_endpos, | |
| (249) JUMP [endif160] | |
| :endif160 | |
| (250) [entry] | |
| (251) call161 <- CALL2 fn:WarpZone_TransformVAngles params: WarpZone_trace_transform, view_angles, | |
| (252) call162 <- CALL2 fn:setproperty params: VF_ANGLES, call161, | |
| (253) JUMP [endif168] | |
| :onfalse163 | |
| (254) [entry] | |
| (255) bin164 <- LT autocvar_chase_active, 0 | |
| (256) COND bin164, [ontrue165], [endif167] | |
| :ontrue165 | |
| (257) [entry] | |
| (258) call166 <- CALL2 fn:cvar_set params: #IMMEDIATE, #IMMEDIATE, | |
| (259) eventchase_current_distance <- STORE_F 0 | |
| (260) JUMP [endif167] | |
| :endif167 | |
| (261) [entry] | |
| (262) JUMP [endif168] | |
| :endif168 | |
| (263) [entry] | |
| (264) JUMP [endif173] | |
| :onfalse169 | |
| (265) [entry] | |
| (266) COND intermission, [ontrue170], [endif172] | |
| :ontrue170 | |
| (267) [entry] | |
| (268) call171 <- CALL2 fn:cvar_settemp params: #IMMEDIATE, #IMMEDIATE, | |
| (269) eventchase_current_distance <- STORE_F 0 | |
| (270) JUMP [endif172] | |
| :endif172 | |
| (271) [entry] | |
| (272) JUMP [endif173] | |
| :endif173 | |
| (273) [entry] | |
| (274) sce_value191 <- STORE_F autocvar_cl_lockview | |
| (275) COND autocvar_cl_lockview, [sce_merge174], [sce_other175] | |
| :sce_other175 | |
| (276) [entry] | |
| (277) unary177 <- NOT_F 1 | |
| (278) sce_value189 <- STORE_F unary177 | |
| (279) COND unary177, [sce_other178], [sce_merge176] | |
| :sce_other178 | |
| (280) [entry] | |
| (281) sce_value183 <- STORE_F autocvar__hud_configure | |
| (282) COND autocvar__hud_configure, [sce_other181], [sce_merge180] | |
| :sce_other181 | |
| (283) [entry] | |
| (284) sce_value183 <- LE spectatee_status, 0 | |
| (285) JUMP [sce_merge180] | |
| :sce_merge180 | |
| (286) [entry] | |
| (287) sce_bool184 <- AND sce_value183, sce_value183 | |
| (288) sce_value187 <- STORE_F sce_bool184 | |
| (289) COND sce_bool184, [sce_merge179], [sce_other185] | |
| :sce_other185 | |
| (290) [entry] | |
| (291) sce_value187 <- GT intermission, 1 | |
| (292) JUMP [sce_merge179] | |
| :sce_merge179 | |
| (293) [entry] | |
| (294) sce_value189 <- AND sce_value187, sce_value187 | |
| (295) JUMP [sce_merge176] | |
| :sce_merge176 | |
| (296) [entry] | |
| (297) sce_value191 <- AND sce_value189, sce_value189 | |
| (298) JUMP [sce_merge174] | |
| :sce_merge174 | |
| (299) [entry] | |
| (300) sce_bool192 <- AND sce_value191, sce_value191 | |
| (301) COND sce_bool192, [ontrue193], [onfalse196] | |
| :ontrue193 | |
| (302) [entry] | |
| (303) call194 <- CALL2 fn:setproperty params: VF_ORIGIN, freeze_org, | |
| (304) call195 <- CALL2 fn:setproperty params: VF_ANGLES, freeze_ang, | |
| (305) JUMP [endif199] | |
| :onfalse196 | |
| (306) [entry] | |
| (307) freeze_org <- CALL1 fn:getpropertyvec params: VF_ORIGIN, | |
| (308) freeze_ang <- CALL1 fn:getpropertyvec params: VF_ANGLES, | |
| (309) JUMP [endif199] | |
| :endif199 | |
| (310) [entry] | |
| (311) call200 <- CALL0 fn:WarpZone_FixView | |
| (312) view_origin <- CALL1 fn:getpropertyvec params: VF_ORIGIN, | |
| (313) view_angles <- CALL1 fn:getpropertyvec params: VF_ANGLES, | |
| (314) call203 <- CALL1 fn:makevectors params: view_angles, | |
| (315) view_forward <- STORE_V v_forward | |
| (316) view_right <- STORE_V v_right | |
| (317) view_up <- STORE_V v_up | |
| (318) call204 <- CALL0 fn:TargetMusic_Advance | |
| (319) call205 <- CALL0 fn:Fog_Force | |
| (320) bin206 <- EQ_F drawtime, 0 | |
| (321) COND bin206, [ontrue207], [onfalse208] | |
| :ontrue207 | |
| (322) [entry] | |
| (323) drawframetime <- STORE_F 0.0166667 | |
| (324) JUMP [endif211] | |
| :onfalse208 | |
| (325) [entry] | |
| (326) bin209 <- SUB_F time, drawtime | |
| (327) drawframetime <- CALL3 fn:bound params: #IMMEDIATE, bin209, #IMMEDIATE, | |
| (328) JUMP [endif211] | |
| :endif211 | |
| (329) [entry] | |
| (330) drawtime <- STORE_F time | |
| (331) COND postinit, [endif214], [onfalse212] | |
| :onfalse212 | |
| (332) [entry] | |
| (333) call213 <- CALL0 fn:PostInit | |
| (334) JUMP [endif214] | |
| :endif214 | |
| (335) [entry] | |
| (336) sce_value220 <- STORE_F intermission | |
| (337) COND intermission, [sce_other217], [sce_merge216] | |
| :sce_other217 | |
| (338) [entry] | |
| (339) call218 <- CALL0 fn:isdemo | |
| (340) sce_value220 <- NOT_F call218 | |
| (341) JUMP [sce_merge216] | |
| :sce_merge216 | |
| (342) [entry] | |
| (343) sce_bool221 <- AND sce_value220, sce_value220 | |
| (344) sce_value225 <- STORE_F sce_bool221 | |
| (345) COND sce_bool221, [sce_other222], [sce_merge215] | |
| :sce_other222 | |
| (346) [entry] | |
| (347) bin223 <- BITAND calledhooks, 2 | |
| (348) sce_value225 <- NOT_F bin223 | |
| (349) JUMP [sce_merge215] | |
| :sce_merge215 | |
| (350) [entry] | |
| (351) sce_bool226 <- AND sce_value225, sce_value225 | |
| (352) COND sce_bool226, [ontrue227], [endif233] | |
| :ontrue227 | |
| (353) [entry] | |
| (354) bin228 <- BITAND calledhooks, 1 | |
| (355) COND bin228, [ontrue229], [endif232] | |
| :ontrue229 | |
| (356) [entry] | |
| (357) call230 <- CALL1 fn:localcmd params: #IMMEDIATE, | |
| (358) calledhooks <- BITOR calledhooks, 2 | |
| (359) JUMP [endif232] | |
| :endif232 | |
| (360) [entry] | |
| (361) JUMP [endif233] | |
| :endif233 | |
| (362) [entry] | |
| (363) call234 <- CALL0 fn:Announcer | |
| (364) fov <- STORE_F autocvar_fov | |
| (365) bin235 <- LE fov, 59.5 | |
| (366) COND bin235, [ontrue236], [onfalse240] | |
| :ontrue236 | |
| (367) [entry] | |
| (368) COND zoomscript_caught, [endif239], [onfalse237] | |
| :onfalse237 | |
| (369) [entry] | |
| (370) call238 <- CALL1 fn:localcmd params: #IMMEDIATE, | |
| (371) zoomscript_caught <- STORE_F 1 | |
| (372) JUMP [endif239] | |
| :endif239 | |
| (373) [entry] | |
| (374) JUMP [endif244] | |
| :onfalse240 | |
| (375) [entry] | |
| (376) COND zoomscript_caught, [ontrue241], [endif243] | |
| :ontrue241 | |
| (377) [entry] | |
| (378) call242 <- CALL1 fn:localcmd params: #IMMEDIATE, | |
| (379) zoomscript_caught <- STORE_F 0 | |
| (380) JUMP [endif243] | |
| :endif243 | |
| (381) [entry] | |
| (382) JUMP [endif244] | |
| :endif244 | |
| (383) [entry] | |
| (384) ColorTranslateMode <- STORE_F autocvar_cl_stripcolorcodes | |
| (385) switchweapon <- CALL1 fn:getstati params: STAT_SWITCHWEAPON, | |
| (386) switchingweapon <- CALL1 fn:getstati params: STAT_SWITCHINGWEAPON, | |
| (387) activeweapon <- CALL1 fn:getstati params: STAT_ACTIVEWEAPON, | |
| (388) f <- BITAND serverflags, 2 | |
| (389) bin249 <- NE_F f, teamplay | |
| (390) COND bin249, [ontrue250], [endif252] | |
| :ontrue250 | |
| (391) [entry] | |
| (392) teamplay <- STORE_F f | |
| (393) call251 <- CALL0 fn:HUD_InitScores | |
| (394) JUMP [endif252] | |
| :endif252 | |
| (395) [entry] | |
| (396) bin253 <- NE_F last_switchweapon, switchweapon | |
| (397) COND bin253, [ontrue254], [endif266] | |
| :ontrue254 | |
| (398) [entry] | |
| (399) weapontime <- STORE_F time | |
| (400) last_switchweapon <- STORE_F switchweapon | |
| (401) sce_value257 <- STORE_F button_zoom | |
| (402) COND button_zoom, [sce_other256], [sce_merge255] | |
| :sce_other256 | |
| (403) [entry] | |
| (404) sce_value257 <- STORE_F 1 | |
| (405) JUMP [sce_merge255] | |
| :sce_merge255 | |
| (406) [entry] | |
| (407) sce_bool258 <- AND sce_value257, sce_value257 | |
| (408) COND sce_bool258, [ontrue259], [endif261] | |
| :ontrue259 | |
| (409) [entry] | |
| (410) call260 <- CALL1 fn:localcmd params: #IMMEDIATE, | |
| (411) button_zoom <- STORE_F 0 | |
| (412) JUMP [endif261] | |
| :endif261 | |
| (413) [entry] | |
| (414) COND 1, [ontrue262], [endif265] | |
| :ontrue262 | |
| (415) [entry] | |
| (416) call263 <- CALL1 fn:localcmd params: #IMMEDIATE, | |
| (417) call264 <- CALL1 fn:localcmd params: #IMMEDIATE, | |
| (418) button_attack2 <- STORE_F 0 | |
| (419) JUMP [endif265] | |
| :endif265 | |
| (420) [entry] | |
| (421) JUMP [endif266] | |
| :endif266 | |
| (422) [entry] | |
| (423) bin267 <- NE_F last_activeweapon, activeweapon | |
| (424) COND bin267, [ontrue268], [endif279] | |
| :ontrue268 | |
| (425) [entry] | |
| (426) last_activeweapon <- STORE_F activeweapon | |
| (427) e <- CALL1 fn:get_weaponinfo params: activeweapon, | |
| (428) efv270 <- FIELD_S e, netname | |
| (429) bin271 <- NE_S efv270, "" | |
| (430) COND bin271, [ontrue272], [onfalse276] | |
| :ontrue272 | |
| (431) [entry] | |
| (432) efv273 <- FIELD_S e, netname | |
| (433) call274 <- CALL2 fn:strcat params: #IMMEDIATE, efv273, | |
| (434) call275 <- CALL2 fn:localcmd params: call274, #IMMEDIATE, | |
| (435) JUMP [endif278] | |
| :onfalse276 | |
| (436) [entry] | |
| (437) call277 <- CALL1 fn:localcmd params: #IMMEDIATE, | |
| (438) JUMP [endif278] | |
| :endif278 | |
| (439) [entry] | |
| (440) JUMP [endif279] | |
| :endif279 | |
| (441) [entry] | |
| (442) call280 <- CALL0 fn:clearscene | |
| (443) call281 <- CALL2 fn:setproperty params: VF_ORIGIN, view_origin, | |
| (444) call282 <- CALL2 fn:setproperty params: VF_ANGLES, view_angles, | |
| (445) call283 <- CALL2 fn:setproperty params: VF_SIZE, vf_size, | |
| (446) call284 <- CALL2 fn:setproperty params: VF_MIN, vf_min, | |
| (447) call285 <- CALL2 fn:setproperty params: VF_DRAWWORLD, #IMMEDIATE, | |
| (448) vid_conwidth <- STORE_F autocvar_vid_conwidth | |
| (449) vid_conheight <- STORE_F autocvar_vid_conheight | |
| (450) vid_pixelheight <- STORE_F autocvar_vid_pixelheight | |
| (451) call286 <- CALL1 fn:GetCurrentFov params: fov, | |
| (452) call287 <- CALL2 fn:setproperty params: VF_FOV, call286, | |
| (453) COND camera_active, [ontrue288], [onfalse296] | |
| :ontrue288 | |
| (454) [entry] | |
| (455) COND autocvar_camera_enable, [ontrue289], [onfalse291] | |
| :ontrue289 | |
| (456) [entry] | |
| (457) call290 <- CALL0 fn:CSQC_Demo_Camera | |
| (458) JUMP [endif295] | |
| :onfalse291 | |
| (459) [entry] | |
| (460) call292 <- CALL1 fn:ftos params: chase_active_backup, | |
| (461) call293 <- CALL2 fn:cvar_set params: #IMMEDIATE, call292, | |
| (462) call294 <- CALL2 fn:cvar_set params: #IMMEDIATE, #IMMEDIATE, | |
| (463) camera_active <- STORE_F 0 | |
| (464) JUMP [endif295] | |
| :endif295 | |
| (465) [entry] | |
| (466) JUMP [endif306] | |
| :onfalse296 | |
| (467) [entry] | |
| (468) sce_value300 <- STORE_F autocvar_camera_enable | |
| (469) COND autocvar_camera_enable, [sce_other298], [sce_merge297] | |
| :sce_other298 | |
| (470) [entry] | |
| (471) sce_value300 <- CALL0 fn:isdemo | |
| (472) JUMP [sce_merge297] | |
| :sce_merge297 | |
| (473) [entry] | |
| (474) sce_bool301 <- AND sce_value300, sce_value300 | |
| (475) COND sce_bool301, [ontrue302], [endif305] | |
| :ontrue302 | |
| (476) [entry] | |
| (477) chase_active_backup <- STORE_F autocvar_chase_active | |
| (478) call303 <- CALL2 fn:cvar_set params: #IMMEDIATE, #IMMEDIATE, | |
| (479) call304 <- CALL2 fn:cvar_set params: #IMMEDIATE, #IMMEDIATE, | |
| (480) camera_active <- STORE_F 1 | |
| (481) camera_mode <- STORE_F 0 | |
| (482) JUMP [endif305] | |
| :endif305 | |
| (483) [entry] | |
| (484) JUMP [endif306] | |
| :endif306 | |
| (485) [entry] | |
| (486) call307 <- CALL2 fn:setproperty params: VF_DRAWCROSSHAIR, #IMMEDIATE, | |
| (487) call308 <- CALL2 fn:setproperty params: VF_DRAWENGINESBAR, #IMMEDIATE, | |
| (488) e <- STORE_ENT self | |
| (489) self <- STORE_ENT world | |
| (490) JUMP [pre_loop_cond309] | |
| :pre_loop_cond309 | |
| (491) [entry] | |
| (492) call310 <- CALL1 fn:nextent params: self, | |
| (493) self <- STORE_ENT call310 | |
| (494) COND call310, [loop_body312], [after_loop311] | |
| :loop_body312 | |
| (495) [entry] | |
| (496) efv313 <- FIELD_FNC self, draw | |
| (497) COND efv313, [ontrue314], [endif317] | |
| :ontrue314 | |
| (498) [entry] | |
| (499) efv315 <- FIELD_FNC self, draw | |
| (500) call316 <- CALL0 efv315 | |
| (501) JUMP [endif317] | |
| :endif317 | |
| (502) [entry] | |
| (503) JUMP [pre_loop_cond309] | |
| :after_loop311 | |
| (504) [entry] | |
| (505) self <- STORE_ENT e | |
| (506) call318 <- CALL1 fn:addentities params: #IMMEDIATE, | |
| (507) call319 <- CALL0 fn:renderscene | |
| (508) call320 <- CALL6 fn:drawstring params: #IMMEDIATE, #IMMEDIATE, #IMMEDIATE, #IMMEDIATE, #IMMEDIATE, #IMMEDIATE, | |
| (509) bin322 <- GE autocvar_r_fakelight, 2 | |
| (510) sce_value324 <- STORE_F bin322 | |
| (511) COND bin322, [sce_merge321], [sce_other323] | |
| :sce_other323 | |
| (512) [entry] | |
| (513) sce_value324 <- STORE_F autocvar_r_fullbright | |
| (514) JUMP [sce_merge321] | |
| :sce_merge321 | |
| (515) [entry] | |
| (516) sce_bool325 <- AND sce_value324, sce_value324 | |
| (517) COND sce_bool325, [ontrue326], [endif421] | |
| :ontrue326 | |
| (518) [entry] | |
| (519) bin327 <- BITAND serverflags, 1 | |
| (520) COND bin327, [endif420], [onfalse328] | |
| :onfalse328 | |
| (521) [entry] | |
| (522) rgb_x <- STORE_F 0 | |
| (523) rgb_y <- STORE_F 0 | |
| (524) rgb_z <- STORE_F 0 | |
| (525) COND nightvision_noise, [endif333], [ontrue330] | |
| :ontrue330 | |
| (526) [entry] | |
| (527) nightvision_noise <- CALL0 fn:spawn | |
| (528) efa332 <- ADDRESS nightvision_noise, classname | |
| (529) efa332 <- STOREP_S "nightvision_noise" | |
| (530) JUMP [endif333] | |
| :endif333 | |
| (531) [entry] | |
| (532) COND nightvision_noise2, [endif338], [ontrue335] | |
| :ontrue335 | |
| (533) [entry] | |
| (534) nightvision_noise2 <- CALL0 fn:spawn | |
| (535) efa337 <- ADDRESS nightvision_noise2, classname | |
| (536) efa337 <- STOREP_S "nightvision_noise2" | |
| (537) JUMP [endif338] | |
| :endif338 | |
| (538) [entry] | |
| (539) bin339 <- MUL_FV autocvar_vid_conwidth, '1 0 0' | |
| (540) bin340 <- MUL_FV autocvar_vid_conheight, '0 1 0' | |
| (541) bin341 <- ADD_V bin339, bin340 | |
| (542) call342 <- CALL5 fn:drawfill params: #IMMEDIATE, bin341, #IMMEDIATE, #IMMEDIATE, DRAWFLAG_MODULATE, | |
| (543) bin343 <- MUL_F frametime, 1.5 | |
| (544) call344 <- CALL2 fn:Noise_Pink params: nightvision_noise, bin343, | |
| (545) bin345 <- MUL_F call344, 0.05 | |
| (546) a <- ADD_F bin345, 0.15 | |
| (547) rgb <- STORE_V '1 1 1' | |
| (548) bin347 <- MUL_F time, 0.3 | |
| (549) call348 <- CALL1 fn:sin params: bin347, | |
| (550) bin349 <- MUL_VF '0.2 0 0', call348 | |
| (551) bin350 <- ADD_V '0 0 0', bin349 | |
| (552) bin351 <- MUL_F time, 0.7 | |
| (553) call352 <- CALL1 fn:cos params: bin351, | |
| (554) bin353 <- MUL_VF '0 0.3 0', call352 | |
| (555) tc_00 <- ADD_V bin350, bin353 | |
| (556) bin355 <- MUL_F time, 1.2 | |
| (557) call356 <- CALL1 fn:cos params: bin355, | |
| (558) bin357 <- MUL_VF '0.6 0 0', call356 | |
| (559) bin358 <- ADD_V '0 2.25 0', bin357 | |
| (560) bin359 <- MUL_F time, 2.2 | |
| (561) call360 <- CALL1 fn:sin params: bin359, | |
| (562) bin361 <- MUL_VF '0 0.3 0', call360 | |
| (563) tc_01 <- SUB_V bin358, bin361 | |
| (564) bin363 <- MUL_F time, 0.5 | |
| (565) call364 <- CALL1 fn:sin params: bin363, | |
| (566) bin365 <- MUL_VF '0.2 0 0', call364 | |
| (567) bin366 <- SUB_V '1.5 0 0', bin365 | |
| (568) bin367 <- MUL_F time, 1.7 | |
| (569) call368 <- CALL1 fn:cos params: bin367, | |
| (570) bin369 <- MUL_VF '0 0.5 0', call368 | |
| (571) tc_10 <- ADD_V bin366, bin369 | |
| (572) bin371 <- ADD_V tc_01, tc_10 | |
| (573) tc_11 <- SUB_V bin371, tc_00 | |
| (574) call373 <- CALL2 fn:R_BeginPolygon params: #IMMEDIATE, DRAWFLAG_ADDITIVE, | |
| (575) call374 <- CALL4 fn:R_PolygonVertex params: #IMMEDIATE, tc_00, rgb, a, | |
| (576) bin375 <- MUL_FV autocvar_vid_conwidth, '1 0 0' | |
| (577) call376 <- CALL4 fn:R_PolygonVertex params: bin375, tc_10, rgb, a, | |
| (578) bin377 <- MUL_FV autocvar_vid_conwidth, '1 0 0' | |
| (579) bin378 <- MUL_FV autocvar_vid_conheight, '0 1 0' | |
| (580) bin379 <- ADD_V bin377, bin378 | |
| (581) call380 <- CALL4 fn:R_PolygonVertex params: bin379, tc_11, rgb, a, | |
| (582) bin381 <- MUL_FV autocvar_vid_conheight, '0 1 0' | |
| (583) call382 <- CALL4 fn:R_PolygonVertex params: bin381, tc_01, rgb, a, | |
| (584) call383 <- CALL0 fn:R_EndPolygon | |
| (585) bin384 <- MUL_F frametime, 0.1 | |
| (586) call385 <- CALL2 fn:Noise_Pink params: nightvision_noise2, bin384, | |
| (587) bin386 <- MUL_F call385, 0.05 | |
| (588) a <- ADD_F bin386, 0.12 | |
| (589) call388 <- CALL2 fn:Noise_White params: nightvision_noise2, frametime, | |
| (590) bin389 <- MUL_VF '0.1 0.4 0.2', call388 | |
| (591) rgb <- ADD_V '0.3 0.6 0.4', bin389 | |
| (592) call391 <- CALL2 fn:Noise_White params: nightvision_noise2, frametime, | |
| (593) bin392 <- MUL_VF '1 0 0', call391 | |
| (594) bin393 <- ADD_V '0 0 0', bin392 | |
| (595) call394 <- CALL2 fn:Noise_White params: nightvision_noise2, frametime, | |
| (596) bin395 <- MUL_VF '0 1 0', call394 | |
| (597) tc_00 <- ADD_V bin393, bin395 | |
| (598) call397 <- CALL2 fn:Noise_White params: nightvision_noise2, frametime, | |
| (599) bin398 <- MUL_F call397, 0.2 | |
| (600) bin399 <- ADD_F 1, bin398 | |
| (601) bin400 <- MUL_VF '0 3 0', bin399 | |
| (602) tc_01 <- ADD_V tc_00, bin400 | |
| (603) call402 <- CALL2 fn:Noise_White params: nightvision_noise2, frametime, | |
| (604) bin403 <- MUL_F call402, 0.3 | |
| (605) bin404 <- ADD_F 1, bin403 | |
| (606) bin405 <- MUL_VF '2 0 0', bin404 | |
| (607) tc_10 <- ADD_V tc_00, bin405 | |
| (608) bin407 <- ADD_V tc_01, tc_10 | |
| (609) tc_11 <- SUB_V bin407, tc_00 | |
| (610) call409 <- CALL2 fn:R_BeginPolygon params: #IMMEDIATE, DRAWFLAG_ADDITIVE, | |
| (611) call410 <- CALL4 fn:R_PolygonVertex params: #IMMEDIATE, tc_00, rgb, a, | |
| (612) bin411 <- MUL_FV autocvar_vid_conwidth, '1 0 0' | |
| (613) call412 <- CALL4 fn:R_PolygonVertex params: bin411, tc_10, rgb, a, | |
| (614) bin413 <- MUL_FV autocvar_vid_conwidth, '1 0 0' | |
| (615) bin414 <- MUL_FV autocvar_vid_conheight, '0 1 0' | |
| (616) bin415 <- ADD_V bin413, bin414 | |
| (617) call416 <- CALL4 fn:R_PolygonVertex params: bin415, tc_11, rgb, a, | |
| (618) bin417 <- MUL_FV autocvar_vid_conheight, '0 1 0' | |
| (619) call418 <- CALL4 fn:R_PolygonVertex params: bin417, tc_01, rgb, a, | |
| (620) call419 <- CALL0 fn:R_EndPolygon | |
| (621) JUMP [endif420] | |
| :endif420 | |
| (622) [entry] | |
| (623) JUMP [endif421] | |
| :endif421 | |
| (624) [entry] | |
| (625) sce_value425 <- STORE_F spectatee_status | |
| (626) COND spectatee_status, [sce_merge423], [sce_other424] | |
| :sce_other424 | |
| (627) [entry] | |
| (628) sce_value425 <- STORE_F is_dead | |
| (629) JUMP [sce_merge423] | |
| :sce_merge423 | |
| (630) [entry] | |
| (631) sce_bool426 <- AND sce_value425, sce_value425 | |
| (632) sce_value429 <- STORE_F sce_bool426 | |
| (633) COND sce_bool426, [sce_merge422], [sce_other427] | |
| :sce_other427 | |
| (634) [entry] | |
| (635) sce_value429 <- NE_F hud, 0 | |
| (636) JUMP [sce_merge422] | |
| :sce_merge422 | |
| (637) [entry] | |
| (638) sce_bool430 <- AND sce_value429, sce_value429 | |
| (639) COND sce_bool430, [ontrue431], [onfalse432] | |
| :ontrue431 | |
| (640) [entry] | |
| (641) reticle_type <- STORE_F 0 | |
| (642) JUMP [endif494] | |
| :onfalse432 | |
| (643) [entry] | |
| (644) bin438 <- EQ_F activeweapon, WEP_NEX | |
| (645) sce_value444 <- STORE_F bin438 | |
| (646) COND bin438, [sce_other439], [sce_merge437] | |
| :sce_other439 | |
| (647) [entry] | |
| (648) sce_value442 <- STORE_F button_zoom | |
| (649) COND button_zoom, [sce_merge440], [sce_other441] | |
| :sce_other441 | |
| (650) [entry] | |
| (651) sce_value442 <- STORE_F zoomscript_caught | |
| (652) JUMP [sce_merge440] | |
| :sce_merge440 | |
| (653) [entry] | |
| (654) sce_value444 <- AND sce_value442, sce_value442 | |
| (655) JUMP [sce_merge437] | |
| :sce_merge437 | |
| (656) [entry] | |
| (657) sce_bool445 <- AND sce_value444, sce_value444 | |
| (658) sce_value448 <- STORE_F sce_bool445 | |
| (659) COND sce_bool445, [sce_merge436], [sce_other446] | |
| :sce_other446 | |
| (660) [entry] | |
| (661) sce_value448 <- EQ_F activeweapon, WEP_RIFLE | |
| (662) JUMP [sce_merge436] | |
| :sce_merge436 | |
| (663) [entry] | |
| (664) sce_bool449 <- AND sce_value448, sce_value448 | |
| (665) sce_value455 <- STORE_F sce_bool449 | |
| (666) COND sce_bool449, [sce_other450], [sce_merge435] | |
| :sce_other450 | |
| (667) [entry] | |
| (668) sce_value453 <- STORE_F button_zoom | |
| (669) COND button_zoom, [sce_merge451], [sce_other452] | |
| :sce_other452 | |
| (670) [entry] | |
| (671) sce_value453 <- STORE_F zoomscript_caught | |
| (672) JUMP [sce_merge451] | |
| :sce_merge451 | |
| (673) [entry] | |
| (674) sce_value455 <- AND sce_value453, sce_value453 | |
| (675) JUMP [sce_merge435] | |
| :sce_merge435 | |
| (676) [entry] | |
| (677) sce_bool456 <- AND sce_value455, sce_value455 | |
| (678) sce_value459 <- STORE_F sce_bool456 | |
| (679) COND sce_bool456, [sce_merge434], [sce_other457] | |
| :sce_other457 | |
| (680) [entry] | |
| (681) sce_value459 <- EQ_F activeweapon, WEP_MINSTANEX | |
| (682) JUMP [sce_merge434] | |
| :sce_merge434 | |
| (683) [entry] | |
| (684) sce_bool460 <- AND sce_value459, sce_value459 | |
| (685) sce_value466 <- STORE_F sce_bool460 | |
| (686) COND sce_bool460, [sce_other461], [sce_merge433] | |
| :sce_other461 | |
| (687) [entry] | |
| (688) sce_value464 <- STORE_F button_zoom | |
| (689) COND button_zoom, [sce_merge462], [sce_other463] | |
| :sce_other463 | |
| (690) [entry] | |
| (691) sce_value464 <- STORE_F zoomscript_caught | |
| (692) JUMP [sce_merge462] | |
| :sce_merge462 | |
| (693) [entry] | |
| (694) sce_value466 <- AND sce_value464, sce_value464 | |
| (695) JUMP [sce_merge433] | |
| :sce_merge433 | |
| (696) [entry] | |
| (697) sce_bool467 <- AND sce_value466, sce_value466 | |
| (698) COND sce_bool467, [ontrue468], [onfalse469] | |
| :ontrue468 | |
| (699) [entry] | |
| (700) reticle_type <- STORE_F 2 | |
| (701) JUMP [endif493] | |
| :onfalse469 | |
| (702) [entry] | |
| (703) sce_value472 <- STORE_F button_zoom | |
| (704) COND button_zoom, [sce_merge470], [sce_other471] | |
| :sce_other471 | |
| (705) [entry] | |
| (706) sce_value472 <- STORE_F zoomscript_caught | |
| (707) JUMP [sce_merge470] | |
| :sce_merge470 | |
| (708) [entry] | |
| (709) sce_bool473 <- AND sce_value472, sce_value472 | |
| (710) COND sce_bool473, [ontrue474], [onfalse475] | |
| :ontrue474 | |
| (711) [entry] | |
| (712) reticle_type <- STORE_F 1 | |
| (713) JUMP [endif492] | |
| :onfalse475 | |
| (714) [entry] | |
| (715) bin479 <- EQ_F activeweapon, WEP_NEX | |
| (716) sce_value481 <- STORE_F bin479 | |
| (717) COND bin479, [sce_other480], [sce_merge478] | |
| :sce_other480 | |
| (718) [entry] | |
| (719) sce_value481 <- STORE_F button_attack2 | |
| (720) JUMP [sce_merge478] | |
| :sce_merge478 | |
| (721) [entry] | |
| (722) sce_bool482 <- AND sce_value481, sce_value481 | |
| (723) sce_value485 <- STORE_F sce_bool482 | |
| (724) COND sce_bool482, [sce_merge477], [sce_other483] | |
| :sce_other483 | |
| (725) [entry] | |
| (726) sce_value485 <- EQ_F activeweapon, WEP_RIFLE | |
| (727) JUMP [sce_merge477] | |
| :sce_merge477 | |
| (728) [entry] | |
| (729) sce_bool486 <- AND sce_value485, sce_value485 | |
| (730) sce_value488 <- STORE_F sce_bool486 | |
| (731) COND sce_bool486, [sce_other487], [sce_merge476] | |
| :sce_other487 | |
| (732) [entry] | |
| (733) sce_value488 <- STORE_F button_attack2 | |
| (734) JUMP [sce_merge476] | |
| :sce_merge476 | |
| (735) [entry] | |
| (736) sce_bool489 <- AND sce_value488, sce_value488 | |
| (737) COND sce_bool489, [ontrue490], [endif491] | |
| :ontrue490 | |
| (738) [entry] | |
| (739) reticle_type <- STORE_F 2 | |
| (740) JUMP [endif491] | |
| :endif491 | |
| (741) [entry] | |
| (742) JUMP [endif492] | |
| :endif492 | |
| (743) [entry] | |
| (744) JUMP [endif493] | |
| :endif493 | |
| (745) [entry] | |
| (746) JUMP [endif494] | |
| :endif494 | |
| (747) [entry] | |
| (748) sce_value497 <- STORE_F reticle_type | |
| (749) COND reticle_type, [sce_other496], [sce_merge495] | |
| :sce_other496 | |
| (750) [entry] | |
| (751) sce_value497 <- STORE_F 1 | |
| (752) JUMP [sce_merge495] | |
| :sce_merge495 | |
| (753) [entry] | |
| (754) sce_bool498 <- AND sce_value497, sce_value497 | |
| (755) COND sce_bool498, [ontrue499], [endif533] | |
| :ontrue499 | |
| (756) [entry] | |
| (757) COND autocvar_cl_reticle_stretch, [ontrue500], [onfalse501] | |
| :ontrue500 | |
| (758) [entry] | |
| (759) reticle_size_x <- STORE_F vid_conwidth | |
| (760) reticle_size_y <- STORE_F vid_conheight | |
| (761) reticle_pos_x <- STORE_F 0 | |
| (762) reticle_pos_y <- STORE_F 0 | |
| (763) JUMP [endif508] | |
| :onfalse501 | |
| (764) [entry] | |
| (765) reticle_size_x <- CALL2 fn:max params: vid_conwidth, vid_conheight, | |
| (766) reticle_size_y <- CALL2 fn:max params: vid_conwidth, vid_conheight, | |
| (767) bin504 <- SUB_F vid_conwidth, reticle_size_x | |
| (768) reticle_pos_x <- DIV bin504, 2 | |
| (769) bin506 <- SUB_F vid_conheight, reticle_size_y | |
| (770) reticle_pos_y <- DIV bin506, 2 | |
| (771) JUMP [endif508] | |
| :endif508 | |
| (772) [entry] | |
| (773) f <- STORE_F current_zoomfraction | |
| (774) COND zoomscript_caught, [ontrue509], [endif510] | |
| :ontrue509 | |
| (775) [entry] | |
| (776) f <- STORE_F 1 | |
| (777) JUMP [endif510] | |
| :endif510 | |
| (778) [entry] | |
| (779) COND autocvar_cl_reticle_item_normal, [ontrue511], [endif521] | |
| :ontrue511 | |
| (780) [entry] | |
| (781) bin513 <- EQ_F reticle_type, 1 | |
| (782) sce_value515 <- STORE_F bin513 | |
| (783) COND bin513, [sce_other514], [sce_merge512] | |
| :sce_other514 | |
| (784) [entry] | |
| (785) sce_value515 <- STORE_F f | |
| (786) JUMP [sce_merge512] | |
| :sce_merge512 | |
| (787) [entry] | |
| (788) sce_bool516 <- AND sce_value515, sce_value515 | |
| (789) COND sce_bool516, [ontrue517], [endif520] | |
| :ontrue517 | |
| (790) [entry] | |
| (791) bin518 <- MUL_F f, autocvar_cl_reticle_item_normal | |
| (792) call519 <- CALL6 fn:drawpic params: reticle_pos, #IMMEDIATE, reticle_size, #IMMEDIATE, bin518, DRAWFLAG_NORMAL, | |
| (793) JUMP [endif520] | |
| :endif520 | |
| (794) [entry] | |
| (795) JUMP [endif521] | |
| :endif521 | |
| (796) [entry] | |
| (797) COND autocvar_cl_reticle_item_nex, [ontrue522], [endif532] | |
| :ontrue522 | |
| (798) [entry] | |
| (799) bin524 <- EQ_F reticle_type, 2 | |
| (800) sce_value526 <- STORE_F bin524 | |
| (801) COND bin524, [sce_other525], [sce_merge523] | |
| :sce_other525 | |
| (802) [entry] | |
| (803) sce_value526 <- STORE_F f | |
| (804) JUMP [sce_merge523] | |
| :sce_merge523 | |
| (805) [entry] | |
| (806) sce_bool527 <- AND sce_value526, sce_value526 | |
| (807) COND sce_bool527, [ontrue528], [endif531] | |
| :ontrue528 | |
| (808) [entry] | |
| (809) bin529 <- MUL_F f, autocvar_cl_reticle_item_nex | |
| (810) call530 <- CALL6 fn:drawpic params: reticle_pos, #IMMEDIATE, reticle_size, #IMMEDIATE, bin529, DRAWFLAG_NORMAL, | |
| (811) JUMP [endif531] | |
| :endif531 | |
| (812) [entry] | |
| (813) JUMP [endif532] | |
| :endif532 | |
| (814) [entry] | |
| (815) JUMP [endif533] | |
| :endif533 | |
| (816) [entry] | |
| (817) COND autocvar_hud_contents, [ontrue534], [endif577] | |
| :ontrue534 | |
| (818) [entry] | |
| (819) call535 <- CALL1 fn:pointcontents params: view_origin, | |
| (820) switch_eq537 <- EQ_F call535, -3 | |
| (821) COND switch_eq537, [case538], [not_case539] | |
| :case538 | |
| (822) [entry] | |
| (823) liquidalpha <- STORE_F autocvar_hud_contents_water_alpha | |
| (824) liquidcolor <- CALL1 fn:stov params: autocvar_hud_contents_water_color, | |
| (825) incontent <- STORE_F 1 | |
| (826) JUMP [after_switch536] | |
| :not_case539 | |
| (827) [entry] | |
| (828) switch_eq541 <- EQ_F call535, -5 | |
| (829) COND switch_eq541, [case542], [not_case543] | |
| :case542 | |
| (830) [entry] | |
| (831) liquidalpha <- STORE_F autocvar_hud_contents_lava_alpha | |
| (832) liquidcolor <- CALL1 fn:stov params: autocvar_hud_contents_lava_color, | |
| (833) incontent <- STORE_F 1 | |
| (834) JUMP [after_switch536] | |
| :not_case543 | |
| (835) [entry] | |
| (836) switch_eq545 <- EQ_F call535, -4 | |
| (837) COND switch_eq545, [case546], [not_case547] | |
| :case546 | |
| (838) [entry] | |
| (839) liquidalpha <- STORE_F autocvar_hud_contents_slime_alpha | |
| (840) liquidcolor <- CALL1 fn:stov params: autocvar_hud_contents_slime_color, | |
| (841) incontent <- STORE_F 1 | |
| (842) JUMP [after_switch536] | |
| :not_case547 | |
| (843) [entry] | |
| (844) liquidalpha <- STORE_F 0 | |
| (845) liquidcolor <- STORE_V '0 0 0' | |
| (846) incontent <- STORE_F 0 | |
| (847) JUMP [after_switch536] | |
| :after_switch536 | |
| (848) [entry] | |
| (849) COND incontent, [ontrue549], [onfalse550] | |
| :ontrue549 | |
| (850) [entry] | |
| (851) contentfadetime <- STORE_F autocvar_hud_contents_fadeintime | |
| (852) liquidalpha_prev <- STORE_F liquidalpha | |
| (853) liquidcolor_prev <- STORE_V liquidcolor | |
| (854) JUMP [endif551] | |
| :onfalse550 | |
| (855) [entry] | |
| (856) contentfadetime <- STORE_F autocvar_hud_contents_fadeouttime | |
| (857) JUMP [endif551] | |
| :endif551 | |
| (858) [entry] | |
| (859) call552 <- CALL2 fn:max params: #IMMEDIATE, contentfadetime, | |
| (860) bin553 <- DIV drawframetime, call552 | |
| (861) contentalpha_temp <- CALL3 fn:bound params: #IMMEDIATE, bin553, #IMMEDIATE, | |
| (862) bin555 <- SUB_F 1, contentalpha_temp | |
| (863) bin556 <- MUL_F contentavgalpha, bin555 | |
| (864) bin557 <- MUL_F incontent, contentalpha_temp | |
| (865) contentavgalpha <- ADD_F bin556, bin557 | |
| (866) COND contentavgalpha, [ontrue559], [endif565] | |
| :ontrue559 | |
| (867) [entry] | |
| (868) bin560 <- MUL_VF '1 0 0', vid_conwidth | |
| (869) bin561 <- MUL_VF '0 1 0', vid_conheight | |
| (870) bin562 <- ADD_V bin560, bin561 | |
| (871) bin563 <- MUL_F contentavgalpha, liquidalpha_prev | |
| (872) call564 <- CALL5 fn:drawfill params: #IMMEDIATE, bin562, liquidcolor_prev, bin563, DRAWFLAG_NORMAL, | |
| (873) JUMP [endif565] | |
| :endif565 | |
| (874) [entry] | |
| (875) COND autocvar_hud_postprocessing, [ontrue566], [endif576] | |
| :ontrue566 | |
| (876) [entry] | |
| (877) sce_value569 <- STORE_F autocvar_hud_contents_blur | |
| (878) COND autocvar_hud_contents_blur, [sce_other568], [sce_merge567] | |
| :sce_other568 | |
| (879) [entry] | |
| (880) sce_value569 <- STORE_F contentavgalpha | |
| (881) JUMP [sce_merge567] | |
| :sce_merge567 | |
| (882) [entry] | |
| (883) sce_bool570 <- AND sce_value569, sce_value569 | |
| (884) COND sce_bool570, [ontrue571], [onfalse574] | |
| :ontrue571 | |
| (885) [entry] | |
| (886) content_blurpostprocess_x <- STORE_F 1 | |
| (887) content_blurpostprocess_y <- MUL_F contentavgalpha, autocvar_hud_contents_blur | |
| (888) content_blurpostprocess_z <- MUL_F contentavgalpha, autocvar_hud_contents_blur_alpha | |
| (889) JUMP [endif575] | |
| :onfalse574 | |
| (890) [entry] | |
| (891) content_blurpostprocess_x <- STORE_F 0 | |
| (892) content_blurpostprocess_y <- STORE_F 0 | |
| (893) content_blurpostprocess_z <- STORE_F 0 | |
| (894) JUMP [endif575] | |
| :endif575 | |
| (895) [entry] | |
| (896) JUMP [endif576] | |
| :endif576 | |
| (897) [entry] | |
| (898) JUMP [endif577] | |
| :endif577 | |
| (899) [entry] | |
| (900) COND autocvar_hud_damage, [ontrue578], [endif675] | |
| :ontrue578 | |
| (901) [entry] | |
| (902) splash_size_x <- CALL2 fn:max params: vid_conwidth, vid_conheight, | |
| (903) splash_size_y <- CALL2 fn:max params: vid_conwidth, vid_conheight, | |
| (904) bin581 <- SUB_F vid_conwidth, splash_size_x | |
| (905) splash_pos_x <- DIV bin581, 2 | |
| (906) bin583 <- SUB_F vid_conheight, splash_size_y | |
| (907) splash_pos_y <- DIV bin583, 2 | |
| (908) myhealth <- CALL1 fn:getstati params: STAT_HEALTH, | |
| (909) bin586 <- MUL_F autocvar_hud_damage_fade_rate, frametime | |
| (910) bin587 <- SUB_F myhealth_flash, bin586 | |
| (911) myhealth_flash <- CALL2 fn:max params: #IMMEDIATE, bin587, | |
| (912) bin589 <- MUL_F dmg_take, autocvar_hud_damage_factor | |
| (913) bin590 <- ADD_F myhealth_flash, bin589 | |
| (914) myhealth_flash <- CALL3 fn:bound params: #IMMEDIATE, bin590, autocvar_hud_damage_maxalpha, | |
| (915) pain_threshold <- STORE_F autocvar_hud_damage_pain_threshold | |
| (916) pain_threshold_lower <- STORE_F autocvar_hud_damage_pain_threshold_lower | |
| (917) pain_threshold_lower_health <- STORE_F autocvar_hud_damage_pain_threshold_lower_health | |
| (918) sce_value595 <- STORE_F pain_threshold_lower | |
| (919) COND pain_threshold_lower, [sce_other593], [sce_merge592] | |
| :sce_other593 | |
| (920) [entry] | |
| (921) sce_value595 <- LT myhealth, pain_threshold_lower_health | |
| (922) JUMP [sce_merge592] | |
| :sce_merge592 | |
| (923) [entry] | |
| (924) sce_bool596 <- AND sce_value595, sce_value595 | |
| (925) COND sce_bool596, [ontrue597], [endif609] | |
| :ontrue597 | |
| (926) [entry] | |
| (927) bin598 <- MUL_F 3.14159, time | |
| (928) bin599 <- DIV bin598, autocvar_hud_damage_pain_threshold_pulsating_period | |
| (929) call600 <- CALL1 fn:sin params: bin599, | |
| (930) call601 <- CALL1 fn:fabs params: call600, | |
| (931) call602 <- CALL2 fn:max params: autocvar_hud_damage_pain_threshold_pulsating_min, call601, | |
| (932) bin603 <- MUL_F call602, pain_threshold_lower | |
| (933) call604 <- CALL2 fn:max params: #IMMEDIATE, myhealth, | |
| (934) bin605 <- DIV call604, pain_threshold_lower_health | |
| (935) bin606 <- SUB_F 1, bin605 | |
| (936) bin607 <- MUL_F bin603, bin606 | |
| (937) pain_threshold <- SUB_F pain_threshold, bin607 | |
| (938) JUMP [endif609] | |
| :endif609 | |
| (939) [entry] | |
| (940) bin610 <- SUB_F myhealth_flash, pain_threshold | |
| (941) myhealth_flash_temp <- CALL3 fn:bound params: #IMMEDIATE, bin610, #IMMEDIATE, | |
| (942) bin612 <- LT myhealth_prev, 1 | |
| (943) COND bin612, [ontrue613], [endif620] | |
| :ontrue613 | |
| (944) [entry] | |
| (945) bin614 <- GE myhealth, 1 | |
| (946) COND bin614, [ontrue615], [onfalse616] | |
| :ontrue615 | |
| (947) [entry] | |
| (948) myhealth_flash <- STORE_F 0 | |
| (949) myhealth_flash_temp <- STORE_F 0 | |
| (950) JUMP [endif619] | |
| :onfalse616 | |
| (951) [entry] | |
| (952) bin617 <- MUL_F autocvar_hud_damage_fade_rate, frametime | |
| (953) myhealth_flash <- ADD_F myhealth_flash, bin617 | |
| (954) JUMP [endif619] | |
| :endif619 | |
| (955) [entry] | |
| (956) JUMP [endif620] | |
| :endif620 | |
| (957) [entry] | |
| (958) bin622 <- EQ_F spectatee_status, -1 | |
| (959) sce_value624 <- STORE_F bin622 | |
| (960) COND bin622, [sce_merge621], [sce_other623] | |
| :sce_other623 | |
| (961) [entry] | |
| (962) sce_value624 <- STORE_F intermission | |
| (963) JUMP [sce_merge621] | |
| :sce_merge621 | |
| (964) [entry] | |
| (965) sce_bool625 <- AND sce_value624, sce_value624 | |
| (966) COND sce_bool625, [ontrue626], [endif627] | |
| :ontrue626 | |
| (967) [entry] | |
| (968) myhealth_flash <- STORE_F 0 | |
| (969) myhealth_flash_temp <- STORE_F 0 | |
| (970) JUMP [endif627] | |
| :endif627 | |
| (971) [entry] | |
| (972) myhealth_prev <- STORE_F myhealth | |
| (973) sce_value630 <- STORE_F autocvar_cl_gentle_damage | |
| (974) COND autocvar_cl_gentle_damage, [sce_merge628], [sce_other629] | |
| :sce_other629 | |
| (975) [entry] | |
| (976) sce_value630 <- STORE_F autocvar_cl_gentle | |
| (977) JUMP [sce_merge628] | |
| :sce_merge628 | |
| (978) [entry] | |
| (979) sce_bool631 <- AND sce_value630, sce_value630 | |
| (980) COND sce_bool631, [ontrue632], [onfalse656] | |
| :ontrue632 | |
| (981) [entry] | |
| (982) bin633 <- EQ_F autocvar_cl_gentle_damage, 2 | |
| (983) COND bin633, [ontrue634], [onfalse646] | |
| :ontrue634 | |
| (984) [entry] | |
| (985) bin635 <- LT myhealth_flash, pain_threshold | |
| (986) COND bin635, [ontrue636], [endif645] | |
| :ontrue636 | |
| (987) [entry] | |
| (988) call637 <- CALL0 fn:random | |
| (989) bin638 <- MUL_VF '1 0 0', call637 | |
| (990) call639 <- CALL0 fn:random | |
| (991) bin640 <- MUL_VF '0 1 0', call639 | |
| (992) bin641 <- ADD_V bin638, bin640 | |
| (993) call642 <- CALL0 fn:random | |
| (994) bin643 <- MUL_VF '0 0 1', call642 | |
| (995) myhealth_gentlergb <- ADD_V bin641, bin643 | |
| (996) JUMP [endif645] | |
| :endif645 | |
| (997) [entry] | |
| (998) JUMP [endif648] | |
| :onfalse646 | |
| (999) [entry] | |
| (1000) myhealth_gentlergb <- CALL1 fn:stov params: autocvar_hud_damage_gentle_color, | |
| (1001) JUMP [endif648] | |
| :endif648 | |
| (1002) [entry] | |
| (1003) bin649 <- MUL_VF '1 0 0', vid_conwidth | |
| (1004) bin650 <- MUL_VF '0 1 0', vid_conheight | |
| (1005) bin651 <- ADD_V bin649, bin650 | |
| (1006) call652 <- CALL3 fn:bound params: #IMMEDIATE, myhealth_flash_temp, #IMMEDIATE, | |
| (1007) bin653 <- MUL_F autocvar_hud_damage_gentle_alpha_multiplier, call652 | |
| (1008) bin654 <- MUL_F bin653, autocvar_hud_damage | |
| (1009) call655 <- CALL5 fn:drawfill params: #IMMEDIATE, bin651, myhealth_gentlergb, bin654, DRAWFLAG_NORMAL, | |
| (1010) JUMP [endif661] | |
| :onfalse656 | |
| (1011) [entry] | |
| (1012) call657 <- CALL1 fn:stov params: autocvar_hud_damage_color, | |
| (1013) call658 <- CALL3 fn:bound params: #IMMEDIATE, myhealth_flash_temp, #IMMEDIATE, | |
| (1014) bin659 <- MUL_F call658, autocvar_hud_damage | |
| (1015) call660 <- CALL6 fn:drawpic params: splash_pos, #IMMEDIATE, splash_size, call657, bin659, DRAWFLAG_NORMAL, | |
| (1016) JUMP [endif661] | |
| :endif661 | |
| (1017) [entry] | |
| (1018) COND autocvar_hud_postprocessing, [ontrue662], [endif674] | |
| :ontrue662 | |
| (1019) [entry] | |
| (1020) sce_value665 <- STORE_F autocvar_hud_damage_blur | |
| (1021) COND autocvar_hud_damage_blur, [sce_other664], [sce_merge663] | |
| :sce_other664 | |
| (1022) [entry] | |
| (1023) sce_value665 <- STORE_F myhealth_flash_temp | |
| (1024) JUMP [sce_merge663] | |
| :sce_merge663 | |
| (1025) [entry] | |
| (1026) sce_bool666 <- AND sce_value665, sce_value665 | |
| (1027) COND sce_bool666, [ontrue667], [onfalse672] | |
| :ontrue667 | |
| (1028) [entry] | |
| (1029) damage_blurpostprocess_x <- STORE_F 1 | |
| (1030) call668 <- CALL3 fn:bound params: #IMMEDIATE, myhealth_flash_temp, #IMMEDIATE, | |
| (1031) damage_blurpostprocess_y <- MUL_F call668, autocvar_hud_damage_blur | |
| (1032) call670 <- CALL3 fn:bound params: #IMMEDIATE, myhealth_flash_temp, #IMMEDIATE, | |
| (1033) damage_blurpostprocess_z <- MUL_F call670, autocvar_hud_damage_blur_alpha | |
| (1034) JUMP [endif673] | |
| :onfalse672 | |
| (1035) [entry] | |
| (1036) damage_blurpostprocess_x <- STORE_F 0 | |
| (1037) damage_blurpostprocess_y <- STORE_F 0 | |
| (1038) damage_blurpostprocess_z <- STORE_F 0 | |
| (1039) JUMP [endif673] | |
| :endif673 | |
| (1040) [entry] | |
| (1041) JUMP [endif674] | |
| :endif674 | |
| (1042) [entry] | |
| (1043) JUMP [endif675] | |
| :endif675 | |
| (1044) [entry] | |
| (1045) e1 <- NE_F autocvar_hud_postprocessing_maxbluralpha, 0 | |
| (1046) e2 <- NE_F autocvar_hud_powerup, 0 | |
| (1047) sce_value684 <- STORE_F autocvar_hud_postprocessing | |
| (1048) COND autocvar_hud_postprocessing, [sce_other679], [sce_merge678] | |
| :sce_other679 | |
| (1049) [entry] | |
| (1050) sce_value682 <- STORE_F e1 | |
| (1051) COND e1, [sce_merge680], [sce_other681] | |
| :sce_other681 | |
| (1052) [entry] | |
| (1053) sce_value682 <- STORE_F e2 | |
| (1054) JUMP [sce_merge680] | |
| :sce_merge680 | |
| (1055) [entry] | |
| (1056) sce_value684 <- AND sce_value682, sce_value682 | |
| (1057) JUMP [sce_merge678] | |
| :sce_merge678 | |
| (1058) [entry] | |
| (1059) sce_bool685 <- AND sce_value684, sce_value684 | |
| (1060) COND sce_bool685, [ontrue686], [onfalse777] | |
| :ontrue686 | |
| (1061) [entry] | |
| (1062) call687 <- CALL1 fn:cvar params: #IMMEDIATE, | |
| (1063) bin688 <- NE_F call687, e1 | |
| (1064) COND bin688, [ontrue689], [endif692] | |
| :ontrue689 | |
| (1065) [entry] | |
| (1066) call690 <- CALL1 fn:ftos params: e1, | |
| (1067) call691 <- CALL2 fn:cvar_set params: #IMMEDIATE, call690, | |
| (1068) JUMP [endif692] | |
| :endif692 | |
| (1069) [entry] | |
| (1070) call693 <- CALL1 fn:cvar params: #IMMEDIATE, | |
| (1071) bin694 <- NE_F call693, e2 | |
| (1072) COND bin694, [ontrue695], [endif698] | |
| :ontrue695 | |
| (1073) [entry] | |
| (1074) call696 <- CALL1 fn:ftos params: e2, | |
| (1075) call697 <- CALL2 fn:cvar_set params: #IMMEDIATE, call696, | |
| (1076) JUMP [endif698] | |
| :endif698 | |
| (1077) [entry] | |
| (1078) sce_value701 <- STORE_F damage_blurpostprocess_x | |
| (1079) COND damage_blurpostprocess_x, [sce_merge699], [sce_other700] | |
| :sce_other700 | |
| (1080) [entry] | |
| (1081) sce_value701 <- STORE_F content_blurpostprocess_x | |
| (1082) JUMP [sce_merge699] | |
| :sce_merge699 | |
| (1083) [entry] | |
| (1084) sce_bool702 <- AND sce_value701, sce_value701 | |
| (1085) COND sce_bool702, [ontrue703], [onfalse720] | |
| :ontrue703 | |
| (1086) [entry] | |
| (1087) bin704 <- ADD_F damage_blurpostprocess_y, content_blurpostprocess_y | |
| (1088) blurradius <- CALL3 fn:bound params: #IMMEDIATE, bin704, autocvar_hud_postprocessing_maxblurradius, | |
| (1089) bin706 <- ADD_F damage_blurpostprocess_z, content_blurpostprocess_z | |
| (1090) bluralpha <- CALL3 fn:bound params: #IMMEDIATE, bin706, autocvar_hud_postprocessing_maxbluralpha, | |
| (1091) bin709 <- NE_F blurradius, old_blurradius | |
| (1092) sce_value712 <- STORE_F bin709 | |
| (1093) COND bin709, [sce_merge708], [sce_other710] | |
| :sce_other710 | |
| (1094) [entry] | |
| (1095) sce_value712 <- NE_F bluralpha, old_bluralpha | |
| (1096) JUMP [sce_merge708] | |
| :sce_merge708 | |
| (1097) [entry] | |
| (1098) sce_bool713 <- AND sce_value712, sce_value712 | |
| (1099) COND sce_bool713, [ontrue714], [endif719] | |
| :ontrue714 | |
| (1100) [entry] | |
| (1101) call715 <- CALL1 fn:ftos params: blurradius, | |
| (1102) call716 <- CALL1 fn:ftos params: bluralpha, | |
| (1103) call717 <- CALL4 fn:strcat params: call715, #IMMEDIATE, call716, #IMMEDIATE, | |
| (1104) call718 <- CALL2 fn:cvar_set params: #IMMEDIATE, call717, | |
| (1105) old_blurradius <- STORE_F blurradius | |
| (1106) old_bluralpha <- STORE_F bluralpha | |
| (1107) JUMP [endif719] | |
| :endif719 | |
| (1108) [entry] | |
| (1109) JUMP [endif726] | |
| :onfalse720 | |
| (1110) [entry] | |
| (1111) call721 <- CALL1 fn:cvar_string params: #IMMEDIATE, | |
| (1112) bin722 <- NE_S call721, "0 0 0 0" | |
| (1113) COND bin722, [ontrue723], [endif725] | |
| :ontrue723 | |
| (1114) [entry] | |
| (1115) call724 <- CALL2 fn:cvar_set params: #IMMEDIATE, #IMMEDIATE, | |
| (1116) old_blurradius <- STORE_F 0 | |
| (1117) old_bluralpha <- STORE_F 0 | |
| (1118) JUMP [endif725] | |
| :endif725 | |
| (1119) [entry] | |
| (1120) JUMP [endif726] | |
| :endif726 | |
| (1121) [entry] | |
| (1122) sharpen_intensity <- STORE_F 0 | |
| (1123) strength_finished <- CALL1 fn:getstatf params: STAT_STRENGTH_FINISHED, | |
| (1124) invincible_finished <- CALL1 fn:getstatf params: STAT_INVINCIBLE_FINISHED, | |
| (1125) bin729 <- SUB_F strength_finished, time | |
| (1126) bin730 <- GT bin729, 0 | |
| (1127) COND bin730, [ontrue731], [endif734] | |
| :ontrue731 | |
| (1128) [entry] | |
| (1129) bin732 <- SUB_F strength_finished, time | |
| (1130) sharpen_intensity <- ADD_F sharpen_intensity, bin732 | |
| (1131) JUMP [endif734] | |
| :endif734 | |
| (1132) [entry] | |
| (1133) bin735 <- SUB_F invincible_finished, time | |
| (1134) bin736 <- GT bin735, 0 | |
| (1135) COND bin736, [ontrue737], [endif740] | |
| :ontrue737 | |
| (1136) [entry] | |
| (1137) bin738 <- SUB_F invincible_finished, time | |
| (1138) sharpen_intensity <- ADD_F sharpen_intensity, bin738 | |
| (1139) JUMP [endif740] | |
| :endif740 | |
| (1140) [entry] | |
| (1141) call741 <- CALL1 fn:getstati params: STAT_HEALTH, | |
| (1142) bin742 <- GT call741, 0 | |
| (1143) COND bin742, [tern_T743], [tern_F744] | |
| :tern_T743 | |
| (1144) [entry] | |
| (1145) phi746 <- STORE_F sharpen_intensity | |
| (1146) JUMP [tern_out745] | |
| :tern_F744 | |
| (1147) [entry] | |
| (1148) phi746 <- STORE_F 0 | |
| (1149) JUMP [tern_out745] | |
| :tern_out745 | |
| (1150) [entry] | |
| (1151) sharpen_intensity <- CALL3 fn:bound params: #IMMEDIATE, phi746, #IMMEDIATE, | |
| (1152) sce_value751 <- STORE_F autocvar_hud_powerup | |
| (1153) COND autocvar_hud_powerup, [sce_other749], [sce_merge748] | |
| :sce_other749 | |
| (1154) [entry] | |
| (1155) sce_value751 <- GT sharpen_intensity, 0 | |
| (1156) JUMP [sce_merge748] | |
| :sce_merge748 | |
| (1157) [entry] | |
| (1158) sce_bool752 <- AND sce_value751, sce_value751 | |
| (1159) COND sce_bool752, [ontrue753], [onfalse765] | |
| :ontrue753 | |
| (1160) [entry] | |
| (1161) bin754 <- NE_F sharpen_intensity, old_sharpen_intensity | |
| (1162) COND bin754, [ontrue755], [endif764] | |
| :ontrue755 | |
| (1163) [entry] | |
| (1164) bin756 <- DIV sharpen_intensity, 5 | |
| (1165) bin757 <- MUL_F bin756, autocvar_hud_powerup | |
| (1166) call758 <- CALL1 fn:ftos params: bin757, | |
| (1167) bin759 <- SUB_F 0, sharpen_intensity | |
| (1168) bin760 <- MUL_F bin759, autocvar_hud_powerup | |
| (1169) call761 <- CALL1 fn:ftos params: bin760, | |
| (1170) call762 <- CALL4 fn:strcat params: call758, #IMMEDIATE, call761, #IMMEDIATE, | |
| (1171) call763 <- CALL2 fn:cvar_set params: #IMMEDIATE, call762, | |
| (1172) old_sharpen_intensity <- STORE_F sharpen_intensity | |
| (1173) JUMP [endif764] | |
| :endif764 | |
| (1174) [entry] | |
| (1175) JUMP [endif771] | |
| :onfalse765 | |
| (1176) [entry] | |
| (1177) call766 <- CALL1 fn:cvar_string params: #IMMEDIATE, | |
| (1178) bin767 <- NE_S call766, "0 0 0 0" | |
| (1179) COND bin767, [ontrue768], [endif770] | |
| :ontrue768 | |
| (1180) [entry] | |
| (1181) call769 <- CALL2 fn:cvar_set params: #IMMEDIATE, #IMMEDIATE, | |
| (1182) old_sharpen_intensity <- STORE_F 0 | |
| (1183) JUMP [endif770] | |
| :endif770 | |
| (1184) [entry] | |
| (1185) JUMP [endif771] | |
| :endif771 | |
| (1186) [entry] | |
| (1187) call772 <- CALL1 fn:cvar params: #IMMEDIATE, | |
| (1188) bin773 <- EQ_F call772, 0 | |
| (1189) COND bin773, [ontrue774], [endif776] | |
| :ontrue774 | |
| (1190) [entry] | |
| (1191) call775 <- CALL2 fn:cvar_set params: #IMMEDIATE, #IMMEDIATE, | |
| (1192) JUMP [endif776] | |
| :endif776 | |
| (1193) [entry] | |
| (1194) JUMP [endif783] | |
| :onfalse777 | |
| (1195) [entry] | |
| (1196) call778 <- CALL1 fn:cvar params: #IMMEDIATE, | |
| (1197) bin779 <- EQ_F call778, 2 | |
| (1198) COND bin779, [ontrue780], [endif782] | |
| :ontrue780 | |
| (1199) [entry] | |
| (1200) call781 <- CALL2 fn:cvar_set params: #IMMEDIATE, #IMMEDIATE, | |
| (1201) JUMP [endif782] | |
| :endif782 | |
| (1202) [entry] | |
| (1203) JUMP [endif783] | |
| :endif783 | |
| (1204) [entry] | |
| (1205) COND menu_visible, [ontrue784], [endif786] | |
| :ontrue784 | |
| (1206) [entry] | |
| (1207) call785 <- CALL0 menu_show | |
| (1208) JUMP [endif786] | |
| :endif786 | |
| (1209) [entry] | |
| (1210) e <- STORE_ENT self | |
| (1211) self <- STORE_ENT world | |
| (1212) JUMP [pre_loop_cond787] | |
| :pre_loop_cond787 | |
| (1213) [entry] | |
| (1214) call788 <- CALL1 fn:nextent params: self, | |
| (1215) self <- STORE_ENT call788 | |
| (1216) COND call788, [loop_body790], [after_loop789] | |
| :loop_body790 | |
| (1217) [entry] | |
| (1218) efv791 <- FIELD_FNC self, draw2d | |
| (1219) COND efv791, [ontrue792], [endif795] | |
| :ontrue792 | |
| (1220) [entry] | |
| (1221) efv793 <- FIELD_FNC self, draw2d | |
| (1222) call794 <- CALL0 efv793 | |
| (1223) JUMP [endif795] | |
| :endif795 | |
| (1224) [entry] | |
| (1225) JUMP [pre_loop_cond787] | |
| :after_loop789 | |
| (1226) [entry] | |
| (1227) self <- STORE_ENT e | |
| (1228) call796 <- CALL0 fn:Draw_ShowNames_All | |
| (1229) scoreboard_active <- CALL0 fn:HUD_WouldDrawScoreboard | |
| (1230) hit_time <- CALL1 fn:getstatf params: STAT_HIT_TIME, | |
| (1231) bin800 <- GT hit_time, nextsound_hit_time | |
| (1232) sce_value802 <- STORE_F bin800 | |
| (1233) COND bin800, [sce_other801], [sce_merge799] | |
| :sce_other801 | |
| (1234) [entry] | |
| (1235) sce_value802 <- STORE_F autocvar_cl_hitsound | |
| (1236) JUMP [sce_merge799] | |
| :sce_merge799 | |
| (1237) [entry] | |
| (1238) sce_bool803 <- AND sce_value802, sce_value802 | |
| (1239) COND sce_bool803, [ontrue804], [endif811] | |
| :ontrue804 | |
| (1240) [entry] | |
| (1241) bin805 <- SUB_F time, hit_time | |
| (1242) bin806 <- LT bin805, 5 | |
| (1243) COND bin806, [ontrue807], [endif809] | |
| :ontrue807 | |
| (1244) [entry] | |
| (1245) call808 <- CALL7 fn:sound7 params: world, CH_INFO, #IMMEDIATE, #IMMEDIATE, ATTN_NONE, #IMMEDIATE, #IMMEDIATE, | |
| (1246) JUMP [endif809] | |
| :endif809 | |
| (1247) [entry] | |
| (1248) nextsound_hit_time <- ADD_F time, autocvar_cl_hitsound_antispam_time | |
| (1249) JUMP [endif811] | |
| :endif811 | |
| (1250) [entry] | |
| (1251) typehit_time <- CALL1 fn:getstatf params: STAT_TYPEHIT_TIME, | |
| (1252) bin813 <- GT typehit_time, nextsound_typehit_time | |
| (1253) COND bin813, [ontrue814], [endif821] | |
| :ontrue814 | |
| (1254) [entry] | |
| (1255) bin815 <- SUB_F time, typehit_time | |
| (1256) bin816 <- LT bin815, 5 | |
| (1257) COND bin816, [ontrue817], [endif819] | |
| :ontrue817 | |
| (1258) [entry] | |
| (1259) call818 <- CALL7 fn:sound7 params: world, CH_INFO, #IMMEDIATE, #IMMEDIATE, ATTN_NONE, #IMMEDIATE, #IMMEDIATE, | |
| (1260) JUMP [endif819] | |
| :endif819 | |
| (1261) [entry] | |
| (1262) nextsound_typehit_time <- ADD_F time, autocvar_cl_hitsound_antispam_time | |
| (1263) JUMP [endif821] | |
| :endif821 | |
| (1264) [entry] | |
| (1265) bin822 <- EQ_F gametype, MAPINFO_TYPE_FREEZETAG | |
| (1266) COND bin822, [ontrue823], [endif845] | |
| :ontrue823 | |
| (1267) [entry] | |
| (1268) call824 <- CALL1 fn:getstati params: STAT_FROZEN, | |
| (1269) COND call824, [ontrue825], [endif830] | |
| :ontrue825 | |
| (1270) [entry] | |
| (1271) bin826 <- MUL_VF '1 0 0', vid_conwidth | |
| (1272) bin827 <- MUL_VF '0 1 0', vid_conheight | |
| (1273) bin828 <- ADD_V bin826, bin827 | |
| (1274) call829 <- CALL5 fn:drawfill params: #IMMEDIATE, bin828, #IMMEDIATE, autocvar_hud_colorflash_alpha, DRAWFLAG_ADDITIVE, | |
| (1275) JUMP [endif830] | |
| :endif830 | |
| (1276) [entry] | |
| (1277) call831 <- CALL1 fn:getstatf params: STAT_REVIVE_PROGRESS, | |
| (1278) COND call831, [ontrue832], [endif844] | |
| :ontrue832 | |
| (1279) [entry] | |
| (1280) bin833 <- MUL_VF '0.5 0 0', vid_conwidth | |
| (1281) bin834 <- MUL_VF '0 0.6 0', vid_conheight | |
| (1282) bin835 <- ADD_V bin833, bin834 | |
| (1283) bin836 <- MUL_F 0.1, vid_conheight | |
| (1284) call837 <- CALL1 fn:getstatf params: STAT_REVIVE_PROGRESS, | |
| (1285) call838 <- CALL7 fn:DrawCircleClippedPic params: bin835, bin836, #IMMEDIATE, call837, #IMMEDIATE, autocvar_hud_colorflash_alpha, DRAWFLAG_ADDITIVE, | |
| (1286) bin839 <- MUL_VF '0 0.64 0', vid_conheight | |
| (1287) bin840 <- MUL_VF '1 0 0', vid_conwidth | |
| (1288) bin841 <- MUL_VF '0 0.025 0', vid_conheight | |
| (1289) bin842 <- ADD_V bin840, bin841 | |
| (1290) call843 <- CALL6 fn:drawstring_aspect params: bin839, #IMMEDIATE, bin842, #IMMEDIATE, #IMMEDIATE, DRAWFLAG_NORMAL, | |
| (1291) JUMP [endif844] | |
| :endif844 | |
| (1292) [entry] | |
| (1293) JUMP [endif845] | |
| :endif845 | |
| (1294) [entry] | |
| (1295) bin846 <- EQ_F autocvar_r_letterbox, 0 | |
| (1296) COND bin846, [ontrue847], [endif852] | |
| :ontrue847 | |
| (1297) [entry] | |
| (1298) bin848 <- LT autocvar_viewsize, 120 | |
| (1299) COND bin848, [ontrue849], [endif851] | |
| :ontrue849 | |
| (1300) [entry] | |
| (1301) call850 <- CALL0 fn:CSQC_common_hud | |
| (1302) JUMP [endif851] | |
| :endif851 | |
| (1303) [entry] | |
| (1304) JUMP [endif852] | |
| :endif852 | |
| (1305) [entry] | |
| (1306) unary857 <- NOT_F scoreboard_active | |
| (1307) sce_value860 <- STORE_F unary857 | |
| (1308) COND unary857, [sce_other858], [sce_merge856] | |
| :sce_other858 | |
| (1309) [entry] | |
| (1310) sce_value860 <- NOT_F camera_active | |
| (1311) JUMP [sce_merge856] | |
| :sce_merge856 | |
| (1312) [entry] | |
| (1313) sce_bool861 <- AND sce_value860, sce_value860 | |
| (1314) sce_value864 <- STORE_F sce_bool861 | |
| (1315) COND sce_bool861, [sce_other862], [sce_merge855] | |
| :sce_other862 | |
| (1316) [entry] | |
| (1317) sce_value864 <- NE_F intermission, 2 | |
| (1318) JUMP [sce_merge855] | |
| :sce_merge855 | |
| (1319) [entry] | |
| (1320) sce_bool865 <- AND sce_value864, sce_value864 | |
| (1321) sce_value868 <- STORE_F sce_bool865 | |
| (1322) COND sce_bool865, [sce_other866], [sce_merge854] | |
| :sce_other866 | |
| (1323) [entry] | |
| (1324) sce_value868 <- NE_F spectatee_status, -1 | |
| (1325) JUMP [sce_merge854] | |
| :sce_merge854 | |
| (1326) [entry] | |
| (1327) sce_bool869 <- AND sce_value868, sce_value868 | |
| (1328) sce_value872 <- STORE_F sce_bool869 | |
| (1329) COND sce_bool869, [sce_other870], [sce_merge853] | |
| :sce_other870 | |
| (1330) [entry] | |
| (1331) sce_value872 <- EQ_F hud, 0 | |
| (1332) JUMP [sce_merge853] | |
| :sce_merge853 | |
| (1333) [entry] | |
| (1334) sce_bool873 <- AND sce_value872, sce_value872 | |
| (1335) COND sce_bool873, [ontrue874], [onfalse1466] | |
| :ontrue874 | |
| (1336) [entry] | |
| (1337) COND 1, [endif876], [onfalse875] | |
| :onfalse875 | |
| (1338) [entry] | |
| (1339) RETURN | |
| :endif876 | |
| (1340) [entry] | |
| (1341) wcross_style <- STORE_S autocvar_crosshair | |
| (1342) bin877 <- EQ_S wcross_style, "0" | |
| (1343) COND bin877, [ontrue878], [endif879] | |
| :ontrue878 | |
| (1344) [entry] | |
| (1345) RETURN | |
| :endif879 | |
| (1346) [entry] | |
| (1347) wcross_resolution <- STORE_F autocvar_crosshair_size | |
| (1348) bin880 <- EQ_F wcross_resolution, 0 | |
| (1349) COND bin880, [ontrue881], [endif882] | |
| :ontrue881 | |
| (1350) [entry] | |
| (1351) RETURN | |
| :endif882 | |
| (1352) [entry] | |
| (1353) wcross_alpha <- STORE_F autocvar_crosshair_alpha | |
| (1354) bin883 <- EQ_F wcross_alpha, 0 | |
| (1355) COND bin883, [ontrue884], [endif885] | |
| :ontrue884 | |
| (1356) [entry] | |
| (1357) RETURN | |
| :endif885 | |
| (1358) [entry] | |
| (1359) bin886 <- MUL_FV 32768, view_forward | |
| (1360) bin887 <- ADD_V view_origin, bin886 | |
| (1361) wcross_origin <- CALL1 fn:project_3d_to_2d params: bin887, | |
| (1362) wcross_origin_z <- STORE_F 0 | |
| (1363) COND autocvar_crosshair_hittest, [ontrue889], [onfalse903] | |
| :ontrue889 | |
| (1364) [entry] | |
| (1365) wcross_oldorigin <- STORE_V wcross_origin | |
| (1366) shottype <- CALL0 fn:TrueAimCheck | |
| (1367) bin891 <- EQ_F shottype, 3 | |
| (1368) COND bin891, [ontrue892], [endif900] | |
| :ontrue892 | |
| (1369) [entry] | |
| (1370) v <- SUB_V wcross_origin, wcross_oldorigin | |
| (1371) v_x <- DIV v_x, vid_conwidth | |
| (1372) v_y <- DIV v_y, vid_conheight | |
| (1373) call896 <- CALL1 fn:vlen params: v, | |
| (1374) bin897 <- GT call896, 0.01 | |
| (1375) COND bin897, [ontrue898], [endif899] | |
| :ontrue898 | |
| (1376) [entry] | |
| (1377) shottype <- STORE_F 2 | |
| (1378) JUMP [endif899] | |
| :endif899 | |
| (1379) [entry] | |
| (1380) JUMP [endif900] | |
| :endif900 | |
| (1381) [entry] | |
| (1382) COND autocvar_crosshair_hittest_showimpact, [endif902], [onfalse901] | |
| :onfalse901 | |
| (1383) [entry] | |
| (1384) wcross_origin <- STORE_V wcross_oldorigin | |
| (1385) JUMP [endif902] | |
| :endif902 | |
| (1386) [entry] | |
| (1387) JUMP [endif904] | |
| :onfalse903 | |
| (1388) [entry] | |
| (1389) shottype <- STORE_F 3 | |
| (1390) JUMP [endif904] | |
| :endif904 | |
| (1391) [entry] | |
| (1392) wcross_color <- STORE_V '0 0 0' | |
| (1393) wcross_size <- STORE_V '0 0 0' | |
| (1394) wcross_wep <- STORE_S "" | |
| (1395) sce_value907 <- STORE_F autocvar_crosshair_per_weapon | |
| (1396) COND autocvar_crosshair_per_weapon, [sce_merge905], [sce_other906] | |
| :sce_other906 | |
| (1397) [entry] | |
| (1398) sce_value907 <- STORE_F autocvar_crosshair_color_per_weapon | |
| (1399) JUMP [sce_merge905] | |
| :sce_merge905 | |
| (1400) [entry] | |
| (1401) sce_bool908 <- AND sce_value907, sce_value907 | |
| (1402) COND sce_bool908, [ontrue909], [endif944] | |
| :ontrue909 | |
| (1403) [entry] | |
| (1404) e <- CALL1 fn:get_weaponinfo params: switchingweapon, | |
| (1405) sce_value915 <- STORE_F e | |
| (1406) COND e, [sce_other912], [sce_merge911] | |
| :sce_other912 | |
| (1407) [entry] | |
| (1408) efv913 <- FIELD_S e, netname | |
| (1409) sce_value915 <- NE_S efv913, "" | |
| (1410) JUMP [sce_merge911] | |
| :sce_merge911 | |
| (1411) [entry] | |
| (1412) sce_bool916 <- AND sce_value915, sce_value915 | |
| (1413) COND sce_bool916, [ontrue917], [endif943] | |
| :ontrue917 | |
| (1414) [entry] | |
| (1415) wcross_wep <- FIELD_S e, netname | |
| (1416) COND autocvar_crosshair_per_weapon, [ontrue919], [endif942] | |
| :ontrue919 | |
| (1417) [entry] | |
| (1418) call920 <- CALL3 fn:strcat params: #IMMEDIATE, wcross_wep, #IMMEDIATE, | |
| (1419) call921 <- CALL1 fn:cvar params: call920, | |
| (1420) wcross_resolution <- MUL_F wcross_resolution, call921 | |
| (1421) bin923 <- EQ_F wcross_resolution, 0 | |
| (1422) COND bin923, [ontrue924], [endif925] | |
| :ontrue924 | |
| (1423) [entry] | |
| (1424) RETURN | |
| :endif925 | |
| (1425) [entry] | |
| (1426) call926 <- CALL3 fn:strcat params: #IMMEDIATE, wcross_wep, #IMMEDIATE, | |
| (1427) call927 <- CALL1 fn:cvar params: call926, | |
| (1428) wcross_alpha <- MUL_F wcross_alpha, call927 | |
| (1429) bin929 <- EQ_F wcross_alpha, 0 | |
| (1430) COND bin929, [ontrue930], [endif931] | |
| :ontrue930 | |
| (1431) [entry] | |
| (1432) RETURN | |
| :endif931 | |
| (1433) [entry] | |
| (1434) call932 <- CALL2 fn:strcat params: #IMMEDIATE, wcross_wep, | |
| (1435) wcross_style <- CALL1 fn:cvar_string params: call932, | |
| (1436) bin935 <- EQ_S wcross_style, "" | |
| (1437) sce_value938 <- STORE_F bin935 | |
| (1438) COND bin935, [sce_merge934], [sce_other936] | |
| :sce_other936 | |
| (1439) [entry] | |
| (1440) sce_value938 <- EQ_S wcross_style, "0" | |
| (1441) JUMP [sce_merge934] | |
| :sce_merge934 | |
| (1442) [entry] | |
| (1443) sce_bool939 <- AND sce_value938, sce_value938 | |
| (1444) COND sce_bool939, [ontrue940], [endif941] | |
| :ontrue940 | |
| (1445) [entry] | |
| (1446) wcross_style <- STORE_S wcross_wep | |
| (1447) JUMP [endif941] | |
| :endif941 | |
| (1448) [entry] | |
| (1449) JUMP [endif942] | |
| :endif942 | |
| (1450) [entry] | |
| (1451) JUMP [endif943] | |
| :endif943 | |
| (1452) [entry] | |
| (1453) JUMP [endif944] | |
| :endif944 | |
| (1454) [entry] | |
| (1455) bin946 <- NE_S wcross_wep, "" | |
| (1456) sce_value948 <- STORE_F bin946 | |
| (1457) COND bin946, [sce_other947], [sce_merge945] | |
| :sce_other947 | |
| (1458) [entry] | |
| (1459) sce_value948 <- STORE_F autocvar_crosshair_color_per_weapon | |
| (1460) JUMP [sce_merge945] | |
| :sce_merge945 | |
| (1461) [entry] | |
| (1462) sce_bool949 <- AND sce_value948, sce_value948 | |
| (1463) COND sce_bool949, [ontrue950], [onfalse954] | |
| :ontrue950 | |
| (1464) [entry] | |
| (1465) call951 <- CALL3 fn:strcat params: #IMMEDIATE, wcross_wep, #IMMEDIATE, | |
| (1466) call952 <- CALL1 fn:cvar_string params: call951, | |
| (1467) wcross_color <- CALL1 fn:stov params: call952, | |
| (1468) JUMP [endif1012] | |
| :onfalse954 | |
| (1469) [entry] | |
| (1470) COND autocvar_crosshair_color_by_health, [ontrue955], [onfalse1009] | |
| :ontrue955 | |
| (1471) [entry] | |
| (1472) x <- CALL1 fn:getstati params: STAT_HEALTH, | |
| (1473) wcross_color_z <- STORE_F 0 | |
| (1474) bin957 <- GT x, 200 | |
| (1475) COND bin957, [ontrue958], [onfalse959] | |
| :ontrue958 | |
| (1476) [entry] | |
| (1477) wcross_color_x <- STORE_F 0 | |
| (1478) wcross_color_y <- STORE_F 1 | |
| (1479) JUMP [endif1008] | |
| :onfalse959 | |
| (1480) [entry] | |
| (1481) bin960 <- GT x, 150 | |
| (1482) COND bin960, [ontrue961], [onfalse970] | |
| :ontrue961 | |
| (1483) [entry] | |
| (1484) bin962 <- SUB_F x, 150 | |
| (1485) bin963 <- MUL_F bin962, 0.02 | |
| (1486) bin964 <- MUL_F bin963, 0.4 | |
| (1487) wcross_color_x <- SUB_F 0.4, bin964 | |
| (1488) bin966 <- SUB_F x, 150 | |
| (1489) bin967 <- MUL_F bin966, 0.02 | |
| (1490) bin968 <- MUL_F bin967, 0.1 | |
| (1491) wcross_color_y <- ADD_F 0.9, bin968 | |
| (1492) JUMP [endif1007] | |
| :onfalse970 | |
| (1493) [entry] | |
| (1494) bin971 <- GT x, 100 | |
| (1495) COND bin971, [ontrue972], [onfalse984] | |
| :ontrue972 | |
| (1496) [entry] | |
| (1497) bin973 <- SUB_F x, 100 | |
| (1498) bin974 <- MUL_F bin973, 0.02 | |
| (1499) bin975 <- MUL_F bin974, 0.6 | |
| (1500) wcross_color_x <- SUB_F 1, bin975 | |
| (1501) bin977 <- SUB_F x, 100 | |
| (1502) bin978 <- MUL_F bin977, 0.02 | |
| (1503) bin979 <- MUL_F bin978, 0.1 | |
| (1504) wcross_color_y <- SUB_F 1, bin979 | |
| (1505) bin981 <- SUB_F x, 100 | |
| (1506) bin982 <- MUL_F bin981, 0.02 | |
| (1507) wcross_color_z <- SUB_F 1, bin982 | |
| (1508) JUMP [endif1006] | |
| :onfalse984 | |
| (1509) [entry] | |
| (1510) bin985 <- GT x, 50 | |
| (1511) COND bin985, [ontrue986], [onfalse991] | |
| :ontrue986 | |
| (1512) [entry] | |
| (1513) wcross_color_x <- STORE_F 1 | |
| (1514) wcross_color_y <- STORE_F 1 | |
| (1515) bin987 <- SUB_F x, 50 | |
| (1516) bin988 <- MUL_F bin987, 0.02 | |
| (1517) bin989 <- MUL_F bin988, 0.8 | |
| (1518) wcross_color_z <- ADD_F 0.2, bin989 | |
| (1519) JUMP [endif1005] | |
| :onfalse991 | |
| (1520) [entry] | |
| (1521) bin992 <- GT x, 20 | |
| (1522) COND bin992, [ontrue993], [onfalse1003] | |
| :ontrue993 | |
| (1523) [entry] | |
| (1524) wcross_color_x <- STORE_F 1 | |
| (1525) bin994 <- SUB_F x, 20 | |
| (1526) bin995 <- MUL_F bin994, 90 | |
| (1527) bin996 <- DIV bin995, 27 | |
| (1528) wcross_color_y <- DIV bin996, 100 | |
| (1529) bin998 <- SUB_F x, 20 | |
| (1530) bin999 <- MUL_F bin998, 90 | |
| (1531) bin1000 <- DIV bin999, 27 | |
| (1532) bin1001 <- DIV bin1000, 100 | |
| (1533) wcross_color_z <- MUL_F bin1001, 0.2 | |
| (1534) JUMP [endif1004] | |
| :onfalse1003 | |
| (1535) [entry] | |
| (1536) wcross_color_x <- STORE_F 1 | |
| (1537) wcross_color_y <- STORE_F 0 | |
| (1538) JUMP [endif1004] | |
| :endif1004 | |
| (1539) [entry] | |
| (1540) JUMP [endif1005] | |
| :endif1005 | |
| (1541) [entry] | |
| (1542) JUMP [endif1006] | |
| :endif1006 | |
| (1543) [entry] | |
| (1544) JUMP [endif1007] | |
| :endif1007 | |
| (1545) [entry] | |
| (1546) JUMP [endif1008] | |
| :endif1008 | |
| (1547) [entry] | |
| (1548) JUMP [endif1011] | |
| :onfalse1009 | |
| (1549) [entry] | |
| (1550) wcross_color <- CALL1 fn:stov params: autocvar_crosshair_color, | |
| (1551) JUMP [endif1011] | |
| :endif1011 | |
| (1552) [entry] | |
| (1553) JUMP [endif1012] | |
| :endif1012 | |
| (1554) [entry] | |
| (1555) wcross_name <- CALL2 fn:strcat params: #IMMEDIATE, wcross_style, | |
| (1556) COND autocvar_crosshair_effect_scalefade, [ontrue1014], [onfalse1015] | |
| :ontrue1014 | |
| (1557) [entry] | |
| (1558) wcross_scale <- STORE_F wcross_resolution | |
| (1559) wcross_resolution <- STORE_F 1 | |
| (1560) JUMP [endif1016] | |
| :onfalse1015 | |
| (1561) [entry] | |
| (1562) wcross_scale <- STORE_F 1 | |
| (1563) JUMP [endif1016] | |
| :endif1016 | |
| (1564) [entry] | |
| (1565) COND autocvar_crosshair_pickup, [ontrue1017], [endif1035] | |
| :ontrue1017 | |
| (1566) [entry] | |
| (1567) stat_pickup_time <- CALL1 fn:getstatf params: STAT_LAST_PICKUP, | |
| (1568) bin1019 <- LT pickup_crosshair_time, stat_pickup_time | |
| (1569) COND bin1019, [ontrue1020], [endif1025] | |
| :ontrue1020 | |
| (1570) [entry] | |
| (1571) bin1021 <- SUB_F time, stat_pickup_time | |
| (1572) bin1022 <- LT bin1021, 5 | |
| (1573) COND bin1022, [ontrue1023], [endif1024] | |
| :ontrue1023 | |
| (1574) [entry] | |
| (1575) pickup_crosshair_size <- STORE_F 1 | |
| (1576) JUMP [endif1024] | |
| :endif1024 | |
| (1577) [entry] | |
| (1578) pickup_crosshair_time <- STORE_F stat_pickup_time | |
| (1579) JUMP [endif1025] | |
| :endif1025 | |
| (1580) [entry] | |
| (1581) bin1026 <- GT pickup_crosshair_size, 0 | |
| (1582) COND bin1026, [ontrue1027], [onfalse1030] | |
| :ontrue1027 | |
| (1583) [entry] | |
| (1584) bin1028 <- MUL_F autocvar_crosshair_pickup_speed, frametime | |
| (1585) pickup_crosshair_size <- SUB_F pickup_crosshair_size, bin1028 | |
| (1586) JUMP [endif1031] | |
| :onfalse1030 | |
| (1587) [entry] | |
| (1588) pickup_crosshair_size <- STORE_F 0 | |
| (1589) JUMP [endif1031] | |
| :endif1031 | |
| (1590) [entry] | |
| (1591) call1032 <- CALL1 fn:sin params: pickup_crosshair_size, | |
| (1592) bin1033 <- MUL_F call1032, autocvar_crosshair_pickup | |
| (1593) wcross_scale <- ADD_F wcross_scale, bin1033 | |
| (1594) JUMP [endif1035] | |
| :endif1035 | |
| (1595) [entry] | |
| (1596) COND autocvar_crosshair_hitindication, [ontrue1036], [endif1068] | |
| :ontrue1036 | |
| (1597) [entry] | |
| (1598) COND autocvar_crosshair_color_per_weapon, [tern_T1037], [tern_F1039] | |
| :tern_T1037 | |
| (1599) [entry] | |
| (1600) phi1042 <- CALL1 fn:stov params: autocvar_crosshair_hitindication_per_weapon_color, | |
| (1601) JUMP [tern_out1041] | |
| :tern_F1039 | |
| (1602) [entry] | |
| (1603) phi1042 <- CALL1 fn:stov params: autocvar_crosshair_hitindication_color, | |
| (1604) JUMP [tern_out1041] | |
| :tern_out1041 | |
| (1605) [entry] | |
| (1606) hitindication_color <- STORE_V phi1042 | |
| (1607) bin1043 <- LT hitindication_crosshair_time, hit_time | |
| (1608) COND bin1043, [ontrue1044], [endif1049] | |
| :ontrue1044 | |
| (1609) [entry] | |
| (1610) bin1045 <- SUB_F time, hit_time | |
| (1611) bin1046 <- LT bin1045, 5 | |
| (1612) COND bin1046, [ontrue1047], [endif1048] | |
| :ontrue1047 | |
| (1613) [entry] | |
| (1614) hitindication_crosshair_size <- STORE_F 1 | |
| (1615) JUMP [endif1048] | |
| :endif1048 | |
| (1616) [entry] | |
| (1617) hitindication_crosshair_time <- STORE_F hit_time | |
| (1618) JUMP [endif1049] | |
| :endif1049 | |
| (1619) [entry] | |
| (1620) bin1050 <- GT hitindication_crosshair_size, 0 | |
| (1621) COND bin1050, [ontrue1051], [onfalse1054] | |
| :ontrue1051 | |
| (1622) [entry] | |
| (1623) bin1052 <- MUL_F autocvar_crosshair_hitindication_speed, frametime | |
| (1624) hitindication_crosshair_size <- SUB_F hitindication_crosshair_size, bin1052 | |
| (1625) JUMP [endif1055] | |
| :onfalse1054 | |
| (1626) [entry] | |
| (1627) hitindication_crosshair_size <- STORE_F 0 | |
| (1628) JUMP [endif1055] | |
| :endif1055 | |
| (1629) [entry] | |
| (1630) call1056 <- CALL1 fn:sin params: hitindication_crosshair_size, | |
| (1631) bin1057 <- MUL_F call1056, autocvar_crosshair_hitindication | |
| (1632) wcross_scale <- ADD_F wcross_scale, bin1057 | |
| (1633) call1059 <- CALL1 fn:sin params: hitindication_crosshair_size, | |
| (1634) bin1060 <- MUL_F call1059, hitindication_color_x | |
| (1635) wcross_color_x <- ADD_F wcross_color_x, bin1060 | |
| (1636) call1062 <- CALL1 fn:sin params: hitindication_crosshair_size, | |
| (1637) bin1063 <- MUL_F call1062, hitindication_color_y | |
| (1638) wcross_color_y <- ADD_F wcross_color_y, bin1063 | |
| (1639) call1065 <- CALL1 fn:sin params: hitindication_crosshair_size, | |
| (1640) bin1066 <- MUL_F call1065, hitindication_color_z | |
| (1641) wcross_color_z <- ADD_F wcross_color_z, bin1066 | |
| (1642) JUMP [endif1068] | |
| :endif1068 | |
| (1643) [entry] | |
| (1644) bin1069 <- EQ_F shottype, 4 | |
| (1645) COND bin1069, [ontrue1070], [endif1072] | |
| :ontrue1070 | |
| (1646) [entry] | |
| (1647) wcross_scale <- MUL_F wcross_scale, autocvar_crosshair_hittest | |
| (1648) JUMP [endif1072] | |
| :endif1072 | |
| (1649) [entry] | |
| (1650) bin1073 <- EQ_F shottype, 1 | |
| (1651) COND bin1073, [ontrue1074], [endif1076] | |
| :ontrue1074 | |
| (1652) [entry] | |
| (1653) wcross_scale <- DIV wcross_scale, autocvar_crosshair_hittest | |
| (1654) JUMP [endif1076] | |
| :endif1076 | |
| (1655) [entry] | |
| (1656) f <- STORE_F autocvar_crosshair_effect_speed | |
| (1657) bin1077 <- LT f, 0 | |
| (1658) COND bin1077, [ontrue1078], [endif1081] | |
| :ontrue1078 | |
| (1659) [entry] | |
| (1660) bin1079 <- MUL_F -2, g_weaponswitchdelay | |
| (1661) f <- MUL_F f, bin1079 | |
| (1662) JUMP [endif1081] | |
| :endif1081 | |
| (1663) [entry] | |
| (1664) bin1084 <- NE_F wcross_scale, wcross_scale_goal_prev | |
| (1665) sce_value1087 <- STORE_F bin1084 | |
| (1666) COND bin1084, [sce_merge1083], [sce_other1085] | |
| :sce_other1085 | |
| (1667) [entry] | |
| (1668) sce_value1087 <- NE_F wcross_alpha, wcross_alpha_goal_prev | |
| (1669) JUMP [sce_merge1083] | |
| :sce_merge1083 | |
| (1670) [entry] | |
| (1671) sce_bool1088 <- AND sce_value1087, sce_value1087 | |
| (1672) sce_value1091 <- STORE_F sce_bool1088 | |
| (1673) COND sce_bool1088, [sce_merge1082], [sce_other1089] | |
| :sce_other1089 | |
| (1674) [entry] | |
| (1675) sce_value1091 <- NE_V wcross_color, wcross_color_goal_prev | |
| (1676) JUMP [sce_merge1082] | |
| :sce_merge1082 | |
| (1677) [entry] | |
| (1678) sce_bool1092 <- AND sce_value1091, sce_value1091 | |
| (1679) COND sce_bool1092, [ontrue1093], [endif1095] | |
| :ontrue1093 | |
| (1680) [entry] | |
| (1681) wcross_changedonetime <- ADD_F time, f | |
| (1682) JUMP [endif1095] | |
| :endif1095 | |
| (1683) [entry] | |
| (1684) bin1097 <- NE_S wcross_name, wcross_name_goal_prev | |
| (1685) sce_value1100 <- STORE_F bin1097 | |
| (1686) COND bin1097, [sce_merge1096], [sce_other1098] | |
| :sce_other1098 | |
| (1687) [entry] | |
| (1688) sce_value1100 <- NE_F wcross_resolution, wcross_resolution_goal_prev | |
| (1689) JUMP [sce_merge1096] | |
| :sce_merge1096 | |
| (1690) [entry] | |
| (1691) sce_bool1101 <- AND sce_value1100, sce_value1100 | |
| (1692) COND sce_bool1101, [ontrue1102], [endif1108] | |
| :ontrue1102 | |
| (1693) [entry] | |
| (1694) wcross_name_changestarttime <- STORE_F time | |
| (1695) wcross_name_changedonetime <- ADD_F time, f | |
| (1696) COND wcross_name_goal_prev_prev, [ontrue1104], [endif1106] | |
| :ontrue1104 | |
| (1697) [entry] | |
| (1698) call1105 <- CALL1 fn:strunzone params: wcross_name_goal_prev_prev, | |
| (1699) JUMP [endif1106] | |
| :endif1106 | |
| (1700) [entry] | |
| (1701) wcross_name_goal_prev_prev <- STORE_S wcross_name_goal_prev | |
| (1702) wcross_name_goal_prev <- CALL1 fn:strzone params: wcross_name, | |
| (1703) wcross_name_alpha_goal_prev_prev <- STORE_F wcross_name_alpha_goal_prev | |
| (1704) wcross_resolution_goal_prev_prev <- STORE_F wcross_resolution_goal_prev | |
| (1705) wcross_resolution_goal_prev <- STORE_F wcross_resolution | |
| (1706) JUMP [endif1108] | |
| :endif1108 | |
| (1707) [entry] | |
| (1708) wcross_scale_goal_prev <- STORE_F wcross_scale | |
| (1709) wcross_alpha_goal_prev <- STORE_F wcross_alpha | |
| (1710) wcross_color_goal_prev <- STORE_V wcross_color | |
| (1711) bin1110 <- EQ_F shottype, 1 | |
| (1712) sce_value1122 <- STORE_F bin1110 | |
| (1713) COND bin1110, [sce_merge1109], [sce_other1111] | |
| :sce_other1111 | |
| (1714) [entry] | |
| (1715) bin1114 <- EQ_F shottype, 2 | |
| (1716) sce_value1116 <- STORE_F bin1114 | |
| (1717) COND bin1114, [sce_other1115], [sce_merge1113] | |
| :sce_other1115 | |
| (1718) [entry] | |
| (1719) sce_value1116 <- STORE_F autocvar_crosshair_hittest_blur | |
| (1720) JUMP [sce_merge1113] | |
| :sce_merge1113 | |
| (1721) [entry] | |
| (1722) sce_bool1117 <- AND sce_value1116, sce_value1116 | |
| (1723) sce_value1120 <- STORE_F sce_bool1117 | |
| (1724) COND sce_bool1117, [sce_other1118], [sce_merge1112] | |
| :sce_other1118 | |
| (1725) [entry] | |
| (1726) sce_value1120 <- NOT_F autocvar_chase_active | |
| (1727) JUMP [sce_merge1112] | |
| :sce_merge1112 | |
| (1728) [entry] | |
| (1729) sce_value1122 <- AND sce_value1120, sce_value1120 | |
| (1730) JUMP [sce_merge1109] | |
| :sce_merge1109 | |
| (1731) [entry] | |
| (1732) sce_bool1123 <- AND sce_value1122, sce_value1122 | |
| (1733) COND sce_bool1123, [ontrue1124], [onfalse1126] | |
| :ontrue1124 | |
| (1734) [entry] | |
| (1735) wcross_blur <- STORE_F 1 | |
| (1736) wcross_alpha <- MUL_F wcross_alpha, 0.75 | |
| (1737) JUMP [endif1127] | |
| :onfalse1126 | |
| (1738) [entry] | |
| (1739) wcross_blur <- STORE_F 0 | |
| (1740) JUMP [endif1127] | |
| :endif1127 | |
| (1741) [entry] | |
| (1742) bin1128 <- LT time, wcross_changedonetime | |
| (1743) COND bin1128, [ontrue1129], [endif1145] | |
| :ontrue1129 | |
| (1744) [entry] | |
| (1745) bin1130 <- SUB_F wcross_changedonetime, time | |
| (1746) bin1131 <- ADD_F bin1130, frametime | |
| (1747) f <- DIV frametime, bin1131 | |
| (1748) bin1133 <- MUL_F f, wcross_scale | |
| (1749) bin1134 <- SUB_F 1, f | |
| (1750) bin1135 <- MUL_F bin1134, wcross_scale_prev | |
| (1751) wcross_scale <- ADD_F bin1133, bin1135 | |
| (1752) bin1137 <- MUL_F f, wcross_alpha | |
| (1753) bin1138 <- SUB_F 1, f | |
| (1754) bin1139 <- MUL_F bin1138, wcross_alpha_prev | |
| (1755) wcross_alpha <- ADD_F bin1137, bin1139 | |
| (1756) bin1141 <- MUL_FV f, wcross_color | |
| (1757) bin1142 <- SUB_F 1, f | |
| (1758) bin1143 <- MUL_FV bin1142, wcross_color_prev | |
| (1759) wcross_color <- ADD_V bin1141, bin1143 | |
| (1760) JUMP [endif1145] | |
| :endif1145 | |
| (1761) [entry] | |
| (1762) wcross_scale_prev <- STORE_F wcross_scale | |
| (1763) wcross_alpha_prev <- STORE_F wcross_alpha | |
| (1764) wcross_color_prev <- STORE_V wcross_color | |
| (1765) bin1146 <- SUB_F 1, autocvar__menu_alpha | |
| (1766) wcross_scale <- MUL_F wcross_scale, bin1146 | |
| (1767) bin1148 <- SUB_F 1, autocvar__menu_alpha | |
| (1768) wcross_alpha <- MUL_F wcross_alpha, bin1148 | |
| (1769) call1150 <- CALL1 fn:draw_getimagesize params: wcross_name, | |
| (1770) wcross_size <- MUL_VF call1150, wcross_scale | |
| (1771) bin1153 <- GE wcross_scale, 0.001 | |
| (1772) sce_value1156 <- STORE_F bin1153 | |
| (1773) COND bin1153, [sce_other1154], [sce_merge1152] | |
| :sce_other1154 | |
| (1774) [entry] | |
| (1775) sce_value1156 <- GE wcross_alpha, 0.001 | |
| (1776) JUMP [sce_merge1152] | |
| :sce_merge1152 | |
| (1777) [entry] | |
| (1778) sce_bool1157 <- AND sce_value1156, sce_value1156 | |
| (1779) COND sce_bool1157, [ontrue1158], [endif1465] | |
| :ontrue1158 | |
| (1780) [entry] | |
| (1781) sce_value1161 <- STORE_F autocvar_crosshair_ring | |
| (1782) COND autocvar_crosshair_ring, [sce_merge1159], [sce_other1160] | |
| :sce_other1160 | |
| (1783) [entry] | |
| (1784) sce_value1161 <- STORE_F autocvar_crosshair_ring_reload | |
| (1785) JUMP [sce_merge1159] | |
| :sce_merge1159 | |
| (1786) [entry] | |
| (1787) sce_bool1162 <- AND sce_value1161, sce_value1161 | |
| (1788) COND sce_bool1162, [ontrue1163], [endif1287] | |
| :ontrue1163 | |
| (1789) [entry] | |
| (1790) ring_value <- STORE_F 0 | |
| (1791) ring_scale <- STORE_F 0 | |
| (1792) ring_alpha <- STORE_F 0 | |
| (1793) ring_inner_value <- STORE_F 0 | |
| (1794) ring_inner_alpha <- STORE_F 0 | |
| (1795) ring_image <- STORE_S nil | |
| (1796) ring_inner_image <- STORE_S nil | |
| (1797) ring_rgb <- STORE_V '0 0 0' | |
| (1798) ring_inner_rgb <- STORE_V '0 0 0' | |
| (1799) ring_scale <- STORE_F autocvar_crosshair_ring_size | |
| (1800) weapon_clipload <- CALL1 fn:getstati params: STAT_WEAPON_CLIPLOAD, | |
| (1801) weapon_clipsize <- CALL1 fn:getstati params: STAT_WEAPON_CLIPSIZE, | |
| (1802) nex_charge <- CALL1 fn:getstatf params: STAT_NEX_CHARGE, | |
| (1803) nex_chargepool <- CALL1 fn:getstatf params: STAT_NEX_CHARGEPOOL, | |
| (1804) bin1168 <- EQ_F nex_charge_movingavg, 0 | |
| (1805) COND bin1168, [ontrue1169], [endif1170] | |
| :ontrue1169 | |
| (1806) [entry] | |
| (1807) nex_charge_movingavg <- STORE_F nex_charge | |
| (1808) JUMP [endif1170] | |
| :endif1170 | |
| (1809) [entry] | |
| (1810) sce_value1176 <- STORE_F autocvar_crosshair_ring | |
| (1811) COND autocvar_crosshair_ring, [sce_other1174], [sce_merge1173] | |
| :sce_other1174 | |
| (1812) [entry] | |
| (1813) sce_value1176 <- EQ_F activeweapon, WEP_NEX | |
| (1814) JUMP [sce_merge1173] | |
| :sce_merge1173 | |
| (1815) [entry] | |
| (1816) sce_bool1177 <- AND sce_value1176, sce_value1176 | |
| (1817) sce_value1179 <- STORE_F sce_bool1177 | |
| (1818) COND sce_bool1177, [sce_other1178], [sce_merge1172] | |
| :sce_other1178 | |
| (1819) [entry] | |
| (1820) sce_value1179 <- STORE_F nex_charge | |
| (1821) JUMP [sce_merge1172] | |
| :sce_merge1172 | |
| (1822) [entry] | |
| (1823) sce_bool1180 <- AND sce_value1179, sce_value1179 | |
| (1824) sce_value1182 <- STORE_F sce_bool1180 | |
| (1825) COND sce_bool1180, [sce_other1181], [sce_merge1171] | |
| :sce_other1181 | |
| (1826) [entry] | |
| (1827) sce_value1182 <- STORE_F autocvar_crosshair_ring_nex | |
| (1828) JUMP [sce_merge1171] | |
| :sce_merge1171 | |
| (1829) [entry] | |
| (1830) sce_bool1183 <- AND sce_value1182, sce_value1182 | |
| (1831) COND sce_bool1183, [ontrue1184], [onfalse1204] | |
| :ontrue1184 | |
| (1832) [entry] | |
| (1833) sce_value1187 <- STORE_F nex_chargepool | |
| (1834) COND nex_chargepool, [sce_merge1185], [sce_other1186] | |
| :sce_other1186 | |
| (1835) [entry] | |
| (1836) sce_value1187 <- STORE_F use_nex_chargepool | |
| (1837) JUMP [sce_merge1185] | |
| :sce_merge1185 | |
| (1838) [entry] | |
| (1839) sce_bool1188 <- AND sce_value1187, sce_value1187 | |
| (1840) COND sce_bool1188, [ontrue1189], [onfalse1190] | |
| :ontrue1189 | |
| (1841) [entry] | |
| (1842) use_nex_chargepool <- STORE_F 1 | |
| (1843) ring_inner_value <- STORE_F nex_chargepool | |
| (1844) JUMP [endif1198] | |
| :onfalse1190 | |
| (1845) [entry] | |
| (1846) bin1191 <- SUB_F 1, autocvar_crosshair_ring_nex_currentcharge_movingavg_rate | |
| (1847) bin1192 <- MUL_F bin1191, nex_charge_movingavg | |
| (1848) bin1193 <- MUL_F autocvar_crosshair_ring_nex_currentcharge_movingavg_rate, nex_charge | |
| (1849) nex_charge_movingavg <- ADD_F bin1192, bin1193 | |
| (1850) bin1195 <- SUB_F nex_charge, nex_charge_movingavg | |
| (1851) bin1196 <- MUL_F autocvar_crosshair_ring_nex_currentcharge_scale, bin1195 | |
| (1852) ring_inner_value <- CALL3 fn:bound params: #IMMEDIATE, bin1196, #IMMEDIATE, | |
| (1853) JUMP [endif1198] | |
| :endif1198 | |
| (1854) [entry] | |
| (1855) ring_inner_alpha <- STORE_F autocvar_crosshair_ring_nex_inner_alpha | |
| (1856) bin1199 <- MUL_VF '1 0 0', autocvar_crosshair_ring_nex_inner_color_red | |
| (1857) bin1200 <- MUL_VF '0 1 0', autocvar_crosshair_ring_nex_inner_color_green | |
| (1858) bin1201 <- ADD_V bin1199, bin1200 | |
| (1859) bin1202 <- MUL_VF '0 0 1', autocvar_crosshair_ring_nex_inner_color_blue | |
| (1860) ring_inner_rgb <- ADD_V bin1201, bin1202 | |
| (1861) ring_inner_image <- STORE_S "gfx/crosshair_ring_inner.tga" | |
| (1862) ring_value <- STORE_F nex_charge | |
| (1863) ring_alpha <- STORE_F autocvar_crosshair_ring_nex_alpha | |
| (1864) ring_rgb <- STORE_V wcross_color | |
| (1865) ring_image <- STORE_S "gfx/crosshair_ring_nexgun.tga" | |
| (1866) JUMP [endif1239] | |
| :onfalse1204 | |
| (1867) [entry] | |
| (1868) sce_value1210 <- STORE_F autocvar_crosshair_ring | |
| (1869) COND autocvar_crosshair_ring, [sce_other1208], [sce_merge1207] | |
| :sce_other1208 | |
| (1870) [entry] | |
| (1871) sce_value1210 <- EQ_F activeweapon, WEP_MINE_LAYER | |
| (1872) JUMP [sce_merge1207] | |
| :sce_merge1207 | |
| (1873) [entry] | |
| (1874) sce_bool1211 <- AND sce_value1210, sce_value1210 | |
| (1875) sce_value1213 <- STORE_F sce_bool1211 | |
| (1876) COND sce_bool1211, [sce_other1212], [sce_merge1206] | |
| :sce_other1212 | |
| (1877) [entry] | |
| (1878) sce_value1213 <- STORE_F minelayer_maxmines | |
| (1879) JUMP [sce_merge1206] | |
| :sce_merge1206 | |
| (1880) [entry] | |
| (1881) sce_bool1214 <- AND sce_value1213, sce_value1213 | |
| (1882) sce_value1216 <- STORE_F sce_bool1214 | |
| (1883) COND sce_bool1214, [sce_other1215], [sce_merge1205] | |
| :sce_other1215 | |
| (1884) [entry] | |
| (1885) sce_value1216 <- STORE_F autocvar_crosshair_ring_minelayer | |
| (1886) JUMP [sce_merge1205] | |
| :sce_merge1205 | |
| (1887) [entry] | |
| (1888) sce_bool1217 <- AND sce_value1216, sce_value1216 | |
| (1889) COND sce_bool1217, [ontrue1218], [onfalse1222] | |
| :ontrue1218 | |
| (1890) [entry] | |
| (1891) call1219 <- CALL1 fn:getstati params: STAT_LAYED_MINES, | |
| (1892) bin1220 <- DIV call1219, minelayer_maxmines | |
| (1893) ring_value <- CALL3 fn:bound params: #IMMEDIATE, bin1220, #IMMEDIATE, | |
| (1894) ring_alpha <- STORE_F autocvar_crosshair_ring_minelayer_alpha | |
| (1895) ring_rgb <- STORE_V wcross_color | |
| (1896) ring_image <- STORE_S "gfx/crosshair_ring.tga" | |
| (1897) JUMP [endif1238] | |
| :onfalse1222 | |
| (1898) [entry] | |
| (1899) bin1225 <- EQ_F activeweapon, WEP_HAGAR | |
| (1900) sce_value1228 <- STORE_F bin1225 | |
| (1901) COND bin1225, [sce_other1226], [sce_merge1224] | |
| :sce_other1226 | |
| (1902) [entry] | |
| (1903) sce_value1228 <- CALL1 fn:getstati params: STAT_HAGAR_LOAD, | |
| (1904) JUMP [sce_merge1224] | |
| :sce_merge1224 | |
| (1905) [entry] | |
| (1906) sce_bool1229 <- AND sce_value1228, sce_value1228 | |
| (1907) sce_value1231 <- STORE_F sce_bool1229 | |
| (1908) COND sce_bool1229, [sce_other1230], [sce_merge1223] | |
| :sce_other1230 | |
| (1909) [entry] | |
| (1910) sce_value1231 <- STORE_F autocvar_crosshair_ring_hagar | |
| (1911) JUMP [sce_merge1223] | |
| :sce_merge1223 | |
| (1912) [entry] | |
| (1913) sce_bool1232 <- AND sce_value1231, sce_value1231 | |
| (1914) COND sce_bool1232, [ontrue1233], [endif1237] | |
| :ontrue1233 | |
| (1915) [entry] | |
| (1916) call1234 <- CALL1 fn:getstati params: STAT_HAGAR_LOAD, | |
| (1917) bin1235 <- DIV call1234, hagar_maxrockets | |
| (1918) ring_value <- CALL3 fn:bound params: #IMMEDIATE, bin1235, #IMMEDIATE, | |
| (1919) ring_alpha <- STORE_F autocvar_crosshair_ring_hagar_alpha | |
| (1920) ring_rgb <- STORE_V wcross_color | |
| (1921) ring_image <- STORE_S "gfx/crosshair_ring.tga" | |
| (1922) JUMP [endif1237] | |
| :endif1237 | |
| (1923) [entry] | |
| (1924) JUMP [endif1238] | |
| :endif1238 | |
| (1925) [entry] | |
| (1926) JUMP [endif1239] | |
| :endif1239 | |
| (1927) [entry] | |
| (1928) sce_value1242 <- STORE_F autocvar_crosshair_ring_reload | |
| (1929) COND autocvar_crosshair_ring_reload, [sce_other1241], [sce_merge1240] | |
| :sce_other1241 | |
| (1930) [entry] | |
| (1931) sce_value1242 <- STORE_F weapon_clipsize | |
| (1932) JUMP [sce_merge1240] | |
| :sce_merge1240 | |
| (1933) [entry] | |
| (1934) sce_bool1243 <- AND sce_value1242, sce_value1242 | |
| (1935) COND sce_bool1243, [ontrue1244], [endif1256] | |
| :ontrue1244 | |
| (1936) [entry] | |
| (1937) bin1245 <- DIV weapon_clipload, weapon_clipsize | |
| (1938) ring_value <- CALL3 fn:bound params: #IMMEDIATE, bin1245, #IMMEDIATE, | |
| (1939) ring_scale <- STORE_F autocvar_crosshair_ring_reload_size | |
| (1940) ring_alpha <- STORE_F autocvar_crosshair_ring_reload_alpha | |
| (1941) ring_rgb <- STORE_V wcross_color | |
| (1942) bin1248 <- EQ_F activeweapon, WEP_RIFLE | |
| (1943) sce_value1251 <- STORE_F bin1248 | |
| (1944) COND bin1248, [sce_other1249], [sce_merge1247] | |
| :sce_other1249 | |
| (1945) [entry] | |
| (1946) sce_value1251 <- EQ_F weapon_clipsize, 80 | |
| (1947) JUMP [sce_merge1247] | |
| :sce_merge1247 | |
| (1948) [entry] | |
| (1949) sce_bool1252 <- AND sce_value1251, sce_value1251 | |
| (1950) COND sce_bool1252, [ontrue1253], [onfalse1254] | |
| :ontrue1253 | |
| (1951) [entry] | |
| (1952) ring_image <- STORE_S "gfx/crosshair_ring_rifle.tga" | |
| (1953) JUMP [endif1255] | |
| :onfalse1254 | |
| (1954) [entry] | |
| (1955) ring_image <- STORE_S "gfx/crosshair_ring.tga" | |
| (1956) JUMP [endif1255] | |
| :endif1255 | |
| (1957) [entry] | |
| (1958) JUMP [endif1256] | |
| :endif1256 | |
| (1959) [entry] | |
| (1960) bin1257 <- GT g_weaponswitchdelay, 0 | |
| (1961) COND bin1257, [ontrue1258], [endif1272] | |
| :ontrue1258 | |
| (1962) [entry] | |
| (1963) bin1259 <- SUB_F time, wcross_name_changestarttime | |
| (1964) f <- DIV bin1259, g_weaponswitchdelay | |
| (1965) bin1262 <- GT f, 0 | |
| (1966) sce_value1265 <- STORE_F bin1262 | |
| (1967) COND bin1262, [sce_other1263], [sce_merge1261] | |
| :sce_other1263 | |
| (1968) [entry] | |
| (1969) sce_value1265 <- LT f, 2 | |
| (1970) JUMP [sce_merge1261] | |
| :sce_merge1261 | |
| (1971) [entry] | |
| (1972) sce_bool1266 <- AND sce_value1265, sce_value1265 | |
| (1973) COND sce_bool1266, [ontrue1267], [endif1271] | |
| :ontrue1267 | |
| (1974) [entry] | |
| (1975) bin1268 <- SUB_F 1, f | |
| (1976) call1269 <- CALL1 fn:fabs params: bin1268, | |
| (1977) ring_alpha <- MUL_F ring_alpha, call1269 | |
| (1978) JUMP [endif1271] | |
| :endif1271 | |
| (1979) [entry] | |
| (1980) JUMP [endif1272] | |
| :endif1272 | |
| (1981) [entry] | |
| (1982) sce_value1275 <- STORE_F autocvar_crosshair_ring_inner | |
| (1983) COND autocvar_crosshair_ring_inner, [sce_other1274], [sce_merge1273] | |
| :sce_other1274 | |
| (1984) [entry] | |
| (1985) sce_value1275 <- STORE_F ring_inner_value | |
| (1986) JUMP [sce_merge1273] | |
| :sce_merge1273 | |
| (1987) [entry] | |
| (1988) sce_bool1276 <- AND sce_value1275, sce_value1275 | |
| (1989) COND sce_bool1276, [ontrue1277], [endif1281] | |
| :ontrue1277 | |
| (1990) [entry] | |
| (1991) bin1278 <- MUL_F wcross_size_x, ring_scale | |
| (1992) bin1279 <- MUL_F wcross_alpha, ring_inner_alpha | |
| (1993) call1280 <- CALL7 fn:DrawCircleClippedPic params: wcross_origin, bin1278, ring_inner_image, ring_inner_value, ring_inner_rgb, bin1279, DRAWFLAG_ADDITIVE, | |
| (1994) JUMP [endif1281] | |
| :endif1281 | |
| (1995) [entry] | |
| (1996) COND ring_value, [ontrue1282], [endif1286] | |
| :ontrue1282 | |
| (1997) [entry] | |
| (1998) bin1283 <- MUL_F wcross_size_x, ring_scale | |
| (1999) bin1284 <- MUL_F wcross_alpha, ring_alpha | |
| (2000) call1285 <- CALL7 fn:DrawCircleClippedPic params: wcross_origin, bin1283, ring_image, ring_value, ring_rgb, bin1284, DRAWFLAG_ADDITIVE, | |
| (2001) JUMP [endif1286] | |
| :endif1286 | |
| (2002) [entry] | |
| (2003) JUMP [endif1287] | |
| :endif1287 | |
| (2004) [entry] | |
| (2005) bin1290 <- LT time, wcross_name_changedonetime | |
| (2006) sce_value1293 <- STORE_F bin1290 | |
| (2007) COND bin1290, [sce_other1291], [sce_merge1289] | |
| :sce_other1291 | |
| (2008) [entry] | |
| (2009) sce_value1293 <- NE_S wcross_name, wcross_name_goal_prev_prev | |
| (2010) JUMP [sce_merge1289] | |
| :sce_merge1289 | |
| (2011) [entry] | |
| (2012) sce_bool1294 <- AND sce_value1293, sce_value1293 | |
| (2013) sce_value1296 <- STORE_F sce_bool1294 | |
| (2014) COND sce_bool1294, [sce_other1295], [sce_merge1288] | |
| :sce_other1295 | |
| (2015) [entry] | |
| (2016) sce_value1296 <- STORE_F wcross_name_goal_prev_prev | |
| (2017) JUMP [sce_merge1288] | |
| :sce_merge1288 | |
| (2018) [entry] | |
| (2019) sce_bool1297 <- AND sce_value1296, sce_value1296 | |
| (2020) COND sce_bool1297, [ontrue1298], [onfalse1353] | |
| :ontrue1298 | |
| (2021) [entry] | |
| (2022) bin1299 <- SUB_F wcross_name_changedonetime, time | |
| (2023) bin1300 <- SUB_F wcross_name_changedonetime, wcross_name_changestarttime | |
| (2024) f <- DIV bin1299, bin1300 | |
| (2025) call1302 <- CALL1 fn:draw_getimagesize params: wcross_name_goal_prev_prev, | |
| (2026) wcross_size <- MUL_VF call1302, wcross_scale | |
| (2027) JUMP [loop_body1306] | |
| :post_loop_cond1304 | |
| (2028) [entry] | |
| (2029) COND 0, [loop_body1306], [after_loop1305] | |
| :loop_body1306 | |
| (2030) [entry] | |
| (2031) bin1307 <- GT wcross_blur, 0 | |
| (2032) COND bin1307, [ontrue1308], [onfalse1336] | |
| :ontrue1308 | |
| (2033) [entry] | |
| (2034) i <- STORE_F -2 | |
| (2035) JUMP [pre_loop_cond1309] | |
| :pre_loop_cond1309 | |
| (2036) [entry] | |
| (2037) bin1310 <- LE i, 2 | |
| (2038) COND bin1310, [loop_body1313], [after_loop1312] | |
| :loop_increment1311 | |
| (2039) [entry] | |
| (2040) i <- ADD_F i, 1 | |
| (2041) JUMP [pre_loop_cond1309] | |
| :loop_body1313 | |
| (2042) [entry] | |
| (2043) j <- STORE_F -2 | |
| (2044) JUMP [pre_loop_cond1314] | |
| :pre_loop_cond1314 | |
| (2045) [entry] | |
| (2046) bin1315 <- LE j, 2 | |
| (2047) COND bin1315, [loop_body1318], [after_loop1317] | |
| :loop_increment1316 | |
| (2048) [entry] | |
| (2049) j <- ADD_F j, 1 | |
| (2050) JUMP [pre_loop_cond1314] | |
| :loop_body1318 | |
| (2051) [entry] | |
| (2052) bin1319 <- MUL_F wcross_resolution_goal_prev_prev, wcross_size_x | |
| (2053) bin1320 <- MUL_F i, wcross_blur | |
| (2054) bin1321 <- ADD_F bin1319, bin1320 | |
| (2055) bin1322 <- MUL_VF '0.5 0 0', bin1321 | |
| (2056) bin1323 <- MUL_F wcross_resolution_goal_prev_prev, wcross_size_y | |
| (2057) bin1324 <- MUL_F j, wcross_blur | |
| (2058) bin1325 <- ADD_F bin1323, bin1324 | |
| (2059) bin1326 <- MUL_VF '0 0.5 0', bin1325 | |
| (2060) bin1327 <- ADD_V bin1322, bin1326 | |
| (2061) bin1328 <- SUB_V wcross_origin, bin1327 | |
| (2062) bin1329 <- MUL_FV wcross_resolution_goal_prev_prev, wcross_size | |
| (2063) bin1330 <- MUL_F wcross_alpha, f | |
| (2064) bin1331 <- MUL_F bin1330, wcross_name_alpha_goal_prev_prev | |
| (2065) bin1332 <- MUL_F bin1331, 0.04 | |
| (2066) call1333 <- CALL6 fn:drawpic params: bin1328, wcross_name_goal_prev_prev, bin1329, wcross_color, bin1332, DRAWFLAG_NORMAL, | |
| (2067) JUMP [loop_increment1316] | |
| :after_loop1317 | |
| (2068) [entry] | |
| (2069) JUMP [loop_increment1311] | |
| :after_loop1312 | |
| (2070) [entry] | |
| (2071) JUMP [endif1351] | |
| :onfalse1336 | |
| (2072) [entry] | |
| (2073) bin1337 <- MUL_F wcross_resolution_goal_prev_prev, wcross_size_x | |
| (2074) bin1338 <- MUL_F 0, wcross_blur | |
| (2075) bin1339 <- ADD_F bin1337, bin1338 | |
| (2076) bin1340 <- MUL_VF '0.5 0 0', bin1339 | |
| (2077) bin1341 <- MUL_F wcross_resolution_goal_prev_prev, wcross_size_y | |
| (2078) bin1342 <- MUL_F 0, wcross_blur | |
| (2079) bin1343 <- ADD_F bin1341, bin1342 | |
| (2080) bin1344 <- MUL_VF '0 0.5 0', bin1343 | |
| (2081) bin1345 <- ADD_V bin1340, bin1344 | |
| (2082) bin1346 <- SUB_V wcross_origin, bin1345 | |
| (2083) bin1347 <- MUL_FV wcross_resolution_goal_prev_prev, wcross_size | |
| (2084) bin1348 <- MUL_F wcross_alpha, f | |
| (2085) bin1349 <- MUL_F bin1348, wcross_name_alpha_goal_prev_prev | |
| (2086) call1350 <- CALL6 fn:drawpic params: bin1346, wcross_name_goal_prev_prev, bin1347, wcross_color, bin1349, DRAWFLAG_NORMAL, | |
| (2087) JUMP [endif1351] | |
| :endif1351 | |
| (2088) [entry] | |
| (2089) JUMP [post_loop_cond1304] | |
| :after_loop1305 | |
| (2090) [entry] | |
| (2091) f <- SUB_F 1, f | |
| (2092) JUMP [endif1354] | |
| :onfalse1353 | |
| (2093) [entry] | |
| (2094) f <- STORE_F 1 | |
| (2095) JUMP [endif1354] | |
| :endif1354 | |
| (2096) [entry] | |
| (2097) wcross_name_alpha_goal_prev <- STORE_F f | |
| (2098) call1355 <- CALL1 fn:draw_getimagesize params: wcross_name, | |
| (2099) wcross_size <- MUL_VF call1355, wcross_scale | |
| (2100) JUMP [loop_body1359] | |
| :post_loop_cond1357 | |
| (2101) [entry] | |
| (2102) COND 0, [loop_body1359], [after_loop1358] | |
| :loop_body1359 | |
| (2103) [entry] | |
| (2104) bin1360 <- GT wcross_blur, 0 | |
| (2105) COND bin1360, [ontrue1361], [onfalse1388] | |
| :ontrue1361 | |
| (2106) [entry] | |
| (2107) i <- STORE_F -2 | |
| (2108) JUMP [pre_loop_cond1362] | |
| :pre_loop_cond1362 | |
| (2109) [entry] | |
| (2110) bin1363 <- LE i, 2 | |
| (2111) COND bin1363, [loop_body1366], [after_loop1365] | |
| :loop_increment1364 | |
| (2112) [entry] | |
| (2113) i <- ADD_F i, 1 | |
| (2114) JUMP [pre_loop_cond1362] | |
| :loop_body1366 | |
| (2115) [entry] | |
| (2116) j <- STORE_F -2 | |
| (2117) JUMP [pre_loop_cond1367] | |
| :pre_loop_cond1367 | |
| (2118) [entry] | |
| (2119) bin1368 <- LE j, 2 | |
| (2120) COND bin1368, [loop_body1371], [after_loop1370] | |
| :loop_increment1369 | |
| (2121) [entry] | |
| (2122) j <- ADD_F j, 1 | |
| (2123) JUMP [pre_loop_cond1367] | |
| :loop_body1371 | |
| (2124) [entry] | |
| (2125) bin1372 <- MUL_F wcross_resolution, wcross_size_x | |
| (2126) bin1373 <- MUL_F i, wcross_blur | |
| (2127) bin1374 <- ADD_F bin1372, bin1373 | |
| (2128) bin1375 <- MUL_VF '0.5 0 0', bin1374 | |
| (2129) bin1376 <- MUL_F wcross_resolution, wcross_size_y | |
| (2130) bin1377 <- MUL_F j, wcross_blur | |
| (2131) bin1378 <- ADD_F bin1376, bin1377 | |
| (2132) bin1379 <- MUL_VF '0 0.5 0', bin1378 | |
| (2133) bin1380 <- ADD_V bin1375, bin1379 | |
| (2134) bin1381 <- SUB_V wcross_origin, bin1380 | |
| (2135) bin1382 <- MUL_FV wcross_resolution, wcross_size | |
| (2136) bin1383 <- MUL_F wcross_alpha, f | |
| (2137) bin1384 <- MUL_F bin1383, 0.04 | |
| (2138) call1385 <- CALL6 fn:drawpic params: bin1381, wcross_name, bin1382, wcross_color, bin1384, DRAWFLAG_NORMAL, | |
| (2139) JUMP [loop_increment1369] | |
| :after_loop1370 | |
| (2140) [entry] | |
| (2141) JUMP [loop_increment1364] | |
| :after_loop1365 | |
| (2142) [entry] | |
| (2143) JUMP [endif1402] | |
| :onfalse1388 | |
| (2144) [entry] | |
| (2145) bin1389 <- MUL_F wcross_resolution, wcross_size_x | |
| (2146) bin1390 <- MUL_F 0, wcross_blur | |
| (2147) bin1391 <- ADD_F bin1389, bin1390 | |
| (2148) bin1392 <- MUL_VF '0.5 0 0', bin1391 | |
| (2149) bin1393 <- MUL_F wcross_resolution, wcross_size_y | |
| (2150) bin1394 <- MUL_F 0, wcross_blur | |
| (2151) bin1395 <- ADD_F bin1393, bin1394 | |
| (2152) bin1396 <- MUL_VF '0 0.5 0', bin1395 | |
| (2153) bin1397 <- ADD_V bin1392, bin1396 | |
| (2154) bin1398 <- SUB_V wcross_origin, bin1397 | |
| (2155) bin1399 <- MUL_FV wcross_resolution, wcross_size | |
| (2156) bin1400 <- MUL_F wcross_alpha, f | |
| (2157) call1401 <- CALL6 fn:drawpic params: bin1398, wcross_name, bin1399, wcross_color, bin1400, DRAWFLAG_NORMAL, | |
| (2158) JUMP [endif1402] | |
| :endif1402 | |
| (2159) [entry] | |
| (2160) JUMP [post_loop_cond1357] | |
| :after_loop1358 | |
| (2161) [entry] | |
| (2162) COND autocvar_crosshair_dot, [ontrue1403], [endif1464] | |
| :ontrue1403 | |
| (2163) [entry] | |
| (2164) wcross_color_old <- STORE_V wcross_color | |
| (2165) sce_value1407 <- STORE_F 1 | |
| (2166) COND 1, [sce_other1405], [sce_merge1404] | |
| :sce_other1405 | |
| (2167) [entry] | |
| (2168) sce_value1407 <- NE_S autocvar_crosshair_dot_color, "0" | |
| (2169) JUMP [sce_merge1404] | |
| :sce_merge1404 | |
| (2170) [entry] | |
| (2171) sce_bool1408 <- AND sce_value1407, sce_value1407 | |
| (2172) COND sce_bool1408, [ontrue1409], [endif1411] | |
| :ontrue1409 | |
| (2173) [entry] | |
| (2174) wcross_color <- CALL1 fn:stov params: autocvar_crosshair_dot_color, | |
| (2175) JUMP [endif1411] | |
| :endif1411 | |
| (2176) [entry] | |
| (2177) JUMP [loop_body1414] | |
| :post_loop_cond1412 | |
| (2178) [entry] | |
| (2179) COND 0, [loop_body1414], [after_loop1413] | |
| :loop_body1414 | |
| (2180) [entry] | |
| (2181) bin1415 <- GT wcross_blur, 0 | |
| (2182) COND bin1415, [ontrue1416], [onfalse1446] | |
| :ontrue1416 | |
| (2183) [entry] | |
| (2184) i <- STORE_F -2 | |
| (2185) JUMP [pre_loop_cond1417] | |
| :pre_loop_cond1417 | |
| (2186) [entry] | |
| (2187) bin1418 <- LE i, 2 | |
| (2188) COND bin1418, [loop_body1421], [after_loop1420] | |
| :loop_increment1419 | |
| (2189) [entry] | |
| (2190) i <- ADD_F i, 1 | |
| (2191) JUMP [pre_loop_cond1417] | |
| :loop_body1421 | |
| (2192) [entry] | |
| (2193) j <- STORE_F -2 | |
| (2194) JUMP [pre_loop_cond1422] | |
| :pre_loop_cond1422 | |
| (2195) [entry] | |
| (2196) bin1423 <- LE j, 2 | |
| (2197) COND bin1423, [loop_body1426], [after_loop1425] | |
| :loop_increment1424 | |
| (2198) [entry] | |
| (2199) j <- ADD_F j, 1 | |
| (2200) JUMP [pre_loop_cond1422] | |
| :loop_body1426 | |
| (2201) [entry] | |
| (2202) bin1427 <- MUL_F wcross_resolution, autocvar_crosshair_dot_size | |
| (2203) bin1428 <- MUL_F bin1427, wcross_size_x | |
| (2204) bin1429 <- MUL_F i, wcross_blur | |
| (2205) bin1430 <- ADD_F bin1428, bin1429 | |
| (2206) bin1431 <- MUL_VF '0.5 0 0', bin1430 | |
| (2207) bin1432 <- MUL_F wcross_resolution, autocvar_crosshair_dot_size | |
| (2208) bin1433 <- MUL_F bin1432, wcross_size_y | |
| (2209) bin1434 <- MUL_F j, wcross_blur | |
| (2210) bin1435 <- ADD_F bin1433, bin1434 | |
| (2211) bin1436 <- MUL_VF '0 0.5 0', bin1435 | |
| (2212) bin1437 <- ADD_V bin1431, bin1436 | |
| (2213) bin1438 <- SUB_V wcross_origin, bin1437 | |
| (2214) bin1439 <- MUL_F wcross_resolution, autocvar_crosshair_dot_size | |
| (2215) bin1440 <- MUL_FV bin1439, wcross_size | |
| (2216) bin1441 <- MUL_F f, autocvar_crosshair_dot_alpha | |
| (2217) bin1442 <- MUL_F bin1441, 0.04 | |
| (2218) call1443 <- CALL6 fn:drawpic params: bin1438, #IMMEDIATE, bin1440, wcross_color, bin1442, DRAWFLAG_NORMAL, | |
| (2219) JUMP [loop_increment1424] | |
| :after_loop1425 | |
| (2220) [entry] | |
| (2221) JUMP [loop_increment1419] | |
| :after_loop1420 | |
| (2222) [entry] | |
| (2223) JUMP [endif1463] | |
| :onfalse1446 | |
| (2224) [entry] | |
| (2225) bin1447 <- MUL_F wcross_resolution, autocvar_crosshair_dot_size | |
| (2226) bin1448 <- MUL_F bin1447, wcross_size_x | |
| (2227) bin1449 <- MUL_F 0, wcross_blur | |
| (2228) bin1450 <- ADD_F bin1448, bin1449 | |
| (2229) bin1451 <- MUL_VF '0.5 0 0', bin1450 | |
| (2230) bin1452 <- MUL_F wcross_resolution, autocvar_crosshair_dot_size | |
| (2231) bin1453 <- MUL_F bin1452, wcross_size_y | |
| (2232) bin1454 <- MUL_F 0, wcross_blur | |
| (2233) bin1455 <- ADD_F bin1453, bin1454 | |
| (2234) bin1456 <- MUL_VF '0 0.5 0', bin1455 | |
| (2235) bin1457 <- ADD_V bin1451, bin1456 | |
| (2236) bin1458 <- SUB_V wcross_origin, bin1457 | |
| (2237) bin1459 <- MUL_F wcross_resolution, autocvar_crosshair_dot_size | |
| (2238) bin1460 <- MUL_FV bin1459, wcross_size | |
| (2239) bin1461 <- MUL_F f, autocvar_crosshair_dot_alpha | |
| (2240) call1462 <- CALL6 fn:drawpic params: bin1458, #IMMEDIATE, bin1460, wcross_color, bin1461, DRAWFLAG_NORMAL, | |
| (2241) JUMP [endif1463] | |
| :endif1463 | |
| (2242) [entry] | |
| (2243) JUMP [post_loop_cond1412] | |
| :after_loop1413 | |
| (2244) [entry] | |
| (2245) wcross_color <- STORE_V wcross_color_old | |
| (2246) JUMP [endif1464] | |
| :endif1464 | |
| (2247) [entry] | |
| (2248) JUMP [endif1465] | |
| :endif1465 | |
| (2249) [entry] | |
| (2250) JUMP [endif1473] | |
| :onfalse1466 | |
| (2251) [entry] | |
| (2252) wcross_scale_prev <- STORE_F 0 | |
| (2253) wcross_alpha_prev <- STORE_F 0 | |
| (2254) wcross_scale_goal_prev <- STORE_F 0 | |
| (2255) wcross_alpha_goal_prev <- STORE_F 0 | |
| (2256) wcross_changedonetime <- STORE_F 0 | |
| (2257) COND wcross_name_goal_prev, [ontrue1467], [endif1469] | |
| :ontrue1467 | |
| (2258) [entry] | |
| (2259) call1468 <- CALL1 fn:strunzone params: wcross_name_goal_prev, | |
| (2260) JUMP [endif1469] | |
| :endif1469 | |
| (2261) [entry] | |
| (2262) wcross_name_goal_prev <- STORE_S nil | |
| (2263) COND wcross_name_goal_prev_prev, [ontrue1470], [endif1472] | |
| :ontrue1470 | |
| (2264) [entry] | |
| (2265) call1471 <- CALL1 fn:strunzone params: wcross_name_goal_prev_prev, | |
| (2266) JUMP [endif1472] | |
| :endif1472 | |
| (2267) [entry] | |
| (2268) wcross_name_goal_prev_prev <- STORE_S nil | |
| (2269) wcross_name_changestarttime <- STORE_F 0 | |
| (2270) wcross_name_changedonetime <- STORE_F 0 | |
| (2271) wcross_name_alpha_goal_prev <- STORE_F 0 | |
| (2272) wcross_name_alpha_goal_prev_prev <- STORE_F 0 | |
| (2273) wcross_resolution_goal_prev <- STORE_F 0 | |
| (2274) wcross_resolution_goal_prev_prev <- STORE_F 0 | |
| (2275) JUMP [endif1473] | |
| :endif1473 | |
| (2276) [entry] | |
| (2277) COND NextFrameCommand, [ontrue1474], [endif1476] | |
| :ontrue1474 | |
| (2278) [entry] | |
| (2279) call1475 <- CALL3 fn:localcmd params: #IMMEDIATE, NextFrameCommand, #IMMEDIATE, | |
| (2280) NextFrameCommand <- STORE_S nil | |
| (2281) JUMP [endif1476] | |
| :endif1476 | |
| (2282) [entry] | |
| (2283) bin1477 <- EQ_F cs_project_is_b0rked, 0 | |
| (2284) COND bin1477, [ontrue1478], [endif1497] | |
| :ontrue1478 | |
| (2285) [entry] | |
| (2286) w0 <- CALL1 fn:ftos params: autocvar_vid_conwidth, | |
| (2287) h0 <- CALL1 fn:ftos params: autocvar_vid_conheight, | |
| (2288) call1481 <- CALL2 fn:setproperty params: VF_ORIGIN, #IMMEDIATE, | |
| (2289) call1482 <- CALL2 fn:setproperty params: VF_ANGLES, #IMMEDIATE, | |
| (2290) call1483 <- CALL2 fn:setproperty params: VF_PERSPECTIVE, #IMMEDIATE, | |
| (2291) call1484 <- CALL1 fn:makevectors params: #IMMEDIATE, | |
| (2292) call1485 <- CALL2 fn:cvar_set params: #IMMEDIATE, #IMMEDIATE, | |
| (2293) call1486 <- CALL2 fn:cvar_set params: #IMMEDIATE, #IMMEDIATE, | |
| (2294) v1 <- CALL1 fn:cs_project params: v_forward, | |
| (2295) call1488 <- CALL2 fn:cvar_set params: #IMMEDIATE, #IMMEDIATE, | |
| (2296) call1489 <- CALL2 fn:cvar_set params: #IMMEDIATE, #IMMEDIATE, | |
| (2297) v2 <- CALL1 fn:cs_project params: v_forward, | |
| (2298) bin1491 <- EQ_V v1, v2 | |
| (2299) COND bin1491, [ontrue1492], [onfalse1493] | |
| :ontrue1492 | |
| (2300) [entry] | |
| (2301) cs_project_is_b0rked <- STORE_F 1 | |
| (2302) JUMP [endif1494] | |
| :onfalse1493 | |
| (2303) [entry] | |
| (2304) cs_project_is_b0rked <- STORE_F -1 | |
| (2305) JUMP [endif1494] | |
| :endif1494 | |
| (2306) [entry] | |
| (2307) call1495 <- CALL2 fn:cvar_set params: #IMMEDIATE, w0, | |
| (2308) call1496 <- CALL2 fn:cvar_set params: #IMMEDIATE, h0, | |
| (2309) JUMP [endif1497] | |
| :endif1497 | |
| (2310) [entry] | |
| (2311) COND autocvar__hud_configure, [ontrue1498], [endif1500] | |
| :ontrue1498 | |
| (2312) [entry] | |
| (2313) call1499 <- CALL0 fn:HUD_Panel_Mouse | |
| (2314) JUMP [endif1500] | |
| :endif1500 | |
| (2315) [entry] | |
| (2316) sce_value1504 <- STORE_F hud | |
| (2317) COND hud, [sce_other1502], [sce_merge1501] | |
| :sce_other1502 | |
| (2318) [entry] | |
| (2319) sce_value1504 <- NOT_F intermission | |
| (2320) JUMP [sce_merge1501] | |
| :sce_merge1501 | |
| (2321) [entry] | |
| (2322) sce_bool1505 <- AND sce_value1504, sce_value1504 | |
| (2323) COND sce_bool1505, [ontrue1506], [endif1531] | |
| :ontrue1506 | |
| (2324) [entry] | |
| (2325) bin1507 <- EQ_F hud, 10 | |
| (2326) COND bin1507, [ontrue1508], [onfalse1510] | |
| :ontrue1508 | |
| (2327) [entry] | |
| (2328) call1509 <- CALL0 fn:CSQC_SPIDER_HUD | |
| (2329) JUMP [endif1530] | |
| :onfalse1510 | |
| (2330) [entry] | |
| (2331) bin1511 <- EQ_F hud, 11 | |
| (2332) COND bin1511, [ontrue1512], [onfalse1514] | |
| :ontrue1512 | |
| (2333) [entry] | |
| (2334) call1513 <- CALL0 fn:CSQC_WAKIZASHI_HUD | |
| (2335) JUMP [endif1529] | |
| :onfalse1514 | |
| (2336) [entry] | |
| (2337) bin1515 <- EQ_F hud, 12 | |
| (2338) COND bin1515, [ontrue1516], [onfalse1518] | |
| :ontrue1516 | |
| (2339) [entry] | |
| (2340) call1517 <- CALL0 fn:CSQC_RAPTOR_HUD | |
| (2341) JUMP [endif1528] | |
| :onfalse1518 | |
| (2342) [entry] | |
| (2343) bin1519 <- EQ_F hud, 13 | |
| (2344) COND bin1519, [ontrue1520], [onfalse1522] | |
| :ontrue1520 | |
| (2345) [entry] | |
| (2346) call1521 <- CALL0 fn:CSQC_BUMBLE_HUD | |
| (2347) JUMP [endif1527] | |
| :onfalse1522 | |
| (2348) [entry] | |
| (2349) bin1523 <- EQ_F hud, 14 | |
| (2350) COND bin1523, [ontrue1524], [endif1526] | |
| :ontrue1524 | |
| (2351) [entry] | |
| (2352) call1525 <- CALL0 fn:CSQC_BUMBLE_GUN_HUD | |
| (2353) JUMP [endif1526] | |
| :endif1526 | |
| (2354) [entry] | |
| (2355) JUMP [endif1527] | |
| :endif1527 | |
| (2356) [entry] | |
| (2357) JUMP [endif1528] | |
| :endif1528 | |
| (2358) [entry] | |
| (2359) JUMP [endif1529] | |
| :endif1529 | |
| (2360) [entry] | |
| (2361) JUMP [endif1530] | |
| :endif1530 | |
| (2362) [entry] | |
| (2363) JUMP [endif1531] | |
| :endif1531 | |
| (2364) [entry] | |
| (2365) call1532 <- CALL0 fn:cl_notice_run | |
| (2366) call1533 <- CALL2 fn:setproperty params: VF_MIN, #IMMEDIATE, | |
| (2367) bin1534 <- MUL_VF '1 0 0', w | |
| (2368) bin1535 <- MUL_VF '0 1 0', h | |
| (2369) bin1536 <- ADD_V bin1534, bin1535 | |
| (2370) call1537 <- CALL2 fn:setproperty params: VF_SIZE, bin1536, | |
| (2371) RETURN | |
| endfunction CSQC_UpdateView | |
| function CSQC_ConsoleCommand | |
| 2 locals: | |
| command | |
| argc | |
| liferanges: | |
| command: string [param] locked @0 [0,1] | |
| argc: float [local] locked @0 [1,3] [6,7] | |
| call0: float [value] @0 [null] | |
| call1: float [return] @0 [2,3] | |
| call4: float [return] @0 [7,8] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) argc <- CALL1 fn:tokenize_console params: command, | |
| (2) call1 <- CALL1 fn:ConsoleCommand_macro_normal params: argc, | |
| (3) COND call1, [ontrue2], [onfalse3] | |
| :ontrue2 | |
| (4) [entry] | |
| (5) RETURN 1 | |
| :onfalse3 | |
| (6) [entry] | |
| (7) call4 <- CALL1 fn:ConsoleCommand_macro_movement params: argc, | |
| (8) COND call4, [ontrue5], [endif6] | |
| :ontrue5 | |
| (9) [entry] | |
| (10) RETURN 1 | |
| :endif6 | |
| (11) [entry] | |
| (12) JUMP [endif7] | |
| :endif7 | |
| (13) [entry] | |
| (14) RETURN 0 | |
| endfunction CSQC_ConsoleCommand | |
| function makevectors = builtin 2 | |
| function setorigin = builtin 3 | |
| function setmodel = builtin 4 | |
| function setsize = builtin 5 | |
| function break_builtin = builtin 7 | |
| function random = builtin 8 | |
| function sound = builtin 9 | |
| function normalize = builtin 10 | |
| function error = builtin 11 | |
| function objerror = builtin 12 | |
| function vlen = builtin 13 | |
| function vectoyaw = builtin 14 | |
| function spawn = builtin 15 | |
| function remove = builtin 16 | |
| function traceline = builtin 17 | |
| function find = builtin 19 | |
| function precache_sound = builtin 20 | |
| function precache_model = builtin 21 | |
| function findradius = builtin 23 | |
| function dprint = builtin 26 | |
| function ftos = builtin 27 | |
| function vtos = builtin 28 | |
| function coredump = builtin 29 | |
| function traceon = builtin 30 | |
| function traceoff = builtin 31 | |
| function eprint = builtin 32 | |
| function walkmove = builtin 33 | |
| function droptofloor = builtin 35 | |
| function lightstyle = builtin 36 | |
| function rint = builtin 37 | |
| function floor = builtin 38 | |
| function ceil = builtin 39 | |
| function checkbottom = builtin 41 | |
| function pointcontents = builtin 42 | |
| function fabs = builtin 44 | |
| function cvar = builtin 46 | |
| function localcmd = builtin 47 | |
| function nextent = builtin 48 | |
| function particle = builtin 49 | |
| function ChangeYaw = builtin 50 | |
| function vectoangles = builtin 52 | |
| function vectoangles2 = builtin 52 | |
| function sin = builtin 61 | |
| function cos = builtin 62 | |
| function sqrt = builtin 63 | |
| function changepitch = builtin 64 | |
| function tracetoss = builtin 65 | |
| function etos = builtin 66 | |
| function precache_file = builtin 69 | |
| function makestatic = builtin 70 | |
| function cvar_set = builtin 73 | |
| function ambientsound = builtin 75 | |
| function precache_model2 = builtin 76 | |
| function precache_sound2 = builtin 77 | |
| function precache_file2 = builtin 78 | |
| function stof = builtin 82 | |
| function tracebox = builtin 91 | |
| function randomvec = builtin 92 | |
| function getlight = builtin 93 | |
| function getlight2 = builtin 93 | |
| function registercvar = builtin 94 | |
| function min = builtin 95 | |
| function max = builtin 96 | |
| function bound = builtin 97 | |
| function pow = builtin 98 | |
| function findfloat = builtin 99 | |
| function checkextension = builtin 100 | |
| function fopen = builtin 111 | |
| function fclose = builtin 112 | |
| function fgets = builtin 113 | |
| function fputs = builtin 114 | |
| function strlen = builtin 115 | |
| function strcat = builtin 116 | |
| function substring = builtin 117 | |
| function stov = builtin 118 | |
| function strzone = builtin 119 | |
| function strunzone = builtin 120 | |
| function bitshift = builtin 219 | |
| function strstrofs = builtin 222 | |
| function str2chr = builtin 223 | |
| function chr2str = builtin 224 | |
| function strconv = builtin 225 | |
| function strpad = builtin 226 | |
| function infoadd = builtin 227 | |
| function infoget = builtin 228 | |
| function strncmp = builtin 229 | |
| function strcasecmp = builtin 230 | |
| function strncasecmp = builtin 231 | |
| function clearscene = builtin 301 | |
| function addentities = builtin 302 | |
| function addentity = builtin 303 | |
| function setproperty = builtin 304 | |
| function getproperty = builtin 310 | |
| function getpropertyvec = builtin 310 | |
| function renderscene = builtin 305 | |
| function adddynamiclight = builtin 306 | |
| function adddynamiclight2 = builtin 306 | |
| function R_BeginPolygon = builtin 307 | |
| function R_PolygonVertex = builtin 308 | |
| function R_EndPolygon = builtin 309 | |
| function cs_unproject = builtin 311 | |
| function cs_project = builtin 312 | |
| function drawline = builtin 316 | |
| function iscachedpic = builtin 317 | |
| function precache_pic = builtin 318 | |
| function precache_cubemap = builtin 318 | |
| function draw_getimagesize = builtin 319 | |
| function freepic = builtin 320 | |
| function drawcharacter = builtin 321 | |
| function drawstring = builtin 322 | |
| function drawpic = builtin 323 | |
| function drawfill = builtin 324 | |
| function drawsetcliparea = builtin 325 | |
| function drawresetcliparea = builtin 326 | |
| function drawcolorcodedstring = builtin 327 | |
| function drawcolorcodedstring2 = builtin 327 | |
| function getstatf = builtin 331 | |
| function getstati = builtin 332 | |
| function getstats = builtin 333 | |
| function setmodelindex = builtin 334 | |
| function modelnameforindex = builtin 335 | |
| function particleeffectnum = builtin 336 | |
| function trailparticles = builtin 337 | |
| function pointparticles = builtin 338 | |
| function centerprint = builtin 339 | |
| function print = builtin 340 | |
| function keynumtostring = builtin 341 | |
| function stringtokeynum = builtin 342 | |
| function getkeybind = builtin 343 | |
| function setcursormode = builtin 344 | |
| function getmousepos = builtin 345 | |
| function getinputstate = builtin 346 | |
| function setsensitivityscale = builtin 347 | |
| function runstandardplayerphysics = builtin 348 | |
| function getplayerkeyvalue = builtin 349 | |
| function isdemo = builtin 350 | |
| function isserver = builtin 351 | |
| function SetListener = builtin 352 | |
| function registercommand = builtin 353 | |
| function wasfreed = builtin 354 | |
| function serverkey = builtin 355 | |
| function ReadByte = builtin 361 | |
| function ReadChar = builtin 362 | |
| function ReadShort = builtin 363 | |
| function ReadLong = builtin 364 | |
| function ReadCoord = builtin 365 | |
| function ReadAngle = builtin 366 | |
| function ReadString = builtin 367 | |
| function ReadFloat = builtin 368 | |
| function copyentity = builtin 401 | |
| function findchain = builtin 403 | |
| function findchainfloat = builtin 404 | |
| function effect = builtin 405 | |
| function te_blood = builtin 406 | |
| function te_bloodshower = builtin 407 | |
| function te_explosionrgb = builtin 408 | |
| function te_particlecube = builtin 409 | |
| function te_particlerain = builtin 410 | |
| function te_particlesnow = builtin 411 | |
| function te_spark = builtin 412 | |
| function te_gunshotquad = builtin 413 | |
| function te_spikequad = builtin 414 | |
| function te_superspikequad = builtin 415 | |
| function te_explosionquad = builtin 416 | |
| function te_smallflash = builtin 417 | |
| function te_customflash = builtin 418 | |
| function te_gunshot = builtin 419 | |
| function te_spike = builtin 420 | |
| function te_superspike = builtin 421 | |
| function te_explosion = builtin 422 | |
| function te_tarexplosion = builtin 423 | |
| function te_wizspike = builtin 424 | |
| function te_knightspike = builtin 425 | |
| function te_lavasplash = builtin 426 | |
| function te_teleport = builtin 427 | |
| function te_explosion2 = builtin 428 | |
| function te_lightning1 = builtin 429 | |
| function te_lightning2 = builtin 430 | |
| function te_lightning3 = builtin 431 | |
| function te_beam = builtin 432 | |
| function vectorvectors = builtin 433 | |
| function te_plasmaburn = builtin 434 | |
| function getsurfacenumpoints = builtin 435 | |
| function getsurfacepoint = builtin 436 | |
| function getsurfacenormal = builtin 437 | |
| function getsurfacetexture = builtin 438 | |
| function getsurfacenearpoint = builtin 439 | |
| function getsurfaceclippedpoint = builtin 440 | |
| function tokenize = builtin 442 | |
| function argv = builtin 443 | |
| function setattachment = builtin 444 | |
| function search_begin = builtin 445 | |
| function search_end = builtin 446 | |
| function search_getsize = builtin 447 | |
| function search_getfilename = builtin 448 | |
| function cvar_string = builtin 449 | |
| function findflags = builtin 450 | |
| function findchainflags = builtin 451 | |
| function gettagindex = builtin 452 | |
| function gettaginfo = builtin 453 | |
| function te_flamejet = builtin 458 | |
| function entitybyindex = builtin 460 | |
| function buf_create = builtin 461 | |
| function buf_del = builtin 462 | |
| function buf_getsize = builtin 463 | |
| function buf_copy = builtin 464 | |
| function buf_sort = builtin 465 | |
| function buf_implode = builtin 466 | |
| function bufstr_get = builtin 467 | |
| function bufstr_set = builtin 468 | |
| function bufstr_add = builtin 469 | |
| function bufstr_free = builtin 470 | |
| function asin = builtin 472 | |
| function acos = builtin 473 | |
| function atan = builtin 474 | |
| function atan2 = builtin 475 | |
| function tan = builtin 476 | |
| function strippedstringlen = builtin 477 | |
| function strlennocol = builtin 477 | |
| function decolorizedstring = builtin 478 | |
| function strdecolorize = builtin 478 | |
| function strftime = builtin 479 | |
| function strtolower = builtin 481 | |
| function strtoupper = builtin 482 | |
| function cvar_defstring = builtin 483 | |
| function pointsound = builtin 484 | |
| function strreplace = builtin 485 | |
| function strireplace = builtin 486 | |
| function getsurfacepointattribute = builtin 487 | |
| function initparticlespawner = builtin 523 | |
| function resetparticle = builtin 524 | |
| function particletheme = builtin 525 | |
| function particlethemesave = builtin 526 | |
| function particlethemeupdate = builtin 526 | |
| function particlethemefree = builtin 527 | |
| function spawnparticle = builtin 528 | |
| function quickparticle = builtin 528 | |
| function delayedparticle = builtin 529 | |
| function quickdelayedparticle = builtin 529 | |
| function printparticle | |
| liferanges: | |
| call0: void [return] @0 [null] | |
| call1: string [value] callparam @0 [2,3] | |
| call2: string [value] callparam @0 [3,4] | |
| call3: void [return] @0 [null] | |
| call4: string [value] callparam @0 [5,6] | |
| call5: string [value] callparam @0 [6,7] | |
| call6: void [return] @0 [null] | |
| call7: string [value] callparam @0 [8,9] | |
| call8: string [value] callparam @0 [9,10] | |
| call9: void [return] @0 [null] | |
| call10: string [value] callparam @0 [11,12] | |
| call11: string [value] callparam @0 [12,13] | |
| call12: void [return] @0 [null] | |
| call13: string [value] callparam @0 [14,15] | |
| call14: string [value] callparam @0 [15,16] | |
| call15: void [return] @0 [null] | |
| call16: string [value] callparam @0 [17,18] | |
| call17: string [value] callparam @0 [18,19] | |
| call18: void [return] @0 [null] | |
| call19: string [value] callparam @0 [20,21] | |
| call20: string [value] callparam @0 [21,22] | |
| call21: void [return] @0 [null] | |
| call22: string [value] callparam @0 [23,24] | |
| call23: string [value] callparam @0 [24,25] | |
| call24: void [return] @0 [null] | |
| call25: string [value] callparam @0 [26,27] | |
| call26: string [value] callparam @0 [27,28] | |
| call27: void [return] @0 [null] | |
| call28: string [value] callparam @0 [29,30] | |
| call29: string [value] callparam @0 [30,31] | |
| call30: void [return] @0 [null] | |
| call31: string [value] callparam @0 [32,33] | |
| call32: string [value] callparam @0 [33,34] | |
| call33: void [return] @0 [null] | |
| call34: string [value] callparam @0 [35,36] | |
| call35: string [value] callparam @0 [36,37] | |
| call36: void [return] @0 [null] | |
| call37: string [value] callparam @0 [38,39] | |
| call38: string [value] callparam @0 [39,40] | |
| call39: void [return] @0 [null] | |
| call40: string [value] callparam @0 [41,42] | |
| call41: string [value] callparam @0 [42,43] | |
| call42: void [return] @0 [null] | |
| call43: string [value] callparam @0 [44,45] | |
| call44: string [value] callparam @0 [45,46] | |
| call45: void [return] @0 [null] | |
| call46: string [value] callparam @0 [47,48] | |
| call47: string [value] callparam @0 [48,49] | |
| call48: void [return] @0 [null] | |
| call49: string [value] callparam @0 [50,51] | |
| call50: string [value] callparam @0 [51,52] | |
| call51: void [return] @0 [null] | |
| call52: string [value] callparam @0 [53,54] | |
| call53: string [value] callparam @0 [54,55] | |
| call54: void [return] @0 [null] | |
| call55: string [value] callparam @0 [56,57] | |
| call56: string [value] callparam @0 [57,58] | |
| call57: void [return] @0 [null] | |
| call58: string [value] callparam @0 [59,60] | |
| call59: string [value] callparam @0 [60,61] | |
| call60: void [return] @0 [null] | |
| call61: string [value] callparam @0 [62,63] | |
| call62: string [value] callparam @0 [63,64] | |
| call63: void [return] @0 [null] | |
| call64: string [value] callparam @0 [65,66] | |
| call65: string [value] callparam @0 [66,67] | |
| call66: void [return] @0 [null] | |
| call67: string [value] callparam @0 [68,69] | |
| call68: string [value] callparam @0 [69,70] | |
| call69: void [return] @0 [null] | |
| call70: string [value] callparam @0 [71,72] | |
| call71: string [value] callparam @0 [72,73] | |
| call72: void [return] @0 [null] | |
| call73: string [value] callparam @0 [74,75] | |
| call74: string [value] callparam @0 [75,76] | |
| call75: void [return] @0 [null] | |
| call76: string [value] callparam @0 [77,78] | |
| call77: string [value] callparam @0 [78,79] | |
| call78: void [return] @0 [null] | |
| call79: string [value] callparam @0 [80,81] | |
| call80: string [value] callparam @0 [81,82] | |
| call81: void [return] @0 [null] | |
| call82: string [value] callparam @0 [83,84] | |
| call83: string [value] callparam @0 [84,85] | |
| call84: void [return] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:print params: #IMMEDIATE, | |
| (2) call1 <- CALL1 fn:ftos params: particle_type, | |
| (3) call2 <- CALL3 fn:strcat params: #IMMEDIATE, call1, #IMMEDIATE, | |
| (4) call3 <- CALL1 fn:print params: call2, | |
| (5) call4 <- CALL1 fn:ftos params: particle_blendmode, | |
| (6) call5 <- CALL3 fn:strcat params: #IMMEDIATE, call4, #IMMEDIATE, | |
| (7) call6 <- CALL1 fn:print params: call5, | |
| (8) call7 <- CALL1 fn:ftos params: particle_orientation, | |
| (9) call8 <- CALL3 fn:strcat params: #IMMEDIATE, call7, #IMMEDIATE, | |
| (10) call9 <- CALL1 fn:print params: call8, | |
| (11) call10 <- CALL1 fn:vtos params: particle_color1, | |
| (12) call11 <- CALL3 fn:strcat params: #IMMEDIATE, call10, #IMMEDIATE, | |
| (13) call12 <- CALL1 fn:print params: call11, | |
| (14) call13 <- CALL1 fn:vtos params: particle_color2, | |
| (15) call14 <- CALL3 fn:strcat params: #IMMEDIATE, call13, #IMMEDIATE, | |
| (16) call15 <- CALL1 fn:print params: call14, | |
| (17) call16 <- CALL1 fn:ftos params: particle_tex, | |
| (18) call17 <- CALL3 fn:strcat params: #IMMEDIATE, call16, #IMMEDIATE, | |
| (19) call18 <- CALL1 fn:print params: call17, | |
| (20) call19 <- CALL1 fn:ftos params: particle_size, | |
| (21) call20 <- CALL3 fn:strcat params: #IMMEDIATE, call19, #IMMEDIATE, | |
| (22) call21 <- CALL1 fn:print params: call20, | |
| (23) call22 <- CALL1 fn:ftos params: particle_sizeincrease, | |
| (24) call23 <- CALL3 fn:strcat params: #IMMEDIATE, call22, #IMMEDIATE, | |
| (25) call24 <- CALL1 fn:print params: call23, | |
| (26) call25 <- CALL1 fn:ftos params: particle_alpha, | |
| (27) call26 <- CALL3 fn:strcat params: #IMMEDIATE, call25, #IMMEDIATE, | |
| (28) call27 <- CALL1 fn:print params: call26, | |
| (29) call28 <- CALL1 fn:ftos params: particle_alphafade, | |
| (30) call29 <- CALL3 fn:strcat params: #IMMEDIATE, call28, #IMMEDIATE, | |
| (31) call30 <- CALL1 fn:print params: call29, | |
| (32) call31 <- CALL1 fn:ftos params: particle_time, | |
| (33) call32 <- CALL3 fn:strcat params: #IMMEDIATE, call31, #IMMEDIATE, | |
| (34) call33 <- CALL1 fn:print params: call32, | |
| (35) call34 <- CALL1 fn:ftos params: particle_gravity, | |
| (36) call35 <- CALL3 fn:strcat params: #IMMEDIATE, call34, #IMMEDIATE, | |
| (37) call36 <- CALL1 fn:print params: call35, | |
| (38) call37 <- CALL1 fn:ftos params: particle_bounce, | |
| (39) call38 <- CALL3 fn:strcat params: #IMMEDIATE, call37, #IMMEDIATE, | |
| (40) call39 <- CALL1 fn:print params: call38, | |
| (41) call40 <- CALL1 fn:ftos params: particle_airfriction, | |
| (42) call41 <- CALL3 fn:strcat params: #IMMEDIATE, call40, #IMMEDIATE, | |
| (43) call42 <- CALL1 fn:print params: call41, | |
| (44) call43 <- CALL1 fn:ftos params: particle_liquidfriction, | |
| (45) call44 <- CALL3 fn:strcat params: #IMMEDIATE, call43, #IMMEDIATE, | |
| (46) call45 <- CALL1 fn:print params: call44, | |
| (47) call46 <- CALL1 fn:ftos params: particle_originjitter, | |
| (48) call47 <- CALL3 fn:strcat params: #IMMEDIATE, call46, #IMMEDIATE, | |
| (49) call48 <- CALL1 fn:print params: call47, | |
| (50) call49 <- CALL1 fn:ftos params: particle_velocityjitter, | |
| (51) call50 <- CALL3 fn:strcat params: #IMMEDIATE, call49, #IMMEDIATE, | |
| (52) call51 <- CALL1 fn:print params: call50, | |
| (53) call52 <- CALL1 fn:ftos params: particle_qualityreduction, | |
| (54) call53 <- CALL3 fn:strcat params: #IMMEDIATE, call52, #IMMEDIATE, | |
| (55) call54 <- CALL1 fn:print params: call53, | |
| (56) call55 <- CALL1 fn:ftos params: particle_stretch, | |
| (57) call56 <- CALL3 fn:strcat params: #IMMEDIATE, call55, #IMMEDIATE, | |
| (58) call57 <- CALL1 fn:print params: call56, | |
| (59) call58 <- CALL1 fn:vtos params: particle_staincolor1, | |
| (60) call59 <- CALL3 fn:strcat params: #IMMEDIATE, call58, #IMMEDIATE, | |
| (61) call60 <- CALL1 fn:print params: call59, | |
| (62) call61 <- CALL1 fn:vtos params: particle_staincolor2, | |
| (63) call62 <- CALL3 fn:strcat params: #IMMEDIATE, call61, #IMMEDIATE, | |
| (64) call63 <- CALL1 fn:print params: call62, | |
| (65) call64 <- CALL1 fn:ftos params: particle_staintex, | |
| (66) call65 <- CALL3 fn:strcat params: #IMMEDIATE, call64, #IMMEDIATE, | |
| (67) call66 <- CALL1 fn:print params: call65, | |
| (68) call67 <- CALL1 fn:ftos params: particle_stainalpha, | |
| (69) call68 <- CALL3 fn:strcat params: #IMMEDIATE, call67, #IMMEDIATE, | |
| (70) call69 <- CALL1 fn:print params: call68, | |
| (71) call70 <- CALL1 fn:ftos params: particle_stainsize, | |
| (72) call71 <- CALL3 fn:strcat params: #IMMEDIATE, call70, #IMMEDIATE, | |
| (73) call72 <- CALL1 fn:print params: call71, | |
| (74) call73 <- CALL1 fn:ftos params: particle_delayspawn, | |
| (75) call74 <- CALL3 fn:strcat params: #IMMEDIATE, call73, #IMMEDIATE, | |
| (76) call75 <- CALL1 fn:print params: call74, | |
| (77) call76 <- CALL1 fn:ftos params: particle_delaycollision, | |
| (78) call77 <- CALL3 fn:strcat params: #IMMEDIATE, call76, #IMMEDIATE, | |
| (79) call78 <- CALL1 fn:print params: call77, | |
| (80) call79 <- CALL1 fn:ftos params: particle_angle, | |
| (81) call80 <- CALL3 fn:strcat params: #IMMEDIATE, call79, #IMMEDIATE, | |
| (82) call81 <- CALL1 fn:print params: call80, | |
| (83) call82 <- CALL1 fn:ftos params: particle_spin, | |
| (84) call83 <- CALL3 fn:strcat params: #IMMEDIATE, call82, #IMMEDIATE, | |
| (85) call84 <- CALL1 fn:print params: call83, | |
| (86) RETURN | |
| endfunction printparticle | |
| function setpause = builtin 532 | |
| function getentity = builtin 505 | |
| function getentityvec = builtin 505 | |
| function findfont = builtin 357 | |
| function loadfont = builtin 358 | |
| function stringwidth = builtin 328 | |
| function stringwidth_menu = builtin 469 | |
| function getkeybind_bindmap = builtin 343 | |
| function setkeybind_bindmap = builtin 631 | |
| function getbindmaps = builtin 632 | |
| function setbindmaps = builtin 633 | |
| function findkeysforcommand = builtin 611 | |
| function crypto_uri_postbuf = builtin 514 | |
| function V_CalcRefdef = builtin 641 | |
| function drawsubpic = builtin 329 | |
| function drawgetimagesize = builtin 319 | |
| function getsurfacenumtriangles = builtin 629 | |
| function getsurfacetriangle = builtin 630 | |
| function sprintf = builtin 628 | |
| function gettime = builtin 520 | |
| function tokenizebyseparator = builtin 480 | |
| function tokenize_console = builtin 515 | |
| function argv_start_index = builtin 516 | |
| function argv_end_index = builtin 517 | |
| function sound7 = builtin 9 | |
| function getsoundtime = builtin 534 | |
| function soundlength = builtin 535 | |
| function num_for_edict = builtin 513 | |
| function cvar_type = builtin 496 | |
| function crc16 = builtin 495 | |
| function uri_escape = builtin 511 | |
| function uri_unescape = builtin 512 | |
| function digest_hex = builtin 640 | |
| function log = builtin 533 | |
| function skel_create = builtin 264 | |
| function skel_build = builtin 265 | |
| function skel_get_numbones = builtin 266 | |
| function skel_get_bonename = builtin 267 | |
| function skel_get_boneparent = builtin 268 | |
| function skel_find_bone = builtin 269 | |
| function skel_get_bonerel = builtin 270 | |
| function skel_get_boneabs = builtin 271 | |
| function skel_set_bone = builtin 272 | |
| function skel_mul_bone = builtin 273 | |
| function skel_mul_bones = builtin 274 | |
| function skel_copybones = builtin 275 | |
| function skel_delete = builtin 276 | |
| function frameforname = builtin 277 | |
| function frameduration = builtin 278 | |
| function example_skel_findbonegroup | |
| 9 locals: | |
| skel | |
| bonenum | |
| g1 | |
| g2 | |
| g3 | |
| g4 | |
| g5 | |
| g6 | |
| bonename | |
| liferanges: | |
| skel: float [param] locked @0 [0,8] [11,13] [16,18] [21,23] [26,28] [31,33] [36,38] | |
| bonenum: float [param] locked @1 [0,8] [11,13] [16,18] [21,23] [26,28] [31,33] [36,38] | |
| g1: string [param] locked @2 [0,8] [11,13] [16,18] [21,23] [26,28] [31,33] [36,38] | |
| g2: string [param] locked @3 [0,8] [11,13] [16,18] [21,23] [26,28] [31,33] [36,38] | |
| g3: string [param] locked @4 [0,8] [11,13] [16,18] [21,23] [26,28] [31,33] [36,38] | |
| g4: string [param] locked @5 [0,8] [11,13] [16,18] [21,23] [26,28] [31,33] [36,38] | |
| g5: string [param] locked @6 [0,8] [11,13] [16,18] [21,23] [26,28] [31,33] [36,38] | |
| g6: string [param] locked @7 [0,8] [11,13] [16,18] [21,23] [26,28] [31,33] [36,38] | |
| bonename: string [local] @0 [6,8] [11,13] [16,18] [21,23] [26,28] [31,32] | |
| bin1: float [value] @0 [3,4] | |
| call4: string [value] @0 [null] | |
| bin5: float [value] @1 [7,8] | |
| bin8: float [value] @1 [12,13] | |
| bin11: float [value] @1 [17,18] | |
| bin14: float [value] @1 [22,23] | |
| bin17: float [value] @1 [27,28] | |
| bin20: float [value] @0 [32,33] | |
| call23: float [value] @0 [null] | |
| life passes: 3 | |
| :entry | |
| (0) [entry] | |
| (1) JUMP [pre_loop_cond0] | |
| :pre_loop_cond0 | |
| (2) [entry] | |
| (3) bin1 <- GE bonenum, 0 | |
| (4) COND bin1, [loop_body3], [after_loop2] | |
| :loop_body3 | |
| (5) [entry] | |
| (6) bonename <- CALL2 fn:skel_get_bonename params: skel, bonenum, | |
| (7) bin5 <- EQ_S bonename, g1 | |
| (8) COND bin5, [ontrue6], [endif7] | |
| :ontrue6 | |
| (9) [entry] | |
| (10) RETURN 1 | |
| :endif7 | |
| (11) [entry] | |
| (12) bin8 <- EQ_S bonename, g2 | |
| (13) COND bin8, [ontrue9], [endif10] | |
| :ontrue9 | |
| (14) [entry] | |
| (15) RETURN 2 | |
| :endif10 | |
| (16) [entry] | |
| (17) bin11 <- EQ_S bonename, g3 | |
| (18) COND bin11, [ontrue12], [endif13] | |
| :ontrue12 | |
| (19) [entry] | |
| (20) RETURN 3 | |
| :endif13 | |
| (21) [entry] | |
| (22) bin14 <- EQ_S bonename, g4 | |
| (23) COND bin14, [ontrue15], [endif16] | |
| :ontrue15 | |
| (24) [entry] | |
| (25) RETURN 4 | |
| :endif16 | |
| (26) [entry] | |
| (27) bin17 <- EQ_S bonename, g5 | |
| (28) COND bin17, [ontrue18], [endif19] | |
| :ontrue18 | |
| (29) [entry] | |
| (30) RETURN 5 | |
| :endif19 | |
| (31) [entry] | |
| (32) bin20 <- EQ_S bonename, g6 | |
| (33) COND bin20, [ontrue21], [endif22] | |
| :ontrue21 | |
| (34) [entry] | |
| (35) RETURN 6 | |
| :endif22 | |
| (36) [entry] | |
| (37) bonenum <- CALL2 fn:skel_get_boneparent params: skel, bonenum, | |
| (38) JUMP [pre_loop_cond0] | |
| :after_loop2 | |
| (39) [entry] | |
| (40) RETURN 0 | |
| endfunction example_skel_findbonegroup | |
| function example_skel_player_setup | |
| liferanges: | |
| efa0: pointer [value] locked @0 [1,4] | |
| efv1: float [value] callparam @0 [2,3] | |
| call2: float [return] @0 [3,4] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efa0 <- ADDRESS self, skeletonindex | |
| (2) efv1 <- FIELD_F self, modelindex | |
| (3) call2 <- CALL1 fn:skel_create params: efv1, | |
| (4) efa0 <- STOREP_F call2 | |
| (5) RETURN | |
| endfunction example_skel_player_setup | |
| function example_skel_player_update_begin | |
| 3 locals: | |
| animmodelindex | |
| framegroup | |
| framegroupstarttime | |
| liferanges: | |
| animmodelindex: float [param] locked @0 [0,24] | |
| framegroup: float [param] locked @1 [0,2] | |
| framegroupstarttime: float [param] locked @2 [0,10] | |
| efa0: pointer [value] @0 [1,2] | |
| efa1: pointer [value] @0 [3,4] | |
| efa2: pointer [value] @0 [5,6] | |
| efa3: pointer [value] @0 [7,8] | |
| efa4: pointer [value] @0 [9,10] | |
| efa5: pointer [value] @0 [11,12] | |
| efa6: pointer [value] @0 [13,14] | |
| efa7: pointer [value] @0 [15,16] | |
| efa8: pointer [value] @0 [17,18] | |
| efa9: pointer [value] @0 [19,20] | |
| efa10: pointer [value] @0 [21,22] | |
| efv11: float [value] callparam @0 [23,24] | |
| call12: float [return] @0 [24,24] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efa0 <- ADDRESS self, frame | |
| (2) efa0 <- STOREP_F framegroup | |
| (3) efa1 <- ADDRESS self, frame2 | |
| (4) efa1 <- STOREP_F 0 | |
| (5) efa2 <- ADDRESS self, frame3 | |
| (6) efa2 <- STOREP_F 0 | |
| (7) efa3 <- ADDRESS self, frame4 | |
| (8) efa3 <- STOREP_F 0 | |
| (9) efa4 <- ADDRESS self, frame1time | |
| (10) efa4 <- STOREP_F framegroupstarttime | |
| (11) efa5 <- ADDRESS self, frame2time | |
| (12) efa5 <- STOREP_F 0 | |
| (13) efa6 <- ADDRESS self, frame3time | |
| (14) efa6 <- STOREP_F 0 | |
| (15) efa7 <- ADDRESS self, frame4time | |
| (16) efa7 <- STOREP_F 0 | |
| (17) efa8 <- ADDRESS self, lerpfrac | |
| (18) efa8 <- STOREP_F 0 | |
| (19) efa9 <- ADDRESS self, lerpfrac3 | |
| (20) efa9 <- STOREP_F 0 | |
| (21) efa10 <- ADDRESS self, lerpfrac4 | |
| (22) efa10 <- STOREP_F 0 | |
| (23) efv11 <- FIELD_F self, skeletonindex | |
| (24) call12 <- CALL6 fn:skel_build params: efv11, self, animmodelindex, #IMMEDIATE, #IMMEDIATE, #IMMEDIATE, | |
| (25) RETURN | |
| endfunction example_skel_player_update_begin | |
| function example_skel_player_update_applyoverride | |
| 9 locals: | |
| animmodelindex | |
| framegroup | |
| framegroupstarttime | |
| blendalpha | |
| groupbonename | |
| excludegroupname1 | |
| excludegroupname2 | |
| bonenum | |
| numbones | |
| liferanges: | |
| animmodelindex: float [param] locked @0 [0,43] | |
| framegroup: float [param] locked @1 [0,2] | |
| framegroupstarttime: float [param] locked @2 [0,10] | |
| blendalpha: float [param] locked @3 [0,43] | |
| groupbonename: string [param] locked @4 [0,43] | |
| excludegroupname1: string [param] locked @5 [0,43] | |
| excludegroupname2: string [param] locked @6 [0,43] | |
| bonenum: float [local] locked @1 [23,43] | |
| numbones: float [local] locked @2 [25,43] | |
| efa0: pointer [value] @0 [1,2] | |
| efa1: pointer [value] @0 [3,4] | |
| efa2: pointer [value] @0 [5,6] | |
| efa3: pointer [value] @0 [7,8] | |
| efa4: pointer [value] @0 [9,10] | |
| efa5: pointer [value] @0 [11,12] | |
| efa6: pointer [value] @0 [13,14] | |
| efa7: pointer [value] @0 [15,16] | |
| efa8: pointer [value] @0 [17,18] | |
| efa9: pointer [value] @0 [19,20] | |
| efa10: pointer [value] @0 [21,22] | |
| efv11: float [value] callparam @0 [24,25] | |
| call12: float [value] @0 [null] | |
| bin14: float [value] @0 [28,29] | |
| efv17: float [value] callparam @0 [31,32] | |
| call18: float [return] @0 [32,33] | |
| bin19: float [value] @0 [33,34] | |
| efv21: float [value] callparam @0 [36,39] | |
| bin22: float [value] callparam @0 [37,39] | |
| bin23: float [value] callparam @0 [38,39] | |
| call24: float [return] @0 [39,39] | |
| bin26: float [value] @0 [null] | |
| life passes: 3 | |
| :entry | |
| (0) [entry] | |
| (1) efa0 <- ADDRESS self, frame | |
| (2) efa0 <- STOREP_F framegroup | |
| (3) efa1 <- ADDRESS self, frame2 | |
| (4) efa1 <- STOREP_F 0 | |
| (5) efa2 <- ADDRESS self, frame3 | |
| (6) efa2 <- STOREP_F 0 | |
| (7) efa3 <- ADDRESS self, frame4 | |
| (8) efa3 <- STOREP_F 0 | |
| (9) efa4 <- ADDRESS self, frame1time | |
| (10) efa4 <- STOREP_F framegroupstarttime | |
| (11) efa5 <- ADDRESS self, frame2time | |
| (12) efa5 <- STOREP_F 0 | |
| (13) efa6 <- ADDRESS self, frame3time | |
| (14) efa6 <- STOREP_F 0 | |
| (15) efa7 <- ADDRESS self, frame4time | |
| (16) efa7 <- STOREP_F 0 | |
| (17) efa8 <- ADDRESS self, lerpfrac | |
| (18) efa8 <- STOREP_F 0 | |
| (19) efa9 <- ADDRESS self, lerpfrac3 | |
| (20) efa9 <- STOREP_F 0 | |
| (21) efa10 <- ADDRESS self, lerpfrac4 | |
| (22) efa10 <- STOREP_F 0 | |
| (23) bonenum <- STORE_F 0 | |
| (24) efv11 <- FIELD_F self, skeletonindex | |
| (25) numbones <- CALL1 fn:skel_get_numbones params: efv11, | |
| (26) JUMP [pre_loop_cond13] | |
| :pre_loop_cond13 | |
| (27) [entry] | |
| (28) bin14 <- LT bonenum, numbones | |
| (29) COND bin14, [loop_body16], [after_loop15] | |
| :loop_body16 | |
| (30) [entry] | |
| (31) efv17 <- FIELD_F self, skeletonindex | |
| (32) call18 <- CALL8 fn:example_skel_findbonegroup params: efv17, bonenum, groupbonename, excludegroupname1, excludegroupname2, #IMMEDIATE, #IMMEDIATE, #IMMEDIATE, | |
| (33) bin19 <- EQ_F call18, 1 | |
| (34) COND bin19, [ontrue20], [endif25] | |
| :ontrue20 | |
| (35) [entry] | |
| (36) efv21 <- FIELD_F self, skeletonindex | |
| (37) bin22 <- SUB_F 1, blendalpha | |
| (38) bin23 <- ADD_F bonenum, 1 | |
| (39) call24 <- CALL6 fn:skel_build params: efv21, self, animmodelindex, bin22, bonenum, bin23, | |
| (40) JUMP [endif25] | |
| :endif25 | |
| (41) [entry] | |
| (42) bonenum <- ADD_F bonenum, 1 | |
| (43) JUMP [pre_loop_cond13] | |
| :after_loop15 | |
| (44) [entry] | |
| (45) RETURN | |
| endfunction example_skel_player_update_applyoverride | |
| function example_skel_player_update_eyetarget | |
| 22 locals: | |
| eyetarget | |
| bonename | |
| bonenum | |
| ang | |
| oldforward | |
| oldright | |
| oldup | |
| relforward | |
| relright | |
| relup | |
| relorg | |
| boneforward | |
| boneright | |
| boneup | |
| boneorg | |
| parentforward | |
| parentright | |
| parentup | |
| parentorg | |
| u | |
| v | |
| modeleyetarget | |
| liferanges: | |
| eyetarget: vector [param] locked @0 [0,5] [8,13] | |
| eyetarget_x: @0 [0,5] [8,13] | |
| eyetarget_y: @0 [0,5] [8,13] | |
| eyetarget_z: @0 [0,5] [8,13] | |
| bonename: string [param] locked @3 [0,2] | |
| bonenum: float [local] locked @3 [3,5] [8,43] | |
| ang: vector [local] @0 [39,41] | |
| ang_x: @0 [39,41] | |
| ang_y: @0 [39,41] | |
| ang_z: @0 [39,41] | |
| oldforward: vector [local] locked @4 [9,44] | |
| oldforward_x: @0 [9,44] | |
| oldforward_y: @0 [9,44] | |
| oldforward_z: @0 [9,44] | |
| oldright: vector [local] locked @7 [10,45] | |
| oldright_x: @0 [10,45] | |
| oldright_y: @0 [10,45] | |
| oldright_z: @0 [10,45] | |
| oldup: vector [local] locked @10 [11,46] | |
| oldup_x: @0 [11,46] | |
| oldup_y: @0 [11,46] | |
| oldup_z: @0 [11,46] | |
| relforward: vector [local] @0 [20,20] | |
| relforward_x: @0 | |
| relforward_y: @0 | |
| relforward_z: @0 | |
| relright: vector [local] @0 [21,21] | |
| relright_x: @0 | |
| relright_y: @0 | |
| relright_z: @0 | |
| relup: vector [local] locked @0 [22,39] | |
| relup_x: @0 [22,39] | |
| relup_y: @0 [22,39] | |
| relup_z: @0 [22,39] | |
| relorg: vector [local] locked @13 [19,43] | |
| relorg_x: @0 [19,43] | |
| relorg_y: @0 [19,43] | |
| relorg_z: @0 [19,43] | |
| boneforward: vector [local] @0 [25,25] | |
| boneforward_x: @0 | |
| boneforward_y: @0 | |
| boneforward_z: @0 | |
| boneright: vector [local] @0 [26,26] | |
| boneright_x: @0 | |
| boneright_y: @0 | |
| boneright_z: @0 | |
| boneup: vector [local] @0 [27,27] | |
| boneup_x: @0 | |
| boneup_y: @0 | |
| boneup_z: @0 | |
| boneorg: vector [local] locked @16 [24,35] | |
| boneorg_x: @0 [24,35] | |
| boneorg_y: @0 [24,35] | |
| boneorg_z: @0 [24,35] | |
| parentforward: vector [local] @0 [32,36] | |
| parentforward_x: @0 [32,36] | |
| parentforward_y: @0 [32,36] | |
| parentforward_z: @0 [32,36] | |
| parentright: vector [local] @3 [33,37] | |
| parentright_x: @0 [33,37] | |
| parentright_y: @0 [33,37] | |
| parentright_z: @0 [33,37] | |
| parentup: vector [local] @6 [34,38] | |
| parentup_x: @0 [34,38] | |
| parentup_y: @0 [34,38] | |
| parentup_z: @0 [34,38] | |
| parentorg: vector [local] @0 [31,31] | |
| parentorg_x: @0 | |
| parentorg_y: @0 | |
| parentorg_z: @0 | |
| u: vector [local] @9 [35,38] | |
| u_x: @0 [35,38] | |
| u_y: @0 [35,38] | |
| u_z: @0 [35,38] | |
| v: vector [local] @0 [13,17] [36,39] | |
| v_x: @0 [13,17] [36,39] | |
| v_y: @0 [13,17] [37,39] | |
| v_z: @0 [13,17] [38,39] | |
| modeleyetarget: vector [local] locked @19 [14,35] | |
| modeleyetarget_x: @0 [14,35] | |
| modeleyetarget_y: @0 [16,35] | |
| modeleyetarget_z: @0 [17,35] | |
| efv0: float [value] callparam @0 [1,2] | |
| call1: float [return] @0 [2,3] | |
| bin2: float [value] @0 [null] | |
| bin3: float [value] @0 [4,5] | |
| efv6: vector [value] @0 [12,13] | |
| efv6_x: @0 [12,13] | |
| efv6_y: @0 [12,13] | |
| efv6_z: @0 [12,13] | |
| bin7: vector [value] @0 [null] | |
| bin7_x: @0 | |
| bin7_y: @0 | |
| bin7_z: @0 | |
| bin8: float [value] @0 [null] | |
| bin9: float [value] @3 [15,16] | |
| bin10: float [value] @0 [null] | |
| bin11: float [value] @0 [null] | |
| efv12: float [value] callparam @0 [18,19] | |
| call13: vector [value] @0 [null] | |
| call13_x: @0 | |
| call13_y: @0 | |
| call13_z: @0 | |
| efv14: float [value] callparam @0 [23,24] | |
| call15: vector [value] @0 [null] | |
| call15_x: @0 | |
| call15_y: @0 | |
| call15_z: @0 | |
| efv16: float [value] locked @22 [28,31] | |
| efv17: float [value] callparam @0 [29,30] | |
| call18: float [value] callparam @0 [30,31] | |
| call19: vector [value] @0 [null] | |
| call19_x: @0 | |
| call19_y: @0 | |
| call19_z: @0 | |
| bin20: vector [value] @0 [null] | |
| bin20_x: @0 | |
| bin20_y: @0 | |
| bin20_z: @0 | |
| bin21: float [value] @0 [null] | |
| bin22: float [value] @0 [null] | |
| bin23: float [value] @0 [null] | |
| call24: vector [value] @0 [null] | |
| call24_x: @0 | |
| call24_y: @0 | |
| call24_z: @0 | |
| bin25: float [value] @0 [null] | |
| call26: void [return] @0 [null] | |
| efv27: float [value] callparam @0 [42,43] | |
| call28: void [return] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efv0 <- FIELD_F self, skeletonindex | |
| (2) call1 <- CALL2 fn:skel_find_bone params: efv0, bonename, | |
| (3) bonenum <- SUB_F call1, 1 | |
| (4) bin3 <- LT bonenum, 0 | |
| (5) COND bin3, [ontrue4], [endif5] | |
| :ontrue4 | |
| (6) [entry] | |
| (7) RETURN | |
| :endif5 | |
| (8) [entry] | |
| (9) oldforward <- STORE_V v_forward | |
| (10) oldright <- STORE_V v_right | |
| (11) oldup <- STORE_V v_up | |
| (12) efv6 <- FIELD_V self, origin | |
| (13) v <- SUB_V eyetarget, efv6 | |
| (14) modeleyetarget_x <- MUL_V v, v_forward | |
| (15) bin9 <- MUL_V v, v_right | |
| (16) modeleyetarget_y <- SUB_F 0, bin9 | |
| (17) modeleyetarget_z <- MUL_V v, v_up | |
| (18) efv12 <- FIELD_F self, skeletonindex | |
| (19) relorg <- CALL2 fn:skel_get_bonerel params: efv12, bonenum, | |
| (20) relforward <- STORE_V v_forward | |
| (21) relright <- STORE_V v_right | |
| (22) relup <- STORE_V v_up | |
| (23) efv14 <- FIELD_F self, skeletonindex | |
| (24) boneorg <- CALL2 fn:skel_get_boneabs params: efv14, bonenum, | |
| (25) boneforward <- STORE_V v_forward | |
| (26) boneright <- STORE_V v_right | |
| (27) boneup <- STORE_V v_up | |
| (28) efv16 <- FIELD_F self, skeletonindex | |
| (29) efv17 <- FIELD_F self, skeletonindex | |
| (30) call18 <- CALL2 fn:skel_get_boneparent params: efv17, bonenum, | |
| (31) parentorg <- CALL2 fn:skel_get_boneabs params: efv16, call18, | |
| (32) parentforward <- STORE_V v_forward | |
| (33) parentright <- STORE_V v_right | |
| (34) parentup <- STORE_V v_up | |
| (35) u <- SUB_V modeleyetarget, boneorg | |
| (36) v_x <- MUL_V u, parentforward | |
| (37) v_y <- MUL_V u, parentright | |
| (38) v_z <- MUL_V u, parentup | |
| (39) ang <- CALL2 fn:vectoangles2 params: v, relup, | |
| (40) ang_x <- SUB_F 0, ang_x | |
| (41) call26 <- CALL1 fn:makevectors params: ang, | |
| (42) efv27 <- FIELD_F self, skeletonindex | |
| (43) call28 <- CALL3 fn:skel_set_bone params: efv27, bonenum, relorg, | |
| (44) v_forward <- STORE_V oldforward | |
| (45) v_right <- STORE_V oldright | |
| (46) v_up <- STORE_V oldup | |
| (47) RETURN | |
| endfunction example_skel_player_update_eyetarget | |
| function example_skel_player_delete | |
| liferanges: | |
| efv0: float [value] callparam @0 [1,2] | |
| call1: void [return] @0 [null] | |
| efa2: pointer [value] @0 [3,4] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efv0 <- FIELD_F self, skeletonindex | |
| (2) call1 <- CALL1 fn:skel_delete params: efv0, | |
| (3) efa2 <- ADDRESS self, skeletonindex | |
| (4) efa2 <- STOREP_F 0 | |
| (5) RETURN | |
| endfunction example_skel_player_delete | |
| function numentityfields = builtin 497 | |
| function entityfieldname = builtin 498 | |
| function entityfieldtype = builtin 499 | |
| function getentityfieldstring = builtin 500 | |
| function putentityfieldstring = builtin 501 | |
| function loadfromdata = builtin 530 | |
| function loadfromfile = builtin 531 | |
| function callfunction = builtin 606 | |
| function writetofile = builtin 607 | |
| function isfunction = builtin 608 | |
| function parseentitydata = builtin 609 | |
| function ReadPicture = builtin 502 | |
| function boxparticles = builtin 503 | |
| function checkpvs = builtin 241 | |
| function fixedvectoangles | |
| 2 locals: | |
| a | |
| ang | |
| liferanges: | |
| a: vector [param] locked @0 [0,1] | |
| a_x: @0 [0,1] | |
| a_y: @0 [0,1] | |
| a_z: @0 [0,1] | |
| ang: vector [local] @0 [1,3] | |
| ang_x: @0 [1,3] | |
| ang_y: @0 [1,3] | |
| ang_z: @0 [1,3] | |
| call0: vector [value] @0 [null] | |
| call0_x: @0 | |
| call0_y: @0 | |
| call0_z: @0 | |
| bin1: float [value] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) ang <- CALL1 fn:vectoangles params: a, | |
| (2) ang_x <- SUB_F 0, ang_x | |
| (3) RETURN ang | |
| endfunction fixedvectoangles | |
| function fixedvectoangles2 | |
| 3 locals: | |
| a | |
| b | |
| ang | |
| liferanges: | |
| a: vector [param] locked @0 [0,1] | |
| a_x: @0 [0,1] | |
| a_y: @0 [0,1] | |
| a_z: @0 [0,1] | |
| b: vector [param] locked @3 [0,1] | |
| b_x: @0 [0,1] | |
| b_y: @0 [0,1] | |
| b_z: @0 [0,1] | |
| ang: vector [local] @0 [1,3] | |
| ang_x: @0 [1,3] | |
| ang_y: @0 [1,3] | |
| ang_z: @0 [1,3] | |
| call0: vector [value] @0 [null] | |
| call0_x: @0 | |
| call0_y: @0 | |
| call0_z: @0 | |
| bin1: float [value] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) ang <- CALL2 fn:vectoangles2 params: a, b, | |
| (2) ang_x <- SUB_F 0, ang_x | |
| (3) RETURN ang | |
| endfunction fixedvectoangles2 | |
| function AnglesTransform_Apply | |
| 2 locals: | |
| transform | |
| v | |
| liferanges: | |
| transform: vector [param] locked @0 [0,1] | |
| transform_x: @0 [0,1] | |
| transform_y: @0 [0,1] | |
| transform_z: @0 [0,1] | |
| v: vector [param] locked @3 [0,7] | |
| v_x: @0 [0,3] | |
| v_y: @0 [0,3] | |
| v_z: @0 [0,7] | |
| call0: void [return] @0 [null] | |
| bin1: vector [value] @0 [2,5] | |
| bin1_x: @0 [2,5] | |
| bin1_y: @0 [2,5] | |
| bin1_z: @0 [2,5] | |
| bin2: float [value] @3 [3,5] | |
| bin3: vector [value] @4 [4,5] | |
| bin3_x: @0 [4,5] | |
| bin3_y: @0 [4,5] | |
| bin3_z: @0 [4,5] | |
| bin4: vector [value] @0 [5,7] | |
| bin4_x: @0 [5,7] | |
| bin4_y: @0 [5,7] | |
| bin4_z: @0 [5,7] | |
| bin5: vector [value] @4 [6,7] | |
| bin5_x: @0 [6,7] | |
| bin5_y: @0 [6,7] | |
| bin5_z: @0 [6,7] | |
| bin6: vector [value] @0 [7,8] | |
| bin6_x: @0 [7,8] | |
| bin6_y: @0 [7,8] | |
| bin6_z: @0 [7,8] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:makevectors params: transform, | |
| (2) bin1 <- MUL_VF v_forward, v_x | |
| (3) bin2 <- SUB_F 0, v_y | |
| (4) bin3 <- MUL_VF v_right, bin2 | |
| (5) bin4 <- ADD_V bin1, bin3 | |
| (6) bin5 <- MUL_VF v_up, v_z | |
| (7) bin6 <- ADD_V bin4, bin5 | |
| (8) RETURN bin6 | |
| endfunction AnglesTransform_Apply | |
| function AnglesTransform_Multiply | |
| 4 locals: | |
| t1 | |
| t2 | |
| m_forward | |
| m_up | |
| liferanges: | |
| t1: vector [param] locked @0 [0,5] | |
| t1_x: @0 [0,5] | |
| t1_y: @0 [0,5] | |
| t1_z: @0 [0,5] | |
| t2: vector [param] locked @3 [0,1] | |
| t2_x: @0 [0,1] | |
| t2_y: @0 [0,1] | |
| t2_z: @0 [0,1] | |
| m_forward: vector [local] locked @3 [2,6] | |
| m_forward_x: @0 [2,6] | |
| m_forward_y: @0 [2,6] | |
| m_forward_z: @0 [2,6] | |
| m_up: vector [local] locked @6 [3,6] | |
| m_up_x: @0 [3,6] | |
| m_up_y: @0 [3,6] | |
| m_up_z: @0 [3,6] | |
| call0: void [return] @0 [null] | |
| call1: vector [value] @0 [null] | |
| call1_x: @0 | |
| call1_y: @0 | |
| call1_z: @0 | |
| call2: vector [value] @0 [null] | |
| call2_x: @0 | |
| call2_y: @0 | |
| call2_z: @0 | |
| call3: vector [return] @0 [6,7] | |
| call3_x: @0 [6,7] | |
| call3_y: @0 [6,7] | |
| call3_z: @0 [6,7] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:makevectors params: t2, | |
| (2) m_forward <- STORE_V v_forward | |
| (3) m_up <- STORE_V v_up | |
| (4) m_forward <- CALL2 fn:AnglesTransform_Apply params: t1, m_forward, | |
| (5) m_up <- CALL2 fn:AnglesTransform_Apply params: t1, m_up, | |
| (6) call3 <- CALL2 fn:fixedvectoangles2 params: m_forward, m_up, | |
| (7) RETURN call3 | |
| endfunction AnglesTransform_Multiply | |
| function AnglesTransform_Invert | |
| 3 locals: | |
| transform | |
| i_forward | |
| i_up | |
| liferanges: | |
| transform: vector [param] locked @0 [0,1] | |
| transform_x: @0 [0,1] | |
| transform_y: @0 [0,1] | |
| transform_z: @0 [0,1] | |
| i_forward: vector [local] @0 [2,8] | |
| i_forward_x: @0 [2,8] | |
| i_forward_y: @0 [3,8] | |
| i_forward_z: @0 [4,8] | |
| i_up: vector [local] @3 [5,8] | |
| i_up_x: @0 [5,8] | |
| i_up_y: @0 [6,8] | |
| i_up_z: @0 [7,8] | |
| call0: void [return] @0 [null] | |
| bin1: float [value] @0 [null] | |
| bin2: float [value] @0 [null] | |
| call3: vector [return] @0 [8,9] | |
| call3_x: @0 [8,9] | |
| call3_y: @0 [8,9] | |
| call3_z: @0 [8,9] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:makevectors params: transform, | |
| (2) i_forward_x <- STORE_F v_forward_x | |
| (3) i_forward_y <- SUB_F 0, v_right_x | |
| (4) i_forward_z <- STORE_F v_up_x | |
| (5) i_up_x <- STORE_F v_forward_z | |
| (6) i_up_y <- SUB_F 0, v_right_z | |
| (7) i_up_z <- STORE_F v_up_z | |
| (8) call3 <- CALL2 fn:fixedvectoangles2 params: i_forward, i_up, | |
| (9) RETURN call3 | |
| endfunction AnglesTransform_Invert | |
| function AnglesTransform_TurnDirectionFU | |
| 1 locals: | |
| transform | |
| liferanges: | |
| transform: vector [param] locked @0 [0,4] | |
| transform_x: @0 [0,4] | |
| transform_y: @0 [0,4] | |
| transform_z: @0 [0,4] | |
| bin0: float [value] @0 [null] | |
| bin1: float [value] @0 [null] | |
| bin2: float [value] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) transform_x <- SUB_F 0, transform_x | |
| (2) transform_y <- ADD_F 180, transform_y | |
| (3) transform_z <- SUB_F 180, transform_z | |
| (4) RETURN transform | |
| endfunction AnglesTransform_TurnDirectionFU | |
| function AnglesTransform_TurnDirectionFR | |
| 1 locals: | |
| transform | |
| liferanges: | |
| transform: vector [param] locked @0 [0,4] | |
| transform_x: @0 [0,4] | |
| transform_y: @0 [0,4] | |
| transform_z: @0 [0,4] | |
| bin0: float [value] @0 [null] | |
| bin1: float [value] @0 [null] | |
| bin2: float [value] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) transform_x <- SUB_F 0, transform_x | |
| (2) transform_y <- ADD_F 180, transform_y | |
| (3) transform_z <- SUB_F 0, transform_z | |
| (4) RETURN transform | |
| endfunction AnglesTransform_TurnDirectionFR | |
| function AnglesTransform_RightDivide | |
| 2 locals: | |
| to_transform | |
| from_transform | |
| liferanges: | |
| to_transform: vector [param] locked @0 [0,2] | |
| to_transform_x: @0 [0,2] | |
| to_transform_y: @0 [0,2] | |
| to_transform_z: @0 [0,2] | |
| from_transform: vector [param] locked @3 [0,1] | |
| from_transform_x: @0 [0,1] | |
| from_transform_y: @0 [0,1] | |
| from_transform_z: @0 [0,1] | |
| call0: vector [value] callparam @0 [1,2] | |
| call0_x: @0 [1,2] | |
| call0_y: @0 [1,2] | |
| call0_z: @0 [1,2] | |
| call1: vector [return] @0 [2,3] | |
| call1_x: @0 [2,3] | |
| call1_y: @0 [2,3] | |
| call1_z: @0 [2,3] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:AnglesTransform_Invert params: from_transform, | |
| (2) call1 <- CALL2 fn:AnglesTransform_Multiply params: to_transform, call0, | |
| (3) RETURN call1 | |
| endfunction AnglesTransform_RightDivide | |
| function AnglesTransform_LeftDivide | |
| 2 locals: | |
| from_transform | |
| to_transform | |
| liferanges: | |
| from_transform: vector [param] locked @0 [0,1] | |
| from_transform_x: @0 [0,1] | |
| from_transform_y: @0 [0,1] | |
| from_transform_z: @0 [0,1] | |
| to_transform: vector [param] locked @3 [0,2] | |
| to_transform_x: @0 [0,2] | |
| to_transform_y: @0 [0,2] | |
| to_transform_z: @0 [0,2] | |
| call0: vector [value] callparam @0 [1,2] | |
| call0_x: @0 [1,2] | |
| call0_y: @0 [1,2] | |
| call0_z: @0 [1,2] | |
| call1: vector [return] @0 [2,3] | |
| call1_x: @0 [2,3] | |
| call1_y: @0 [2,3] | |
| call1_z: @0 [2,3] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:AnglesTransform_Invert params: from_transform, | |
| (2) call1 <- CALL2 fn:AnglesTransform_Multiply params: call0, to_transform, | |
| (3) RETURN call1 | |
| endfunction AnglesTransform_LeftDivide | |
| function AnglesTransform_Normalize | |
| 3 locals: | |
| t | |
| minimize_roll | |
| need_flip | |
| liferanges: | |
| t: vector [param] locked @0 [0,66] | |
| t_x: @0 [0,66] | |
| t_y: @0 [0,66] | |
| t_z: @0 [0,66] | |
| minimize_roll: float [param] locked @3 [0,13] | |
| need_flip: float [local] @0 [22,23] [32,35] | |
| bin0: float [value] callparam @0 [1,2] | |
| call1: float [return] @0 [2,3] | |
| bin2: float [value] @0 [3,4] | |
| bin3: float [value] @0 [null] | |
| bin4: float [value] callparam @0 [5,6] | |
| call5: float [return] @0 [6,7] | |
| bin6: float [value] @0 [7,8] | |
| bin7: float [value] @0 [null] | |
| bin8: float [value] callparam @0 [9,10] | |
| call9: float [return] @0 [10,11] | |
| bin10: float [value] @0 [11,12] | |
| bin11: float [value] @0 [null] | |
| bin14: float [value] @0 [15,17] | |
| bin16: float [value] @0 [null] | |
| sce_value17: float [value] @1 [16,17] [19,22] | |
| sce_bool18: float [value] @0 [null] | |
| bin21: float [value] @0 [25,27] | |
| bin23: float [value] @0 [null] | |
| sce_value24: float [value] @1 [26,27] [29,32] | |
| sce_bool25: float [value] @0 [null] | |
| bin28: float [value] @0 [37,38] | |
| bin30: float [value] @0 [null] | |
| bin32: float [value] @0 [null] | |
| bin34: float [value] @0 [46,47] | |
| binst36: float [value] @0 [null] | |
| binst38: float [value] @0 [null] | |
| bin40: float [value] @0 [55,56] | |
| binst42: float [value] @0 [null] | |
| binst44: float [value] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bin0 <- DIV t_x, 360 | |
| (2) call1 <- CALL1 fn:rint params: bin0, | |
| (3) bin2 <- MUL_F 360, call1 | |
| (4) t_x <- SUB_F t_x, bin2 | |
| (5) bin4 <- DIV t_y, 360 | |
| (6) call5 <- CALL1 fn:rint params: bin4, | |
| (7) bin6 <- MUL_F 360, call5 | |
| (8) t_y <- SUB_F t_y, bin6 | |
| (9) bin8 <- DIV t_z, 360 | |
| (10) call9 <- CALL1 fn:rint params: bin8, | |
| (11) bin10 <- MUL_F 360, call9 | |
| (12) t_z <- SUB_F t_z, bin10 | |
| (13) COND minimize_roll, [ontrue12], [onfalse19] | |
| :ontrue12 | |
| (14) [entry] | |
| (15) bin14 <- GT t_z, 90 | |
| (16) sce_value17 <- STORE_F bin14 | |
| (17) COND bin14, [sce_merge13], [sce_other15] | |
| :sce_other15 | |
| (18) [entry] | |
| (19) sce_value17 <- LE t_z, -90 | |
| (20) JUMP [sce_merge13] | |
| :sce_merge13 | |
| (21) [entry] | |
| (22) need_flip <- AND sce_value17, sce_value17 | |
| (23) JUMP [endif26] | |
| :onfalse19 | |
| (24) [entry] | |
| (25) bin21 <- GT t_x, 90 | |
| (26) sce_value24 <- STORE_F bin21 | |
| (27) COND bin21, [sce_merge20], [sce_other22] | |
| :sce_other22 | |
| (28) [entry] | |
| (29) sce_value24 <- LT t_x, -90 | |
| (30) JUMP [sce_merge20] | |
| :sce_merge20 | |
| (31) [entry] | |
| (32) need_flip <- AND sce_value24, sce_value24 | |
| (33) JUMP [endif26] | |
| :endif26 | |
| (34) [entry] | |
| (35) COND need_flip, [ontrue27], [endif46] | |
| :ontrue27 | |
| (36) [entry] | |
| (37) bin28 <- GE t_x, 0 | |
| (38) COND bin28, [ontrue29], [onfalse31] | |
| :ontrue29 | |
| (39) [entry] | |
| (40) t_x <- SUB_F 180, t_x | |
| (41) JUMP [endif33] | |
| :onfalse31 | |
| (42) [entry] | |
| (43) t_x <- SUB_F -180, t_x | |
| (44) JUMP [endif33] | |
| :endif33 | |
| (45) [entry] | |
| (46) bin34 <- GT t_y, 0 | |
| (47) COND bin34, [ontrue35], [onfalse37] | |
| :ontrue35 | |
| (48) [entry] | |
| (49) t_y <- SUB_F t_y, 180 | |
| (50) JUMP [endif39] | |
| :onfalse37 | |
| (51) [entry] | |
| (52) t_y <- ADD_F t_y, 180 | |
| (53) JUMP [endif39] | |
| :endif39 | |
| (54) [entry] | |
| (55) bin40 <- GT t_z, 0 | |
| (56) COND bin40, [ontrue41], [onfalse43] | |
| :ontrue41 | |
| (57) [entry] | |
| (58) t_z <- SUB_F t_z, 180 | |
| (59) JUMP [endif45] | |
| :onfalse43 | |
| (60) [entry] | |
| (61) t_z <- ADD_F t_z, 180 | |
| (62) JUMP [endif45] | |
| :endif45 | |
| (63) [entry] | |
| (64) JUMP [endif46] | |
| :endif46 | |
| (65) [entry] | |
| (66) RETURN t | |
| endfunction AnglesTransform_Normalize | |
| function AnglesTransform_ApplyToAngles | |
| 2 locals: | |
| transform | |
| v | |
| liferanges: | |
| transform: vector [param] locked @0 [0,2] | |
| transform_x: @0 [0,2] | |
| transform_y: @0 [0,2] | |
| transform_z: @0 [0,2] | |
| v: vector [param] locked @3 [0,4] | |
| v_x: @0 [0,4] | |
| v_y: @0 [0,4] | |
| v_z: @0 [0,4] | |
| bin0: float [value] @0 [null] | |
| call1: vector [value] @0 [null] | |
| call1_x: @0 | |
| call1_y: @0 | |
| call1_z: @0 | |
| bin2: float [value] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) v_x <- SUB_F 0, v_x | |
| (2) v <- CALL2 fn:AnglesTransform_Multiply params: transform, v, | |
| (3) v_x <- SUB_F 0, v_x | |
| (4) RETURN v | |
| endfunction AnglesTransform_ApplyToAngles | |
| function AnglesTransform_ApplyToVAngles | |
| 2 locals: | |
| transform | |
| v | |
| liferanges: | |
| transform: vector [param] locked @0 [0,1] | |
| transform_x: @0 [0,1] | |
| transform_y: @0 [0,1] | |
| transform_z: @0 [0,1] | |
| v: vector [param] locked @3 [0,2] | |
| v_x: @0 [0,2] | |
| v_y: @0 [0,2] | |
| v_z: @0 [0,2] | |
| call0: vector [value] @0 [null] | |
| call0_x: @0 | |
| call0_y: @0 | |
| call0_z: @0 | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) v <- CALL2 fn:AnglesTransform_Multiply params: transform, v, | |
| (2) RETURN v | |
| endfunction AnglesTransform_ApplyToVAngles | |
| function AnglesTransform_FromAngles | |
| 1 locals: | |
| v | |
| liferanges: | |
| v: vector [param] locked @0 [0,2] | |
| v_x: @0 [0,2] | |
| v_y: @0 [0,2] | |
| v_z: @0 [0,2] | |
| bin0: float [value] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) v_x <- SUB_F 0, v_x | |
| (2) RETURN v | |
| endfunction AnglesTransform_FromAngles | |
| function AnglesTransform_ToAngles | |
| 1 locals: | |
| v | |
| liferanges: | |
| v: vector [param] locked @0 [0,2] | |
| v_x: @0 [0,2] | |
| v_y: @0 [0,2] | |
| v_z: @0 [0,2] | |
| bin0: float [value] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) v_x <- SUB_F 0, v_x | |
| (2) RETURN v | |
| endfunction AnglesTransform_ToAngles | |
| function AnglesTransform_FromVAngles | |
| 1 locals: | |
| v | |
| liferanges: | |
| v: vector [param] locked @0 [0,1] | |
| v_x: @0 [0,1] | |
| v_y: @0 [0,1] | |
| v_z: @0 [0,1] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) RETURN v | |
| endfunction AnglesTransform_FromVAngles | |
| function AnglesTransform_ToVAngles | |
| 1 locals: | |
| v | |
| liferanges: | |
| v: vector [param] locked @0 [0,1] | |
| v_x: @0 [0,1] | |
| v_y: @0 [0,1] | |
| v_z: @0 [0,1] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) RETURN v | |
| endfunction AnglesTransform_ToVAngles | |
| function AnglesTransform_Multiply_GetPostShift | |
| 4 locals: | |
| t0 | |
| st0 | |
| t1 | |
| st1 | |
| liferanges: | |
| t0: vector [param] locked @0 [0,1] | |
| t0_x: @0 [0,1] | |
| t0_y: @0 [0,1] | |
| t0_z: @0 [0,1] | |
| st0: vector [param] locked @3 [0,2] | |
| st0_x: @0 [0,2] | |
| st0_y: @0 [0,2] | |
| st0_z: @0 [0,2] | |
| t1: vector [param] locked @6 [0,0] | |
| t1_x: @0 | |
| t1_y: @0 | |
| t1_z: @0 | |
| st1: vector [param] locked @9 [0,1] | |
| st1_x: @0 [0,1] | |
| st1_y: @0 [0,1] | |
| st1_z: @0 [0,1] | |
| call0: vector [return] @0 [1,2] | |
| call0_x: @0 [1,2] | |
| call0_y: @0 [1,2] | |
| call0_z: @0 [1,2] | |
| bin1: vector [value] @0 [2,3] | |
| bin1_x: @0 [2,3] | |
| bin1_y: @0 [2,3] | |
| bin1_z: @0 [2,3] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL2 fn:AnglesTransform_Apply params: t0, st1, | |
| (2) bin1 <- ADD_V st0, call0 | |
| (3) RETURN bin1 | |
| endfunction AnglesTransform_Multiply_GetPostShift | |
| function AnglesTransform_PrePostShift_GetPostShift | |
| 3 locals: | |
| sf | |
| t | |
| st | |
| liferanges: | |
| sf: vector [param] locked @0 [0,1] | |
| sf_x: @0 [0,1] | |
| sf_y: @0 [0,1] | |
| sf_z: @0 [0,1] | |
| t: vector [param] locked @3 [0,1] | |
| t_x: @0 [0,1] | |
| t_y: @0 [0,1] | |
| t_z: @0 [0,1] | |
| st: vector [param] locked @6 [0,2] | |
| st_x: @0 [0,2] | |
| st_y: @0 [0,2] | |
| st_z: @0 [0,2] | |
| call0: vector [return] @0 [1,2] | |
| call0_x: @0 [1,2] | |
| call0_y: @0 [1,2] | |
| call0_z: @0 [1,2] | |
| bin1: vector [value] @0 [2,3] | |
| bin1_x: @0 [2,3] | |
| bin1_y: @0 [2,3] | |
| bin1_z: @0 [2,3] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL2 fn:AnglesTransform_Apply params: t, sf, | |
| (2) bin1 <- SUB_V st, call0 | |
| (3) RETURN bin1 | |
| endfunction AnglesTransform_PrePostShift_GetPostShift | |
| function fpclassify | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,2] [5,7] [10,11] | |
| call0: float [return] @0 [1,2] | |
| call3: float [return] @0 [6,7] | |
| bin6: float [value] @0 [11,12] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:isnan params: x, | |
| (2) COND call0, [ontrue1], [endif2] | |
| :ontrue1 | |
| (3) [entry] | |
| (4) RETURN 0 | |
| :endif2 | |
| (5) [entry] | |
| (6) call3 <- CALL1 fn:isinf params: x, | |
| (7) COND call3, [ontrue4], [endif5] | |
| :ontrue4 | |
| (8) [entry] | |
| (9) RETURN 1 | |
| :endif5 | |
| (10) [entry] | |
| (11) bin6 <- EQ_F x, 0 | |
| (12) COND bin6, [ontrue7], [endif8] | |
| :ontrue7 | |
| (13) [entry] | |
| (14) RETURN 2 | |
| :endif8 | |
| (15) [entry] | |
| (16) RETURN 4 | |
| endfunction fpclassify | |
| function isfinite | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,5] | |
| call1: float [return] @0 [1,3] | |
| call3: float [value] @0 [null] | |
| sce_value4: float [value] @0 [2,3] [5,8] | |
| sce_bool5: float [value] @0 [8,9] | |
| unary6: float [value] @0 [9,10] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call1 <- CALL1 fn:isnan params: x, | |
| (2) sce_value4 <- STORE_F call1 | |
| (3) COND call1, [sce_merge0], [sce_other2] | |
| :sce_other2 | |
| (4) [entry] | |
| (5) sce_value4 <- CALL1 fn:isinf params: x, | |
| (6) JUMP [sce_merge0] | |
| :sce_merge0 | |
| (7) [entry] | |
| (8) sce_bool5 <- AND sce_value4, sce_value4 | |
| (9) unary6 <- NOT_F sce_bool5 | |
| (10) RETURN unary6 | |
| endfunction isfinite | |
| function isinf | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,6] | |
| bin1: float [value] @0 [1,3] | |
| bin3: float [value] @0 [5,6] | |
| bin4: float [value] @0 [null] | |
| sce_value5: float [value] @1 [2,3] [6,9] | |
| sce_bool6: float [value] @0 [9,10] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bin1 <- NE_F x, 0 | |
| (2) sce_value5 <- STORE_F bin1 | |
| (3) COND bin1, [sce_other2], [sce_merge0] | |
| :sce_other2 | |
| (4) [entry] | |
| (5) bin3 <- ADD_F x, x | |
| (6) sce_value5 <- EQ_F bin3, x | |
| (7) JUMP [sce_merge0] | |
| :sce_merge0 | |
| (8) [entry] | |
| (9) sce_bool6 <- AND sce_value5, sce_value5 | |
| (10) RETURN sce_bool6 | |
| endfunction isinf | |
| function isnan | |
| 2 locals: | |
| x | |
| y | |
| liferanges: | |
| x: float [param] locked @0 [0,2] | |
| y: float [local] @0 [1,2] | |
| bin0: float [value] @0 [2,3] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) y <- STORE_F x | |
| (2) bin0 <- NE_F x, y | |
| (3) RETURN bin0 | |
| endfunction isnan | |
| function isnormal | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| call0: float [return] @0 [1,2] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:isfinite params: x, | |
| (2) RETURN call0 | |
| endfunction isnormal | |
| function signbit | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| bin0: float [value] @0 [1,2] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bin0 <- LT x, 0 | |
| (2) RETURN bin0 | |
| endfunction signbit | |
| function acosh | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,4] | |
| bin0: float [value] @0 [1,2] | |
| bin1: float [value] callparam @0 [2,3] | |
| call2: float [return] @0 [3,4] | |
| bin3: float [value] callparam @0 [4,5] | |
| call4: float [return] @0 [5,6] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bin0 <- MUL_F x, x | |
| (2) bin1 <- SUB_F bin0, 1 | |
| (3) call2 <- CALL1 fn:sqrt params: bin1, | |
| (4) bin3 <- ADD_F x, call2 | |
| (5) call4 <- CALL1 fn:log params: bin3, | |
| (6) RETURN call4 | |
| endfunction acosh | |
| function asinh | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,4] | |
| bin0: float [value] @0 [1,2] | |
| bin1: float [value] callparam @0 [2,3] | |
| call2: float [return] @0 [3,4] | |
| bin3: float [value] callparam @0 [4,5] | |
| call4: float [return] @0 [5,6] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bin0 <- MUL_F x, x | |
| (2) bin1 <- ADD_F bin0, 1 | |
| (3) call2 <- CALL1 fn:sqrt params: bin1, | |
| (4) bin3 <- ADD_F x, call2 | |
| (5) call4 <- CALL1 fn:log params: bin3, | |
| (6) RETURN call4 | |
| endfunction asinh | |
| function atanh | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,2] | |
| bin0: float [value] @0 [1,3] | |
| bin1: float [value] @1 [2,3] | |
| bin2: float [value] callparam @0 [3,4] | |
| call3: float [return] @0 [4,5] | |
| bin4: float [value] @0 [5,6] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bin0 <- ADD_F 1, x | |
| (2) bin1 <- SUB_F 1, x | |
| (3) bin2 <- DIV bin0, bin1 | |
| (4) call3 <- CALL1 fn:log params: bin2, | |
| (5) bin4 <- MUL_F 0.5, call3 | |
| (6) RETURN bin4 | |
| endfunction atanh | |
| function cosh | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,2] | |
| call0: float [value] locked @1 [1,4] | |
| bin1: float [value] callparam @0 [2,3] | |
| call2: float [return] @0 [3,4] | |
| bin3: float [value] @0 [4,5] | |
| bin4: float [value] @0 [5,6] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:exp params: x, | |
| (2) bin1 <- SUB_F 0, x | |
| (3) call2 <- CALL1 fn:exp params: bin1, | |
| (4) bin3 <- ADD_F call0, call2 | |
| (5) bin4 <- MUL_F 0.5, bin3 | |
| (6) RETURN bin4 | |
| endfunction cosh | |
| function sinh | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,2] | |
| call0: float [value] locked @1 [1,4] | |
| bin1: float [value] callparam @0 [2,3] | |
| call2: float [return] @0 [3,4] | |
| bin3: float [value] @0 [4,5] | |
| bin4: float [value] @0 [5,6] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:exp params: x, | |
| (2) bin1 <- SUB_F 0, x | |
| (3) call2 <- CALL1 fn:exp params: bin1, | |
| (4) bin3 <- SUB_F call0, call2 | |
| (5) bin4 <- MUL_F 0.5, bin3 | |
| (6) RETURN bin4 | |
| endfunction sinh | |
| function tanh | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,2] | |
| call0: float [value] locked @1 [1,3] | |
| call1: float [return] @0 [2,3] | |
| bin2: float [value] @0 [3,4] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:sinh params: x, | |
| (2) call1 <- CALL1 fn:cosh params: x, | |
| (3) bin2 <- DIV call0, call1 | |
| (4) RETURN bin2 | |
| endfunction tanh | |
| function exp | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| call0: float [return] @0 [1,2] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL2 fn:pow params: #IMMEDIATE, x, | |
| (2) RETURN call0 | |
| endfunction exp | |
| function exp2 | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| call0: float [return] @0 [1,2] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL2 fn:pow params: #IMMEDIATE, x, | |
| (2) RETURN call0 | |
| endfunction exp2 | |
| function expm1 | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| call0: float [return] @0 [1,2] | |
| bin1: float [value] @0 [2,3] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:exp params: x, | |
| (2) bin1 <- SUB_F call0, 1 | |
| (3) RETURN bin1 | |
| endfunction expm1 | |
| function frexp | |
| 2 locals: | |
| x | |
| v | |
| liferanges: | |
| x: float [param] locked @0 [0,5] | |
| v: vector [local] locked @1 [1,6] | |
| v_x: @0 [5,6] | |
| v_y: @0 [3,6] | |
| v_z: @0 [1,6] | |
| call0: float [return] @0 [2,3] | |
| bin1: float [value] @0 [null] | |
| call2: float [return] @0 [4,5] | |
| bin3: float [value] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) v_z <- STORE_F 0 | |
| (2) call0 <- CALL1 fn:ilogb params: x, | |
| (3) v_y <- ADD_F call0, 1 | |
| (4) call2 <- CALL1 fn:exp2 params: v_y, | |
| (5) v_x <- DIV x, call2 | |
| (6) RETURN v | |
| endfunction frexp | |
| function ilogb | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| call0: float [value] callparam @0 [1,2] | |
| call1: float [value] callparam @0 [2,3] | |
| call2: float [return] @0 [3,4] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:fabs params: x, | |
| (2) call1 <- CALL1 fn:log2 params: call0, | |
| (3) call2 <- CALL1 fn:floor params: call1, | |
| (4) RETURN call2 | |
| endfunction ilogb | |
| function ldexp | |
| 2 locals: | |
| x | |
| e | |
| liferanges: | |
| x: float [param] locked @0 [0,2] | |
| e: float [param] locked @1 [0,1] | |
| call0: float [return] @0 [1,2] | |
| bin1: float [value] @0 [2,3] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL2 fn:pow params: #IMMEDIATE, e, | |
| (2) bin1 <- MUL_F x, call0 | |
| (3) RETURN bin1 | |
| endfunction ldexp | |
| function log10 | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| call0: float [return] @0 [1,2] | |
| bin1: float [value] @0 [2,3] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:log params: x, | |
| (2) bin1 <- MUL_F call0, 0.434294 | |
| (3) RETURN bin1 | |
| endfunction log10 | |
| function log1p | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| bin0: float [value] callparam @0 [1,2] | |
| call1: float [return] @0 [2,3] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bin0 <- ADD_F x, 1 | |
| (2) call1 <- CALL1 fn:log params: bin0, | |
| (3) RETURN call1 | |
| endfunction log1p | |
| function log2 | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| call0: float [return] @0 [1,2] | |
| bin1: float [value] @0 [2,3] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:log params: x, | |
| (2) bin1 <- MUL_F call0, 1.4427 | |
| (3) RETURN bin1 | |
| endfunction log2 | |
| function logb | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| call0: float [value] callparam @0 [1,2] | |
| call1: float [value] callparam @0 [2,3] | |
| call2: float [return] @0 [3,4] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:fabs params: x, | |
| (2) call1 <- CALL1 fn:log2 params: call0, | |
| (3) call2 <- CALL1 fn:floor params: call1, | |
| (4) RETURN call2 | |
| endfunction logb | |
| function modf | |
| 1 locals: | |
| f | |
| liferanges: | |
| f: float [param] locked @0 [0,4] | |
| call0: float [return] @0 [1,2] | |
| bin1: float [value] @0 [2,4] | |
| bin2: vector [value] locked @1 [3,6] | |
| bin2_x: locked @0 [3,6] | |
| bin2_y: locked @0 [3,6] | |
| bin2_z: locked @0 [3,6] | |
| call3: float [return] @0 [4,6] | |
| bin4: vector [value] @1 [5,6] | |
| bin4_x: @0 [5,6] | |
| bin4_y: @0 [5,6] | |
| bin4_z: @0 [5,6] | |
| bin5: vector [value] @1 [6,7] | |
| bin5_x: @0 [6,7] | |
| bin5_y: @0 [6,7] | |
| bin5_z: @0 [6,7] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:trunc params: f, | |
| (2) bin1 <- SUB_F f, call0 | |
| (3) bin2 <- MUL_VF '1 0 0', bin1 | |
| (4) call3 <- CALL1 fn:trunc params: f, | |
| (5) bin4 <- MUL_VF '0 1 0', call3 | |
| (6) bin5 <- ADD_V bin2, bin4 | |
| (7) RETURN bin5 | |
| endfunction modf | |
| function scalbn | |
| 2 locals: | |
| x | |
| n | |
| liferanges: | |
| x: float [param] locked @0 [0,2] | |
| n: float [param] locked @1 [0,1] | |
| call0: float [return] @0 [1,2] | |
| bin1: float [value] @0 [2,3] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL2 fn:pow params: #IMMEDIATE, n, | |
| (2) bin1 <- MUL_F x, call0 | |
| (3) RETURN bin1 | |
| endfunction scalbn | |
| function cbrt | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,3] | |
| call0: float [value] callparam @0 [1,2] | |
| call1: float [value] callparam @0 [2,3] | |
| call2: float [return] @0 [3,4] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:fabs params: x, | |
| (2) call1 <- CALL2 fn:pow params: call0, #IMMEDIATE, | |
| (3) call2 <- CALL2 fn:copysign params: call1, x, | |
| (4) RETURN call2 | |
| endfunction cbrt | |
| function hypot | |
| 2 locals: | |
| x | |
| y | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| y: float [param] locked @1 [0,2] | |
| bin0: float [value] @0 [1,3] | |
| bin1: float [value] @1 [2,3] | |
| bin2: float [value] callparam @0 [3,4] | |
| call3: float [return] @0 [4,5] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bin0 <- MUL_F x, x | |
| (2) bin1 <- MUL_F y, y | |
| (3) bin2 <- ADD_F bin0, bin1 | |
| (4) call3 <- CALL1 fn:sqrt params: bin2, | |
| (5) RETURN call3 | |
| endfunction hypot | |
| function erf | |
| 2 locals: | |
| x | |
| y | |
| liferanges: | |
| x: float [param] locked @0 [0,12] | |
| y: float [local] @0 [1,6] | |
| bin0: float [value] @0 [null] | |
| bin1: float [value] @1 [2,5] | |
| bin2: float [value] @2 [3,4] | |
| bin3: float [value] @2 [4,5] | |
| bin4: float [value] @1 [5,8] | |
| bin5: float [value] @0 [6,7] | |
| bin6: float [value] @0 [7,8] | |
| bin7: float [value] callparam @0 [8,9] | |
| call8: float [return] @0 [9,10] | |
| bin9: float [value] callparam @0 [10,11] | |
| call10: float [value] callparam @0 [11,12] | |
| call11: float [return] @0 [12,13] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) y <- MUL_F x, x | |
| (2) bin1 <- SUB_F 0, y | |
| (3) bin2 <- MUL_F 0.140012, y | |
| (4) bin3 <- ADD_F 1.27324, bin2 | |
| (5) bin4 <- MUL_F bin1, bin3 | |
| (6) bin5 <- MUL_F 0.140012, y | |
| (7) bin6 <- ADD_F 1, bin5 | |
| (8) bin7 <- DIV bin4, bin6 | |
| (9) call8 <- CALL1 fn:exp params: bin7, | |
| (10) bin9 <- SUB_F 1, call8 | |
| (11) call10 <- CALL1 fn:sqrt params: bin9, | |
| (12) call11 <- CALL2 fn:copysign params: call10, x, | |
| (13) RETURN call11 | |
| endfunction erf | |
| function erfc | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| call0: float [return] @0 [1,2] | |
| bin1: float [value] @0 [2,3] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:erf params: x, | |
| (2) bin1 <- SUB_F 1, call0 | |
| (3) RETURN bin1 | |
| endfunction erfc | |
| function lgamma | |
| 2 locals: | |
| x | |
| v | |
| liferanges: | |
| x: float [param] locked @0 [0,6] [10,20] [25,31] [46,52] [56,63] | |
| v: vector [local] locked @1 [30,45] | |
| v_x: @0 [30,45] | |
| v_y: @0 [30,45] | |
| v_z: @0 [32,38] [44,45] | |
| call0: float [return] @0 [1,2] | |
| call2: float [return] @0 [4,6] | |
| bin3: vector [value] locked @1 [5,8] | |
| bin3_x: locked @0 [5,8] | |
| bin3_y: locked @0 [5,8] | |
| bin3_z: locked @0 [5,8] | |
| call4: float [return] @0 [6,8] | |
| bin5: vector [value] @0 [7,8] | |
| bin5_x: @0 [7,8] | |
| bin5_y: @0 [7,8] | |
| bin5_z: @0 [7,8] | |
| bin6: vector [value] @0 [8,9] | |
| bin6_x: @0 [8,9] | |
| bin6_y: @0 [8,9] | |
| bin6_z: @0 [8,9] | |
| bin9: float [value] @0 [11,13] | |
| call11: float [return] @0 [15,16] | |
| bin12: float [value] @0 [null] | |
| sce_value13: float [value] @3 [12,13] [16,19] | |
| sce_bool14: float [value] @0 [19,20] | |
| call16: float [return] @0 [22,24] | |
| bin17: vector [value] @0 [23,24] | |
| bin17_x: @0 [23,24] | |
| bin17_y: @0 [23,24] | |
| bin17_z: @0 [23,24] | |
| bin19: float [value] @0 [26,27] | |
| bin21: float [value] callparam @0 [29,30] | |
| call22: vector [value] @0 [null] | |
| call22_x: @0 | |
| call22_y: @0 | |
| call22_z: @0 | |
| bin23: float [value] callparam @0 [31,32] | |
| call24: float [value] @0 [null] | |
| call25: float [value] locked @0 [33,36] | |
| call26: float [value] callparam @0 [34,35] | |
| call27: float [return] @0 [35,36] | |
| bin28: float [value] @0 [36,37] | |
| bin29: float [value] @0 [null] | |
| bin30: float [value] @0 [38,39] | |
| bin32: float [value] @0 [null] | |
| bin35: float [value] @0 [47,48] | |
| bin37: float [value] callparam @0 [50,51] | |
| call38: vector [value] locked @1 [51,54] | |
| call38_x: locked @0 [51,54] | |
| call38_y: locked @0 [51,54] | |
| call38_z: locked @0 [51,54] | |
| call39: float [return] @0 [52,54] | |
| bin40: vector [value] @0 [53,54] | |
| bin40_x: @0 [53,54] | |
| bin40_y: @0 [53,54] | |
| bin40_z: @0 [53,54] | |
| bin41: vector [value] @0 [54,55] | |
| bin41_x: @0 [54,55] | |
| bin41_y: @0 [54,55] | |
| bin41_z: @0 [54,55] | |
| binst43: float [value] @0 [null] | |
| bin44: float [value] callparam @0 [58,59] | |
| call45: float [return] @0 [59,60] | |
| bin46: float [value] locked @1 [60,64] | |
| call47: float [return] @0 [61,62] | |
| bin48: float [value] @0 [62,63] | |
| bin49: float [value] @0 [63,64] | |
| bin50: float [value] @0 [64,66] | |
| bin51: vector [value] @3 [65,66] | |
| bin51_x: @0 [65,66] | |
| bin51_y: @0 [65,66] | |
| bin51_z: @0 [65,66] | |
| bin52: vector [value] @0 [66,67] | |
| bin52_x: @0 [66,67] | |
| bin52_y: @0 [66,67] | |
| bin52_z: @0 [66,67] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:isfinite params: x, | |
| (2) COND call0, [endif7], [onfalse1] | |
| :onfalse1 | |
| (3) [entry] | |
| (4) call2 <- CALL1 fn:fabs params: x, | |
| (5) bin3 <- MUL_FV call2, '1 0 0' | |
| (6) call4 <- CALL2 fn:copysign params: #IMMEDIATE, x, | |
| (7) bin5 <- MUL_FV call4, '0 1 0' | |
| (8) bin6 <- ADD_V bin3, bin5 | |
| (9) RETURN bin6 | |
| :endif7 | |
| (10) [entry] | |
| (11) bin9 <- LT x, 1 | |
| (12) sce_value13 <- STORE_F bin9 | |
| (13) COND bin9, [sce_other10], [sce_merge8] | |
| :sce_other10 | |
| (14) [entry] | |
| (15) call11 <- CALL1 fn:floor params: x, | |
| (16) sce_value13 <- EQ_F x, call11 | |
| (17) JUMP [sce_merge8] | |
| :sce_merge8 | |
| (18) [entry] | |
| (19) sce_bool14 <- AND sce_value13, sce_value13 | |
| (20) COND sce_bool14, [ontrue15], [endif18] | |
| :ontrue15 | |
| (21) [entry] | |
| (22) call16 <- CALL1 fn:nan params: #IMMEDIATE, | |
| (23) bin17 <- MUL_FV call16, '1 1 1' | |
| (24) RETURN bin17 | |
| :endif18 | |
| (25) [entry] | |
| (26) bin19 <- LT x, 0.1 | |
| (27) COND bin19, [ontrue20], [endif34] | |
| :ontrue20 | |
| (28) [entry] | |
| (29) bin21 <- SUB_F 1, x | |
| (30) v <- CALL1 fn:lgamma params: bin21, | |
| (31) bin23 <- MUL_F 3.14159, x | |
| (32) v_z <- CALL1 fn:sin params: bin23, | |
| (33) call25 <- CALL1 fn:log params: #IMMEDIATE, | |
| (34) call26 <- CALL1 fn:fabs params: v_z, | |
| (35) call27 <- CALL1 fn:log params: call26, | |
| (36) bin28 <- SUB_F call25, call27 | |
| (37) v_x <- SUB_F bin28, v_x | |
| (38) bin30 <- LT v_z, 0 | |
| (39) COND bin30, [ontrue31], [endif33] | |
| :ontrue31 | |
| (40) [entry] | |
| (41) v_y <- SUB_F 0, v_y | |
| (42) JUMP [endif33] | |
| :endif33 | |
| (43) [entry] | |
| (44) v_z <- STORE_F 0 | |
| (45) RETURN v | |
| :endif34 | |
| (46) [entry] | |
| (47) bin35 <- LT x, 1.1 | |
| (48) COND bin35, [ontrue36], [endif42] | |
| :ontrue36 | |
| (49) [entry] | |
| (50) bin37 <- ADD_F x, 1 | |
| (51) call38 <- CALL1 fn:lgamma params: bin37, | |
| (52) call39 <- CALL1 fn:log params: x, | |
| (53) bin40 <- MUL_FV call39, '1 0 0' | |
| (54) bin41 <- SUB_V call38, bin40 | |
| (55) RETURN bin41 | |
| :endif42 | |
| (56) [entry] | |
| (57) x <- SUB_F x, 1 | |
| (58) bin44 <- MUL_F 6.28319, x | |
| (59) call45 <- CALL1 fn:log params: bin44, | |
| (60) bin46 <- MUL_F 0.5, call45 | |
| (61) call47 <- CALL1 fn:log params: x, | |
| (62) bin48 <- SUB_F call47, 1 | |
| (63) bin49 <- MUL_F x, bin48 | |
| (64) bin50 <- ADD_F bin46, bin49 | |
| (65) bin51 <- MUL_FV bin50, '1 0 0' | |
| (66) bin52 <- ADD_V bin51, '0 1 0' | |
| (67) RETURN bin52 | |
| endfunction lgamma | |
| function tgamma | |
| 2 locals: | |
| x | |
| v | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| v: vector [local] locked @1 [1,3] | |
| v_x: @0 [1,2] | |
| v_y: @0 [1,3] | |
| v_z: @0 | |
| call0: vector [value] @0 [null] | |
| call0_x: @0 | |
| call0_y: @0 | |
| call0_z: @0 | |
| call1: float [return] @0 [2,3] | |
| bin2: float [value] @0 [3,4] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) v <- CALL1 fn:lgamma params: x, | |
| (2) call1 <- CALL1 fn:exp params: v_x, | |
| (3) bin2 <- MUL_F call1, v_y | |
| (4) RETURN bin2 | |
| endfunction tgamma | |
| function nearbyint | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| call0: float [return] @0 [1,2] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:rint params: x, | |
| (2) RETURN call0 | |
| endfunction nearbyint | |
| function trunc | |
| 1 locals: | |
| x | |
| liferanges: | |
| x: float [param] locked @0 [0,4] [6,7] | |
| bin0: float [value] @0 [1,2] | |
| call2: float [value] @0 [null] | |
| call4: float [value] @0 [null] | |
| phi6: float [value] @0 [4,5] [7,10] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bin0 <- GE x, 0 | |
| (2) COND bin0, [tern_T1], [tern_F3] | |
| :tern_T1 | |
| (3) [entry] | |
| (4) phi6 <- CALL1 fn:floor params: x, | |
| (5) JUMP [tern_out5] | |
| :tern_F3 | |
| (6) [entry] | |
| (7) phi6 <- CALL1 fn:ceil params: x, | |
| (8) JUMP [tern_out5] | |
| :tern_out5 | |
| (9) [entry] | |
| (10) RETURN phi6 | |
| endfunction trunc | |
| function fmod | |
| 2 locals: | |
| x | |
| y | |
| liferanges: | |
| x: float [param] locked @0 [0,4] | |
| y: float [param] locked @1 [0,3] | |
| bin0: float [value] callparam @0 [1,2] | |
| call1: float [return] @0 [2,3] | |
| bin2: float [value] @0 [3,4] | |
| bin3: float [value] @0 [4,5] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bin0 <- DIV x, y | |
| (2) call1 <- CALL1 fn:trunc params: bin0, | |
| (3) bin2 <- MUL_F y, call1 | |
| (4) bin3 <- SUB_F x, bin2 | |
| (5) RETURN bin3 | |
| endfunction fmod | |
| function remainder | |
| 2 locals: | |
| x | |
| y | |
| liferanges: | |
| x: float [param] locked @0 [0,4] | |
| y: float [param] locked @1 [0,3] | |
| bin0: float [value] callparam @0 [1,2] | |
| call1: float [return] @0 [2,3] | |
| bin2: float [value] @0 [3,4] | |
| bin3: float [value] @0 [4,5] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bin0 <- DIV x, y | |
| (2) call1 <- CALL1 fn:rint params: bin0, | |
| (3) bin2 <- MUL_F y, call1 | |
| (4) bin3 <- SUB_F x, bin2 | |
| (5) RETURN bin3 | |
| endfunction remainder | |
| function remquo | |
| 3 locals: | |
| x | |
| y | |
| v | |
| liferanges: | |
| x: float [param] locked @0 [0,5] | |
| y: float [param] locked @1 [0,4] | |
| v: vector [local] locked @2 [1,6] | |
| v_x: @0 [5,6] | |
| v_y: @0 [3,6] | |
| v_z: @0 [1,6] | |
| bin0: float [value] callparam @0 [2,3] | |
| call1: float [value] @0 [null] | |
| bin2: float [value] @0 [4,5] | |
| bin3: float [value] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) v_z <- STORE_F 0 | |
| (2) bin0 <- DIV x, y | |
| (3) v_y <- CALL1 fn:rint params: bin0, | |
| (4) bin2 <- MUL_F y, v_y | |
| (5) v_x <- SUB_F x, bin2 | |
| (6) RETURN v | |
| endfunction remquo | |
| function copysign | |
| 2 locals: | |
| x | |
| y | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| y: float [param] locked @1 [0,2] | |
| call0: float [return] @0 [1,11] | |
| bin1: float [value] @0 [2,3] | |
| phi5: float [value] @0 [5,6] [8,11] | |
| bin6: float [value] @0 [11,12] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:fabs params: x, | |
| (2) bin1 <- GT y, 0 | |
| (3) COND bin1, [tern_T2], [tern_F3] | |
| :tern_T2 | |
| (4) [entry] | |
| (5) phi5 <- STORE_F 1 | |
| (6) JUMP [tern_out4] | |
| :tern_F3 | |
| (7) [entry] | |
| (8) phi5 <- STORE_F -1 | |
| (9) JUMP [tern_out4] | |
| :tern_out4 | |
| (10) [entry] | |
| (11) bin6 <- MUL_F call0, phi5 | |
| (12) RETURN bin6 | |
| endfunction copysign | |
| function nan | |
| 1 locals: | |
| tag | |
| liferanges: | |
| tag: string [param] locked @0 [0,0] | |
| call0: float [return] @0 [1,2] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL1 fn:sqrt params: #IMMEDIATE, | |
| (2) RETURN call0 | |
| endfunction nan | |
| function nextafter | |
| 5 locals: | |
| x | |
| y | |
| d | |
| a | |
| b | |
| liferanges: | |
| x: float [param] locked @0 [0,2] [6,10] [15,27] | |
| y: float [param] locked @1 [0,2] [6,11] | |
| d: float [local] @0 [17,27] | |
| a: float [local] @1 [18,27] | |
| b: float [local] @2 [20,22] [25,29] | |
| bin0: float [value] @0 [1,2] | |
| call2: float [return] @0 [4,5] | |
| bin4: float [value] @0 [7,8] | |
| bin6: float [value] callparam @0 [10,12] | |
| bin7: float [value] callparam @0 [11,12] | |
| call8: float [return] @0 [12,13] | |
| bin9: float [value] @0 [13,14] | |
| call11: float [value] callparam @0 [16,17] | |
| call12: float [value] @0 [null] | |
| bin13: float [value] @0 [null] | |
| binst17: float [value] @0 [null] | |
| bin18: float [value] @0 [null] | |
| bin19: float [value] @3 [21,22] | |
| life passes: 3 | |
| :entry | |
| (0) [entry] | |
| (1) bin0 <- EQ_F x, y | |
| (2) COND bin0, [ontrue1], [endif3] | |
| :ontrue1 | |
| (3) [entry] | |
| (4) call2 <- CALL1 fn:nan params: #IMMEDIATE, | |
| (5) RETURN call2 | |
| :endif3 | |
| (6) [entry] | |
| (7) bin4 <- GT x, y | |
| (8) COND bin4, [ontrue5], [endif10] | |
| :ontrue5 | |
| (9) [entry] | |
| (10) bin6 <- SUB_F 0, x | |
| (11) bin7 <- SUB_F 0, y | |
| (12) call8 <- CALL2 fn:nextafter params: bin6, bin7, | |
| (13) bin9 <- SUB_F 0, call8 | |
| (14) RETURN bin9 | |
| :endif10 | |
| (15) [entry] | |
| (16) call11 <- CALL1 fn:fabs params: x, | |
| (17) d <- CALL2 fn:max params: call11, #IMMEDIATE, | |
| (18) a <- ADD_F x, d | |
| (19) JUMP [loop_body16] | |
| :post_loop_cond14 | |
| (20) [entry] | |
| (21) bin19 <- NE_F a, x | |
| (22) COND bin19, [loop_body16], [after_loop15] | |
| :loop_body16 | |
| (23) [entry] | |
| (24) d <- MUL_F d, 0.5 | |
| (25) b <- STORE_F a | |
| (26) a <- ADD_F x, d | |
| (27) JUMP [post_loop_cond14] | |
| :after_loop15 | |
| (28) [entry] | |
| (29) RETURN b | |
| endfunction nextafter | |
| function nexttoward | |
| 2 locals: | |
| x | |
| y | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| y: float [param] locked @1 [0,1] | |
| call0: float [return] @0 [1,2] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL2 fn:nextafter params: x, y, | |
| (2) RETURN call0 | |
| endfunction nexttoward | |
| function fdim | |
| 2 locals: | |
| x | |
| y | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| y: float [param] locked @1 [0,1] | |
| bin0: float [value] callparam @0 [1,2] | |
| call1: float [return] @0 [2,3] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bin0 <- SUB_F x, y | |
| (2) call1 <- CALL2 fn:max params: bin0, #IMMEDIATE, | |
| (3) RETURN call1 | |
| endfunction fdim | |
| function fmax | |
| 2 locals: | |
| x | |
| y | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| y: float [param] locked @1 [0,1] | |
| call0: float [return] @0 [1,2] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL2 fn:max params: x, y, | |
| (2) RETURN call0 | |
| endfunction fmax | |
| function fmin | |
| 2 locals: | |
| x | |
| y | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| y: float [param] locked @1 [0,1] | |
| call0: float [return] @0 [1,2] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL2 fn:min params: x, y, | |
| (2) RETURN call0 | |
| endfunction fmin | |
| function fma | |
| 3 locals: | |
| x | |
| y | |
| z | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| y: float [param] locked @1 [0,1] | |
| z: float [param] locked @2 [0,2] | |
| bin0: float [value] @0 [1,2] | |
| bin1: float [value] @0 [2,3] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bin0 <- MUL_F x, y | |
| (2) bin1 <- ADD_F bin0, z | |
| (3) RETURN bin1 | |
| endfunction fma | |
| function isgreater | |
| 2 locals: | |
| x | |
| y | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| y: float [param] locked @1 [0,1] | |
| bin0: float [value] @0 [1,2] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bin0 <- GT x, y | |
| (2) RETURN bin0 | |
| endfunction isgreater | |
| function isgreaterequal | |
| 2 locals: | |
| x | |
| y | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| y: float [param] locked @1 [0,1] | |
| bin0: float [value] @0 [1,2] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bin0 <- GE x, y | |
| (2) RETURN bin0 | |
| endfunction isgreaterequal | |
| function isless | |
| 2 locals: | |
| x | |
| y | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| y: float [param] locked @1 [0,1] | |
| bin0: float [value] @0 [1,2] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bin0 <- LT x, y | |
| (2) RETURN bin0 | |
| endfunction isless | |
| function islessequal | |
| 2 locals: | |
| x | |
| y | |
| liferanges: | |
| x: float [param] locked @0 [0,1] | |
| y: float [param] locked @1 [0,1] | |
| bin0: float [value] @0 [1,2] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bin0 <- LE x, y | |
| (2) RETURN bin0 | |
| endfunction islessequal | |
| function islessgreater | |
| 2 locals: | |
| x | |
| y | |
| liferanges: | |
| x: float [param] locked @0 [0,5] | |
| y: float [param] locked @1 [0,5] | |
| bin1: float [value] @0 [1,3] | |
| bin3: float [value] @0 [null] | |
| sce_value4: float [value] @1 [2,3] [5,8] | |
| sce_bool5: float [value] @0 [8,9] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bin1 <- LT x, y | |
| (2) sce_value4 <- STORE_F bin1 | |
| (3) COND bin1, [sce_merge0], [sce_other2] | |
| :sce_other2 | |
| (4) [entry] | |
| (5) sce_value4 <- GT x, y | |
| (6) JUMP [sce_merge0] | |
| :sce_merge0 | |
| (7) [entry] | |
| (8) sce_bool5 <- AND sce_value4, sce_value4 | |
| (9) RETURN sce_bool5 | |
| endfunction islessgreater | |
| function isunordered | |
| 2 locals: | |
| x | |
| y | |
| liferanges: | |
| x: float [param] locked @0 [0,12] | |
| y: float [param] locked @1 [0,12] | |
| bin2: float [value] @0 [1,3] | |
| bin4: float [value] @0 [null] | |
| sce_value5: float [value] @1 [2,3] [5,8] | |
| sce_bool6: float [value] @0 [8,10] | |
| bin8: float [value] @0 [null] | |
| sce_value9: float [value] @1 [9,10] [12,15] | |
| sce_bool10: float [value] @0 [15,16] | |
| unary11: float [value] @0 [16,17] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bin2 <- LT x, y | |
| (2) sce_value5 <- STORE_F bin2 | |
| (3) COND bin2, [sce_merge1], [sce_other3] | |
| :sce_other3 | |
| (4) [entry] | |
| (5) sce_value5 <- EQ_F x, y | |
| (6) JUMP [sce_merge1] | |
| :sce_merge1 | |
| (7) [entry] | |
| (8) sce_bool6 <- AND sce_value5, sce_value5 | |
| (9) sce_value9 <- STORE_F sce_bool6 | |
| (10) COND sce_bool6, [sce_merge0], [sce_other7] | |
| :sce_other7 | |
| (11) [entry] | |
| (12) sce_value9 <- GT x, y | |
| (13) JUMP [sce_merge0] | |
| :sce_merge0 | |
| (14) [entry] | |
| (15) sce_bool10 <- AND sce_value9, sce_value9 | |
| (16) unary11 <- NOT_F sce_bool10 | |
| (17) RETURN unary11 | |
| endfunction isunordered | |
| function WarpZone_SetUp | |
| 5 locals: | |
| e | |
| my_org | |
| my_ang | |
| other_org | |
| other_ang | |
| liferanges: | |
| e: entity [param] locked @0 [0,23] | |
| my_org: vector [param] locked @1 [0,10] | |
| my_org_x: @0 [0,10] | |
| my_org_y: @0 [0,10] | |
| my_org_z: @0 [0,10] | |
| my_ang: vector [param] locked @4 [0,17] | |
| my_ang_x: @0 [0,17] | |
| my_ang_y: @0 [0,17] | |
| my_ang_z: @0 [0,17] | |
| other_org: vector [param] locked @7 [0,12] | |
| other_org_x: @0 [0,12] | |
| other_org_y: @0 [0,12] | |
| other_org_z: @0 [0,12] | |
| other_ang: vector [param] locked @10 [0,20] | |
| other_ang_x: @0 [0,20] | |
| other_ang_y: @0 [0,20] | |
| other_ang_z: @0 [0,20] | |
| efa0: pointer [value] locked @13 [1,4] | |
| call1: vector [value] callparam @0 [2,3] | |
| call1_x: @0 [2,3] | |
| call1_y: @0 [2,3] | |
| call1_z: @0 [2,3] | |
| call2: vector [return] @0 [3,4] | |
| call2_x: @0 [3,4] | |
| call2_y: @0 [3,4] | |
| call2_z: @0 [3,4] | |
| efa3: pointer [value] locked @13 [5,8] | |
| efv4: vector [value] callparam @0 [6,7] | |
| efv4_x: @0 [6,7] | |
| efv4_y: @0 [6,7] | |
| efv4_z: @0 [6,7] | |
| call5: vector [return] @0 [7,8] | |
| call5_x: @0 [7,8] | |
| call5_y: @0 [7,8] | |
| call5_z: @0 [7,8] | |
| efa6: pointer [value] @0 [9,10] | |
| efa7: pointer [value] @0 [11,12] | |
| efa8: pointer [value] @0 [13,14] | |
| efa9: pointer [value] @0 [15,16] | |
| call10: void [return] @0 [null] | |
| efa11: pointer [value] @0 [18,19] | |
| call12: void [return] @0 [null] | |
| efa13: pointer [value] @0 [21,22] | |
| efa14: pointer [value] @0 [23,24] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efa0 <- ADDRESS e, warpzone_transform | |
| (2) call1 <- CALL1 fn:AnglesTransform_TurnDirectionFR params: my_ang, | |
| (3) call2 <- CALL2 fn:AnglesTransform_RightDivide params: other_ang, call1, | |
| (4) efa0 <- STOREP_V call2 | |
| (5) efa3 <- ADDRESS e, warpzone_shift | |
| (6) efv4 <- FIELD_V e, warpzone_transform | |
| (7) call5 <- CALL3 fn:AnglesTransform_PrePostShift_GetPostShift params: my_org, efv4, other_org, | |
| (8) efa3 <- STOREP_V call5 | |
| (9) efa6 <- ADDRESS e, warpzone_origin | |
| (10) efa6 <- STOREP_V my_org | |
| (11) efa7 <- ADDRESS e, warpzone_targetorigin | |
| (12) efa7 <- STOREP_V other_org | |
| (13) efa8 <- ADDRESS e, warpzone_angles | |
| (14) efa8 <- STOREP_V my_ang | |
| (15) efa9 <- ADDRESS e, warpzone_targetangles | |
| (16) efa9 <- STOREP_V other_ang | |
| (17) call10 <- CALL1 fn:makevectors params: my_ang, | |
| (18) efa11 <- ADDRESS e, warpzone_forward | |
| (19) efa11 <- STOREP_V v_forward | |
| (20) call12 <- CALL1 fn:makevectors params: other_ang, | |
| (21) efa13 <- ADDRESS e, warpzone_targetforward | |
| (22) efa13 <- STOREP_V v_forward | |
| (23) efa14 <- ADDRESS e, camera_transform | |
| (24) efa14 <- STOREP_FNC fn:WarpZone_camera_transform | |
| (25) RETURN | |
| endfunction WarpZone_SetUp | |
| function WarpZoneLib_BoxTouchesBrush | |
| 6 locals: | |
| mi | |
| ma | |
| e | |
| ig | |
| f | |
| s | |
| liferanges: | |
| mi: vector [param] locked @0 [0,10] [13,17] | |
| mi_x: @0 [0,10] [13,17] | |
| mi_y: @0 [0,10] [13,17] | |
| mi_z: @0 [0,10] [13,17] | |
| ma: vector [param] locked @3 [0,10] [13,18] | |
| ma_x: @0 [0,10] [13,18] | |
| ma_y: @0 [0,10] [13,18] | |
| ma_z: @0 [0,10] [13,18] | |
| e: entity [param] locked @6 [0,10] [13,22] | |
| ig: entity [param] locked @7 [0,10] [13,20] | |
| f: float [local] @0 [21,24] | |
| s: float [local] locked @8 [14,23] | |
| efv1: float [value] @0 [1,2] | |
| unary2: float [value] @0 [2,4] | |
| efv4: float [value] @0 [null] | |
| sce_value5: float [value] @1 [3,4] [6,9] | |
| sce_bool6: float [value] @0 [9,10] | |
| efv9: float [value] @0 [null] | |
| efa10: pointer [value] @0 [15,16] | |
| call11: float [value] @0 [null] | |
| efa12: pointer [value] @1 [22,23] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efv1 <- FIELD_F e, modelindex | |
| (2) unary2 <- NOT_F efv1 | |
| (3) sce_value5 <- STORE_F unary2 | |
| (4) COND unary2, [sce_merge0], [sce_other3] | |
| :sce_other3 | |
| (5) [entry] | |
| (6) sce_value5 <- FIELD_F e, warpzone_isboxy | |
| (7) JUMP [sce_merge0] | |
| :sce_merge0 | |
| (8) [entry] | |
| (9) sce_bool6 <- AND sce_value5, sce_value5 | |
| (10) COND sce_bool6, [ontrue7], [endif8] | |
| :ontrue7 | |
| (11) [entry] | |
| (12) RETURN 1 | |
| :endif8 | |
| (13) [entry] | |
| (14) s <- FIELD_F e, solid | |
| (15) efa10 <- ADDRESS e, solid | |
| (16) efa10 <- STOREP_F 4 | |
| (17) WarpZoneLib_BoxTouchesBrush_mins <- STORE_V mi | |
| (18) WarpZoneLib_BoxTouchesBrush_maxs <- STORE_V ma | |
| (19) WarpZoneLib_BoxTouchesBrush_ent <- STORE_ENT e | |
| (20) WarpZoneLib_BoxTouchesBrush_ignore <- STORE_ENT ig | |
| (21) f <- CALL0 fn:WarpZoneLib_BoxTouchesBrush_Recurse | |
| (22) efa12 <- ADDRESS e, solid | |
| (23) efa12 <- STOREP_F s | |
| (24) RETURN f | |
| endfunction WarpZoneLib_BoxTouchesBrush | |
| function WarpZoneLib_NearestPointOnBox | |
| 4 locals: | |
| mi | |
| ma | |
| org | |
| nearest | |
| liferanges: | |
| mi: vector [param] locked @0 [0,3] | |
| mi_x: @0 [0,1] | |
| mi_y: @0 [0,2] | |
| mi_z: @0 [0,3] | |
| ma: vector [param] locked @3 [0,3] | |
| ma_x: @0 [0,1] | |
| ma_y: @0 [0,2] | |
| ma_z: @0 [0,3] | |
| org: vector [param] locked @6 [0,3] | |
| org_x: @0 [0,1] | |
| org_y: @0 [0,2] | |
| org_z: @0 [0,3] | |
| nearest: vector [local] locked @9 [1,4] | |
| nearest_x: @0 [1,4] | |
| nearest_y: @0 [2,4] | |
| nearest_z: @0 [3,4] | |
| call0: float [value] @0 [null] | |
| call1: float [value] @0 [null] | |
| call2: float [value] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) nearest_x <- CALL3 fn:bound params: mi_x, org_x, ma_x, | |
| (2) nearest_y <- CALL3 fn:bound params: mi_y, org_y, ma_y, | |
| (3) nearest_z <- CALL3 fn:bound params: mi_z, org_z, ma_z, | |
| (4) RETURN nearest | |
| endfunction WarpZoneLib_NearestPointOnBox | |
| function WarpZone_Find | |
| 3 locals: | |
| mi | |
| ma | |
| e | |
| liferanges: | |
| mi: vector [param] locked @0 [0,1] [4,13] [16,17] | |
| mi_x: @0 [0,1] [4,13] [16,17] | |
| mi_y: @0 [0,1] [4,13] [16,17] | |
| mi_z: @0 [0,1] [4,13] [16,17] | |
| ma: vector [param] locked @3 [0,1] [4,13] [16,17] | |
| ma_x: @0 [0,1] [4,13] [16,17] | |
| ma_y: @0 [0,1] [4,13] [16,17] | |
| ma_z: @0 [0,1] [4,13] [16,17] | |
| e: entity [local] locked @6 [5,17] | |
| call3: entity [return] @0 [8,10] | |
| call6: float [return] @0 [12,13] | |
| life passes: 3 | |
| :entry | |
| (0) [entry] | |
| (1) COND warpzone_warpzones_exist, [endif1], [onfalse0] | |
| :onfalse0 | |
| (2) [entry] | |
| (3) RETURN world | |
| :endif1 | |
| (4) [entry] | |
| (5) e <- STORE_ENT world | |
| (6) JUMP [pre_loop_cond2] | |
| :pre_loop_cond2 | |
| (7) [entry] | |
| (8) call3 <- CALL3 fn:find params: e, classname, #IMMEDIATE, | |
| (9) e <- STORE_ENT call3 | |
| (10) COND call3, [loop_body5], [after_loop4] | |
| :loop_body5 | |
| (11) [entry] | |
| (12) call6 <- CALL4 fn:WarpZoneLib_BoxTouchesBrush params: mi, ma, e, world, | |
| (13) COND call6, [ontrue7], [endif8] | |
| :ontrue7 | |
| (14) [entry] | |
| (15) RETURN e | |
| :endif8 | |
| (16) [entry] | |
| (17) JUMP [pre_loop_cond2] | |
| :after_loop4 | |
| (18) [entry] | |
| (19) RETURN world | |
| endfunction WarpZone_Find | |
| function WarpZone_MakeAllSolid | |
| 1 locals: | |
| e | |
| liferanges: | |
| e: entity [local] @0 [5,14] | |
| call3: entity [return] @0 [8,10] | |
| efa6: pointer [value] @1 [12,13] | |
| life passes: 3 | |
| :entry | |
| (0) [entry] | |
| (1) COND warpzone_warpzones_exist, [endif1], [onfalse0] | |
| :onfalse0 | |
| (2) [entry] | |
| (3) RETURN | |
| :endif1 | |
| (4) [entry] | |
| (5) e <- STORE_ENT world | |
| (6) JUMP [pre_loop_cond2] | |
| :pre_loop_cond2 | |
| (7) [entry] | |
| (8) call3 <- CALL3 fn:find params: e, classname, #IMMEDIATE, | |
| (9) e <- STORE_ENT call3 | |
| (10) COND call3, [loop_body5], [after_loop4] | |
| :loop_body5 | |
| (11) [entry] | |
| (12) efa6 <- ADDRESS e, solid | |
| (13) efa6 <- STOREP_F 4 | |
| (14) JUMP [pre_loop_cond2] | |
| :after_loop4 | |
| (15) [entry] | |
| (16) RETURN | |
| endfunction WarpZone_MakeAllSolid | |
| function WarpZone_MakeAllOther | |
| 1 locals: | |
| e | |
| liferanges: | |
| e: entity [local] @0 [5,14] | |
| call3: entity [return] @0 [8,10] | |
| efa6: pointer [value] @1 [12,13] | |
| life passes: 3 | |
| :entry | |
| (0) [entry] | |
| (1) COND warpzone_warpzones_exist, [endif1], [onfalse0] | |
| :onfalse0 | |
| (2) [entry] | |
| (3) RETURN | |
| :endif1 | |
| (4) [entry] | |
| (5) e <- STORE_ENT world | |
| (6) JUMP [pre_loop_cond2] | |
| :pre_loop_cond2 | |
| (7) [entry] | |
| (8) call3 <- CALL3 fn:find params: e, classname, #IMMEDIATE, | |
| (9) e <- STORE_ENT call3 | |
| (10) COND call3, [loop_body5], [after_loop4] | |
| :loop_body5 | |
| (11) [entry] | |
| (12) efa6 <- ADDRESS e, solid | |
| (13) efa6 <- STOREP_F 1 | |
| (14) JUMP [pre_loop_cond2] | |
| :after_loop4 | |
| (15) [entry] | |
| (16) RETURN | |
| endfunction WarpZone_MakeAllOther | |
| function WarpZone_TraceBox | |
| 6 locals: | |
| org | |
| mi | |
| ma | |
| end | |
| nomonsters | |
| forent | |
| liferanges: | |
| org: vector [param] locked @0 [0,1] | |
| org_x: @0 [0,1] | |
| org_y: @0 [0,1] | |
| org_z: @0 [0,1] | |
| mi: vector [param] locked @3 [0,1] | |
| mi_x: @0 [0,1] | |
| mi_y: @0 [0,1] | |
| mi_z: @0 [0,1] | |
| ma: vector [param] locked @6 [0,1] | |
| ma_x: @0 [0,1] | |
| ma_y: @0 [0,1] | |
| ma_z: @0 [0,1] | |
| end: vector [param] locked @9 [0,1] | |
| end_x: @0 [0,1] | |
| end_y: @0 [0,1] | |
| end_z: @0 [0,1] | |
| nomonsters: float [param] locked @12 [0,1] | |
| forent: entity [param] locked @13 [0,1] | |
| call0: void [return] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL8 fn:WarpZone_TraceBox_ThroughZone params: org, mi, ma, end, nomonsters, forent, world, WarpZone_trace_callback_t_null, | |
| (2) RETURN | |
| endfunction WarpZone_TraceBox | |
| function WarpZone_TraceBox_ThroughZone | |
| 19 locals: | |
| org | |
| mi | |
| ma | |
| end | |
| nomonsters | |
| forent | |
| zone | |
| cb | |
| nomonsters_adjusted | |
| frac | |
| sol | |
| i | |
| contentshack | |
| o0 | |
| e0 | |
| wz | |
| vf | |
| vr | |
| vu | |
| liferanges: | |
| org: vector [param] locked @0 [0,14] [18,22] [26,83] [85,100] [105,124] [127,164] [166,167] [197,205] | |
| org_x: @0 [0,14] [18,22] [26,83] [85,100] [105,124] [127,164] [166,167] [197,205] | |
| org_y: @0 [0,14] [18,22] [26,83] [85,100] [105,124] [127,164] [166,167] [197,205] | |
| org_z: @0 [0,14] [18,22] [26,83] [85,100] [105,124] [127,164] [166,167] [197,205] | |
| mi: vector [param] locked @3 [0,8] [18,19] [26,79] [85,100] [105,124] [127,167] [170,172] [177,192] [195,205] | |
| mi_x: @0 [0,8] [18,19] [26,79] [85,100] [105,124] [127,167] [170,172] [177,192] [195,205] | |
| mi_y: @0 [0,8] [18,19] [26,79] [85,100] [105,124] [127,167] [170,172] [177,192] [195,205] | |
| mi_z: @0 [0,8] [18,19] [26,79] [85,100] [105,124] [127,167] [170,172] [177,192] [195,205] | |
| ma: vector [param] locked @6 [0,8] [18,19] [26,79] [85,100] [105,124] [127,167] [170,172] [177,192] [195,205] | |
| ma_x: @0 [0,8] [18,19] [26,79] [85,100] [105,124] [127,167] [170,172] [177,192] [195,205] | |
| ma_y: @0 [0,8] [18,19] [26,79] [85,100] [105,124] [127,167] [170,172] [177,192] [195,205] | |
| ma_z: @0 [0,8] [18,19] [26,79] [85,100] [105,124] [127,167] [170,172] [177,192] [195,205] | |
| end: vector [param] locked @9 [0,14] [18,22] [26,79] [85,100] [105,124] [127,167] [170,172] [177,192] [195,205] | |
| end_x: @0 [0,14] [18,22] [26,79] [85,100] [105,124] [127,167] [170,172] [177,192] [195,205] | |
| end_y: @0 [0,14] [18,22] [26,79] [85,100] [105,124] [127,167] [170,172] [177,192] [195,205] | |
| end_z: @0 [0,14] [18,22] [26,79] [85,100] [105,124] [127,167] [170,172] [177,192] [195,205] | |
| nomonsters: float [param] locked @12 [0,8] [18,19] [26,79] [85,100] [105,124] [127,167] [170,172] [177,192] [195,205] | |
| forent: entity [param] locked @13 [0,1] | |
| zone: entity [param] locked @14 [0,5] [26,79] [85,100] [105,124] [127,167] [170,172] [177,192] [195,205] | |
| cb: function [param] locked @15 [0,14] [18,22] [26,79] [85,100] [105,124] [127,167] [170,172] [177,192] [195,205] | |
| nomonsters_adjusted: float [local] locked @13 [40,41] [43,79] [85,100] [105,124] [127,167] [170,172] [177,192] [195,205] | |
| frac: float [local] locked @16 [93,100] [105,120] [122,124] [127,167] [170,172] [177,192] [195,205] | |
| sol: float [local] locked @17 [81,84] [92,113] [115,220] | |
| i: float [local] locked @18 [94,100] [105,124] [127,167] [170,172] [177,192] [195,205] | |
| contentshack: float [local] locked @19 [56,210] | |
| o0: vector [local] @0 [30,30] | |
| o0_x: @0 | |
| o0_y: @0 | |
| o0_z: @0 | |
| e0: vector [local] @0 [31,31] | |
| e0_x: @0 | |
| e0_y: @0 | |
| e0_z: @0 | |
| wz: entity [local] locked @20 [67,79] [85,100] [105,124] [127,167] [170,171] [178,192] [195,205] | |
| vf: vector [local] locked @21 [27,221] | |
| vf_x: @0 [27,221] | |
| vf_y: @0 [27,221] | |
| vf_z: @0 [27,221] | |
| vr: vector [local] locked @24 [28,222] | |
| vr_x: @0 [28,222] | |
| vr_y: @0 [28,222] | |
| vr_z: @0 [28,222] | |
| vu: vector [local] locked @27 [29,223] | |
| vu_x: @0 [29,223] | |
| vu_y: @0 [29,223] | |
| vu_z: @0 [29,223] | |
| call0: void [return] @0 [null] | |
| bin2: float [value] @0 [7,8] | |
| call5: void [return] @0 [null] | |
| call8: void [return] @0 [null] | |
| call10: void [return] @0 [null] | |
| switch_eq14: float [value] @0 [32,33] | |
| switch_eq17: float [value] @0 [37,38] | |
| efv21: float [value] @0 [46,48] | |
| efv23: float [value] @0 [50,51] | |
| bin24: float [value] @0 [51,52] | |
| unary25: float [value] @0 [null] | |
| sce_value26: float [value] @3 [47,48] [52,55] | |
| sce_bool27: float [value] @0 [55,57] | |
| efv29: float [value] @0 [59,60] | |
| binst30: float [value] @0 [60,62] | |
| efa31: pointer [value] @3 [61,62] | |
| bin33: vector [value] callparam @0 [65,67] | |
| bin33_x: @0 [65,67] | |
| bin33_y: @0 [65,67] | |
| bin33_z: @0 [65,67] | |
| bin34: vector [value] callparam @0 [66,67] | |
| bin34_x: @0 [66,67] | |
| bin34_y: @0 [66,67] | |
| bin34_z: @0 [66,67] | |
| call35: entity [value] @0 [null] | |
| bin39: float [value] @0 [null] | |
| sce_value40: float [value] @0 [72,73] [75,78] | |
| sce_bool41: float [value] @0 [78,79] | |
| call44: void [return] @0 [null] | |
| call45: vector [value] @0 [null] | |
| call45_x: @0 | |
| call45_y: @0 | |
| call45_z: @0 | |
| call46: vector [value] @0 [null] | |
| call46_x: @0 | |
| call46_y: @0 | |
| call46_z: @0 | |
| call48: void [return] @0 [null] | |
| binst51: float [value] @0 [97,99] | |
| bin52: float [value] @0 [99,100] | |
| call54: void [return] @0 [null] | |
| call56: void [return] @0 [null] | |
| call58: void [return] @0 [null] | |
| bin60: float [value] @0 [112,113] | |
| bin63: float [value] @0 [118,119] | |
| bin64: float [value] @0 [119,120] | |
| bin65: float [value] @0 [120,122] | |
| bin66: float [value] @0 [123,124] | |
| efv69: string [value] @0 [128,129] | |
| bin70: float [value] @0 [129,130] | |
| bin74: float [value] @0 [132,134] | |
| bin77: float [value] @0 [136,138] | |
| sce_value79: float [value] @3 [137,138] [140,143] | |
| sce_bool80: float [value] @0 [null] | |
| sce_value81: float [value] @3 [133,134] [143,146] | |
| sce_bool82: float [value] @0 [146,148] | |
| efv86: float [value] @0 [153,154] | |
| bin87: float [value] @0 [154,155] | |
| bin88: float [value] @0 [null] | |
| sce_value89: float [value] @0 [150,151] [155,158] | |
| sce_bool90: float [value] @0 [null] | |
| sce_value91: float [value] @3 [147,148] [158,161] | |
| sce_bool92: float [value] @0 [161,162] | |
| bin94: vector [value] callparam @0 [164,165] | |
| bin94_x: @0 [164,165] | |
| bin94_y: @0 [164,165] | |
| bin94_z: @0 [164,165] | |
| call95: vector [return] @0 [165,166] | |
| call95_x: @0 [165,166] | |
| call95_y: @0 [165,166] | |
| call95_z: @0 [165,166] | |
| bin96: vector [value] @0 [null] | |
| bin96_x: @0 | |
| bin96_y: @0 | |
| bin96_z: @0 | |
| bin99: float [value] @0 [171,172] | |
| call101: void [return] @0 [null] | |
| unary103: float [value] @0 [null] | |
| bin108: float [value] @0 [null] | |
| sce_value109: float [value] @0 [185,186] [188,191] | |
| sce_bool110: float [value] @0 [191,192] | |
| call113: void [return] @0 [null] | |
| call114: vector [value] @0 [null] | |
| call114_x: @0 | |
| call114_y: @0 | |
| call114_z: @0 | |
| call115: vector [value] @0 [null] | |
| call115_x: @0 | |
| call115_y: @0 | |
| call115_z: @0 | |
| bin116: vector [value] callparam @0 [199,200] | |
| bin116_x: @0 [199,200] | |
| bin116_y: @0 [199,200] | |
| bin116_z: @0 [199,200] | |
| call117: vector [return] @0 [200,201] | |
| call117_x: @0 [200,201] | |
| call117_y: @0 [200,201] | |
| call117_z: @0 [200,201] | |
| bin118: vector [value] @0 [201,202] | |
| bin118_x: @0 [201,202] | |
| bin118_y: @0 [201,202] | |
| bin118_z: @0 [201,202] | |
| bin119: vector [value] callparam @0 [202,203] | |
| bin119_x: @0 [202,203] | |
| bin119_y: @0 [202,203] | |
| bin119_z: @0 [202,203] | |
| call120: void [return] @0 [null] | |
| call121: void [return] @0 [null] | |
| efa123: pointer [value] @0 [212,217] | |
| efv124: float [value] @3 [213,216] | |
| efv125: float [value] @4 [214,215] | |
| bin126: float [value] @4 [215,216] | |
| bin127: float [value] @3 [216,217] | |
| life passes: 3 | |
| :entry | |
| (0) [entry] | |
| (1) WarpZone_trace_forent <- STORE_ENT forent | |
| (2) WarpZone_trace_firstzone <- STORE_ENT world | |
| (3) WarpZone_trace_lastzone <- STORE_ENT world | |
| (4) call0 <- CALL0 fn:WarpZone_Trace_InitTransform | |
| (5) COND warpzone_warpzones_exist, [endif12], [onfalse1] | |
| :onfalse1 | |
| (6) [entry] | |
| (7) bin2 <- EQ_F nomonsters, -1 | |
| (8) COND bin2, [ontrue3], [onfalse7] | |
| :ontrue3 | |
| (9) [entry] | |
| (10) trace_endpos <- STORE_V end | |
| (11) trace_fraction <- STORE_F 1 | |
| (12) COND cb, [ontrue4], [endif6] | |
| :ontrue4 | |
| (13) [entry] | |
| (14) call5 <- CALL3 cb params: org, trace_endpos, end, | |
| (15) JUMP [endif6] | |
| :endif6 | |
| (16) [entry] | |
| (17) RETURN | |
| :onfalse7 | |
| (18) [entry] | |
| (19) call8 <- CALL6 fn:tracebox params: org, mi, ma, end, nomonsters, WarpZone_trace_forent, | |
| (20) COND cb, [ontrue9], [endif11] | |
| :ontrue9 | |
| (21) [entry] | |
| (22) call10 <- CALL3 cb params: org, trace_endpos, end, | |
| (23) JUMP [endif11] | |
| :endif11 | |
| (24) [entry] | |
| (25) RETURN | |
| :endif12 | |
| (26) [entry] | |
| (27) vf <- STORE_V v_forward | |
| (28) vr <- STORE_V v_right | |
| (29) vu <- STORE_V v_up | |
| (30) o0 <- STORE_V org | |
| (31) e0 <- STORE_V end | |
| (32) switch_eq14 <- EQ_F nomonsters, 3 | |
| (33) COND switch_eq14, [case15], [not_case16] | |
| :case15 | |
| (34) [entry] | |
| (35) JUMP [case18] | |
| :not_case16 | |
| (36) [entry] | |
| (37) switch_eq17 <- EQ_F nomonsters, -1 | |
| (38) COND switch_eq17, [case18], [not_case19] | |
| :case18 | |
| (39) [entry] | |
| (40) nomonsters_adjusted <- STORE_F 1 | |
| (41) JUMP [after_switch13] | |
| :not_case19 | |
| (42) [entry] | |
| (43) nomonsters_adjusted <- STORE_F nomonsters | |
| (44) JUMP [after_switch13] | |
| :after_switch13 | |
| (45) [entry] | |
| (46) efv21 <- FIELD_F WarpZone_trace_forent, dphitcontentsmask | |
| (47) sce_value26 <- STORE_F efv21 | |
| (48) COND efv21, [sce_other22], [sce_merge20] | |
| :sce_other22 | |
| (49) [entry] | |
| (50) efv23 <- FIELD_F WarpZone_trace_forent, dphitcontentsmask | |
| (51) bin24 <- BITAND efv23, 1 | |
| (52) sce_value26 <- NOT_F bin24 | |
| (53) JUMP [sce_merge20] | |
| :sce_merge20 | |
| (54) [entry] | |
| (55) sce_bool27 <- AND sce_value26, sce_value26 | |
| (56) contentshack <- STORE_F sce_bool27 | |
| (57) COND sce_bool27, [ontrue28], [endif32] | |
| :ontrue28 | |
| (58) [entry] | |
| (59) efv29 <- FIELD_F WarpZone_trace_forent, dphitcontentsmask | |
| (60) binst30 <- BITOR efv29, 1 | |
| (61) efa31 <- ADDRESS WarpZone_trace_forent, dphitcontentsmask | |
| (62) efa31 <- STOREP_F binst30 | |
| (63) JUMP [endif32] | |
| :endif32 | |
| (64) [entry] | |
| (65) bin33 <- ADD_V org, mi | |
| (66) bin34 <- ADD_V org, ma | |
| (67) wz <- CALL2 fn:WarpZone_Find params: bin33, bin34, | |
| (68) COND wz, [ontrue36], [endif47] | |
| :ontrue36 | |
| (69) [entry] | |
| (70) WarpZone_trace_firstzone <- STORE_ENT wz | |
| (71) WarpZone_trace_lastzone <- STORE_ENT wz | |
| (72) sce_value40 <- STORE_F zone | |
| (73) COND zone, [sce_other38], [sce_merge37] | |
| :sce_other38 | |
| (74) [entry] | |
| (75) sce_value40 <- NE_E wz, zone | |
| (76) JUMP [sce_merge37] | |
| :sce_merge37 | |
| (77) [entry] | |
| (78) sce_bool41 <- AND sce_value40, sce_value40 | |
| (79) COND sce_bool41, [ontrue42], [endif43] | |
| :ontrue42 | |
| (80) [entry] | |
| (81) sol <- STORE_F 1 | |
| (82) trace_fraction <- STORE_F 0 | |
| (83) trace_endpos <- STORE_V org | |
| (84) JUMP [fail] | |
| :endif43 | |
| (85) [entry] | |
| (86) call44 <- CALL1 fn:WarpZone_Trace_AddTransform params: wz, | |
| (87) org <- CALL2 fn:WarpZone_TransformOrigin params: wz, org, | |
| (88) end <- CALL2 fn:WarpZone_TransformOrigin params: wz, end, | |
| (89) JUMP [endif47] | |
| :endif47 | |
| (90) [entry] | |
| (91) call48 <- CALL0 fn:WarpZone_MakeAllSolid | |
| (92) sol <- STORE_F -1 | |
| (93) frac <- STORE_F 0 | |
| (94) i <- STORE_F 16 | |
| (95) JUMP [loop_body50] | |
| :loop_body50 | |
| (96) [entry] | |
| (97) binst51 <- SUB_F i, 1 | |
| (98) i <- STORE_F binst51 | |
| (99) bin52 <- LT binst51, 1 | |
| (100) COND bin52, [ontrue53], [endif55] | |
| :ontrue53 | |
| (101) [entry] | |
| (102) call54 <- CALL1 fn:dprint params: #IMMEDIATE, | |
| (103) trace_ent <- STORE_ENT world | |
| (104) JUMP [after_loop49] | |
| :endif55 | |
| (105) [entry] | |
| (106) call56 <- CALL6 fn:tracebox params: org, mi, ma, end, nomonsters_adjusted, WarpZone_trace_forent, | |
| (107) COND cb, [ontrue57], [endif59] | |
| :ontrue57 | |
| (108) [entry] | |
| (109) call58 <- CALL3 cb params: org, trace_endpos, end, | |
| (110) JUMP [endif59] | |
| :endif59 | |
| (111) [entry] | |
| (112) bin60 <- LT sol, 0 | |
| (113) COND bin60, [ontrue61], [endif62] | |
| :ontrue61 | |
| (114) [entry] | |
| (115) sol <- STORE_F trace_startsolid | |
| (116) JUMP [endif62] | |
| :endif62 | |
| (117) [entry] | |
| (118) bin63 <- SUB_F 1, frac | |
| (119) bin64 <- MUL_F bin63, trace_fraction | |
| (120) bin65 <- ADD_F frac, bin64 | |
| (121) trace_fraction <- STORE_F bin65 | |
| (122) frac <- STORE_F bin65 | |
| (123) bin66 <- GE trace_fraction, 1 | |
| (124) COND bin66, [ontrue67], [endif68] | |
| :ontrue67 | |
| (125) [entry] | |
| (126) JUMP [after_loop49] | |
| :endif68 | |
| (127) [entry] | |
| (128) efv69 <- FIELD_S trace_ent, classname | |
| (129) bin70 <- NE_S efv69, "trigger_warpzone" | |
| (130) COND bin70, [ontrue71], [endif98] | |
| :ontrue71 | |
| (131) [entry] | |
| (132) bin74 <- EQ_F nomonsters, -1 | |
| (133) sce_value81 <- STORE_F bin74 | |
| (134) COND bin74, [sce_merge73], [sce_other75] | |
| :sce_other75 | |
| (135) [entry] | |
| (136) bin77 <- EQ_F nomonsters, 3 | |
| (137) sce_value79 <- STORE_F bin77 | |
| (138) COND bin77, [sce_other78], [sce_merge76] | |
| :sce_other78 | |
| (139) [entry] | |
| (140) sce_value79 <- STORE_F trace_ent | |
| (141) JUMP [sce_merge76] | |
| :sce_merge76 | |
| (142) [entry] | |
| (143) sce_value81 <- AND sce_value79, sce_value79 | |
| (144) JUMP [sce_merge73] | |
| :sce_merge73 | |
| (145) [entry] | |
| (146) sce_bool82 <- AND sce_value81, sce_value81 | |
| (147) sce_value91 <- STORE_F sce_bool82 | |
| (148) COND sce_bool82, [sce_merge72], [sce_other83] | |
| :sce_other83 | |
| (149) [entry] | |
| (150) sce_value89 <- STORE_F contentshack | |
| (151) COND contentshack, [sce_other85], [sce_merge84] | |
| :sce_other85 | |
| (152) [entry] | |
| (153) efv86 <- FIELD_F WarpZone_trace_forent, dphitcontentsmask | |
| (154) bin87 <- BITAND trace_dphitcontents, efv86 | |
| (155) sce_value89 <- EQ_F bin87, 1 | |
| (156) JUMP [sce_merge84] | |
| :sce_merge84 | |
| (157) [entry] | |
| (158) sce_value91 <- AND sce_value89, sce_value89 | |
| (159) JUMP [sce_merge72] | |
| :sce_merge72 | |
| (160) [entry] | |
| (161) sce_bool92 <- AND sce_value91, sce_value91 | |
| (162) COND sce_bool92, [ontrue93], [endif97] | |
| :ontrue93 | |
| (163) [entry] | |
| (164) bin94 <- SUB_V end, org | |
| (165) call95 <- CALL1 fn:normalize params: bin94, | |
| (166) org <- ADD_V trace_endpos, call95 | |
| (167) JUMP [loop_body50] | |
| :endif97 | |
| (168) [entry] | |
| (169) JUMP [after_loop49] | |
| :endif98 | |
| (170) [entry] | |
| (171) bin99 <- EQ_E trace_ent, wz | |
| (172) COND bin99, [ontrue100], [endif102] | |
| :ontrue100 | |
| (173) [entry] | |
| (174) call101 <- CALL1 fn:dprint params: #IMMEDIATE, | |
| (175) trace_ent <- STORE_ENT world | |
| (176) JUMP [after_loop49] | |
| :endif102 | |
| (177) [entry] | |
| (178) wz <- STORE_ENT trace_ent | |
| (179) COND WarpZone_trace_firstzone, [endif105], [ontrue104] | |
| :ontrue104 | |
| (180) [entry] | |
| (181) WarpZone_trace_firstzone <- STORE_ENT wz | |
| (182) JUMP [endif105] | |
| :endif105 | |
| (183) [entry] | |
| (184) WarpZone_trace_lastzone <- STORE_ENT wz | |
| (185) sce_value109 <- STORE_F zone | |
| (186) COND zone, [sce_other107], [sce_merge106] | |
| :sce_other107 | |
| (187) [entry] | |
| (188) sce_value109 <- NE_E wz, zone | |
| (189) JUMP [sce_merge106] | |
| :sce_merge106 | |
| (190) [entry] | |
| (191) sce_bool110 <- AND sce_value109, sce_value109 | |
| (192) COND sce_bool110, [ontrue111], [endif112] | |
| :ontrue111 | |
| (193) [entry] | |
| (194) JUMP [after_loop49] | |
| :endif112 | |
| (195) [entry] | |
| (196) call113 <- CALL1 fn:WarpZone_Trace_AddTransform params: wz, | |
| (197) org <- CALL2 fn:WarpZone_TransformOrigin params: wz, trace_endpos, | |
| (198) end <- CALL2 fn:WarpZone_TransformOrigin params: wz, end, | |
| (199) bin116 <- SUB_V org, end | |
| (200) call117 <- CALL1 fn:normalize params: bin116, | |
| (201) bin118 <- MUL_VF call117, 32 | |
| (202) bin119 <- ADD_V org, bin118 | |
| (203) call120 <- CALL6 fn:tracebox params: org, mi, ma, bin119, nomonsters_adjusted, WarpZone_trace_forent, | |
| (204) org <- STORE_V trace_endpos | |
| (205) JUMP [loop_body50] | |
| :after_loop49 | |
| (206) [entry] | |
| (207) call121 <- CALL0 fn:WarpZone_MakeAllOther | |
| (208) JUMP [fail] | |
| :fail | |
| (209) [entry] | |
| (210) COND contentshack, [ontrue122], [endif128] | |
| :ontrue122 | |
| (211) [entry] | |
| (212) efa123 <- ADDRESS WarpZone_trace_forent, dphitcontentsmask | |
| (213) efv124 <- FIELD_F WarpZone_trace_forent, dphitcontentsmask | |
| (214) efv125 <- FIELD_F WarpZone_trace_forent, dphitcontentsmask | |
| (215) bin126 <- BITAND efv125, 1 | |
| (216) bin127 <- SUB_F efv124, bin126 | |
| (217) efa123 <- STOREP_F bin127 | |
| (218) JUMP [endif128] | |
| :endif128 | |
| (219) [entry] | |
| (220) trace_startsolid <- STORE_F sol | |
| (221) v_forward <- STORE_V vf | |
| (222) v_right <- STORE_V vr | |
| (223) v_up <- STORE_V vu | |
| (224) RETURN | |
| endfunction WarpZone_TraceBox_ThroughZone | |
| function WarpZone_TraceLine | |
| 4 locals: | |
| org | |
| end | |
| nomonsters | |
| forent | |
| liferanges: | |
| org: vector [param] locked @0 [0,1] | |
| org_x: @0 [0,1] | |
| org_y: @0 [0,1] | |
| org_z: @0 [0,1] | |
| end: vector [param] locked @3 [0,1] | |
| end_x: @0 [0,1] | |
| end_y: @0 [0,1] | |
| end_z: @0 [0,1] | |
| nomonsters: float [param] locked @6 [0,1] | |
| forent: entity [param] locked @7 [0,1] | |
| call0: void [return] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL6 fn:WarpZone_TraceBox params: org, #IMMEDIATE, #IMMEDIATE, end, nomonsters, forent, | |
| (2) RETURN | |
| endfunction WarpZone_TraceLine | |
| function WarpZone_TraceToss | |
| 2 locals: | |
| e | |
| forent | |
| liferanges: | |
| e: entity [param] locked @0 [0,1] | |
| forent: entity [param] locked @1 [0,1] | |
| call0: void [return] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL4 fn:WarpZone_TraceToss_ThroughZone params: e, forent, world, WarpZone_trace_callback_t_null, | |
| (2) RETURN | |
| endfunction WarpZone_TraceToss | |
| function WarpZone_TraceToss_ThroughZone | |
| 13 locals: | |
| e | |
| forent | |
| zone | |
| cb | |
| g | |
| dt | |
| i | |
| vf | |
| vr | |
| vu | |
| v0 | |
| o0 | |
| wz | |
| liferanges: | |
| e: entity [param] locked @0 [0,33] [36,182] | |
| forent: entity [param] locked @1 [0,6] | |
| zone: entity [param] locked @2 [0,11] [36,58] [63,81] [86,109] [112,115] [118,120] [125,140] [143,171] | |
| cb: function [param] locked @3 [0,17] [36,58] [63,81] [86,109] [112,115] [118,120] [125,140] [143,171] | |
| g: float [local] locked @4 [5,28] [36,58] [63,81] [86,109] [112,115] [118,120] [125,140] [143,171] | |
| dt: float [local] @0 [25,28] [99,104] [163,164] | |
| i: float [local] locked @1 [75,81] [86,109] [112,115] [118,120] [125,140] [143,171] | |
| vf: vector [local] locked @5 [37,177] | |
| vf_x: @0 [37,177] | |
| vf_y: @0 [37,177] | |
| vf_z: @0 [37,177] | |
| vr: vector [local] locked @8 [38,178] | |
| vr_x: @0 [38,178] | |
| vr_y: @0 [38,178] | |
| vr_z: @0 [38,178] | |
| vu: vector [local] locked @11 [39,179] | |
| vu_x: @0 [39,179] | |
| vu_y: @0 [39,179] | |
| vu_z: @0 [39,179] | |
| v0: vector [local] locked @14 [2,34] [36,181] | |
| v0_x: @0 [2,34] [36,181] | |
| v0_y: @0 [2,34] [36,181] | |
| v0_z: @0 [2,34] [36,181] | |
| o0: vector [local] locked @17 [1,21] [36,183] | |
| o0_x: @0 [1,21] [36,183] | |
| o0_y: @0 [1,21] [36,183] | |
| o0_z: @0 [1,21] [36,183] | |
| wz: entity [local] locked @20 [46,58] [63,81] [86,109] [112,115] [118,119] [126,140] [143,171] | |
| efv0: vector [value] @0 [null] | |
| efv0_x: @0 | |
| efv0_y: @0 | |
| efv0_z: @0 | |
| efv1: vector [value] @0 [null] | |
| efv1_x: @0 | |
| efv1_y: @0 | |
| efv1_z: @0 | |
| call2: float [return] @0 [3,5] | |
| efv3: float [value] @0 [4,5] | |
| bin4: float [value] @0 [null] | |
| call5: void [return] @0 [null] | |
| call7: void [return] @0 [null] | |
| efv9: vector [value] callparam @0 [16,17] | |
| efv9_x: @0 [16,17] | |
| efv9_y: @0 [16,17] | |
| efv9_z: @0 [16,17] | |
| call10: void [return] @0 [null] | |
| efv12: vector [value] @1 [20,21] | |
| efv12_x: @0 [20,21] | |
| efv12_y: @0 [20,21] | |
| efv12_z: @0 [20,21] | |
| bin13: vector [value] callparam @0 [21,22] | |
| bin13_x: @0 [21,22] | |
| bin13_y: @0 [21,22] | |
| bin13_z: @0 [21,22] | |
| call14: float [value] locked @1 [22,25] | |
| efv15: vector [value] callparam @0 [23,24] | |
| efv15_x: @0 [23,24] | |
| efv15_y: @0 [23,24] | |
| efv15_z: @0 [23,24] | |
| call16: float [return] @0 [24,25] | |
| bin17: float [value] @0 [null] | |
| binst18: float [value] @0 [null] | |
| efv19: float [value] @1 [27,29] | |
| bin20: float [value] @0 [28,29] | |
| binst21: float [value] @0 [29,31] | |
| efa22: pointer [value] @1 [30,31] | |
| efv23: vector [value] @0 [null] | |
| efv23_x: @0 | |
| efv23_y: @0 | |
| efv23_z: @0 | |
| efa24: pointer [value] @0 [33,34] | |
| efv26: vector [value] @1 [40,42] | |
| efv26_x: @0 [40,42] | |
| efv26_y: @0 [40,42] | |
| efv26_z: @0 [40,42] | |
| efv27: vector [value] @4 [41,42] | |
| efv27_x: @0 [41,42] | |
| efv27_y: @0 [41,42] | |
| efv27_z: @0 [41,42] | |
| bin28: vector [value] callparam @0 [42,46] | |
| bin28_x: @0 [42,46] | |
| bin28_y: @0 [42,46] | |
| bin28_z: @0 [42,46] | |
| efv29: vector [value] @1 [43,45] | |
| efv29_x: @0 [43,45] | |
| efv29_y: @0 [43,45] | |
| efv29_z: @0 [43,45] | |
| efv30: vector [value] @4 [44,45] | |
| efv30_x: @0 [44,45] | |
| efv30_y: @0 [44,45] | |
| efv30_z: @0 [44,45] | |
| bin31: vector [value] callparam @0 [45,46] | |
| bin31_x: @0 [45,46] | |
| bin31_y: @0 [45,46] | |
| bin31_z: @0 [45,46] | |
| call32: entity [value] @0 [null] | |
| bin36: float [value] @0 [null] | |
| sce_value37: float [value] @0 [51,52] [54,57] | |
| sce_bool38: float [value] @0 [57,58] | |
| call41: void [return] @0 [null] | |
| efv42: vector [value] callparam @0 [65,66] | |
| efv42_x: @0 [65,66] | |
| efv42_y: @0 [65,66] | |
| efv42_z: @0 [65,66] | |
| call43: vector [value] callparam @0 [66,67] | |
| call43_x: @0 [66,67] | |
| call43_y: @0 [66,67] | |
| call43_z: @0 [66,67] | |
| call44: void [return] @0 [null] | |
| efa45: pointer [value] locked @1 [68,71] | |
| efv46: vector [value] callparam @0 [69,70] | |
| efv46_x: @0 [69,70] | |
| efv46_y: @0 [69,70] | |
| efv46_z: @0 [69,70] | |
| call47: vector [return] @0 [70,71] | |
| call47_x: @0 [70,71] | |
| call47_y: @0 [70,71] | |
| call47_z: @0 [70,71] | |
| call49: void [return] @0 [null] | |
| binst52: float [value] @0 [78,80] | |
| bin53: float [value] @0 [80,81] | |
| call55: void [return] @0 [null] | |
| call57: void [return] @0 [null] | |
| efv59: vector [value] callparam @0 [90,91] | |
| efv59_x: @0 [90,91] | |
| efv59_y: @0 [90,91] | |
| efv59_z: @0 [90,91] | |
| call60: void [return] @0 [null] | |
| efv62: vector [value] @1 [94,95] | |
| efv62_x: @0 [94,95] | |
| efv62_y: @0 [94,95] | |
| efv62_z: @0 [94,95] | |
| bin63: vector [value] callparam @0 [95,96] | |
| bin63_x: @0 [95,96] | |
| bin63_y: @0 [95,96] | |
| bin63_z: @0 [95,96] | |
| call64: float [value] locked @21 [96,99] | |
| efv65: vector [value] callparam @0 [97,98] | |
| efv65_x: @0 [97,98] | |
| efv65_y: @0 [97,98] | |
| efv65_z: @0 [97,98] | |
| call66: float [return] @0 [98,99] | |
| bin67: float [value] @0 [null] | |
| binst68: float [value] @0 [null] | |
| efa69: pointer [value] @1 [101,102] | |
| efv70: float [value] @1 [103,105] | |
| bin71: float [value] @0 [104,105] | |
| binst72: float [value] @0 [105,107] | |
| efa73: pointer [value] @1 [106,107] | |
| bin74: float [value] @0 [108,109] | |
| efv77: string [value] @0 [113,114] | |
| bin78: float [value] @0 [114,115] | |
| bin81: float [value] @0 [119,120] | |
| call83: void [return] @0 [null] | |
| unary85: float [value] @0 [null] | |
| bin90: float [value] @0 [null] | |
| sce_value91: float [value] @0 [133,134] [136,139] | |
| sce_bool92: float [value] @0 [139,140] | |
| call95: void [return] @0 [null] | |
| efa96: pointer [value] locked @21 [145,148] | |
| efv97: vector [value] callparam @0 [146,147] | |
| efv97_x: @0 [146,147] | |
| efv97_y: @0 [146,147] | |
| efv97_z: @0 [146,147] | |
| call98: vector [return] @0 [147,148] | |
| call98_x: @0 [147,148] | |
| call98_y: @0 [147,148] | |
| call98_z: @0 [147,148] | |
| efa99: pointer [value] locked @21 [149,152] | |
| efv100: vector [value] callparam @0 [150,151] | |
| efv100_x: @0 [150,151] | |
| efv100_y: @0 [150,151] | |
| efv100_z: @0 [150,151] | |
| call101: vector [return] @0 [151,152] | |
| call101_x: @0 [151,152] | |
| call101_y: @0 [151,152] | |
| call101_z: @0 [151,152] | |
| efa102: pointer [value] @0 [153,156] | |
| efv103: vector [value] @1 [154,155] | |
| efv103_x: @0 [154,155] | |
| efv103_y: @0 [154,155] | |
| efv103_z: @0 [154,155] | |
| bin104: vector [value] @1 [155,156] | |
| bin104_x: @0 [155,156] | |
| bin104_y: @0 [155,156] | |
| bin104_z: @0 [155,156] | |
| call105: void [return] @0 [null] | |
| efv106: vector [value] @1 [158,159] | |
| efv106_x: @0 [158,159] | |
| efv106_y: @0 [158,159] | |
| efv106_z: @0 [158,159] | |
| bin107: vector [value] callparam @0 [159,160] | |
| bin107_x: @0 [159,160] | |
| bin107_y: @0 [159,160] | |
| bin107_z: @0 [159,160] | |
| call108: float [value] locked @21 [160,163] | |
| efv109: vector [value] callparam @0 [161,162] | |
| efv109_x: @0 [161,162] | |
| efv109_y: @0 [161,162] | |
| efv109_z: @0 [161,162] | |
| call110: float [return] @0 [162,163] | |
| bin111: float [value] @0 [null] | |
| binst112: float [value] @0 [null] | |
| efa113: pointer [value] @0 [165,166] | |
| efa114: pointer [value] @0 [167,170] | |
| efv115: vector [value] @1 [168,169] | |
| efv115_x: @0 [168,169] | |
| efv115_y: @0 [168,169] | |
| efv115_z: @0 [168,169] | |
| bin116: vector [value] @1 [169,170] | |
| bin116_x: @0 [169,170] | |
| bin116_y: @0 [169,170] | |
| bin116_z: @0 [169,170] | |
| call117: void [return] @0 [null] | |
| efv118: vector [value] @0 [null] | |
| efv118_x: @0 | |
| efv118_y: @0 | |
| efv118_z: @0 | |
| efa119: pointer [value] @0 [180,181] | |
| efa120: pointer [value] @0 [182,183] | |
| life passes: 3 | |
| :entry | |
| (0) [entry] | |
| (1) o0 <- FIELD_V e, origin | |
| (2) v0 <- FIELD_V e, velocity | |
| (3) call2 <- CALL1 fn:cvar params: #IMMEDIATE, | |
| (4) efv3 <- FIELD_F e, gravity | |
| (5) g <- MUL_F call2, efv3 | |
| (6) WarpZone_trace_forent <- STORE_ENT forent | |
| (7) WarpZone_trace_firstzone <- STORE_ENT world | |
| (8) WarpZone_trace_lastzone <- STORE_ENT world | |
| (9) call5 <- CALL0 fn:WarpZone_Trace_InitTransform | |
| (10) WarpZone_tracetoss_time <- STORE_F 0 | |
| (11) COND warpzone_warpzones_exist, [endif25], [onfalse6] | |
| :onfalse6 | |
| (12) [entry] | |
| (13) call7 <- CALL2 fn:tracetoss params: e, WarpZone_trace_forent, | |
| (14) COND cb, [ontrue8], [endif11] | |
| :ontrue8 | |
| (15) [entry] | |
| (16) efv9 <- FIELD_V e, origin | |
| (17) call10 <- CALL3 cb params: efv9, trace_endpos, trace_endpos, | |
| (18) JUMP [endif11] | |
| :endif11 | |
| (19) [entry] | |
| (20) efv12 <- FIELD_V e, origin | |
| (21) bin13 <- SUB_V efv12, o0 | |
| (22) call14 <- CALL1 fn:vlen params: bin13, | |
| (23) efv15 <- FIELD_V e, velocity | |
| (24) call16 <- CALL1 fn:vlen params: efv15, | |
| (25) dt <- DIV call14, call16 | |
| (26) WarpZone_tracetoss_time <- ADD_F WarpZone_tracetoss_time, dt | |
| (27) efv19 <- FIELD_F e, velocity_z | |
| (28) bin20 <- MUL_F dt, g | |
| (29) binst21 <- SUB_F efv19, bin20 | |
| (30) efa22 <- ADDRESS e, velocity_z | |
| (31) efa22 <- STOREP_F binst21 | |
| (32) WarpZone_tracetoss_velocity <- FIELD_V e, velocity | |
| (33) efa24 <- ADDRESS e, velocity | |
| (34) efa24 <- STOREP_V v0 | |
| (35) RETURN | |
| :endif25 | |
| (36) [entry] | |
| (37) vf <- STORE_V v_forward | |
| (38) vr <- STORE_V v_right | |
| (39) vu <- STORE_V v_up | |
| (40) efv26 <- FIELD_V e, origin | |
| (41) efv27 <- FIELD_V e, mins | |
| (42) bin28 <- ADD_V efv26, efv27 | |
| (43) efv29 <- FIELD_V e, origin | |
| (44) efv30 <- FIELD_V e, maxs | |
| (45) bin31 <- ADD_V efv29, efv30 | |
| (46) wz <- CALL2 fn:WarpZone_Find params: bin28, bin31, | |
| (47) COND wz, [ontrue33], [endif48] | |
| :ontrue33 | |
| (48) [entry] | |
| (49) WarpZone_trace_firstzone <- STORE_ENT wz | |
| (50) WarpZone_trace_lastzone <- STORE_ENT wz | |
| (51) sce_value37 <- STORE_F zone | |
| (52) COND zone, [sce_other35], [sce_merge34] | |
| :sce_other35 | |
| (53) [entry] | |
| (54) sce_value37 <- NE_E wz, zone | |
| (55) JUMP [sce_merge34] | |
| :sce_merge34 | |
| (56) [entry] | |
| (57) sce_bool38 <- AND sce_value37, sce_value37 | |
| (58) COND sce_bool38, [ontrue39], [endif40] | |
| :ontrue39 | |
| (59) [entry] | |
| (60) WarpZone_tracetoss_time <- STORE_F 0 | |
| (61) trace_endpos <- STORE_V o0 | |
| (62) JUMP [fail] | |
| :endif40 | |
| (63) [entry] | |
| (64) call41 <- CALL1 fn:WarpZone_Trace_AddTransform params: wz, | |
| (65) efv42 <- FIELD_V e, origin | |
| (66) call43 <- CALL2 fn:WarpZone_TransformOrigin params: wz, efv42, | |
| (67) call44 <- CALL2 fn:setorigin params: e, call43, | |
| (68) efa45 <- ADDRESS e, velocity | |
| (69) efv46 <- FIELD_V e, velocity | |
| (70) call47 <- CALL2 fn:WarpZone_TransformVelocity params: wz, efv46, | |
| (71) efa45 <- STOREP_V call47 | |
| (72) JUMP [endif48] | |
| :endif48 | |
| (73) [entry] | |
| (74) call49 <- CALL0 fn:WarpZone_MakeAllSolid | |
| (75) i <- STORE_F 16 | |
| (76) JUMP [loop_body51] | |
| :loop_body51 | |
| (77) [entry] | |
| (78) binst52 <- SUB_F i, 1 | |
| (79) i <- STORE_F binst52 | |
| (80) bin53 <- LT binst52, 1 | |
| (81) COND bin53, [ontrue54], [endif56] | |
| :ontrue54 | |
| (82) [entry] | |
| (83) call55 <- CALL1 fn:dprint params: #IMMEDIATE, | |
| (84) trace_ent <- STORE_ENT world | |
| (85) JUMP [after_loop50] | |
| :endif56 | |
| (86) [entry] | |
| (87) call57 <- CALL2 fn:tracetoss params: e, WarpZone_trace_forent, | |
| (88) COND cb, [ontrue58], [endif61] | |
| :ontrue58 | |
| (89) [entry] | |
| (90) efv59 <- FIELD_V e, origin | |
| (91) call60 <- CALL3 cb params: efv59, trace_endpos, trace_endpos, | |
| (92) JUMP [endif61] | |
| :endif61 | |
| (93) [entry] | |
| (94) efv62 <- FIELD_V e, origin | |
| (95) bin63 <- SUB_V trace_endpos, efv62 | |
| (96) call64 <- CALL1 fn:vlen params: bin63, | |
| (97) efv65 <- FIELD_V e, velocity | |
| (98) call66 <- CALL1 fn:vlen params: efv65, | |
| (99) dt <- DIV call64, call66 | |
| (100) WarpZone_tracetoss_time <- ADD_F WarpZone_tracetoss_time, dt | |
| (101) efa69 <- ADDRESS e, origin | |
| (102) efa69 <- STOREP_V trace_endpos | |
| (103) efv70 <- FIELD_F e, velocity_z | |
| (104) bin71 <- MUL_F dt, g | |
| (105) binst72 <- SUB_F efv70, bin71 | |
| (106) efa73 <- ADDRESS e, velocity_z | |
| (107) efa73 <- STOREP_F binst72 | |
| (108) bin74 <- GE trace_fraction, 1 | |
| (109) COND bin74, [ontrue75], [endif76] | |
| :ontrue75 | |
| (110) [entry] | |
| (111) JUMP [after_loop50] | |
| :endif76 | |
| (112) [entry] | |
| (113) efv77 <- FIELD_S trace_ent, classname | |
| (114) bin78 <- NE_S efv77, "trigger_warpzone" | |
| (115) COND bin78, [ontrue79], [endif80] | |
| :ontrue79 | |
| (116) [entry] | |
| (117) JUMP [after_loop50] | |
| :endif80 | |
| (118) [entry] | |
| (119) bin81 <- EQ_E trace_ent, wz | |
| (120) COND bin81, [ontrue82], [endif84] | |
| :ontrue82 | |
| (121) [entry] | |
| (122) call83 <- CALL1 fn:dprint params: #IMMEDIATE, | |
| (123) trace_ent <- STORE_ENT world | |
| (124) JUMP [after_loop50] | |
| :endif84 | |
| (125) [entry] | |
| (126) wz <- STORE_ENT trace_ent | |
| (127) COND WarpZone_trace_firstzone, [endif87], [ontrue86] | |
| :ontrue86 | |
| (128) [entry] | |
| (129) WarpZone_trace_firstzone <- STORE_ENT wz | |
| (130) JUMP [endif87] | |
| :endif87 | |
| (131) [entry] | |
| (132) WarpZone_trace_lastzone <- STORE_ENT wz | |
| (133) sce_value91 <- STORE_F zone | |
| (134) COND zone, [sce_other89], [sce_merge88] | |
| :sce_other89 | |
| (135) [entry] | |
| (136) sce_value91 <- NE_E wz, zone | |
| (137) JUMP [sce_merge88] | |
| :sce_merge88 | |
| (138) [entry] | |
| (139) sce_bool92 <- AND sce_value91, sce_value91 | |
| (140) COND sce_bool92, [ontrue93], [endif94] | |
| :ontrue93 | |
| (141) [entry] | |
| (142) JUMP [after_loop50] | |
| :endif94 | |
| (143) [entry] | |
| (144) call95 <- CALL1 fn:WarpZone_Trace_AddTransform params: wz, | |
| (145) efa96 <- ADDRESS e, origin | |
| (146) efv97 <- FIELD_V e, origin | |
| (147) call98 <- CALL2 fn:WarpZone_TransformOrigin params: wz, efv97, | |
| (148) efa96 <- STOREP_V call98 | |
| (149) efa99 <- ADDRESS e, velocity | |
| (150) efv100 <- FIELD_V e, velocity | |
| (151) call101 <- CALL2 fn:WarpZone_TransformVelocity params: wz, efv100, | |
| (152) efa99 <- STOREP_V call101 | |
| (153) efa102 <- ADDRESS e, velocity | |
| (154) efv103 <- FIELD_V e, velocity | |
| (155) bin104 <- SUB_V '0 0 0', efv103 | |
| (156) efa102 <- STOREP_V bin104 | |
| (157) call105 <- CALL2 fn:tracetoss params: e, WarpZone_trace_forent, | |
| (158) efv106 <- FIELD_V e, origin | |
| (159) bin107 <- SUB_V trace_endpos, efv106 | |
| (160) call108 <- CALL1 fn:vlen params: bin107, | |
| (161) efv109 <- FIELD_V e, velocity | |
| (162) call110 <- CALL1 fn:vlen params: efv109, | |
| (163) dt <- DIV call108, call110 | |
| (164) WarpZone_tracetoss_time <- SUB_F WarpZone_tracetoss_time, dt | |
| (165) efa113 <- ADDRESS e, origin | |
| (166) efa113 <- STOREP_V trace_endpos | |
| (167) efa114 <- ADDRESS e, velocity | |
| (168) efv115 <- FIELD_V e, velocity | |
| (169) bin116 <- SUB_V '0 0 0', efv115 | |
| (170) efa114 <- STOREP_V bin116 | |
| (171) JUMP [loop_body51] | |
| :after_loop50 | |
| (172) [entry] | |
| (173) call117 <- CALL0 fn:WarpZone_MakeAllOther | |
| (174) JUMP [fail] | |
| :fail | |
| (175) [entry] | |
| (176) WarpZone_tracetoss_velocity <- FIELD_V e, velocity | |
| (177) v_forward <- STORE_V vf | |
| (178) v_right <- STORE_V vr | |
| (179) v_up <- STORE_V vu | |
| (180) efa119 <- ADDRESS e, velocity | |
| (181) efa119 <- STOREP_V v0 | |
| (182) efa120 <- ADDRESS e, origin | |
| (183) efa120 <- STOREP_V o0 | |
| (184) RETURN | |
| endfunction WarpZone_TraceToss_ThroughZone | |
| function WarpZone_TrailParticles | |
| 4 locals: | |
| own | |
| eff | |
| org | |
| end | |
| liferanges: | |
| own: entity [param] locked @0 [0,1] | |
| eff: float [param] locked @1 [0,2] | |
| org: vector [param] locked @2 [0,3] | |
| org_x: @0 [0,3] | |
| org_y: @0 [0,3] | |
| org_z: @0 [0,3] | |
| end: vector [param] locked @5 [0,3] | |
| end_x: @0 [0,3] | |
| end_y: @0 [0,3] | |
| end_z: @0 [0,3] | |
| call0: void [return] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) WarpZone_TrailParticles_trace_callback_own <- STORE_ENT own | |
| (2) WarpZone_TrailParticles_trace_callback_eff <- STORE_F eff | |
| (3) call0 <- CALL8 fn:WarpZone_TraceBox_ThroughZone params: org, #IMMEDIATE, #IMMEDIATE, end, MOVE_NOMONSTERS, world, world, WarpZone_TrailParticles_trace_callback, | |
| (4) RETURN | |
| endfunction WarpZone_TrailParticles | |
| function WarpZone_TrailParticles_WithMultiplier | |
| 6 locals: | |
| own | |
| eff | |
| org | |
| end | |
| f | |
| boxflags | |
| liferanges: | |
| own: entity [param] locked @0 [0,1] | |
| eff: float [param] locked @1 [0,2] | |
| org: vector [param] locked @2 [0,5] | |
| org_x: @0 [0,5] | |
| org_y: @0 [0,5] | |
| org_z: @0 [0,5] | |
| end: vector [param] locked @5 [0,5] | |
| end_x: @0 [0,5] | |
| end_y: @0 [0,5] | |
| end_z: @0 [0,5] | |
| f: float [param] locked @8 [0,3] | |
| boxflags: float [param] locked @9 [0,4] | |
| call0: void [return] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) WarpZone_TrailParticles_trace_callback_own <- STORE_ENT own | |
| (2) WarpZone_TrailParticles_trace_callback_eff <- STORE_F eff | |
| (3) WarpZone_TrailParticles_trace_callback_f <- STORE_F f | |
| (4) WarpZone_TrailParticles_trace_callback_flags <- STORE_F boxflags | |
| (5) call0 <- CALL8 fn:WarpZone_TraceBox_ThroughZone params: org, #IMMEDIATE, #IMMEDIATE, end, MOVE_NOMONSTERS, world, world, WarpZone_TrailParticles_WithMultiplier_trace_callback, | |
| (6) RETURN | |
| endfunction WarpZone_TrailParticles_WithMultiplier | |
| function WarpZone_FindRadius | |
| 5 locals: | |
| org | |
| rad | |
| needlineofsight | |
| e0 | |
| e | |
| liferanges: | |
| org: vector [param] locked @0 [0,1] | |
| org_x: @0 [0,1] | |
| org_y: @0 [0,1] | |
| org_z: @0 [0,1] | |
| rad: float [param] locked @3 [0,1] | |
| needlineofsight: float [param] locked @4 [0,1] | |
| e0: entity [local] @0 [2,15] | |
| e: entity [local] @1 [3,13] | |
| call0: void [return] @0 [null] | |
| call1: entity [value] @0 [null] | |
| efa6: pointer [value] @2 [11,12] | |
| efv7: entity [value] @0 [null] | |
| life passes: 4 | |
| :entry | |
| (0) [entry] | |
| (1) call0 <- CALL6 fn:WarpZone_FindRadius_Recurse params: org, rad, org, #IMMEDIATE, #IMMEDIATE, needlineofsight, | |
| (2) e0 <- CALL2 fn:findchainfloat params: WarpZone_findradius_hit, #IMMEDIATE, | |
| (3) e <- STORE_ENT e0 | |
| (4) JUMP [pre_loop_cond2] | |
| :pre_loop_cond2 | |
| (5) [entry] | |
| (6) COND e, [loop_body5], [after_loop4] | |
| :loop_increment3 | |
| (7) [entry] | |
| (8) e <- FIELD_ENT e, chain | |
| (9) JUMP [pre_loop_cond2] | |
| :loop_body5 | |
| (10) [entry] | |
| (11) efa6 <- ADDRESS e, WarpZone_findradius_hit | |
| (12) efa6 <- STOREP_F 0 | |
| (13) JUMP [loop_increment3] | |
| :after_loop4 | |
| (14) [entry] | |
| (15) RETURN e0 | |
| endfunction WarpZone_FindRadius | |
| function WarpZone_PlaneDist | |
| 2 locals: | |
| wz | |
| v | |
| liferanges: | |
| wz: entity [param] locked @0 [0,4] | |
| v: vector [param] locked @1 [0,2] | |
| v_x: @0 [0,2] | |
| v_y: @0 [0,2] | |
| v_z: @0 [0,2] | |
| efv0: vector [value] @0 [1,2] | |
| efv0_x: @0 [1,2] | |
| efv0_y: @0 [1,2] | |
| efv0_z: @0 [1,2] | |
| bin1: vector [value] @0 [2,4] | |
| bin1_x: @0 [2,4] | |
| bin1_y: @0 [2,4] | |
| bin1_z: @0 [2,4] | |
| efv2: vector [value] @3 [3,4] | |
| efv2_x: @0 [3,4] | |
| efv2_y: @0 [3,4] | |
| efv2_z: @0 [3,4] | |
| bin3: float [value] @0 [4,5] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efv0 <- FIELD_V wz, warpzone_origin | |
| (2) bin1 <- SUB_V v, efv0 | |
| (3) efv2 <- FIELD_V wz, warpzone_forward | |
| (4) bin3 <- MUL_V bin1, efv2 | |
| (5) RETURN bin3 | |
| endfunction WarpZone_PlaneDist | |
| function WarpZone_TargetPlaneDist | |
| 2 locals: | |
| wz | |
| v | |
| liferanges: | |
| wz: entity [param] locked @0 [0,4] | |
| v: vector [param] locked @1 [0,2] | |
| v_x: @0 [0,2] | |
| v_y: @0 [0,2] | |
| v_z: @0 [0,2] | |
| efv0: vector [value] @0 [1,2] | |
| efv0_x: @0 [1,2] | |
| efv0_y: @0 [1,2] | |
| efv0_z: @0 [1,2] | |
| bin1: vector [value] @0 [2,4] | |
| bin1_x: @0 [2,4] | |
| bin1_y: @0 [2,4] | |
| bin1_z: @0 [2,4] | |
| efv2: vector [value] @3 [3,4] | |
| efv2_x: @0 [3,4] | |
| efv2_y: @0 [3,4] | |
| efv2_z: @0 [3,4] | |
| bin3: float [value] @0 [4,5] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efv0 <- FIELD_V wz, warpzone_targetorigin | |
| (2) bin1 <- SUB_V v, efv0 | |
| (3) efv2 <- FIELD_V wz, warpzone_targetforward | |
| (4) bin3 <- MUL_V bin1, efv2 | |
| (5) RETURN bin3 | |
| endfunction WarpZone_TargetPlaneDist | |
| function WarpZone_TransformOrigin | |
| 2 locals: | |
| wz | |
| v | |
| liferanges: | |
| wz: entity [param] locked @0 [0,3] | |
| v: vector [param] locked @1 [0,3] | |
| v_x: @0 [0,3] | |
| v_y: @0 [0,3] | |
| v_z: @0 [0,3] | |
| efv0: vector [value] locked @4 [1,4] | |
| efv0_x: locked @0 [1,4] | |
| efv0_y: locked @0 [1,4] | |
| efv0_z: locked @0 [1,4] | |
| efv1: vector [value] callparam @0 [2,3] | |
| efv1_x: @0 [2,3] | |
| efv1_y: @0 [2,3] | |
| efv1_z: @0 [2,3] | |
| call2: vector [return] @0 [3,4] | |
| call2_x: @0 [3,4] | |
| call2_y: @0 [3,4] | |
| call2_z: @0 [3,4] | |
| bin3: vector [value] @0 [4,5] | |
| bin3_x: @0 [4,5] | |
| bin3_y: @0 [4,5] | |
| bin3_z: @0 [4,5] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efv0 <- FIELD_V wz, warpzone_shift | |
| (2) efv1 <- FIELD_V wz, warpzone_transform | |
| (3) call2 <- CALL2 fn:AnglesTransform_Apply params: efv1, v, | |
| (4) bin3 <- ADD_V efv0, call2 | |
| (5) RETURN bin3 | |
| endfunction WarpZone_TransformOrigin | |
| function WarpZone_TransformVelocity | |
| 2 locals: | |
| wz | |
| v | |
| liferanges: | |
| wz: entity [param] locked @0 [0,2] | |
| v: vector [param] locked @1 [0,2] | |
| v_x: @0 [0,2] | |
| v_y: @0 [0,2] | |
| v_z: @0 [0,2] | |
| efv0: vector [value] callparam @0 [1,2] | |
| efv0_x: @0 [1,2] | |
| efv0_y: @0 [1,2] | |
| efv0_z: @0 [1,2] | |
| call1: vector [return] @0 [2,3] | |
| call1_x: @0 [2,3] | |
| call1_y: @0 [2,3] | |
| call1_z: @0 [2,3] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efv0 <- FIELD_V wz, warpzone_transform | |
| (2) call1 <- CALL2 fn:AnglesTransform_Apply params: efv0, v, | |
| (3) RETURN call1 | |
| endfunction WarpZone_TransformVelocity | |
| function WarpZone_TransformAngles | |
| 2 locals: | |
| wz | |
| v | |
| liferanges: | |
| wz: entity [param] locked @0 [0,2] | |
| v: vector [param] locked @1 [0,2] | |
| v_x: @0 [0,2] | |
| v_y: @0 [0,2] | |
| v_z: @0 [0,2] | |
| efv0: vector [value] callparam @0 [1,2] | |
| efv0_x: @0 [1,2] | |
| efv0_y: @0 [1,2] | |
| efv0_z: @0 [1,2] | |
| call1: vector [return] @0 [2,3] | |
| call1_x: @0 [2,3] | |
| call1_y: @0 [2,3] | |
| call1_z: @0 [2,3] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efv0 <- FIELD_V wz, warpzone_transform | |
| (2) call1 <- CALL2 fn:AnglesTransform_ApplyToAngles params: efv0, v, | |
| (3) RETURN call1 | |
| endfunction WarpZone_TransformAngles | |
| function WarpZone_TransformVAngles | |
| 2 locals: | |
| wz | |
| ang | |
| liferanges: | |
| wz: entity [param] locked @0 [0,2] | |
| ang: vector [param] locked @1 [0,4] | |
| ang_x: @0 [0,4] | |
| ang_y: @0 [0,4] | |
| ang_z: @0 [0,4] | |
| efv0: vector [value] callparam @0 [1,2] | |
| efv0_x: @0 [1,2] | |
| efv0_y: @0 [1,2] | |
| efv0_z: @0 [1,2] | |
| call1: vector [value] @0 [null] | |
| call1_x: @0 | |
| call1_y: @0 | |
| call1_z: @0 | |
| call2: vector [value] @0 [null] | |
| call2_x: @0 | |
| call2_y: @0 | |
| call2_z: @0 | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efv0 <- FIELD_V wz, warpzone_transform | |
| (2) ang <- CALL2 fn:AnglesTransform_ApplyToVAngles params: efv0, ang, | |
| (3) ang <- CALL2 fn:AnglesTransform_Normalize params: ang, FALSE, | |
| (4) RETURN ang | |
| endfunction WarpZone_TransformVAngles | |
| function WarpZone_UnTransformOrigin | |
| 2 locals: | |
| wz | |
| v | |
| liferanges: | |
| wz: entity [param] locked @0 [0,4] | |
| v: vector [param] locked @1 [0,4] | |
| v_x: @0 [0,4] | |
| v_y: @0 [0,4] | |
| v_z: @0 [0,4] | |
| efv0: vector [value] callparam @0 [1,2] | |
| efv0_x: @0 [1,2] | |
| efv0_y: @0 [1,2] | |
| efv0_z: @0 [1,2] | |
| call1: vector [value] callparam @0 [2,5] | |
| call1_x: @0 [2,5] | |
| call1_y: @0 [2,5] | |
| call1_z: @0 [2,5] | |
| efv2: vector [value] @0 [3,4] | |
| efv2_x: @0 [3,4] | |
| efv2_y: @0 [3,4] | |
| efv2_z: @0 [3,4] | |
| bin3: vector [value] callparam @0 [4,5] | |
| bin3_x: @0 [4,5] | |
| bin3_y: @0 [4,5] | |
| bin3_z: @0 [4,5] | |
| call4: vector [return] @0 [5,6] | |
| call4_x: @0 [5,6] | |
| call4_y: @0 [5,6] | |
| call4_z: @0 [5,6] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efv0 <- FIELD_V wz, warpzone_transform | |
| (2) call1 <- CALL1 fn:AnglesTransform_Invert params: efv0, | |
| (3) efv2 <- FIELD_V wz, warpzone_shift | |
| (4) bin3 <- SUB_V v, efv2 | |
| (5) call4 <- CALL2 fn:AnglesTransform_Apply params: call1, bin3, | |
| (6) RETURN call4 | |
| endfunction WarpZone_UnTransformOrigin | |
| function WarpZone_UnTransformVelocity | |
| 2 locals: | |
| wz | |
| v | |
| liferanges: | |
| wz: entity [param] locked @0 [0,2] | |
| v: vector [param] locked @1 [0,3] | |
| v_x: @0 [0,3] | |
| v_y: @0 [0,3] | |
| v_z: @0 [0,3] | |
| efv0: vector [value] callparam @0 [1,2] | |
| efv0_x: @0 [1,2] | |
| efv0_y: @0 [1,2] | |
| efv0_z: @0 [1,2] | |
| call1: vector [value] callparam @0 [2,3] | |
| call1_x: @0 [2,3] | |
| call1_y: @0 [2,3] | |
| call1_z: @0 [2,3] | |
| call2: vector [return] @0 [3,4] | |
| call2_x: @0 [3,4] | |
| call2_y: @0 [3,4] | |
| call2_z: @0 [3,4] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efv0 <- FIELD_V wz, warpzone_transform | |
| (2) call1 <- CALL1 fn:AnglesTransform_Invert params: efv0, | |
| (3) call2 <- CALL2 fn:AnglesTransform_Apply params: call1, v, | |
| (4) RETURN call2 | |
| endfunction WarpZone_UnTransformVelocity | |
| function WarpZone_UnTransformAngles | |
| 2 locals: | |
| wz | |
| v | |
| liferanges: | |
| wz: entity [param] locked @0 [0,2] | |
| v: vector [param] locked @1 [0,3] | |
| v_x: @0 [0,3] | |
| v_y: @0 [0,3] | |
| v_z: @0 [0,3] | |
| efv0: vector [value] callparam @0 [1,2] | |
| efv0_x: @0 [1,2] | |
| efv0_y: @0 [1,2] | |
| efv0_z: @0 [1,2] | |
| call1: vector [value] callparam @0 [2,3] | |
| call1_x: @0 [2,3] | |
| call1_y: @0 [2,3] | |
| call1_z: @0 [2,3] | |
| call2: vector [return] @0 [3,4] | |
| call2_x: @0 [3,4] | |
| call2_y: @0 [3,4] | |
| call2_z: @0 [3,4] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efv0 <- FIELD_V wz, warpzone_transform | |
| (2) call1 <- CALL1 fn:AnglesTransform_Invert params: efv0, | |
| (3) call2 <- CALL2 fn:AnglesTransform_ApplyToAngles params: call1, v, | |
| (4) RETURN call2 | |
| endfunction WarpZone_UnTransformAngles | |
| function WarpZone_UnTransformVAngles | |
| 3 locals: | |
| wz | |
| ang | |
| roll | |
| liferanges: | |
| wz: entity [param] locked @0 [0,4] | |
| ang: vector [param] locked @1 [0,9] | |
| ang_x: @0 [0,9] | |
| ang_y: @0 [0,9] | |
| ang_z: @0 [0,9] | |
| roll: float [local] locked @4 [1,8] | |
| efv0: vector [value] callparam @0 [3,4] | |
| efv0_x: @0 [3,4] | |
| efv0_y: @0 [3,4] | |
| efv0_z: @0 [3,4] | |
| call1: vector [value] callparam @0 [4,5] | |
| call1_x: @0 [4,5] | |
| call1_y: @0 [4,5] | |
| call1_z: @0 [4,5] | |
| call2: vector [value] @0 [null] | |
| call2_x: @0 | |
| call2_y: @0 | |
| call2_z: @0 | |
| call3: vector [value] @0 [null] | |
| call3_x: @0 | |
| call3_y: @0 | |
| call3_z: @0 | |
| call4: vector [value] @0 [null] | |
| call4_x: @0 | |
| call4_y: @0 | |
| call4_z: @0 | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) roll <- STORE_F ang_z | |
| (2) ang_z <- STORE_F 0 | |
| (3) efv0 <- FIELD_V wz, warpzone_transform | |
| (4) call1 <- CALL1 fn:AnglesTransform_Invert params: efv0, | |
| (5) ang <- CALL2 fn:AnglesTransform_ApplyToVAngles params: call1, ang, | |
| (6) ang <- CALL2 fn:AnglesTransform_Normalize params: ang, TRUE, | |
| (7) ang <- CALL1 fn:AnglesTransform_CancelRoll params: ang, | |
| (8) ang_z <- STORE_F roll | |
| (9) RETURN ang | |
| endfunction WarpZone_UnTransformVAngles | |
| function WarpZone_RefSys_Clear | |
| 1 locals: | |
| me | |
| liferanges: | |
| me: entity [param] locked @0 [0,6] | |
| efv0: entity [value] @0 [1,2] | |
| efv2: entity [value] callparam @0 [4,5] | |
| call3: void [return] @0 [null] | |
| efa4: pointer [value] @0 [6,7] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efv0 <- FIELD_ENT me, WarpZone_refsys | |
| (2) COND efv0, [ontrue1], [endif5] | |
| :ontrue1 | |
| (3) [entry] | |
| (4) efv2 <- FIELD_ENT me, WarpZone_refsys | |
| (5) call3 <- CALL1 fn:remove params: efv2, | |
| (6) efa4 <- ADDRESS me, WarpZone_refsys | |
| (7) efa4 <- STOREP_ENT world | |
| (8) JUMP [endif5] | |
| :endif5 | |
| (9) [entry] | |
| (10) RETURN | |
| endfunction WarpZone_RefSys_Clear | |
| function WarpZone_RefSys_Add | |
| 2 locals: | |
| me | |
| wz | |
| liferanges: | |
| me: entity [param] locked @0 [0,3] | |
| wz: entity [param] locked @1 [0,3] | |
| efv0: vector [value] callparam @0 [1,3] | |
| efv0_x: @0 [1,3] | |
| efv0_y: @0 [1,3] | |
| efv0_z: @0 [1,3] | |
| efv1: vector [value] callparam @0 [2,3] | |
| efv1_x: @0 [2,3] | |
| efv1_y: @0 [2,3] | |
| efv1_z: @0 [2,3] | |
| call2: void [return] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efv0 <- FIELD_V wz, warpzone_transform | |
| (2) efv1 <- FIELD_V wz, warpzone_shift | |
| (3) call2 <- CALL3 fn:WarpZone_RefSys_AddTransform params: me, efv0, efv1, | |
| (4) RETURN | |
| endfunction WarpZone_RefSys_Add | |
| function WarpZone_RefSys_AddInverse | |
| 2 locals: | |
| me | |
| wz | |
| liferanges: | |
| me: entity [param] locked @0 [0,3] | |
| wz: entity [param] locked @1 [0,3] | |
| efv0: vector [value] callparam @0 [1,3] | |
| efv0_x: @0 [1,3] | |
| efv0_y: @0 [1,3] | |
| efv0_z: @0 [1,3] | |
| efv1: vector [value] callparam @0 [2,3] | |
| efv1_x: @0 [2,3] | |
| efv1_y: @0 [2,3] | |
| efv1_z: @0 [2,3] | |
| call2: void [return] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efv0 <- FIELD_V wz, warpzone_transform | |
| (2) efv1 <- FIELD_V wz, warpzone_shift | |
| (3) call2 <- CALL3 fn:WarpZone_RefSys_AddInverseTransform params: me, efv0, efv1, | |
| (4) RETURN | |
| endfunction WarpZone_RefSys_AddInverse | |
| function WarpZone_RefSys_AddTransform | |
| 3 locals: | |
| me | |
| t | |
| s | |
| liferanges: | |
| me: entity [param] locked @0 [0,12] | |
| t: vector [param] locked @1 [0,13] | |
| t_x: @0 [0,13] | |
| t_y: @0 [0,13] | |
| t_z: @0 [0,13] | |
| s: vector [param] locked @4 [0,13] | |
| s_x: @0 [0,13] | |
| s_y: @0 [0,13] | |
| s_z: @0 [0,13] | |
| bin1: float [value] @0 [1,3] | |
| bin3: float [value] @0 [null] | |
| sce_value4: float [value] @1 [2,3] [5,8] | |
| sce_bool5: float [value] @0 [8,9] | |
| call7: void [return] @0 [null] | |
| efv8: entity [value] callparam @0 [12,13] | |
| call9: void [return] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bin1 <- NE_V t, '0 0 0' | |
| (2) sce_value4 <- STORE_F bin1 | |
| (3) COND bin1, [sce_merge0], [sce_other2] | |
| :sce_other2 | |
| (4) [entry] | |
| (5) sce_value4 <- NE_V s, '0 0 0' | |
| (6) JUMP [sce_merge0] | |
| :sce_merge0 | |
| (7) [entry] | |
| (8) sce_bool5 <- AND sce_value4, sce_value4 | |
| (9) COND sce_bool5, [ontrue6], [endif10] | |
| :ontrue6 | |
| (10) [entry] | |
| (11) call7 <- CALL1 fn:WarpZone_RefSys_CheckCreate params: me, | |
| (12) efv8 <- FIELD_ENT me, WarpZone_refsys | |
| (13) call9 <- CALL3 fn:WarpZone_Accumulator_AddTransform params: efv8, t, s, | |
| (14) JUMP [endif10] | |
| :endif10 | |
| (15) [entry] | |
| (16) RETURN | |
| endfunction WarpZone_RefSys_AddTransform | |
| function WarpZone_RefSys_AddInverseTransform | |
| 3 locals: | |
| me | |
| t | |
| s | |
| liferanges: | |
| me: entity [param] locked @0 [0,12] | |
| t: vector [param] locked @1 [0,13] | |
| t_x: @0 [0,13] | |
| t_y: @0 [0,13] | |
| t_z: @0 [0,13] | |
| s: vector [param] locked @4 [0,13] | |
| s_x: @0 [0,13] | |
| s_y: @0 [0,13] | |
| s_z: @0 [0,13] | |
| bin1: float [value] @0 [1,3] | |
| bin3: float [value] @0 [null] | |
| sce_value4: float [value] @1 [2,3] [5,8] | |
| sce_bool5: float [value] @0 [8,9] | |
| call7: void [return] @0 [null] | |
| efv8: entity [value] callparam @0 [12,13] | |
| call9: void [return] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) bin1 <- NE_V t, '0 0 0' | |
| (2) sce_value4 <- STORE_F bin1 | |
| (3) COND bin1, [sce_merge0], [sce_other2] | |
| :sce_other2 | |
| (4) [entry] | |
| (5) sce_value4 <- NE_V s, '0 0 0' | |
| (6) JUMP [sce_merge0] | |
| :sce_merge0 | |
| (7) [entry] | |
| (8) sce_bool5 <- AND sce_value4, sce_value4 | |
| (9) COND sce_bool5, [ontrue6], [endif10] | |
| :ontrue6 | |
| (10) [entry] | |
| (11) call7 <- CALL1 fn:WarpZone_RefSys_CheckCreate params: me, | |
| (12) efv8 <- FIELD_ENT me, WarpZone_refsys | |
| (13) call9 <- CALL3 fn:WarpZone_Accumulator_AddInverseTransform params: efv8, t, s, | |
| (14) JUMP [endif10] | |
| :endif10 | |
| (15) [entry] | |
| (16) RETURN | |
| endfunction WarpZone_RefSys_AddInverseTransform | |
| function WarpZone_RefSys_AddIncrementally | |
| 2 locals: | |
| me | |
| ref | |
| liferanges: | |
| me: entity [param] locked @0 [0,11] [14,28] | |
| ref: entity [param] locked @1 [0,11] [14,29] | |
| efv0: vector [value] @0 [1,4] | |
| efv0_x: @0 [1,4] | |
| efv0_y: @0 [1,4] | |
| efv0_z: @0 [1,4] | |
| efv1: entity [value] @3 [2,4] | |
| efv2: vector [value] @4 [3,4] | |
| efv2_x: @0 [3,4] | |
| efv2_y: @0 [3,4] | |
| efv2_z: @0 [3,4] | |
| bin3: float [value] @0 [4,5] | |
| efv5: vector [value] @0 [7,10] | |
| efv5_x: @0 [7,10] | |
| efv5_y: @0 [7,10] | |
| efv5_z: @0 [7,10] | |
| efv6: entity [value] @3 [8,10] | |
| efv7: vector [value] @4 [9,10] | |
| efv7_x: @0 [9,10] | |
| efv7_y: @0 [9,10] | |
| efv7_z: @0 [9,10] | |
| bin8: float [value] @0 [10,11] | |
| efv12: entity [value] callparam @0 [17,20] | |
| efv13: vector [value] callparam @0 [18,20] | |
| efv13_x: @0 [18,20] | |
| efv13_y: @0 [18,20] | |
| efv13_z: @0 [18,20] | |
| efv14: vector [value] callparam @0 [19,20] | |
| efv14_x: @0 [19,20] | |
| efv14_y: @0 [19,20] | |
| efv14_z: @0 [19,20] | |
| call15: void [return] @0 [null] | |
| efv16: entity [value] callparam @0 [21,23] | |
| efv17: entity [value] callparam @0 [22,23] | |
| call18: void [return] @0 [null] | |
| efa19: pointer [value] @0 [24,27] | |
| efv20: entity [value] @3 [25,27] | |
| efv21: vector [value] @4 [26,27] | |
| efv21_x: @0 [26,27] | |
| efv21_y: @0 [26,27] | |
| efv21_z: @0 [26,27] | |
| efa22: pointer [value] @0 [28,31] | |
| efv23: entity [value] @3 [29,31] | |
| efv24: vector [value] @4 [30,31] | |
| efv24_x: @0 [30,31] | |
| efv24_y: @0 [30,31] | |
| efv24_z: @0 [30,31] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efv0 <- FIELD_V me, WarpZone_refsys_incremental_transform | |
| (2) efv1 <- FIELD_ENT ref, WarpZone_refsys | |
| (3) efv2 <- FIELD_V efv1, warpzone_transform | |
| (4) bin3 <- EQ_V efv0, efv2 | |
| (5) COND bin3, [ontrue4], [endif11] | |
| :ontrue4 | |
| (6) [entry] | |
| (7) efv5 <- FIELD_V me, WarpZone_refsys_incremental_shift | |
| (8) efv6 <- FIELD_ENT ref, WarpZone_refsys | |
| (9) efv7 <- FIELD_V efv6, warpzone_shift | |
| (10) bin8 <- EQ_V efv5, efv7 | |
| (11) COND bin8, [ontrue9], [endif10] | |
| :ontrue9 | |
| (12) [entry] | |
| (13) RETURN | |
| :endif10 | |
| (14) [entry] | |
| (15) JUMP [endif11] | |
| :endif11 | |
| (16) [entry] | |
| (17) efv12 <- FIELD_ENT me, WarpZone_refsys | |
| (18) efv13 <- FIELD_V me, WarpZone_refsys_incremental_transform | |
| (19) efv14 <- FIELD_V me, WarpZone_refsys_incremental_shift | |
| (20) call15 <- CALL3 fn:WarpZone_Accumulator_AddInverseTransform params: efv12, efv13, efv14, | |
| (21) efv16 <- FIELD_ENT me, WarpZone_refsys | |
| (22) efv17 <- FIELD_ENT ref, WarpZone_refsys | |
| (23) call18 <- CALL2 fn:WarpZone_Accumulator_Add params: efv16, efv17, | |
| (24) efa19 <- ADDRESS me, WarpZone_refsys_incremental_shift | |
| (25) efv20 <- FIELD_ENT ref, WarpZone_refsys | |
| (26) efv21 <- FIELD_V efv20, warpzone_shift | |
| (27) efa19 <- STOREP_V efv21 | |
| (28) efa22 <- ADDRESS me, WarpZone_refsys_incremental_transform | |
| (29) efv23 <- FIELD_ENT ref, WarpZone_refsys | |
| (30) efv24 <- FIELD_V efv23, warpzone_transform | |
| (31) efa22 <- STOREP_V efv24 | |
| (32) RETURN | |
| endfunction WarpZone_RefSys_AddIncrementally | |
| function WarpZone_RefSys_BeginAddingIncrementally | |
| 2 locals: | |
| me | |
| ref | |
| liferanges: | |
| me: entity [param] locked @0 [0,5] | |
| ref: entity [param] locked @1 [0,6] | |
| efa0: pointer [value] @0 [1,4] | |
| efv1: entity [value] @1 [2,4] | |
| efv2: vector [value] @2 [3,4] | |
| efv2_x: @0 [3,4] | |
| efv2_y: @0 [3,4] | |
| efv2_z: @0 [3,4] | |
| efa3: pointer [value] @0 [5,8] | |
| efv4: entity [value] @1 [6,8] | |
| efv5: vector [value] @2 [7,8] | |
| efv5_x: @0 [7,8] | |
| efv5_y: @0 [7,8] | |
| efv5_z: @0 [7,8] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efa0 <- ADDRESS me, WarpZone_refsys_incremental_shift | |
| (2) efv1 <- FIELD_ENT ref, WarpZone_refsys | |
| (3) efv2 <- FIELD_V efv1, warpzone_shift | |
| (4) efa0 <- STOREP_V efv2 | |
| (5) efa3 <- ADDRESS me, WarpZone_refsys_incremental_transform | |
| (6) efv4 <- FIELD_ENT ref, WarpZone_refsys | |
| (7) efv5 <- FIELD_V efv4, warpzone_transform | |
| (8) efa3 <- STOREP_V efv5 | |
| (9) RETURN | |
| endfunction WarpZone_RefSys_BeginAddingIncrementally | |
| function WarpZone_RefSys_TransformOrigin | |
| 3 locals: | |
| from | |
| to | |
| org | |
| liferanges: | |
| from: entity [param] locked @0 [0,4] | |
| to: entity [param] locked @1 [0,11] | |
| org: vector [param] locked @2 [0,15] | |
| org_x: @0 [0,15] | |
| org_y: @0 [0,15] | |
| org_z: @0 [0,15] | |
| efv0: entity [value] @0 [1,2] | |
| efv2: entity [value] callparam @0 [4,5] | |
| call3: vector [value] @0 [null] | |
| call3_x: @0 | |
| call3_y: @0 | |
| call3_z: @0 | |
| efv5: entity [value] @0 [8,9] | |
| efv7: entity [value] callparam @0 [11,12] | |
| call8: vector [value] @0 [null] | |
| call8_x: @0 | |
| call8_y: @0 | |
| call8_z: @0 | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efv0 <- FIELD_ENT from, WarpZone_refsys | |
| (2) COND efv0, [ontrue1], [endif4] | |
| :ontrue1 | |
| (3) [entry] | |
| (4) efv2 <- FIELD_ENT from, WarpZone_refsys | |
| (5) org <- CALL2 fn:WarpZone_UnTransformOrigin params: efv2, org, | |
| (6) JUMP [endif4] | |
| :endif4 | |
| (7) [entry] | |
| (8) efv5 <- FIELD_ENT to, WarpZone_refsys | |
| (9) COND efv5, [ontrue6], [endif9] | |
| :ontrue6 | |
| (10) [entry] | |
| (11) efv7 <- FIELD_ENT to, WarpZone_refsys | |
| (12) org <- CALL2 fn:WarpZone_TransformOrigin params: efv7, org, | |
| (13) JUMP [endif9] | |
| :endif9 | |
| (14) [entry] | |
| (15) RETURN org | |
| endfunction WarpZone_RefSys_TransformOrigin | |
| function WarpZone_RefSys_TransformVelocity | |
| 3 locals: | |
| from | |
| to | |
| vel | |
| liferanges: | |
| from: entity [param] locked @0 [0,4] | |
| to: entity [param] locked @1 [0,11] | |
| vel: vector [param] locked @2 [0,15] | |
| vel_x: @0 [0,15] | |
| vel_y: @0 [0,15] | |
| vel_z: @0 [0,15] | |
| efv0: entity [value] @0 [1,2] | |
| efv2: entity [value] callparam @0 [4,5] | |
| call3: vector [value] @0 [null] | |
| call3_x: @0 | |
| call3_y: @0 | |
| call3_z: @0 | |
| efv5: entity [value] @0 [8,9] | |
| efv7: entity [value] callparam @0 [11,12] | |
| call8: vector [value] @0 [null] | |
| call8_x: @0 | |
| call8_y: @0 | |
| call8_z: @0 | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efv0 <- FIELD_ENT from, WarpZone_refsys | |
| (2) COND efv0, [ontrue1], [endif4] | |
| :ontrue1 | |
| (3) [entry] | |
| (4) efv2 <- FIELD_ENT from, WarpZone_refsys | |
| (5) vel <- CALL2 fn:WarpZone_UnTransformVelocity params: efv2, vel, | |
| (6) JUMP [endif4] | |
| :endif4 | |
| (7) [entry] | |
| (8) efv5 <- FIELD_ENT to, WarpZone_refsys | |
| (9) COND efv5, [ontrue6], [endif9] | |
| :ontrue6 | |
| (10) [entry] | |
| (11) efv7 <- FIELD_ENT to, WarpZone_refsys | |
| (12) vel <- CALL2 fn:WarpZone_TransformVelocity params: efv7, vel, | |
| (13) JUMP [endif9] | |
| :endif9 | |
| (14) [entry] | |
| (15) RETURN vel | |
| endfunction WarpZone_RefSys_TransformVelocity | |
| function WarpZone_RefSys_TransformAngles | |
| 3 locals: | |
| from | |
| to | |
| ang | |
| liferanges: | |
| from: entity [param] locked @0 [0,4] | |
| to: entity [param] locked @1 [0,11] | |
| ang: vector [param] locked @2 [0,15] | |
| ang_x: @0 [0,15] | |
| ang_y: @0 [0,15] | |
| ang_z: @0 [0,15] | |
| efv0: entity [value] @0 [1,2] | |
| efv2: entity [value] callparam @0 [4,5] | |
| call3: vector [value] @0 [null] | |
| call3_x: @0 | |
| call3_y: @0 | |
| call3_z: @0 | |
| efv5: entity [value] @0 [8,9] | |
| efv7: entity [value] callparam @0 [11,12] | |
| call8: vector [value] @0 [null] | |
| call8_x: @0 | |
| call8_y: @0 | |
| call8_z: @0 | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efv0 <- FIELD_ENT from, WarpZone_refsys | |
| (2) COND efv0, [ontrue1], [endif4] | |
| :ontrue1 | |
| (3) [entry] | |
| (4) efv2 <- FIELD_ENT from, WarpZone_refsys | |
| (5) ang <- CALL2 fn:WarpZone_UnTransformAngles params: efv2, ang, | |
| (6) JUMP [endif4] | |
| :endif4 | |
| (7) [entry] | |
| (8) efv5 <- FIELD_ENT to, WarpZone_refsys | |
| (9) COND efv5, [ontrue6], [endif9] | |
| :ontrue6 | |
| (10) [entry] | |
| (11) efv7 <- FIELD_ENT to, WarpZone_refsys | |
| (12) ang <- CALL2 fn:WarpZone_TransformAngles params: efv7, ang, | |
| (13) JUMP [endif9] | |
| :endif9 | |
| (14) [entry] | |
| (15) RETURN ang | |
| endfunction WarpZone_RefSys_TransformAngles | |
| function WarpZone_RefSys_TransformVAngles | |
| 3 locals: | |
| from | |
| to | |
| ang | |
| liferanges: | |
| from: entity [param] locked @0 [0,4] | |
| to: entity [param] locked @1 [0,11] | |
| ang: vector [param] locked @2 [0,15] | |
| ang_x: @0 [0,15] | |
| ang_y: @0 [0,15] | |
| ang_z: @0 [0,15] | |
| efv0: entity [value] @0 [1,2] | |
| efv2: entity [value] callparam @0 [4,5] | |
| call3: vector [value] @0 [null] | |
| call3_x: @0 | |
| call3_y: @0 | |
| call3_z: @0 | |
| efv5: entity [value] @0 [8,9] | |
| efv7: entity [value] callparam @0 [11,12] | |
| call8: vector [value] @0 [null] | |
| call8_x: @0 | |
| call8_y: @0 | |
| call8_z: @0 | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efv0 <- FIELD_ENT from, WarpZone_refsys | |
| (2) COND efv0, [ontrue1], [endif4] | |
| :ontrue1 | |
| (3) [entry] | |
| (4) efv2 <- FIELD_ENT from, WarpZone_refsys | |
| (5) ang <- CALL2 fn:WarpZone_UnTransformVAngles params: efv2, ang, | |
| (6) JUMP [endif4] | |
| :endif4 | |
| (7) [entry] | |
| (8) efv5 <- FIELD_ENT to, WarpZone_refsys | |
| (9) COND efv5, [ontrue6], [endif9] | |
| :ontrue6 | |
| (10) [entry] | |
| (11) efv7 <- FIELD_ENT to, WarpZone_refsys | |
| (12) ang <- CALL2 fn:WarpZone_TransformVAngles params: efv7, ang, | |
| (13) JUMP [endif9] | |
| :endif9 | |
| (14) [entry] | |
| (15) RETURN ang | |
| endfunction WarpZone_RefSys_TransformVAngles | |
| function WarpZone_RefSys_Copy | |
| 2 locals: | |
| me | |
| from | |
| liferanges: | |
| me: entity [param] locked @0 [0,10] [16,17] | |
| from: entity [param] locked @1 [0,12] | |
| efv0: entity [value] @0 [1,2] | |
| call2: void [return] @0 [null] | |
| efv3: entity [value] @0 [5,6] | |
| efa4: pointer [value] @0 [6,9] | |
| efv5: entity [value] @1 [7,9] | |
| efv6: vector [value] @2 [8,9] | |
| efv6_x: @0 [8,9] | |
| efv6_y: @0 [8,9] | |
| efv6_z: @0 [8,9] | |
| efv7: entity [value] @0 [10,11] | |
| efa8: pointer [value] @0 [11,14] | |
| efv9: entity [value] @1 [12,14] | |
| efv10: vector [value] @2 [13,14] | |
| efv10_x: @0 [13,14] | |
| efv10_y: @0 [13,14] | |
| efv10_z: @0 [13,14] | |
| call12: void [return] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) efv0 <- FIELD_ENT from, WarpZone_refsys | |
| (2) COND efv0, [ontrue1], [onfalse11] | |
| :ontrue1 | |
| (3) [entry] | |
| (4) call2 <- CALL1 fn:WarpZone_RefSys_CheckCreate params: me, | |
| (5) efv3 <- FIELD_ENT me, WarpZone_refsys | |
| (6) efa4 <- ADDRESS efv3, warpzone_shift | |
| (7) efv5 <- FIELD_ENT from, WarpZone_refsys | |
| (8) efv6 <- FIELD_V efv5, warpzone_shift | |
| (9) efa4 <- STOREP_V efv6 | |
| (10) efv7 <- FIELD_ENT me, WarpZone_refsys | |
| (11) efa8 <- ADDRESS efv7, warpzone_transform | |
| (12) efv9 <- FIELD_ENT from, WarpZone_refsys | |
| (13) efv10 <- FIELD_V efv9, warpzone_transform | |
| (14) efa8 <- STOREP_V efv10 | |
| (15) JUMP [endif13] | |
| :onfalse11 | |
| (16) [entry] | |
| (17) call12 <- CALL1 fn:WarpZone_RefSys_Clear params: me, | |
| (18) JUMP [endif13] | |
| :endif13 | |
| (19) [entry] | |
| (20) RETURN | |
| endfunction WarpZone_RefSys_Copy | |
| function WarpZone_RefSys_SpawnSameRefSys | |
| 2 locals: | |
| me | |
| e | |
| liferanges: | |
| me: entity [param] locked @0 [0,2] | |
| e: entity [local] locked @1 [1,3] | |
| call0: entity [value] @0 [null] | |
| call1: void [return] @0 [null] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) e <- CALL0 fn:spawn | |
| (2) call1 <- CALL2 fn:WarpZone_RefSys_Copy params: e, me, | |
| (3) RETURN e | |
| endfunction WarpZone_RefSys_SpawnSameRefSys | |
| function WarpZone_Read | |
| 2 locals: | |
| isnew | |
| f | |
| liferanges: | |
| isnew: float [param] locked @0 [0,0] | |
| f: float [local] locked @0 [15,104] | |
| efv0: entity [value] @0 [2,3] | |
| efa2: pointer [value] locked @0 [5,7] | |
| call3: entity [return] @0 [6,7] | |
| efv4: entity [value] @0 [8,9] | |
| efa5: pointer [value] @0 [9,10] | |
| efa7: pointer [value] @0 [13,14] | |
| call8: float [value] @0 [null] | |
| efa9: pointer [value] @0 [16,18] | |
| bin10: float [value] @1 [17,18] | |
| bin11: float [value] @0 [19,20] | |
| efa13: pointer [value] locked @1 [22,24] | |
| call14: float [return] @0 [23,24] | |
| efa15: pointer [value] locked @1 [25,27] | |
| call16: float [return] @0 [26,27] | |
| efa17: pointer [value] locked @1 [28,30] | |
| call18: float [return] @0 [29,30] | |
| efa20: pointer [value] @0 [33,34] | |
| efa22: pointer [value] locked @1 [37,39] | |
| call23: float [return] @0 [38,39] | |
| efa24: pointer [value] locked @1 [40,42] | |
| call25: float [return] @0 [41,42] | |
| efa26: pointer [value] locked @1 [43,45] | |
| call27: float [return] @0 [44,45] | |
| efa28: pointer [value] locked @1 [46,48] | |
| call29: float [return] @0 [47,48] | |
| efa30: pointer [value] locked @1 [49,51] | |
| call31: float [return] @0 [50,51] | |
| efa32: pointer [value] locked @1 [52,54] | |
| call33: float [return] @0 [53,54] | |
| efa34: pointer [value] locked @1 [55,57] | |
| call35: float [return] @0 [56,57] | |
| efa36: pointer [value] locked @1 [58,61] | |
| call37: float [return] @0 [59,60] | |
| bin38: float [value] @0 [60,61] | |
| efv39: entity [value] @0 [62,63] | |
| efa40: pointer [value] locked @1 [63,65] | |
| call41: float [return] @0 [64,65] | |
| efv42: entity [value] @0 [66,67] | |
| efa43: pointer [value] locked @1 [67,69] | |
| call44: float [return] @0 [68,69] | |
| efv45: entity [value] @0 [70,71] | |
| efa46: pointer [value] locked @1 [71,73] | |
| call47: float [return] @0 [72,73] | |
| efv48: entity [value] @0 [74,75] | |
| efa49: pointer [value] locked @1 [75,77] | |
| call50: float [return] @0 [76,77] | |
| efv51: entity [value] @0 [78,79] | |
| efa52: pointer [value] locked @1 [79,81] | |
| call53: float [return] @0 [80,81] | |
| efv54: entity [value] @0 [82,83] | |
| efa55: pointer [value] locked @1 [83,85] | |
| call56: float [return] @0 [84,85] | |
| efa57: pointer [value] locked @1 [86,88] | |
| call58: float [return] @0 [87,88] | |
| efa59: pointer [value] locked @1 [89,91] | |
| call60: float [return] @0 [90,91] | |
| efa61: pointer [value] locked @1 [92,94] | |
| call62: float [return] @0 [93,94] | |
| efa63: pointer [value] locked @1 [95,97] | |
| call64: float [return] @0 [96,97] | |
| efa65: pointer [value] locked @1 [98,100] | |
| call66: float [return] @0 [99,100] | |
| efa67: pointer [value] locked @1 [101,103] | |
| call68: float [return] @0 [102,103] | |
| bin69: float [value] @0 [104,105] | |
| efa71: pointer [value] locked @0 [107,109] | |
| call72: float [return] @0 [108,109] | |
| efa73: pointer [value] locked @0 [110,115] | |
| efv74: float [value] @0 [111,112] | |
| bin75: float [value] locked @1 [112,114] | |
| call76: float [value] callparam @0 [113,114] | |
| call77: float [return] @0 [114,115] | |
| efa79: pointer [value] @0 [118,119] | |
| efa80: pointer [value] @0 [120,121] | |
| efv82: entity [value] @0 [124,126] | |
| efv83: vector [value] callparam @0 [125,130] | |
| efv83_x: @0 [125,130] | |
| efv83_y: @0 [125,130] | |
| efv83_z: @0 [125,130] | |
| efv84: entity [value] @0 [126,128] | |
| efv85: vector [value] callparam @0 [127,130] | |
| efv85_x: @0 [127,130] | |
| efv85_y: @0 [127,130] | |
| efv85_z: @0 [127,130] | |
| efv86: vector [value] callparam @0 [128,130] | |
| efv86_x: @0 [128,130] | |
| efv86_y: @0 [128,130] | |
| efv86_z: @0 [128,130] | |
| efv87: vector [value] callparam @0 [129,130] | |
| efv87_x: @0 [129,130] | |
| efv87_y: @0 [129,130] | |
| efv87_z: @0 [129,130] | |
| call88: void [return] @0 [null] | |
| efv89: vector [value] callparam @0 [131,132] | |
| efv89_x: @0 [131,132] | |
| efv89_y: @0 [131,132] | |
| efv89_z: @0 [131,132] | |
| call90: void [return] @0 [null] | |
| efv91: vector [value] callparam @0 [133,135] | |
| efv91_x: @0 [133,135] | |
| efv91_y: @0 [133,135] | |
| efv91_z: @0 [133,135] | |
| efv92: vector [value] callparam @0 [134,135] | |
| efv92_x: @0 [134,135] | |
| efv92_y: @0 [134,135] | |
| efv92_z: @0 [134,135] | |
| call93: void [return] @0 [null] | |
| efa94: pointer [value] @0 [136,137] | |
| life passes: 2 | |
| :entry | |
| (0) [entry] | |
| (1) warpzone_warpzones_exist <- STORE_F 1 | |
| (2) efv0 <- FIELD_ENT self, enemy | |
| (3) COND efv0, [endif6], [onfalse1] | |
| :onfalse1 | |
| (4) [entry] | |
| (5) efa2 <- ADDRESS self, enemy | |
| (6) call3 <- CALL0 fn:spawn | |
| (7) efa2 <- STOREP_ENT call3 | |
| (8) efv4 <- FIELD_ENT self, enemy | |
| (9) efa5 <- ADDRESS efv4, classname | |
| (10) efa5 <- STOREP_S "warpzone_from" | |
| (11) JUMP [endif6] | |
| :endif6 | |
| (12) [entry] | |
| (13) efa7 <- ADDRESS self, classname | |
| (14) efa7 <- STOREP_S "trigger_warpzone" | |
| (15) f <- CALL0 fn:ReadByte | |
| (16) efa9 <- ADDRESS self, warpzone_isboxy | |
| (17) bin10 <- BITAND f, 1 | |
| (18) efa9 <- STOREP_F bin10 | |
| (19) bin11 <- BITAND f, 4 | |
| (20) COND bin11, [ontrue12], [onfalse19] | |
| :ontrue12 | |
| (21) [entry] | |
| (22) efa13 <- ADDRESS self, origin_x | |
| (23) call14 <- CALL0 fn:ReadCoord | |
| (24) efa13 <- STOREP_F call14 | |
| (25) efa15 <- ADDRESS self, origin_y | |
| (26) call16 <- CALL0 fn:ReadCoord | |
| (27) efa15 <- STOREP_F call16 | |
| (28) efa17 <- ADDRESS self, origin_z | |
| (29) call18 <- CALL0 fn:ReadCoord | |
| (30) efa17 <- STOREP_F call18 | |
| (31) JUMP [endif21] | |
| :onfalse19 | |
| (32) [entry] | |
| (33) efa20 <- ADDRESS self, origin | |
| (34) efa20 <- STOREP_V '0 0 0' | |
| (35) JUMP [endif21] | |
| :endif21 | |
| (36) [entry] | |
| (37) efa22 <- ADDRESS self, modelindex | |
| (38) call23 <- CALL0 fn:ReadShort | |
| (39) efa22 <- STOREP_F call23 | |
| (40) efa24 <- ADDRESS self, mins_x | |
| (41) call25 <- CALL0 fn:ReadCoord | |
| (42) efa24 <- STOREP_F call25 | |
| (43) efa26 <- ADDRESS self, mins_y | |
| (44) call27 <- CALL0 fn:ReadCoord | |
| (45) efa26 <- STOREP_F call27 | |
| (46) efa28 <- ADDRESS self, mins_z | |
| (47) call29 <- CALL0 fn:ReadCoord | |
| (48) efa28 <- STOREP_F call29 | |
| (49) efa30 <- ADDRESS self, maxs_x | |
| (50) call31 <- CALL0 fn:ReadCoord | |
| (51) efa30 <- STOREP_F call31 | |
| (52) efa32 <- ADDRESS self, maxs_y | |
| (53) call33 <- CALL0 fn:ReadCoord | |
| (54) efa32 <- STOREP_F call33 | |
| (55) efa34 <- ADDRESS self, maxs_z | |
| (56) call35 <- CALL0 fn:ReadCoord | |
| (57) efa34 <- STOREP_F call35 | |
| (58) efa36 <- ADDRESS self, scale | |
| (59) call37 <- CALL0 fn:ReadByte | |
| (60) bin38 <- DIV call37, 16 | |
| (61) efa36 <- STOREP_F bin38 | |
| (62) efv39 <- FIELD_ENT self, enemy | |
| (63) efa40 <- ADDRESS efv39, oldorigin_x | |
| (64) call41 <- CALL0 fn:ReadCoord | |
| (65) efa40 <- STOREP_F call41 | |
| (66) efv42 <- FIELD_ENT self, enemy | |
| (67) efa43 <- ADDRESS efv42, oldorigin_y | |
| (68) call44 <- CALL0 fn:ReadCoord | |
| (69) efa43 <- STOREP_F call44 | |
| (70) efv45 <- FIELD_ENT self, enemy | |
| (71) efa46 <- ADDRESS efv45, oldorigin_z | |
| (72) call47 <- CALL0 fn:ReadCoord | |
| (73) efa46 <- STOREP_F call47 | |
| (74) efv48 <- FIELD_ENT self, enemy | |
| (75) efa49 <- ADDRESS efv48, avelocity_x | |
| (76) call50 <- CALL0 fn:ReadCoord | |
| (77) efa49 <- STOREP_F call50 | |
| (78) efv51 <- FIELD_ENT self, enemy | |
| (79) efa52 <- ADDRESS efv51, avelocity_y | |
| (80) call53 <- CALL0 fn:ReadCoord | |
| (81) efa52 <- STOREP_F call53 | |
| (82) efv54 <- FIELD_ENT self, enemy | |
| (83) efa55 <- ADDRESS efv54, avelocity_z | |
| (84) call56 <- CALL0 fn:ReadCoord | |
| (85) efa55 <- STOREP_F call56 | |
| (86) efa57 <- ADDRESS self, oldorigin_x | |
| (87) call58 <- CALL0 fn:ReadCoord | |
| (88) efa57 <- STOREP_F call58 | |
| (89) efa59 <- ADDRESS self, oldorigin_y | |
| (90) call60 <- CALL0 fn:ReadCoord | |
| (91) efa59 <- STOREP_F call60 | |
| (92) efa61 <- ADDRESS self, oldorigin_z | |
| (93) call62 <- CALL0 fn:ReadCoord | |
| (94) efa61 <- STOREP_F call62 | |
| (95) efa63 <- ADDRESS self, avelocity_x | |
| (96) call64 <- CALL0 fn:ReadCoord | |
| (97) efa63 <- STOREP_F call64 | |
| (98) efa65 <- ADDRESS self, avelocity_y | |
| (99) call66 <- CALL0 fn:ReadCoord | |
| (100) efa65 <- STOREP_F call66 | |
| (101) efa67 <- ADDRESS self, avelocity_z | |
| (102) call68 <- CALL0 fn:ReadCoord | |
| (103) efa67 <- STOREP_F call68 | |
| (104) bin69 <- BITAND f, 2 | |
| (105) COND bin69, [ontrue70], [onfalse78] | |
| :ontrue70 | |
| (106) [entry] | |
| (107) efa71 <- ADDRESS self, warpzone_fadestart | |
| (108) call72 <- CALL0 fn:ReadShort | |
| (109) efa71 <- STOREP_F call72 | |
| (110) efa73 <- ADDRESS self, warpzone_fadeend | |
| (111) efv74 <- FIELD_F self, warpzone_fadestart | |
| (112) bin75 <- ADD_F efv74, 1 | |
| (113) call76 <- CALL0 fn:ReadShort | |
| (114) call77 <- CALL2 fn:max params: bin75, call76, | |
| (115) efa73 <- STOREP_F call77 | |
| (116) JUMP [endif81] | |
| :onfalse78 | |
| (117) [entry] | |
| (118) efa79 <- ADDRESS self, warpzone_fadestart | |
| (119) efa79 <- STOREP_F 0 | |
| (120) efa80 <- ADDRESS self, warpzone_fadeend | |
| (121) efa80 <- STOREP_F 0 | |
| (122) JUMP [endif81] | |
| :endif81 | |
| (123) [entry] | |
| (124) efv82 <- FIELD_ENT self, enemy | |
| (125) efv83 <- FIELD_V efv82, oldorigin | |
| (126) efv84 <- FIELD_ENT self, enemy | |
| (127) efv85 <- FIELD_V efv84, avelocity | |
| (128) efv86 <- FIELD_V self, oldorigin | |
| (129) efv87 <- FIELD_V self, avelocity | |
| (130) call88 <- CALL5 fn:WarpZone_SetUp params: self, efv83, efv85, efv86, efv87, | |
| (131) efv89 <- FIELD_V self, origin | |
| (132) call90 <- CALL2 fn:setorigin params: self, efv89, | |
| (133) efv91 <- FIELD_V self, mins | |
| (134) efv92 <- FIELD_V self, maxs | |
| (135) call93 <- CALL3 fn:setsize params: self, efv91, efv92, | |
| (136) efa94 <- ADDRESS self, predraw | |
| (137) efa94 <- STOREP_FNC fn:WarpZone_Fade_PreDraw | |
| (138) RETURN | |
| endfunction WarpZone_Read | |
| endmodule gmqcc_out |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment