Parallax optimizations (#1091)

* parallax port broken

* fixed

Author: Kapu1178

code/_compile_options.dm

@@ -162,7 +162,7 @@
 /////////////////////// MISC PERFORMANCE
 
 //uncomment this to load centcom and runtime station and thats it.
-// #define LOWMEMORYMODE
+#define LOWMEMORYMODE
 
 //uncomment to enable the spatial grid debug proc.
 // #define SPATIAL_GRID_ZLEVEL_STATS

code/_onclick/hud/parallax.dm

@@ -7,6 +7,11 @@
 	if (!apply_parallax_pref(viewmob)) //don't want shit computers to crash when specing someone with insane parallax, so use the viewer's pref
 		return
 
+	if(isnull(C.parallax_master))
+		C.parallax_master = new(null, src)
+
+	C.screen |= C.parallax_master
+
 	if(!length(C.parallax_layers_cached))
 		C.parallax_layers_cached = list()
 		C.parallax_layers_cached += new /atom/movable/screen/parallax_layer/layer_1(null, src)
@@ -17,11 +22,13 @@
 	if (length(C.parallax_layers) > C.parallax_layers_max)
 		C.parallax_layers.len = C.parallax_layers_max
 
-	C.screen |= (C.parallax_layers)
+	C.parallax_master.vis_contents = C.parallax_layers
+
 	var/atom/movable/screen/plane_master/PM = screenmob.hud_used.plane_masters["[PLANE_SPACE]"]
 	if(screenmob != mymob)
 		C.screen -= locate(/atom/movable/screen/plane_master/parallax_white) in C.screen
 		C.screen += PM
+
 	PM.color = list(
 		0, 0, 0, 0,
 		0, 0, 0, 0,
@@ -34,11 +41,13 @@
 /datum/hud/proc/remove_parallax(mob/viewmob)
 	var/mob/screenmob = viewmob || mymob
 	var/client/C = screenmob.client
-	C.screen -= (C.parallax_layers_cached)
+	C.screen -= C.parallax_master
+
 	var/atom/movable/screen/plane_master/PM = screenmob.hud_used.plane_masters["[PLANE_SPACE]"]
 	if(screenmob != mymob)
 		C.screen -= locate(/atom/movable/screen/plane_master/parallax_white) in C.screen
 		C.screen += PM
+
 	PM.color = initial(PM.color)
 	C.parallax_layers = null
 
@@ -92,74 +101,62 @@
 	var/client/C = screenmob.client
 	if(new_parallax_movedir == C.parallax_movedir)
 		return
-	var/animatedir = new_parallax_movedir
-	if(new_parallax_movedir == FALSE)
-		var/animate_time = 0
-		for(var/atom/movable/screen/parallax_layer/L as anything in C.parallax_layers)
-			L.icon_state = initial(L.icon_state)
-			L.update_o(C.view)
-			var/T = PARALLAX_LOOP_TIME / L.speed
-			if (T > animate_time)
-				animate_time = T
-		C.dont_animate_parallax = world.time + min(animate_time, PARALLAX_LOOP_TIME)
-		animatedir = C.parallax_movedir
-
-	var/matrix/newtransform
-	switch(animatedir)
+
+	var/animation_dir = new_parallax_movedir || C.parallax_movedir
+	var/matrix/new_transform
+	switch(animation_dir)
 		if(NORTH)
-			newtransform = matrix(1, 0, 0, 0, 1, PARALLAX_ICON_SIZE)
+			new_transform = matrix(1, 0, 0, 0, 1, PARALLAX_ICON_SIZE)
 		if(SOUTH)
-			newtransform = matrix(1, 0, 0, 0, 1,-PARALLAX_ICON_SIZE)
+			new_transform = matrix(1, 0, 0, 0, 1,-PARALLAX_ICON_SIZE)
 		if(EAST)
-			newtransform = matrix(1, 0, PARALLAX_ICON_SIZE, 0, 1, 0)
+			new_transform = matrix(1, 0, PARALLAX_ICON_SIZE, 0, 1, 0)
 		if(WEST)
-			newtransform = matrix(1, 0,-PARALLAX_ICON_SIZE, 0, 1, 0)
-
-	var/shortesttimer
-	if(!skip_windups)
-		for(var/atom/movable/screen/parallax_layer/L as anything in C.parallax_layers)
-			var/T = PARALLAX_LOOP_TIME / L.speed
-			if (isnull(shortesttimer))
-				shortesttimer = T
-			if (T < shortesttimer)
-				shortesttimer = T
-			L.transform = newtransform
-			animate(L, transform = matrix(), time = T, easing = QUAD_EASING | (new_parallax_movedir ? EASE_IN : EASE_OUT), flags = ANIMATION_END_NOW)
-			if (new_parallax_movedir)
-				L.transform = newtransform
-				animate(transform = matrix(), time = T) //queue up another animate so lag doesn't create a shutter
+			new_transform = matrix(1, 0,-PARALLAX_ICON_SIZE, 0, 1, 0)
 
-	C.parallax_movedir = new_parallax_movedir
-	if (C.parallax_animate_timer)
-		deltimer(C.parallax_animate_timer)
-	var/datum/callback/CB = CALLBACK(src, PROC_REF(update_parallax_motionblur), C, animatedir, new_parallax_movedir, newtransform)
-	if(skip_windups)
-		CB.Invoke()
-	else
-		C.parallax_animate_timer = addtimer(CB, min(shortesttimer, PARALLAX_LOOP_TIME), TIMER_CLIENT_TIME|TIMER_STOPPABLE)
+	var/longest_timer = 0
+	for(var/key in C.parallax_animate_timers)
+		deltimer(C.parallax_animate_timers[key])
+	C.parallax_animate_timers = list()
 
+	for(var/atom/movable/screen/parallax_layer/layer as anything in C.parallax_layers)
+		var/scaled_time = PARALLAX_LOOP_TIME / layer.speed
+		if(new_parallax_movedir == NONE) // If we're stopping, we need to stop on the same dime, yeah?
+			scaled_time = PARALLAX_LOOP_TIME
+		longest_timer = max(longest_timer, scaled_time)
 
-/datum/hud/proc/update_parallax_motionblur(client/C, animatedir, new_parallax_movedir, matrix/newtransform)
-	if(!C)
-		return
-	C.parallax_animate_timer = FALSE
-	for(var/thing in C.parallax_layers)
-		var/atom/movable/screen/parallax_layer/L = thing
-		if (!new_parallax_movedir)
-			animate(L)
+		if(skip_windups)
+			update_parallax_motionblur(C, layer, new_parallax_movedir, new_transform)
 			continue
 
-		var/newstate = initial(L.icon_state)
-		var/T = PARALLAX_LOOP_TIME / L.speed
+		layer.transform = new_transform
+		animate(layer, transform = matrix(), time = scaled_time, easing = QUAD_EASING | (new_parallax_movedir ? EASE_IN : EASE_OUT))
+		if (new_parallax_movedir == NONE)
+			continue
 
-		if (newstate in icon_states(L.icon))
-			L.icon_state = newstate
-			L.update_o(C.view)
+		//queue up another animate so lag doesn't create a shutter
+		animate(transform = new_transform, time = 0)
+		animate(transform = matrix(), time = scaled_time / 2)
+		C.parallax_animate_timers[layer] = addtimer(CALLBACK(src, PROC_REF(update_parallax_motionblur), C, layer, new_parallax_movedir, new_transform), scaled_time, TIMER_CLIENT_TIME|TIMER_STOPPABLE)
 
-		L.transform = newtransform
+	C.dont_animate_parallax = world.time + min(longest_timer, PARALLAX_LOOP_TIME)
+	C.parallax_movedir = new_parallax_movedir
+
+/datum/hud/proc/update_parallax_motionblur(client/C, atom/movable/screen/parallax_layer/layer, new_parallax_movedir, matrix/new_transform)
+	if(!C)
+		return
 
-		animate(L, transform = L.transform, time = 0, loop = -1, flags = ANIMATION_END_NOW)
-		animate(transform = matrix(), time = T)
+	C.parallax_animate_timers -= layer
+
+	// If we are moving in a direction, we used the QUAD_EASING function with EASE_IN
+	// This means our position function is x^2. This is always LESS then the linear we're using here
+	// But if we just used the same time delay, our rate of change would mismatch. f'(1) = 2x for quad easing, rather then the 1 we get for linear
+	// (This is because of how derivatives work right?)
+	// Because of this, while our actual rate of change from before was PARALLAX_LOOP_TIME, our perceived rate of change was PARALLAX_LOOP_TIME / 2 (lower == faster).
+	// Let's account for that here
+	var/scaled_time = (PARALLAX_LOOP_TIME / layer.speed) / 2
+	animate(layer, transform = new_transform, time = 0, loop = -1, flags = ANIMATION_END_NOW)
+	animate(transform = matrix(), time = scaled_time)
 
 /datum/hud/proc/update_parallax(mob/viewmob)
 	var/mob/screenmob = viewmob || mymob
@@ -196,36 +193,39 @@
 		var/our_speed = parallax_layer.speed
 		var/change_x
 		var/change_y
+		var/old_x = parallax_layer.offset_x
+		var/old_y = parallax_layer.offset_y
+
 		if(parallax_layer.absolute)
 			// We use change here so the typically large absolute objects don't jitter so much
-			change_x = (posobj.x - SSparallax.planet_x_offset) * our_speed + parallax_layer.offset_x
-			change_y = (posobj.y - SSparallax.planet_y_offset) * our_speed + parallax_layer.offset_y
+			change_x = (posobj.x - SSparallax.planet_x_offset) * our_speed + old_x
+			change_y = (posobj.y - SSparallax.planet_y_offset) * our_speed + old_y
 		else
 			change_x = offset_x * our_speed
 			change_y = offset_y * our_speed
 
 			// This is how we tile parralax sprites
 			// It doesn't use change because we really don't want to animate this
-			if(parallax_layer.offset_x - change_x > PARALLAX_ICON_SIZE/2)
+			if(old_x - change_x > PARALLAX_ICON_SIZE/2)
 				parallax_layer.offset_x -= PARALLAX_ICON_SIZE
-			else if(parallax_layer.offset_x - change_x < -(PARALLAX_ICON_SIZE/2))
+			else if(old_x - change_x < -(PARALLAX_ICON_SIZE/2))
 				parallax_layer.offset_x += PARALLAX_ICON_SIZE
-			if(parallax_layer.offset_y - change_y > PARALLAX_ICON_SIZE/2)
+			if(old_y - change_y > PARALLAX_ICON_SIZE/2)
 				parallax_layer.offset_y -= PARALLAX_ICON_SIZE
-			else if(parallax_layer.offset_y - change_y < -(PARALLAX_ICON_SIZE/2))
+			else if(old_y - change_y < -(PARALLAX_ICON_SIZE/2))
 				parallax_layer.offset_y += PARALLAX_ICON_SIZE
 
-		// Now that we have our offsets, let's do our positioning
 		parallax_layer.offset_x -= change_x
 		parallax_layer.offset_y -= change_y
 
-		parallax_layer.screen_loc = "CENTER-7:[round(parallax_layer.offset_x, 1)],CENTER-7:[round(parallax_layer.offset_y, 1)]"
-
-		// We're going to use a transform to "glide" that last movement out, so it looks nicer
+		// Now that we have our offsets, let's do our positioning
+		// We're going to use an animate to "glide" that last movement out, so it looks nicer
 		// Don't do any animates if we're not actually moving enough distance yeah? thanks lad
 		if(run_parralax && (largest_change * our_speed > 1))
-			parallax_layer.transform = matrix(1,0,change_x, 0,1,change_y)
-			animate(parallax_layer, transform=matrix(), time = glide_rate)
+			animate(parallax_layer, pixel_x = round(parallax_layer.offset_x, 1), pixel_y = round(parallax_layer.offset_y, 1), time = glide_rate)
+		else
+			parallax_layer.pixel_x = round(parallax_layer.offset_x, 1)
+			parallax_layer.pixel_y = round(parallax_layer.offset_y, 1)
 
 /atom/movable/proc/update_parallax_contents()
 	for(var/mob/client_mob as anything in client_mobs_in_contents)
@@ -237,6 +237,15 @@
 		var/area/areaobj = get_area(client.eye)
 		hud_used.set_parallax_movedir(areaobj.parallax_movedir, TRUE)
 
+// Root object for parallax, all parallax layers are drawn onto this
+INITIALIZE_IMMEDIATE(/atom/movable/screen/parallax_root)
+/atom/movable/screen/parallax_root
+	icon = null
+	blend_mode = BLEND_ADD
+	plane = PLANE_SPACE_PARALLAX
+	screen_loc = "CENTER-7,CENTER-7"
+	mouse_opacity = MOUSE_OPACITY_TRANSPARENT
+
 // We need parallax to always pass its args down into initialize, so we immediate init it
 INITIALIZE_IMMEDIATE(/atom/movable/screen/parallax_layer)
 /atom/movable/screen/parallax_layer
@@ -246,17 +255,16 @@ INITIALIZE_IMMEDIATE(/atom/movable/screen/parallax_layer)
 	var/offset_y = 0
 	var/view_sized
 	var/absolute = FALSE
-	appearance_flags = APPEARANCE_UI | TILE_BOUND
+	appearance_flags = APPEARANCE_UI | TILE_BOUND | KEEP_TOGETHER
 	blend_mode = BLEND_ADD
 	plane = PLANE_SPACE_PARALLAX
-	screen_loc = "CENTER-7,CENTER-7"
 	mouse_opacity = MOUSE_OPACITY_TRANSPARENT
 
 /atom/movable/screen/parallax_layer/Initialize(mapload, datum/hud/hud_owner)
 	. = ..()
 	// Parallax layers are independant of hud, they care about client
 	// Not doing this will just create a bunch of hard deletes
-	hud = null
+	set_new_hud(null)
 
 	var/client/boss = hud_owner?.mymob?.canon_client
 
@@ -280,16 +288,20 @@ INITIALIZE_IMMEDIATE(/atom/movable/screen/parallax_layer)
 
 	// Turn the view size into a grid of correctly scaled overlays
 	var/list/viewscales = getviewsize(view)
+	// This could be half the size but we need to provide space for parallax movement on mob movement, and movement on scroll from shuttles, so like this instead
 	var/countx = CEILING((viewscales[1] / 2) * parallax_scaler, 1) + 1
 	var/county = CEILING((viewscales[2] / 2) * parallax_scaler, 1) + 1
 	var/list/new_overlays = new
 	for(var/x in -countx to countx)
 		for(var/y in -county to county)
 			if(x == 0 && y == 0)
 				continue
+
 			var/mutable_appearance/texture_overlay = mutable_appearance(icon, icon_state)
-			texture_overlay.transform = matrix(1, 0, x*PARALLAX_ICON_SIZE, 0, 1, y*PARALLAX_ICON_SIZE)
+			texture_overlay.pixel_x += PARALLAX_ICON_SIZE * x
+			texture_overlay.pixel_y += PARALLAX_ICON_SIZE * y
 			new_overlays += texture_overlay
+
 	cut_overlays()
 	add_overlay(new_overlays)
 	view_sized = view

code/_onclick/hud/screen_objects.dm

@@ -37,8 +37,10 @@
 
 /atom/movable/screen/Initialize(mapload, datum/hud/hud_owner)
 	. = ..()
-	if(istype(hud_owner))
-		hud = hud_owner
+	if(isnull(hud_owner)) //some screens set their hud owners on /new, this prevents overriding them with null post atoms init
+		return
+
+	set_new_hud(hud_owner)
 
 /atom/movable/screen/Destroy()
 	master_ref = null
@@ -54,20 +56,37 @@
 
 	SEND_SIGNAL(src, COMSIG_CLICK, location, control, params, usr)
 
-/atom/movable/screen/proc/can_usr_use(mob/user)
-	. = TRUE
-	if(private_screen && (hud?.mymob != user))
-		return FALSE
 
 /atom/movable/screen/examine(mob/user)
 	return list()
 
 /atom/movable/screen/orbit()
 	return
 
+/atom/movable/screen/proc/can_usr_use(mob/user)
+	. = TRUE
+	if(private_screen && (hud?.mymob != user))
+		return FALSE
+
+///setter used to set our new hud
+/atom/movable/screen/proc/set_new_hud(datum/hud/hud_owner)
+	if(hud)
+		UnregisterSignal(hud, COMSIG_PARENT_QDELETING)
+
+	if(isnull(hud_owner))
+		hud = null
+		return
+
+	hud = hud_owner
+	RegisterSignal(hud, COMSIG_PARENT_QDELETING, PROC_REF(on_hud_delete))
+
 /atom/movable/screen/proc/component_click(atom/movable/screen/component_button/component, params)
 	return
 
+/atom/movable/screen/proc/on_hud_delete(datum/source)
+	SIGNAL_HANDLER
+	set_new_hud(hud_owner = null)
+
 /atom/movable/screen/text
 	icon = null
 	icon_state = null

code/modules/client/client_defines.dm

@@ -204,6 +204,8 @@
 
 	var/list/parallax_layers
 	var/list/parallax_layers_cached
+	var/atom/movable/screen/parallax_root/parallax_master
+
 	///this is the last recorded client eye by SSparallax/fire()
 	var/atom/movable/movingmob
 	var/turf/previous_turf
@@ -213,8 +215,8 @@
 	var/parallax_movedir = 0
 	/// How many parallax layers to show our client
 	var/parallax_layers_max = 4
-	/// Timer for the area directional animation
-	var/parallax_animate_timer
+	/// Timers for the area directional animation, one for each layer
+	var/list/parallax_animate_timers
 	/// Do we want to do parallax animations at all?
 	/// Exists to prevent laptop fires
 	var/do_parallax_animations = TRUE

code/modules/client/client_procs.dm

@@ -600,6 +600,9 @@ GLOBAL_LIST_INIT(blacklisted_builds, list(
 	QDEL_NULL(view_size)
 	QDEL_NULL(void)
 	QDEL_NULL(tooltips)
+	QDEL_NULL(parallax_master)
+	QDEL_LIST(parallax_layers_cached)
+	parallax_layers = null
 	seen_messages = null
 	Master.UpdateTickRate()
 	..() //Even though we're going to be hard deleted there are still some things that want to know the destroy is happening