Ways of replace Managed DirectX?

Question

i have a some problem with my old project... if short - "using Microsoft.DirectX". They deprecated, and nowadays, i run my game on new PC and got various glitches & troubles, that not exists before anyways. As they deprecated and not supported anymore, I am looking for solution for good way of replace gfx engine without lose all my application code. For example, old XNA projects can be ported to MonoGame or FNA without general changes on their architecture, i need do it same way. Here any framework close to managed directX by API without many pain for port them? SharpDX? SlimDX? Any other? (I dont have expirience with SharpDX or SlimDX before)

Here the some snippet about my GFX code, just for imagine how it is. Them based on Managed DirectX.

public bool InitD3D(ref Form frmForm)
{
    PresentParameters uParms = null;
    bool bRes = false;

    mfrmMain = frmForm;

    Constants.gSettings.LoadSettings();

    //Debug.WriteLine("InitD3D in thread: " & Threading.Thread.CurrentThread.ManagedThreadId.ToString)

    try {
        CreateFlags lCreateFlags = default(CreateFlags);
        bool bReduced = false;
        uParms = CreatePresentationParams(mfrmMain);
        if (uParms == null)
            return false;

        lCreateFlags = (CreateFlags)Constants.gSettings.VertexProcessing;

        if (lCreateFlags != CreateFlags.HardwareVertexProcessing && lCreateFlags != CreateFlags.MixedVertexProcessing && lCreateFlags != CreateFlags.SoftwareVertexProcessing) {
            lCreateFlags = CreateFlags.HardwareVertexProcessing;
        }

        Caps uDevCaps = Manager.GetDeviceCaps(Manager.Adapters.Default.Adapter, DeviceType.Hardware);
        if (uDevCaps.DeviceCaps.SupportsHardwareTransformAndLight == false) {
            if (lCreateFlags == CreateFlags.HardwareVertexProcessing) {
                lCreateFlags = CreateFlags.SoftwareVertexProcessing;
                bReduced = true;
            }
        }

        try {
            gfxDevice = new Device(0, DeviceType.Hardware, frmForm.Handle, lCreateFlags, uParms);
        } catch {
            bReduced = true;
            if ((lCreateFlags & CreateFlags.HardwareVertexProcessing) == CreateFlags.HardwareVertexProcessing) {
                lCreateFlags = (lCreateFlags ^ CreateFlags.HardwareVertexProcessing) | CreateFlags.MixedVertexProcessing;
                try {
                    gfxDevice = new Device(0, DeviceType.Hardware, frmForm.Handle, lCreateFlags, uParms);
                } catch {
                    lCreateFlags = (lCreateFlags ^ CreateFlags.MixedVertexProcessing) | CreateFlags.SoftwareVertexProcessing;
                    try {
                        gfxDevice = new Device(0, DeviceType.Hardware, frmForm.Handle, lCreateFlags, uParms);
                    } catch (Exception ex) {
                        Interaction.MsgBox("Game will not run on this computer because the video hardware is not sufficient.", MsgBoxStyle.OkOnly, "Error");
                        System.Environment.Exit(0);
                    }
                }
            } else if ((lCreateFlags & CreateFlags.MixedVertexProcessing) == CreateFlags.MixedVertexProcessing) {
                lCreateFlags = (lCreateFlags ^ CreateFlags.MixedVertexProcessing) | CreateFlags.SoftwareVertexProcessing;
                try {
                    gfxDevice = new Device(0, DeviceType.Hardware, frmForm.Handle, lCreateFlags, uParms);
                } catch (Exception ex) {
                    Interaction.MsgBox("Game will not run on this computer because the video hardware is not sufficient.", MsgBoxStyle.OkOnly, "Error");
                    System.Environment.Exit(0);
                }
            }
        }

        if (bReduced == true)
            Interaction.MsgBox("Game was required to alter settings that will affect performance in order to run the game.", MsgBoxStyle.OkOnly, "Error");
        Constants.gSettings.VertexProcessing = Convert.ToInt32(lCreateFlags);

        bRes = (gfxDevice != null);

        if (Constants.gSettings.MiniMapLocX > uParms.BackBufferWidth)
            Constants.gSettings.MiniMapLocX = uParms.BackBufferWidth - Constants.gSettings.MiniMapWidthHeight;
        if (Constants.gSettings.MiniMapLocY > uParms.BackBufferHeight)
            Constants.gSettings.MiniMapLocY = uParms.BackBufferHeight - Constants.gSettings.MiniMapWidthHeight;
    } catch {
        Interaction.MsgBox(Err().Description, MsgBoxStyle.Critical | MsgBoxStyle.OkOnly, "Error in initialize Direct3D");
        bRes = false;
    } finally {
        uParms = null;
    }

    if (bRes == false) {
        Interaction.MsgBox("Unable to initialize Direct3D 9.0c. Your video card may not fully support DirectX 9.0c. Download the latest drivers for your video card and try again.", MsgBoxStyle.OkOnly | MsgBoxStyle.Critical, "Unable to Initialize");
        return false;
    }

    var _with8 = gfxDevice.DeviceCaps.VertexShaderVersion;
    if (_with8.Major == 1) {
        Constants.gSettings.PostGlowAmt = 0f;
        Constants.gSettings.LightQuality = EngineSettings.LightQualitySetting.VSPS1;
    }

    mbSupportsNewModelMethod = gfxDevice.DeviceCaps.TextureOperationCaps.SupportsBlendTextureAlpha == true && gfxDevice.DeviceCaps.MaxTextureBlendStages > 2 && gfxDevice.DeviceCaps.MaxSimultaneousTextures > 1;

    if (Constants.gWMgr == null)
        Constants.gWMgr = new WpnFXManager();
    if (Constants.gShldMgr == null)
        Constants.gShldMgr = new ShieldFXManager();
    if (Constants.gExplMgr == null)
        Constants.gExplMgr = new ExplosionManager();
    //  New ExplosionFXManager(gfxDevice)
    if (Constants.gPFXEngine32 == null)
        Constants.gPFXEngine32 = new BurnFX.ParticleEngine(32);
    //32 for size of points
    if (Constants.gEntityDeath == null)
        Constants.gEntityDeath = new DeathSequenceMgr();
    //If goRewards Is Nothing Then goRewards = New WarpointRewards()
    if (Constants.gMissileMgr == null)
        Constants.gMissileMgr = new MissileMgr();
    if (Constants.gBurnMarkMgr == null)
        Constants.gBurnMarkMgr = new EntityBurnMarkManager();

    Constants.InitializeFXColors();

    var _with9 = matIronCurtain;
    _with9.Emissive = System.Drawing.Color.FromArgb(255, 255, 0, 0);
    _with9.Diffuse = System.Drawing.Color.FromArgb(255, 255, 0, 0);
    _with9.Ambient = System.Drawing.Color.FromArgb(255, 255, 0, 0);
    _with9.Specular = System.Drawing.Color.FromArgb(255, 255, 0, 0);
    _with9.SpecularSharpness = 10;


    gfxDevice.DeviceLost += gfxDevice_DeviceLost;
    gfxDevice.DeviceReset += gfxDevice_DeviceReset;
    gfxDevice.Disposing += gfxDevice_Disposing;

    mbInitialized = bRes;

    return bRes;
}

Answer 1

For a direct port of existing legacy Managed DirectX 1.1 C# code, SlimDX is probably your best bet as it's intended to be a direct replacement. You can also potentially port to using SharpDX, MonoGame, Unity3D, or some other framework as well.

See DirectX and .NET