dolphin/Source/Plugins/Plugin_VideoDX9/Src/D3DBase.cpp

// Copyright (C) 2003 Dolphin Project.

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License 2.0 for more details.

// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/

// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/

#include "D3DBase.h"
#include "Render.h"
#include "XFStructs.h"

namespace D3D
{

LPDIRECT3D9        D3D = NULL; // Used to create the D3DDevice
LPDIRECT3DDEVICE9  dev = NULL; // Our rendering device
LPDIRECT3DSURFACE9 backBuffer;
D3DCAPS9 caps;
HWND hWnd;

static bool fullScreen = false;
static bool nextFullScreen = false;
static int multisample;
static int resolution;
static int xres, yres;

#define VENDOR_NVIDIA 4318
#define VENDOR_ATI    4098

static bool bFrameInProgress = false;

#define MAX_ADAPTERS 4
static Adapter adapters[MAX_ADAPTERS];
static int numAdapters;
static int cur_adapter;

// Value caches for state filtering
const int MaxTextureStages = 9;
const int MaxRenderStates = 210;
const DWORD MaxTextureTypes = 33;
const DWORD MaxSamplerSize = 13;
const DWORD MaxSamplerTypes = 15;
static DWORD m_RenderStates[MaxRenderStates+46];
static DWORD m_TextureStageStates[MaxTextureStages][MaxTextureTypes];
static DWORD m_SamplerStates[MaxSamplerSize][MaxSamplerTypes];
LPDIRECT3DBASETEXTURE9 m_Textures[16];

void Enumerate();

int GetNumAdapters() { return numAdapters; }
const Adapter &GetAdapter(int i) { return adapters[i]; }
const Adapter &GetCurAdapter() { return adapters[cur_adapter]; }

HRESULT Init()
{
	// Create the D3D object, which is needed to create the D3DDevice.
	D3D = Direct3DCreate9(D3D_SDK_VERSION);
	if (!D3D)
		return E_FAIL;
	Enumerate();
	return S_OK;
}

void Shutdown()
{
	D3D->Release();
	D3D = 0;
}

void EnableAlphaToCoverage()
{
	// Each vendor has their own specific little hack.
	if (GetCurAdapter().ident.VendorId == VENDOR_ATI)
		D3D::SetRenderState(D3DRS_POINTSIZE, (D3DFORMAT)MAKEFOURCC('A', '2', 'M', '1'));
	else
		D3D::SetRenderState(D3DRS_ADAPTIVETESS_Y, (D3DFORMAT)MAKEFOURCC('A', 'T', 'O', 'C'));			
}

	void InitPP(int adapter, int f, int aa_mode, D3DPRESENT_PARAMETERS *pp)
	{
		int FSResX = adapters[adapter].resolutions[resolution].xres; 
		int FSResY = adapters[adapter].resolutions[resolution].yres;

		ZeroMemory(pp, sizeof(D3DPRESENT_PARAMETERS));
		pp->hDeviceWindow = hWnd;
		pp->EnableAutoDepthStencil = TRUE;
		pp->AutoDepthStencilFormat = D3DFMT_D24S8;
		pp->BackBufferFormat = D3DFMT_A8R8G8B8;
		if (aa_mode >= (int)adapters[adapter].aa_levels.size())
			aa_mode = 0;

		pp->MultiSampleType = adapters[adapter].aa_levels[aa_mode].ms_setting;
		pp->MultiSampleQuality = adapters[adapter].aa_levels[aa_mode].qual_setting;
		
		pp->Flags = D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL; 
		if (fullScreen)
		{
			xres = pp->BackBufferWidth = FSResX;
			yres = pp->BackBufferHeight = FSResY;	
			pp->SwapEffect = D3DSWAPEFFECT_DISCARD;
			pp->Windowed = FALSE;
		}
		else
		{
			RECT client;
			GetClientRect(hWnd, &client);
			xres = pp->BackBufferWidth  = client.right - client.left;
			yres = pp->BackBufferHeight = client.bottom - client.top;
			pp->SwapEffect = D3DSWAPEFFECT_DISCARD;
			pp->PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
			pp->Windowed = TRUE;
		}
	}

	void Enumerate()
	{
		numAdapters = D3D::D3D->GetAdapterCount();
		for (int i = 0; i < std::min(MAX_ADAPTERS, numAdapters); i++)
		{
			Adapter &a = adapters[i];
			D3D::D3D->GetAdapterIdentifier(i, 0, &a.ident);
			bool isNvidia = a.ident.VendorId == VENDOR_NVIDIA;

			// Add multisample modes
			a.aa_levels.push_back(AALevel("None", D3DMULTISAMPLE_NONE, 0));

			DWORD qlevels = 0;
			if (D3DERR_NOTAVAILABLE != D3D::D3D->CheckDeviceMultiSampleType(
				i, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, TRUE, D3DMULTISAMPLE_2_SAMPLES, &qlevels))
				if (qlevels > 0)
					a.aa_levels.push_back(AALevel("2x MSAA", D3DMULTISAMPLE_2_SAMPLES, 0));
			
			if (D3DERR_NOTAVAILABLE != D3D::D3D->CheckDeviceMultiSampleType(
				i, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, TRUE, D3DMULTISAMPLE_2_SAMPLES, &qlevels))
				if (qlevels > 0)
					a.aa_levels.push_back(AALevel("4x MSAA", D3DMULTISAMPLE_4_SAMPLES, 0));

			if (D3DERR_NOTAVAILABLE != D3D::D3D->CheckDeviceMultiSampleType(
				i, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, TRUE, D3DMULTISAMPLE_8_SAMPLES, &qlevels))
				if (qlevels > 0)
					a.aa_levels.push_back(AALevel("8x MSAA", D3DMULTISAMPLE_8_SAMPLES, 0));

			if (isNvidia)
			{
				// CSAA support
				if (D3DERR_NOTAVAILABLE != D3D::D3D->CheckDeviceMultiSampleType(
					i, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, TRUE, D3DMULTISAMPLE_4_SAMPLES, &qlevels))
				{
					if (qlevels > 2)
					{
						// 8x, 8xQ are available
						// See http://developer.nvidia.com/object/coverage-sampled-aa.html
						a.aa_levels.push_back(AALevel("8x CSAA", D3DMULTISAMPLE_4_SAMPLES, 2));
						a.aa_levels.push_back(AALevel("8xQ CSAA", D3DMULTISAMPLE_8_SAMPLES, 0));
					}
				}
				if (D3DERR_NOTAVAILABLE != D3D::D3D->CheckDeviceMultiSampleType(
					i, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, TRUE, D3DMULTISAMPLE_8_SAMPLES, &qlevels)) 
				{
					if (qlevels > 2)
					{
						// 16x, 16xQ are available
						// See http://developer.nvidia.com/object/coverage-sampled-aa.html
						a.aa_levels.push_back(AALevel("16x CSAA", D3DMULTISAMPLE_4_SAMPLES, 4));
						a.aa_levels.push_back(AALevel("16xQ CSAA", D3DMULTISAMPLE_8_SAMPLES, 2));
					}
				}
			}
			if (a.aa_levels.size() == 1)
			{
				strcpy(a.aa_levels[0].name, "(Not supported on this device)");
			}
			int numModes = D3D::D3D->GetAdapterModeCount(i, D3DFMT_X8R8G8B8);
			for (int m = 0; m < numModes; m++)
			{	
				D3DDISPLAYMODE mode;
				D3D::D3D->EnumAdapterModes(i, D3DFMT_X8R8G8B8, m, &mode);
				
				int found = -1;
				for (int x = 0; x < (int)a.resolutions.size(); x++)
				{
					if (a.resolutions[x].xres == mode.Width && a.resolutions[x].yres == mode.Height)
					{
						found = x;
						break;
					}
				}

				Resolution temp;
				Resolution &r = found==-1 ? temp : a.resolutions[found];
				
				sprintf(r.name, "%ix%i", mode.Width, mode.Height);
				r.bitdepths.insert(mode.Format);
				r.refreshes.insert(mode.RefreshRate);
				if (found == -1 && mode.Width >= 640 && mode.Height >= 480)
				{
					r.xres = mode.Width;
					r.yres = mode.Height;
					a.resolutions.push_back(r);
				}
			}
		}
	}

	HRESULT Create(int adapter, HWND wnd, bool _fullscreen, int _resolution, int aa_mode)
	{
		hWnd = wnd;
		fullScreen = _fullscreen;
		nextFullScreen = _fullscreen;
		multisample = aa_mode;
		resolution = _resolution;
		cur_adapter = adapter;
		D3DPRESENT_PARAMETERS d3dpp; 
		InitPP(adapter, resolution, aa_mode, &d3dpp);

		if (FAILED(D3D->CreateDevice( 
			adapter, 
			D3DDEVTYPE_HAL, 
			wnd,
			D3DCREATE_HARDWARE_VERTEXPROCESSING,
			&d3dpp, &dev)))
		{
			MessageBoxA(wnd,
				"Sorry, but it looks like your 3D accelerator is too old,\n"
				"or doesn't support features that Dolphin requires.\n"
				"Falling back to software vertex processing.\n", 
				"Dolphin Direct3D plugin", MB_OK | MB_ICONERROR);
			if (FAILED(D3D->CreateDevice( 
				adapter, 
				D3DDEVTYPE_HAL, 
				wnd,
				D3DCREATE_SOFTWARE_VERTEXPROCESSING | D3DCREATE_MULTITHREADED,
				// |D3DCREATE_MULTITHREADED /* | D3DCREATE_PUREDEVICE*/,
				//D3DCREATE_SOFTWARE_VERTEXPROCESSING ,
				&d3dpp, &dev)))
			{
				MessageBoxA(wnd,
					"Software VP failed too. Upgrade your graphics card.", 
					"Dolphin Direct3D plugin", MB_OK | MB_ICONERROR);
				return E_FAIL;
			}
		}
		dev->GetDeviceCaps(&caps);
		dev->GetRenderTarget(0, &backBuffer);

		// Device state would normally be set here
		return S_OK;
	}

	void Close()
	{
		dev->Release(); 
		dev = 0;
	}

const D3DCAPS9 &GetCaps()
{
	return caps;
}

const char *VertexShaderVersionString()
{
	static const char *versions[5] = {"ERROR", "vs_1_4", "vs_2_0", "vs_3_0", "vs_4_0"};
	int version = ((D3D::caps.VertexShaderVersion >> 8) & 0xFF);
	return versions[std::min(4, version)];
}

const char *PixelShaderVersionString()
{
	static const char *versions[5] = {"ERROR", "ps_1_4", "ps_2_0", "ps_3_0", "ps_4_0"};
	int version = ((D3D::caps.PixelShaderVersion >> 8) & 0xFF);
	return versions[std::min(4, version)];
}

LPDIRECT3DSURFACE9 GetBackBufferSurface()
{
	return backBuffer;
}

void ShowD3DError(HRESULT err)
{
	switch (err) 
	{
	case D3DERR_DEVICELOST: PanicAlert("Device Lost"); break;
	case D3DERR_INVALIDCALL: PanicAlert("Invalid Call"); break;
	case D3DERR_DRIVERINTERNALERROR: PanicAlert("Driver Internal Error"); break;
	case D3DERR_OUTOFVIDEOMEMORY: PanicAlert("Out of vid mem"); break;
	default:
		// MessageBoxA(0,"Other error or success","ERROR",0);
		break;
	}
}

	void Reset()
	{
		if (dev)
		{
			D3DPRESENT_PARAMETERS d3dpp; 
			InitPP(cur_adapter, resolution, multisample, &d3dpp);
			HRESULT hr = dev->Reset(&d3dpp);
			ShowD3DError(hr);
		}
	}

	bool IsFullscreen()
	{
		return fullScreen;
	}

	int GetDisplayWidth()
	{
		return xres;
	}

	int GetDisplayHeight()
	{
		return yres;
	}

	void SwitchFullscreen(bool fullscreen)
	{
		nextFullScreen = fullscreen;
	}

	bool BeginFrame(bool clear, u32 color, float z)
	{
		if (bFrameInProgress)
		{
			PanicAlert("BeginFrame WTF");
			return false;
		}
		bFrameInProgress = true;
		if (dev)
		{
			if (clear)
				dev->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL, (DWORD)color, z, 0 );
			dev->BeginScene();
			return true;
		}
		else 
			return false;
	}

	void EndFrame()
	{
		if (!bFrameInProgress)
		{
			PanicAlert("EndFrame WTF");
			return;
		}
		bFrameInProgress = false;

		if (dev)
		{
			dev->EndScene();
			dev->Present(NULL, NULL, NULL, NULL);
		}

		if (fullScreen != nextFullScreen)
		{
			fullScreen = nextFullScreen;
			Reset();
		}
	}

void SetTexture(DWORD Stage, LPDIRECT3DBASETEXTURE9 pTexture)
{
	if (m_Textures[Stage] != pTexture)
	{
		m_Textures[Stage] = pTexture;
		D3D::dev->SetTexture(Stage, pTexture);
	}
}

void SetRenderState(D3DRENDERSTATETYPE State, DWORD Value)
{
	if (m_RenderStates[State] != Value)
	{
		m_RenderStates[State] = Value;
		D3D::dev->SetRenderState(State, Value);
	}
}

void SetTextureStageState(DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value)
{
	if (m_TextureStageStates[Stage][Type] != Value)
	{
		m_TextureStageStates[Stage][Type] = Value;
		D3D::dev->SetTextureStageState(Stage, Type, Value);
	}
}

void SetSamplerState(DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value)
{
	if (m_SamplerStates[Sampler][Type] != Value)
	{
		m_SamplerStates[Sampler][Type] = Value;
		D3D::dev->SetSamplerState(Sampler, Type, Value);
	}
}

}  // namespace