first stage

lib/bsp_loader/src/bsp.rs

@@ -1,4 +1,5 @@
 use std::borrow::Cow;
+use std::collections::HashMap;
 
 use vbsp_entities_css::Entity;
 
@@ -6,7 +7,7 @@ use strafesnet_common::{map,model,integer,gameplay_attributes as attr};
 use strafesnet_deferred_loader::deferred_loader::{MeshDeferredLoader,RenderConfigDeferredLoader};
 use strafesnet_deferred_loader::mesh::Meshes;
 use strafesnet_deferred_loader::texture::{RenderConfigs,Texture};
-use strafesnet_common::gameplay_modes::{NormalizedMode,NormalizedModes,Mode,Stage};
+use strafesnet_common::gameplay_modes::{self as modes,NormalizedMode,NormalizedModes,Mode,Stage};
 
 use crate::valve_transform;
 
@@ -35,6 +36,12 @@ fn ingest_vertex(
 	})
 }
 
+#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
+enum AddBrush{
+	Available(model::ModelId),
+	Deferred(model::ModelId),
+}
+
 fn add_brush<'a>(
 	mesh_deferred_loader:&mut MeshDeferredLoader<&'a str>,
 	world_models:&mut Vec<model::Model>,
@@ -43,7 +50,7 @@ fn add_brush<'a>(
 	origin:vbsp::Vector,
 	rendercolor:vbsp::Color,
 	attributes:attr::CollisionAttributesId,
-){
+)->Option<AddBrush>{
 	let transform=integer::Planar64Affine3::from_translation(
 		valve_transform(origin.into())
 	);
@@ -58,20 +65,24 @@ fn add_brush<'a>(
 		("*",id_str)=>match id_str.parse(){
 			Ok(mesh_id)=>{
 				let mesh=model::MeshId::new(mesh_id);
+				let model_id=model::ModelId::new(world_models.len() as u32);
 				world_models.push(
 					model::Model{mesh,attributes,transform,color}
 				);
+				Some(AddBrush::Available(model_id))
 			},
 			Err(e)=>{
 				println!("Brush model int parse error: {e} model={model}");
-				return;
+				None
 			},
 		},
 		_=>{
 			let mesh=mesh_deferred_loader.acquire_mesh_id(model);
+			let model_id=model::ModelId::new(prop_models.len() as u32);
 			prop_models.push(
 				model::Model{mesh,attributes,transform,color}
 			);
+			Some(AddBrush::Deferred(model_id))
 		}
 	}
 }
@@ -80,7 +91,7 @@ pub fn convert<'a>(
 	bsp:&'a crate::Bsp,
 	render_config_deferred_loader:&mut RenderConfigDeferredLoader<Cow<'a,str>>,
 	mesh_deferred_loader:&mut MeshDeferredLoader<&'a str>,
-)->PartialMap1{
+)->PartialMap1<'a>{
 	let bsp=bsp.as_ref();
 	//figure out real attributes later
 	let unique_attributes=vec![
@@ -151,7 +162,7 @@ pub fn convert<'a>(
 
 		let color=mb.acquire_color_id(glam::Vec4::ONE);
 		let mut graphics_groups=Vec::new();
-		let mut render_id_to_graphics_group_id=std::collections::HashMap::new();
+		let mut render_id_to_graphics_group_id=HashMap::new();
 		let polygon_groups=world_model.faces().enumerate().map(|(polygon_group_id,face)|{
 			let polygon_group_id=model::PolygonGroupId::new(polygon_group_id as u32);
 			let face_texture=face.texture();
@@ -209,52 +220,221 @@ pub fn convert<'a>(
 		color:glam::Vec4::W,
 	});
 
+	// THE CUBE OF DESTINY
+	let destination_mesh_id=model::MeshId::new(world_meshes.len() as u32);
+	world_meshes.push(crate::brush::unit_cube());
+
+	let mut teleports=HashMap::new();
+	let mut teleport_destinations=HashMap::new();
+
 	const WHITE:vbsp::Color=vbsp::Color{r:255,g:255,b:255};
+	const ENTITY_ATTRIBUTE:gameplay_attributes::CollisionAttributesId=ATTRIBUTE_DECORATION;
+	const ENTITY_TRIGGER_ATTRIBUTE:gameplay_attributes::CollisionAttributesId=ATTRIBUTE_INTERSECT_DEFAULT;
 	for raw_ent in &bsp.entities{
+		macro_rules! ent_brush_default{
+			($entity:ident)=>{
+				{add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,$entity.model,$entity.origin,$entity.rendercolor,ENTITY_ATTRIBUTE);}
+			};
+		}	macro_rules! ent_brush_prop{
+			($entity:ident)=>{
+				{add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,$entity.model,$entity.origin,WHITE,ENTITY_ATTRIBUTE);}
+			};
+		}
+		macro_rules! ent_brush_trigger{
+			($entity:ident)=>{
+				{add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,$entity.model,$entity.origin,WHITE,ENTITY_TRIGGER_ATTRIBUTE);}
+			};
+		}
 		match raw_ent.parse(){
-			Ok(Entity::Cycler(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
-			Ok(Entity::EnvSprite(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
-			Ok(Entity::FuncBreakable(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
-			Ok(Entity::FuncBrush(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
-			Ok(Entity::FuncButton(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
-			Ok(Entity::FuncDoor(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
-			Ok(Entity::FuncDoorRotating(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
-			Ok(Entity::FuncIllusionary(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
-			Ok(Entity::FuncMonitor(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
-			Ok(Entity::FuncMovelinear(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
-			Ok(Entity::FuncPhysbox(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
-			Ok(Entity::FuncPhysboxMultiplayer(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
-			Ok(Entity::FuncRotButton(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
-			Ok(Entity::FuncRotating(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
-			Ok(Entity::FuncTracktrain(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
-			Ok(Entity::FuncTrain(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
-			Ok(Entity::FuncWall(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin.unwrap_or_default(),brush.rendercolor,ATTRIBUTE_DECORATION),
-			Ok(Entity::FuncWallToggle(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin.unwrap_or_default(),brush.rendercolor,ATTRIBUTE_DECORATION),
-			Ok(Entity::FuncWaterAnalog(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor.unwrap_or(WHITE),ATTRIBUTE_DECORATION),
-			Ok(Entity::PropDoorRotating(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
-			Ok(Entity::PropDynamic(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
-			Ok(Entity::PropDynamicOverride(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
-			Ok(Entity::PropPhysics(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
-			Ok(Entity::PropPhysicsMultiplayer(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
-			Ok(Entity::PropPhysicsOverride(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
-			Ok(Entity::PropRagdoll(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
-			Ok(Entity::TriggerGravity(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
-			Ok(Entity::TriggerHurt(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
-			Ok(Entity::TriggerLook(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
-			Ok(Entity::TriggerMultiple(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model.unwrap_or_default(),brush.origin,WHITE,ATTRIBUTE_DECORATION),
-			Ok(Entity::TriggerOnce(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
-			Ok(Entity::TriggerProximity(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
-			Ok(Entity::TriggerPush(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
-			Ok(Entity::TriggerSoundscape(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
-			Ok(Entity::TriggerTeleport(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model.unwrap_or_default(),brush.origin,WHITE,ATTRIBUTE_DECORATION),
-			Ok(Entity::TriggerVphysicsMotion(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
-			Ok(Entity::TriggerWind(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
-			Ok(Entity::InfoPlayerCounterterrorist(spawn))=>{
-				found_spawn=Some(valve_transform(spawn.origin.into()));
+			Ok(Entity::AmbientGeneric(_ambient_generic))=>(),
+			Ok(Entity::Cycler(brush))=>ent_brush_default!(brush),
+			Ok(Entity::EnvBeam(_env_beam))=>(),
+			Ok(Entity::EnvBubbles(_env_bubbles))=>(),
+			Ok(Entity::EnvDetailController(_env_detail_controller))=>(),
+			Ok(Entity::EnvEmbers(_env_embers))=>(),
+			Ok(Entity::EnvEntityMaker(_env_entity_maker))=>(),
+			Ok(Entity::EnvExplosion(_env_explosion))=>(),
+			Ok(Entity::EnvFade(_env_fade))=>(),
+			Ok(Entity::EnvFire(_env_fire))=>(),
+			Ok(Entity::EnvFireTrail(_env_fire_trail))=>(),
+			Ok(Entity::EnvFiresource(_env_firesource))=>(),
+			Ok(Entity::EnvFogController(_env_fog_controller))=>(),
+			Ok(Entity::EnvHudhint(_env_hudhint))=>(),
+			Ok(Entity::EnvLaser(_env_laser))=>(),
+			Ok(Entity::EnvLightglow(_env_lightglow))=>(),
+			Ok(Entity::EnvPhysexplosion(_env_physexplosion))=>(),
+			Ok(Entity::EnvProjectedtexture(_env_projectedtexture))=>(),
+			Ok(Entity::EnvScreenoverlay(_env_screenoverlay))=>(),
+			Ok(Entity::EnvShake(_env_shake))=>(),
+			Ok(Entity::EnvShooter(_env_shooter))=>(),
+			Ok(Entity::EnvSmokestack(_env_smokestack))=>(),
+			Ok(Entity::EnvSoundscape(_env_soundscape))=>(),
+			Ok(Entity::EnvSoundscapeProxy(_env_soundscape_proxy))=>(),
+			Ok(Entity::EnvSoundscapeTriggerable(_env_soundscape_triggerable))=>(),
+			Ok(Entity::EnvSpark(_env_spark))=>(),
+			Ok(Entity::EnvSprite(brush))=>ent_brush_default!(brush),
+			Ok(Entity::EnvSpritetrail(_env_spritetrail))=>(),
+			Ok(Entity::EnvSteam(_env_steam))=>(),
+			Ok(Entity::EnvSun(_env_sun))=>(),
+			Ok(Entity::EnvTonemapController(_env_tonemap_controller))=>(),
+			Ok(Entity::EnvWind(_env_wind))=>(),
+			// trigger_teleport.filtername probably has to do with one of these
+			Ok(Entity::FilterActivatorClass(_filter_activator_class))=>(),
+			Ok(Entity::FilterActivatorName(_filter_activator_name))=>(),
+			Ok(Entity::FilterDamageType(_filter_damage_type))=>(),
+			Ok(Entity::FilterMulti(_filter_multi))=>(),
+			Ok(Entity::FuncAreaportal(_func_areaportal))=>(),
+			Ok(Entity::FuncAreaportalwindow(_func_areaportalwindow))=>(),
+			Ok(Entity::FuncBombTarget(_func_bomb_target))=>(),
+			Ok(Entity::FuncBreakable(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncBreakableSurf(_func_breakable_surf))=>(),
+			Ok(Entity::FuncBrush(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncButton(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncBuyzone(_func_buyzone))=>(),
+			Ok(Entity::FuncClipVphysics(_func_clip_vphysics))=>(),
+			Ok(Entity::FuncConveyor(_func_conveyor))=>(),
+			// FuncDoor is Platform
+			Ok(Entity::FuncDoor(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncDoorRotating(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncDustcloud(_func_dustcloud))=>(),
+			Ok(Entity::FuncDustmotes(_func_dustmotes))=>(),
+			Ok(Entity::FuncFishPool(_func_fish_pool))=>(),
+			Ok(Entity::FuncFootstepControl(_func_footstep_control))=>(),
+			Ok(Entity::FuncHostageRescue(_func_hostage_rescue))=>(),
+			Ok(Entity::FuncIllusionary(brush))=>{add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION);},
+			Ok(Entity::FuncLod(_func_lod))=>(),
+			Ok(Entity::FuncMonitor(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncMovelinear(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncOccluder(_func_occluder))=>(),
+			Ok(Entity::FuncPhysbox(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncPhysboxMultiplayer(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncPrecipitation(_func_precipitation))=>(),
+			Ok(Entity::FuncRotButton(brush))=>ent_brush_prop!(brush),
+			Ok(Entity::FuncRotating(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncSmokevolume(_func_smokevolume))=>(),
+			Ok(Entity::FuncTracktrain(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncTrain(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncWall(brush))=>{add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin.unwrap_or_default(),brush.rendercolor,ENTITY_ATTRIBUTE);},
+			Ok(Entity::FuncWallToggle(brush))=>{add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin.unwrap_or_default(),brush.rendercolor,ENTITY_ATTRIBUTE);},
+			Ok(Entity::FuncWaterAnalog(brush))=>{add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor.unwrap_or(WHITE),ENTITY_ATTRIBUTE);},
+			Ok(Entity::GamePlayerEquip(_game_player_equip))=>(),
+			Ok(Entity::GameText(_game_text))=>(),
+			Ok(Entity::GameUi(_game_ui))=>(),
+			Ok(Entity::GameWeaponManager(_game_weapon_manager))=>(),
+			Ok(Entity::HostageEntity(_hostage_entity))=>(),
+			Ok(Entity::InfoCameraLink(_info_camera_link))=>(),
+			Ok(Entity::InfoLadder(_info_ladder))=>(),
+			Ok(Entity::InfoLightingRelative(_info_lighting_relative))=>(),
+			Ok(Entity::InfoMapParameters(_info_map_parameters))=>(),
+			Ok(Entity::InfoNode(_info_node))=>(),
+			Ok(Entity::InfoNodeHint(_info_node_hint))=>(),
+			Ok(Entity::InfoParticleSystem(_info_particle_system))=>(),
+			Ok(Entity::InfoPlayerCounterterrorist(spawn))=>found_spawn=Some(spawn.origin),
+			Ok(Entity::InfoPlayerLogo(_info_player_logo))=>(),
+			Ok(Entity::InfoPlayerStart(_info_player_start))=>(),
+			Ok(Entity::InfoPlayerTerrorist(spawn))=>found_spawn=Some(spawn.origin),
+			Ok(Entity::InfoTarget(_info_target))=>(),
+			// InfoTeleportDestination is Spawn#
+			Ok(Entity::InfoTeleportDestination(info_teleport_destination))=>if let Some(target)=info_teleport_destination.targetname{
+				// create a new model
+				let model_id=model::ModelId::new(world_models.len() as u32);
+				world_models.push(model::Model{
+					mesh:destination_mesh_id,
+					attributes:ATTRIBUTE_INTERSECT_DEFAULT,
+					transform:integer::Planar64Affine3::from_translation(valve_transform(info_teleport_destination.origin.into())),
+					color:glam::Vec4::W,
+				});
+				teleport_destinations.insert(target,model_id);
 			},
-			Ok(Entity::InfoPlayerTerrorist(spawn))=>{
-				found_spawn=Some(valve_transform(spawn.origin.into()));
+			Ok(Entity::Infodecal(_infodecal))=>(),
+			Ok(Entity::KeyframeRope(_keyframe_rope))=>(),
+			Ok(Entity::Light(_light))=>(),
+			Ok(Entity::LightEnvironment(_light_environment))=>(),
+			Ok(Entity::LightSpot(_light_spot))=>(),
+			Ok(Entity::LogicAuto(_logic_auto))=>(),
+			Ok(Entity::LogicBranch(_logic_branch))=>(),
+			Ok(Entity::LogicCase(_logic_case))=>(),
+			Ok(Entity::LogicCompare(_logic_compare))=>(),
+			Ok(Entity::LogicMeasureMovement(_logic_measure_movement))=>(),
+			Ok(Entity::LogicRelay(_logic_relay))=>(),
+			Ok(Entity::LogicTimer(_logic_timer))=>(),
+			Ok(Entity::MathCounter(_math_counter))=>(),
+			Ok(Entity::MoveRope(_move_rope))=>(),
+			Ok(Entity::PathTrack(_path_track))=>(),
+			Ok(Entity::PhysBallsocket(_phys_ballsocket))=>(),
+			Ok(Entity::PhysConstraint(_phys_constraint))=>(),
+			Ok(Entity::PhysConstraintsystem(_phys_constraintsystem))=>(),
+			Ok(Entity::PhysHinge(_phys_hinge))=>(),
+			Ok(Entity::PhysKeepupright(_phys_keepupright))=>(),
+			Ok(Entity::PhysLengthconstraint(_phys_lengthconstraint))=>(),
+			Ok(Entity::PhysPulleyconstraint(_phys_pulleyconstraint))=>(),
+			Ok(Entity::PhysRagdollconstraint(_phys_ragdollconstraint))=>(),
+			Ok(Entity::PhysRagdollmagnet(_phys_ragdollmagnet))=>(),
+			Ok(Entity::PhysThruster(_phys_thruster))=>(),
+			Ok(Entity::PhysTorque(_phys_torque))=>(),
+			Ok(Entity::PlayerSpeedmod(_player_speedmod))=>(),
+			Ok(Entity::PlayerWeaponstrip(_player_weaponstrip))=>(),
+			Ok(Entity::PointCamera(_point_camera))=>(),
+			Ok(Entity::PointClientcommand(_point_clientcommand))=>(),
+			Ok(Entity::PointDevshotCamera(_point_devshot_camera))=>(),
+			Ok(Entity::PointServercommand(_point_servercommand))=>(),
+			Ok(Entity::PointSpotlight(_point_spotlight))=>(),
+			Ok(Entity::PointSurroundtest(_point_surroundtest))=>(),
+			Ok(Entity::PointTemplate(_point_template))=>(),
+			Ok(Entity::PointTesla(_point_tesla))=>(),
+			Ok(Entity::PointViewcontrol(_point_viewcontrol))=>(),
+			Ok(Entity::PropDoorRotating(brush))=>ent_brush_prop!(brush),
+			Ok(Entity::PropDynamic(brush))=>ent_brush_prop!(brush),
+			Ok(Entity::PropDynamicOverride(brush))=>ent_brush_prop!(brush),
+			Ok(Entity::PropPhysics(brush))=>ent_brush_prop!(brush),
+			Ok(Entity::PropPhysicsMultiplayer(brush))=>ent_brush_prop!(brush),
+			Ok(Entity::PropPhysicsOverride(brush))=>ent_brush_prop!(brush),
+			Ok(Entity::PropRagdoll(brush))=>ent_brush_prop!(brush),
+			Ok(Entity::ShadowControl(_shadow_control))=>(),
+			Ok(Entity::SkyCamera(_sky_camera))=>(),
+			Ok(Entity::TriggerGravity(brush))=>ent_brush_trigger!(brush),
+			Ok(Entity::TriggerHurt(brush))=>ent_brush_trigger!(brush),
+			Ok(Entity::TriggerLook(brush))=>ent_brush_trigger!(brush),
+			Ok(Entity::TriggerMultiple(brush))=>{add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model.unwrap_or_default(),brush.origin,WHITE,ENTITY_TRIGGER_ATTRIBUTE);},
+			Ok(Entity::TriggerOnce(brush))=>ent_brush_trigger!(brush),
+			Ok(Entity::TriggerProximity(brush))=>ent_brush_trigger!(brush),
+			// TriggerPush is booster
+			Ok(Entity::TriggerPush(brush))=>ent_brush_trigger!(brush),
+			Ok(Entity::TriggerSoundscape(brush))=>ent_brush_trigger!(brush),
+			// TriggerTeleport is Trigger#
+			Ok(Entity::TriggerTeleport(brush))=>{
+				if let (Some(model_id),Some(target))=(add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model.unwrap_or_default(),brush.origin,WHITE,ENTITY_TRIGGER_ATTRIBUTE),brush.target){
+					teleports.insert(model_id,target);
+				}
 			},
+			Ok(Entity::TriggerVphysicsMotion(brush))=>ent_brush_trigger!(brush),
+			Ok(Entity::TriggerWind(brush))=>ent_brush_trigger!(brush),
+			Ok(Entity::WaterLodControl(_water_lod_control))=>(),
+			Ok(Entity::WeaponAk47(_weapon_ak47))=>(),
+			Ok(Entity::WeaponAwp(_weapon_awp))=>(),
+			Ok(Entity::WeaponDeagle(_weapon_deagle))=>(),
+			Ok(Entity::WeaponElite(_weapon_elite))=>(),
+			Ok(Entity::WeaponFamas(_weapon_famas))=>(),
+			Ok(Entity::WeaponFiveseven(_weapon_fiveseven))=>(),
+			Ok(Entity::WeaponFlashbang(_weapon_flashbang))=>(),
+			Ok(Entity::WeaponG3sg1(_weapon_g3sg1))=>(),
+			Ok(Entity::WeaponGlock(_weapon_glock))=>(),
+			Ok(Entity::WeaponHegrenade(_weapon_hegrenade))=>(),
+			Ok(Entity::WeaponKnife(_weapon_knife))=>(),
+			Ok(Entity::WeaponM249(_weapon_m249))=>(),
+			Ok(Entity::WeaponM3(_weapon_m3))=>(),
+			Ok(Entity::WeaponM4a1(_weapon_m4a1))=>(),
+			Ok(Entity::WeaponMac10(_weapon_mac10))=>(),
+			Ok(Entity::WeaponP228(_weapon_p228))=>(),
+			Ok(Entity::WeaponP90(_weapon_p90))=>(),
+			Ok(Entity::WeaponScout(_weapon_scout))=>(),
+			Ok(Entity::WeaponSg550(_weapon_sg550))=>(),
+			Ok(Entity::WeaponSmokegrenade(_weapon_smokegrenade))=>(),
+			Ok(Entity::WeaponTmp(_weapon_tmp))=>(),
+			Ok(Entity::WeaponUmp45(_weapon_ump45))=>(),
+			Ok(Entity::WeaponUsp(_weapon_usp))=>(),
+			Ok(Entity::WeaponXm1014(_weapon_xm1014))=>(),
+			Ok(Entity::Worldspawn(_worldspawn))=>(),
 			Err(e)=>{
 				println!("Bsp Entity parse error: {e}");
 			},
@@ -304,72 +484,68 @@ pub fn convert<'a>(
 		}
 	}
 
-	let mut modes_list=Vec::new();
-	if let Some(spawn_point)=found_spawn{
-		// create a new mesh
-		let mesh_id=model::MeshId::new(world_meshes.len() as u32);
-		world_meshes.push(crate::brush::unit_cube());
+	let first_stage=found_spawn.map(|spawn_point|{
 		// create a new model
 		let model_id=model::ModelId::new(world_models.len() as u32);
 		world_models.push(model::Model{
-			mesh:mesh_id,
+			mesh:destination_mesh_id,
 			attributes:ATTRIBUTE_INTERSECT_DEFAULT,
-			transform:integer::Planar64Affine3::from_translation(spawn_point),
+			transform:integer::Planar64Affine3::from_translation(valve_transform(spawn_point.into())),
 			color:glam::Vec4::W,
 		});
 
-		let first_stage=Stage::empty(model_id);
-		let main_mode=Mode::new(
-			strafesnet_common::gameplay_style::StyleModifiers::source_bhop(),
-			model_id,
-			std::collections::HashMap::new(),
-			vec![first_stage],
-			std::collections::HashMap::new(),
-		);
-		modes_list.push(NormalizedMode::new(main_mode));
-	}
+		Stage::empty(model_id)
+	});
 
 	PartialMap1{
 		attributes:unique_attributes,
 		world_meshes,
 		prop_models,
 		world_models,
-		modes:NormalizedModes::new(modes_list),
+		first_stage,
+		teleports,
+		teleport_destinations,
 	}
 }
 
 //partially constructed map types
-pub struct PartialMap1{
+pub struct PartialMap1<'a>{
 	attributes:Vec<attr::CollisionAttributes>,
 	prop_models:Vec<model::Model>,
 	world_meshes:Vec<model::Mesh>,
 	world_models:Vec<model::Model>,
-	modes:NormalizedModes,
+	first_stage:Option<Stage>,
+	teleports:HashMap<AddBrush,&'a str>,
+	teleport_destinations:HashMap<&'a str,model::ModelId>,
 }
-impl PartialMap1{
-	pub fn add_prop_meshes<'a>(
+impl<'a> PartialMap1<'a>{
+	pub fn add_prop_meshes(
 		self,
 		prop_meshes:Meshes,
-	)->PartialMap2{
+	)->PartialMap2<'a>{
 		PartialMap2{
 			attributes:self.attributes,
 			prop_meshes:prop_meshes.consume().collect(),
 			prop_models:self.prop_models,
 			world_meshes:self.world_meshes,
 			world_models:self.world_models,
-			modes:self.modes,
+			first_stage:self.first_stage,
+			teleports:self.teleports,
+			teleport_destinations:self.teleport_destinations,
 		}
 	}
 }
-pub struct PartialMap2{
+pub struct PartialMap2<'a>{
 	attributes:Vec<attr::CollisionAttributes>,
 	prop_meshes:Vec<(model::MeshId,model::Mesh)>,
 	prop_models:Vec<model::Model>,
 	world_meshes:Vec<model::Mesh>,
 	world_models:Vec<model::Model>,
-	modes:NormalizedModes,
+	first_stage:Option<Stage>,
+	teleports:HashMap<AddBrush,&'a str>,
+	teleport_destinations:HashMap<&'a str,model::ModelId>,
 }
-impl PartialMap2{
+impl PartialMap2<'_>{
 	pub fn add_render_configs_and_textures(
 		mut self,
 		render_configs:RenderConfigs,
@@ -377,22 +553,70 @@ impl PartialMap2{
 		//merge mesh and model lists, flatten and remap all ids
 		let mesh_id_offset=self.world_meshes.len();
 		println!("prop_meshes.len()={}",self.prop_meshes.len());
-		let (mut prop_meshes,prop_mesh_id_map):(Vec<model::Mesh>,std::collections::HashMap<model::MeshId,model::MeshId>)
+		let (mut prop_meshes,prop_mesh_id_map):(Vec<model::Mesh>,HashMap<model::MeshId,model::MeshId>)
 		=self.prop_meshes.into_iter().enumerate().map(|(new_mesh_id,(old_mesh_id,mesh))|{
 			(mesh,(old_mesh_id,model::MeshId::new((mesh_id_offset+new_mesh_id) as u32)))
 		}).unzip();
 		self.world_meshes.append(&mut prop_meshes);
-		//there is no modes or runtime behaviour with references to the model ids currently
-		//so just relentlessly cull them if the mesh is missing
-		self.world_models.extend(self.prop_models.into_iter().filter_map(|mut model|
+
+		// cull models with a missing mesh
+		let model_id_offset=self.world_models.len();
+		let mut prop_model_id_to_final_model_id=HashMap::new();
+		self.world_models.extend(self.prop_models.into_iter().enumerate().filter_map(|(prop_model_id,mut model)|
 			prop_mesh_id_map.get(&model.mesh).map(|&new_mesh_id|{
 				model.mesh=new_mesh_id;
-				model
+				(prop_model_id,model)
 			})
+		).enumerate().map(|(model_id,(prop_model_id,model))|{
+			prop_model_id_to_final_model_id.insert(
+				model::ModelId::new(prop_model_id as u32),
+				model::ModelId::new((model_id_offset+model_id) as u32),
+			);
+			model
+		}));
+
+		//calculate teleports
+		let first_stage_spawn_model_id=self.first_stage.as_ref().unwrap().spawn();
+		let mut teleport_destinations=HashMap::new();
+		let stages={
+			let mut stages=self.teleport_destinations.iter().map(|(&target,&model_id)|(target,model_id)).collect::<Vec<_>>();
+			stages.sort_by_key(|&(target,_)|target);
+			self.first_stage.into_iter().chain(
+				stages.into_iter().enumerate().map(|(stage_id,(target,model_id))|{
+					let stage_id=modes::StageId::new(1+stage_id as u32);
+					teleport_destinations.insert(target,stage_id);
+					Stage::empty(model_id)
+				})
+			).collect()
+		};
+		let mut elements=HashMap::new();
+		for (teleport_model,target) in self.teleports{
+			if let Some(&stage_id)=teleport_destinations.get(target){
+				let model_id=match teleport_model{
+					AddBrush::Available(model_id)=>Some(model_id),
+					AddBrush::Deferred(model_id)=>prop_model_id_to_final_model_id.get(&model_id).copied(),
+				};
+				if let Some(model_id)=model_id{
+					elements.insert(model_id,modes::StageElement::new(
+						stage_id,
+						true,
+						modes::StageElementBehaviour::Teleport,
+						None,
+					));
+				}
+			}
+		}
+		let main_mode=NormalizedMode::new(Mode::new(
+			strafesnet_common::gameplay_style::StyleModifiers::default(),
+			first_stage_spawn_model_id,
+			HashMap::new(),
+			stages,
+			elements,
 		));
-		//let mut models=Vec::new();
+		let modes=NormalizedModes::new(vec![main_mode]);
+
 		let (textures,render_configs)=render_configs.consume();
-		let (textures,texture_id_map):(Vec<Vec<u8>>,std::collections::HashMap<model::TextureId,model::TextureId>)
+		let (textures,texture_id_map):(Vec<Vec<u8>>,HashMap<model::TextureId,model::TextureId>)
 		=textures.into_iter()
 		//.filter_map(f) cull unused textures
 		.enumerate().map(|(new_texture_id,(old_texture_id,Texture::ImageDDS(texture)))|{
@@ -406,7 +630,7 @@ impl PartialMap2{
 			render_config
 		}).collect();
 		map::CompleteMap{
-			modes:self.modes,
+			modes,
 			attributes:self.attributes,
 			meshes:self.world_meshes,
 			models:self.world_models,