Improved parallax system

objects/obj_parallax/Create_0.gml

@@ -1,14 +1,83 @@
-bg_scroll = {
-	x: 0,
-	y: 0
+#macro CAM_X camera_get_view_x(view_camera[0])
+#macro CAM_Y camera_get_view_y(view_camera[0])
+#macro CAM_W camera_get_view_width(view_camera[0])
+#macro CAM_H camera_get_view_height(view_camera[0])
+global.parallaxLayers = {}
+parallaxFactors = {
+	Backgrounds_1 : 0.25,
+	Backgrounds_2 : 0.2,
+	Backgrounds_2 : 0.15,
+	Backgrounds_scroll : 0.3,
+	Backgrounds_scroll1 : 0.3,
+	Backgrounds_scroll2 : 0.25,
+	Backgrounds_scroll3 : 0.2,	
+    Backgrounds_Ground1 : 0.2,
+    Backgrounds_Ground2 : 0.18,
+    Backgrounds_Ground3 : 0.16,
+	Backgrounds_stillH1 : 1,
+	Backgrounds_stillH1 : 1 - 0.3,
+	Backgrounds_stillH2 : 1 - 0.35,
+	Backgrounds_stillH3 : 1 - 0.4,
+	Backgrounds_stillH4 : 1 - 0.45,
+	Backgrounds_H1 : 0.22,
+	Backgrounds_H2 : 0.11,
+	Foregrounds_1 : -0.15,
+	Foregrounds_2 : -0.25,
+	Foregrounds_3 : -0.35,
+	Foregrounds_Ground1 : -0.15,
+	Foregrounds_Ground2 : -0.25,
+	Foregrounds_Ground3 : -0.35,
 }
+parallaxLayer = function(lay) constructor {
+	name = layer_get_name(lay)
+	factor = struct_get(other.parallaxFactors, name) ?? 0
+
+	bgID = layer_background_get_id(lay)
+	layerid = lay
 
-l = []
-offsets = []
-
-stillHfactors = {
-	Backgrounds_stillH1: 0.3,
-	Backgrounds_stillH2: 0.35,
-	Backgrounds_stillH3: 0.4,
-	Backgrounds_stillH4: 0.45
+	sprite_index = layer_background_get_sprite(bgID)
+	image_index = layer_background_get_index(bgID)
+	image_speed = layer_background_get_speed(bgID)
+	layer_background_speed(bgID, 0)
+
+	x_offset = layer_get_x(lay)
+	y_offset = layer_get_y(lay)
+	x = x_offset
+	y = y_offset
+	x_scroll = 0
+	y_scroll = 0
+
+	// so you can set these like: 'global.parallaxLayers.Backgrounds_scroll.vsp = -14' or idk (if the layer exists ofc)
+	vsp = layer_get_vspeed(lay)
+	hsp = layer_get_hspeed(lay)
+	layer_vspeed(lay, 0)
+	layer_hspeed(lay, 0)
+
+	var str = name
+	var i = 0
+	var maxLayerCount = 5
+	repeat maxLayerCount {
+		i++
+		str = string_replace_all(str, string(i), "")
+	}
+	baseName = str
+	static calculateStillX = function() {
+		var a = max(CAM_X / (room_width - CAM_W), 1) * (sprite_get_width(sprite_index) - screen_w)
+		return CAM_X - a
+	}
+	static calculateStillY = function() { 
+		var a = max(CAM_Y / (room_height - CAM_H), 1) * (sprite_get_height(sprite_index) - screen_h)
+		return CAM_Y - a
+	}
+	static scroll = function() {
+		x_scroll = (x_scroll + hsp) % sprite_get_width(sprite_index)
+		y_scroll = (y_scroll + vsp) % sprite_get_height(sprite_index)
+	}
+	static panicSprite = function(_bg, _panic_bg) {
+		if sprite_index == _bg || !sprite_exists(sprite_index) {
+			image_index = 0
+			sprite_index = _panic_bg
+		}
+	}
 }
+

objects/obj_parallax/Other_4.gml

@@ -1,18 +1,7 @@
-bg_scroll.x = 0
-bg_scroll.y = 0
-
-offsets = []
-
-l = layer_get_all()
-
-for (var i = 0; i < array_length(l); i++)
-{
-	var bg_id = l[i]
-
-	var s = {
-		x: layer_get_x(bg_id),
-		y: layer_get_y(bg_id)
-	}
-
-	array_push(offsets, s)
-}
+global.parallaxLayers = {}
+var a = layer_get_all()
+for (var i = 0; i < array_length(a); i++) {
+	var name = layer_get_name(a[i])
+	if string_starts_with(name, "Backgrounds_") ||string_starts_with(name, "Foregrounds_")
+		global.parallaxLayers[$ name] = new parallaxLayer(name)
+}

objects/obj_parallax/Step_2.gml

@@ -1,104 +1,50 @@
-var camera_pos = {
-	x: camera_get_view_x(view_camera[0]),
-	y: camera_get_view_y(view_camera[0])
-}
-
-bg_scroll.x++
-bg_scroll.y++
-
-for (var i = 0; i < array_length(l); i++)
-{
-	var bg_id = l[i]
-
-	var _lay_name = layer_get_name(bg_id)
-	switch (_lay_name)
-	{
-		case "Backgrounds_1":
-			layer_x(bg_id, offsets[i].x + (camera_pos.x * 0.25))
-			layer_y(bg_id, offsets[i].y + (camera_pos.y * 0.25))
-			break;
-		case "Backgrounds_2":
-			layer_x(bg_id, offsets[i].x + (camera_pos.x * 0.2))
-			layer_y(bg_id, offsets[i].y + (camera_pos.y * 0.2))
-			break;
-		case "Backgrounds_3":
-			layer_x(bg_id, offsets[i].x + (camera_pos.x * 0.15))
-			layer_y(bg_id, offsets[i].y + (camera_pos.y * 0.15))
-			break;
-        case "Backgrounds_Ground1":
-            layer_x(bg_id, camera_pos.x * 0.2)
-            break;
-        case "Backgrounds_Ground2":
-            layer_x(bg_id, camera_pos.x * 0.18)
-            break;
-        case "Backgrounds_Ground3":
-            layer_x(bg_id, camera_pos.x * 0.16)
-            break;
-        case "Backgrounds_H1":
-            layer_x(bg_id, camera_pos.x * 0.22)
-            layer_y(bg_id, camera_pos.y)
-            break;
-            break;
-        case "Backgrounds_H2":
-            layer_x(bg_id, camera_pos.x * 0.11)
-            layer_y(bg_id, camera_pos.y)
-            break;
-        case "Backgrounds_sky":
-        case "Backgrounds_still":
-            layer_x(bg_id, camera_pos.x + (bg_scroll.x * layer_get_hspeed(bg_id)))
-            layer_y(bg_id, camera_pos.y + (bg_scroll.y * layer_get_vspeed(bg_id)))
-            break;
-        case "Backgrounds_stillfit":
-			var _spr = layer_background_get_sprite(layer_background_get_id(bg_id))
-			var _dist_x = camera_pos.x / (room_width - screen_w)
-			var _dist_y = camera_pos.y / (room_height - screen_h)
-			layer_x(bg_id, camera_pos.x - (_dist_x * max(sprite_get_width(_spr) - screen_w, 0)))
-			layer_y(bg_id, camera_pos.y - (_dist_y * max(sprite_get_height(_spr) - screen_h, 0)))
-            break;
-		case "Backgrounds_stillH":
-			var _spr = layer_background_get_sprite(layer_background_get_id(bg_id))
-			var _dist = camera_pos.y / (room_height - screen_h)
-			layer_x(bg_id, camera_pos.x)
-			layer_y(bg_id, camera_pos.y - (_dist * max(sprite_get_height(_spr) - screen_h, 0)))
-			break;
-		case "Backgrounds_stillH1":
-		case "Backgrounds_stillH2":
-		case "Backgrounds_stillH3":
-		case "Backgrounds_stillH4":
-			var _spr = layer_background_get_sprite(layer_background_get_id(bg_id))
-			var _dist = camera_pos.y / (room_height - screen_h)
-			var _factor = stillHfactors[$ _lay_name]
-			layer_x(bg_id, camera_pos.x * _factor)
-			layer_y(bg_id, camera_pos.y - (_dist * max(sprite_get_height(_spr) - screen_h, 0) * (1 - _factor)))
-			break;
-		case "Backgrounds_scroll":
-		case "Backgrounds_scroll1":
-			layer_x(bg_id, (camera_pos.x * 0.3) + (bg_scroll.x * layer_get_hspeed(bg_id)))
-			layer_y(bg_id, (camera_pos.y * 0.3) + (bg_scroll.y * layer_get_vspeed(bg_id)))
-			break;
-		case "Backgrounds_scroll2":
-			layer_x(bg_id, (camera_pos.x * 0.25) + (bg_scroll.x * layer_get_hspeed(bg_id)))
-			layer_y(bg_id, (camera_pos.y * 0.25) + (bg_scroll.y * layer_get_vspeed(bg_id)))
-			break;
-		case "Backgrounds_scroll3":
-			layer_x(bg_id, (camera_pos.x * 0.2) + (bg_scroll.x * layer_get_hspeed(bg_id)))
-			layer_y(bg_id, (camera_pos.y * 0.2) + (bg_scroll.y * layer_get_vspeed(bg_id)))
-			break;
-		case "Foregrounds_1":
-			layer_x(bg_id, offsets[i].x + camera_pos.x * -0.15)
-			layer_y(bg_id, offsets[i].y + camera_pos.y * -0.15)
-			break;
-		case "Foregrounds_2":
-			layer_x(bg_id, offsets[i].x + camera_pos.x * -0.25)
-			layer_y(bg_id, offsets[i].y + camera_pos.y * -0.25)
-			break;
-		case "Foregrounds_3":
-			layer_x(bg_id, offsets[i].x + camera_pos.x * -0.35)
-			layer_y(bg_id, offsets[i].y + camera_pos.y * -0.35)
-			break;
-        case "Foregrounds_Ground1":
-            layer_x(bg_id, camera_pos.x * -0.15)
-            layer_y(bg_id, room_height - sprite_get_height(layer_background_get_sprite(layer_background_get_id(bg_id))))
-            break;
+var names = struct_get_names(global.parallaxLayers)
+for (var i = 0; i < array_length(names); i++) {
+	with global.parallaxLayers[$ names[i]] {
+		switch baseName {
+			case "Backgrounds_scroll":
+				scroll()
+				x = (CAM_X * factor) + x_scroll
+				y = (CAM_Y * factor) + y_scroll
+				break;
+			case "Backgrounds_Ground":
+				x = CAM_X * factor
+				break;	
+	        case "Backgrounds_H":
+				x = CAM_X * factor
+				y = CAM_Y
+	            break;
+			case "Backgrounds_sky":
+				scroll()
+				x = CAM_X + x_scroll
+				y = CAM_Y + y_scroll
+				break;
+			case "Backgrounds_stillfit":
+				x = calculateStillX()
+				y = calculateStillY()
+				break;
+			case "Backgrounds_stillH":
+				if name == "Backgrounds_stillH" {
+					x = CAM_X
+					y = calculateStillY()
+				} else {
+					x = CAM_X * factor
+					y = (calculateStillY() * (1 - factor))	
+				}
+				break;
+			case "Foregrounds_Ground":
+				x = CAM_X * factor
+				y = room_height - sprite_get_height(sprite_index)
+				break;
+			default:
+				x = x_offset + CAM_X * factor
+				y = y_offset + CAM_Y * factor
+		}
+		image_index += image_speed
+		image_index %= sprite_get_number(sprite_index)
+		layer_x(layerid, x)
+		layer_y(layerid, y)
+		layer_background_index(bgID, image_index)
+		layer_background_sprite(bgID, sprite_index)
 	}
 }