public static D3D9.TextureAddress ConvertEnum(TextureAddressing type, D3D9.Capabilities caps)
{
// convert from ours to D3D
switch (type)
{
case TextureAddressing.Wrap:
return(D3D9.TextureAddress.Wrap);
case TextureAddressing.Mirror:
return(D3D9.TextureAddress.Mirror);
case TextureAddressing.Clamp:
return(D3D9.TextureAddress.Clamp);
case TextureAddressing.Border:
if ((caps.TextureAddressCaps & D3D9.TextureAddressCaps.Border) == D3D9.TextureAddressCaps.Border)
{
return(D3D9.TextureAddress.Border);
}
else
{
return(D3D9.TextureAddress.Clamp);
}
} // end switch
return((D3D9.TextureAddress) 0x7fffffff); //D3DTADDRESS_FORCE_DWORD
}
public static D3D9.TextureOperation ConvertEnum(LayerBlendOperationEx lbo, D3D9.Capabilities devCaps)
{
switch (lbo)
{
case LayerBlendOperationEx.Source1:
return(D3D9.TextureOperation.SelectArg1);
case LayerBlendOperationEx.Source2:
return(D3D9.TextureOperation.SelectArg2);
case LayerBlendOperationEx.Modulate:
return(D3D9.TextureOperation.Modulate);
case LayerBlendOperationEx.ModulateX2:
return(D3D9.TextureOperation.Modulate2X);
case LayerBlendOperationEx.ModulateX4:
return(D3D9.TextureOperation.Modulate4X);
case LayerBlendOperationEx.Add:
return(D3D9.TextureOperation.Add);
case LayerBlendOperationEx.AddSigned:
return(D3D9.TextureOperation.AddSigned);
case LayerBlendOperationEx.AddSmooth:
return(D3D9.TextureOperation.AddSmooth);
case LayerBlendOperationEx.Subtract:
return(D3D9.TextureOperation.Subtract);
case LayerBlendOperationEx.BlendDiffuseAlpha:
return(D3D9.TextureOperation.BlendDiffuseAlpha);
case LayerBlendOperationEx.BlendTextureAlpha:
return(D3D9.TextureOperation.BlendTextureAlpha);
case LayerBlendOperationEx.BlendCurrentAlpha:
return(D3D9.TextureOperation.BlendCurrentAlpha);
case LayerBlendOperationEx.BlendManual:
return(D3D9.TextureOperation.BlendFactorAlpha);
case LayerBlendOperationEx.DotProduct:
return((devCaps.TextureOperationCaps & D3D9.TextureOperationCaps.DotProduct3) != 0
? D3D9.TextureOperation.DotProduct3
: D3D9.TextureOperation.Modulate);
case LayerBlendOperationEx.BlendDiffuseColor:
return((devCaps.TextureOperationCaps & D3D9.TextureOperationCaps.Lerp) != 0
? D3D9.TextureOperation.Lerp
: D3D9.TextureOperation.Modulate);
}
return(0);
}
public D3D9Driver(int adapterNumber, D3D9.Capabilities deviceCaps, D3D9.AdapterDetails adapterIdentifier,
D3D9.DisplayMode desktopDisplayMode)
: base()
{
this._adapterNumber = adapterNumber;
this._d3D9DeviceCaps = deviceCaps;
this._adapterIdentifier = adapterIdentifier;
this._desktopDisplayMode = desktopDisplayMode;
this._videoModeList = null;
}
public static DxCapabilities RequestCapabilities(Capabilities deviceCapabilities, DisplayMode displayMode)
{
int maxAnisotropy = deviceCapabilities.MaxAnisotropy;
bool supportsFiltering = MPDirect3D.Direct3D.CheckDeviceFormat(
deviceCapabilities.AdapterOrdinal, deviceCapabilities.DeviceType, displayMode.Format,
Usage.RenderTarget | Usage.QueryFilter, ResourceType.Texture, Format.A8R8G8B8);
bool supportsAlphaBlend = MPDirect3D.Direct3D.CheckDeviceFormat(deviceCapabilities.AdapterOrdinal,
deviceCapabilities.DeviceType, displayMode.Format, Usage.RenderTarget | Usage.QueryPostPixelShaderBlending,
ResourceType.Surface, Format.A8R8G8B8);
bool supportsShaders = deviceCapabilities.PixelShaderVersion.Major >= 2 && deviceCapabilities.VertexShaderVersion.Major >= 2;
return new DxCapabilities(maxAnisotropy, supportsFiltering, supportsAlphaBlend, supportsShaders);
}
public static int ConvertEnum(TexCoordCalcMethod method, D3D9.Capabilities caps)
{
switch (method)
{
case TexCoordCalcMethod.None:
return((int)D3D9.TextureCoordIndex.PassThru);
case TexCoordCalcMethod.EnvironmentMapReflection:
return((int)D3D9.TextureCoordIndex.CameraSpaceReflectionVector);
case TexCoordCalcMethod.EnvironmentMapPlanar:
if ((caps.VertexProcessingCaps & D3D9.VertexProcessingCaps.TexGenSphereMap) ==
D3D9.VertexProcessingCaps.TexGenSphereMap)
{
// use sphere map if available
return((int)D3D9.TextureCoordIndex.SphereMap);
}
else
{
// If not, fall back on camera space reflection vector which isn't as good
return((int)D3D9.TextureCoordIndex.CameraSpaceReflectionVector);
}
case TexCoordCalcMethod.EnvironmentMapNormal:
return((int)D3D9.TextureCoordIndex.CameraSpaceNormal);
case TexCoordCalcMethod.EnvironmentMap:
if ((caps.VertexProcessingCaps & D3D9.VertexProcessingCaps.TexGenSphereMap) ==
D3D9.VertexProcessingCaps.TexGenSphereMap)
{
return((int)D3D9.TextureCoordIndex.SphereMap);
}
else
{
// fall back on camera space normal if sphere map isnt supported
return((int)D3D9.TextureCoordIndex.CameraSpaceNormal);
}
case TexCoordCalcMethod.ProjectiveTexture:
return((int)D3D9.TextureCoordIndex.CameraSpacePosition);
} // switch
return(0);
}
protected void CreateD3D9Device()
{
// Update focus window.
var primaryRenderWindow = PrimaryWindow;
// Case we have to share the same focus window.
this._focusWindow = SharedFocusWindow != IntPtr.Zero ? SharedFocusWindow : primaryRenderWindow.WindowHandle;
var pD3D9 = D3D9RenderSystem.Direct3D9;
if ( IsMultihead )
{
this.BehaviorFlags |= D3D9.CreateFlags.AdapterGroupDevice;
}
else
{
this.BehaviorFlags &= ~D3D9.CreateFlags.AdapterGroupDevice;
}
// Try to create the device with hardware vertex processing.
this.BehaviorFlags |= D3D9.CreateFlags.HardwareVertexProcessing;
var keepTrying = true;
var loopCount = 0;
LogManager.Instance.Write( "Creating D3D9 Device..." );
while ( keepTrying )
{
try
{
this.pDevice = new D3D9.Device( pD3D9, AdapterNumber, DeviceType, this._focusWindow, this.BehaviorFlags,
this.PresentationParams );
keepTrying = false;
}
catch ( DX.SharpDXException ex )
{
LogManager.Instance.Write( "FAIL!" );
switch ( loopCount )
{
case 0:
// Try a second time, may fail the first time due to back buffer count,
// which will be corrected down to 1 by the runtime
LogManager.Instance.Write( "Trying to create the device a second time.." );
break;
case 1:
// Case hardware vertex processing failed.
// Try to create the device with mixed vertex processing.
this.BehaviorFlags &= ~D3D9.CreateFlags.HardwareVertexProcessing;
this.BehaviorFlags |= D3D9.CreateFlags.MixedVertexProcessing;
LogManager.Instance.Write( "Trying to create the device with mixed vertex processing.." );
break;
case 2:
// try to create the device with software vertex processing.
this.BehaviorFlags &= ~D3D9.CreateFlags.MixedVertexProcessing;
this.BehaviorFlags |= D3D9.CreateFlags.SoftwareVertexProcessing;
LogManager.Instance.Write( "Trying to create the device with software vertex processing.." );
break;
case 3:
// try reference device
DeviceType = D3D9.DeviceType.Reference;
LogManager.Instance.Write( "Trying to create a reference device.." );
break;
default:
throw new AxiomException( "Cannot create device!", ex );
}
;
loopCount++;
}
}
;
// Get current device caps.
this.d3d9DeviceCaps = this.pDevice.Capabilities;
// Get current creation parameters caps.
this.creationParams = this.pDevice.CreationParameters;
this.D3D9DeviceCapsValid = true;
// Initialize device states.
SetupDeviceStates();
// Lock access to rendering device.
D3D9RenderSystem.ResourceManager.LockDeviceAccess();
var pCurActiveDevice = this.pDeviceManager.ActiveDevice;
this.pDeviceManager.ActiveDevice = this;
// Inform all resources that new device created.
D3D9RenderSystem.ResourceManager.NotifyOnDeviceCreate( this.pDevice );
this.pDeviceManager.ActiveDevice = pCurActiveDevice;
// UnLock access to rendering device.
D3D9RenderSystem.ResourceManager.UnlockDeviceAccess();
}
private D3D9Device _selectDevice(D3D9RenderWindow renderWindow, D3D9RenderWindowList renderWindowsGroup)
{
var renderSystem = D3D9RenderSystem.Instance;
D3D9Device renderDevice = null;
var direct3D9 = D3D9RenderSystem.Direct3D9;
var nAdapterOrdinal = 0; // D3DADAPTER_DEFAULT
var devType = D3D9.DeviceType.Hardware;
D3D9.CreateFlags extraFlags = 0;
var driverList = renderSystem.Direct3DDrivers;
var nvAdapterFound = false;
// Default group includes at least the given render window.
renderWindowsGroup.Add(renderWindow);
// Case we use nvidia performance HUD, override the device settings.
if (renderWindow.IsNvPerfHUDEnable)
{
// Look for 'NVIDIA NVPerfHUD' adapter (<= v4)
// or 'NVIDIA PerfHUD' (v5)
// If it is present, override default settings
for (var adapter = 0; adapter < direct3D9.AdapterCount; ++adapter)
{
var currDriver = driverList[adapter];
if (!currDriver.DriverDescription.Contains("PerfHUD"))
{
continue;
}
// renderDevice = null;
nAdapterOrdinal = adapter;
renderSystem._activeD3DDriver = currDriver;
devType = D3D9.DeviceType.Reference;
nvAdapterFound = true;
break;
}
}
// No special adapter should be used.
if (nvAdapterFound == false)
{
renderSystem._activeD3DDriver = _findDriver(renderWindow);
nAdapterOrdinal = renderSystem._activeD3DDriver.AdapterNumber;
var bTryUsingMultiheadDevice = false;
if (renderWindow.IsFullScreen)
{
bTryUsingMultiheadDevice = true;
var osVersionInfo = System.Environment.OSVersion;
// XP and below - multi-head will cause artifacts when vsync is on.
if (osVersionInfo.Version.Major <= 5 && renderWindow.IsVSync)
{
bTryUsingMultiheadDevice = false;
LogManager.Instance.Write(
"D3D9 : Multi head disabled. It causes horizontal line when used in XP + VSync combination");
}
// Vista and SP1 or SP2 - multi-head device can not be reset - it causes memory corruption.
if (osVersionInfo.Version.Major == 6 &&
(osVersionInfo.ServicePack.Contains("Service Pack 1") ||
osVersionInfo.ServicePack.Contains("Service Pack 2")))
{
bTryUsingMultiheadDevice = false;
LogManager.Instance.Write(
"D3D9 : Multi head disabled. It causes application run time crashes when used in Vista + SP 1 or 2 combination");
}
}
// Check if we can create a group of render windows
// on the same device using the multi-head feature.
if (bTryUsingMultiheadDevice)
{
var targetAdapterCaps = renderSystem._activeD3DDriver.D3D9DeviceCaps;
var masterAdapterCaps = new Capabilities();
// Find the master device caps.
if (targetAdapterCaps.MasterAdapterOrdinal == targetAdapterCaps.AdapterOrdinal)
{
masterAdapterCaps = targetAdapterCaps;
}
else
{
foreach (var currDriver in driverList)
{
var currDeviceCaps = currDriver.D3D9DeviceCaps;
if (currDeviceCaps.AdapterOrdinal != targetAdapterCaps.MasterAdapterOrdinal)
{
continue;
}
masterAdapterCaps = currDeviceCaps;
break;
}
}
// Case the master adapter can handle multiple adapters.
if (masterAdapterCaps.NumberOfAdaptersInGroup > 1)
{
// Create empty list of render windows composing this group.
renderWindowsGroup.Clear();
while (renderWindowsGroup.Count < masterAdapterCaps.NumberOfAdaptersInGroup)
{
renderWindowsGroup.Add(null);
}
// Assign the current render window to it's place in the group.
renderWindowsGroup[targetAdapterCaps.AdapterOrdinalInGroup] = renderWindow;
// For each existing window - check if it belongs to the group.
foreach (var currRenderWindow in renderSystem.RenderWindows)
{
if (!currRenderWindow.IsFullScreen)
{
continue;
}
var currDriver = _findDriver((D3D9RenderWindow)currRenderWindow);
var currDeviceCaps = currDriver.D3D9DeviceCaps;
if (currDeviceCaps.MasterAdapterOrdinal != masterAdapterCaps.AdapterOrdinal)
{
continue;
}
renderWindowsGroup[currDeviceCaps.AdapterOrdinalInGroup] = (D3D9RenderWindow)currRenderWindow;
break;
}
var bDeviceGroupFull = true;
// Check if render windows group is full and ready to be driven by
// the master device.
for (var i = 0; i < renderWindowsGroup.Count; ++i)
{
// This group misses required window -> go back to default.
if (renderWindowsGroup[i] != null)
{
continue;
}
bDeviceGroupFull = false;
renderWindowsGroup.Clear();
renderWindowsGroup.Add(renderWindow);
break;
}
// Case device group is full -> we can use multi head device.
if (bDeviceGroupFull)
{
var validateAllDevices = false;
for (var i = 0; i < renderWindowsGroup.Count; ++i)
{
var currRenderWindow = renderWindowsGroup[i];
var currDevice = currRenderWindow.Device;
// This is the master window
if (i == 0)
{
// If master device exists - just release it.
if (currDevice != null)
{
renderDevice = currDevice;
renderDevice.Release();
}
}
// This is subordinate window.
else
{
// If subordinate device exists - destroy it.
if (currDevice != null)
{
currDevice.Destroy();
validateAllDevices = true;
}
}
}
// In case some device was destroyed - make sure all other devices are valid.
// A possible scenario is that full screen window has been destroyed and it's handle
// was used and the shared focus handle. All other devices used this handle and must be
// recreated using other handles otherwise create device will fail.
if (validateAllDevices)
{
foreach (var dev in this._renderDevices)
{
dev.ValidateFocusWindow();
}
}
}
}
}
}
// Do we want to preserve the FPU mode? Might be useful for scientific apps
var options = renderSystem.ConfigOptions;
ConfigOption opti;
if (options.TryGetValue("Floating-point mode", out opti) && opti.Value == "Consistent")
{
extraFlags |= D3D9.CreateFlags.FpuPreserve;
}
#if AXIOM_THREAD_SUPPORT
if (Configuration.Config.AxiomThreadLevel == 1)
{
extraFlags |= D3D9.CreateFlags.Multithreaded;
}
#endif
// Try to find a matching device from current device list.
if (renderDevice == null)
{
foreach (var currDevice in this._renderDevices)
{
if (currDevice.AdapterNumber != nAdapterOrdinal || currDevice.DeviceType != devType)
{
continue;
}
renderDevice = currDevice;
break;
}
}
// No matching device found -> try reference device type (might have been
// previously created as a fallback, but don't change devType because HAL
// should be preferred on creation)
if (renderDevice == null)
{
foreach (var currDevice in this._renderDevices)
{
if (currDevice.AdapterNumber != nAdapterOrdinal || currDevice.DeviceType != D3D9.DeviceType.Reference)
{
continue;
}
renderDevice = currDevice;
break;
}
}
// No matching device found -> create new one.
if (renderDevice == null)
{
renderDevice = new D3D9Device(this, nAdapterOrdinal, direct3D9.GetAdapterMonitor(nAdapterOrdinal), devType,
extraFlags);
this._renderDevices.Add(renderDevice);
if (this._activeDevice == null)
{
ActiveDevice = renderDevice;
}
}
return(renderDevice);
}
public CAdapter(Direct3D direct3D, AdapterInformation adapterInfo)
{
this.direct3D = direct3D;
this.adapterInfo = adapterInfo;
desctopDisplayMode = adapterInfo.CurrentDisplayMode;
caps = adapterInfo.GetCaps(DeviceType.Hardware);
index = adapterInfo.Adapter;
var shaderModel = System.Math.Min(caps.VertexShaderVersion.Major, caps.PixelShaderVersion.Major);
apiVersion = new ApiVersion(9, (byte)shaderModel);
var details = adapterInfo.Details;
restrictions = new AdapterRestrictions
{
UniformBufferSlots = 256,
SamplerSlots = caps.MaxSimultaneousTextures,
ShaderResourceSlots = caps.MaxSimultaneousTextures,
UnorderedAccessResourceSlots = 0,
MaxVertexStreams = caps.MaxStreams,
MaxVertexStreamElementCount = caps.MaxStreamStride / (4 * sizeof(float)),
MaxStreamOutputTargets = 0,
MaxViewports = 1,
MaxRenderTargets = caps.SimultaneousRTCount,
MaxThreadGroupsX = 0,
MaxThreadGroupsY = 0,
MaxThreadGroupsZ = 0,
MaxThreadGroupsTotal = 0,
};
adapterDesc = new AdapterDescription
{
Description = details.Description,
VendorId = details.VendorId,
DeviceId = details.DeviceId,
SubSysId = details.SubsystemId,
Revision = details.Revision,
DedicatedVideoMemory = 0,
DedicatedSystemMemory = 0,
SharedSystemMemory = 0,
AdapterLuidHigh = 0,
AdapterLuidLow = 0,
Flags = AdapterFlags.None
};
outputDesc = new OutputDescription
{
DeviceName = details.DeviceName,
DesctopCoordinates = new Math.Rectangle(),
AttachedToDesctop = false,
Rotation = ModeRotation.Unspecified,
MonitorHandle = adapterInfo.Monitor
};
outputs = new[] { this };
formatSupports = ((Format[])Enum.GetValues(typeof(Format))).ToDictionary(f => f, GetFormatSupport);
}
private void _convertPixelShaderCaps( RenderSystemCapabilities rsc )
{
var major = 0xFF;
var minor = 0xFF;
var minPsCaps = new D3D9.Capabilities();
// Find the device with the lowest vertex shader caps.
foreach ( var pCurDriver in this._driverList )
{
var currCaps = pCurDriver.D3D9DeviceCaps;
var currMajor = currCaps.PixelShaderVersion.Major;
var currMinor = currCaps.PixelShaderVersion.Minor;
if ( currMajor < major )
{
major = currMajor;
minor = currMinor;
minPsCaps = currCaps;
}
else if ( currMajor == major && currMinor < minor )
{
minor = currMinor;
minPsCaps = currCaps;
}
}
var ps2a = false;
var ps2b = false;
var ps2x = false;
// Special case detection for ps_2_x/a/b support
if ( major >= 2 )
{
if ( ( minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.NoTextureInstructionLimit ) != 0 &&
( minPsCaps.PS20Caps.TempCount >= 32 ) )
{
ps2b = true;
}
if ( ( minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.NoTextureInstructionLimit ) != 0 &&
( minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.NoDependentReadLimit ) != 0 &&
( minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.ArbitrarySwizzle ) != 0 &&
( minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.GradientInstructions ) != 0 &&
( minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.Predication ) != 0 && ( minPsCaps.PS20Caps.TempCount >= 22 ) )
{
ps2a = true;
}
// Does this enough?
if ( ps2a || ps2b )
{
ps2x = true;
}
}
switch ( major )
{
case 1:
// no boolean params allowed
rsc.FragmentProgramConstantBoolCount = 0;
// no integer params allowed
rsc.FragmentProgramConstantIntCount = 0;
// float params, always 4D
// NB in ps_1_x these are actually stored as fixed point values,
// but they are entered as floats
rsc.FragmentProgramConstantFloatCount = 8;
break;
case 2:
// 16 boolean params allowed
rsc.FragmentProgramConstantBoolCount = 16;
// 16 integer params allowed, 4D
rsc.FragmentProgramConstantIntCount = 16;
// float params, always 4D
rsc.FragmentProgramConstantFloatCount = 32;
break;
case 3:
// 16 boolean params allowed
rsc.FragmentProgramConstantBoolCount = 16;
// 16 integer params allowed, 4D
rsc.FragmentProgramConstantIntCount = 16;
// float params, always 4D
rsc.FragmentProgramConstantFloatCount = 224;
break;
}
// populate syntax codes in program manager (no breaks in this one so it falls through)
switch ( major )
{
case 3:
if ( minor > 0 )
{
rsc.AddShaderProfile( "ps_3_x" );
}
rsc.AddShaderProfile( "ps_3_0" );
goto case 2;
case 2:
if ( ps2x )
{
rsc.AddShaderProfile( "ps_2_x" );
}
if ( ps2a )
{
rsc.AddShaderProfile( "ps_2_a" );
}
if ( ps2b )
{
rsc.AddShaderProfile( "ps_2_b" );
}
rsc.AddShaderProfile( "ps_2_0" );
goto case 1;
case 1:
if ( major > 1 || minor >= 4 )
{
rsc.AddShaderProfile( "ps_1_4" );
}
if ( major > 1 || minor >= 3 )
{
rsc.AddShaderProfile( "ps_1_3" );
}
if ( major > 1 || minor >= 2 )
{
rsc.AddShaderProfile( "ps_1_2" );
}
rsc.AddShaderProfile( "ps_1_1" );
rsc.SetCapability( Graphics.Capabilities.FragmentPrograms );
break;
}
}
private void _convertVertexShaderCaps(RenderSystemCapabilities rsc)
{
var major = 0xFF;
var minor = 0xFF;
var minVsCaps = new D3D9.Capabilities();
// Find the device with the lowest vertex shader caps.
foreach (var pCurDriver in this._driverList)
{
var rkCurCaps = pCurDriver.D3D9DeviceCaps;
var currMajor = rkCurCaps.VertexShaderVersion.Major;
var currMinor = rkCurCaps.VertexShaderVersion.Minor;
if (currMajor < major)
{
major = currMajor;
minor = currMinor;
minVsCaps = rkCurCaps;
}
else if (currMajor == major && currMinor < minor)
{
minor = currMinor;
minVsCaps = rkCurCaps;
}
}
var vs2x = false;
var vs2a = false;
// Special case detection for vs_2_x/a support
if (major >= 2)
{
if ((minVsCaps.VS20Caps.Caps & D3D9.VertexShaderCaps.Predication) != 0 &&
(minVsCaps.VS20Caps.DynamicFlowControlDepth > 0) && (minVsCaps.VS20Caps.TempCount >= 12))
{
vs2x = true;
}
if ((minVsCaps.VS20Caps.Caps & D3D9.VertexShaderCaps.Predication) != 0 &&
(minVsCaps.VS20Caps.DynamicFlowControlDepth > 0) && (minVsCaps.VS20Caps.TempCount >= 13))
{
vs2a = true;
}
}
// Populate max param count
switch (major)
{
case 1:
// No boolean params allowed
rsc.VertexProgramConstantBoolCount = 0;
// No integer params allowed
rsc.VertexProgramConstantIntCount = 0;
// float params, always 4D
rsc.VertexProgramConstantFloatCount = minVsCaps.MaxVertexShaderConst;
break;
case 2:
// 16 boolean params allowed
rsc.VertexProgramConstantBoolCount = 16;
// 16 integer params allowed, 4D
rsc.VertexProgramConstantIntCount = 16;
// float params, always 4D
rsc.VertexProgramConstantFloatCount = minVsCaps.MaxVertexShaderConst;
break;
case 3:
// 16 boolean params allowed
rsc.VertexProgramConstantBoolCount = 16;
// 16 integer params allowed, 4D
rsc.VertexProgramConstantIntCount = 16;
// float params, always 4D
rsc.VertexProgramConstantFloatCount = minVsCaps.MaxVertexShaderConst;
break;
}
// populate syntax codes in program manager (no breaks in this one so it falls through)
switch (major)
{
case 3:
rsc.AddShaderProfile("vs_3_0");
goto case 2;
case 2:
if (vs2x)
{
rsc.AddShaderProfile("vs_2_x");
}
if (vs2a)
{
rsc.AddShaderProfile("vs_2_a");
}
rsc.AddShaderProfile("vs_2_0");
goto case 1;
case 1:
rsc.AddShaderProfile("vs_1_1");
rsc.SetCapability(Graphics.Capabilities.VertexPrograms);
break;
}
}
private void _convertPixelShaderCaps(RenderSystemCapabilities rsc)
{
var major = 0xFF;
var minor = 0xFF;
var minPsCaps = new D3D9.Capabilities();
// Find the device with the lowest vertex shader caps.
foreach (var pCurDriver in this._driverList)
{
var currCaps = pCurDriver.D3D9DeviceCaps;
var currMajor = currCaps.PixelShaderVersion.Major;
var currMinor = currCaps.PixelShaderVersion.Minor;
if (currMajor < major)
{
major = currMajor;
minor = currMinor;
minPsCaps = currCaps;
}
else if (currMajor == major && currMinor < minor)
{
minor = currMinor;
minPsCaps = currCaps;
}
}
var ps2a = false;
var ps2b = false;
var ps2x = false;
// Special case detection for ps_2_x/a/b support
if (major >= 2)
{
if ((minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.NoTextureInstructionLimit) != 0 &&
(minPsCaps.PS20Caps.TempCount >= 32))
{
ps2b = true;
}
if ((minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.NoTextureInstructionLimit) != 0 &&
(minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.NoDependentReadLimit) != 0 &&
(minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.ArbitrarySwizzle) != 0 &&
(minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.GradientInstructions) != 0 &&
(minPsCaps.PS20Caps.Caps & D3D9.PixelShaderCaps.Predication) != 0 && (minPsCaps.PS20Caps.TempCount >= 22))
{
ps2a = true;
}
// Does this enough?
if (ps2a || ps2b)
{
ps2x = true;
}
}
switch (major)
{
case 1:
// no boolean params allowed
rsc.FragmentProgramConstantBoolCount = 0;
// no integer params allowed
rsc.FragmentProgramConstantIntCount = 0;
// float params, always 4D
// NB in ps_1_x these are actually stored as fixed point values,
// but they are entered as floats
rsc.FragmentProgramConstantFloatCount = 8;
break;
case 2:
// 16 boolean params allowed
rsc.FragmentProgramConstantBoolCount = 16;
// 16 integer params allowed, 4D
rsc.FragmentProgramConstantIntCount = 16;
// float params, always 4D
rsc.FragmentProgramConstantFloatCount = 32;
break;
case 3:
// 16 boolean params allowed
rsc.FragmentProgramConstantBoolCount = 16;
// 16 integer params allowed, 4D
rsc.FragmentProgramConstantIntCount = 16;
// float params, always 4D
rsc.FragmentProgramConstantFloatCount = 224;
break;
}
// populate syntax codes in program manager (no breaks in this one so it falls through)
switch (major)
{
case 3:
if (minor > 0)
{
rsc.AddShaderProfile("ps_3_x");
}
rsc.AddShaderProfile("ps_3_0");
goto case 2;
case 2:
if (ps2x)
{
rsc.AddShaderProfile("ps_2_x");
}
if (ps2a)
{
rsc.AddShaderProfile("ps_2_a");
}
if (ps2b)
{
rsc.AddShaderProfile("ps_2_b");
}
rsc.AddShaderProfile("ps_2_0");
goto case 1;
case 1:
if (major > 1 || minor >= 4)
{
rsc.AddShaderProfile("ps_1_4");
}
if (major > 1 || minor >= 3)
{
rsc.AddShaderProfile("ps_1_3");
}
if (major > 1 || minor >= 2)
{
rsc.AddShaderProfile("ps_1_2");
}
rsc.AddShaderProfile("ps_1_1");
rsc.SetCapability(Graphics.Capabilities.FragmentPrograms);
break;
}
}
private Result GetDeviceCaps(IntPtr devicePointer, Capabilities caps)
{
throw new NotImplementedException();
}
public Capabilities GetDeviceCaps(int adapter, DeviceType deviceType)
{
Capabilities capsRef = new Capabilities();
int res = Interop.Calli(comPointer, adapter, (int)deviceType, (IntPtr)(void*)&capsRef,(*(IntPtr**)comPointer)[14]);
if( res < 0 ) { throw new SharpDXException( res ); }
return capsRef;
}
public static D3D9.TextureFilter ConvertEnum(FilterType type, FilterOptions options, D3D9.Capabilities devCaps,
D3D9TextureType texType)
{
// Assume normal
D3D9.FilterCaps capsType = devCaps.TextureFilterCaps;
switch (texType)
{
case D3D9TextureType.Normal:
capsType = devCaps.TextureFilterCaps;
break;
case D3D9TextureType.Cube:
capsType = devCaps.CubeTextureFilterCaps;
break;
case D3D9TextureType.Volume:
capsType = devCaps.VolumeTextureFilterCaps;
break;
}
switch (type)
{
#region FilterType.Min
case FilterType.Min:
{
switch (options)
{
// NOTE: Fall through if device doesn't support requested type
case FilterOptions.Anisotropic:
if ((capsType & D3D9.FilterCaps.MinAnisotropic) == D3D9.FilterCaps.MinAnisotropic)
{
return(D3D9.TextureFilter.Anisotropic);
}
break;
case FilterOptions.Linear:
if ((capsType & D3D9.FilterCaps.MinLinear) == D3D9.FilterCaps.MinLinear)
{
return(D3D9.TextureFilter.Linear);
}
break;
case FilterOptions.Point:
case FilterOptions.None:
return(D3D9.TextureFilter.Point);
}
break;
}
#endregion FilterType.Min
#region FilterType.Mag
case FilterType.Mag:
{
switch (options)
{
// NOTE: Fall through if device doesn't support requested type
case FilterOptions.Anisotropic:
if ((capsType & D3D9.FilterCaps.MagAnisotropic) == D3D9.FilterCaps.MagAnisotropic)
{
return(D3D9.TextureFilter.Anisotropic);
}
break;
case FilterOptions.Linear:
if ((capsType & D3D9.FilterCaps.MagLinear) == D3D9.FilterCaps.MagLinear)
{
return(D3D9.TextureFilter.Linear);
}
break;
case FilterOptions.Point:
case FilterOptions.None:
return(D3D9.TextureFilter.Point);
}
break;
}
#endregion FilterType.Mag
#region FilterType.Mip
case FilterType.Mip:
{
switch (options)
{
case FilterOptions.Anisotropic:
case FilterOptions.Linear:
if ((capsType & D3D9.FilterCaps.MipLinear) == D3D9.FilterCaps.MipLinear)
{
return(D3D9.TextureFilter.Linear);
}
break;
case FilterOptions.Point:
if ((capsType & D3D9.FilterCaps.MipPoint) == D3D9.FilterCaps.MipPoint)
{
return(D3D9.TextureFilter.Point);
}
break;
case FilterOptions.None:
return(D3D9.TextureFilter.None);
}
break;
}
#endregion FilterType.Mip
}
// should never get here
return(0);
}
private void _convertVertexShaderCaps( RenderSystemCapabilities rsc )
{
var major = 0xFF;
var minor = 0xFF;
var minVsCaps = new D3D9.Capabilities();
// Find the device with the lowest vertex shader caps.
foreach ( var pCurDriver in this._driverList )
{
var rkCurCaps = pCurDriver.D3D9DeviceCaps;
var currMajor = rkCurCaps.VertexShaderVersion.Major;
var currMinor = rkCurCaps.VertexShaderVersion.Minor;
if ( currMajor < major )
{
major = currMajor;
minor = currMinor;
minVsCaps = rkCurCaps;
}
else if ( currMajor == major && currMinor < minor )
{
minor = currMinor;
minVsCaps = rkCurCaps;
}
}
var vs2x = false;
var vs2a = false;
// Special case detection for vs_2_x/a support
if ( major >= 2 )
{
if ( ( minVsCaps.VS20Caps.Caps & D3D9.VertexShaderCaps.Predication ) != 0 &&
( minVsCaps.VS20Caps.DynamicFlowControlDepth > 0 ) && ( minVsCaps.VS20Caps.TempCount >= 12 ) )
{
vs2x = true;
}
if ( ( minVsCaps.VS20Caps.Caps & D3D9.VertexShaderCaps.Predication ) != 0 &&
( minVsCaps.VS20Caps.DynamicFlowControlDepth > 0 ) && ( minVsCaps.VS20Caps.TempCount >= 13 ) )
{
vs2a = true;
}
}
// Populate max param count
switch ( major )
{
case 1:
// No boolean params allowed
rsc.VertexProgramConstantBoolCount = 0;
// No integer params allowed
rsc.VertexProgramConstantIntCount = 0;
// float params, always 4D
rsc.VertexProgramConstantFloatCount = minVsCaps.MaxVertexShaderConst;
break;
case 2:
// 16 boolean params allowed
rsc.VertexProgramConstantBoolCount = 16;
// 16 integer params allowed, 4D
rsc.VertexProgramConstantIntCount = 16;
// float params, always 4D
rsc.VertexProgramConstantFloatCount = minVsCaps.MaxVertexShaderConst;
break;
case 3:
// 16 boolean params allowed
rsc.VertexProgramConstantBoolCount = 16;
// 16 integer params allowed, 4D
rsc.VertexProgramConstantIntCount = 16;
// float params, always 4D
rsc.VertexProgramConstantFloatCount = minVsCaps.MaxVertexShaderConst;
break;
}
// populate syntax codes in program manager (no breaks in this one so it falls through)
switch ( major )
{
case 3:
rsc.AddShaderProfile( "vs_3_0" );
goto case 2;
case 2:
if ( vs2x )
{
rsc.AddShaderProfile( "vs_2_x" );
}
if ( vs2a )
{
rsc.AddShaderProfile( "vs_2_a" );
}
rsc.AddShaderProfile( "vs_2_0" );
goto case 1;
case 1:
rsc.AddShaderProfile( "vs_1_1" );
rsc.SetCapability( Graphics.Capabilities.VertexPrograms );
break;
}
}
protected virtual bool ConfirmDevice(Capabilities caps, VertexProcessingType vertexProcessingType,
Format adapterFormat, Format backBufferFormat)
{
return true;
}
public WinformsDevice(WinformsEye eye, Direct3D direct3D, CAdapter adapter,
ControlWindow primaryWindow, SwapChainDescription implicitSwapChainDesc,
DeviceInitializationFlags flags, IFileSystem fileSystem)
{
this.eye = eye;
this.adapter = adapter;
this.primaryWindow = primaryWindow;
this.implicitSwapChainDesc = implicitSwapChainDesc;
this.flags = flags;
caps = adapter.Info.GetCaps(DeviceType.Hardware);
devicePresentParams = new PresentParameters();
FillDevicePresentParams();
d3dDevice = new Device(direct3D, adapter.Index, DeviceType.Hardware, primaryWindow.Handle, CreateFlags.FpuPreserve | CreateFlags.HardwareVertexProcessing, devicePresentParams);
CreateBackBufferAndDepthStencil();
additionalSwapChains = new List<CAdditionalSwapChain>();
creator = new CDeviceChildCreator(this);
immediateContext = new CDeviceContext(this);
lastSwapChainSize = new IntSize(primaryWindow.SwapChainWidth, primaryWindow.SwapChainHeight);
fullscreenState = FullscreenState.Windowed;
fullscreenDisplayMode = adapter.GetSupportedDisplayModes().First();
}