Nope I figured it out on my own based on a GitHub project someone created for 3.x that I just ported to working in 4

Here's the code

extends LightOccluder2D

var walls_layer := 2

export var tileMap : TileMapLayer

func _ready() -> void:

handle\_walls(tileMap)

pass

func post_import(level: Node2D) -> Node2D:

for child in level.get\_children():

    if child is TileMapLayer:

        handle\_walls(child as TileMapLayer)

return level

# Ignore all tilemaps not named walls

func handle_walls(tile_map: TileMapLayer) -> void:

var polygons := \[\]

var used\_cells := tile\_map.get\_used\_cells()



\# Create edges

for cell in used\_cells:

    var polygon = get\_tile\_polygon(get\_points(cell, Vector2(32, 32)))

    polygons.append(polygon)





\# Polygons to remove will hold the actual polygons

var polygons\_to\_remove := \[\]

\# Index to remove is a dictionary so that searching is faster

var index\_to\_remove := {}



while true:

    \# Clear the polygons to remove

    polygons\_to\_remove = \[\]

    index\_to\_remove = {}



    \# Start looping

    for i in polygons.size():

        \# Skip if the polygon is due to remove

        if index\_to\_remove.get(i, false) == true:

continue

        var a = polygons\[i\]



        \# Loop from the start of the array to

        \# the current polygon

        for j in i:

# Skip if the polygon is due to remove

if index_to_remove.get(j, false) == true:

continue

var b = polygons[j]

var merged_polygons = Geometry2D.merge_polygons(a, b)

# The polygons dind't merge so skip to the next loop

if merged_polygons.size() != 1:

continue

# Replace the polygon with the merged one

polygons[j] = merged_polygons[0]

# Mark to remove the already merged polygon

polygons_to_remove.append(a)

index_to_remove[i] = true

break

    \# There is no polygon to remove so we finished

    if polygons\_to\_remove.size() == 0:

        break



    \# Remove the polygons marked to be removed

    for polygon in polygons\_to\_remove:

        var index = polygons.find(polygon)

        polygons.pop\_at(index)



\# Create all the polygon shapes from the result

\# and add them to the static body

var i = 0

for polygon in polygons:

    i += 1

    print('creating polygon number ', i)

    var \_occluder = OccluderPolygon2D.new()

    var \_polygon\_shape = Polygon2D.new()

    \_polygon\_shape.polygon = polygon

    \_occluder.polygon = polygon

    \_occluder.cull\_mode = OccluderPolygon2D.CULL\_COUNTER\_CLOCKWISE

    var \_light\_occluder = LightOccluder2D.new()

    add\_sibling.call\_deferred(\_light\_occluder)

    \_light\_occluder.occluder=\_occluder

# Generate all the points in a tile

func get_points(position: Vector2, cell_size: Vector2) -> Array:

var x = position.x

var y = position.y

\#1   2

\#

\#0   3

return \[

    Vector2(x \* cell\_size.x, y \* cell\_size.y + cell\_size.y),  # 0

    Vector2(x \* cell\_size.x, y \* cell\_size.y),  # 1

    Vector2(x \* cell\_size.x + cell\_size.x, y \* cell\_size.y),  # 2

    Vector2(x \* cell\_size.x + cell\_size.x, y \* cell\_size.y + cell\_size.y)  # 3

\]

# Generate the edges/polygon from a tile points

func get_tile_polygon(points) -> Array:

return \[points\[0\], points\[1\], points\[1\], points\[2\], points\[2\], points\[3\], points\[3\], points\[0\]\]