Changing window transparency using P/Invoke

Question

I'm having problems with changing a window's transparency.

What I'm trying to accomplish

I develop a WPF application, which has some interaction with another application (a game developed in Unity3D). My goal is to "integrate" the game into my WPF app to make it look like the game is a natural part of the WPF app. So when I move my main window, I use PInvoke to move the game's window, too, I use PInvoke to hide the window borders of the game window etc. This all works decently.

However, a problem arises when I try to hide the game without closing it. My first approach was to use PInvoke to set the game window as hidden:

[DllImport("user32.dll")]
static extern bool ShowWindow(IntPtr hwnd, int show);

const int SW_HIDE = 0;
const int SW_Show = 5;

ShowWindow(Handle, SW_HIDE);

Using this function call the window disappeares, but as a consequence, the CPU usage of the game process jumps from 1% to 20%. So far, I have no clue why that is. Maybe it's related to Unity, maybe not. (CPU goes back to normal when I show the window again, though).

My second approach was not to hide the window using the ShowWindow-call but to set the window's opacity to 0 (as suggested in this thread). On my setup, this works just fine (without the CPU going crazy), but on other setups, the window will stay visible.

Updating the graphics driver solves the issue sometimes, but not always. I have an old Vista machine where everything works, and I also tried it on newer Dell Laptops with Windows 10 installed, where it does not work. I don't have the issue on my Mac with Windows 10 and Boot Camp. So I have no clue what causes this problem.

Did anyone experience similiar issues? Is there another way to hide a window or does anyone know why CPU goes insane when using the ShowWindow()-method?

Any hint is much appreciated.

EDIT

Would be nice to know why this post is downvoted so much, but okay. I think especially the CPU usage thing is an interesting issue and I am terribly sorry if someone thinks it's obvious and I am a moron.

For those who are also interested, here is a minimal WPF reconstruction of my problem:

MainWindow.xaml

<Window x:Class="SampleWpfApp.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="MainWindow" Height="1024" Width="1280"
    KeyDown="MainWindow_OnKeyDown">
<Grid>
</Grid>
</Window>

MainWindow.xaml.cs

public partial class MainWindow : Window
{
    const int SW_HIDE = 0;
    const int SW_SHOW = 5;

    private Process gameProcess;
    private IntPtr gameWindowHandle;

    private bool windowHidden = false;

    public MainWindow()
    {
        InitializeComponent();

        this.SizeChanged += OnSizeChanged;
    }

    private void OnSizeChanged(object sender, SizeChangedEventArgs e)
    {
        StartGame();
    }

    private void MainWindow_OnKeyDown(object sender, KeyEventArgs e)
    {
        if (e.Key == Key.Space)
        {
            if (windowHidden)
            {
                NativeMethods.ShowWindow(gameWindowHandle, SW_HIDE);
                windowHidden = false;
            }
            else
            {
                NativeMethods.ShowWindow(gameWindowHandle, SW_SHOW);
                windowHidden = true;
            }
        }
    }

    private void StartGame()
    {
        var mainWindowHandle = new  WindowInteropHelper(this).Handle;
        var processStartInfo = new ProcessStartInfo(@"Path\To\SampleUnityApp.exe");
        processStartInfo.Arguments += "-parentHWND " + mainWindowHandle.ToInt32() + " " + Environment.CommandLine + " ";
        processStartInfo.CreateNoWindow = true;
        processStartInfo.UseShellExecute = false;

        gameProcess = Process.Start(processStartInfo);
        gameProcess.WaitForInputIdle();

        NativeMethods.EnumChildWindows(mainWindowHandle,
            (hwnd, lparam) =>
            {
                // Set the window handle of the game
                gameWindowHandle = hwnd;
                return 0;
            }, IntPtr.Zero);
    }

    static class NativeMethods
    {

        [DllImport("user32.dll")]
        internal static extern bool ShowWindow(IntPtr hwnd, int show);

        [DllImport("user32.dll")]
        internal static extern bool EnumChildWindows(IntPtr hwnd, WindowEnumProc func, IntPtr lParam);

        internal delegate int WindowEnumProc(IntPtr hwnd, IntPtr lparam);
    }
}

The SampleUnityApp I used is just a blank Unity project with a main camera. No other game object. No code I wrote. It's created with Unity 5.3.4f1 Personal.

Screenshot of TaskManager with window visible

Screenshot of TaskManager with window hidden