You should make sure the animation namespace is shared correctly across the different views that participate in the animation. From your code, it appears that separate namespaces are being used in ContentView and BottomVideoView, which might be causing the issue with the animation not working as expected.

The namespace used for the matched geometry effect should be declared in a common ancestor view and passed down to all child views that need it. That way, the same animation namespace is used across your views.
The ID used with .matchedGeometryEffect (as described in "How to synchronize animations from one view to another with matchedGeometryEffect()" from Paul Hudson) needs to be consistent across both views participating in the animation. It looks like you are using popRoot.playID, which should work as long as it is correctly set before the animation starts.

Your TopVideoView uses a UIHostingController to present the video player, which might complicate the matched geometry effect. SwiftUI animations work best within the SwiftUI view hierarchy, so consider integrating the TopVideo directly into the SwiftUI view hierarchy instead of adding it over a window.

class PopToRoot: ObservableObject { // Environment object accessible anywhere
    @Published var player: AVPlayer? = nil
    @Published var playID: String = ""
}

struct ContentView: View { // Top of the view hierarchy
    @EnvironmentObject var popRoot: PopToRoot
    @Namespace private var animationNamespace

    var body: some View {
        ZStack {
            SomeView(animation: animationNamespace)
            
            if popRoot.player != nil {
                TopVideo(player: $popRoot.player)
                    .matchedGeometryEffect(id: popRoot.playID, in: animationNamespace)
                    .ignoresSafeArea()
            }
        }
    }
}

struct SomeView: View { // Subview
    let example = "example URL"
    var animation: Namespace.ID

    var body: some View {
        ScrollView {
            BottomVideoView(url: URL(string: example)!, animation: animation)
            // Additional views
        }
    }
}

struct BottomVideoView: View {
    @EnvironmentObject var popRoot: PopToRoot
    let url: URL
    var animation: Namespace.ID
    @State var player: AVPlayer? = nil

    var body: some View {
        ZStack {
            if let vid = player {
                VidPlayer(player: vid)
                    .matchedGeometryEffect(id: url.absoluteString, in: animation)
                    .onTapGesture {
                        withAnimation {
                            popRoot.playID = url.absoluteString
                            popRoot.player = player
                        }
                    }
            }
        }
        .onAppear {
            if player == nil {
                player = AVPlayer(url: url)
                self.player?.play()
            }
        }
    }
}

// No changes needed for VidPlayer and TopVideo

The animationNamespace is declared in ContentView and passed to SomeView and BottomVideoView. That makes sure the matched geometry effect operates within the same namespace across these views. The TopVideo view is directly integrated into the SwiftUI view hierarchy, which should help with the animation.
Make sure the environment object (PopToRoot) is correctly passed down to all views that require access to it.

I think the issue is adding the view to the window. I need this functionality though to present the video player about everything including sheets and fullscreencovers.

Matched geometry effect animations are designed to work within the SwiftUI view hierarchy, and using a UIHostingController to present a view on top of everything else complicates this.

Since the matched geometry effect relies on both views being in the same view hierarchy and this requirement conflicts with your need to present the view above everything, you might consider implementing a custom animation. You can animate the frame of the UIHostingController‘s view manually to mimic the matched geometry effect. That involves calculating the starting and ending frames and using UIView animations to transition between them.

For views within the SwiftUI hierarchy, you can use .zIndex() to manage which views are presented on top of others. While this will not help with presenting over fullscreen covers or sheets directly, it is useful for in-hierarchy presentation order management.

Instead of adding the UIHostingController‘s view to the window directly, consider creating a new UIWindow that is presented on top of your current window. That overlay window can be used exclusively for presenting the video player. That approach makes it easier to manage the video player independently of the rest of your UI and can simplify animations since you are moving a window instead of a view within a window.

To integrate this approach with SwiftUI and still trigger animations from SwiftUI views, you can use onTapGesture or similar triggers to initiate the presentation and dismissal of the overlay window. You would still use environment objects or shared state management to coordinate the data between your SwiftUI views and the video player being presented in the overlay window.

Assuming you have a method to calculate the starting and ending frames based on your UI layout, your method would be:

func presentVideoPlayerOverlay(player: AVPlayer, fromStartFrame startFrame: CGRect, toEndFrame endFrame: CGRect) {
    let swiftUIView = TopVideo(player: .constant(player))
    let hostingController = UIHostingController(rootView: swiftUIView)
    hostingController.view.frame = startFrame // Initial frame, possibly matching a SwiftUI view's frame
    
    let overlayWindow = UIWindow(frame: UIScreen.main.bounds)
    overlayWindow.rootViewController = hostingController
    overlayWindow.makeKeyAndVisible()
    
    UIView.animate(withDuration: 0.5, animations: {
        hostingController.view.frame = endFrame // Final frame, e.g., fullscreen
    }) { _ in
        // Animation completion actions if needed
    }
}

// You would call `presentVideoPlayerOverlay` with the appropriate player and frame parameters when you want to present the video player.