// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
|
//
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
// you may not use this file except in compliance with the License.
|
// You may obtain a copy of the License at
|
//
|
// http://www.apache.org/licenses/LICENSE-2.0
|
//
|
// Unless required by applicable law or agreed to in writing, software
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
// See the License for the specific language governing permissions and
|
// limitations under the License.
|
|
#include "Direct3D9Ex.hpp"
|
|
#include "Direct3DDevice9Ex.hpp"
|
#include "Debug.hpp"
|
|
namespace sw
|
{
|
extern bool postBlendSRGB;
|
}
|
|
namespace D3D9
|
{
|
Direct3D9Ex::Direct3D9Ex(int version, const HINSTANCE instance) : Direct3D9(version, instance)
|
{
|
d3d9ex = 0;
|
}
|
|
Direct3D9Ex::~Direct3D9Ex()
|
{
|
}
|
|
long Direct3D9Ex::QueryInterface(const IID &iid, void **object)
|
{
|
TRACE("const IID &iid = 0x%0.8p, void **object = 0x%0.8p", iid, object);
|
|
if(iid == IID_IDirect3D9Ex ||
|
iid == IID_IDirect3D9 ||
|
iid == IID_IUnknown)
|
{
|
AddRef();
|
*object = this;
|
|
return S_OK;
|
}
|
|
*object = 0;
|
|
return NOINTERFACE(iid);
|
}
|
|
unsigned long Direct3D9Ex::AddRef()
|
{
|
TRACE("void");
|
|
return Direct3D9::AddRef();
|
}
|
|
unsigned long Direct3D9Ex::Release()
|
{
|
TRACE("void");
|
|
return Direct3D9::Release();
|
}
|
|
long Direct3D9Ex::RegisterSoftwareDevice(void *initializeFunction)
|
{
|
TRACE("void *initializeFunction = 0x%0.8p", initializeFunction);
|
|
loadSystemD3D9ex();
|
|
if(d3d9ex)
|
{
|
return d3d9ex->RegisterSoftwareDevice(initializeFunction);
|
}
|
else
|
{
|
return INVALIDCALL();
|
}
|
}
|
|
unsigned int Direct3D9Ex::GetAdapterCount()
|
{
|
TRACE("void");
|
|
return Direct3D9::GetAdapterCount();
|
}
|
|
long Direct3D9Ex::GetAdapterIdentifier(unsigned int adapter, unsigned long flags, D3DADAPTER_IDENTIFIER9 *identifier)
|
{
|
TRACE("unsigned int adapter = %d, unsigned long flags = 0x%0.8X, D3DADAPTER_IDENTIFIER9 *identifier = 0x%0.8p", adapter, flags, identifier);
|
|
return Direct3D9::GetAdapterIdentifier(adapter, flags, identifier);
|
}
|
|
unsigned int Direct3D9Ex::GetAdapterModeCount(unsigned int adapter, D3DFORMAT format)
|
{
|
TRACE("unsigned int adapter = %d, D3DFORMAT format = %d", adapter, format);
|
|
return Direct3D9::GetAdapterModeCount(adapter, format);
|
}
|
|
long Direct3D9Ex::EnumAdapterModes(unsigned int adapter, D3DFORMAT format, unsigned int index, D3DDISPLAYMODE *mode)
|
{
|
TRACE("unsigned int adapter = %d, D3DFORMAT format = %d, unsigned int index = %d, D3DDISPLAYMODE *mode = 0x%0.8p", adapter, format, index, mode);
|
|
return Direct3D9::EnumAdapterModes(adapter, format, index, mode);
|
}
|
|
long Direct3D9Ex::GetAdapterDisplayMode(unsigned int adapter, D3DDISPLAYMODE *mode)
|
{
|
TRACE("unsigned int adapter = %d, D3DDISPLAYMODE *mode = 0x%0.8p", adapter, mode);
|
|
return Direct3D9::GetAdapterDisplayMode(adapter, mode);
|
}
|
|
long Direct3D9Ex::CheckDeviceType(unsigned int adapter, D3DDEVTYPE checkType, D3DFORMAT displayFormat, D3DFORMAT backBufferFormat, int windowed)
|
{
|
TRACE("unsigned int adapter = %d, D3DDEVTYPE checkType = %d, D3DFORMAT displayFormat = %d, D3DFORMAT backBufferFormat = %d, int windowed = %d", adapter, checkType, displayFormat, backBufferFormat, windowed);
|
|
if(checkType != D3DDEVTYPE_HAL)
|
{
|
loadSystemD3D9ex();
|
|
if(d3d9ex)
|
{
|
return d3d9ex->CheckDeviceType(adapter, checkType, displayFormat, backBufferFormat, windowed);
|
}
|
else
|
{
|
return CheckDeviceType(adapter, D3DDEVTYPE_HAL, displayFormat, backBufferFormat, windowed);
|
}
|
}
|
|
return Direct3D9::CheckDeviceType(adapter, checkType, displayFormat, backBufferFormat, windowed);
|
}
|
|
long Direct3D9Ex::CheckDeviceFormat(unsigned int adapter, D3DDEVTYPE deviceType, D3DFORMAT adapterFormat, unsigned long usage, D3DRESOURCETYPE resourceType, D3DFORMAT checkFormat)
|
{
|
TRACE("unsigned int adapter = %d, D3DDEVTYPE deviceType = %d, D3DFORMAT adapterFormat = %d, unsigned long usage = %d, D3DRESOURCETYPE resourceType = %d, D3DFORMAT checkFormat = %d", adapter, deviceType, adapterFormat, usage, resourceType, checkFormat);
|
|
if(deviceType != D3DDEVTYPE_HAL)
|
{
|
loadSystemD3D9ex();
|
|
if(d3d9ex)
|
{
|
return d3d9ex->CheckDeviceFormat(adapter, deviceType, adapterFormat, usage, resourceType, checkFormat);
|
}
|
else
|
{
|
return CheckDeviceFormat(adapter, D3DDEVTYPE_HAL, adapterFormat, usage, resourceType, checkFormat);
|
}
|
}
|
|
return Direct3D9::CheckDeviceFormat(adapter, deviceType, adapterFormat, usage, resourceType, checkFormat);
|
}
|
|
long Direct3D9Ex::CheckDeviceMultiSampleType(unsigned int adapter, D3DDEVTYPE deviceType, D3DFORMAT surfaceFormat, int windowed, D3DMULTISAMPLE_TYPE multiSampleType, unsigned long *qualityLevels)
|
{
|
TRACE("unsigned int adapter = %d, D3DDEVTYPE deviceType = %d, D3DFORMAT surfaceFormat = %d, int windowed = %d, D3DMULTISAMPLE_TYPE multiSampleType = %d, unsigned long *qualityLevels = 0x%0.8p", adapter, deviceType, surfaceFormat, windowed, multiSampleType, qualityLevels);
|
|
if(deviceType != D3DDEVTYPE_HAL)
|
{
|
loadSystemD3D9ex();
|
|
if(d3d9ex)
|
{
|
return d3d9ex->CheckDeviceMultiSampleType(adapter, deviceType, surfaceFormat, windowed, multiSampleType, qualityLevels);
|
}
|
else
|
{
|
return CheckDeviceMultiSampleType(adapter, D3DDEVTYPE_HAL, surfaceFormat, windowed, multiSampleType, qualityLevels);
|
}
|
}
|
|
return Direct3D9::CheckDeviceMultiSampleType(adapter, deviceType, surfaceFormat, windowed, multiSampleType, qualityLevels);
|
}
|
|
long Direct3D9Ex::CheckDepthStencilMatch(unsigned int adapter, D3DDEVTYPE deviceType, D3DFORMAT adapterFormat, D3DFORMAT renderTargetFormat, D3DFORMAT depthStencilFormat)
|
{
|
TRACE("unsigned int adapter = %d, D3DDEVTYPE deviceType = %d, D3DFORMAT adapterFormat = %d, D3DFORMAT renderTargetFormat = %d, D3DFORMAT depthStencilFormat = %d", adapter, deviceType, adapterFormat, renderTargetFormat, depthStencilFormat);
|
|
return Direct3D9::CheckDepthStencilMatch(adapter, deviceType, adapterFormat, renderTargetFormat, depthStencilFormat);
|
}
|
|
long Direct3D9Ex::CheckDeviceFormatConversion(unsigned int adapter, D3DDEVTYPE deviceType, D3DFORMAT sourceFormat, D3DFORMAT targetFormat)
|
{
|
TRACE("unsigned int adapter = %d, D3DDEVTYPE deviceType = %d, D3DFORMAT sourceFormat = %d, D3DFORMAT targetFormat = %d", adapter, deviceType, sourceFormat, targetFormat);
|
|
if(deviceType != D3DDEVTYPE_HAL)
|
{
|
loadSystemD3D9ex();
|
|
if(d3d9ex)
|
{
|
return d3d9ex->CheckDeviceFormatConversion(adapter, deviceType, sourceFormat, targetFormat);
|
}
|
else
|
{
|
return CheckDeviceFormatConversion(adapter, D3DDEVTYPE_HAL, sourceFormat, targetFormat);
|
}
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3D9Ex::GetDeviceCaps(unsigned int adapter, D3DDEVTYPE deviceType, D3DCAPS9 *capabilities)
|
{
|
TRACE("unsigned int adapter = %d, D3DDEVTYPE deviceType = %d, D3DCAPS9 *capabilities = 0x%0.8p", adapter, deviceType, capabilities);
|
|
if(deviceType != D3DDEVTYPE_HAL)
|
{
|
loadSystemD3D9ex();
|
|
if(d3d9ex)
|
{
|
return d3d9ex->GetDeviceCaps(adapter, deviceType, capabilities);
|
}
|
else
|
{
|
return GetDeviceCaps(adapter, D3DDEVTYPE_HAL, capabilities);
|
}
|
}
|
|
long result = Direct3D9::GetDeviceCaps(adapter, deviceType, capabilities);
|
|
if(sw::postBlendSRGB)
|
{
|
capabilities->PrimitiveMiscCaps |= D3DPMISCCAPS_POSTBLENDSRGBCONVERT; // Indicates device can perform conversion to sRGB after blending.
|
}
|
|
return result;
|
}
|
|
HMONITOR Direct3D9Ex::GetAdapterMonitor(unsigned int adapter)
|
{
|
TRACE("unsigned int adapter = %d", adapter);
|
|
return Direct3D9::GetAdapterMonitor(adapter);
|
}
|
|
long Direct3D9Ex::CreateDevice(unsigned int adapter, D3DDEVTYPE deviceType, HWND focusWindow, unsigned long behaviorFlags, D3DPRESENT_PARAMETERS *presentParameters, IDirect3DDevice9 **returnedDeviceInterface)
|
{
|
TRACE("unsigned int adapter = %d, D3DDEVTYPE deviceType = %d, HWND focusWindow = %d, unsigned long behaviorFlags = 0x%0.8X, D3DPRESENT_PARAMETERS *presentParameters = 0x%0.8p, IDirect3DDevice9 **returnedDeviceInterface = 0x%0.8p", adapter, deviceType, focusWindow, behaviorFlags, presentParameters, returnedDeviceInterface);
|
|
if(!focusWindow || !presentParameters || !returnedDeviceInterface)
|
{
|
*returnedDeviceInterface = 0;
|
|
return INVALIDCALL();
|
}
|
|
D3DDISPLAYMODEEX fullscreenDisplayMode = {0};
|
fullscreenDisplayMode.Size = sizeof(D3DDISPLAYMODEEX);
|
fullscreenDisplayMode.Format = presentParameters->BackBufferFormat;
|
fullscreenDisplayMode.Width = presentParameters->BackBufferWidth;
|
fullscreenDisplayMode.Height = presentParameters->BackBufferHeight;
|
fullscreenDisplayMode.RefreshRate = presentParameters->FullScreen_RefreshRateInHz;
|
fullscreenDisplayMode.ScanLineOrdering = D3DSCANLINEORDERING_PROGRESSIVE;
|
|
return CreateDeviceEx(adapter, deviceType, focusWindow, behaviorFlags, presentParameters, presentParameters->Windowed ? 0 : &fullscreenDisplayMode, (IDirect3DDevice9Ex**)returnedDeviceInterface);
|
}
|
|
unsigned int __stdcall Direct3D9Ex::GetAdapterModeCountEx(unsigned int adapter, const D3DDISPLAYMODEFILTER *filter)
|
{
|
TRACE("unsigned int adapter = %d, const D3DDISPLAYMODEFILTER *filter = 0x%0.8p", adapter, filter);
|
|
return Direct3D9::GetAdapterModeCount(adapter, filter->Format); // FIXME
|
}
|
|
long __stdcall Direct3D9Ex::EnumAdapterModesEx(unsigned int adapter, const D3DDISPLAYMODEFILTER *filter, unsigned int index, D3DDISPLAYMODEEX *modeEx)
|
{
|
TRACE("unsigned int adapter = %d, const D3DDISPLAYMODEFILTER *filter = 0x%0.8p, unsigned int index = %d, D3DDISPLAYMODEEX *modeEx = 0x%0.8p", adapter, filter, index, modeEx);
|
|
D3DDISPLAYMODE mode;
|
|
mode.Format = modeEx->Format;
|
mode.Width = modeEx->Width;
|
mode.Height = modeEx->Height;
|
mode.RefreshRate = modeEx->RefreshRate;
|
|
return Direct3D9::EnumAdapterModes(adapter, filter->Format, index, &mode); // FIXME
|
}
|
|
long __stdcall Direct3D9Ex::GetAdapterDisplayModeEx(unsigned int adapter, D3DDISPLAYMODEEX *modeEx, D3DDISPLAYROTATION *rotation)
|
{
|
TRACE("unsigned int adapter = %d, D3DDISPLAYMODEEX *modeEx = 0x%0.8p, D3DDISPLAYROTATION *rotation = 0x%0.8p", adapter, modeEx, rotation);
|
|
D3DDISPLAYMODE mode;
|
|
mode.Format = modeEx->Format;
|
mode.Width = modeEx->Width;
|
mode.Height = modeEx->Height;
|
mode.RefreshRate = modeEx->RefreshRate;
|
|
return GetAdapterDisplayMode(adapter, &mode); // FIXME
|
}
|
|
long __stdcall Direct3D9Ex::CreateDeviceEx(unsigned int adapter, D3DDEVTYPE deviceType, HWND focusWindow, DWORD behaviorFlags, D3DPRESENT_PARAMETERS *presentParameters, D3DDISPLAYMODEEX *fullscreenDisplayMode, IDirect3DDevice9Ex **returnedDeviceInterface)
|
{
|
TRACE("unsigned int adapter = %d, D3DDEVTYPE deviceType = %d, HWND focusWindow = %d, DWORD behaviorFlags = 0x%0.8X, D3DPRESENT_PARAMETERS *presentParameters = 0x%0.8p, D3DDISPLAYMODEEX *fullscreenDisplayMode = 0x%0.8p, IDirect3DDevice9Ex **returnedDeviceInterface = 0x%0.8p", adapter, deviceType, focusWindow, behaviorFlags, presentParameters, fullscreenDisplayMode, returnedDeviceInterface);
|
|
if(deviceType != D3DDEVTYPE_HAL)
|
{
|
loadSystemD3D9ex();
|
|
if(d3d9ex)
|
{
|
return d3d9ex->CreateDeviceEx(adapter, deviceType, focusWindow, behaviorFlags, presentParameters, fullscreenDisplayMode, returnedDeviceInterface);
|
}
|
else
|
{
|
CreateDeviceEx(adapter, deviceType, focusWindow, behaviorFlags, presentParameters, fullscreenDisplayMode, returnedDeviceInterface);
|
}
|
}
|
|
if(!focusWindow || !presentParameters || !returnedDeviceInterface)
|
{
|
*returnedDeviceInterface = 0;
|
|
return INVALIDCALL();
|
}
|
|
*returnedDeviceInterface = new Direct3DDevice9Ex(instance, this, adapter, deviceType, focusWindow, behaviorFlags, presentParameters);
|
|
if(*returnedDeviceInterface)
|
{
|
(*returnedDeviceInterface)->AddRef();
|
}
|
|
return D3D_OK;
|
}
|
|
long __stdcall Direct3D9Ex::GetAdapterLUID(unsigned int adapter, LUID *luid)
|
{
|
TRACE("unsigned int adapter = %d, LUID *luid = 0x%0.8p", adapter, luid);
|
|
if(adapter != D3DADAPTER_DEFAULT)
|
{
|
UNIMPLEMENTED();
|
}
|
|
// FIXME: Should return a presistent id using AllocateLocallyUniqueId()
|
luid->LowPart = 0x0000001;
|
luid->HighPart = 0x0000000;
|
|
return D3D_OK;
|
}
|
|
void Direct3D9Ex::loadSystemD3D9ex()
|
{
|
if(d3d9ex)
|
{
|
return;
|
}
|
|
char d3d9Path[MAX_PATH + 16];
|
GetSystemDirectory(d3d9Path, MAX_PATH);
|
strcat(d3d9Path, "\\d3d9.dll");
|
d3d9Lib = LoadLibrary(d3d9Path);
|
|
if(d3d9Lib)
|
{
|
typedef IDirect3D9Ex* (__stdcall *DIRECT3DCREATE9EX)(unsigned int, IDirect3D9Ex**);
|
DIRECT3DCREATE9EX direct3DCreate9Ex = (DIRECT3DCREATE9EX)GetProcAddress(d3d9Lib, "Direct3DCreate9Ex");
|
direct3DCreate9Ex(D3D_SDK_VERSION, &d3d9ex);
|
}
|
}
|
}
|
