Toggle MSAA

#define ANTI_ALIASING

#include "EterBase/Debug.h"

#ifdef ANTI_ALIASING
#include "../UserInterface/PythonSystem.h"
#endif

#include <intrin.h>

bool CGraphicDevice::Reset()
{
    HRESULT hr;

#ifdef ANTI_ALIASING

    ms_d3dPresentParameter.MultiSampleType = D3DMULTISAMPLE_NONE;
    ms_d3dPresentParameter.MultiSampleQuality = 0;

    if (CPythonSystem::Instance().IsMSAAEnable())
    {

        D3DDISPLAYMODE d3dDisplayMode;
        ms_lpd3d->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3dDisplayMode);
        D3DFORMAT msaaCheckFormat = ms_d3dPresentParameter.Windowed ? d3dDisplayMode.Format : ms_d3dPresentParameter.BackBufferFormat;

        if (SUCCEEDED(ms_lpd3d->CheckDeviceMultiSampleType(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, msaaCheckFormat, ms_d3dPresentParameter.Windowed, D3DMULTISAMPLE_8_SAMPLES, &ms_d3dPresentParameter.MultiSampleQuality)))
        {
            ms_d3dPresentParameter.MultiSampleType = D3DMULTISAMPLE_8_SAMPLES;
            ms_d3dPresentParameter.MultiSampleQuality = 0;
        }
    }
#endif

    if (FAILED(hr = ms_lpd3dDevice->Reset(&ms_d3dPresentParameter)))
        return false;

    if (m_pStateManager)
        m_pStateManager->SetDefaultState();

    return true;
}

    ms_d3dPresentParameter.EnableAutoDepthStencil            = TRUE;
    ms_d3dPresentParameter.AutoDepthStencilFormat            = D3DFMT_D24S8;

#ifdef ANTI_ALIASING
    if (CPythonSystem::Instance().IsMSAAEnable() && !disableMSAA)
    {
        D3DFORMAT msaaCheckFormat = Windowed ? d3dDisplayMode.Format : ms_d3dPresentParameter.BackBufferFormat;
       
        if (SUCCEEDED(ms_lpd3d->CheckDeviceMultiSampleType(
            D3DADAPTER_DEFAULT,
            D3DDEVTYPE_HAL,
            msaaCheckFormat,
            Windowed,
            D3DMULTISAMPLE_8_SAMPLES,
            &ms_d3dPresentParameter.MultiSampleQuality)))
        {
            ms_d3dPresentParameter.MultiSampleType = D3DMULTISAMPLE_8_SAMPLES;
            ms_d3dPresentParameter.MultiSampleQuality = 0;
        }
        else if (SUCCEEDED(ms_lpd3d->CheckDeviceMultiSampleType(
            D3DADAPTER_DEFAULT,
            D3DDEVTYPE_HAL,
            msaaCheckFormat,
            Windowed,
            D3DMULTISAMPLE_4_SAMPLES,
            &ms_d3dPresentParameter.MultiSampleQuality)))
        {
            ms_d3dPresentParameter.MultiSampleType = D3DMULTISAMPLE_4_SAMPLES;
            ms_d3dPresentParameter.MultiSampleQuality = 0;
        }
    }
#else
    if (!Windowed && !disableMSAA)
    {
        D3DFORMAT msaaCheckFormat = ms_d3dPresentParameter.BackBufferFormat;
        if (SUCCEEDED(ms_lpd3d->CheckDeviceMultiSampleType(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, msaaCheckFormat, FALSE, D3DMULTISAMPLE_2_SAMPLES, &ms_d3dPresentParameter.MultiSampleQuality)))
        {
            ms_d3dPresentParameter.MultiSampleType = D3DMULTISAMPLE_2_SAMPLES;
            ms_d3dPresentParameter.MultiSampleQuality = 0;
        }
        if (SUCCEEDED(ms_lpd3d->CheckDeviceMultiSampleType(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, msaaCheckFormat, FALSE, D3DMULTISAMPLE_4_SAMPLES, &ms_d3dPresentParameter.MultiSampleQuality)))
        {
            ms_d3dPresentParameter.MultiSampleType = D3DMULTISAMPLE_4_SAMPLES;
            ms_d3dPresentParameter.MultiSampleQuality = 0;
        }
    }
#endif

    D3DDISPLAYMODEEX displayModeEx;
    ZeroMemory(&displayModeEx, sizeof(displayModeEx));

CStateManager::CStateManager(LPDIRECT3DDEVICE9EX lpDevice) : m_lpD3DDev(NULL)
{
    m_bScene = false;

#ifdef ANTI_ALIASING
    m_bMSAAEnabled = true;
#endif

    m_dwBestMinFilter = D3DTEXF_ANISOTROPIC;
    m_dwBestMagFilter = D3DTEXF_ANISOTROPIC;

    SaveVertexProcessing(FALSE);
    SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);

#ifdef ANTI_ALIASING
    SetRenderState(D3DRS_MULTISAMPLEANTIALIAS, m_bMSAAEnabled ? TRUE : FALSE);
#else
    SetRenderState(D3DRS_MULTISAMPLEANTIALIAS, TRUE);
#endif

    SetRenderState(D3DRS_MULTISAMPLEMASK, 0xFFFFFFFF);
    SetRenderState(D3DRS_PATCHEDGESTYLE, D3DPATCHEDGE_CONTINUOUS);

    m_lpD3DDev->SetIndices(pIndexData);
    m_CurrentState.m_IndexData = kIndexData;
}

#ifdef ANTI_ALIASING
void CStateManager::SetMSAAOption(bool bEnable)
{
    m_bMSAAEnabled = bEnable;

    SetRenderState(D3DRS_MULTISAMPLEANTIALIAS, bEnable ? TRUE : FALSE);
}
#endif

HRESULT CStateManager::DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount)
{

    void StateManager_Capture();
    void StateManager_Apply();

    LPDIRECT3DDEVICE9EX GetDevice();

#ifdef _DEBUG
    void ResetDrawCallCounter();
    int GetDrawCallCount() const;
#endif

#ifdef ANTI_ALIASING
    void SetMSAAOption(bool bEnable);
#endif

private:
    void SetDevice(LPDIRECT3DDEVICE9EX lpDevice);

    bool                m_bForce;
    bool                m_bScene;

#ifdef ANTI_ALIASING
    bool                m_bMSAAEnabled;
#endif

    DWORD                m_dwBestMinFilter;
    DWORD                m_dwBestMagFilter;

void CPythonApplication::SetForceSightRange(int iRange)
{
    m_iForceSightRange = iRange;
}

#ifdef ANTI_ALIASING
void CPythonApplication::ResetDevice()
{
    m_grpDevice.Reset();
}
#endif

void CPythonApplication::Clear()
{
    m_pySystem.Clear();
}

class CPythonApplication : public CMSApplication, public CInputKeyboard, public IAbstractApplication
{
    public:

    #ifdef ANTI_ALIASING
        void ResetDevice();
    #endif

        enum EDeviceState
        {
            DEVICE_STATE_FALSE,
            DEVICE_STATE_SKIP,
            DEVICE_STATE_OK,
        };

    m_Config.bShowDamage        = true;
    m_Config.bShowSalesText        = true;

#ifdef ANTI_ALIASING
    m_Config.bMSAA = true;
#endif
}

bool CPythonSystem::IsWindowed()
{
    return m_Config.bWindowed;
}

        else if (!stricmp(command, "SHOW_DAMAGE"))
            m_Config.bShowDamage = atoi(value) == 1 ? true : false;
        else if (!stricmp(command, "SHOW_SALESTEXT"))
            m_Config.bShowSalesText = atoi(value) == 1 ? true : false;

#ifdef ANTI_ALIASING
        else if (!stricmp(command, "MSAA"))
        {
            m_Config.bMSAA = atoi(value) == 1 ? true : false;
            continue;
        }
#endif
    }

    if (m_Config.bWindowed)
    {

    fprintf(fp, "SHADOW_LEVEL            %d\n", m_Config.iShadowLevel);
    fprintf(fp, "FOG_LEVEL                %d\n", m_Config.iFogLevel);

#ifdef ANTI_ALIASING
    fprintf(fp, "MSAA\t\t%d\n", m_Config.bMSAA ? 1 : 0);
#endif

    fprintf(fp, "\n");

    fclose(fp);
    return true;
}

void CPythonSystem::Clear()
{
    SetInterfaceHandler(NULL);
}

#ifdef ANTI_ALIASING
void CPythonSystem::SetMSAAState(bool bEnable)
{
    if (m_Config.bMSAA == bEnable)
        return;

    m_Config.bMSAA = bEnable;

    CPythonApplication::Instance().ResetDevice();
}

bool CPythonSystem::IsMSAAEnable()
{
    return m_Config.bMSAA;
}
#endif

CPythonSystem::CPythonSystem()
{

            bool            bShowDamage;
            bool            bShowSalesText;

#ifdef ANTI_ALIASING
            bool            bMSAA;
#endif
        } TConfig;

    public:
        CPythonSystem();

        TConfig *                        GetConfig();
        void                            ChangeSystem();

#ifdef ANTI_ALIASING
        void                            SetMSAAState(bool bEnable);
        bool                            IsMSAAEnable();
#endif

        bool                            LoadInterfaceStatus();
        void                            SaveInterfaceStatus();

#include "StdAfx.h"
#include "PythonSystem.h"

#ifdef ANTI_ALIASING
#include "../EterLib/StateManager.h"
#endif

PyObject * systemGetWidth(PyObject* poSelf, PyObject* poArgs)
{
    return Py_BuildValue("i", CPythonSystem::Instance().GetWidth());
}

    CPythonSystem::Instance().SetFogLevel(iLevel);
    return Py_BuildNone();
}

#ifdef ANTI_ALIASING
PyObject* systemSetMSAAState(PyObject* poSelf, PyObject* poArgs)
{
    int iEnable;
    if (!PyArg_ParseTuple(poArgs, "i", &iEnable))
        return Py_BuildException();

    CStateManager::Instance().SetMSAAOption(iEnable ? true : false);

    CPythonSystem::Instance().SetMSAAState(iEnable ? true : false);

    return Py_BuildNone();
}

PyObject* systemIsMSAAEnable(PyObject* poSelf, PyObject* poArgs)
{
    return Py_BuildValue("i", CPythonSystem::Instance().IsMSAAEnable() ? 1 : 0);
}
#endif

void initsystem()
{

        { "GetShadowLevel",                systemGetShadowLevel,            METH_VARARGS },
        { "SetShadowLevel",                systemSetShadowLevel,            METH_VARARGS },

#ifdef ANTI_ALIASING
        { "SetMSAAState",               systemSetMSAAState,             METH_VARARGS },
        { "IsMSAAEnable",               systemIsMSAAEnable,             METH_VARARGS },
#endif

        { NULL,                            NULL,                            NULL }
    };

    PyObject * poModule = Py_InitModule("systemSetting", s_methods);

    PyModule_AddIntConstant(poModule, "WINDOW_STATUS",        CPythonSystem::WINDOW_STATUS);