1use serde::Deserialize;
2use vbsp_common::deserialize_bool;
3use vbsp_common::{Angles, Color, LightColor, Negated, Vector};
4#[derive(Debug, Clone, Deserialize)]
5#[non_exhaustive]
6#[serde(tag = "classname")]
7pub enum Entity<'a> {
8 #[serde(rename = "ambient_generic")]
9 #[serde(borrow)]
10 AmbientGeneric(AmbientGeneric<'a>),
11 #[serde(rename = "cycler")]
12 #[serde(borrow)]
13 Cycler(Cycler<'a>),
14 #[serde(rename = "env_beam")]
15 #[serde(borrow)]
16 EnvBeam(EnvBeam<'a>),
17 #[serde(rename = "env_bubbles")]
18 #[serde(borrow)]
19 EnvBubbles(EnvBubbles<'a>),
20 #[serde(rename = "env_detail_controller")]
21 EnvDetailController(EnvDetailController),
22 #[serde(rename = "env_embers")]
23 #[serde(borrow)]
24 EnvEmbers(EnvEmbers<'a>),
25 #[serde(rename = "env_entity_maker")]
26 #[serde(borrow)]
27 EnvEntityMaker(EnvEntityMaker<'a>),
28 #[serde(rename = "env_explosion")]
29 #[serde(borrow)]
30 EnvExplosion(EnvExplosion<'a>),
31 #[serde(rename = "env_fade")]
32 #[serde(borrow)]
33 EnvFade(EnvFade<'a>),
34 #[serde(rename = "env_fire")]
35 #[serde(borrow)]
36 EnvFire(EnvFire<'a>),
37 #[serde(rename = "env_fire_trail")]
38 #[serde(borrow)]
39 EnvFireTrail(EnvFireTrail<'a>),
40 #[serde(rename = "env_firesource")]
41 EnvFiresource(EnvFiresource),
42 #[serde(rename = "env_fog_controller")]
43 #[serde(borrow)]
44 EnvFogController(EnvFogController<'a>),
45 #[serde(rename = "env_hudhint")]
46 #[serde(borrow)]
47 EnvHudhint(EnvHudhint<'a>),
48 #[serde(rename = "env_laser")]
49 #[serde(borrow)]
50 EnvLaser(EnvLaser<'a>),
51 #[serde(rename = "env_lightglow")]
52 EnvLightglow(EnvLightglow),
53 #[serde(rename = "env_physexplosion")]
54 #[serde(borrow)]
55 EnvPhysexplosion(EnvPhysexplosion<'a>),
56 #[serde(rename = "env_projectedtexture")]
57 #[serde(borrow)]
58 EnvProjectedtexture(EnvProjectedtexture<'a>),
59 #[serde(rename = "env_screenoverlay")]
60 #[serde(borrow)]
61 EnvScreenoverlay(EnvScreenoverlay<'a>),
62 #[serde(rename = "env_shake")]
63 #[serde(borrow)]
64 EnvShake(EnvShake<'a>),
65 #[serde(rename = "env_shooter")]
66 #[serde(borrow)]
67 EnvShooter(EnvShooter<'a>),
68 #[serde(rename = "env_smokestack")]
69 #[serde(borrow)]
70 EnvSmokestack(EnvSmokestack<'a>),
71 #[serde(rename = "env_soundscape")]
72 #[serde(borrow)]
73 EnvSoundscape(EnvSoundscape<'a>),
74 #[serde(rename = "env_soundscape_proxy")]
75 #[serde(borrow)]
76 EnvSoundscapeProxy(EnvSoundscapeProxy<'a>),
77 #[serde(rename = "env_soundscape_triggerable")]
78 #[serde(borrow)]
79 EnvSoundscapeTriggerable(EnvSoundscapeTriggerable<'a>),
80 #[serde(rename = "env_spark")]
81 #[serde(borrow)]
82 EnvSpark(EnvSpark<'a>),
83 #[serde(rename = "env_sprite")]
84 #[serde(borrow)]
85 EnvSprite(EnvSprite<'a>),
86 #[serde(rename = "env_spritetrail")]
87 #[serde(borrow)]
88 EnvSpritetrail(EnvSpritetrail<'a>),
89 #[serde(rename = "env_steam")]
90 #[serde(borrow)]
91 EnvSteam(EnvSteam<'a>),
92 #[serde(rename = "env_sun")]
93 #[serde(borrow)]
94 EnvSun(EnvSun<'a>),
95 #[serde(rename = "env_tonemap_controller")]
96 #[serde(borrow)]
97 EnvTonemapController(EnvTonemapController<'a>),
98 #[serde(rename = "env_wind")]
99 EnvWind(EnvWind),
100 #[serde(rename = "filter_activator_class")]
101 #[serde(borrow)]
102 FilterActivatorClass(FilterActivatorClass<'a>),
103 #[serde(rename = "filter_activator_name")]
104 #[serde(borrow)]
105 FilterActivatorName(FilterActivatorName<'a>),
106 #[serde(rename = "filter_damage_type")]
107 #[serde(borrow)]
108 FilterDamageType(FilterDamageType<'a>),
109 #[serde(rename = "filter_multi")]
110 #[serde(borrow)]
111 FilterMulti(FilterMulti<'a>),
112 #[serde(rename = "func_areaportal")]
113 #[serde(borrow)]
114 FuncAreaportal(FuncAreaportal<'a>),
115 #[serde(rename = "func_areaportalwindow")]
116 #[serde(borrow)]
117 FuncAreaportalwindow(FuncAreaportalwindow<'a>),
118 #[serde(rename = "func_bomb_target")]
119 #[serde(borrow)]
120 FuncBombTarget(FuncBombTarget<'a>),
121 #[serde(rename = "func_breakable")]
122 #[serde(borrow)]
123 FuncBreakable(FuncBreakable<'a>),
124 #[serde(rename = "func_breakable_surf")]
125 #[serde(borrow)]
126 FuncBreakableSurf(FuncBreakableSurf<'a>),
127 #[serde(rename = "func_brush")]
128 #[serde(borrow)]
129 FuncBrush(FuncBrush<'a>),
130 #[serde(rename = "func_button")]
131 #[serde(borrow)]
132 FuncButton(FuncButton<'a>),
133 #[serde(rename = "func_buyzone")]
134 #[serde(borrow)]
135 FuncBuyzone(FuncBuyzone<'a>),
136 #[serde(rename = "func_clip_vphysics")]
137 #[serde(borrow)]
138 FuncClipVphysics(FuncClipVphysics<'a>),
139 #[serde(rename = "func_conveyor")]
140 #[serde(borrow)]
141 FuncConveyor(FuncConveyor<'a>),
142 #[serde(rename = "func_door")]
143 #[serde(borrow)]
144 FuncDoor(FuncDoor<'a>),
145 #[serde(rename = "func_door_rotating")]
146 #[serde(borrow)]
147 FuncDoorRotating(FuncDoorRotating<'a>),
148 #[serde(rename = "func_dustcloud")]
149 #[serde(borrow)]
150 FuncDustcloud(FuncDustcloud<'a>),
151 #[serde(rename = "func_dustmotes")]
152 #[serde(borrow)]
153 FuncDustmotes(FuncDustmotes<'a>),
154 #[serde(rename = "func_fish_pool")]
155 #[serde(borrow)]
156 FuncFishPool(FuncFishPool<'a>),
157 #[serde(rename = "func_footstep_control")]
158 #[serde(borrow)]
159 FuncFootstepControl(FuncFootstepControl<'a>),
160 #[serde(rename = "func_hostage_rescue")]
161 #[serde(borrow)]
162 FuncHostageRescue(FuncHostageRescue<'a>),
163 #[serde(rename = "func_illusionary")]
164 #[serde(borrow)]
165 FuncIllusionary(FuncIllusionary<'a>),
166 #[serde(rename = "func_lod")]
167 #[serde(borrow)]
168 FuncLod(FuncLod<'a>),
169 #[serde(rename = "func_monitor")]
170 #[serde(borrow)]
171 FuncMonitor(FuncMonitor<'a>),
172 #[serde(rename = "func_movelinear")]
173 #[serde(borrow)]
174 FuncMovelinear(FuncMovelinear<'a>),
175 #[serde(rename = "func_occluder")]
176 #[serde(borrow)]
177 FuncOccluder(FuncOccluder<'a>),
178 #[serde(rename = "func_physbox")]
179 #[serde(borrow)]
180 FuncPhysbox(FuncPhysbox<'a>),
181 #[serde(rename = "func_physbox_multiplayer")]
182 #[serde(borrow)]
183 FuncPhysboxMultiplayer(FuncPhysboxMultiplayer<'a>),
184 #[serde(rename = "func_precipitation")]
185 #[serde(borrow)]
186 FuncPrecipitation(FuncPrecipitation<'a>),
187 #[serde(rename = "func_rot_button")]
188 #[serde(borrow)]
189 FuncRotButton(FuncRotButton<'a>),
190 #[serde(rename = "func_rotating")]
191 #[serde(borrow)]
192 FuncRotating(FuncRotating<'a>),
193 #[serde(rename = "func_smokevolume")]
194 #[serde(borrow)]
195 FuncSmokevolume(FuncSmokevolume<'a>),
196 #[serde(rename = "func_tracktrain")]
197 #[serde(borrow)]
198 FuncTracktrain(FuncTracktrain<'a>),
199 #[serde(rename = "func_train")]
200 #[serde(borrow)]
201 FuncTrain(FuncTrain<'a>),
202 #[serde(rename = "func_wall")]
203 #[serde(borrow)]
204 FuncWall(FuncWall<'a>),
205 #[serde(rename = "func_wall_toggle")]
206 #[serde(borrow)]
207 FuncWallToggle(FuncWallToggle<'a>),
208 #[serde(rename = "func_water_analog")]
209 #[serde(borrow)]
210 FuncWaterAnalog(FuncWaterAnalog<'a>),
211 #[serde(rename = "game_player_equip")]
212 #[serde(borrow)]
213 GamePlayerEquip(GamePlayerEquip<'a>),
214 #[serde(rename = "game_text")]
215 #[serde(borrow)]
216 GameText(GameText<'a>),
217 #[serde(rename = "game_ui")]
218 #[serde(borrow)]
219 GameUi(GameUi<'a>),
220 #[serde(rename = "game_weapon_manager")]
221 #[serde(borrow)]
222 GameWeaponManager(GameWeaponManager<'a>),
223 #[serde(rename = "hostage_entity")]
224 #[serde(borrow)]
225 HostageEntity(HostageEntity<'a>),
226 #[serde(rename = "info_camera_link")]
227 #[serde(borrow)]
228 InfoCameraLink(InfoCameraLink<'a>),
229 #[serde(rename = "info_ladder")]
230 InfoLadder(InfoLadder),
231 #[serde(rename = "info_lighting_relative")]
232 #[serde(borrow)]
233 InfoLightingRelative(InfoLightingRelative<'a>),
234 #[serde(rename = "info_map_parameters")]
235 InfoMapParameters(InfoMapParameters),
236 #[serde(rename = "info_node")]
237 InfoNode(InfoNode),
238 #[serde(rename = "info_node_hint")]
239 InfoNodeHint(InfoNodeHint),
240 #[serde(rename = "info_particle_system")]
241 #[serde(borrow)]
242 InfoParticleSystem(InfoParticleSystem<'a>),
243 #[serde(rename = "info_player_counterterrorist")]
244 InfoPlayerCounterterrorist(InfoPlayerCounterterrorist),
245 #[serde(rename = "info_player_logo")]
246 InfoPlayerLogo(InfoPlayerLogo),
247 #[serde(rename = "info_player_start")]
248 InfoPlayerStart(InfoPlayerStart),
249 #[serde(rename = "info_player_terrorist")]
250 InfoPlayerTerrorist(InfoPlayerTerrorist),
251 #[serde(rename = "info_target")]
252 #[serde(borrow)]
253 InfoTarget(InfoTarget<'a>),
254 #[serde(rename = "info_teleport_destination")]
255 #[serde(borrow)]
256 InfoTeleportDestination(InfoTeleportDestination<'a>),
257 #[serde(rename = "infodecal")]
258 #[serde(borrow)]
259 Infodecal(Infodecal<'a>),
260 #[serde(rename = "keyframe_rope")]
261 #[serde(borrow)]
262 KeyframeRope(KeyframeRope<'a>),
263 #[serde(rename = "light")]
264 #[serde(borrow)]
265 Light(Light<'a>),
266 #[serde(rename = "light_environment")]
267 #[serde(borrow)]
268 LightEnvironment(LightEnvironment<'a>),
269 #[serde(rename = "light_spot")]
270 #[serde(borrow)]
271 LightSpot(LightSpot<'a>),
272 #[serde(rename = "logic_auto")]
273 #[serde(borrow)]
274 LogicAuto(LogicAuto<'a>),
275 #[serde(rename = "logic_branch")]
276 #[serde(borrow)]
277 LogicBranch(LogicBranch<'a>),
278 #[serde(rename = "logic_case")]
279 #[serde(borrow)]
280 LogicCase(LogicCase<'a>),
281 #[serde(rename = "logic_compare")]
282 #[serde(borrow)]
283 LogicCompare(LogicCompare<'a>),
284 #[serde(rename = "logic_measure_movement")]
285 #[serde(borrow)]
286 LogicMeasureMovement(LogicMeasureMovement<'a>),
287 #[serde(rename = "logic_relay")]
288 #[serde(borrow)]
289 LogicRelay(LogicRelay<'a>),
290 #[serde(rename = "logic_timer")]
291 #[serde(borrow)]
292 LogicTimer(LogicTimer<'a>),
293 #[serde(rename = "math_counter")]
294 #[serde(borrow)]
295 MathCounter(MathCounter<'a>),
296 #[serde(rename = "move_rope")]
297 #[serde(borrow)]
298 MoveRope(MoveRope<'a>),
299 #[serde(rename = "path_track")]
300 #[serde(borrow)]
301 PathTrack(PathTrack<'a>),
302 #[serde(rename = "phys_ballsocket")]
303 #[serde(borrow)]
304 PhysBallsocket(PhysBallsocket<'a>),
305 #[serde(rename = "phys_constraint")]
306 #[serde(borrow)]
307 PhysConstraint(PhysConstraint<'a>),
308 #[serde(rename = "phys_constraintsystem")]
309 #[serde(borrow)]
310 PhysConstraintsystem(PhysConstraintsystem<'a>),
311 #[serde(rename = "phys_hinge")]
312 #[serde(borrow)]
313 PhysHinge(PhysHinge<'a>),
314 #[serde(rename = "phys_keepupright")]
315 #[serde(borrow)]
316 PhysKeepupright(PhysKeepupright<'a>),
317 #[serde(rename = "phys_lengthconstraint")]
318 #[serde(borrow)]
319 PhysLengthconstraint(PhysLengthconstraint<'a>),
320 #[serde(rename = "phys_pulleyconstraint")]
321 #[serde(borrow)]
322 PhysPulleyconstraint(PhysPulleyconstraint<'a>),
323 #[serde(rename = "phys_ragdollconstraint")]
324 #[serde(borrow)]
325 PhysRagdollconstraint(PhysRagdollconstraint<'a>),
326 #[serde(rename = "phys_ragdollmagnet")]
327 PhysRagdollmagnet(PhysRagdollmagnet),
328 #[serde(rename = "phys_thruster")]
329 #[serde(borrow)]
330 PhysThruster(PhysThruster<'a>),
331 #[serde(rename = "phys_torque")]
332 #[serde(borrow)]
333 PhysTorque(PhysTorque<'a>),
334 #[serde(rename = "player_speedmod")]
335 #[serde(borrow)]
336 PlayerSpeedmod(PlayerSpeedmod<'a>),
337 #[serde(rename = "player_weaponstrip")]
338 #[serde(borrow)]
339 PlayerWeaponstrip(PlayerWeaponstrip<'a>),
340 #[serde(rename = "point_camera")]
341 #[serde(borrow)]
342 PointCamera(PointCamera<'a>),
343 #[serde(rename = "point_clientcommand")]
344 #[serde(borrow)]
345 PointClientcommand(PointClientcommand<'a>),
346 #[serde(rename = "point_devshot_camera")]
347 #[serde(borrow)]
348 PointDevshotCamera(PointDevshotCamera<'a>),
349 #[serde(rename = "point_servercommand")]
350 #[serde(borrow)]
351 PointServercommand(PointServercommand<'a>),
352 #[serde(rename = "point_spotlight")]
353 #[serde(borrow)]
354 PointSpotlight(PointSpotlight<'a>),
355 #[serde(rename = "point_surroundtest")]
356 #[serde(borrow)]
357 PointSurroundtest(PointSurroundtest<'a>),
358 #[serde(rename = "point_template")]
359 #[serde(borrow)]
360 PointTemplate(PointTemplate<'a>),
361 #[serde(rename = "point_tesla")]
362 #[serde(borrow)]
363 PointTesla(PointTesla<'a>),
364 #[serde(rename = "point_viewcontrol")]
365 #[serde(borrow)]
366 PointViewcontrol(PointViewcontrol<'a>),
367 #[serde(rename = "prop_door_rotating")]
368 #[serde(borrow)]
369 PropDoorRotating(PropDoorRotating<'a>),
370 #[serde(rename = "prop_dynamic")]
371 #[serde(borrow)]
372 PropDynamic(PropDynamic<'a>),
373 #[serde(rename = "prop_dynamic_override")]
374 #[serde(borrow)]
375 PropDynamicOverride(PropDynamicOverride<'a>),
376 #[serde(rename = "prop_physics")]
377 #[serde(borrow)]
378 PropPhysics(PropPhysics<'a>),
379 #[serde(rename = "prop_physics_multiplayer")]
380 #[serde(borrow)]
381 PropPhysicsMultiplayer(PropPhysicsMultiplayer<'a>),
382 #[serde(rename = "prop_physics_override")]
383 #[serde(borrow)]
384 PropPhysicsOverride(PropPhysicsOverride<'a>),
385 #[serde(rename = "prop_ragdoll")]
386 #[serde(borrow)]
387 PropRagdoll(PropRagdoll<'a>),
388 #[serde(rename = "shadow_control")]
389 ShadowControl(ShadowControl),
390 #[serde(rename = "sky_camera")]
391 SkyCamera(SkyCamera),
392 #[serde(rename = "trigger_gravity")]
393 #[serde(borrow)]
394 TriggerGravity(TriggerGravity<'a>),
395 #[serde(rename = "trigger_hurt")]
396 #[serde(borrow)]
397 TriggerHurt(TriggerHurt<'a>),
398 #[serde(rename = "trigger_look")]
399 #[serde(borrow)]
400 TriggerLook(TriggerLook<'a>),
401 #[serde(rename = "trigger_multiple")]
402 #[serde(borrow)]
403 TriggerMultiple(TriggerMultiple<'a>),
404 #[serde(rename = "trigger_once")]
405 #[serde(borrow)]
406 TriggerOnce(TriggerOnce<'a>),
407 #[serde(rename = "trigger_proximity")]
408 #[serde(borrow)]
409 TriggerProximity(TriggerProximity<'a>),
410 #[serde(rename = "trigger_push")]
411 #[serde(borrow)]
412 TriggerPush(TriggerPush<'a>),
413 #[serde(rename = "trigger_soundscape")]
414 #[serde(borrow)]
415 TriggerSoundscape(TriggerSoundscape<'a>),
416 #[serde(rename = "trigger_teleport")]
417 #[serde(borrow)]
418 TriggerTeleport(TriggerTeleport<'a>),
419 #[serde(rename = "trigger_vphysics_motion")]
420 #[serde(borrow)]
421 TriggerVphysicsMotion(TriggerVphysicsMotion<'a>),
422 #[serde(rename = "trigger_wind")]
423 #[serde(borrow)]
424 TriggerWind(TriggerWind<'a>),
425 #[serde(rename = "water_lod_control")]
426 #[serde(borrow)]
427 WaterLodControl(WaterLodControl<'a>),
428 #[serde(rename = "weapon_ak47")]
429 #[serde(borrow)]
430 WeaponAk47(WeaponAk47<'a>),
431 #[serde(rename = "weapon_awp")]
432 #[serde(borrow)]
433 WeaponAwp(WeaponAwp<'a>),
434 #[serde(rename = "weapon_deagle")]
435 #[serde(borrow)]
436 WeaponDeagle(WeaponDeagle<'a>),
437 #[serde(rename = "weapon_elite")]
438 #[serde(borrow)]
439 WeaponElite(WeaponElite<'a>),
440 #[serde(rename = "weapon_famas")]
441 WeaponFamas(WeaponFamas),
442 #[serde(rename = "weapon_fiveseven")]
443 #[serde(borrow)]
444 WeaponFiveseven(WeaponFiveseven<'a>),
445 #[serde(rename = "weapon_flashbang")]
446 #[serde(borrow)]
447 WeaponFlashbang(WeaponFlashbang<'a>),
448 #[serde(rename = "weapon_g3sg1")]
449 WeaponG3sg1(WeaponG3sg1),
450 #[serde(rename = "weapon_glock")]
451 #[serde(borrow)]
452 WeaponGlock(WeaponGlock<'a>),
453 #[serde(rename = "weapon_hegrenade")]
454 #[serde(borrow)]
455 WeaponHegrenade(WeaponHegrenade<'a>),
456 #[serde(rename = "weapon_knife")]
457 #[serde(borrow)]
458 WeaponKnife(WeaponKnife<'a>),
459 #[serde(rename = "weapon_m249")]
460 #[serde(borrow)]
461 WeaponM249(WeaponM249<'a>),
462 #[serde(rename = "weapon_m3")]
463 #[serde(borrow)]
464 WeaponM3(WeaponM3<'a>),
465 #[serde(rename = "weapon_m4a1")]
466 #[serde(borrow)]
467 WeaponM4a1(WeaponM4a1<'a>),
468 #[serde(rename = "weapon_mac10")]
469 WeaponMac10(WeaponMac10),
470 #[serde(rename = "weapon_p228")]
471 #[serde(borrow)]
472 WeaponP228(WeaponP228<'a>),
473 #[serde(rename = "weapon_p90")]
474 #[serde(borrow)]
475 WeaponP90(WeaponP90<'a>),
476 #[serde(rename = "weapon_scout")]
477 #[serde(borrow)]
478 WeaponScout(WeaponScout<'a>),
479 #[serde(rename = "weapon_sg550")]
480 WeaponSg550(WeaponSg550),
481 #[serde(rename = "weapon_smokegrenade")]
482 #[serde(borrow)]
483 WeaponSmokegrenade(WeaponSmokegrenade<'a>),
484 #[serde(rename = "weapon_tmp")]
485 WeaponTmp(WeaponTmp),
486 #[serde(rename = "weapon_ump45")]
487 #[serde(borrow)]
488 WeaponUmp45(WeaponUmp45<'a>),
489 #[serde(rename = "weapon_usp")]
490 #[serde(borrow)]
491 WeaponUsp(WeaponUsp<'a>),
492 #[serde(rename = "weapon_xm1014")]
493 #[serde(borrow)]
494 WeaponXm1014(WeaponXm1014<'a>),
495 #[serde(rename = "worldspawn")]
496 #[serde(borrow)]
497 Worldspawn(Worldspawn<'a>),
498}
499#[derive(Debug, Clone, Deserialize)]
500pub struct AmbientGeneric<'a> {
501 #[serde(default)]
502 pub cspinup: Option<i32>,
503 #[serde(default)]
504 pub fadein: Option<i32>,
505 #[serde(default)]
506 pub fadeinsecs: Option<i32>,
507 #[serde(default)]
508 pub fadeout: Option<i32>,
509 #[serde(default)]
510 pub fadeoutsecs: Option<i32>,
511 pub health: u8,
512 #[serde(default)]
513 pub lfomodpitch: Option<i32>,
514 #[serde(default)]
515 pub lfomodvol: Option<i32>,
516 #[serde(default)]
517 pub lforate: Option<i32>,
518 #[serde(default)]
519 pub lfotype: Option<i32>,
520 pub message: &'a str,
521 #[serde(deserialize_with = "deserialize_bool")]
522 #[serde(default)]
523 pub no_decomp: bool,
524 pub origin: Vector,
525 pub pitch: i32,
526 pub pitchstart: i32,
527 #[serde(default)]
528 pub preset: Option<i32>,
529 pub radius: f32,
530 #[serde(default)]
531 pub sourceentityname: Option<&'a str>,
532 pub spawnflags: u32,
533 #[serde(default)]
534 pub spindown: Option<i32>,
535 #[serde(default)]
536 pub spinup: Option<i32>,
537 #[serde(default)]
538 pub targetname: Option<&'a str>,
539 #[serde(default)]
540 pub volstart: Option<i32>,
541}
542#[derive(Debug, Clone, Deserialize)]
543pub struct Cycler<'a> {
544 pub angles: Angles,
545 #[serde(deserialize_with = "deserialize_bool")]
546 #[serde(default)]
547 pub disablereceiveshadows: bool,
548 #[serde(deserialize_with = "deserialize_bool")]
549 #[serde(default)]
550 pub disableshadows: bool,
551 pub model: &'a str,
552 pub origin: Vector,
553 pub renderamt: u8,
554 pub rendercolor: Color,
555 #[serde(deserialize_with = "deserialize_bool")]
556 #[serde(default)]
557 pub sequence: bool,
558 #[serde(deserialize_with = "deserialize_bool")]
559 #[serde(default)]
560 pub skin: bool,
561 pub spawnflags: u32,
562 #[serde(default)]
563 pub targetname: Option<&'a str>,
564}
565#[derive(Debug, Clone, Deserialize)]
566pub struct EnvBeam<'a> {
567 pub boltwidth: f32,
568 #[serde(default)]
569 pub damage: Option<f32>,
570 #[serde(default)]
571 pub decalname: Option<&'a str>,
572 #[serde(default)]
573 pub framerate: Option<u8>,
574 #[serde(default)]
575 pub framestart: Option<i32>,
576 #[serde(default)]
577 pub hdrcolorscale: Option<f32>,
578 pub life: f32,
579 pub lightningend: &'a str,
580 pub lightningstart: &'a str,
581 #[serde(default)]
582 pub noiseamplitude: Option<&'a str>,
583 pub origin: Vector,
584 #[serde(default)]
585 pub parentname: Option<&'a str>,
586 pub radius: f32,
587 pub renderamt: u8,
588 pub rendercolor: Color,
589 #[serde(deserialize_with = "deserialize_bool")]
590 #[serde(default)]
591 pub renderfx: bool,
592 pub spawnflags: u32,
593 pub striketime: f32,
594 #[serde(default)]
595 pub targetname: Option<&'a str>,
596 pub texture: &'a str,
597 pub texturescroll: u8,
598 #[serde(deserialize_with = "deserialize_bool")]
599 #[serde(default)]
600 pub touchtype: bool,
601}
602#[derive(Debug, Clone, Deserialize)]
603pub struct EnvBubbles<'a> {
604 pub current: f32,
605 pub density: i32,
606 pub frequency: i32,
607 pub model: &'a str,
608 pub spawnflags: u32,
609}
610#[derive(Debug, Clone, Deserialize)]
611pub struct EnvDetailController {
612 pub angles: Angles,
613 pub fademaxdist: u16,
614 pub fademindist: u16,
615 pub origin: Vector,
616}
617#[derive(Debug, Clone, Deserialize)]
618pub struct EnvEmbers<'a> {
619 pub angles: Angles,
620 pub density: i32,
621 pub lifetime: i32,
622 pub model: &'a str,
623 #[serde(deserialize_with = "deserialize_bool")]
624 #[serde(default)]
625 pub particletype: bool,
626 pub rendercolor: Color,
627 #[serde(default)]
628 pub spawnflags: Option<u32>,
629 pub speed: i32,
630 #[serde(default)]
631 pub targetname: Option<&'a str>,
632}
633#[derive(Debug, Clone, Deserialize)]
634pub struct EnvEntityMaker<'a> {
635 pub angles: Angles,
636 pub entitytemplate: &'a str,
637 pub onentityspawned: &'a str,
638 pub origin: Vector,
639 pub postspawndirection: Vector,
640 pub postspawndirectionvariance: f32,
641 #[serde(deserialize_with = "deserialize_bool")]
642 #[serde(default)]
643 pub postspawninheritangles: bool,
644 #[serde(deserialize_with = "deserialize_bool")]
645 #[serde(default)]
646 pub postspawnspeed: bool,
647 pub spawnflags: u32,
648 pub targetname: &'a str,
649}
650#[derive(Debug, Clone, Deserialize)]
651pub struct EnvExplosion<'a> {
652 pub fireballsprite: &'a str,
653 pub imagnitude: u16,
654 #[serde(default)]
655 pub iradiusoverride: Option<u16>,
656 pub origin: Vector,
657 #[serde(default)]
658 pub parentname: Option<&'a str>,
659 pub rendermode: u8,
660 #[serde(default)]
661 pub spawnflags: Option<u32>,
662 pub targetname: &'a str,
663}
664#[derive(Debug, Clone, Deserialize)]
665pub struct EnvFade<'a> {
666 pub duration: f32,
667 pub holdtime: f32,
668 pub origin: Vector,
669 pub renderamt: u8,
670 pub rendercolor: Color,
671 pub spawnflags: u32,
672 pub targetname: &'a str,
673}
674#[derive(Debug, Clone, Deserialize)]
675pub struct EnvFire<'a> {
676 pub damagescale: f32,
677 pub fireattack: f32,
678 #[serde(default)]
679 pub firedecay: Option<u8>,
680 pub firesize: f32,
681 #[serde(default)]
682 pub firetype: Option<i32>,
683 pub health: u16,
684 pub ignitionpoint: f32,
685 pub origin: Vector,
686 pub spawnflags: u32,
687 #[serde(deserialize_with = "deserialize_bool")]
688 #[serde(default)]
689 pub startdisabled: bool,
690 #[serde(default)]
691 pub targetname: Option<&'a str>,
692}
693#[derive(Debug, Clone, Deserialize)]
694pub struct EnvFireTrail<'a> {
695 pub origin: Vector,
696 pub parentname: &'a str,
697 pub targetname: &'a str,
698}
699#[derive(Debug, Clone, Deserialize)]
700pub struct EnvFiresource {
701 pub firedamage: f32,
702 pub fireradius: f32,
703 pub origin: Vector,
704 pub spawnflags: u32,
705}
706#[derive(Debug, Clone, Deserialize)]
707pub struct EnvFogController<'a> {
708 pub angles: Angles,
709 pub farz: f32,
710 #[serde(deserialize_with = "deserialize_bool")]
711 #[serde(default)]
712 pub fogblend: bool,
713 pub fogcolor: Color,
714 pub fogcolor2: Color,
715 pub fogdir: Vector,
716 #[serde(deserialize_with = "deserialize_bool")]
717 pub fogenable: bool,
718 pub fogend: f32,
719 #[serde(default)]
720 pub foglerptime: Option<f32>,
721 #[serde(default)]
722 pub fogmaxdensity: Option<f32>,
723 pub fogstart: f32,
724 #[serde(deserialize_with = "deserialize_bool")]
725 #[serde(default)]
726 pub maxdxlevel: bool,
727 #[serde(deserialize_with = "deserialize_bool")]
728 #[serde(default)]
729 pub mindxlevel: bool,
730 pub origin: Vector,
731 #[serde(default)]
732 pub spawnflags: Option<u32>,
733 #[serde(default)]
734 pub targetname: Option<&'a str>,
735 #[serde(deserialize_with = "deserialize_bool")]
736 #[serde(default)]
737 pub use_angles: bool,
738}
739#[derive(Debug, Clone, Deserialize)]
740pub struct EnvHudhint<'a> {
741 pub message: &'a str,
742 pub origin: Vector,
743 #[serde(default)]
744 pub spawnflags: Option<u32>,
745 pub targetname: &'a str,
746}
747#[derive(Debug, Clone, Deserialize)]
748pub struct EnvLaser<'a> {
749 #[serde(default)]
750 pub angles: Option<Angles>,
751 #[serde(deserialize_with = "deserialize_bool")]
752 #[serde(default)]
753 pub current: bool,
754 pub damage: f32,
755 #[serde(default)]
756 pub density: Option<u8>,
757 pub dissolvetype: i32,
758 #[serde(default)]
759 pub frequency: Option<u8>,
760 #[serde(default)]
761 pub hdrcolorscale: Option<f32>,
762 #[serde(default)]
763 pub lasertarget: Option<&'a str>,
764 #[serde(default)]
765 pub noiseamplitude: Option<f32>,
766 pub origin: Vector,
767 #[serde(default)]
768 pub parentname: Option<&'a str>,
769 pub renderamt: u8,
770 pub rendercolor: Color,
771 #[serde(default)]
772 pub spawnflags: Option<u32>,
773 #[serde(default)]
774 pub targetname: Option<&'a str>,
775 pub texture: &'a str,
776 pub texturescroll: u8,
777 pub width: f32,
778}
779#[derive(Debug, Clone, Deserialize)]
780pub struct EnvLightglow {
781 pub angles: Angles,
782 pub glowproxysize: f32,
783 #[serde(default)]
784 pub hdrcolorscale: Option<f32>,
785 pub horizontalglowsize: u16,
786 pub maxdist: u16,
787 pub mindist: u16,
788 pub origin: Vector,
789 #[serde(default)]
790 pub outermaxdist: Option<u16>,
791 pub rendercolor: Color,
792 #[serde(default)]
793 pub spawnflags: Option<u32>,
794 pub verticalglowsize: u16,
795}
796#[derive(Debug, Clone, Deserialize)]
797pub struct EnvPhysexplosion<'a> {
798 pub magnitude: f32,
799 pub origin: Vector,
800 pub radius: f32,
801 pub spawnflags: u32,
802 pub targetentityname: &'a str,
803 pub targetname: &'a str,
804}
805#[derive(Debug, Clone, Deserialize)]
806pub struct EnvProjectedtexture<'a> {
807 pub angles: Angles,
808 #[serde(deserialize_with = "deserialize_bool")]
809 pub cameraspace: bool,
810 #[serde(deserialize_with = "deserialize_bool")]
811 pub enableshadows: bool,
812 pub farz: f32,
813 pub lightcolor: LightColor,
814 pub lightfov: f32,
815 #[serde(deserialize_with = "deserialize_bool")]
816 pub lightonlytarget: bool,
817 #[serde(deserialize_with = "deserialize_bool")]
818 pub lightworld: bool,
819 pub nearz: f32,
820 pub origin: Vector,
821 #[serde(default)]
822 pub parentname: Option<&'a str>,
823 pub shadowquality: i32,
824 pub spawnflags: u32,
825 pub targetname: &'a str,
826}
827#[derive(Debug, Clone, Deserialize)]
828pub struct EnvScreenoverlay<'a> {
829 pub origin: Vector,
830 pub overlayname1: &'a str,
831 pub overlaytime1: f32,
832 pub overlaytime10: f32,
833 pub overlaytime2: f32,
834 pub overlaytime3: f32,
835 pub overlaytime4: f32,
836 pub overlaytime5: f32,
837 pub overlaytime6: f32,
838 pub overlaytime7: f32,
839 pub overlaytime8: f32,
840 pub overlaytime9: f32,
841 pub targetname: &'a str,
842}
843#[derive(Debug, Clone, Deserialize)]
844pub struct EnvShake<'a> {
845 pub amplitude: f32,
846 pub duration: f32,
847 pub frequency: f32,
848 pub origin: Vector,
849 pub radius: f32,
850 pub spawnflags: u32,
851 pub targetname: &'a str,
852}
853#[derive(Debug, Clone, Deserialize)]
854pub struct EnvShooter<'a> {
855 pub angles: Angles,
856 pub delay: f32,
857 #[serde(deserialize_with = "deserialize_bool")]
858 pub disablereceiveshadows: bool,
859 #[serde(deserialize_with = "deserialize_bool")]
860 #[serde(default)]
861 pub disableshadows: bool,
862 pub gibangles: Vector,
863 #[serde(default)]
864 pub gibanglevelocity: Option<f32>,
865 pub gibgravityscale: f32,
866 pub m_flgiblife: f32,
867 pub m_flvariance: f32,
868 pub m_flvelocity: u16,
869 pub m_igibs: u32,
870 #[serde(default)]
871 pub massoverride: Option<f32>,
872 #[serde(deserialize_with = "deserialize_bool")]
873 #[serde(default)]
874 pub nogibshadows: bool,
875 pub origin: Vector,
876 #[serde(default)]
877 pub parentname: Option<&'a str>,
878 pub renderamt: u8,
879 pub rendercolor: Color,
880 #[serde(deserialize_with = "deserialize_bool")]
881 pub renderfx: bool,
882 #[serde(deserialize_with = "deserialize_bool")]
883 pub rendermode: bool,
884 #[serde(default)]
885 pub shootmodel: Option<&'a str>,
886 pub shootsounds: i32,
887 #[serde(deserialize_with = "deserialize_bool")]
888 pub simulation: bool,
889 pub skin: i32,
890 pub spawnflags: u32,
891 pub targetname: &'a str,
892}
893#[derive(Debug, Clone, Deserialize)]
894pub struct EnvSmokestack<'a> {
895 pub angles: Angles,
896 pub basespread: u8,
897 pub endsize: u8,
898 #[serde(deserialize_with = "deserialize_bool")]
899 #[serde(default)]
900 pub initialstate: bool,
901 pub jetlength: u8,
902 pub origin: Vector,
903 #[serde(default)]
904 pub parentname: Option<&'a str>,
905 pub rate: u8,
906 pub renderamt: u8,
907 pub rendercolor: Color,
908 #[serde(default)]
909 pub roll: Option<f32>,
910 pub smokematerial: &'a str,
911 pub speed: u8,
912 pub spreadspeed: u8,
913 pub startsize: u8,
914 #[serde(default)]
915 pub targetname: Option<&'a str>,
916 #[serde(default)]
917 pub twist: Option<u8>,
918 #[serde(default)]
919 pub windangle: Option<u8>,
920 #[serde(default)]
921 pub windspeed: Option<u8>,
922}
923#[derive(Debug, Clone, Deserialize)]
924pub struct EnvSoundscape<'a> {
925 pub origin: Vector,
926 #[serde(default)]
927 pub position0: Option<&'a str>,
928 #[serde(default)]
929 pub position1: Option<&'a str>,
930 #[serde(default)]
931 pub position2: Option<&'a str>,
932 #[serde(default)]
933 pub position3: Option<&'a str>,
934 #[serde(default)]
935 pub position4: Option<&'a str>,
936 #[serde(default)]
937 pub position5: Option<&'a str>,
938 #[serde(default)]
939 pub position6: Option<&'a str>,
940 #[serde(default)]
941 pub position7: Option<&'a str>,
942 pub radius: f32,
943 pub soundscape: &'a str,
944 #[serde(deserialize_with = "deserialize_bool")]
945 #[serde(default)]
946 pub startdisabled: bool,
947 #[serde(default)]
948 pub targetname: Option<&'a str>,
949}
950#[derive(Debug, Clone, Deserialize)]
951pub struct EnvSoundscapeProxy<'a> {
952 pub mainsoundscapename: &'a str,
953 pub origin: Vector,
954 pub radius: f32,
955}
956#[derive(Debug, Clone, Deserialize)]
957pub struct EnvSoundscapeTriggerable<'a> {
958 pub origin: Vector,
959 #[serde(default)]
960 pub position0: Option<&'a str>,
961 #[serde(default)]
962 pub position1: Option<&'a str>,
963 #[serde(default)]
964 pub position2: Option<&'a str>,
965 #[serde(default)]
966 pub position3: Option<&'a str>,
967 #[serde(default)]
968 pub position4: Option<&'a str>,
969 #[serde(default)]
970 pub position5: Option<&'a str>,
971 #[serde(default)]
972 pub position6: Option<&'a str>,
973 #[serde(default)]
974 pub position7: Option<&'a str>,
975 pub radius: f32,
976 pub soundscape: &'a str,
977 #[serde(deserialize_with = "deserialize_bool")]
978 #[serde(default)]
979 pub startdisabled: bool,
980 pub targetname: &'a str,
981}
982#[derive(Debug, Clone, Deserialize)]
983pub struct EnvSpark<'a> {
984 pub angles: Angles,
985 pub magnitude: u8,
986 #[serde(default)]
987 pub maxdelay: Option<f32>,
988 pub origin: Vector,
989 #[serde(default)]
990 pub parentname: Option<&'a str>,
991 pub spawnflags: u32,
992 #[serde(default)]
993 pub targetname: Option<&'a str>,
994 pub traillength: u8,
995}
996#[derive(Debug, Clone, Deserialize)]
997pub struct EnvSprite<'a> {
998 #[serde(default)]
999 pub _minlight: Option<f32>,
1000 #[serde(default)]
1001 pub angles: Option<Angles>,
1002 #[serde(deserialize_with = "deserialize_bool")]
1003 #[serde(default)]
1004 pub disablereceiveshadows: bool,
1005 #[serde(deserialize_with = "deserialize_bool")]
1006 #[serde(default)]
1007 pub disableshadows: bool,
1008 pub framerate: f32,
1009 pub glowproxysize: f32,
1010 #[serde(default)]
1011 pub hdrcolorscale: Option<f32>,
1012 #[serde(deserialize_with = "deserialize_bool")]
1013 #[serde(default)]
1014 pub maxdxlevel: bool,
1015 #[serde(default)]
1016 pub mindxlevel: Option<u8>,
1017 pub model: &'a str,
1018 pub origin: Vector,
1019 #[serde(default)]
1020 pub parentname: Option<&'a str>,
1021 pub renderamt: u8,
1022 pub rendercolor: Color,
1023 #[serde(default)]
1024 pub renderfx: Option<u8>,
1025 #[serde(default)]
1026 pub rendermode: Option<u8>,
1027 #[serde(default)]
1028 pub scale: Option<f32>,
1029 #[serde(default)]
1030 pub spawnflags: Option<u32>,
1031 #[serde(default)]
1032 pub targetname: Option<&'a str>,
1033}
1034#[derive(Debug, Clone, Deserialize)]
1035pub struct EnvSpritetrail<'a> {
1036 #[serde(deserialize_with = "deserialize_bool")]
1037 #[serde(default)]
1038 pub disablereceiveshadows: bool,
1039 #[serde(deserialize_with = "deserialize_bool")]
1040 #[serde(default)]
1041 pub disableshadows: bool,
1042 pub endwidth: f32,
1043 pub lifetime: f32,
1044 #[serde(deserialize_with = "deserialize_bool")]
1045 #[serde(default)]
1046 pub maxdxlevel: bool,
1047 #[serde(deserialize_with = "deserialize_bool")]
1048 #[serde(default)]
1049 pub mindxlevel: bool,
1050 pub origin: Vector,
1051 #[serde(default)]
1052 pub parentname: Option<&'a str>,
1053 pub renderamt: u8,
1054 pub rendercolor: Color,
1055 pub rendermode: u8,
1056 pub spritename: &'a str,
1057 pub startwidth: f32,
1058 #[serde(default)]
1059 pub targetname: Option<&'a str>,
1060}
1061#[derive(Debug, Clone, Deserialize)]
1062pub struct EnvSteam<'a> {
1063 pub angles: Angles,
1064 pub endsize: u8,
1065 #[serde(deserialize_with = "deserialize_bool")]
1066 #[serde(default)]
1067 pub initialstate: bool,
1068 pub jetlength: u16,
1069 pub origin: Vector,
1070 #[serde(default)]
1071 pub parentname: Option<&'a str>,
1072 #[serde(deserialize_with = "deserialize_bool")]
1073 #[serde(default)]
1074 pub r#type: bool,
1075 pub rate: u8,
1076 pub renderamt: u8,
1077 pub rendercolor: Color,
1078 #[serde(default)]
1079 pub rollspeed: Option<u8>,
1080 #[serde(default)]
1081 pub spawnflags: Option<u32>,
1082 pub speed: u8,
1083 pub spreadspeed: u8,
1084 pub startsize: u8,
1085 #[serde(default)]
1086 pub targetname: Option<&'a str>,
1087}
1088#[derive(Debug, Clone, Deserialize)]
1089pub struct EnvSun<'a> {
1090 pub angles: Angles,
1091 #[serde(default)]
1092 pub hdrcolorscale: Option<f32>,
1093 #[serde(default)]
1094 pub horzsize0: Option<u8>,
1095 #[serde(default)]
1096 pub horzsize1: Option<u8>,
1097 #[serde(default)]
1098 pub horzsize2: Option<u8>,
1099 #[serde(default)]
1100 pub horzsize3: Option<u8>,
1101 #[serde(default)]
1102 pub material: Option<&'a str>,
1103 #[serde(default)]
1104 pub material0: Option<&'a str>,
1105 #[serde(default)]
1106 pub material1: Option<&'a str>,
1107 #[serde(default)]
1108 pub material2: Option<&'a str>,
1109 #[serde(default)]
1110 pub material3: Option<&'a str>,
1111 #[serde(default)]
1112 pub numlayers: Option<u8>,
1113 pub origin: Vector,
1114 #[serde(default)]
1115 pub overlaycolor: Option<Color>,
1116 #[serde(default)]
1117 pub overlaymaterial: Option<&'a str>,
1118 #[serde(default)]
1119 pub overlaysize: Option<i32>,
1120 #[serde(default)]
1121 pub pitch: Option<f32>,
1122 pub rendercolor: Color,
1123 pub size: i32,
1124 #[serde(default)]
1125 pub target: Option<&'a str>,
1126 #[serde(default)]
1127 pub use_angles: Option<i32>,
1128 #[serde(default)]
1129 pub vertsize0: Option<u8>,
1130 #[serde(default)]
1131 pub vertsize1: Option<u8>,
1132 #[serde(default)]
1133 pub vertsize2: Option<u8>,
1134 #[serde(default)]
1135 pub vertsize3: Option<u8>,
1136}
1137#[derive(Debug, Clone, Deserialize)]
1138pub struct EnvTonemapController<'a> {
1139 pub origin: Vector,
1140 #[serde(default)]
1141 pub targetname: Option<&'a str>,
1142}
1143#[derive(Debug, Clone, Deserialize)]
1144pub struct EnvWind {
1145 #[serde(default)]
1146 pub angles: Option<Angles>,
1147 pub gustdirchange: i32,
1148 #[serde(default)]
1149 pub gustduration: Option<f32>,
1150 pub maxgust: i32,
1151 pub maxgustdelay: f32,
1152 pub maxwind: i32,
1153 pub mingust: i32,
1154 pub mingustdelay: f32,
1155 pub minwind: i32,
1156 pub origin: Vector,
1157}
1158#[derive(Debug, Clone, Deserialize)]
1159pub struct FilterActivatorClass<'a> {
1160 pub filterclass: &'a str,
1161 pub negated: Negated,
1162 pub origin: Vector,
1163 pub targetname: &'a str,
1164}
1165#[derive(Debug, Clone, Deserialize)]
1166pub struct FilterActivatorName<'a> {
1167 #[serde(default)]
1168 pub filtername: Option<&'a str>,
1169 pub negated: Negated,
1170 #[serde(default)]
1171 pub onfail: Option<&'a str>,
1172 #[serde(default)]
1173 pub onpass: Option<&'a str>,
1174 pub origin: Vector,
1175 pub targetname: &'a str,
1176}
1177#[derive(Debug, Clone, Deserialize)]
1178pub struct FilterDamageType<'a> {
1179 pub damagetype: i32,
1180 pub negated: Negated,
1181 pub origin: Vector,
1182 #[serde(default)]
1183 pub targetname: Option<&'a str>,
1184}
1185#[derive(Debug, Clone, Deserialize)]
1186pub struct FilterMulti<'a> {
1187 pub filter01: &'a str,
1188 #[serde(default)]
1189 pub filter02: Option<&'a str>,
1190 #[serde(default)]
1191 pub filter03: Option<&'a str>,
1192 #[serde(default)]
1193 pub filter04: Option<&'a str>,
1194 #[serde(default)]
1195 pub filter05: Option<&'a str>,
1196 #[serde(deserialize_with = "deserialize_bool")]
1197 pub filtertype: bool,
1198 #[serde(deserialize_with = "deserialize_bool")]
1199 pub negated: bool,
1200 pub origin: Vector,
1201 pub targetname: &'a str,
1202}
1203#[derive(Debug, Clone, Deserialize)]
1204pub struct FuncAreaportal<'a> {
1205 pub portalnumber: i32,
1206 #[serde(deserialize_with = "deserialize_bool")]
1207 #[serde(default)]
1208 pub portalversion: bool,
1209 #[serde(deserialize_with = "deserialize_bool")]
1210 pub startopen: bool,
1211 #[serde(default)]
1212 pub target: Option<&'a str>,
1213 #[serde(default)]
1214 pub targetname: Option<&'a str>,
1215}
1216#[derive(Debug, Clone, Deserialize)]
1217pub struct FuncAreaportalwindow<'a> {
1218 pub fadedist: u16,
1219 pub fadestartdist: u16,
1220 pub portalnumber: i32,
1221 #[serde(deserialize_with = "deserialize_bool")]
1222 #[serde(default)]
1223 pub portalversion: bool,
1224 #[serde(default)]
1225 pub target: Option<&'a str>,
1226 pub translucencylimit: f32,
1227}
1228#[derive(Debug, Clone, Deserialize)]
1229pub struct FuncBombTarget<'a> {
1230 pub bombexplode: &'a str,
1231 pub model: &'a str,
1232 #[serde(default)]
1233 pub spawnflags: Option<u32>,
1234 #[serde(default)]
1235 pub target: Option<&'a str>,
1236 #[serde(default)]
1237 pub targetname: Option<&'a str>,
1238}
1239#[derive(Debug, Clone, Deserialize)]
1240pub struct FuncBreakable<'a> {
1241 #[serde(default)]
1242 pub _minlight: Option<f32>,
1243 #[serde(default)]
1244 pub angles: Option<Angles>,
1245 #[serde(deserialize_with = "deserialize_bool")]
1246 #[serde(default)]
1247 pub delay: bool,
1248 #[serde(deserialize_with = "deserialize_bool")]
1249 #[serde(default)]
1250 pub disablereceiveshadows: bool,
1251 #[serde(deserialize_with = "deserialize_bool")]
1252 #[serde(default)]
1253 pub disableshadows: bool,
1254 #[serde(deserialize_with = "deserialize_bool")]
1255 #[serde(default)]
1256 pub explodedamage: bool,
1257 #[serde(default)]
1258 pub explodemagnitude: Option<i32>,
1259 #[serde(default)]
1260 pub exploderadius: Option<u16>,
1261 #[serde(default)]
1262 pub explosion: Option<i32>,
1263 pub gibdir: Vector,
1264 pub health: u32,
1265 #[serde(default)]
1266 pub material: Option<i32>,
1267 #[serde(default)]
1268 pub minhealthdmg: Option<i32>,
1269 pub model: &'a str,
1270 #[serde(deserialize_with = "deserialize_bool")]
1271 #[serde(default)]
1272 pub nodamageforces: bool,
1273 #[serde(default)]
1274 pub onbreak: Option<&'a str>,
1275 pub origin: Vector,
1276 #[serde(default)]
1277 pub parentname: Option<&'a str>,
1278 #[serde(deserialize_with = "deserialize_bool")]
1279 #[serde(default)]
1280 pub performancemode: bool,
1281 pub physdamagescale: f32,
1282 #[serde(deserialize_with = "deserialize_bool")]
1283 #[serde(default)]
1284 pub pressuredelay: bool,
1285 #[serde(default)]
1286 pub propdata: Option<i32>,
1287 pub renderamt: i32,
1288 pub rendercolor: Color,
1289 #[serde(deserialize_with = "deserialize_bool")]
1290 #[serde(default)]
1291 pub renderfx: bool,
1292 #[serde(default)]
1293 pub rendermode: Option<u8>,
1294 #[serde(default)]
1295 pub spawnflags: Option<u32>,
1296 #[serde(default)]
1297 pub spawnobject: Option<i32>,
1298 #[serde(default)]
1299 pub targetname: Option<&'a str>,
1300}
1301#[derive(Debug, Clone, Deserialize)]
1302pub struct FuncBreakableSurf<'a> {
1303 #[serde(deserialize_with = "deserialize_bool")]
1304 pub disablereceiveshadows: bool,
1305 #[serde(deserialize_with = "deserialize_bool")]
1306 pub disableshadows: bool,
1307 pub error: i32,
1308 #[serde(deserialize_with = "deserialize_bool")]
1309 pub explodedamage: bool,
1310 pub explodemagnitude: i32,
1311 #[serde(deserialize_with = "deserialize_bool")]
1312 pub exploderadius: bool,
1313 pub explosion: i32,
1314 pub fragility: i32,
1315 pub gibdir: Vector,
1316 pub health: u8,
1317 pub lowerleft: Vector,
1318 pub lowerright: Vector,
1319 pub material: i32,
1320 pub model: &'a str,
1321 #[serde(deserialize_with = "deserialize_bool")]
1322 #[serde(default)]
1323 pub nodamageforces: bool,
1324 #[serde(deserialize_with = "deserialize_bool")]
1325 #[serde(default)]
1326 pub performancemode: bool,
1327 #[serde(deserialize_with = "deserialize_bool")]
1328 pub pressuredelay: bool,
1329 #[serde(default)]
1330 pub propdata: Option<i32>,
1331 pub renderamt: u8,
1332 pub rendercolor: Color,
1333 #[serde(deserialize_with = "deserialize_bool")]
1334 pub renderfx: bool,
1335 #[serde(deserialize_with = "deserialize_bool")]
1336 pub rendermode: bool,
1337 #[serde(default)]
1338 pub spawnflags: Option<u32>,
1339 pub spawnobject: i32,
1340 pub surfacetype: i32,
1341 #[serde(default)]
1342 pub targetname: Option<&'a str>,
1343 pub upperleft: Vector,
1344 pub upperright: Vector,
1345}
1346#[derive(Debug, Clone, Deserialize)]
1347pub struct FuncBrush<'a> {
1348 #[serde(default)]
1349 pub _minlight: Option<f32>,
1350 #[serde(deserialize_with = "deserialize_bool")]
1351 #[serde(default)]
1352 pub disablereceiveshadows: bool,
1353 #[serde(deserialize_with = "deserialize_bool")]
1354 #[serde(default)]
1355 pub disableshadows: bool,
1356 #[serde(default)]
1357 pub inputfilter: Option<u8>,
1358 #[serde(deserialize_with = "deserialize_bool")]
1359 #[serde(default)]
1360 pub invert_exclusion: bool,
1361 pub model: &'a str,
1362 pub origin: Vector,
1363 pub renderamt: i32,
1364 pub rendercolor: Color,
1365 #[serde(default)]
1366 pub renderfx: Option<u8>,
1367 #[serde(default)]
1368 pub rendermode: Option<u8>,
1369 #[serde(deserialize_with = "deserialize_bool")]
1370 #[serde(default)]
1371 pub solidbsp: bool,
1372 pub solidity: u8,
1373 #[serde(default)]
1374 pub spawnflags: Option<u32>,
1375 #[serde(default)]
1376 pub speed: Option<u8>,
1377 #[serde(deserialize_with = "deserialize_bool")]
1378 #[serde(default)]
1379 pub startdisabled: bool,
1380 #[serde(default)]
1381 pub targetname: Option<&'a str>,
1382 #[serde(deserialize_with = "deserialize_bool")]
1383 #[serde(default)]
1384 pub vrad_brush_cast_shadows: bool,
1385 #[serde(default)]
1386 pub wait: Option<u8>,
1387}
1388#[derive(Debug, Clone, Deserialize)]
1389pub struct FuncButton<'a> {
1390 #[serde(default)]
1391 pub _minlight: Option<f32>,
1392 #[serde(default)]
1393 pub angles: Option<Angles>,
1394 #[serde(deserialize_with = "deserialize_bool")]
1395 pub disablereceiveshadows: bool,
1396 #[serde(deserialize_with = "deserialize_bool")]
1397 #[serde(default)]
1398 pub disableshadows: bool,
1399 #[serde(deserialize_with = "deserialize_bool")]
1400 #[serde(default)]
1401 pub health: bool,
1402 pub lip: f32,
1403 #[serde(deserialize_with = "deserialize_bool")]
1404 #[serde(default)]
1405 pub locked_sentence: bool,
1406 #[serde(default)]
1407 pub locked_sound: Option<u8>,
1408 pub model: &'a str,
1409 pub movedir: Vector,
1410 #[serde(default)]
1411 pub ondamaged: Option<&'a str>,
1412 #[serde(default)]
1413 pub onin: Option<&'a str>,
1414 #[serde(default)]
1415 pub onout: Option<&'a str>,
1416 pub onpressed: &'a str,
1417 #[serde(default)]
1418 pub onuselocked: Option<&'a str>,
1419 pub origin: Vector,
1420 #[serde(default)]
1421 pub parentname: Option<&'a str>,
1422 pub renderamt: u8,
1423 pub rendercolor: Color,
1424 pub renderfx: u8,
1425 pub rendermode: u8,
1426 pub sounds: i32,
1427 pub spawnflags: u32,
1428 pub speed: f32,
1429 #[serde(default)]
1430 pub targetname: Option<&'a str>,
1431 #[serde(deserialize_with = "deserialize_bool")]
1432 #[serde(default)]
1433 pub unlocked_sentence: bool,
1434 #[serde(deserialize_with = "deserialize_bool")]
1435 #[serde(default)]
1436 pub unlocked_sound: bool,
1437 pub wait: f32,
1438}
1439#[derive(Debug, Clone, Deserialize)]
1440pub struct FuncBuyzone<'a> {
1441 pub model: &'a str,
1442 #[serde(default)]
1443 pub team: Option<u8>,
1444 #[serde(default)]
1445 pub teamnum: Option<u8>,
1446}
1447#[derive(Debug, Clone, Deserialize)]
1448pub struct FuncClipVphysics<'a> {
1449 pub model: &'a str,
1450 #[serde(default)]
1451 pub spawnflags: Option<u32>,
1452 #[serde(default)]
1453 pub targetname: Option<&'a str>,
1454}
1455#[derive(Debug, Clone, Deserialize)]
1456pub struct FuncConveyor<'a> {
1457 #[serde(default)]
1458 pub _minlight: Option<f32>,
1459 #[serde(default)]
1460 pub angles: Option<Angles>,
1461 #[serde(deserialize_with = "deserialize_bool")]
1462 pub disablereceiveshadows: bool,
1463 #[serde(deserialize_with = "deserialize_bool")]
1464 pub disableshadows: bool,
1465 pub model: &'a str,
1466 pub movedir: Vector,
1467 pub renderamt: u8,
1468 pub rendercolor: Color,
1469 #[serde(deserialize_with = "deserialize_bool")]
1470 pub renderfx: bool,
1471 #[serde(deserialize_with = "deserialize_bool")]
1472 pub rendermode: bool,
1473 pub spawnflags: u32,
1474 pub speed: u16,
1475}
1476#[derive(Debug, Clone, Deserialize)]
1477pub struct FuncDoor<'a> {
1478 #[serde(default)]
1479 pub _minlight: Option<f32>,
1480 #[serde(deserialize_with = "deserialize_bool")]
1481 pub disablereceiveshadows: bool,
1482 #[serde(deserialize_with = "deserialize_bool")]
1483 #[serde(default)]
1484 pub disableshadows: bool,
1485 #[serde(default)]
1486 pub dmg: Option<f32>,
1487 #[serde(deserialize_with = "deserialize_bool")]
1488 #[serde(default)]
1489 pub forceclosed: bool,
1490 #[serde(deserialize_with = "deserialize_bool")]
1491 pub health: bool,
1492 #[serde(deserialize_with = "deserialize_bool")]
1493 #[serde(default)]
1494 pub ignoredebris: bool,
1495 #[serde(default)]
1496 pub lip: Option<f32>,
1497 #[serde(deserialize_with = "deserialize_bool")]
1498 pub locked_sentence: bool,
1499 #[serde(deserialize_with = "deserialize_bool")]
1500 #[serde(default)]
1501 pub locked_sound: bool,
1502 #[serde(deserialize_with = "deserialize_bool")]
1503 #[serde(default)]
1504 pub loopmovesound: bool,
1505 pub model: &'a str,
1506 pub movedir: Vector,
1507 #[serde(deserialize_with = "deserialize_bool")]
1508 #[serde(default)]
1509 pub no_decomp: bool,
1510 #[serde(default)]
1511 pub noise1: Option<&'a str>,
1512 #[serde(default)]
1513 pub noise2: Option<&'a str>,
1514 #[serde(default)]
1515 pub onclose: Option<&'a str>,
1516 #[serde(default)]
1517 pub onfullyclosed: Option<&'a str>,
1518 #[serde(default)]
1519 pub onfullyopen: Option<&'a str>,
1520 #[serde(default)]
1521 pub onopen: Option<&'a str>,
1522 pub origin: Vector,
1523 #[serde(default)]
1524 pub parentname: Option<&'a str>,
1525 pub renderamt: u8,
1526 pub rendercolor: Color,
1527 #[serde(default)]
1528 pub renderfx: Option<u8>,
1529 pub rendermode: u8,
1530 #[serde(deserialize_with = "deserialize_bool")]
1531 #[serde(default)]
1532 pub sounds: bool,
1533 pub spawnflags: u32,
1534 #[serde(default)]
1535 pub spawnpos: Option<i32>,
1536 pub speed: u16,
1537 #[serde(default)]
1538 pub targetname: Option<&'a str>,
1539 #[serde(deserialize_with = "deserialize_bool")]
1540 pub unlocked_sentence: bool,
1541 #[serde(deserialize_with = "deserialize_bool")]
1542 #[serde(default)]
1543 pub unlocked_sound: bool,
1544 pub wait: f32,
1545}
1546#[derive(Debug, Clone, Deserialize)]
1547pub struct FuncDoorRotating<'a> {
1548 #[serde(deserialize_with = "deserialize_bool")]
1549 #[serde(default)]
1550 pub _minlight: bool,
1551 pub angles: Angles,
1552 #[serde(default)]
1553 pub chainstodoor: Option<&'a str>,
1554 #[serde(deserialize_with = "deserialize_bool")]
1555 pub disablereceiveshadows: bool,
1556 #[serde(deserialize_with = "deserialize_bool")]
1557 pub disableshadows: bool,
1558 pub distance: u8,
1559 pub dmg: f32,
1560 #[serde(deserialize_with = "deserialize_bool")]
1561 #[serde(default)]
1562 pub forceclosed: bool,
1563 #[serde(deserialize_with = "deserialize_bool")]
1564 pub health: bool,
1565 #[serde(deserialize_with = "deserialize_bool")]
1566 #[serde(default)]
1567 pub ignoredebris: bool,
1568 pub lip: u8,
1569 #[serde(deserialize_with = "deserialize_bool")]
1570 pub locked_sentence: bool,
1571 #[serde(deserialize_with = "deserialize_bool")]
1572 #[serde(default)]
1573 pub loopmovesound: bool,
1574 pub model: &'a str,
1575 #[serde(default)]
1576 pub noise1: Option<&'a str>,
1577 #[serde(default)]
1578 pub noise2: Option<&'a str>,
1579 #[serde(default)]
1580 pub onfullyclosed: Option<&'a str>,
1581 #[serde(default)]
1582 pub onfullyopen: Option<&'a str>,
1583 pub origin: Vector,
1584 #[serde(default)]
1585 pub parentname: Option<&'a str>,
1586 pub renderamt: u8,
1587 pub rendercolor: Color,
1588 #[serde(deserialize_with = "deserialize_bool")]
1589 pub renderfx: bool,
1590 #[serde(deserialize_with = "deserialize_bool")]
1591 pub rendermode: bool,
1592 #[serde(deserialize_with = "deserialize_bool")]
1593 #[serde(default)]
1594 pub solidbsp: bool,
1595 pub spawnflags: u32,
1596 #[serde(default)]
1597 pub spawnpos: Option<i32>,
1598 pub speed: u16,
1599 #[serde(default)]
1600 pub targetname: Option<&'a str>,
1601 #[serde(deserialize_with = "deserialize_bool")]
1602 pub unlocked_sentence: bool,
1603 pub wait: i32,
1604}
1605#[derive(Debug, Clone, Deserialize)]
1606pub struct FuncDustcloud<'a> {
1607 pub alpha: u8,
1608 pub color: Color,
1609 pub distmax: u16,
1610 #[serde(deserialize_with = "deserialize_bool")]
1611 pub frozen: bool,
1612 pub lifetimemax: u8,
1613 pub lifetimemin: u8,
1614 pub model: &'a str,
1615 pub sizemax: u8,
1616 pub sizemin: u8,
1617 pub spawnrate: u16,
1618 pub speedmax: u8,
1619 #[serde(deserialize_with = "deserialize_bool")]
1620 pub startdisabled: bool,
1621 #[serde(default)]
1622 pub targetname: Option<&'a str>,
1623}
1624#[derive(Debug, Clone, Deserialize)]
1625pub struct FuncDustmotes<'a> {
1626 pub alpha: u8,
1627 pub color: Color,
1628 pub distmax: u16,
1629 #[serde(deserialize_with = "deserialize_bool")]
1630 #[serde(default)]
1631 pub fallspeed: bool,
1632 #[serde(deserialize_with = "deserialize_bool")]
1633 pub frozen: bool,
1634 pub lifetimemax: u8,
1635 pub lifetimemin: u8,
1636 pub model: &'a str,
1637 pub sizemax: u8,
1638 pub sizemin: u8,
1639 pub spawnrate: u32,
1640 pub speedmax: u8,
1641 #[serde(deserialize_with = "deserialize_bool")]
1642 pub startdisabled: bool,
1643 #[serde(default)]
1644 pub targetname: Option<&'a str>,
1645}
1646#[derive(Debug, Clone, Deserialize)]
1647pub struct FuncFishPool<'a> {
1648 pub fish_count: i32,
1649 pub max_range: u16,
1650 pub model: &'a str,
1651 pub origin: Vector,
1652 #[serde(deserialize_with = "deserialize_bool")]
1653 #[serde(default)]
1654 pub skin: bool,
1655}
1656#[derive(Debug, Clone, Deserialize)]
1657pub struct FuncFootstepControl<'a> {
1658 pub destination: &'a str,
1659 pub model: &'a str,
1660 pub source: &'a str,
1661}
1662#[derive(Debug, Clone, Deserialize)]
1663pub struct FuncHostageRescue<'a> {
1664 pub model: &'a str,
1665}
1666#[derive(Debug, Clone, Deserialize)]
1667pub struct FuncIllusionary<'a> {
1668 #[serde(default)]
1669 pub _minlight: Option<f32>,
1670 #[serde(deserialize_with = "deserialize_bool")]
1671 #[serde(default)]
1672 pub disablereceiveshadows: bool,
1673 #[serde(deserialize_with = "deserialize_bool")]
1674 #[serde(default)]
1675 pub disableshadows: bool,
1676 pub model: &'a str,
1677 pub origin: Vector,
1678 pub renderamt: i32,
1679 pub rendercolor: Color,
1680 #[serde(default)]
1681 pub renderfx: Option<u8>,
1682 #[serde(default)]
1683 pub rendermode: Option<u8>,
1684 #[serde(default)]
1685 pub skin: Option<i32>,
1686 #[serde(default)]
1687 pub spawnflags: Option<u32>,
1688 #[serde(default)]
1689 pub speed: Option<u8>,
1690 #[serde(default)]
1691 pub targetname: Option<&'a str>,
1692 #[serde(default)]
1693 pub wait: Option<u8>,
1694 #[serde(default)]
1695 pub zhlt_lightflags: Option<u8>,
1696}
1697#[derive(Debug, Clone, Deserialize)]
1698pub struct FuncLod<'a> {
1699 pub disappeardist: u16,
1700 pub model: &'a str,
1701 #[serde(deserialize_with = "deserialize_bool")]
1702 pub solid: bool,
1703}
1704#[derive(Debug, Clone, Deserialize)]
1705pub struct FuncMonitor<'a> {
1706 #[serde(default)]
1707 pub _minlight: Option<f32>,
1708 #[serde(deserialize_with = "deserialize_bool")]
1709 #[serde(default)]
1710 pub disablereceiveshadows: bool,
1711 #[serde(deserialize_with = "deserialize_bool")]
1712 #[serde(default)]
1713 pub disableshadows: bool,
1714 #[serde(deserialize_with = "deserialize_bool")]
1715 #[serde(default)]
1716 pub inputfilter: bool,
1717 #[serde(deserialize_with = "deserialize_bool")]
1718 #[serde(default)]
1719 pub invert_exclusion: bool,
1720 pub model: &'a str,
1721 pub origin: Vector,
1722 #[serde(default)]
1723 pub parentname: Option<&'a str>,
1724 pub renderamt: u8,
1725 pub rendercolor: Color,
1726 #[serde(deserialize_with = "deserialize_bool")]
1727 #[serde(default)]
1728 pub renderfx: bool,
1729 #[serde(default)]
1730 pub rendermode: Option<u8>,
1731 #[serde(deserialize_with = "deserialize_bool")]
1732 #[serde(default)]
1733 pub solidbsp: bool,
1734 #[serde(deserialize_with = "deserialize_bool")]
1735 #[serde(default)]
1736 pub solidity: bool,
1737 #[serde(default)]
1738 pub spawnflags: Option<u32>,
1739 #[serde(deserialize_with = "deserialize_bool")]
1740 #[serde(default)]
1741 pub startdisabled: bool,
1742 pub target: &'a str,
1743 #[serde(default)]
1744 pub targetname: Option<&'a str>,
1745 #[serde(deserialize_with = "deserialize_bool")]
1746 #[serde(default)]
1747 pub vrad_brush_cast_shadows: bool,
1748}
1749#[derive(Debug, Clone, Deserialize)]
1750pub struct FuncMovelinear<'a> {
1751 #[serde(default)]
1752 pub _minlight: Option<f32>,
1753 #[serde(default)]
1754 pub blockdamage: Option<f32>,
1755 #[serde(deserialize_with = "deserialize_bool")]
1756 pub disablereceiveshadows: bool,
1757 #[serde(deserialize_with = "deserialize_bool")]
1758 #[serde(default)]
1759 pub disableshadows: bool,
1760 pub model: &'a str,
1761 pub movedir: Vector,
1762 pub movedistance: u16,
1763 #[serde(default)]
1764 pub onfullyclosed: Option<&'a str>,
1765 #[serde(default)]
1766 pub onfullyopen: Option<&'a str>,
1767 pub origin: Vector,
1768 #[serde(default)]
1769 pub parentname: Option<&'a str>,
1770 pub renderamt: u8,
1771 pub rendercolor: Color,
1772 #[serde(deserialize_with = "deserialize_bool")]
1773 pub renderfx: bool,
1774 pub rendermode: u8,
1775 pub spawnflags: u32,
1776 pub speed: u8,
1777 pub startposition: f32,
1778 #[serde(default)]
1779 pub startsound: Option<&'a str>,
1780 #[serde(default)]
1781 pub stopsound: Option<&'a str>,
1782 #[serde(default)]
1783 pub targetname: Option<&'a str>,
1784}
1785#[derive(Debug, Clone, Deserialize)]
1786pub struct FuncOccluder<'a> {
1787 pub model: &'a str,
1788 pub occludernumber: i32,
1789 #[serde(deserialize_with = "deserialize_bool")]
1790 pub startactive: bool,
1791 #[serde(default)]
1792 pub targetname: Option<&'a str>,
1793}
1794#[derive(Debug, Clone, Deserialize)]
1795pub struct FuncPhysbox<'a> {
1796 #[serde(default)]
1797 pub _minlight: Option<f32>,
1798 #[serde(default)]
1799 pub damagetoenablemotion: Option<i32>,
1800 #[serde(deserialize_with = "deserialize_bool")]
1801 pub damagetype: bool,
1802 #[serde(deserialize_with = "deserialize_bool")]
1803 pub disablereceiveshadows: bool,
1804 #[serde(deserialize_with = "deserialize_bool")]
1805 pub disableshadows: bool,
1806 #[serde(deserialize_with = "deserialize_bool")]
1807 #[serde(default)]
1808 pub explodedamage: bool,
1809 #[serde(default)]
1810 pub explodemagnitude: Option<i32>,
1811 #[serde(deserialize_with = "deserialize_bool")]
1812 #[serde(default)]
1813 pub exploderadius: bool,
1814 #[serde(default)]
1815 pub explosion: Option<i32>,
1816 #[serde(default)]
1817 pub forcetoenablemotion: Option<f32>,
1818 pub gibdir: Vector,
1819 #[serde(default)]
1820 pub health: Option<u16>,
1821 #[serde(default)]
1822 pub massscale: Option<f32>,
1823 #[serde(default)]
1824 pub material: Option<i32>,
1825 pub model: &'a str,
1826 #[serde(deserialize_with = "deserialize_bool")]
1827 #[serde(default)]
1828 pub nodamageforces: bool,
1829 #[serde(deserialize_with = "deserialize_bool")]
1830 #[serde(default)]
1831 pub notsolid: bool,
1832 pub origin: Vector,
1833 #[serde(default)]
1834 pub parentname: Option<&'a str>,
1835 #[serde(deserialize_with = "deserialize_bool")]
1836 #[serde(default)]
1837 pub performancemode: bool,
1838 pub preferredcarryangles: Vector,
1839 #[serde(deserialize_with = "deserialize_bool")]
1840 #[serde(default)]
1841 pub pressuredelay: bool,
1842 #[serde(default)]
1843 pub propdata: Option<i32>,
1844 pub renderamt: u8,
1845 pub rendercolor: Color,
1846 #[serde(deserialize_with = "deserialize_bool")]
1847 pub renderfx: bool,
1848 #[serde(deserialize_with = "deserialize_bool")]
1849 pub rendermode: bool,
1850 pub spawnflags: u32,
1851 #[serde(default)]
1852 pub spawnobject: Option<i32>,
1853 #[serde(default)]
1854 pub targetname: Option<&'a str>,
1855}
1856#[derive(Debug, Clone, Deserialize)]
1857pub struct FuncPhysboxMultiplayer<'a> {
1858 #[serde(default)]
1859 pub _minlight: Option<u8>,
1860 pub damagetoenablemotion: i32,
1861 #[serde(deserialize_with = "deserialize_bool")]
1862 pub damagetype: bool,
1863 #[serde(deserialize_with = "deserialize_bool")]
1864 pub disablereceiveshadows: bool,
1865 #[serde(deserialize_with = "deserialize_bool")]
1866 pub disableshadows: bool,
1867 #[serde(deserialize_with = "deserialize_bool")]
1868 pub explodedamage: bool,
1869 #[serde(deserialize_with = "deserialize_bool")]
1870 pub explodemagnitude: bool,
1871 #[serde(deserialize_with = "deserialize_bool")]
1872 pub exploderadius: bool,
1873 #[serde(deserialize_with = "deserialize_bool")]
1874 pub explosion: bool,
1875 pub forcetoenablemotion: f32,
1876 pub gibdir: Angles,
1877 pub health: u8,
1878 pub massscale: f32,
1879 pub material: u8,
1880 pub model: &'a str,
1881 #[serde(deserialize_with = "deserialize_bool")]
1882 pub nodamageforces: bool,
1883 #[serde(deserialize_with = "deserialize_bool")]
1884 pub notsolid: bool,
1885 #[serde(default)]
1886 pub onawakened: Option<&'a str>,
1887 pub origin: Vector,
1888 #[serde(default)]
1889 pub parentname: Option<&'a str>,
1890 #[serde(deserialize_with = "deserialize_bool")]
1891 pub performancemode: bool,
1892 pub preferredcarryangles: Vector,
1893 #[serde(deserialize_with = "deserialize_bool")]
1894 pub pressuredelay: bool,
1895 #[serde(deserialize_with = "deserialize_bool")]
1896 pub propdata: bool,
1897 pub renderamt: u8,
1898 pub rendercolor: Color,
1899 pub renderfx: u8,
1900 pub rendermode: u8,
1901 pub spawnflags: u32,
1902 #[serde(deserialize_with = "deserialize_bool")]
1903 #[serde(default)]
1904 pub spawnobject: bool,
1905 #[serde(default)]
1906 pub targetname: Option<&'a str>,
1907}
1908#[derive(Debug, Clone, Deserialize)]
1909pub struct FuncPrecipitation<'a> {
1910 pub model: &'a str,
1911 #[serde(default)]
1912 pub preciptype: Option<i32>,
1913 pub renderamt: i32,
1914 pub rendercolor: Color,
1915 #[serde(default)]
1916 pub renderfx: Option<u8>,
1917 #[serde(default)]
1918 pub targetname: Option<&'a str>,
1919}
1920#[derive(Debug, Clone, Deserialize)]
1921pub struct FuncRotButton<'a> {
1922 pub angles: Angles,
1923 pub distance: i32,
1924 #[serde(deserialize_with = "deserialize_bool")]
1925 pub health: bool,
1926 pub model: &'a str,
1927 pub onpressed: &'a str,
1928 pub origin: Vector,
1929 pub sounds: i32,
1930 pub spawnflags: u32,
1931 pub speed: u8,
1932 #[serde(deserialize_with = "deserialize_bool")]
1933 #[serde(default)]
1934 pub startdisabled: bool,
1935 #[serde(default)]
1936 pub targetname: Option<&'a str>,
1937 pub wait: i32,
1938}
1939#[derive(Debug, Clone, Deserialize)]
1940pub struct FuncRotating<'a> {
1941 #[serde(default)]
1942 pub _minlight: Option<f32>,
1943 pub angles: Angles,
1944 #[serde(deserialize_with = "deserialize_bool")]
1945 pub disablereceiveshadows: bool,
1946 #[serde(deserialize_with = "deserialize_bool")]
1947 #[serde(default)]
1948 pub disableshadows: bool,
1949 pub dmg: f32,
1950 pub fanfriction: f32,
1951 pub maxspeed: f32,
1952 #[serde(default)]
1953 pub message: Option<&'a str>,
1954 pub model: &'a str,
1955 #[serde(deserialize_with = "deserialize_bool")]
1956 #[serde(default)]
1957 pub no_decomp: bool,
1958 pub origin: Vector,
1959 #[serde(default)]
1960 pub parentname: Option<&'a str>,
1961 pub renderamt: i32,
1962 pub rendercolor: Color,
1963 #[serde(deserialize_with = "deserialize_bool")]
1964 pub renderfx: bool,
1965 pub rendermode: u8,
1966 #[serde(deserialize_with = "deserialize_bool")]
1967 #[serde(default)]
1968 pub solidbsp: bool,
1969 pub spawnflags: u32,
1970 #[serde(default)]
1971 pub targetname: Option<&'a str>,
1972 pub volume: f32,
1973}
1974#[derive(Debug, Clone, Deserialize)]
1975pub struct FuncSmokevolume<'a> {
1976 pub color1: Color,
1977 pub color2: Color,
1978 pub density: f32,
1979 #[serde(deserialize_with = "deserialize_bool")]
1980 pub densityrampspeed: bool,
1981 pub material: &'a str,
1982 pub model: &'a str,
1983 pub movementspeed: u8,
1984 pub particledrawwidth: u8,
1985 pub particlespacingdistance: u8,
1986 pub rotationspeed: u8,
1987 pub spawnflags: u32,
1988}
1989#[derive(Debug, Clone, Deserialize)]
1990pub struct FuncTracktrain<'a> {
1991 #[serde(deserialize_with = "deserialize_bool")]
1992 #[serde(default)]
1993 pub _minlight: bool,
1994 pub bank: f32,
1995 #[serde(deserialize_with = "deserialize_bool")]
1996 pub disablereceiveshadows: bool,
1997 #[serde(deserialize_with = "deserialize_bool")]
1998 pub disableshadows: bool,
1999 pub dmg: f32,
2000 pub height: f32,
2001 #[serde(deserialize_with = "deserialize_bool")]
2002 #[serde(default)]
2003 pub manualaccelspeed: bool,
2004 #[serde(deserialize_with = "deserialize_bool")]
2005 #[serde(default)]
2006 pub manualdecelspeed: bool,
2007 #[serde(deserialize_with = "deserialize_bool")]
2008 #[serde(default)]
2009 pub manualspeedchanges: bool,
2010 pub model: &'a str,
2011 #[serde(default)]
2012 pub movesound: Option<&'a str>,
2013 pub movesoundmaxpitch: u8,
2014 #[serde(deserialize_with = "deserialize_bool")]
2015 pub movesoundmaxtime: bool,
2016 pub movesoundminpitch: u8,
2017 #[serde(deserialize_with = "deserialize_bool")]
2018 pub movesoundmintime: bool,
2019 pub orientationtype: i32,
2020 pub origin: Vector,
2021 pub renderamt: i32,
2022 pub rendercolor: Color,
2023 #[serde(deserialize_with = "deserialize_bool")]
2024 pub renderfx: bool,
2025 #[serde(deserialize_with = "deserialize_bool")]
2026 pub rendermode: bool,
2027 pub spawnflags: u32,
2028 pub speed: u16,
2029 #[serde(default)]
2030 pub startsound: Option<&'a str>,
2031 pub startspeed: f32,
2032 #[serde(default)]
2033 pub stopsound: Option<&'a str>,
2034 pub target: &'a str,
2035 pub targetname: &'a str,
2036 pub velocitytype: i32,
2037 pub volume: i32,
2038 pub wheels: f32,
2039}
2040#[derive(Debug, Clone, Deserialize)]
2041pub struct FuncTrain<'a> {
2042 pub _minlight: f32,
2043 #[serde(deserialize_with = "deserialize_bool")]
2044 pub disablereceiveshadows: bool,
2045 #[serde(deserialize_with = "deserialize_bool")]
2046 pub disableshadows: bool,
2047 pub dmg: f32,
2048 pub model: &'a str,
2049 pub origin: Vector,
2050 pub renderamt: u8,
2051 pub rendercolor: Color,
2052 #[serde(deserialize_with = "deserialize_bool")]
2053 pub renderfx: bool,
2054 #[serde(deserialize_with = "deserialize_bool")]
2055 pub rendermode: bool,
2056 pub spawnflags: u32,
2057 pub speed: u16,
2058 pub target: &'a str,
2059 pub targetname: &'a str,
2060 #[serde(deserialize_with = "deserialize_bool")]
2061 pub texframeindex: bool,
2062 pub volume: f32,
2063}
2064#[derive(Debug, Clone, Deserialize)]
2065pub struct FuncWall<'a> {
2066 #[serde(default)]
2067 pub _minlight: Option<f32>,
2068 #[serde(deserialize_with = "deserialize_bool")]
2069 #[serde(default)]
2070 pub disablereceiveshadows: bool,
2071 #[serde(deserialize_with = "deserialize_bool")]
2072 #[serde(default)]
2073 pub disableshadows: bool,
2074 pub model: &'a str,
2075 #[serde(default)]
2076 pub origin: Option<Vector>,
2077 pub renderamt: i32,
2078 pub rendercolor: Color,
2079 #[serde(default)]
2080 pub renderfx: Option<u8>,
2081 #[serde(default)]
2082 pub rendermode: Option<u8>,
2083 #[serde(default)]
2084 pub spawnflags: Option<u32>,
2085 #[serde(default)]
2086 pub targetname: Option<&'a str>,
2087 #[serde(deserialize_with = "deserialize_bool")]
2088 #[serde(default)]
2089 pub zhlt_lightflags: bool,
2090}
2091#[derive(Debug, Clone, Deserialize)]
2092pub struct FuncWallToggle<'a> {
2093 #[serde(default)]
2094 pub _minlight: Option<f32>,
2095 #[serde(deserialize_with = "deserialize_bool")]
2096 pub disablereceiveshadows: bool,
2097 #[serde(deserialize_with = "deserialize_bool")]
2098 pub disableshadows: bool,
2099 pub model: &'a str,
2100 #[serde(default)]
2101 pub origin: Option<Vector>,
2102 pub renderamt: u8,
2103 pub rendercolor: Color,
2104 pub renderfx: u8,
2105 pub rendermode: u8,
2106 pub spawnflags: u32,
2107 pub targetname: &'a str,
2108}
2109#[derive(Debug, Clone, Deserialize)]
2110pub struct FuncWaterAnalog<'a> {
2111 #[serde(default)]
2112 pub _minlight: Option<f32>,
2113 #[serde(deserialize_with = "deserialize_bool")]
2114 #[serde(default)]
2115 pub disablereceiveshadows: bool,
2116 #[serde(deserialize_with = "deserialize_bool")]
2117 #[serde(default)]
2118 pub disableshadows: bool,
2119 pub model: &'a str,
2120 #[serde(default)]
2121 pub movedir: Option<Vector>,
2122 #[serde(default)]
2123 pub movedistance: Option<u8>,
2124 pub origin: Vector,
2125 #[serde(default)]
2126 pub parentname: Option<&'a str>,
2127 #[serde(default)]
2128 pub renderamt: Option<u8>,
2129 #[serde(default)]
2130 pub rendercolor: Option<Color>,
2131 #[serde(deserialize_with = "deserialize_bool")]
2132 #[serde(default)]
2133 pub renderfx: bool,
2134 #[serde(default)]
2135 pub rendermode: Option<u8>,
2136 #[serde(default)]
2137 pub speed: Option<u8>,
2138 #[serde(deserialize_with = "deserialize_bool")]
2139 #[serde(default)]
2140 pub startposition: bool,
2141 #[serde(default)]
2142 pub targetname: Option<&'a str>,
2143 pub waveheight: f32,
2144}
2145#[derive(Debug, Clone, Deserialize)]
2146pub struct GamePlayerEquip<'a> {
2147 #[serde(deserialize_with = "deserialize_bool")]
2148 #[serde(default)]
2149 pub ammo_338mag: bool,
2150 #[serde(default)]
2151 pub ammo_45acp: Option<u8>,
2152 #[serde(default)]
2153 pub ammo_50ae: Option<u8>,
2154 #[serde(default)]
2155 pub ammo_762mm: Option<u8>,
2156 #[serde(default)]
2157 pub ammo_9mm: Option<u8>,
2158 #[serde(default)]
2159 pub ammo_buckshot: Option<u8>,
2160 #[serde(default)]
2161 pub item_assaultsuit: Option<u8>,
2162 pub origin: Vector,
2163 #[serde(default)]
2164 pub spawnflags: Option<u32>,
2165 #[serde(default)]
2166 pub targetname: Option<&'a str>,
2167 #[serde(deserialize_with = "deserialize_bool")]
2168 #[serde(default)]
2169 pub weapon_awp: bool,
2170 #[serde(deserialize_with = "deserialize_bool")]
2171 #[serde(default)]
2172 pub weapon_deagle: bool,
2173 #[serde(deserialize_with = "deserialize_bool")]
2174 #[serde(default)]
2175 pub weapon_glock: bool,
2176 #[serde(deserialize_with = "deserialize_bool")]
2177 #[serde(default)]
2178 pub weapon_hegrenade: bool,
2179 #[serde(deserialize_with = "deserialize_bool")]
2180 #[serde(default)]
2181 pub weapon_knife: bool,
2182 #[serde(deserialize_with = "deserialize_bool")]
2183 #[serde(default)]
2184 pub weapon_m3: bool,
2185 #[serde(deserialize_with = "deserialize_bool")]
2186 #[serde(default)]
2187 pub weapon_p90: bool,
2188 #[serde(deserialize_with = "deserialize_bool")]
2189 #[serde(default)]
2190 pub weapon_scout: bool,
2191 #[serde(deserialize_with = "deserialize_bool")]
2192 #[serde(default)]
2193 pub weapon_usp: bool,
2194}
2195#[derive(Debug, Clone, Deserialize)]
2196pub struct GameText<'a> {
2197 pub channel: i32,
2198 pub color: Color,
2199 pub color2: Color,
2200 pub effect: i32,
2201 pub fadein: f32,
2202 pub fadeout: f32,
2203 pub fxtime: f32,
2204 pub holdtime: f32,
2205 pub message: &'a str,
2206 pub origin: Vector,
2207 pub spawnflags: u32,
2208 pub targetname: &'a str,
2209 pub x: f32,
2210 pub y: f32,
2211}
2212#[derive(Debug, Clone, Deserialize)]
2213pub struct GameUi<'a> {
2214 pub fieldofview: f32,
2215 pub origin: Vector,
2216 pub playeroff: &'a str,
2217 pub pressedback: &'a str,
2218 pub pressedforward: &'a str,
2219 pub pressedmoveleft: &'a str,
2220 pub pressedmoveright: &'a str,
2221 pub spawnflags: u32,
2222 pub targetname: &'a str,
2223 pub unpressedback: &'a str,
2224 pub unpressedforward: &'a str,
2225 pub unpressedmoveleft: &'a str,
2226 pub unpressedmoveright: &'a str,
2227}
2228#[derive(Debug, Clone, Deserialize)]
2229pub struct GameWeaponManager<'a> {
2230 pub ammomod: f32,
2231 pub maxpieces: i32,
2232 pub origin: Vector,
2233 pub weaponname: &'a str,
2234}
2235#[derive(Debug, Clone, Deserialize)]
2236pub struct HostageEntity<'a> {
2237 pub angles: Angles,
2238 #[serde(deserialize_with = "deserialize_bool")]
2239 #[serde(default)]
2240 pub hostagetype: bool,
2241 #[serde(default)]
2242 pub model: Option<&'a str>,
2243 pub origin: Vector,
2244 #[serde(deserialize_with = "deserialize_bool")]
2245 #[serde(default)]
2246 pub skin: bool,
2247 #[serde(default)]
2248 pub spawnflags: Option<u32>,
2249}
2250#[derive(Debug, Clone, Deserialize)]
2251pub struct InfoCameraLink<'a> {
2252 pub origin: Vector,
2253 #[serde(default)]
2254 pub pointcamera: Option<&'a str>,
2255 #[serde(default)]
2256 pub target: Option<&'a str>,
2257 #[serde(default)]
2258 pub targetname: Option<&'a str>,
2259}
2260#[derive(Debug, Clone, Deserialize)]
2261pub struct InfoLadder {
2262 #[serde(rename = "maxs.x")]
2263 pub maxs_x: f32,
2264 #[serde(rename = "maxs.y")]
2265 pub maxs_y: f32,
2266 #[serde(rename = "maxs.z")]
2267 pub maxs_z: f32,
2268 #[serde(rename = "mins.x")]
2269 pub mins_x: f32,
2270 #[serde(rename = "mins.y")]
2271 pub mins_y: f32,
2272 #[serde(rename = "mins.z")]
2273 pub mins_z: f32,
2274}
2275#[derive(Debug, Clone, Deserialize)]
2276pub struct InfoLightingRelative<'a> {
2277 pub lightinglandmark: &'a str,
2278 pub origin: Vector,
2279 pub targetname: &'a str,
2280}
2281#[derive(Debug, Clone, Deserialize)]
2282pub struct InfoMapParameters {
2283 #[serde(default)]
2284 pub angles: Option<Angles>,
2285 pub bombradius: u16,
2286 #[serde(deserialize_with = "deserialize_bool")]
2287 #[serde(default)]
2288 pub buying: bool,
2289 pub origin: Vector,
2290 #[serde(default)]
2291 pub spawnflags: Option<u32>,
2292}
2293#[derive(Debug, Clone, Deserialize)]
2294pub struct InfoNode {
2295 pub nodeid: u16,
2296 pub origin: Vector,
2297}
2298#[derive(Debug, Clone, Deserialize)]
2299pub struct InfoNodeHint {
2300 pub angles: Angles,
2301 pub hinttype: u16,
2302 pub ignorefacing: u8,
2303 pub maximumstate: u8,
2304 #[serde(deserialize_with = "deserialize_bool")]
2305 pub minimumstate: bool,
2306 pub nodefov: u8,
2307 pub nodeid: u8,
2308 pub origin: Vector,
2309 #[serde(deserialize_with = "deserialize_bool")]
2310 pub starthintdisabled: bool,
2311 pub targetnode: i32,
2312}
2313#[derive(Debug, Clone, Deserialize)]
2314pub struct InfoParticleSystem<'a> {
2315 pub angles: Angles,
2316 #[serde(deserialize_with = "deserialize_bool")]
2317 pub cpoint1_parent: bool,
2318 #[serde(deserialize_with = "deserialize_bool")]
2319 pub cpoint2_parent: bool,
2320 #[serde(deserialize_with = "deserialize_bool")]
2321 pub cpoint3_parent: bool,
2322 #[serde(deserialize_with = "deserialize_bool")]
2323 pub cpoint4_parent: bool,
2324 #[serde(deserialize_with = "deserialize_bool")]
2325 pub cpoint5_parent: bool,
2326 #[serde(deserialize_with = "deserialize_bool")]
2327 pub cpoint6_parent: bool,
2328 #[serde(deserialize_with = "deserialize_bool")]
2329 pub cpoint7_parent: bool,
2330 pub effect_name: &'a str,
2331 #[serde(deserialize_with = "deserialize_bool")]
2332 pub flag_as_weather: bool,
2333 pub origin: Vector,
2334 #[serde(default)]
2335 pub parentname: Option<&'a str>,
2336 #[serde(default)]
2337 pub spawnflags: Option<u32>,
2338 #[serde(deserialize_with = "deserialize_bool")]
2339 pub start_active: bool,
2340 #[serde(default)]
2341 pub targetname: Option<&'a str>,
2342}
2343#[derive(Debug, Clone, Deserialize)]
2344pub struct InfoPlayerCounterterrorist {
2345 pub angles: Angles,
2346 pub origin: Vector,
2347}
2348#[derive(Debug, Clone, Deserialize)]
2349pub struct InfoPlayerLogo {
2350 pub angles: Angles,
2351 pub origin: Vector,
2352}
2353#[derive(Debug, Clone, Deserialize)]
2354pub struct InfoPlayerStart {
2355 pub angles: Angles,
2356 pub origin: Vector,
2357 #[serde(default)]
2358 pub spawnflags: Option<u32>,
2359}
2360#[derive(Debug, Clone, Deserialize)]
2361pub struct InfoPlayerTerrorist {
2362 pub angles: Angles,
2363 #[serde(deserialize_with = "deserialize_bool")]
2364 #[serde(default)]
2365 pub no_decomp: bool,
2366 pub origin: Vector,
2367}
2368#[derive(Debug, Clone, Deserialize)]
2369pub struct InfoTarget<'a> {
2370 pub angles: Angles,
2371 pub origin: Vector,
2372 #[serde(default)]
2373 pub parentname: Option<&'a str>,
2374 #[serde(default)]
2375 pub spawnflags: Option<u32>,
2376 #[serde(default)]
2377 pub targetname: Option<&'a str>,
2378}
2379#[derive(Debug, Clone, Deserialize)]
2380pub struct InfoTeleportDestination<'a> {
2381 pub angles: Angles,
2382 pub origin: Vector,
2383 #[serde(default)]
2384 pub parentname: Option<&'a str>,
2385 #[serde(default)]
2386 pub targetname: Option<&'a str>,
2387}
2388#[derive(Debug, Clone, Deserialize)]
2389pub struct Infodecal<'a> {
2390 #[serde(default)]
2391 pub angles: Option<Angles>,
2392 #[serde(deserialize_with = "deserialize_bool")]
2393 #[serde(default)]
2394 pub lowpriority: bool,
2395 pub origin: Vector,
2396 #[serde(default)]
2397 pub spawnflags: Option<u32>,
2398 pub texture: &'a str,
2399}
2400#[derive(Debug, Clone, Deserialize)]
2401pub struct KeyframeRope<'a> {
2402 #[serde(default)]
2403 pub angles: Option<Angles>,
2404 #[serde(deserialize_with = "deserialize_bool")]
2405 #[serde(default)]
2406 pub barbed: bool,
2407 #[serde(deserialize_with = "deserialize_bool")]
2408 #[serde(default)]
2409 pub breakable: bool,
2410 #[serde(deserialize_with = "deserialize_bool")]
2411 #[serde(default)]
2412 pub collide: bool,
2413 #[serde(deserialize_with = "deserialize_bool")]
2414 #[serde(default)]
2415 pub dangling: bool,
2416 #[serde(deserialize_with = "deserialize_bool")]
2417 #[serde(default)]
2418 pub maxdxlevel: bool,
2419 #[serde(deserialize_with = "deserialize_bool")]
2420 #[serde(default)]
2421 pub mindxlevel: bool,
2422 pub movespeed: u8,
2423 #[serde(default)]
2424 pub nextkey: Option<&'a str>,
2425 #[serde(deserialize_with = "deserialize_bool")]
2426 #[serde(default)]
2427 pub nowind: bool,
2428 pub origin: Vector,
2429 #[serde(default)]
2430 pub parentname: Option<&'a str>,
2431 #[serde(deserialize_with = "deserialize_bool")]
2432 #[serde(default)]
2433 pub r#type: bool,
2434 pub ropematerial: &'a str,
2435 pub slack: f32,
2436 #[serde(default)]
2437 pub spawnflags: Option<u32>,
2438 pub subdiv: u8,
2439 pub targetname: &'a str,
2440 pub texturescale: u8,
2441 pub width: f32,
2442}
2443#[derive(Debug, Clone, Deserialize)]
2444pub struct Light<'a> {
2445 #[serde(default)]
2446 pub _constant_attn: Option<f32>,
2447 #[serde(default)]
2448 pub _distance: Option<u16>,
2449 #[serde(default)]
2450 pub _fifty_percent_distance: Option<f32>,
2451 #[serde(default)]
2452 pub _hardfalloff: Option<u16>,
2453 pub _light: LightColor,
2454 #[serde(default)]
2455 pub _lighthdr: Option<&'a str>,
2456 #[serde(deserialize_with = "deserialize_bool")]
2457 #[serde(default)]
2458 pub _lightscalehdr: bool,
2459 #[serde(default)]
2460 pub _linear_attn: Option<f32>,
2461 pub _quadratic_attn: f32,
2462 #[serde(default)]
2463 pub _zero_percent_distance: Option<f32>,
2464 #[serde(default)]
2465 pub angles: Option<Angles>,
2466 #[serde(default)]
2467 pub defaultstyle: Option<i32>,
2468 #[serde(default)]
2469 pub ontimer: Option<&'a str>,
2470 pub origin: Vector,
2471 #[serde(default)]
2472 pub spawnflags: Option<u32>,
2473 #[serde(default)]
2474 pub style: Option<i32>,
2475 #[serde(default)]
2476 pub targetname: Option<&'a str>,
2477}
2478#[derive(Debug, Clone, Deserialize)]
2479pub struct LightEnvironment<'a> {
2480 pub _ambient: LightColor,
2481 #[serde(default)]
2482 pub _ambienthdr: Option<&'a str>,
2483 #[serde(deserialize_with = "deserialize_bool")]
2484 #[serde(default)]
2485 pub _ambientscalehdr: bool,
2486 #[serde(default)]
2487 pub _diffuse_light: Option<LightColor>,
2488 #[serde(default)]
2489 pub _diffuse_lighting: Option<LightColor>,
2490 pub _light: LightColor,
2491 #[serde(default)]
2492 pub _lighthdr: Option<&'a str>,
2493 #[serde(deserialize_with = "deserialize_bool")]
2494 #[serde(default)]
2495 pub _lightscalehdr: bool,
2496 pub angles: Angles,
2497 pub origin: Vector,
2498 #[serde(default)]
2499 pub pitch: Option<Angles>,
2500 #[serde(default)]
2501 pub spawnflags: Option<u32>,
2502 #[serde(default)]
2503 pub style: Option<i32>,
2504 #[serde(default)]
2505 pub sunspreadangle: Option<u8>,
2506}
2507#[derive(Debug, Clone, Deserialize)]
2508pub struct LightSpot<'a> {
2509 pub _cone: u8,
2510 #[serde(default)]
2511 pub _cone2: Option<u8>,
2512 #[serde(default)]
2513 pub _constant_attn: Option<f32>,
2514 #[serde(default)]
2515 pub _distance: Option<u32>,
2516 pub _exponent: f32,
2517 #[serde(default)]
2518 pub _fifty_percent_distance: Option<f32>,
2519 #[serde(deserialize_with = "deserialize_bool")]
2520 #[serde(default)]
2521 pub _hardfalloff: bool,
2522 pub _inner_cone: u8,
2523 pub _light: LightColor,
2524 #[serde(default)]
2525 pub _lighthdr: Option<&'a str>,
2526 #[serde(deserialize_with = "deserialize_bool")]
2527 #[serde(default)]
2528 pub _lightscalehdr: bool,
2529 #[serde(default)]
2530 pub _linear_attn: Option<f32>,
2531 #[serde(deserialize_with = "deserialize_bool")]
2532 pub _quadratic_attn: bool,
2533 #[serde(default)]
2534 pub _zero_percent_distance: Option<f32>,
2535 pub angles: Angles,
2536 #[serde(default)]
2537 pub defaultstyle: Option<i32>,
2538 pub origin: Vector,
2539 pub pitch: Angles,
2540 #[serde(default)]
2541 pub renderamt: Option<u8>,
2542 #[serde(default)]
2543 pub spawnflags: Option<u32>,
2544 #[serde(default)]
2545 pub style: Option<i32>,
2546 #[serde(default)]
2547 pub targetname: Option<&'a str>,
2548}
2549#[derive(Debug, Clone, Deserialize)]
2550pub struct LogicAuto<'a> {
2551 #[serde(default)]
2552 pub onloadgame: Option<&'a str>,
2553 pub onmapspawn: &'a str,
2554 #[serde(default)]
2555 pub onnewgame: Option<&'a str>,
2556 pub origin: Vector,
2557 pub spawnflags: u32,
2558}
2559#[derive(Debug, Clone, Deserialize)]
2560pub struct LogicBranch<'a> {
2561 #[serde(deserialize_with = "deserialize_bool")]
2562 pub initialvalue: bool,
2563 #[serde(default)]
2564 pub onfalse: Option<&'a str>,
2565 pub ontrue: &'a str,
2566 pub origin: Vector,
2567 pub targetname: &'a str,
2568}
2569#[derive(Debug, Clone, Deserialize)]
2570pub struct LogicCase<'a> {
2571 #[serde(default)]
2572 pub case01: Option<u8>,
2573 #[serde(default)]
2574 pub case02: Option<u8>,
2575 #[serde(default)]
2576 pub case03: Option<u8>,
2577 #[serde(default)]
2578 pub case04: Option<u8>,
2579 #[serde(default)]
2580 pub case05: Option<u8>,
2581 #[serde(default)]
2582 pub case06: Option<u8>,
2583 #[serde(default)]
2584 pub case07: Option<u8>,
2585 #[serde(default)]
2586 pub case08: Option<u8>,
2587 #[serde(default)]
2588 pub case09: Option<u8>,
2589 #[serde(default)]
2590 pub case10: Option<u8>,
2591 #[serde(default)]
2592 pub case11: Option<u8>,
2593 #[serde(default)]
2594 pub case12: Option<u8>,
2595 #[serde(default)]
2596 pub case13: Option<u8>,
2597 #[serde(default)]
2598 pub case14: Option<u8>,
2599 #[serde(default)]
2600 pub case15: Option<u8>,
2601 #[serde(default)]
2602 pub case16: Option<u8>,
2603 pub oncase01: &'a str,
2604 pub oncase02: &'a str,
2605 pub oncase03: &'a str,
2606 pub oncase04: &'a str,
2607 #[serde(default)]
2608 pub oncase05: Option<&'a str>,
2609 #[serde(default)]
2610 pub oncase06: Option<&'a str>,
2611 #[serde(default)]
2612 pub oncase07: Option<&'a str>,
2613 #[serde(default)]
2614 pub oncase08: Option<&'a str>,
2615 #[serde(default)]
2616 pub oncase09: Option<&'a str>,
2617 #[serde(default)]
2618 pub oncase10: Option<&'a str>,
2619 #[serde(default)]
2620 pub oncase11: Option<&'a str>,
2621 #[serde(default)]
2622 pub oncase12: Option<&'a str>,
2623 #[serde(default)]
2624 pub oncase13: Option<&'a str>,
2625 #[serde(default)]
2626 pub oncase14: Option<&'a str>,
2627 #[serde(default)]
2628 pub oncase15: Option<&'a str>,
2629 #[serde(default)]
2630 pub oncase16: Option<&'a str>,
2631 pub origin: Vector,
2632 pub targetname: &'a str,
2633}
2634#[derive(Debug, Clone, Deserialize)]
2635pub struct LogicCompare<'a> {
2636 #[serde(deserialize_with = "deserialize_bool")]
2637 pub comparevalue: bool,
2638 pub ongreaterthan: &'a str,
2639 pub origin: Vector,
2640 pub targetname: &'a str,
2641}
2642#[derive(Debug, Clone, Deserialize)]
2643pub struct LogicMeasureMovement<'a> {
2644 pub measurereference: &'a str,
2645 pub measuretarget: &'a str,
2646 #[serde(deserialize_with = "deserialize_bool")]
2647 pub measuretype: bool,
2648 pub origin: Vector,
2649 pub target: &'a str,
2650 pub targetname: &'a str,
2651 pub targetreference: &'a str,
2652 #[serde(deserialize_with = "deserialize_bool")]
2653 pub targetscale: bool,
2654}
2655#[derive(Debug, Clone, Deserialize)]
2656pub struct LogicRelay<'a> {
2657 pub ontrigger: &'a str,
2658 pub origin: Vector,
2659 #[serde(default)]
2660 pub spawnflags: Option<u32>,
2661 #[serde(deserialize_with = "deserialize_bool")]
2662 #[serde(default)]
2663 pub startdisabled: bool,
2664 pub targetname: &'a str,
2665}
2666#[derive(Debug, Clone, Deserialize)]
2667pub struct LogicTimer<'a> {
2668 #[serde(default)]
2669 pub lowerrandombound: Option<u8>,
2670 pub ontimer: &'a str,
2671 #[serde(default)]
2672 pub ontimerhigh: Option<&'a str>,
2673 #[serde(default)]
2674 pub ontimerlow: Option<&'a str>,
2675 pub origin: Vector,
2676 #[serde(default)]
2677 pub refiretime: Option<f32>,
2678 #[serde(default)]
2679 pub spawnflags: Option<u32>,
2680 #[serde(deserialize_with = "deserialize_bool")]
2681 #[serde(default)]
2682 pub startdisabled: bool,
2683 #[serde(default)]
2684 pub targetname: Option<&'a str>,
2685 #[serde(default)]
2686 pub upperrandombound: Option<u8>,
2687 #[serde(deserialize_with = "deserialize_bool")]
2688 #[serde(default)]
2689 pub userandomtime: bool,
2690}
2691#[derive(Debug, Clone, Deserialize)]
2692pub struct MathCounter<'a> {
2693 pub max: f32,
2694 #[serde(default)]
2695 pub min: Option<f32>,
2696 pub onhitmax: &'a str,
2697 pub origin: Vector,
2698 #[serde(default)]
2699 pub outvalue: Option<&'a str>,
2700 #[serde(deserialize_with = "deserialize_bool")]
2701 #[serde(default)]
2702 pub startdisabled: bool,
2703 #[serde(deserialize_with = "deserialize_bool")]
2704 #[serde(default)]
2705 pub startvalue: bool,
2706 pub targetname: &'a str,
2707}
2708#[derive(Debug, Clone, Deserialize)]
2709pub struct MoveRope<'a> {
2710 #[serde(default)]
2711 pub angles: Option<Angles>,
2712 #[serde(deserialize_with = "deserialize_bool")]
2713 #[serde(default)]
2714 pub barbed: bool,
2715 #[serde(deserialize_with = "deserialize_bool")]
2716 #[serde(default)]
2717 pub breakable: bool,
2718 #[serde(deserialize_with = "deserialize_bool")]
2719 #[serde(default)]
2720 pub collide: bool,
2721 #[serde(deserialize_with = "deserialize_bool")]
2722 #[serde(default)]
2723 pub dangling: bool,
2724 #[serde(deserialize_with = "deserialize_bool")]
2725 #[serde(default)]
2726 pub maxdxlevel: bool,
2727 #[serde(deserialize_with = "deserialize_bool")]
2728 #[serde(default)]
2729 pub mindxlevel: bool,
2730 pub movespeed: u8,
2731 #[serde(default)]
2732 pub nextkey: Option<&'a str>,
2733 #[serde(deserialize_with = "deserialize_bool")]
2734 #[serde(default)]
2735 pub nowind: bool,
2736 pub origin: Vector,
2737 #[serde(default)]
2738 pub parentname: Option<&'a str>,
2739 pub positioninterpolator: u8,
2740 #[serde(default)]
2741 pub r#type: Option<u8>,
2742 pub ropematerial: &'a str,
2743 pub slack: u8,
2744 #[serde(default)]
2745 pub spawnflags: Option<u32>,
2746 pub subdiv: u8,
2747 #[serde(default)]
2748 pub targetname: Option<&'a str>,
2749 pub texturescale: u8,
2750 pub width: f32,
2751}
2752#[derive(Debug, Clone, Deserialize)]
2753pub struct PathTrack<'a> {
2754 pub angles: Angles,
2755 #[serde(default)]
2756 pub onpass: Option<&'a str>,
2757 #[serde(default)]
2758 pub onuser1: Option<&'a str>,
2759 pub orientationtype: i32,
2760 pub origin: Vector,
2761 #[serde(default)]
2762 pub radius: Option<f32>,
2763 #[serde(default)]
2764 pub spawnflags: Option<u32>,
2765 #[serde(default)]
2766 pub speed: Option<u16>,
2767 #[serde(default)]
2768 pub target: Option<&'a str>,
2769 pub targetname: &'a str,
2770}
2771#[derive(Debug, Clone, Deserialize)]
2772pub struct PhysBallsocket<'a> {
2773 pub attach1: &'a str,
2774 #[serde(default)]
2775 pub forcelimit: Option<f32>,
2776 pub origin: Vector,
2777 #[serde(default)]
2778 pub spawnflags: Option<u32>,
2779 #[serde(default)]
2780 pub targetname: Option<&'a str>,
2781 #[serde(default)]
2782 pub torquelimit: Option<f32>,
2783}
2784#[derive(Debug, Clone, Deserialize)]
2785pub struct PhysConstraint<'a> {
2786 pub angles: Angles,
2787 pub constraintsystem: &'a str,
2788 pub forcelimit: f32,
2789 pub origin: Vector,
2790 pub spawnflags: u32,
2791 pub torquelimit: f32,
2792}
2793#[derive(Debug, Clone, Deserialize)]
2794pub struct PhysConstraintsystem<'a> {
2795 pub additionaliterations: i32,
2796 pub origin: Vector,
2797 pub targetname: &'a str,
2798}
2799#[derive(Debug, Clone, Deserialize)]
2800pub struct PhysHinge<'a> {
2801 pub attach1: &'a str,
2802 #[serde(default)]
2803 pub breaksound: Option<&'a str>,
2804 #[serde(default)]
2805 pub constraintsystem: Option<&'a str>,
2806 pub forcelimit: f32,
2807 pub hingeaxis: Vector,
2808 pub hingefriction: f32,
2809 pub origin: Vector,
2810 pub spawnflags: u32,
2811 pub systemloadscale: f32,
2812 #[serde(default)]
2813 pub targetname: Option<&'a str>,
2814 pub torquelimit: f32,
2815}
2816#[derive(Debug, Clone, Deserialize)]
2817pub struct PhysKeepupright<'a> {
2818 pub angles: Angles,
2819 pub angularlimit: f32,
2820 pub attach1: &'a str,
2821 pub origin: Vector,
2822 pub spawnflags: u32,
2823 #[serde(default)]
2824 pub targetname: Option<&'a str>,
2825}
2826#[derive(Debug, Clone, Deserialize)]
2827pub struct PhysLengthconstraint<'a> {
2828 pub addlength: f32,
2829 pub angles: Angles,
2830 pub attach1: &'a str,
2831 pub attachpoint: Vector,
2832 pub constraintsystem: &'a str,
2833 pub forcelimit: f32,
2834 pub minlength: f32,
2835 pub origin: Vector,
2836 pub spawnflags: u32,
2837 #[serde(default)]
2838 pub targetname: Option<&'a str>,
2839 pub torquelimit: f32,
2840}
2841#[derive(Debug, Clone, Deserialize)]
2842pub struct PhysPulleyconstraint<'a> {
2843 pub addlength: f32,
2844 pub angles: Angles,
2845 #[serde(default)]
2846 pub attach1: Option<&'a str>,
2847 #[serde(default)]
2848 pub attach2: Option<&'a str>,
2849 #[serde(default)]
2850 pub constraintsystem: Option<&'a str>,
2851 pub forcelimit: f32,
2852 pub gearratio: f32,
2853 pub origin: Vector,
2854 pub position2: Vector,
2855 pub spawnflags: u32,
2856 pub torquelimit: f32,
2857}
2858#[derive(Debug, Clone, Deserialize)]
2859pub struct PhysRagdollconstraint<'a> {
2860 #[serde(default)]
2861 pub angles: Option<Angles>,
2862 pub attach1: &'a str,
2863 pub forcelimit: f32,
2864 pub origin: Vector,
2865 pub spawnflags: u32,
2866 #[serde(default)]
2867 pub teleportfollowdistance: Option<f32>,
2868 pub torquelimit: f32,
2869 pub xfriction: f32,
2870 pub xmax: f32,
2871 pub xmin: f32,
2872 pub yfriction: f32,
2873 pub ymax: f32,
2874 pub ymin: f32,
2875 pub zfriction: f32,
2876 pub zmax: f32,
2877 pub zmin: f32,
2878}
2879#[derive(Debug, Clone, Deserialize)]
2880pub struct PhysRagdollmagnet {
2881 pub angles: Angles,
2882 pub axis: Vector,
2883 pub force: f32,
2884 pub origin: Vector,
2885 pub radius: f32,
2886 pub spawnflags: u32,
2887 #[serde(deserialize_with = "deserialize_bool")]
2888 pub startdisabled: bool,
2889}
2890#[derive(Debug, Clone, Deserialize)]
2891pub struct PhysThruster<'a> {
2892 pub angles: Angles,
2893 pub attach1: &'a str,
2894 pub force: f32,
2895 pub forcetime: f32,
2896 pub origin: Vector,
2897 #[serde(default)]
2898 pub parentname: Option<&'a str>,
2899 pub spawnflags: u32,
2900 pub targetname: &'a str,
2901}
2902#[derive(Debug, Clone, Deserialize)]
2903pub struct PhysTorque<'a> {
2904 pub attach1: &'a str,
2905 pub axis: Vector,
2906 pub force: f32,
2907 pub forcetime: f32,
2908 pub origin: Vector,
2909 pub spawnflags: u32,
2910 pub targetname: &'a str,
2911}
2912#[derive(Debug, Clone, Deserialize)]
2913pub struct PlayerSpeedmod<'a> {
2914 pub origin: Vector,
2915 #[serde(default)]
2916 pub spawnflags: Option<u32>,
2917 pub targetname: &'a str,
2918}
2919#[derive(Debug, Clone, Deserialize)]
2920pub struct PlayerWeaponstrip<'a> {
2921 pub origin: Vector,
2922 pub targetname: &'a str,
2923}
2924#[derive(Debug, Clone, Deserialize)]
2925pub struct PointCamera<'a> {
2926 pub angles: Angles,
2927 pub fogcolor: Color,
2928 #[serde(deserialize_with = "deserialize_bool")]
2929 #[serde(default)]
2930 pub fogenable: bool,
2931 pub fogend: u16,
2932 #[serde(deserialize_with = "deserialize_bool")]
2933 #[serde(default)]
2934 pub fogmaxdensity: bool,
2935 pub fogstart: u16,
2936 pub fov: u8,
2937 pub origin: Vector,
2938 #[serde(default)]
2939 pub resolution: Option<f32>,
2940 #[serde(default)]
2941 pub spawnflags: Option<u32>,
2942 pub targetname: &'a str,
2943 #[serde(deserialize_with = "deserialize_bool")]
2944 #[serde(default)]
2945 pub usescreenaspectratio: bool,
2946}
2947#[derive(Debug, Clone, Deserialize)]
2948pub struct PointClientcommand<'a> {
2949 pub origin: Vector,
2950 pub targetname: &'a str,
2951}
2952#[derive(Debug, Clone, Deserialize)]
2953pub struct PointDevshotCamera<'a> {
2954 pub angles: Angles,
2955 #[serde(default)]
2956 pub cameraname: Option<&'a str>,
2957 pub fov: u8,
2958 pub origin: Vector,
2959}
2960#[derive(Debug, Clone, Deserialize)]
2961pub struct PointServercommand<'a> {
2962 pub origin: Vector,
2963 pub targetname: &'a str,
2964}
2965#[derive(Debug, Clone, Deserialize)]
2966pub struct PointSpotlight<'a> {
2967 pub angles: Angles,
2968 #[serde(deserialize_with = "deserialize_bool")]
2969 #[serde(default)]
2970 pub disablereceiveshadows: bool,
2971 #[serde(default)]
2972 pub hdrcolorscale: Option<f32>,
2973 #[serde(deserialize_with = "deserialize_bool")]
2974 #[serde(default)]
2975 pub maxdxlevel: bool,
2976 #[serde(default)]
2977 pub mindxlevel: Option<i32>,
2978 pub origin: Vector,
2979 #[serde(default)]
2980 pub parentname: Option<&'a str>,
2981 #[serde(default)]
2982 pub renderamt: Option<u8>,
2983 pub rendercolor: Color,
2984 #[serde(default)]
2985 pub renderfx: Option<u8>,
2986 #[serde(default)]
2987 pub rendermode: Option<u8>,
2988 pub spawnflags: u32,
2989 pub spotlightlength: f32,
2990 pub spotlightwidth: f32,
2991 #[serde(default)]
2992 pub targetname: Option<&'a str>,
2993}
2994#[derive(Debug, Clone, Deserialize)]
2995pub struct PointSurroundtest<'a> {
2996 pub on2speakers: &'a str,
2997 pub on4speakers: &'a str,
2998 pub on51speakers: &'a str,
2999 pub origin: Vector,
3000 pub targetname: &'a str,
3001}
3002#[derive(Debug, Clone, Deserialize)]
3003pub struct PointTemplate<'a> {
3004 #[serde(default)]
3005 pub boltwidth: Option<u8>,
3006 #[serde(deserialize_with = "deserialize_bool")]
3007 #[serde(default)]
3008 pub damage: bool,
3009 #[serde(default)]
3010 pub decalname: Option<&'a str>,
3011 #[serde(deserialize_with = "deserialize_bool")]
3012 #[serde(default)]
3013 pub framerate: bool,
3014 #[serde(deserialize_with = "deserialize_bool")]
3015 #[serde(default)]
3016 pub framestart: bool,
3017 #[serde(default)]
3018 pub hdrcolorscale: Option<f32>,
3019 #[serde(deserialize_with = "deserialize_bool")]
3020 #[serde(default)]
3021 pub life: bool,
3022 #[serde(deserialize_with = "deserialize_bool")]
3023 #[serde(default)]
3024 pub noiseamplitude: bool,
3025 #[serde(default)]
3026 pub onentityspawned: Option<&'a str>,
3027 pub origin: Vector,
3028 #[serde(default)]
3029 pub radius: Option<u16>,
3030 #[serde(default)]
3031 pub renderamt: Option<u8>,
3032 #[serde(default)]
3033 pub rendercolor: Option<Color>,
3034 #[serde(deserialize_with = "deserialize_bool")]
3035 #[serde(default)]
3036 pub renderfx: bool,
3037 pub spawnflags: u32,
3038 #[serde(deserialize_with = "deserialize_bool")]
3039 #[serde(default)]
3040 pub striketime: bool,
3041 pub targetname: &'a str,
3042 pub template01: &'a str,
3043 #[serde(default)]
3044 pub template02: Option<&'a str>,
3045 #[serde(default)]
3046 pub template03: Option<&'a str>,
3047 #[serde(default)]
3048 pub template04: Option<&'a str>,
3049 #[serde(default)]
3050 pub template05: Option<&'a str>,
3051 #[serde(default)]
3052 pub texture: Option<&'a str>,
3053 #[serde(default)]
3054 pub texturescroll: Option<u8>,
3055 #[serde(deserialize_with = "deserialize_bool")]
3056 #[serde(default)]
3057 pub touchtype: bool,
3058}
3059#[derive(Debug, Clone, Deserialize)]
3060pub struct PointTesla<'a> {
3061 pub beamcount_max: i32,
3062 pub beamcount_min: i32,
3063 pub interval_max: f32,
3064 pub interval_min: f32,
3065 pub lifetime_max: f32,
3066 pub lifetime_min: f32,
3067 pub m_color: Color,
3068 pub m_flradius: u8,
3069 pub m_soundname: &'a str,
3070 pub origin: Vector,
3071 pub targetname: &'a str,
3072 pub texture: &'a str,
3073 pub thick_max: f32,
3074 pub thick_min: f32,
3075}
3076#[derive(Debug, Clone, Deserialize)]
3077pub struct PointViewcontrol<'a> {
3078 pub acceleration: u16,
3079 pub angles: Angles,
3080 pub deceleration: u16,
3081 #[serde(deserialize_with = "deserialize_bool")]
3082 #[serde(default)]
3083 pub interpolatepositiontoplayer: bool,
3084 pub origin: Vector,
3085 #[serde(default)]
3086 pub parentname: Option<&'a str>,
3087 pub spawnflags: u32,
3088 #[serde(deserialize_with = "deserialize_bool")]
3089 #[serde(default)]
3090 pub speed: bool,
3091 #[serde(default)]
3092 pub target: Option<&'a str>,
3093 #[serde(default)]
3094 pub targetname: Option<&'a str>,
3095 pub wait: f32,
3096}
3097#[derive(Debug, Clone, Deserialize)]
3098pub struct PropDoorRotating<'a> {
3099 pub ajarangles: Vector,
3100 pub angles: Angles,
3101 pub axis: Vector,
3102 #[serde(deserialize_with = "deserialize_bool")]
3103 pub disableshadows: bool,
3104 pub distance: f32,
3105 #[serde(default)]
3106 pub dmg: Option<f32>,
3107 #[serde(deserialize_with = "deserialize_bool")]
3108 #[serde(default)]
3109 pub forceclosed: bool,
3110 pub hardware: i32,
3111 #[serde(deserialize_with = "deserialize_bool")]
3112 #[serde(default)]
3113 pub health: bool,
3114 pub model: &'a str,
3115 #[serde(default)]
3116 pub onclose: Option<&'a str>,
3117 #[serde(default)]
3118 pub onopen: Option<&'a str>,
3119 #[serde(default)]
3120 pub opendir: Option<i32>,
3121 pub origin: Vector,
3122 pub returndelay: f32,
3123 pub skin: u8,
3124 #[serde(default)]
3125 pub soundcloseoverride: Option<&'a str>,
3126 #[serde(default)]
3127 pub soundmoveoverride: Option<&'a str>,
3128 #[serde(default)]
3129 pub soundopenoverride: Option<&'a str>,
3130 pub spawnflags: u32,
3131 #[serde(default)]
3132 pub spawnpos: Option<i32>,
3133 pub speed: u8,
3134 #[serde(default)]
3135 pub targetname: Option<&'a str>,
3136}
3137#[derive(Debug, Clone, Deserialize)]
3138pub struct PropDynamic<'a> {
3139 #[serde(default)]
3140 pub _minlight: Option<f32>,
3141 pub angles: Angles,
3142 #[serde(deserialize_with = "deserialize_bool")]
3143 #[serde(default)]
3144 pub body: bool,
3145 #[serde(default)]
3146 pub defaultanim: Option<&'a str>,
3147 #[serde(deserialize_with = "deserialize_bool")]
3148 #[serde(default)]
3149 pub disablebonefollowers: bool,
3150 #[serde(deserialize_with = "deserialize_bool")]
3151 #[serde(default)]
3152 pub disablereceiveshadows: bool,
3153 #[serde(deserialize_with = "deserialize_bool")]
3154 #[serde(default)]
3155 pub disableshadows: bool,
3156 #[serde(deserialize_with = "deserialize_bool")]
3157 #[serde(default)]
3158 pub explodedamage: bool,
3159 #[serde(deserialize_with = "deserialize_bool")]
3160 #[serde(default)]
3161 pub exploderadius: bool,
3162 #[serde(default)]
3163 pub fademaxdist: Option<f32>,
3164 pub fademindist: f32,
3165 #[serde(deserialize_with = "deserialize_bool")]
3166 #[serde(default)]
3167 pub fadescale: bool,
3168 #[serde(default)]
3169 pub globalname: Option<&'a str>,
3170 #[serde(deserialize_with = "deserialize_bool")]
3171 #[serde(default)]
3172 pub health: bool,
3173 #[serde(default)]
3174 pub lightingoriginhack: Option<&'a str>,
3175 pub maxanimtime: u8,
3176 #[serde(deserialize_with = "deserialize_bool")]
3177 #[serde(default)]
3178 pub maxdxlevel: bool,
3179 pub minanimtime: u8,
3180 #[serde(deserialize_with = "deserialize_bool")]
3181 #[serde(default)]
3182 pub mindxlevel: bool,
3183 pub model: &'a str,
3184 #[serde(default)]
3185 pub modelscale: Option<f32>,
3186 #[serde(default)]
3187 pub ontakedamage: Option<&'a str>,
3188 pub origin: Vector,
3189 #[serde(default)]
3190 pub parentname: Option<&'a str>,
3191 #[serde(deserialize_with = "deserialize_bool")]
3192 #[serde(default)]
3193 pub performancemode: bool,
3194 #[serde(deserialize_with = "deserialize_bool")]
3195 #[serde(default)]
3196 pub pressuredelay: bool,
3197 #[serde(deserialize_with = "deserialize_bool")]
3198 #[serde(default)]
3199 pub randomanimation: bool,
3200 #[serde(default)]
3201 pub renderamt: Option<u8>,
3202 #[serde(default)]
3203 pub rendercolor: Option<Color>,
3204 #[serde(default)]
3205 pub renderfx: Option<u8>,
3206 #[serde(deserialize_with = "deserialize_bool")]
3207 #[serde(default)]
3208 pub rendermode: bool,
3209 #[serde(default)]
3210 pub setbodygroup: Option<u8>,
3211 #[serde(deserialize_with = "deserialize_bool")]
3212 #[serde(default)]
3213 pub skin: bool,
3214 pub solid: u8,
3215 #[serde(default)]
3216 pub spawnflags: Option<u32>,
3217 #[serde(deserialize_with = "deserialize_bool")]
3218 #[serde(default)]
3219 pub startdisabled: bool,
3220 #[serde(default)]
3221 pub targetname: Option<&'a str>,
3222}
3223#[derive(Debug, Clone, Deserialize)]
3224pub struct PropDynamicOverride<'a> {
3225 #[serde(default)]
3226 pub _minlight: Option<f32>,
3227 pub angles: Angles,
3228 #[serde(default)]
3229 pub defaultanim: Option<&'a str>,
3230 #[serde(deserialize_with = "deserialize_bool")]
3231 #[serde(default)]
3232 pub disablebonefollowers: bool,
3233 #[serde(deserialize_with = "deserialize_bool")]
3234 #[serde(default)]
3235 pub disablereceiveshadows: bool,
3236 #[serde(deserialize_with = "deserialize_bool")]
3237 #[serde(default)]
3238 pub disableshadows: bool,
3239 #[serde(deserialize_with = "deserialize_bool")]
3240 #[serde(default)]
3241 pub explodedamage: bool,
3242 #[serde(deserialize_with = "deserialize_bool")]
3243 #[serde(default)]
3244 pub exploderadius: bool,
3245 #[serde(default)]
3246 pub fademaxdist: Option<u16>,
3247 pub fademindist: i32,
3248 #[serde(deserialize_with = "deserialize_bool")]
3249 pub fadescale: bool,
3250 #[serde(deserialize_with = "deserialize_bool")]
3251 #[serde(default)]
3252 pub health: bool,
3253 pub maxanimtime: f32,
3254 #[serde(deserialize_with = "deserialize_bool")]
3255 #[serde(default)]
3256 pub maxdxlevel: bool,
3257 pub minanimtime: f32,
3258 #[serde(deserialize_with = "deserialize_bool")]
3259 #[serde(default)]
3260 pub mindxlevel: bool,
3261 pub model: &'a str,
3262 #[serde(default)]
3263 pub modelscale: Option<f32>,
3264 pub origin: Vector,
3265 #[serde(default)]
3266 pub parentname: Option<&'a str>,
3267 #[serde(deserialize_with = "deserialize_bool")]
3268 #[serde(default)]
3269 pub performancemode: bool,
3270 #[serde(deserialize_with = "deserialize_bool")]
3271 #[serde(default)]
3272 pub pressuredelay: bool,
3273 #[serde(deserialize_with = "deserialize_bool")]
3274 #[serde(default)]
3275 pub randomanimation: bool,
3276 #[serde(default)]
3277 pub renderamt: Option<u8>,
3278 #[serde(default)]
3279 pub rendercolor: Option<Color>,
3280 #[serde(deserialize_with = "deserialize_bool")]
3281 #[serde(default)]
3282 pub renderfx: bool,
3283 #[serde(deserialize_with = "deserialize_bool")]
3284 #[serde(default)]
3285 pub rendermode: bool,
3286 #[serde(deserialize_with = "deserialize_bool")]
3287 #[serde(default)]
3288 pub setbodygroup: bool,
3289 #[serde(deserialize_with = "deserialize_bool")]
3290 #[serde(default)]
3291 pub skin: bool,
3292 pub solid: u8,
3293 #[serde(default)]
3294 pub spawnflags: Option<u32>,
3295 #[serde(deserialize_with = "deserialize_bool")]
3296 #[serde(default)]
3297 pub startdisabled: bool,
3298 #[serde(default)]
3299 pub targetname: Option<&'a str>,
3300}
3301#[derive(Debug, Clone, Deserialize)]
3302pub struct PropPhysics<'a> {
3303 #[serde(default)]
3304 pub _minlight: Option<f32>,
3305 pub angles: Angles,
3306 #[serde(default)]
3307 pub damagetoenablemotion: Option<i32>,
3308 #[serde(deserialize_with = "deserialize_bool")]
3309 #[serde(default)]
3310 pub damagetype: bool,
3311 #[serde(deserialize_with = "deserialize_bool")]
3312 #[serde(default)]
3313 pub disablereceiveshadows: bool,
3314 #[serde(deserialize_with = "deserialize_bool")]
3315 #[serde(default)]
3316 pub disableshadows: bool,
3317 #[serde(deserialize_with = "deserialize_bool")]
3318 #[serde(default)]
3319 pub explodedamage: bool,
3320 #[serde(deserialize_with = "deserialize_bool")]
3321 #[serde(default)]
3322 pub exploderadius: bool,
3323 #[serde(default)]
3324 pub fademaxdist: Option<u16>,
3325 pub fademindist: i32,
3326 #[serde(deserialize_with = "deserialize_bool")]
3327 #[serde(default)]
3328 pub fadescale: bool,
3329 #[serde(default)]
3330 pub forcetoenablemotion: Option<f32>,
3331 pub inertiascale: f32,
3332 #[serde(default)]
3333 pub massscale: Option<f32>,
3334 #[serde(deserialize_with = "deserialize_bool")]
3335 #[serde(default)]
3336 pub maxdxlevel: bool,
3337 #[serde(deserialize_with = "deserialize_bool")]
3338 #[serde(default)]
3339 pub mindxlevel: bool,
3340 #[serde(default)]
3341 pub minhealthdmg: Option<i32>,
3342 pub model: &'a str,
3343 #[serde(deserialize_with = "deserialize_bool")]
3344 #[serde(default)]
3345 pub nodamageforces: bool,
3346 pub origin: Vector,
3347 #[serde(deserialize_with = "deserialize_bool")]
3348 #[serde(default)]
3349 pub performancemode: bool,
3350 pub physdamagescale: f32,
3351 #[serde(deserialize_with = "deserialize_bool")]
3352 #[serde(default)]
3353 pub pressuredelay: bool,
3354 #[serde(default)]
3355 pub renderamt: Option<u8>,
3356 #[serde(default)]
3357 pub rendercolor: Option<Color>,
3358 #[serde(deserialize_with = "deserialize_bool")]
3359 #[serde(default)]
3360 pub renderfx: bool,
3361 #[serde(deserialize_with = "deserialize_bool")]
3362 #[serde(default)]
3363 pub rendermode: bool,
3364 #[serde(default)]
3365 pub shadowcastdist: Option<u8>,
3366 #[serde(default)]
3367 pub skin: Option<u8>,
3368 pub spawnflags: u32,
3369 #[serde(default)]
3370 pub targetname: Option<&'a str>,
3371}
3372#[derive(Debug, Clone, Deserialize)]
3373pub struct PropPhysicsMultiplayer<'a> {
3374 #[serde(default)]
3375 pub _minlight: Option<f32>,
3376 pub angles: Angles,
3377 #[serde(deserialize_with = "deserialize_bool")]
3378 #[serde(default)]
3379 pub body: bool,
3380 #[serde(default)]
3381 pub damagetoenablemotion: Option<i32>,
3382 #[serde(deserialize_with = "deserialize_bool")]
3383 #[serde(default)]
3384 pub damagetype: bool,
3385 #[serde(deserialize_with = "deserialize_bool")]
3386 #[serde(default)]
3387 pub disablereceiveshadows: bool,
3388 #[serde(deserialize_with = "deserialize_bool")]
3389 #[serde(default)]
3390 pub disableshadows: bool,
3391 #[serde(deserialize_with = "deserialize_bool")]
3392 #[serde(default)]
3393 pub explodedamage: bool,
3394 #[serde(deserialize_with = "deserialize_bool")]
3395 #[serde(default)]
3396 pub exploderadius: bool,
3397 #[serde(default)]
3398 pub fademaxdist: Option<u16>,
3399 pub fademindist: i32,
3400 #[serde(default)]
3401 pub fadescale: Option<f32>,
3402 #[serde(default)]
3403 pub forcetoenablemotion: Option<f32>,
3404 #[serde(deserialize_with = "deserialize_bool")]
3405 #[serde(default)]
3406 pub health: bool,
3407 pub inertiascale: f32,
3408 #[serde(default)]
3409 pub massscale: Option<f32>,
3410 #[serde(deserialize_with = "deserialize_bool")]
3411 #[serde(default)]
3412 pub maxdxlevel: bool,
3413 #[serde(deserialize_with = "deserialize_bool")]
3414 #[serde(default)]
3415 pub mindxlevel: bool,
3416 #[serde(default)]
3417 pub minhealthdmg: Option<u8>,
3418 pub model: &'a str,
3419 #[serde(deserialize_with = "deserialize_bool")]
3420 #[serde(default)]
3421 pub multiplayer_physics_mode: bool,
3422 #[serde(deserialize_with = "deserialize_bool")]
3423 #[serde(default)]
3424 pub nodamageforces: bool,
3425 #[serde(default)]
3426 pub onawakened: Option<&'a str>,
3427 #[serde(default)]
3428 pub onbreak: Option<&'a str>,
3429 #[serde(default)]
3430 pub onhealthchanged: Option<&'a str>,
3431 #[serde(default)]
3432 pub onmotionenabled: Option<&'a str>,
3433 pub origin: Vector,
3434 #[serde(deserialize_with = "deserialize_bool")]
3435 #[serde(default)]
3436 pub performancemode: bool,
3437 pub physdamagescale: f32,
3438 #[serde(default)]
3439 pub physicsmode: Option<i32>,
3440 #[serde(deserialize_with = "deserialize_bool")]
3441 #[serde(default)]
3442 pub pressuredelay: bool,
3443 #[serde(default)]
3444 pub renderamt: Option<u8>,
3445 #[serde(default)]
3446 pub rendercolor: Option<Color>,
3447 #[serde(deserialize_with = "deserialize_bool")]
3448 #[serde(default)]
3449 pub renderfx: bool,
3450 #[serde(deserialize_with = "deserialize_bool")]
3451 #[serde(default)]
3452 pub rendermode: bool,
3453 #[serde(deserialize_with = "deserialize_bool")]
3454 #[serde(default)]
3455 pub shadowcastdist: bool,
3456 #[serde(default)]
3457 pub skin: Option<u8>,
3458 #[serde(default)]
3459 pub solid: Option<u8>,
3460 pub spawnflags: u32,
3461 #[serde(default)]
3462 pub targetname: Option<&'a str>,
3463}
3464#[derive(Debug, Clone, Deserialize)]
3465pub struct PropPhysicsOverride<'a> {
3466 #[serde(default)]
3467 pub _minlight: Option<f32>,
3468 pub angles: Angles,
3469 #[serde(deserialize_with = "deserialize_bool")]
3470 #[serde(default)]
3471 pub body: bool,
3472 pub damagetoenablemotion: i32,
3473 #[serde(deserialize_with = "deserialize_bool")]
3474 pub damagetype: bool,
3475 #[serde(deserialize_with = "deserialize_bool")]
3476 #[serde(default)]
3477 pub disablereceiveshadows: bool,
3478 #[serde(deserialize_with = "deserialize_bool")]
3479 pub disableshadows: bool,
3480 #[serde(deserialize_with = "deserialize_bool")]
3481 pub explodedamage: bool,
3482 #[serde(deserialize_with = "deserialize_bool")]
3483 pub exploderadius: bool,
3484 #[serde(default)]
3485 pub fademaxdist: Option<u16>,
3486 pub fademindist: i32,
3487 #[serde(deserialize_with = "deserialize_bool")]
3488 pub fadescale: bool,
3489 pub forcetoenablemotion: f32,
3490 #[serde(deserialize_with = "deserialize_bool")]
3491 pub health: bool,
3492 pub inertiascale: f32,
3493 pub massscale: f32,
3494 #[serde(deserialize_with = "deserialize_bool")]
3495 #[serde(default)]
3496 pub maxdxlevel: bool,
3497 #[serde(deserialize_with = "deserialize_bool")]
3498 #[serde(default)]
3499 pub mindxlevel: bool,
3500 pub minhealthdmg: i32,
3501 pub model: &'a str,
3502 #[serde(default)]
3503 pub modelscale: Option<f32>,
3504 #[serde(deserialize_with = "deserialize_bool")]
3505 pub nodamageforces: bool,
3506 pub origin: Vector,
3507 #[serde(default)]
3508 pub parentname: Option<&'a str>,
3509 #[serde(deserialize_with = "deserialize_bool")]
3510 pub performancemode: bool,
3511 pub physdamagescale: f32,
3512 #[serde(deserialize_with = "deserialize_bool")]
3513 pub pressuredelay: bool,
3514 #[serde(default)]
3515 pub renderamt: Option<u8>,
3516 #[serde(default)]
3517 pub rendercolor: Option<Color>,
3518 #[serde(deserialize_with = "deserialize_bool")]
3519 #[serde(default)]
3520 pub renderfx: bool,
3521 #[serde(deserialize_with = "deserialize_bool")]
3522 #[serde(default)]
3523 pub rendermode: bool,
3524 #[serde(deserialize_with = "deserialize_bool")]
3525 pub shadowcastdist: bool,
3526 #[serde(deserialize_with = "deserialize_bool")]
3527 #[serde(default)]
3528 pub skin: bool,
3529 pub spawnflags: u32,
3530 #[serde(default)]
3531 pub targetname: Option<&'a str>,
3532}
3533#[derive(Debug, Clone, Deserialize)]
3534pub struct PropRagdoll<'a> {
3535 #[serde(default)]
3536 pub _minlight: Option<f32>,
3537 pub angles: Angles,
3538 #[serde(deserialize_with = "deserialize_bool")]
3539 #[serde(default)]
3540 pub disableshadows: bool,
3541 #[serde(default)]
3542 pub fademaxdist: Option<f32>,
3543 #[serde(default)]
3544 pub fademindist: Option<f32>,
3545 #[serde(default)]
3546 pub fadescale: Option<f32>,
3547 #[serde(deserialize_with = "deserialize_bool")]
3548 #[serde(default)]
3549 pub maxdxlevel: bool,
3550 #[serde(deserialize_with = "deserialize_bool")]
3551 #[serde(default)]
3552 pub mindxlevel: bool,
3553 pub model: &'a str,
3554 #[serde(default)]
3555 pub modelscale: Option<f32>,
3556 pub origin: Vector,
3557 #[serde(deserialize_with = "deserialize_bool")]
3558 #[serde(default)]
3559 pub renderamt: bool,
3560 #[serde(default)]
3561 pub rendercolor: Option<Color>,
3562 #[serde(default)]
3563 pub sequence: Option<i32>,
3564 #[serde(deserialize_with = "deserialize_bool")]
3565 #[serde(default)]
3566 pub skin: bool,
3567 #[serde(default)]
3568 pub solid: Option<u8>,
3569 pub spawnflags: u32,
3570 #[serde(deserialize_with = "deserialize_bool")]
3571 #[serde(default)]
3572 pub startdisabled: bool,
3573 #[serde(default)]
3574 pub targetname: Option<&'a str>,
3575}
3576#[derive(Debug, Clone, Deserialize)]
3577pub struct ShadowControl {
3578 pub angles: Angles,
3579 pub color: Color,
3580 #[serde(deserialize_with = "deserialize_bool")]
3581 #[serde(default)]
3582 pub disableallshadows: bool,
3583 pub distance: f32,
3584 pub origin: Vector,
3585}
3586#[derive(Debug, Clone, Deserialize)]
3587pub struct SkyCamera {
3588 pub angles: Angles,
3589 #[serde(deserialize_with = "deserialize_bool")]
3590 #[serde(default)]
3591 pub fogblend: bool,
3592 pub fogcolor: Color,
3593 pub fogcolor2: Color,
3594 pub fogdir: Vector,
3595 #[serde(deserialize_with = "deserialize_bool")]
3596 #[serde(default)]
3597 pub fogenable: bool,
3598 pub fogend: f32,
3599 #[serde(default)]
3600 pub fogmaxdensity: Option<f32>,
3601 pub fogstart: f32,
3602 pub origin: Vector,
3603 pub scale: i32,
3604 #[serde(deserialize_with = "deserialize_bool")]
3605 #[serde(default)]
3606 pub use_angles: bool,
3607}
3608#[derive(Debug, Clone, Deserialize)]
3609pub struct TriggerGravity<'a> {
3610 pub gravity: f32,
3611 pub model: &'a str,
3612 #[serde(default)]
3613 pub onstarttouch: Option<&'a str>,
3614 pub origin: Vector,
3615 pub spawnflags: u32,
3616 #[serde(deserialize_with = "deserialize_bool")]
3617 pub startdisabled: bool,
3618}
3619#[derive(Debug, Clone, Deserialize)]
3620pub struct TriggerHurt<'a> {
3621 #[serde(default)]
3622 pub angles: Option<Angles>,
3623 pub damage: f32,
3624 pub damagecap: f32,
3625 pub damagemodel: i32,
3626 pub damagetype: i32,
3627 pub model: &'a str,
3628 #[serde(deserialize_with = "deserialize_bool")]
3629 #[serde(default)]
3630 pub nodmgforce: bool,
3631 #[serde(default)]
3632 pub onhurtplayer: Option<&'a str>,
3633 #[serde(default)]
3634 pub onstarttouch: Option<&'a str>,
3635 pub origin: Vector,
3636 #[serde(default)]
3637 pub parentname: Option<&'a str>,
3638 pub spawnflags: u32,
3639 #[serde(deserialize_with = "deserialize_bool")]
3640 pub startdisabled: bool,
3641 #[serde(default)]
3642 pub targetname: Option<&'a str>,
3643}
3644#[derive(Debug, Clone, Deserialize)]
3645pub struct TriggerLook<'a> {
3646 pub fieldofview: f32,
3647 pub looktime: u8,
3648 pub model: &'a str,
3649 pub ontrigger: &'a str,
3650 pub origin: Vector,
3651 pub spawnflags: u32,
3652 #[serde(deserialize_with = "deserialize_bool")]
3653 pub startdisabled: bool,
3654 pub target: &'a str,
3655 pub timeout: f32,
3656}
3657#[derive(Debug, Clone, Deserialize)]
3658pub struct TriggerMultiple<'a> {
3659 #[serde(default)]
3660 pub angles: Option<Angles>,
3661 #[serde(default)]
3662 pub filtername: Option<&'a str>,
3663 #[serde(default)]
3664 pub model: Option<&'a str>,
3665 #[serde(default)]
3666 pub onendtouch: Option<&'a str>,
3667 #[serde(default)]
3668 pub onendtouchall: Option<&'a str>,
3669 #[serde(default)]
3670 pub onstarttouch: Option<&'a str>,
3671 #[serde(default)]
3672 pub onstarttouchall: Option<&'a str>,
3673 pub ontrigger: &'a str,
3674 pub origin: Vector,
3675 #[serde(default)]
3676 pub parentname: Option<&'a str>,
3677 pub spawnflags: u32,
3678 #[serde(default)]
3679 pub speed: Option<u16>,
3680 #[serde(deserialize_with = "deserialize_bool")]
3681 #[serde(default)]
3682 pub startdisabled: bool,
3683 #[serde(default)]
3684 pub target: Option<&'a str>,
3685 #[serde(default)]
3686 pub targetname: Option<&'a str>,
3687 pub wait: f32,
3688}
3689#[derive(Debug, Clone, Deserialize)]
3690pub struct TriggerOnce<'a> {
3691 #[serde(default)]
3692 pub angles: Option<Angles>,
3693 pub model: &'a str,
3694 #[serde(default)]
3695 pub onstarttouch: Option<&'a str>,
3696 pub ontrigger: &'a str,
3697 pub origin: Vector,
3698 pub spawnflags: u32,
3699 #[serde(deserialize_with = "deserialize_bool")]
3700 pub startdisabled: bool,
3701 #[serde(default)]
3702 pub targetname: Option<&'a str>,
3703 #[serde(default)]
3704 pub wait: Option<i32>,
3705}
3706#[derive(Debug, Clone, Deserialize)]
3707pub struct TriggerProximity<'a> {
3708 pub model: &'a str,
3709 pub onstarttouch: &'a str,
3710 pub origin: Vector,
3711 pub radius: f32,
3712 pub spawnflags: u32,
3713 #[serde(deserialize_with = "deserialize_bool")]
3714 pub startdisabled: bool,
3715}
3716#[derive(Debug, Clone, Deserialize)]
3717pub struct TriggerPush<'a> {
3718 #[serde(default)]
3719 pub alternateticksfix: Option<f32>,
3720 #[serde(default)]
3721 pub angles: Option<Angles>,
3722 #[serde(default)]
3723 pub filtername: Option<&'a str>,
3724 pub model: &'a str,
3725 #[serde(default)]
3726 pub onendtouch: Option<&'a str>,
3727 #[serde(default)]
3728 pub onstarttouch: Option<&'a str>,
3729 pub origin: Vector,
3730 #[serde(default)]
3731 pub parentname: Option<&'a str>,
3732 pub pushdir: Vector,
3733 pub spawnflags: u32,
3734 pub speed: f32,
3735 #[serde(deserialize_with = "deserialize_bool")]
3736 pub startdisabled: bool,
3737 #[serde(default)]
3738 pub targetname: Option<&'a str>,
3739}
3740#[derive(Debug, Clone, Deserialize)]
3741pub struct TriggerSoundscape<'a> {
3742 #[serde(default)]
3743 pub angles: Option<Angles>,
3744 pub model: &'a str,
3745 #[serde(default)]
3746 pub onstarttouch: Option<&'a str>,
3747 pub origin: Vector,
3748 pub soundscape: &'a str,
3749 pub spawnflags: u32,
3750 #[serde(deserialize_with = "deserialize_bool")]
3751 pub startdisabled: bool,
3752 #[serde(default)]
3753 pub targetname: Option<&'a str>,
3754}
3755#[derive(Debug, Clone, Deserialize)]
3756pub struct TriggerTeleport<'a> {
3757 #[serde(default)]
3758 pub angles: Option<Angles>,
3759 #[serde(default)]
3760 pub filtername: Option<&'a str>,
3761 #[serde(default)]
3762 pub model: Option<&'a str>,
3763 #[serde(default)]
3764 pub onendtouch: Option<&'a str>,
3765 #[serde(default)]
3766 pub onstarttouch: Option<&'a str>,
3767 #[serde(default)]
3768 pub ontrigger: Option<&'a str>,
3769 pub origin: Vector,
3770 #[serde(default)]
3771 pub parentname: Option<&'a str>,
3772 pub spawnflags: u32,
3773 #[serde(default)]
3774 pub speed: Option<u16>,
3775 #[serde(deserialize_with = "deserialize_bool")]
3776 pub startdisabled: bool,
3777 #[serde(default)]
3778 pub target: Option<&'a str>,
3779 #[serde(default)]
3780 pub targetname: Option<&'a str>,
3781}
3782#[derive(Debug, Clone, Deserialize)]
3783pub struct TriggerVphysicsMotion<'a> {
3784 pub model: &'a str,
3785 pub origin: Vector,
3786 pub particletrailendsize: u8,
3787 pub particletraillifetime: u8,
3788 pub particletrailmaterial: &'a str,
3789 pub particletrailstartsize: u8,
3790 #[serde(deserialize_with = "deserialize_bool")]
3791 pub setadditionalairdensity: bool,
3792 pub setangvelocitylimit: f32,
3793 pub setangvelocityscale: f32,
3794 pub setgravityscale: f32,
3795 pub setlinearforce: f32,
3796 pub setlinearforceangles: Angles,
3797 pub setvelocitylimit: f32,
3798 pub setvelocitylimitdelta: f32,
3799 pub setvelocityscale: f32,
3800 pub spawnflags: u32,
3801 #[serde(deserialize_with = "deserialize_bool")]
3802 pub startdisabled: bool,
3803}
3804#[derive(Debug, Clone, Deserialize)]
3805pub struct TriggerWind<'a> {
3806 pub angles: Angles,
3807 pub directionnoise: u8,
3808 #[serde(deserialize_with = "deserialize_bool")]
3809 pub holdnoise: bool,
3810 #[serde(deserialize_with = "deserialize_bool")]
3811 pub holdtime: bool,
3812 pub model: &'a str,
3813 pub origin: Vector,
3814 pub spawnflags: u32,
3815 pub speed: u16,
3816 pub speednoise: u8,
3817 #[serde(deserialize_with = "deserialize_bool")]
3818 pub startdisabled: bool,
3819}
3820#[derive(Debug, Clone, Deserialize)]
3821pub struct WaterLodControl<'a> {
3822 pub cheapwaterenddistance: f32,
3823 pub cheapwaterstartdistance: f32,
3824 #[serde(default)]
3825 pub origin: Option<Vector>,
3826 #[serde(default)]
3827 pub targetname: Option<&'a str>,
3828}
3829#[derive(Debug, Clone, Deserialize)]
3830pub struct WeaponAk47<'a> {
3831 #[serde(default)]
3832 pub _minlight: Option<f32>,
3833 #[serde(default)]
3834 pub ammo: Option<u16>,
3835 pub angles: Angles,
3836 #[serde(default)]
3837 pub onplayerpickup: Option<&'a str>,
3838 pub origin: Vector,
3839 #[serde(default)]
3840 pub renderamt: Option<u8>,
3841 #[serde(default)]
3842 pub rendercolor: Option<Color>,
3843 #[serde(default)]
3844 pub spawnflags: Option<u32>,
3845 #[serde(default)]
3846 pub targetname: Option<&'a str>,
3847}
3848#[derive(Debug, Clone, Deserialize)]
3849pub struct WeaponAwp<'a> {
3850 #[serde(default)]
3851 pub _minlight: Option<f32>,
3852 #[serde(default)]
3853 pub ammo: Option<u16>,
3854 pub angles: Angles,
3855 #[serde(default)]
3856 pub fademaxdist: Option<f32>,
3857 #[serde(default)]
3858 pub fademindist: Option<f32>,
3859 #[serde(default)]
3860 pub fadescale: Option<f32>,
3861 pub origin: Vector,
3862 #[serde(default)]
3863 pub renderamt: Option<u8>,
3864 #[serde(default)]
3865 pub rendercolor: Option<Color>,
3866 #[serde(default)]
3867 pub spawnflags: Option<u32>,
3868 #[serde(default)]
3869 pub targetname: Option<&'a str>,
3870}
3871#[derive(Debug, Clone, Deserialize)]
3872pub struct WeaponDeagle<'a> {
3873 #[serde(default)]
3874 pub _minlight: Option<f32>,
3875 #[serde(default)]
3876 pub ammo: Option<u16>,
3877 pub angles: Angles,
3878 pub origin: Vector,
3879 #[serde(default)]
3880 pub renderamt: Option<u8>,
3881 #[serde(default)]
3882 pub rendercolor: Option<Color>,
3883 #[serde(default)]
3884 pub spawnflags: Option<u32>,
3885 #[serde(default)]
3886 pub targetname: Option<&'a str>,
3887}
3888#[derive(Debug, Clone, Deserialize)]
3889pub struct WeaponElite<'a> {
3890 pub ammo: u16,
3891 pub angles: Angles,
3892 #[serde(default)]
3893 pub fademaxdist: Option<f32>,
3894 #[serde(default)]
3895 pub fademindist: Option<f32>,
3896 #[serde(default)]
3897 pub fadescale: Option<f32>,
3898 pub origin: Vector,
3899 #[serde(default)]
3900 pub renderamt: Option<u8>,
3901 #[serde(default)]
3902 pub rendercolor: Option<Color>,
3903 #[serde(default)]
3904 pub spawnflags: Option<u32>,
3905 #[serde(default)]
3906 pub targetname: Option<&'a str>,
3907}
3908#[derive(Debug, Clone, Deserialize)]
3909pub struct WeaponFamas {
3910 pub ammo: u16,
3911 pub angles: Angles,
3912 pub fademaxdist: f32,
3913 pub fademindist: f32,
3914 pub fadescale: f32,
3915 #[serde(deserialize_with = "deserialize_bool")]
3916 pub maxdxlevel: bool,
3917 #[serde(deserialize_with = "deserialize_bool")]
3918 pub mindxlevel: bool,
3919 #[serde(deserialize_with = "deserialize_bool")]
3920 pub nodamageforces: bool,
3921 pub origin: Vector,
3922 pub renderamt: u8,
3923 pub rendercolor: Color,
3924 #[serde(deserialize_with = "deserialize_bool")]
3925 pub renderfx: bool,
3926 #[serde(deserialize_with = "deserialize_bool")]
3927 pub rendermode: bool,
3928 #[serde(deserialize_with = "deserialize_bool")]
3929 pub shadowcastdist: bool,
3930 pub spawnflags: u32,
3931}
3932#[derive(Debug, Clone, Deserialize)]
3933pub struct WeaponFiveseven<'a> {
3934 pub ammo: u16,
3935 pub angles: Angles,
3936 pub origin: Vector,
3937 pub spawnflags: u32,
3938 pub targetname: &'a str,
3939}
3940#[derive(Debug, Clone, Deserialize)]
3941pub struct WeaponFlashbang<'a> {
3942 pub angles: Angles,
3943 #[serde(default)]
3944 pub fademaxdist: Option<f32>,
3945 #[serde(default)]
3946 pub fademindist: Option<f32>,
3947 #[serde(default)]
3948 pub fadescale: Option<f32>,
3949 pub origin: Vector,
3950 #[serde(default)]
3951 pub renderamt: Option<u8>,
3952 #[serde(default)]
3953 pub rendercolor: Option<Color>,
3954 #[serde(default)]
3955 pub spawnflags: Option<u32>,
3956 pub targetname: &'a str,
3957}
3958#[derive(Debug, Clone, Deserialize)]
3959pub struct WeaponG3sg1 {
3960 pub ammo: u16,
3961 pub angles: Angles,
3962 pub fademaxdist: f32,
3963 pub fademindist: f32,
3964 pub fadescale: f32,
3965 #[serde(deserialize_with = "deserialize_bool")]
3966 pub maxdxlevel: bool,
3967 #[serde(deserialize_with = "deserialize_bool")]
3968 pub mindxlevel: bool,
3969 #[serde(deserialize_with = "deserialize_bool")]
3970 pub nodamageforces: bool,
3971 pub origin: Vector,
3972 pub renderamt: u8,
3973 pub rendercolor: Color,
3974 #[serde(deserialize_with = "deserialize_bool")]
3975 pub renderfx: bool,
3976 #[serde(deserialize_with = "deserialize_bool")]
3977 pub rendermode: bool,
3978 #[serde(deserialize_with = "deserialize_bool")]
3979 pub shadowcastdist: bool,
3980 pub spawnflags: u32,
3981}
3982#[derive(Debug, Clone, Deserialize)]
3983pub struct WeaponGlock<'a> {
3984 #[serde(default)]
3985 pub _minlight: Option<f32>,
3986 pub ammo: u16,
3987 pub angles: Angles,
3988 pub origin: Vector,
3989 #[serde(default)]
3990 pub renderamt: Option<u8>,
3991 #[serde(default)]
3992 pub rendercolor: Option<Color>,
3993 pub spawnflags: u32,
3994 pub targetname: &'a str,
3995}
3996#[derive(Debug, Clone, Deserialize)]
3997pub struct WeaponHegrenade<'a> {
3998 #[serde(default)]
3999 pub _minlight: Option<f32>,
4000 pub angles: Angles,
4001 #[serde(deserialize_with = "deserialize_bool")]
4002 #[serde(default)]
4003 pub disablereceiveshadows: bool,
4004 #[serde(deserialize_with = "deserialize_bool")]
4005 #[serde(default)]
4006 pub disableshadows: bool,
4007 #[serde(default)]
4008 pub fademaxdist: Option<f32>,
4009 #[serde(default)]
4010 pub fademindist: Option<f32>,
4011 #[serde(default)]
4012 pub fadescale: Option<f32>,
4013 #[serde(deserialize_with = "deserialize_bool")]
4014 #[serde(default)]
4015 pub maxdxlevel: bool,
4016 #[serde(deserialize_with = "deserialize_bool")]
4017 #[serde(default)]
4018 pub mindxlevel: bool,
4019 #[serde(deserialize_with = "deserialize_bool")]
4020 #[serde(default)]
4021 pub nodamageforces: bool,
4022 pub origin: Vector,
4023 #[serde(default)]
4024 pub renderamt: Option<u8>,
4025 #[serde(default)]
4026 pub rendercolor: Option<Color>,
4027 #[serde(deserialize_with = "deserialize_bool")]
4028 #[serde(default)]
4029 pub renderfx: bool,
4030 #[serde(deserialize_with = "deserialize_bool")]
4031 #[serde(default)]
4032 pub rendermode: bool,
4033 #[serde(deserialize_with = "deserialize_bool")]
4034 #[serde(default)]
4035 pub shadowcastdist: bool,
4036 #[serde(default)]
4037 pub spawnflags: Option<u32>,
4038 #[serde(default)]
4039 pub targetname: Option<&'a str>,
4040}
4041#[derive(Debug, Clone, Deserialize)]
4042pub struct WeaponKnife<'a> {
4043 #[serde(default)]
4044 pub _minlight: Option<f32>,
4045 pub angles: Angles,
4046 #[serde(default)]
4047 pub onplayerpickup: Option<&'a str>,
4048 pub origin: Vector,
4049 #[serde(default)]
4050 pub renderamt: Option<u8>,
4051 #[serde(default)]
4052 pub rendercolor: Option<Color>,
4053 #[serde(default)]
4054 pub spawnflags: Option<u32>,
4055 #[serde(default)]
4056 pub targetname: Option<&'a str>,
4057}
4058#[derive(Debug, Clone, Deserialize)]
4059pub struct WeaponM249<'a> {
4060 #[serde(default)]
4061 pub _minlight: Option<f32>,
4062 #[serde(default)]
4063 pub ammo: Option<u16>,
4064 pub angles: Angles,
4065 #[serde(default)]
4066 pub fademaxdist: Option<f32>,
4067 #[serde(default)]
4068 pub fademindist: Option<f32>,
4069 #[serde(default)]
4070 pub fadescale: Option<f32>,
4071 pub origin: Vector,
4072 #[serde(default)]
4073 pub renderamt: Option<u8>,
4074 #[serde(default)]
4075 pub rendercolor: Option<Color>,
4076 #[serde(default)]
4077 pub spawnflags: Option<u32>,
4078 #[serde(default)]
4079 pub targetname: Option<&'a str>,
4080}
4081#[derive(Debug, Clone, Deserialize)]
4082pub struct WeaponM3<'a> {
4083 #[serde(default)]
4084 pub _minlight: Option<f32>,
4085 #[serde(default)]
4086 pub ammo: Option<u16>,
4087 pub angles: Angles,
4088 pub origin: Vector,
4089 #[serde(default)]
4090 pub renderamt: Option<u8>,
4091 #[serde(default)]
4092 pub rendercolor: Option<Color>,
4093 #[serde(default)]
4094 pub spawnflags: Option<u32>,
4095 pub targetname: &'a str,
4096}
4097#[derive(Debug, Clone, Deserialize)]
4098pub struct WeaponM4a1<'a> {
4099 #[serde(default)]
4100 pub ammo: Option<u16>,
4101 pub angles: Angles,
4102 #[serde(default)]
4103 pub fademaxdist: Option<f32>,
4104 #[serde(default)]
4105 pub fademindist: Option<f32>,
4106 #[serde(default)]
4107 pub fadescale: Option<f32>,
4108 #[serde(deserialize_with = "deserialize_bool")]
4109 #[serde(default)]
4110 pub maxdxlevel: bool,
4111 #[serde(deserialize_with = "deserialize_bool")]
4112 #[serde(default)]
4113 pub mindxlevel: bool,
4114 #[serde(deserialize_with = "deserialize_bool")]
4115 #[serde(default)]
4116 pub nodamageforces: bool,
4117 pub origin: Vector,
4118 #[serde(default)]
4119 pub renderamt: Option<u8>,
4120 #[serde(default)]
4121 pub rendercolor: Option<Color>,
4122 #[serde(deserialize_with = "deserialize_bool")]
4123 #[serde(default)]
4124 pub renderfx: bool,
4125 #[serde(deserialize_with = "deserialize_bool")]
4126 #[serde(default)]
4127 pub rendermode: bool,
4128 #[serde(deserialize_with = "deserialize_bool")]
4129 #[serde(default)]
4130 pub shadowcastdist: bool,
4131 #[serde(default)]
4132 pub spawnflags: Option<u32>,
4133 #[serde(default)]
4134 pub targetname: Option<&'a str>,
4135}
4136#[derive(Debug, Clone, Deserialize)]
4137pub struct WeaponMac10 {
4138 pub ammo: u16,
4139 pub angles: Angles,
4140 pub fademaxdist: f32,
4141 pub fademindist: f32,
4142 pub fadescale: f32,
4143 #[serde(deserialize_with = "deserialize_bool")]
4144 pub maxdxlevel: bool,
4145 #[serde(deserialize_with = "deserialize_bool")]
4146 pub mindxlevel: bool,
4147 #[serde(deserialize_with = "deserialize_bool")]
4148 pub nodamageforces: bool,
4149 pub origin: Vector,
4150 pub renderamt: u8,
4151 pub rendercolor: Color,
4152 #[serde(deserialize_with = "deserialize_bool")]
4153 pub renderfx: bool,
4154 #[serde(deserialize_with = "deserialize_bool")]
4155 pub rendermode: bool,
4156 #[serde(deserialize_with = "deserialize_bool")]
4157 pub shadowcastdist: bool,
4158 pub spawnflags: u32,
4159}
4160#[derive(Debug, Clone, Deserialize)]
4161pub struct WeaponP228<'a> {
4162 pub ammo: u16,
4163 pub angles: Angles,
4164 pub origin: Vector,
4165 pub spawnflags: u32,
4166 pub targetname: &'a str,
4167}
4168#[derive(Debug, Clone, Deserialize)]
4169pub struct WeaponP90<'a> {
4170 #[serde(default)]
4171 pub ammo: Option<u16>,
4172 pub angles: Angles,
4173 #[serde(default)]
4174 pub fademaxdist: Option<f32>,
4175 #[serde(default)]
4176 pub fademindist: Option<f32>,
4177 #[serde(default)]
4178 pub fadescale: Option<f32>,
4179 #[serde(deserialize_with = "deserialize_bool")]
4180 #[serde(default)]
4181 pub maxdxlevel: bool,
4182 #[serde(deserialize_with = "deserialize_bool")]
4183 #[serde(default)]
4184 pub mindxlevel: bool,
4185 #[serde(deserialize_with = "deserialize_bool")]
4186 #[serde(default)]
4187 pub nodamageforces: bool,
4188 pub origin: Vector,
4189 #[serde(default)]
4190 pub renderamt: Option<u8>,
4191 #[serde(default)]
4192 pub rendercolor: Option<Color>,
4193 #[serde(deserialize_with = "deserialize_bool")]
4194 #[serde(default)]
4195 pub renderfx: bool,
4196 #[serde(deserialize_with = "deserialize_bool")]
4197 #[serde(default)]
4198 pub rendermode: bool,
4199 #[serde(deserialize_with = "deserialize_bool")]
4200 #[serde(default)]
4201 pub shadowcastdist: bool,
4202 pub spawnflags: u32,
4203 #[serde(default)]
4204 pub targetname: Option<&'a str>,
4205}
4206#[derive(Debug, Clone, Deserialize)]
4207pub struct WeaponScout<'a> {
4208 #[serde(default)]
4209 pub _minlight: Option<f32>,
4210 #[serde(default)]
4211 pub ammo: Option<u16>,
4212 pub angles: Angles,
4213 #[serde(deserialize_with = "deserialize_bool")]
4214 #[serde(default)]
4215 pub disablereceiveshadows: bool,
4216 #[serde(deserialize_with = "deserialize_bool")]
4217 #[serde(default)]
4218 pub disableshadows: bool,
4219 #[serde(default)]
4220 pub fademaxdist: Option<f32>,
4221 #[serde(default)]
4222 pub fademindist: Option<f32>,
4223 #[serde(default)]
4224 pub fadescale: Option<f32>,
4225 #[serde(default)]
4226 pub onplayerpickup: Option<&'a str>,
4227 pub origin: Vector,
4228 #[serde(default)]
4229 pub renderamt: Option<u8>,
4230 #[serde(default)]
4231 pub rendercolor: Option<Color>,
4232 #[serde(default)]
4233 pub renderfx: Option<u8>,
4234 #[serde(default)]
4235 pub rendermode: Option<u8>,
4236 #[serde(default)]
4237 pub spawnflags: Option<u32>,
4238 #[serde(default)]
4239 pub targetname: Option<&'a str>,
4240}
4241#[derive(Debug, Clone, Deserialize)]
4242pub struct WeaponSg550 {
4243 pub ammo: u16,
4244 pub angles: Angles,
4245 pub fademaxdist: f32,
4246 pub fademindist: f32,
4247 pub fadescale: f32,
4248 #[serde(deserialize_with = "deserialize_bool")]
4249 pub maxdxlevel: bool,
4250 #[serde(deserialize_with = "deserialize_bool")]
4251 pub mindxlevel: bool,
4252 #[serde(deserialize_with = "deserialize_bool")]
4253 pub nodamageforces: bool,
4254 pub origin: Vector,
4255 pub renderamt: u8,
4256 pub rendercolor: Color,
4257 #[serde(deserialize_with = "deserialize_bool")]
4258 pub renderfx: bool,
4259 #[serde(deserialize_with = "deserialize_bool")]
4260 pub rendermode: bool,
4261 #[serde(deserialize_with = "deserialize_bool")]
4262 pub shadowcastdist: bool,
4263 pub spawnflags: u32,
4264}
4265#[derive(Debug, Clone, Deserialize)]
4266pub struct WeaponSmokegrenade<'a> {
4267 pub angles: Angles,
4268 pub origin: Vector,
4269 #[serde(default)]
4270 pub spawnflags: Option<u32>,
4271 pub targetname: &'a str,
4272}
4273#[derive(Debug, Clone, Deserialize)]
4274pub struct WeaponTmp {
4275 pub ammo: u16,
4276 pub angles: Angles,
4277 pub fademaxdist: f32,
4278 pub fademindist: f32,
4279 pub fadescale: f32,
4280 #[serde(deserialize_with = "deserialize_bool")]
4281 pub maxdxlevel: bool,
4282 #[serde(deserialize_with = "deserialize_bool")]
4283 pub mindxlevel: bool,
4284 #[serde(deserialize_with = "deserialize_bool")]
4285 pub nodamageforces: bool,
4286 pub origin: Vector,
4287 pub renderamt: u8,
4288 pub rendercolor: Color,
4289 #[serde(deserialize_with = "deserialize_bool")]
4290 pub renderfx: bool,
4291 #[serde(deserialize_with = "deserialize_bool")]
4292 pub rendermode: bool,
4293 #[serde(deserialize_with = "deserialize_bool")]
4294 pub shadowcastdist: bool,
4295 pub spawnflags: u32,
4296}
4297#[derive(Debug, Clone, Deserialize)]
4298pub struct WeaponUmp45<'a> {
4299 pub ammo: u16,
4300 pub angles: Angles,
4301 #[serde(default)]
4302 pub fademaxdist: Option<f32>,
4303 #[serde(default)]
4304 pub fademindist: Option<f32>,
4305 #[serde(default)]
4306 pub fadescale: Option<f32>,
4307 #[serde(deserialize_with = "deserialize_bool")]
4308 #[serde(default)]
4309 pub maxdxlevel: bool,
4310 #[serde(deserialize_with = "deserialize_bool")]
4311 #[serde(default)]
4312 pub mindxlevel: bool,
4313 #[serde(deserialize_with = "deserialize_bool")]
4314 #[serde(default)]
4315 pub nodamageforces: bool,
4316 pub origin: Vector,
4317 #[serde(default)]
4318 pub renderamt: Option<u8>,
4319 #[serde(default)]
4320 pub rendercolor: Option<Color>,
4321 #[serde(deserialize_with = "deserialize_bool")]
4322 #[serde(default)]
4323 pub renderfx: bool,
4324 #[serde(deserialize_with = "deserialize_bool")]
4325 #[serde(default)]
4326 pub rendermode: bool,
4327 #[serde(deserialize_with = "deserialize_bool")]
4328 #[serde(default)]
4329 pub shadowcastdist: bool,
4330 pub spawnflags: u32,
4331 #[serde(default)]
4332 pub targetname: Option<&'a str>,
4333}
4334#[derive(Debug, Clone, Deserialize)]
4335pub struct WeaponUsp<'a> {
4336 #[serde(default)]
4337 pub _minlight: Option<f32>,
4338 #[serde(default)]
4339 pub ammo: Option<u16>,
4340 pub angles: Angles,
4341 #[serde(default)]
4342 pub onplayerpickup: Option<&'a str>,
4343 pub origin: Vector,
4344 #[serde(default)]
4345 pub renderamt: Option<u8>,
4346 #[serde(default)]
4347 pub rendercolor: Option<Color>,
4348 pub spawnflags: u32,
4349 pub targetname: &'a str,
4350}
4351#[derive(Debug, Clone, Deserialize)]
4352pub struct WeaponXm1014<'a> {
4353 pub ammo: u32,
4354 pub angles: Angles,
4355 #[serde(default)]
4356 pub fademaxdist: Option<f32>,
4357 #[serde(default)]
4358 pub fademindist: Option<f32>,
4359 #[serde(default)]
4360 pub fadescale: Option<f32>,
4361 #[serde(deserialize_with = "deserialize_bool")]
4362 #[serde(default)]
4363 pub maxdxlevel: bool,
4364 #[serde(deserialize_with = "deserialize_bool")]
4365 #[serde(default)]
4366 pub mindxlevel: bool,
4367 #[serde(deserialize_with = "deserialize_bool")]
4368 #[serde(default)]
4369 pub nodamageforces: bool,
4370 pub origin: Vector,
4371 #[serde(default)]
4372 pub renderamt: Option<u8>,
4373 #[serde(default)]
4374 pub rendercolor: Option<Color>,
4375 #[serde(deserialize_with = "deserialize_bool")]
4376 #[serde(default)]
4377 pub renderfx: bool,
4378 #[serde(deserialize_with = "deserialize_bool")]
4379 #[serde(default)]
4380 pub rendermode: bool,
4381 #[serde(deserialize_with = "deserialize_bool")]
4382 #[serde(default)]
4383 pub shadowcastdist: bool,
4384 pub spawnflags: u32,
4385 #[serde(default)]
4386 pub targetname: Option<&'a str>,
4387}
4388#[derive(Debug, Clone, Deserialize)]
4389pub struct Worldspawn<'a> {
4390 #[serde(default)]
4391 pub _minlight: Option<f32>,
4392 #[serde(default)]
4393 pub chaptertitle: Option<&'a str>,
4394 #[serde(deserialize_with = "deserialize_bool")]
4395 #[serde(default)]
4396 pub coldworld: bool,
4397 #[serde(default)]
4398 pub comment: Option<&'a str>,
4399 #[serde(default)]
4400 pub csg_options: Option<&'a str>,
4401 #[serde(deserialize_with = "deserialize_bool")]
4402 #[serde(default)]
4403 pub defaultteam: bool,
4404 #[serde(default)]
4405 pub detailmaterial: Option<&'a str>,
4406 #[serde(default)]
4407 pub detailvbsp: Option<&'a str>,
4408 #[serde(default)]
4409 pub fogcolor: Option<Color>,
4410 #[serde(default)]
4411 pub fogcolor2: Option<Color>,
4412 #[serde(default)]
4413 pub fogdir: Option<Angles>,
4414 #[serde(deserialize_with = "deserialize_bool")]
4415 #[serde(default)]
4416 pub fogenable: bool,
4417 #[serde(default)]
4418 pub fogend: Option<f32>,
4419 #[serde(default)]
4420 pub fogstart: Option<u16>,
4421 #[serde(deserialize_with = "deserialize_bool")]
4422 #[serde(default)]
4423 pub gametitle: bool,
4424 #[serde(default)]
4425 pub light: Option<u8>,
4426 #[serde(default)]
4427 pub mapversion: Option<u16>,
4428 #[serde(default)]
4429 pub maxoccludeearea: Option<f32>,
4430 pub maxpropscreenwidth: f32,
4431 #[serde(default)]
4432 pub maxrange: Option<u16>,
4433 #[serde(default)]
4434 pub message: Option<&'a str>,
4435 #[serde(default)]
4436 pub minoccluderarea: Option<f32>,
4437 #[serde(default)]
4438 pub minpropscreenwidth: Option<f32>,
4439 #[serde(deserialize_with = "deserialize_bool")]
4440 #[serde(default)]
4441 pub newunit: bool,
4442 #[serde(deserialize_with = "deserialize_bool")]
4443 #[serde(default)]
4444 pub no_decomp: bool,
4445 pub skyname: &'a str,
4446 #[serde(deserialize_with = "deserialize_bool")]
4447 #[serde(default)]
4448 pub sounds: bool,
4449 #[serde(default)]
4450 pub spawnflags: Option<u32>,
4451 #[serde(deserialize_with = "deserialize_bool")]
4452 #[serde(default)]
4453 pub startdark: bool,
4454 #[serde(default)]
4455 pub waveheight: Option<f32>,
4456 pub world_maxs: Vector,
4457 pub world_mins: Vector,
4458 #[serde(deserialize_with = "deserialize_bool")]
4459 #[serde(default)]
4460 pub worldtype: bool,
4461}