/// <summary>Initializes DirectX graphics</summary>
/// <returns>true on success, false on failure</returns>
private bool InitializeGraphics()
{
try
{
PresentParameters presentParams = new PresentParameters();
presentParams.Windowed = true;
presentParams.SwapEffect = SwapEffect.Discard;
presentParams.BackBufferFormat = Format.Unknown;
presentParams.AutoDepthStencilFormat = DepthFormat.D16;
presentParams.EnableAutoDepthStencil = true;
int adapterOrdinal = D3D.Manager.Adapters.Default.Adapter;
CreateFlags flags = CreateFlags.SoftwareVertexProcessing;
D3D.Caps caps = D3D.Manager.GetDeviceCaps(adapterOrdinal, D3D.DeviceType.Hardware);
if (caps.DeviceCaps.SupportsHardwareTransformAndLight)
{
flags = CreateFlags.HardwareVertexProcessing;
}
device = new Device(0, DeviceType.Hardware, this, flags, presentParams);
device.DeviceLost += new EventHandler(this.InvalidateDeviceObjects);
device.DeviceReset += new EventHandler(this.RestoreDeviceObjects);
device.Disposing += new EventHandler(this.DeleteDeviceObjects);
device.DeviceResizing += new CancelEventHandler(this.EnvironmentResizeing);
d3dsprite = new Sprite(device);
return(true);
}
catch (DirectXException)
{
return(false);
}
}
private void Initialize()
{
try {
//Common DirectX setup calls...
PresentParameters presentParams = new PresentParameters();
presentParams.Windowed = true;
presentParams.SwapEffect = SwapEffect.Discard;
presentParams.BackBufferFormat = Format.Unknown;
presentParams.AutoDepthStencilFormat = DepthFormat.D16;
presentParams.EnableAutoDepthStencil = true;
// Store the default adapter
int adapterOrdinal = D3D.Manager.Adapters.Default.Adapter;
CreateFlags flags = CreateFlags.SoftwareVertexProcessing;
// Check to see if we can use a pure hardware device
D3D.Caps caps = D3D.Manager.GetDeviceCaps(adapterOrdinal, D3D.DeviceType.Hardware);
// Do we support hardware vertex processing?
if (caps.DeviceCaps.SupportsHardwareTransformAndLight)
{
// Replace the software vertex processing
flags = CreateFlags.HardwareVertexProcessing;
}
device = new D3D.Device(0, D3D.DeviceType.Hardware, this, flags, presentParams);
device.DeviceReset += new System.EventHandler(this.OnResetDevice);
OnResetDevice(device, null);
//Space Donuts setup
donutTexture = TextureLoader.FromFile(device, MediaUtilities.FindFile(TileSetFileName), 1024, 1024,
1, 0, Format.A8R8G8B8, Pool.Managed, Filter.Point, Filter.Point, (unchecked ((int)0xff000000)));
donutTileSet = new TileSet(donutTexture, 0, 0, 6, 5, 32, 32);
pyramidTileSet = new TileSet(donutTexture, 0, 384, 4, 10, 16, 16);
sphereTileSet = new TileSet(donutTexture, 0, 512, 2, 20, 8, 8);
cubeTileSet = new TileSet(donutTexture, 0, 544, 2, 20, 8, 8);
shipTileSet = new TileSet(donutTexture, 0, 576, 4, 10, 16, 16);
nixiesTileSet = new TileSet(donutTexture, 0, 832, 1, 14, 8, 8);
bulletTileSet = new TileSet(donutTexture, 304, 832, 1, 1, 8, 2);
//set up DirectInput keyboard device...
kbd = new DI.Device(SystemGuid.Keyboard);
kbd.SetCooperativeLevel(this,
DI.CooperativeLevelFlags.Background | DI.CooperativeLevelFlags.NonExclusive);
kbd.Acquire();
soundHandler = new SoundHandler(this);
sm.OnCollisionDetected += new SpriteManager.HandleCollision(this.CollisionHandler);
hrt.Start();
}
catch (DirectXException e) {
Console.WriteLine("Exception is " + e.ErrorString);
// Catch any errors and return a failure
}
}
private void InitializeGraphics()
{
try {
PresentParameters presentParams = new PresentParameters();
presentParams.Windowed = true;
presentParams.SwapEffect = SwapEffect.Discard;
presentParams.BackBufferFormat = Format.Unknown;
presentParams.AutoDepthStencilFormat = DepthFormat.D16;
presentParams.EnableAutoDepthStencil = true;
// Store the default adapter
int adapterOrdinal = D3D.Manager.Adapters.Default.Adapter;
CreateFlags flags = CreateFlags.SoftwareVertexProcessing;
// Check to see if we can use a pure hardware device
D3D.Caps caps = D3D.Manager.GetDeviceCaps(adapterOrdinal, D3D.DeviceType.Hardware);
// Do we support hardware vertex processing?
if (caps.DeviceCaps.SupportsHardwareTransformAndLight)
{
// Replace the software vertex processing
flags = CreateFlags.HardwareVertexProcessing;
}
// Do we support a pure device?
if (caps.DeviceCaps.SupportsPureDevice)
{
flags |= CreateFlags.PureDevice;
}
device = new D3D.Device(0, D3D.DeviceType.Hardware, this, flags, presentParams);
device.DeviceReset += new System.EventHandler(this.OnResetDevice);
OnResetDevice(device, null);
tileSheet = TextureLoader.FromFile(device, MediaUtilities.FindFile("donuts.bmp"), 1024, 1024,
1, 0, Format.A8R8G8B8, Pool.Managed, Filter.Point, Filter.Point, (unchecked ((int)0xff000000)));
tileSet = new TileSet(tileSheet, 0, 0, 6, 5, 32, 32);
tilePosition = new Rectangle(tileSet.XOrigin, tileSet.YOrigin, tileSet.ExtentX * 2, tileSet.ExtentY * 2);
//set up DirectInput keyboard device...
kbd = new DI.Device(SystemGuid.Keyboard);
kbd.SetCooperativeLevel(this,
DI.CooperativeLevelFlags.Background | DI.CooperativeLevelFlags.NonExclusive);
kbd.Acquire();
//Set up DirectSound device and buffers
snd = new DS.Device();
snd.SetCooperativeLevel(this, DS.CooperativeLevel.Normal);
bounce = new DS.SecondaryBuffer(MediaUtilities.FindFile("bounce.wav"), snd);
hrt.Start();
}
catch (DirectXException) {
// Catch any errors and return a failure
}
}
internal void Initialize(MDX1_DisplayWindow window)
{
if (mInitialized)
{
return;
}
if (window.RenderTarget.TopLevelControl == null)
{
throw new ArgumentException("The specified render target does not have a Form object yet. " +
"It's TopLevelControl property is null. You may not create DisplayWindow objects before " +
"the control to render to is added to the Form.");
}
mInitialized = true;
// ok, create D3D device
PresentParameters present = CreateWindowedPresentParameters(window, 0, 0);
present.BackBufferWidth = 1;
present.BackBufferHeight = 1;
DeviceType dtype = DeviceType.Hardware;
int adapterOrdinal = Direct3D.Manager.Adapters.Default.Adapter;
Direct3D.Caps caps = Direct3D.Manager.GetDeviceCaps(adapterOrdinal, Direct3D.DeviceType.Hardware);
Direct3D.CreateFlags flags = Direct3D.CreateFlags.SoftwareVertexProcessing;
// Is there support for hardware vertex processing? If so, replace
// software vertex processing.
if (caps.DeviceCaps.SupportsHardwareTransformAndLight)
{
flags = Direct3D.CreateFlags.HardwareVertexProcessing;
}
// Does the device support a pure device?
if (caps.DeviceCaps.SupportsPureDevice)
{
flags |= Direct3D.CreateFlags.PureDevice;
}
Device device = new Device
(0, dtype, window.RenderTarget.TopLevelControl.Handle,
flags, present);
device.DeviceLost += new EventHandler(mDevice_DeviceLost);
device.DeviceReset += new EventHandler(mDevice_DeviceReset);
mDevice = new D3DDevice(device);
// create primitive objects
mLine = new Direct3D.Line(device);
//CreateSurfaceVB();
}
public static D3D.CreateFlags GetDeviceCreateFlags(int adpNum, D3D.DeviceType type)
{
DebugOnly.ConsoleWrite("Getting device creation flags...");
D3D.Caps caps = D3D.Manager.GetDeviceCaps(adpNum, type);
D3D.CreateFlags flags = D3D.CreateFlags.SoftwareVertexProcessing;
if (caps.DeviceCaps.SupportsHardwareRasterization && caps.DeviceCaps.SupportsHardwareTransformAndLight)
{
flags = D3D.CreateFlags.HardwareVertexProcessing;
if (caps.DeviceCaps.SupportsPureDevice)
{
flags |= D3D.CreateFlags.PureDevice;
}
}
DebugOnly.ConsoleWrite("Found flags: " + flags.ToString());
return(flags);
}
public bool IsDeviceAcceptable(Microsoft.DirectX.Direct3D.Caps caps, Microsoft.DirectX.Direct3D.Format adapterFormat, Microsoft.DirectX.Direct3D.Format backBufferFormat, bool isWindowed)
{
// No fallback, need at least PS1.1
if (caps.PixelShaderVersion < new Version(1, 1))
{
return(false);
}
// Skip back buffer formats that don't support alpha blending
if (!Manager.CheckDeviceFormat(caps.AdapterOrdinal, caps.DeviceType, adapterFormat,
Usage.QueryPostPixelShaderBlending, ResourceType.Textures, backBufferFormat))
{
return(false);
}
return(true);
}
//***************************************************************************
// Static Methods
//
public static D3D.DeviceType GetDeviceType(int adpNum)
{
DebugOnly.ConsoleWrite("Determining device type...");
D3D.DeviceType devType = D3D.DeviceType.Reference;
D3D.Caps devCaps = D3D.Manager.GetDeviceCaps(adpNum, D3D.DeviceType.Hardware);
if (devCaps.DeviceCaps.SupportsHardwareRasterization)
{
devType = D3D.DeviceType.Hardware;
}
else if (devCaps.DeviceType == D3D.DeviceType.Software)
{
devType = D3D.DeviceType.Software;
}
DebugOnly.ConsoleWrite("Found DeviceType: " + devType.ToString());
return(devType);
}
public static int ConvertEnum(TexCoordCalcMethod method, D3D.Caps caps)
{
switch (method)
{
case TexCoordCalcMethod.None:
return((int)D3D.TextureCoordinateIndex.PassThru);
case TexCoordCalcMethod.EnvironmentMapReflection:
return((int)D3D.TextureCoordinateIndex.CameraSpaceReflectionVector);
case TexCoordCalcMethod.EnvironmentMapPlanar:
//return (int)D3D.TextureCoordinateIndex.CameraSpacePosition;
if (caps.VertexProcessingCaps.SupportsTextureGenerationSphereMap)
{
// use sphere map if available
return((int)D3D.TextureCoordinateIndex.SphereMap);
}
else
{
// If not, fall back on camera space reflection vector which isn't as good
return((int)D3D.TextureCoordinateIndex.CameraSpaceReflectionVector);
}
case TexCoordCalcMethod.EnvironmentMapNormal:
return((int)D3D.TextureCoordinateIndex.CameraSpaceNormal);
case TexCoordCalcMethod.EnvironmentMap:
if (caps.VertexProcessingCaps.SupportsTextureGenerationSphereMap)
{
return((int)D3D.TextureCoordinateIndex.SphereMap);
}
else
{
// fall back on camera space normal if sphere map isnt supported
return((int)D3D.TextureCoordinateIndex.CameraSpaceNormal);
}
case TexCoordCalcMethod.ProjectiveTexture:
return((int)D3D.TextureCoordinateIndex.CameraSpacePosition);
} // switch
return(0);
}
public void ModifyDeviceSettings(DeviceSettings settings, Microsoft.DirectX.Direct3D.Caps caps)
{
// If device doesn't support HW T&L or doesn't support 1.1 vertex shaders in HW
// then switch to SWVP.
if ((!caps.DeviceCaps.SupportsHardwareTransformAndLight) ||
(caps.VertexShaderVersion < new Version(1, 1)))
{
settings.BehaviorFlags = CreateFlags.SoftwareVertexProcessing;
}
else
{
settings.BehaviorFlags = CreateFlags.HardwareVertexProcessing;
}
// This application is designed to work on a pure device by not using
// any get methods, so create a pure device if supported and using HWVP.
if ((caps.DeviceCaps.SupportsPureDevice) &&
((settings.BehaviorFlags & CreateFlags.HardwareVertexProcessing) != 0))
{
settings.BehaviorFlags |= CreateFlags.PureDevice;
}
// Debugging vertex shaders requires either REF or software vertex processing
// and debugging pixel shaders requires REF.
#if (DEBUG_VS)
if (settings.DeviceType != DeviceType.Reference)
{
settings.BehaviorFlags &= ~CreateFlags.HardwareVertexProcessing;
settings.BehaviorFlags |= CreateFlags.SoftwareVertexProcessing;
}
#endif
#if (DEBUG_PS)
settings.DeviceType = DeviceType.Reference;
#endif
// For the first device created if its a REF device, optionally display a warning dialog box
if (settings.DeviceType == DeviceType.Reference)
{
Utility.DisplaySwitchingToRefWarning(sampleFramework, "ProgressiveMesh");
}
}
/// <summary>
/// Initialize the device objects
/// </summary>
/// <param name="dev">The grpahics device used to initialize</param>
public void InitializeDeviceObjects(Device dev)
{
if (dev != null)
{
// Set up our events
dev.DeviceReset += new System.EventHandler(this.RestoreDeviceObjects);
}
// Keep a local copy of the device
device = dev;
textureState0 = device.TextureState[0];
textureState1 = device.TextureState[1];
samplerState0 = device.SamplerState[0];
renderState = device.RenderState;
// Establish the font and texture size
textureScale = 1.0f; // Draw fonts into texture without scaling
// Large fonts need larger textures
if (ourFontHeight > 60)
{
textureWidth = textureHeight = 2048;
}
else if (ourFontHeight > 30)
{
textureWidth = textureHeight = 1024;
}
else if (ourFontHeight > 15)
{
textureWidth = textureHeight = 512;
}
else
{
textureWidth = textureHeight = 256;
}
// If requested texture is too big, use a smaller texture and smaller font,
// and scale up when rendering.
Direct3D.Caps d3dCaps = device.DeviceCaps;
if (textureWidth > d3dCaps.MaxTextureWidth)
{
textureScale = (float)d3dCaps.MaxTextureWidth / (float)textureWidth;
textureWidth = textureHeight = d3dCaps.MaxTextureWidth;
}
Bitmap bmp = new Bitmap(textureWidth, textureHeight, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
Graphics g = Graphics.FromImage(bmp);
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
g.TextContrast = 0;
string str;
float x = 0;
float y = 0;
Point p = new Point(0, 0);
Size size = new Size(0, 0);
// Calculate the spacing between characters based on line height
size = g.MeasureString(" ", systemFont).ToSize();
x = spacingPerChar = (int)Math.Ceiling(size.Height * 0.3);
for (char c = (char)32; c < (char)127; c++)
{
str = c.ToString();
// We need to do some things here to get the right sizes. The default implemententation of MeasureString
// will return a resolution independant size. For our height, this is what we want. However, for our width, we
// want a resolution dependant size.
Size resSize = g.MeasureString(str, systemFont).ToSize();
size.Height = resSize.Height + 1;
// Now the Resolution independent width
if (c != ' ') // We need the special case here because a space has a 0 width in GenericTypoGraphic stringformats
{
resSize = g.MeasureString(str, systemFont, p, StringFormat.GenericTypographic).ToSize();
size.Width = resSize.Width;
}
else
{
size.Width = resSize.Width;
}
if ((x + size.Width + spacingPerChar) > textureWidth)
{
x = spacingPerChar;
y += size.Height;
}
if (c != ' ') // We need the special case here because a space has a 0 width in GenericTypoGraphic stringformats
{
g.DrawString(str, systemFont, Brushes.White, new Point((int)x, (int)y), StringFormat.GenericTypographic);
}
else
{
g.DrawString(str, systemFont, Brushes.White, new Point((int)x, (int)y));
}
textureCoords[c - 32, 0] = ((float)(x + 0 - spacingPerChar)) / textureWidth;
textureCoords[c - 32, 1] = ((float)(y + 0 + 0)) / textureHeight;
textureCoords[c - 32, 2] = ((float)(x + size.Width + spacingPerChar)) / textureWidth;
textureCoords[c - 32, 3] = ((float)(y + size.Height + 0)) / textureHeight;
x += size.Width + (2 * spacingPerChar);
}
// Create a new texture for the font from the bitmap we just created
fontTexture = Texture.FromBitmap(device, bmp, 0, Pool.Managed);
RestoreDeviceObjects(null, null);
}
private D3D.Device InitDevice(bool isFullscreen, bool depthBuffer, int width, int height, int colorDepth, Control target)
{
if(device != null) {
return device;
}
// we don't care about event handlers
Device.IsUsingEventHandlers = false;
D3D.Device newDevice;
PresentParameters presentParams = CreatePresentationParams(isFullscreen, depthBuffer, width, height, colorDepth);
// create the D3D Device, trying for the best vertex support first, and settling for less if necessary
try {
// hardware vertex processing
int adapterNum = 0;
DeviceType type = DeviceType.Hardware;
#if DEBUG
for ( int i = 0; i < Manager.Adapters.Count; i++ ) {
if (Manager.Adapters[i].Information.Description == "NVIDIA NVPerfHUD")
{
adapterNum = i;
type = DeviceType.Reference;
}
}
#endif
// use this with NVPerfHUD
newDevice = new D3D.Device(adapterNum, type, target, CreateFlags.HardwareVertexProcessing, presentParams);
// newDevice = new D3D.Device(0, DeviceType.Hardware, target, CreateFlags.HardwareVertexProcessing, presentParams);
}
catch(Exception) {
try {
// doh, how bout mixed vertex processing
newDevice = new D3D.Device(0, DeviceType.Hardware, target, CreateFlags.MixedVertexProcessing, presentParams);
}
catch(Exception) {
// what the...ok, how bout software vertex procssing. if this fails, then I don't even know how they are seeing
// anything at all since they obviously don't have a video card installed
newDevice = new D3D.Device(0, DeviceType.Hardware, target, CreateFlags.SoftwareVertexProcessing, presentParams);
}
}
// CMH - end
// save the device capabilites
d3dCaps = newDevice.DeviceCaps;
// by creating our texture manager, singleton TextureManager will hold our implementation
textureMgr = new D3DTextureManager(newDevice);
// by creating our Gpu program manager, singleton GpuProgramManager will hold our implementation
gpuProgramMgr = new D3DGpuProgramManager(newDevice);
// intializes the HardwareBufferManager singleton
hardwareBufferManager = new D3DHardwareBufferManager(newDevice);
return newDevice;
}
/// <summary>
/// Helper method to go through and interrogate hardware capabilities.
/// </summary>
private void InitCapabilities()
{
// get caps
d3dCaps = device.DeviceCaps;
// max active lights
caps.MaxLights = d3dCaps.MaxActiveLights;
D3D.Surface surface = device.DepthStencilSurface;
D3D.SurfaceDescription surfaceDesc = surface.Description;
surface.Dispose();
if (surfaceDesc.Format == D3D.Format.D24S8 || surfaceDesc.Format == D3D.Format.D24X8) {
caps.SetCap(Capabilities.StencilBuffer);
// Actually, it's always 8-bit
caps.StencilBufferBits = 8;
}
// Set number of texture units
caps.TextureUnitCount = d3dCaps.MaxSimultaneousTextures;
// some cards, oddly enough, do not support this
if(d3dCaps.DeclTypes.SupportsUByte4) {
caps.SetCap(Capabilities.VertexFormatUByte4);
}
// Anisotropy?
if(d3dCaps.MaxAnisotropy > 1) {
caps.SetCap(Capabilities.AnisotropicFiltering);
}
// Hardware mipmapping?
if(d3dCaps.DriverCaps.CanAutoGenerateMipMap) {
caps.SetCap(Capabilities.HardwareMipMaps);
}
// blending between stages is definately supported
caps.SetCap(Capabilities.TextureBlending);
caps.SetCap(Capabilities.MultiTexturing);
// Dot3 bump mapping?
if(d3dCaps.TextureOperationCaps.SupportsDotProduct3) {
caps.SetCap(Capabilities.Dot3);
}
// Cube mapping?
if(d3dCaps.TextureCaps.SupportsCubeMap) {
caps.SetCap(Capabilities.CubeMapping);
}
// Texture Compression
// We always support compression, D3DX will decompress if device does not support
caps.SetCap(Capabilities.TextureCompression);
caps.SetCap(Capabilities.TextureCompressionDXT);
// D3D uses vertex buffers for everything
caps.SetCap(Capabilities.VertexBuffer);
// Scissor test
if(d3dCaps.RasterCaps.SupportsScissorTest) {
caps.SetCap(Capabilities.ScissorTest);
}
// 2 sided stencil
if(d3dCaps.StencilCaps.SupportsTwoSided) {
caps.SetCap(Capabilities.TwoSidedStencil);
}
// stencil wrap
if(d3dCaps.StencilCaps.SupportsIncrement && d3dCaps.StencilCaps.SupportsDecrement) {
caps.SetCap(Capabilities.StencilWrap);
}
// Hardware Occlusion
try {
D3D.Query test = new D3D.Query(device, QueryType.Occlusion);
// if we made it this far, it is supported
caps.SetCap(Capabilities.HardwareOcculusion);
test.Dispose();
}
catch {
// eat it, this is not supported
// TODO: Isn't there a better way to check for D3D occlusion query support?
}
if(d3dCaps.MaxUserClipPlanes > 0) {
caps.SetCap(Capabilities.UserClipPlanes);
}
CheckVertexProgramCaps();
CheckFragmentProgramCaps();
Driver driver = D3DHelper.GetDriverInfo();
AdapterDetails details = D3D.Manager.Adapters[driver.AdapterNumber].Information;
caps.DeviceName = details.Description;
caps.DriverVersion = details.DriverVersion.ToString();
try {
//
// use the dxdiag interface to get the actual size of video memory
//
Container container = new Container(false);
container = container.GetContainer("DxDiag_DisplayDevices").Container;
container = container.GetContainer(0).Container;
Microsoft.DirectX.Diagnostics.PropertyData prop = container.GetProperty("szDisplayMemoryEnglish");
string s = prop.Data as string;
int numStartOffset = -1;
for (int i = 0; i < s.Length; i++) {
char c = s[i];
if (char.IsDigit(s[i])) {
numStartOffset = i;
break;
}
}
if (numStartOffset >= 0) {
int numEndOffset;
for (numEndOffset = numStartOffset; numEndOffset < s.Length; numEndOffset++) {
if (!char.IsDigit(s[numEndOffset])) {
break;
}
}
string numString = s.Substring(numStartOffset, numEndOffset - numStartOffset);
//LogManager.Instance.Write("DXDiag memory size string returned: {0}", s);
//LogManager.Instance.Write("parsing memory size string: {0}", numString);
caps.VideoMemorySize = int.Parse(numString);
//LogManager.Instance.Write("Parsed memory size value is: {0}", caps.VideoMemorySize);
} else {
// couldn't determine size
caps.VideoMemorySize = 0;
}
} catch (Exception) {
#if FALSE_WARNING_IS_FIXED
log.Warn("DXDiag unable to determine memory size.");
#endif
// couldn't determine size
caps.VideoMemorySize = 0;
}
// Infinite projection?
// We have no capability for this, so we have to base this on our
// experience and reports from users
// Non-vertex program capable hardware does not appear to support it
if(caps.CheckCap(Capabilities.VertexPrograms)) {
// GeForce4 Ti (and presumably GeForce3) does not
// render infinite projection properly, even though it does in GL
// So exclude all cards prior to the FX range from doing infinite
// not nVidia or GeForceFX and above
if(details.VendorId != 0x10DE || details.DeviceId >= 0x0301) {
caps.SetCap(Capabilities.InfiniteFarPlane);
}
}
// TODO: Add the rest of the caps.
caps.NumMultiRenderTargets = d3dCaps.NumberSimultaneousRts;
// write hardware capabilities to registered log listeners
caps.Log();
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <param name="options"></param>
/// <param name="caps"></param>
/// <param name="texType"></param>
/// <returns></returns>
public static D3D.TextureFilter ConvertEnum(FilterType type, FilterOptions options, D3D.Caps devCaps, D3DTexType texType)
{
// setting a default val here to keep compiler from complaining about using unassigned value types
D3D.FilterCaps filterCaps = devCaps.TextureFilterCaps;
switch (texType)
{
case D3DTexType.Normal:
filterCaps = devCaps.TextureFilterCaps;
break;
case D3DTexType.Cube:
filterCaps = devCaps.CubeTextureFilterCaps;
break;
case D3DTexType.Volume:
filterCaps = devCaps.VolumeTextureFilterCaps;
break;
}
switch (type)
{
case FilterType.Min: {
switch (options)
{
case FilterOptions.Anisotropic:
if (filterCaps.SupportsMinifyAnisotropic)
{
return(D3D.TextureFilter.Anisotropic);
}
else
{
return(D3D.TextureFilter.Linear);
}
case FilterOptions.Linear:
if (filterCaps.SupportsMinifyLinear)
{
return(D3D.TextureFilter.Linear);
}
else
{
return(D3D.TextureFilter.Point);
}
case FilterOptions.Point:
case FilterOptions.None:
return(D3D.TextureFilter.Point);
}
break;
}
case FilterType.Mag: {
switch (options)
{
case FilterOptions.Anisotropic:
if (filterCaps.SupportsMagnifyAnisotropic)
{
return(D3D.TextureFilter.Anisotropic);
}
else
{
return(D3D.TextureFilter.Linear);
}
case FilterOptions.Linear:
if (filterCaps.SupportsMagnifyLinear)
{
return(D3D.TextureFilter.Linear);
}
else
{
return(D3D.TextureFilter.Point);
}
case FilterOptions.Point:
case FilterOptions.None:
return(D3D.TextureFilter.Point);
}
break;
}
case FilterType.Mip: {
switch (options)
{
case FilterOptions.Anisotropic:
case FilterOptions.Linear:
if (filterCaps.SupportsMipMapLinear)
{
return(D3D.TextureFilter.Linear);
}
else
{
return(D3D.TextureFilter.Point);
}
case FilterOptions.Point:
if (filterCaps.SupportsMipMapPoint)
{
return(D3D.TextureFilter.Point);
}
else
{
return(D3D.TextureFilter.None);
}
case FilterOptions.None:
return(D3D.TextureFilter.None);
}
break;
}
}
// should never get here
return(0);
}
/// <summary>
/// Static method for converting LayerBlendOperationEx enum values to the Direct3D
/// TextureOperation enum.
/// </summary>
/// <param name="blendop"></param>
/// <returns></returns>
public static D3D.TextureOperation ConvertEnum(LayerBlendOperationEx blendop, D3D.Caps devCaps)
{
D3D.TextureOperation d3dTexOp = 0;
// figure out what is what
switch (blendop)
{
case LayerBlendOperationEx.Source1:
d3dTexOp = D3D.TextureOperation.SelectArg1;
break;
case LayerBlendOperationEx.Source2:
d3dTexOp = D3D.TextureOperation.SelectArg2;
break;
case LayerBlendOperationEx.Modulate:
d3dTexOp = D3D.TextureOperation.Modulate;
break;
case LayerBlendOperationEx.ModulateX2:
d3dTexOp = D3D.TextureOperation.Modulate2X;
break;
case LayerBlendOperationEx.ModulateX4:
d3dTexOp = D3D.TextureOperation.Modulate4X;
break;
case LayerBlendOperationEx.Add:
d3dTexOp = D3D.TextureOperation.Add;
break;
case LayerBlendOperationEx.AddSigned:
d3dTexOp = D3D.TextureOperation.AddSigned;
break;
case LayerBlendOperationEx.AddSmooth:
d3dTexOp = D3D.TextureOperation.AddSmooth;
break;
case LayerBlendOperationEx.Subtract:
d3dTexOp = D3D.TextureOperation.Subtract;
break;
case LayerBlendOperationEx.BlendDiffuseAlpha:
d3dTexOp = D3D.TextureOperation.BlendDiffuseAlpha;
break;
case LayerBlendOperationEx.BlendTextureAlpha:
d3dTexOp = D3D.TextureOperation.BlendTextureAlpha;
break;
case LayerBlendOperationEx.BlendCurrentAlpha:
d3dTexOp = D3D.TextureOperation.BlendCurrentAlpha;
break;
case LayerBlendOperationEx.BlendManual:
d3dTexOp = D3D.TextureOperation.BlendFactorAlpha;
break;
case LayerBlendOperationEx.DotProduct:
if (Root.Instance.RenderSystem.Caps.CheckCap(Capabilities.Dot3))
{
d3dTexOp = D3D.TextureOperation.DotProduct3;
}
else
{
d3dTexOp = D3D.TextureOperation.Modulate;
}
break;
case LayerBlendOperationEx.BlendDiffuseColor:
if (devCaps.TextureOperationCaps.SupportsLerp)
{
d3dTexOp = D3D.TextureOperation.Lerp;
}
else
{
d3dTexOp = D3D.TextureOperation.Modulate;
}
break;
} // end switch
return(d3dTexOp);
}
protected void InitDevice()
{
Debug.Assert(device != null);
// get device caps
devCaps = device.DeviceCaps;
// get our device creation parameters
devParms = device.CreationParameters;
// get our back buffer pixel format
using (D3D.Surface back = device.GetBackBuffer(0, 0, D3D.BackBufferType.Mono)) {
bbPixelFormat = back.Description.Format;
}
}
/// <summary>
/// Initialize the device objects
/// </summary>
/// <param name="dev">The grpahics device used to initialize</param>
public void InitializeDeviceObjects(Device dev)
{
if (dev != null)
{
// Set up our events
dev.DeviceReset += new System.EventHandler(this.RestoreDeviceObjects);
}
// Keep a local copy of the device
device = dev;
textureState0 = device.TextureState[0];
textureState1 = device.TextureState[1];
samplerState0 = device.SamplerState[0];
renderState = device.RenderState;
// Create a bitmap on which to measure the alphabet
Bitmap bmp = new Bitmap(1, 1, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
Graphics g = Graphics.FromImage(bmp);
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
g.TextContrast = 0;
// Establish the font and texture size
textureScale = 1.0f; // Draw fonts into texture without scaling
// Calculate the dimensions for the smallest power-of-two texture which
// can hold all the printable characters
textureWidth = textureHeight = 128;
for (;;)
{
try
{
// Measure the alphabet
PaintAlphabet(g, true);
}
catch (System.InvalidOperationException)
{
// Scale up the texture size and try again
textureWidth *= 2;
textureHeight *= 2;
continue;
}
break;
}
// If requested texture is too big, use a smaller texture and smaller font,
// and scale up when rendering.
Direct3D.Caps d3dCaps = device.DeviceCaps;
// If the needed texture is too large for the video card...
if (textureWidth > d3dCaps.MaxTextureWidth)
{
// Scale the font size down to fit on the largest possible texture
textureScale = (float)d3dCaps.MaxTextureWidth / (float)textureWidth;
textureWidth = textureHeight = d3dCaps.MaxTextureWidth;
for (;;)
{
// Create a new, smaller font
ourFontHeight = (int)Math.Floor(ourFontHeight * textureScale);
systemFont = new System.Drawing.Font(systemFont.Name, ourFontHeight, systemFont.Style);
try
{
// Measure the alphabet
PaintAlphabet(g, true);
}
catch (System.InvalidOperationException)
{
// If that still doesn't fit, scale down again and continue
textureScale *= 0.9F;
continue;
}
break;
}
}
// Release the bitmap used for measuring and create one for drawing
bmp.Dispose();
bmp = new Bitmap(textureWidth, textureHeight, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
g = Graphics.FromImage(bmp);
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
g.TextContrast = 0;
// Draw the alphabet
PaintAlphabet(g, false);
// Create a new texture for the font from the bitmap we just created
fontTexture = Texture.FromBitmap(device, bmp, 0, Pool.Managed);
RestoreDeviceObjects(null, null);
}
public ScreenAccess()
{
try
{
Direct3D.PresentParameters presentParams = new Direct3D.PresentParameters();
presentParams.Windowed = true;
presentParams.SwapEffect = Direct3D.SwapEffect.Discard;
presentParams.EnableAutoDepthStencil = true;
presentParams.AutoDepthStencilFormat = Direct3D.DepthFormat.D16;
Direct3D.Caps hardware = Direct3D.Manager.GetDeviceCaps(0, Direct3D.DeviceType.Hardware);
Direct3D.CreateFlags flags = Direct3D.CreateFlags.SoftwareVertexProcessing;
// Search for the highest possible shader support and define the device.
if (hardware.VertexShaderVersion >= new Version(2, 0))
{
if (hardware.DeviceCaps.SupportsHardwareTransformAndLight)
{
flags = Direct3D.CreateFlags.HardwareVertexProcessing;
}
if (hardware.DeviceCaps.SupportsPureDevice)
{
flags |= Direct3D.CreateFlags.PureDevice;
}
if (hardware.PixelShaderVersion >= new Version(3, 0))
{
CardShader = GameEngine.ShaderLevel.Pixel_3_0;
}
else if (hardware.PixelShaderVersion >= new Version(2, 2))
{
CardShader = GameEngine.ShaderLevel.Pixel_2_b;
}
else if (hardware.PixelShaderVersion >= new Version(2, 0))
{
CardShader = GameEngine.ShaderLevel.Pixel_2_0;
}
else if (hardware.PixelShaderVersion >= new Version(1, 4))
{
CardShader = GameEngine.ShaderLevel.Pixel_1_4;
}
else
{
CardShader = GameEngine.ShaderLevel.NoShaders;
}
device = new Direct3D.Device(0, Direct3D.DeviceType.Hardware, this, flags, presentParams);
}
else if (hardware.VertexShaderVersion >= new Version(1, 1))
{
if (hardware.DeviceCaps.SupportsHardwareTransformAndLight)
{
flags = Direct3D.CreateFlags.HardwareVertexProcessing;
}
if (hardware.DeviceCaps.SupportsPureDevice)
{
flags |= Direct3D.CreateFlags.PureDevice;
}
if (hardware.PixelShaderVersion >= new Version(1, 4))
{
CardShader = GameEngine.ShaderLevel.Pixel_1_4;
}
else
{
CardShader = GameEngine.ShaderLevel.NoShaders;
}
device = new Direct3D.Device(0, Direct3D.DeviceType.Hardware, this, flags, presentParams);
}
//TODO: test this on shit cards and fake cards to see if they can use DeviceType.Hardware
else
{
CardShader = GameEngine.ShaderLevel.NoShaders;
device = new Direct3D.Device(0, Direct3D.DeviceType.Hardware, this,
Direct3D.CreateFlags.SoftwareVertexProcessing, presentParams);
}
//Setup Alpha Blending
this.device.RenderState.AlphaBlendOperation = Direct3D.BlendOperation.Add;
this.device.RenderState.AlphaTestEnable = true;
this.device.RenderState.ReferenceAlpha = 0x08;
this.device.RenderState.AlphaFunction = Direct3D.Compare.GreaterEqual;
this.device.SetTextureStageState(0, Direct3D.TextureStageStates.AlphaOperation, true);
//Get the best texture filtering available from the card
if (this.device.DeviceCaps.TextureFilterCaps.SupportsMinifyAnisotropic == true &&
this.device.DeviceCaps.TextureFilterCaps.SupportsMagnifyAnisotropic == true)
{
this.PreferedTextureFilter = Direct3D.TextureFilter.Anisotropic;
}
else if (this.device.DeviceCaps.TextureFilterCaps.SupportsMinifyLinear == true &&
this.device.DeviceCaps.TextureFilterCaps.SupportsMagnifyLinear == true)
{
this.PreferedTextureFilter = Direct3D.TextureFilter.Linear;
}
else
{
this.PreferedTextureFilter = Direct3D.TextureFilter.None;
}
//Add window events to hardware screen device
this.DeligateEventsToDevices();
}
catch (Exception err)
{
throw new Exception(err.StackTrace);
}
}
