public Terrain(Device device, String texture, int pitch, Renderer renderer)
{
HeightMap = new System.Drawing.Bitmap(@"Data/Textures/"+texture);
WaterShader = new WaterShader(device);
TerrainShader = new TerrainShader(device);
_width = HeightMap.Width-1;
_height = HeightMap.Height-1;
_pitch = pitch;
_terrainTextures = new ShaderResourceView[4];
_terrainTextures[0] = new Texture(device, "Sand.png").TextureResource;
_terrainTextures[1] = new Texture(device, "Grass.png").TextureResource;
_terrainTextures[2] = new Texture(device, "Ground.png").TextureResource;
_terrainTextures[3] = new Texture(device, "Rock.png").TextureResource;
_reflectionClippingPlane = new Vector4(0.0f, 1.0f, 0.0f, 0.0f);
_refractionClippingPlane = new Vector4(0.0f, -1.0f, 0.0f, 0.0f);
_noClippingPlane = new Vector4(0.0f, 1.0f, 0.0f, 10000);
_reflectionTexture = new RenderTexture(device, renderer.ScreenSize);
_refractionTexture = new RenderTexture(device, renderer.ScreenSize);
_renderer = renderer;
_bitmap = new Bitmap(device,_refractionTexture.ShaderResourceView,renderer.ScreenSize, new Vector2I(100, 100), 0);
_bitmap.Position = new Vector2I(renderer.ScreenSize.X - 100, 0);
_bitmap2 = new Bitmap(device, _reflectionTexture.ShaderResourceView, renderer.ScreenSize, new Vector2I(100, 100), 0);
_bitmap2.Position = new Vector2I(renderer.ScreenSize.X - 100, 120);
_bumpMap = _renderer.TextureManager.Create("OceanWater.png");
_skydome = new ObjModel(device, "skydome.obj", renderer.TextureManager.Create("Sky.png"));
BuildBuffers(device);
WaveTranslation = new Vector2(0,0);
}
public PhysicsDebugDraw(DeviceManager manager)
{
device = manager.Direct3DDevice;
inputAssembler = device.ImmediateContext.InputAssembler;
lineArray = new PositionColored[0];
using (var bc = HLSLCompiler.CompileFromFile(@"Shaders\PhysicsDebug.hlsl", "VSMain", "vs_5_0"))
{
vertexShader = new VertexShader(device, bc);
InputElement[] elements = new InputElement[]
{
new InputElement("SV_POSITION", 0, Format.R32G32B32_Float, 0, 0, InputClassification.PerVertexData, 0),
new InputElement("COLOR", 0, Format.R8G8B8A8_UNorm, 12, 0, InputClassification.PerVertexData, 0)
};
inputLayout = new InputLayout(device, bc, elements);
}
vertexBufferDesc = new BufferDescription()
{
Usage = ResourceUsage.Dynamic,
BindFlags = BindFlags.VertexBuffer,
CpuAccessFlags = CpuAccessFlags.Write
};
vertexBufferBinding = new VertexBufferBinding(null, PositionColored.Stride, 0);
using (var bc = HLSLCompiler.CompileFromFile(@"Shaders\PhysicsDebug.hlsl", "PSMain", "ps_5_0"))
pixelShader = new PixelShader(device, bc);
}
public DrawingSurface(DrawingBackend backend, int width, int height)
{
if (width < 0 || height < 0)
throw new Exception("Area of DrawingSurface's is neagative");
_factory = backend.Factory;
_device = backend.Device;
_backend = backend;
_width = width;
_height = height;
var textureDesc = new Texture2DDescription
{
MipLevels = 1,
ArraySize = 1,
BindFlags = BindFlags.RenderTarget,
CpuAccessFlags = CpuAccessFlags.None,
Format = Format.B8G8R8A8_UNorm,
OptionFlags = ResourceOptionFlags.None,
Width = _width,
Height = _height,
Usage = ResourceUsage.Default,
SampleDescription = new SampleDescription(1, 0)
};
_texture = new Texture2D(_device, textureDesc);
}
public bool Initialize(Device device, DeviceContext deviceContext, IntPtr windowHandle, int screanWidth, int screenHeight, Matrix baseViewMatrix)
{
// Store the screen width and height.
ScreenWidth = screanWidth;
ScreenHeight = screenHeight;
// Store the base view matrix.
BaseViewMatrix = baseViewMatrix;
// Create the font object.
Font = new Font();
// Initialize the font object.
if (!Font.Initialize(device, "fontdata.txt", "font.dds"))
return false;
// Create the font shader object.
FontShader = new FontShader();
// Initialize the font shader object.
if (!FontShader.Initialize(device, windowHandle))
return false;
// Initialize the first sentence.
if (!InitializeSentence(out sentences[0], 32, device))
return false;
// Now update the sentence vertex buffer with the new string information.
if (!UpdateSentece(ref sentences[0], "Render Count:", 20, 20, 1, 1, 1, deviceContext))
return false;
return true;
}
/// <summary>
/// Create a buffer containing all GameColors
/// </summary>
public static SharpDX.Direct3D11.Buffer CreateGameColorBuffer(Device device)
{
int numcolors = GameColorRGB.NUMCOLORS;
var arr = new int[numcolors];
for (int i = 0; i < numcolors; ++i)
{
var gc = (GameColor)i;
arr[i] = GameColorRGB.FromGameColor(gc).ToInt32();
}
SharpDX.Direct3D11.Buffer colorBuffer;
using (var stream = DataStream.Create(arr, true, false))
{
colorBuffer = new SharpDX.Direct3D11.Buffer(device, stream, new BufferDescription()
{
BindFlags = BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None,
SizeInBytes = sizeof(int) * arr.Length,
Usage = ResourceUsage.Immutable,
});
}
return colorBuffer;
}
// Used with soft bodies
public void SetDynamicVertexBuffer(Device device, Vector3[] vectors)
{
if (VertexBuffer != null && VertexCount * 2 == vectors.Length)
{
DataBox db = device.ImmediateContext.MapSubresource(VertexBuffer, 0, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None);
SharpDX.Utilities.Write(db.DataPointer, vectors, 0, vectors.Length);
device.ImmediateContext.UnmapSubresource(VertexBuffer, 0);
}
else
{
// Create new buffer
if (VertexBuffer != null)
VertexBuffer.Dispose();
BufferDescription vertexBufferDesc = new BufferDescription()
{
SizeInBytes = Vector3.SizeInBytes * vectors.Length,
Usage = ResourceUsage.Dynamic,
BindFlags = BindFlags.VertexBuffer,
CpuAccessFlags = CpuAccessFlags.Write
};
using (var data = new DataStream(vertexBufferDesc.SizeInBytes, false, true))
{
data.WriteRange(vectors);
data.Position = 0;
VertexBuffer = new Buffer(device, data, vertexBufferDesc);
}
VertexCount = vectors.Length / 2;
BufferBindings[0] = new VertexBufferBinding(VertexBuffer, 24, 0);
}
}
public bool Initialize(Device device, string heightMapFileName)
{
// Load the height map for the terrain
if (!LoadHeightMapFilename(heightMapFileName))
return false;
// Normalize the height of the height map
NormalizeHeightMap();
// Calculate the normals for the terrain data.
if (!CalculateNormals())
return false;
// Set the number of vertices per quad (2 triangles)
NumberOfVerticesPerQuad = 6;
// Set the value of the topology
CurrentTopology = PrimitiveTopology.TriangleList;
// Initialize the vertex and index buffer.
if (!InitializeBuffers(device))
return false;
return true;
}
public DepthBuffer(Device device, int width, int height)
{
try
{
_device = device;
_depthBuffer = new Texture2D(_device, new Texture2DDescription
{
Format = Format.D32_Float_S8X24_UInt,
ArraySize = 1,
MipLevels = 1,
Width = width,
Height = height,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
});
_depthView = new DepthStencilView(device, _depthBuffer);
}
catch
{
Dispose();
throw;
}
}
// ReSharper restore InconsistentNaming
static CompositionEngine()
{
_wicFactory = new SharpDX.WIC.ImagingFactory();
_dWriteFactory = new SharpDX.DirectWrite.Factory();
var d3DDevice = new SharpDX.Direct3D11.Device(
DriverType.Hardware,
DeviceCreationFlags.BgraSupport
#if DEBUG
| DeviceCreationFlags.Debug
#endif
,
FeatureLevel.Level_11_1,
FeatureLevel.Level_11_0,
FeatureLevel.Level_10_1,
FeatureLevel.Level_10_0,
FeatureLevel.Level_9_3,
FeatureLevel.Level_9_2,
FeatureLevel.Level_9_1
);
var dxgiDevice = ComObject.As<SharpDX.DXGI.Device>(d3DDevice.NativePointer);
//new SharpDX.DXGI.Device2(d3DDevice.NativePointer);
var d2DDevice = new SharpDX.Direct2D1.Device(dxgiDevice);
_d2DFactory = d2DDevice.Factory;
_d2DDeviceContext = new SharpDX.Direct2D1.DeviceContext(d2DDevice, D2D.DeviceContextOptions.None);
_d2DDeviceContext.DotsPerInch = new Size2F(LogicalDpi, LogicalDpi);
}
public RenderTexture(Device device, Vector2I screenSize)
{
var textureDesc = new Texture2DDescription()
{
Width = screenSize.X,
Height = screenSize.Y,
MipLevels = 1,
ArraySize = 1,
Format = Format.R32G32B32A32_Float,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
};
_renderTargetTexture = new Texture2D(device, textureDesc);
_renderTargetView = new RenderTargetView(device, _renderTargetTexture,
new RenderTargetViewDescription
{
Format = textureDesc.Format,
Dimension = RenderTargetViewDimension.Texture2D,
Texture2D = {MipSlice = 0},
});
// Create the render target view.
ShaderResourceView = new ShaderResourceView(device, _renderTargetTexture,
new ShaderResourceViewDescription
{
Format = textureDesc.Format,
Dimension = ShaderResourceViewDimension.Texture2D,
Texture2D = { MipLevels = 1, MostDetailedMip = 0 },
});
}
public Bitmap(Device device, ShaderResourceView texture, Vector2I screenSize, Vector2I size, float depth = 0.0f)
{
Texture = texture;
ScreenSize = screenSize;
Size = size;
_changed = true;
Depth = depth;
VertexCount = 4;
IndexCount = 6;
_vertices = new TranslateShader.Vertex[VertexCount];
UInt32[] indices = {0, 1, 2, 0, 3, 1};
VertexBuffer = Buffer.Create(device, _vertices,
new BufferDescription
{
Usage = ResourceUsage.Dynamic,
SizeInBytes = Utilities.SizeOf<TranslateShader.Vertex>() * VertexCount,
BindFlags = BindFlags.VertexBuffer,
CpuAccessFlags = CpuAccessFlags.Write,
OptionFlags = ResourceOptionFlags.None,
StructureByteStride = 0
});
IndexBuffer = Buffer.Create(device, BindFlags.IndexBuffer, indices);
}
public ProjectorFormLoader(String path)
{
Forms = new List<ProjectorForm>();
// load ensemble.xml
string directory = Path.GetDirectoryName(path);
var ensemble = ProjectorCameraEnsemble.FromFile(path);
// create d3d device
var factory = new Factory1();
var adapter = factory.Adapters[0];
// When using DeviceCreationFlags.Debug on Windows 10, ensure that "Graphics Tools" are installed via Settings/System/Apps & features/Manage optional features.
// Also, when debugging in VS, "Enable native code debugging" must be selected on the project.
var device = new SharpDX.Direct3D11.Device(adapter, DeviceCreationFlags.None);
Object renderLock = new Object();
// create a form for each projector
foreach (var projector in ensemble.projectors) {
var form = new ProjectorForm(factory, device, renderLock, projector);
form.FullScreen = FULLSCREEN_ENABLED; // TODO: fix this so can be called after Show
form.Show();
Forms.Add(form);
}
}
/// <summary>
/// Copies the content of the specified texture.
/// </summary>
/// <param name="device">The Direct3D 11 device.</param>
/// <param name="source">The source texture.</param>
/// <param name="target">The target texture.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="device"/>, <paramref name="source"/> or <paramref name="target"/> is
/// <see langword="null"/>.
/// </exception>
public static void Copy(Device device, Texture2D source, Texture2D target)
{
if (device == null)
throw new ArgumentNullException("device");
if (source == null)
throw new ArgumentNullException("source");
if (target == null)
throw new ArgumentNullException("target");
int sourceWidth = source.Description.Width;
int sourceHeight = source.Description.Height;
int targetWidth = target.Description.Width;
int targetHeight = target.Description.Height;
if (sourceWidth == targetWidth && sourceHeight == targetHeight)
{
device.ImmediateContext.CopyResource(source, target);
}
else
{
int width = Math.Min(sourceWidth, targetWidth);
int height = Math.Min(sourceHeight, targetHeight);
var region = new ResourceRegion(0, 0, 0, width, height, 1);
device.ImmediateContext.CopySubresourceRegion(source, 0, region, target, 0);
}
}
public TextureShader(Device device)
{
var vertexShaderByteCode = ShaderBytecode.CompileFromFile(ShaderFileName, "TextureVertexShader", "vs_4_0", ShaderFlags);
var pixelShaderByteCode = ShaderBytecode.CompileFromFile(ShaderFileName, "TexturePixelShader", "ps_4_0", ShaderFlags);
VertexShader = new VertexShader(device, vertexShaderByteCode);
PixelShader = new PixelShader(device, pixelShaderByteCode);
Layout = VertexDefinition.PositionTexture.GetInputLayout(device, vertexShaderByteCode);
vertexShaderByteCode.Dispose();
pixelShaderByteCode.Dispose();
ConstantMatrixBuffer = new Buffer(device, MatrixBufferDesription);
// Create a texture sampler state description.
var samplerDesc = new SamplerStateDescription
{
Filter = Filter.Anisotropic,
AddressU = TextureAddressMode.Mirror,
AddressV = TextureAddressMode.Mirror,
AddressW = TextureAddressMode.Mirror,
MipLodBias = 0,
MaximumAnisotropy = 16,
ComparisonFunction = Comparison.Always,
BorderColor = new Color4(1, 1, 1, 1),
MinimumLod = 0,
MaximumLod = 0
};
// Create the texture sampler state.
SamplerState = new SamplerState(device, samplerDesc);
}
public DX11Renderer(IntPtr windowHandle, Size2 size, Device dev = null)
{
RenderSize = size;
_windowHandle = windowHandle;
if(dev != null)
{
_dxDevice = dev;
}
else
{
var swapchainDesc = new SwapChainDescription()
{
BufferCount = 2,
ModeDescription =
new ModeDescription(size.Width, size.Height,
new Rational(60, 1), Format.R8G8B8A8_UNorm),
IsWindowed = true,
OutputHandle = windowHandle,
SampleDescription = new SampleDescription(1, 0),
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput
};
// Create Device and SwapChain
Device.CreateWithSwapChain(DriverType.Hardware,
DeviceCreationFlags.None, swapchainDesc, out _dxDevice, out _swapChain);
// Ignore all windows events
// var factory = _swapChain.GetParent<Factory>();
// factory.MakeWindowAssociation(windowHandle, WindowAssociationFlags.None);
Reset(size.Width, size.Height);
}
}
public Form1(Factory factory, SharpDX.Direct3D11.Device device, Object renderLock)
{
InitializeComponent();
this.factory = factory;
this.device = device;
this.renderLock = renderLock;
}
public UISurface(Device device)
{
this.mDevice = device;
mBatchPool = new UISurfaceBatchPool(device);
mFontMaterialMgr = new UISurfaceFontMaterialManager(device);
SetDesignHeight(Game.Instance.RenderViewSize.Height);
}
/// <summary>
/// Creates a new graphics resource.
/// </summary>
/// <param name="device">The graphics device to use.</param>
/// <param name="dimensions">The resource dimensions.</param>
/// <param name="format">The resource's DXGI format.</param>
/// <param name="renderTargetView">Whether to bind as RTV.</param>
/// <param name="shaderResourceView">Whether to bind as SRV.</param>
/// <param name="hasMipMaps">Whether to enable mip-maps for this texture.</param>
public GraphicsResource(Device device, Size dimensions, Format format, Boolean renderTargetView = true, Boolean shaderResourceView = true, Boolean hasMipMaps = false)
{
if ((!renderTargetView) && (!shaderResourceView))
throw new ArgumentException("The requested resource cannot be bound at all to the pipeline.");
if ((hasMipMaps) && ((!renderTargetView) || (!shaderResourceView)))
throw new ArgumentException("A resource with mipmaps must be bound as both input and output.");
BindFlags bindFlags = (renderTargetView ? BindFlags.RenderTarget : 0) | (shaderResourceView ? BindFlags.ShaderResource : 0);
ResourceOptionFlags optionFlags = (hasMipMaps ? ResourceOptionFlags.GenerateMipMaps : 0);
int mipLevels = (hasMipMaps ? MipLevels(dimensions) : 1);
Resource = new Texture2D(device, new Texture2DDescription()
{
Format = format,
BindFlags = bindFlags,
Width = dimensions.Width,
Height = dimensions.Height,
ArraySize = 1,
MipLevels = mipLevels,
OptionFlags = optionFlags,
Usage = ResourceUsage.Default,
CpuAccessFlags = CpuAccessFlags.None,
SampleDescription = new SampleDescription(1, 0),
});
RTV = ( renderTargetView ? new RenderTargetView(device, Resource) : null);
SRV = (shaderResourceView ? new ShaderResourceView(device, Resource) : null);
}
public RenderTarget(Device device, int width, int height, int sampleCount, int sampleQuality, Format format)
: this()
{
Texture = _disposer.Add(new Texture2D(device, new Texture2DDescription
{
Format = format,
Width = width,
Height = height,
ArraySize = 1,
MipLevels = 1,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None,
Usage = ResourceUsage.Default,
SampleDescription = new SampleDescription(sampleCount, sampleQuality),
}));
RenderTargetView = _disposer.Add(new RenderTargetView(device, Texture, new RenderTargetViewDescription
{
Format = format,
Dimension = RenderTargetViewDimension.Texture2DMultisampled,
//MipSlice = 0,
}));
ShaderResourceView = _disposer.Add(new ShaderResourceView(device, Texture));
Viewport = new Viewport(0, 0, width, height, 0.0f, 1.0f);
}
public void Initialize()
{
DestroyResources();
var flags = DeviceCreationFlags.BgraSupport;
#if DEBUG
flags |= DeviceCreationFlags.Debug;
#endif
var featureLevels = new[]
{
FeatureLevel.Level_11_1,
FeatureLevel.Level_11_0
};
using(var device = new Device(DriverType.Hardware, flags, featureLevels))
{
Device = device.QueryInterface<Device1>();
Context = device.ImmediateContext.QueryInterface<DeviceContext1>();
}
IsInitialized = true;
// todo: Reinitialize all dependent resources by having them hook this event
var handler = Initialized;
if(handler != null)
handler();
}
public static bool IsDx11Supported()
{
var factory = GetFactory();
FeatureLevel[] featureLevels = {FeatureLevel.Level_11_0};
for (int i = 0; i < factory.Adapters.Length; i++)
{
var adapter = factory.Adapters[i];
Device adapterTestDevice = null;
try
{
adapterTestDevice = new Device(adapter, DeviceCreationFlags.None, featureLevels);
}
catch (Exception)
{
continue;
}
UInt64 vram;
UInt64 svram;
GetRamSizes(out vram, adapter, out svram);
// microsoft software renderer allocates 256MB shared memory, cpu integrated graphic on notebooks has 0 preallocated, all shared
return (vram > 500000000 || svram > 500000000);
}
return false;
}
public static InputLayout GetInputLayout(Device device, CompilationResult vertexShaderByteCode)
{
var inputElements = new InputElement[]
{
new InputElement
{
SemanticName = "POSITION",
SemanticIndex = 0,
Format = Format.R32G32B32_Float,
Slot = 0,
AlignedByteOffset = 0,
Classification = InputClassification.PerVertexData,
InstanceDataStepRate = 0
},
new InputElement
{
SemanticName = "COLOR",
SemanticIndex = 0,
Format = Format.R32G32B32A32_Float,
Slot = 0,
AlignedByteOffset = LightShader.Vertex.AppendAlignedElement1,
Classification = InputClassification.PerVertexData,
InstanceDataStepRate = 0
}
};
return new InputLayout(device, ShaderSignature.GetInputSignature(vertexShaderByteCode), inputElements);
}
public FbxMesh(AssimpSharp.Mesh mesh, AssimpSharp.Material mat, Device device, string path)
{
this.device = device;
this.path = path;
LoadMesh(mesh);
LoadMaterial(mat);
}
public MeshFactory(SharpDX11Graphics graphics)
{
this.device = graphics.Device;
this.inputAssembler = device.ImmediateContext.InputAssembler;
this.demo = graphics.Demo;
instanceDataDesc = new BufferDescription()
{
Usage = ResourceUsage.Dynamic,
BindFlags = BindFlags.VertexBuffer,
CpuAccessFlags = CpuAccessFlags.Write,
OptionFlags = ResourceOptionFlags.None,
};
InputElement[] elements = new InputElement[]
{
new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0, InputClassification.PerVertexData, 0),
new InputElement("NORMAL", 0, Format.R32G32B32_Float, 12, 0, InputClassification.PerVertexData, 0),
new InputElement("WORLD", 0, Format.R32G32B32A32_Float, 0, 1, InputClassification.PerInstanceData, 1),
new InputElement("WORLD", 1, Format.R32G32B32A32_Float, 16, 1, InputClassification.PerInstanceData, 1),
new InputElement("WORLD", 2, Format.R32G32B32A32_Float, 32, 1, InputClassification.PerInstanceData, 1),
new InputElement("WORLD", 3, Format.R32G32B32A32_Float, 48, 1, InputClassification.PerInstanceData, 1),
new InputElement("COLOR", 0, Format.R8G8B8A8_UNorm, 64, 1, InputClassification.PerInstanceData, 1)
};
inputLayout = new InputLayout(device, graphics.GetEffectPass().Description.Signature, elements);
groundColor = ColorToUint(Color.Green);
activeColor = ColorToUint(Color.Orange);
passiveColor = ColorToUint(Color.OrangeRed);
softBodyColor = ColorToUint(Color.LightBlue);
}
private void CreateDeviceResources()
{
// This flag adds support for surfaces with a different color channel ordering
// than the API default. It is required for compatibility with Direct2D.
DeviceCreationFlags creationFlags = DeviceCreationFlags.BgraSupport | DeviceCreationFlags.Debug;
// This array defines the set of DirectX hardware feature levels this app will support.
// Note the ordering should be preserved.
// Don't forget to declare your application's minimum required feature level in its
// description. All applications are assumed to support 9.1 unless otherwise stated.
SharpDX.Direct3D.FeatureLevel[] featureLevels =
{
SharpDX.Direct3D.FeatureLevel.Level_11_1,
SharpDX.Direct3D.FeatureLevel.Level_11_0,
SharpDX.Direct3D.FeatureLevel.Level_10_1,
SharpDX.Direct3D.FeatureLevel.Level_10_0,
SharpDX.Direct3D.FeatureLevel.Level_9_3
};
// Create the Direct3D 11 API device object and a corresponding context.
using (var defaultDevice = new SharpDX.Direct3D11.Device(SharpDX.Direct3D.DriverType.Hardware, creationFlags, featureLevels))
_device = defaultDevice.QueryInterface<SharpDX.Direct3D11.Device1>();
// Get Direct3D 11.1 context
_deviceContext = ToDispose(_device.ImmediateContext.QueryInterface<SharpDX.Direct3D11.DeviceContext1>());
}
public bool Initialize(Device device, HeightMapTerrain terrain)
{
// Get the number of the vertices on the terrain vertex array.
var vertexCount = terrain.VertexCount;
// Store the total triangle count for the vertex list.
TriangleCount = vertexCount / 3;
VertexList = new List<HeightMapTerrainShader.Vertex>(vertexCount);
// Copy the terrain vertices into vertex list.
terrain.CopyVertexArray(VertexList);
// Calculate the center x,z and the width of the mesh.
float centerX, centerZ, width;
CalculateMeshDimensions(vertexCount, out centerX, out centerZ, out width);
// Create the parent node for the quad tree
// Recursively build the quad tree based on the vertex list data and mesh dimensions.
ParentNode = CreateTreeNode(device, centerX, centerZ, width);
// Release the vertex list since the quad tree now has the vertices in each node.
VertexList.Clear();
return true;
}
public bool Initialize(Device device, string heightMapFileName, string textureFileName)
{
// Set the number of vertices per quad (2 triangles)
NumberOfVerticesPerQuad = 6;
// Set the value of the topology
CurrentTopology = PrimitiveTopology.TriangleList;
// How many times the terrain texture will be repeated both over the width and length of the terrain.
TextureRepeat = 8;
// Load the height map for the terrain
if (!LoadHeightMapFilename(heightMapFileName))
return false;
// Normalize the height of the height map
NormalizeHeightMap();
// Calculate the normals for the terrain data.
if (!CalculateNormals())
return false;
// Calculate the texture coordinates.
CalculateTextureCoordinates();
// Load the texture for this model.
if (!LoadTexture(device, textureFileName))
return false;
// Initialize the vertex and index buffer.
if (!InitializeBuffers(device))
return false;
return true;
}
public void SetInputLayout(Device device, ShaderSignature inputSignature)
{
foreach (ModelMesh mesh in m_meshes)
{
mesh.SetInputLayout(device, inputSignature);
}
m_inputLayoutSet = true;
}
public RenderTarget(Device device, SwapChain swapChain)
: this()
{
Texture = _disposer.Add(Texture2D.FromSwapChain<Texture2D>(swapChain, 0));
RenderTargetView = _disposer.Add(new RenderTargetView(device, Texture));
ShaderResourceView = null;
Viewport = new Viewport(0, 0, Width, Height, 0.0f, 1.0f);
}
public D3D11_2D1(Device11 drawdevice, Device10 textdevice)
: base(false) // nothing!
{
if (drawdevice == null || textdevice == null)
{
using (var dg = new DisposeGroup())
{
if (drawdevice == null && textdevice == null)
{
Adapter a = null;
foreach (var item in DeviceUtil.GetAdapters(dg))
{
if (!item.IsInterfaceSupported<Device10>())
continue;
if (Device11.GetSupportedFeatureLevel(item) < Direct3D.FeatureLevel.Level_10_1)
continue;
a = item;
break;
}
device = new Device11(a, DeviceCreationFlags.BgraSupport | DeviceCreationFlags.SingleThreaded | DeviceCreationFlags.Debug);
device10 = new Device10(a, Direct3D10.DeviceCreationFlags.BgraSupport | Direct3D10.DeviceCreationFlags.Singlethreaded | Direct3D10.DeviceCreationFlags.Debug);
}
else
{
if (drawdevice == null)
{
using (var xgidtext = textdevice.QueryInterface<DeviceXGI>())
device = new Device11(xgidtext.Adapter, DeviceCreationFlags.BgraSupport | DeviceCreationFlags.SingleThreaded | DeviceCreationFlags.Debug);
textdevice.AddReference();
device10 = textdevice;
}
else
{
using (var xgiddraw = drawdevice.QueryInterface<DeviceXGI>())
device10 = new Device10(xgiddraw.Adapter, Direct3D10.DeviceCreationFlags.BgraSupport | Direct3D10.DeviceCreationFlags.Singlethreaded | Direct3D10.DeviceCreationFlags.Debug);
drawdevice.AddReference();
device = drawdevice;
}
}
}
}
else
{
using (var xgidev10 = device10.QueryInterface<DeviceXGI>())
using (var xgidev11 = device.QueryInterface<DeviceXGI>())
{
if (xgidev10.Adapter.NativePointer != xgidev11.Adapter.NativePointer)
throw new ArgumentException("drawdevice.Adapter.NativePointer != textdevice.Adapter.NativePointer");
}
textdevice.AddReference();
drawdevice.AddReference();
device = drawdevice;
device10 = textdevice;
}
factory2D = new SharpDX.Direct2D1.Factory();
factoryDW = new FactoryDW();
}
private static void Main()
{
var form = new RenderForm("SharpDX - MiniTri Direct3D 11 Sample");
// SwapChain description
var desc = new SwapChainDescription()
{
BufferCount = 1,
ModeDescription =
new ModeDescription(form.ClientSize.Width, form.ClientSize.Height,
new Rational(60, 1), Format.R8G8B8A8_UNorm),
IsWindowed = true,
OutputHandle = form.Handle,
SampleDescription = new SampleDescription(1, 0),
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput
};
// Create Device and SwapChain
Device device;
SwapChain swapChain;
Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.None, desc, out device, out swapChain);
var context = device.ImmediateContext;
// Ignore all windows events
var factory = swapChain.GetParent <Factory>();
factory.MakeWindowAssociation(form.Handle, WindowAssociationFlags.IgnoreAll);
// New RenderTargetView from the backbuffer
var backBuffer = Texture2D.FromSwapChain <Texture2D>(swapChain, 0);
var renderView = new RenderTargetView(device, backBuffer);
// Compile Vertex and Pixel shaders
var vertexShaderByteCode = ShaderBytecode.CompileFromFile("MiniTri.fx", "VS", "vs_4_0", ShaderFlags.None, EffectFlags.None);
var vertexShader = new VertexShader(device, vertexShaderByteCode);
var pixelShaderByteCode = ShaderBytecode.CompileFromFile("MiniTri.fx", "PS", "ps_4_0", ShaderFlags.None, EffectFlags.None);
var pixelShader = new PixelShader(device, pixelShaderByteCode);
// Layout from VertexShader input signature
var layout = new InputLayout(
device,
ShaderSignature.GetInputSignature(vertexShaderByteCode),
new[]
{
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
new InputElement("COLOR", 0, Format.R32G32B32A32_Float, 16, 0)
});
// Instantiate Vertex buiffer from vertex data
var vertices = Buffer.Create(device, BindFlags.VertexBuffer, new[]
{
new Vector4(0.0f, 0.5f, 0.5f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(0.5f, -0.5f, 0.5f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f),
new Vector4(-0.5f, -0.5f, 0.5f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f)
});
// Prepare All the stages
context.InputAssembler.InputLayout = layout;
context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertices, 32, 0));
context.VertexShader.Set(vertexShader);
context.Rasterizer.SetViewport(new Viewport(0, 0, form.ClientSize.Width, form.ClientSize.Height, 0.0f, 1.0f));
context.PixelShader.Set(pixelShader);
context.OutputMerger.SetTargets(renderView);
// Main loop
RenderLoop.Run(form, () =>
{
context.ClearRenderTargetView(renderView, Color.Black);
context.Draw(3, 0);
swapChain.Present(0, PresentFlags.None);
});
// Release all resources
vertexShaderByteCode.Dispose();
vertexShader.Dispose();
pixelShaderByteCode.Dispose();
pixelShader.Dispose();
vertices.Dispose();
layout.Dispose();
renderView.Dispose();
backBuffer.Dispose();
context.ClearState();
context.Flush();
device.Dispose();
context.Dispose();
swapChain.Dispose();
factory.Dispose();
}
public ShadowShader(Device device)
{
byte[] vsbytes = File.ReadAllBytes("Shaders\\ShadowVS.cso");
byte[] psbytes = File.ReadAllBytes("Shaders\\ShadowPS.cso");
shadowvs = new VertexShader(device, vsbytes);
shadowps = new PixelShader(device, psbytes);
VSSceneVars = new GpuVarsBuffer <ShadowShaderVSSceneVars>(device);
VSEntityVars = new GpuVarsBuffer <ShadowShaderVSEntityVars>(device);
VSModelVars = new GpuVarsBuffer <ShadowShaderVSModelVars>(device);
GeomVars = new GpuVarsBuffer <ShadowShaderGeomVars>(device);
//supported layouts - requires Position, Normal, Colour, Texcoord
layouts.Add(VertexType.Default, new InputLayout(device, vsbytes, VertexTypeDefault.GetLayout()));
layouts.Add(VertexType.DefaultEx, new InputLayout(device, vsbytes, VertexTypeDefaultEx.GetLayout()));
layouts.Add(VertexType.PNCCT, new InputLayout(device, vsbytes, VertexTypePNCCT.GetLayout()));
layouts.Add(VertexType.PNCCTTTT, new InputLayout(device, vsbytes, VertexTypePNCCTTTT.GetLayout()));
layouts.Add(VertexType.PBBNCCTTX, new InputLayout(device, vsbytes, VertexTypePBBNCCTTX.GetLayout()));
layouts.Add(VertexType.PBBNCCT, new InputLayout(device, vsbytes, VertexTypePBBNCCT.GetLayout()));
layouts.Add(VertexType.PNCTTTX, new InputLayout(device, vsbytes, VertexTypePNCTTTX.GetLayout()));
layouts.Add(VertexType.PNCTTTX_2, new InputLayout(device, vsbytes, VertexTypePNCTTTX_2.GetLayout()));
layouts.Add(VertexType.PNCTTTX_3, new InputLayout(device, vsbytes, VertexTypePNCTTTX_3.GetLayout()));
layouts.Add(VertexType.PNCTTTTX, new InputLayout(device, vsbytes, VertexTypePNCTTTTX.GetLayout()));
layouts.Add(VertexType.PNCTTX, new InputLayout(device, vsbytes, VertexTypePNCTTX.GetLayout()));
layouts.Add(VertexType.PNCCTTX, new InputLayout(device, vsbytes, VertexTypePNCCTTX.GetLayout()));
layouts.Add(VertexType.PNCCTTX_2, new InputLayout(device, vsbytes, VertexTypePNCCTTX_2.GetLayout()));
layouts.Add(VertexType.PNCCTTTX, new InputLayout(device, vsbytes, VertexTypePNCCTTTX.GetLayout()));
layouts.Add(VertexType.PBBNCCTX, new InputLayout(device, vsbytes, VertexTypePBBNCCTX.GetLayout()));
layouts.Add(VertexType.PBBNCTX, new InputLayout(device, vsbytes, VertexTypePBBNCTX.GetLayout()));
layouts.Add(VertexType.PBBNCT, new InputLayout(device, vsbytes, VertexTypePBBNCT.GetLayout()));
layouts.Add(VertexType.PNCCTT, new InputLayout(device, vsbytes, VertexTypePNCCTT.GetLayout()));
layouts.Add(VertexType.PNCCTX, new InputLayout(device, vsbytes, VertexTypePNCCTX.GetLayout()));
layouts.Add(VertexType.PNCH2, new InputLayout(device, vsbytes, VertexTypePNCH2.GetLayout()));
layouts.Add(VertexType.PCCH2H4, new InputLayout(device, vsbytes, VertexTypePCCH2H4.GetLayout()));
layouts.Add(VertexType.PBBNCTT, new InputLayout(device, vsbytes, VertexTypePBBNCTT.GetLayout()));
layouts.Add(VertexType.PBBNCTTX, new InputLayout(device, vsbytes, VertexTypePBBNCTTX.GetLayout()));
layouts.Add(VertexType.PBBNCTTT, new InputLayout(device, vsbytes, VertexTypePBBNCTTT.GetLayout()));
layouts.Add(VertexType.PNCTT, new InputLayout(device, vsbytes, VertexTypePNCTT.GetLayout()));
layouts.Add(VertexType.PNCTTT, new InputLayout(device, vsbytes, VertexTypePNCTTT.GetLayout()));
layouts.Add(VertexType.PBBNCTTTX, new InputLayout(device, vsbytes, VertexTypePBBNCTTTX.GetLayout()));
texsampler = new SamplerState(device, new SamplerStateDescription()
{
AddressU = TextureAddressMode.Wrap,
AddressV = TextureAddressMode.Wrap,
AddressW = TextureAddressMode.Wrap,
BorderColor = Color.Black,
ComparisonFunction = Comparison.Always,
Filter = Filter.MinMagMipLinear,
MaximumAnisotropy = 1,
MaximumLod = float.MaxValue,
MinimumLod = 0,
MipLodBias = 0,
});
texsamplerc = new SamplerState(device, new SamplerStateDescription()
{
AddressU = TextureAddressMode.Clamp,
AddressV = TextureAddressMode.Clamp,
AddressW = TextureAddressMode.Clamp,
BorderColor = Color.Black,
ComparisonFunction = Comparison.Always,
Filter = Filter.MinMagMipPoint,
MaximumAnisotropy = 1,
MaximumLod = float.MaxValue,
MinimumLod = 0,
MipLodBias = 0,
});
}
/// <summary>
/// Constructs a new CPU DX-interop accelerator.
/// </summary>
/// <param name="accelerator">The target CPU accelerator.</param>
/// <param name="d3dDevice">The target DX device.</param>
internal CPUDirectXAccelerator(CPUAccelerator accelerator, Device d3dDevice)
: base(accelerator, d3dDevice)
{
}
private bool InitializeShader(Device device, IntPtr windowHandler, string vsFileName, string psFileName)
{
try
{
// Setup full pathes
vsFileName = SystemConfiguration.ShadersFilePath + vsFileName;
psFileName = SystemConfiguration.ShadersFilePath + psFileName;
// Compile the vertex shader code.
var vertexShaderByteCode = ShaderBytecode.CompileFromFile(vsFileName, "ColorVertexShader", SystemConfiguration.VertexShaderProfile, ShaderFlags.None, EffectFlags.None);
// Compile the pixel shader code.
var pixelShaderByteCode = ShaderBytecode.CompileFromFile(psFileName, "ColorPixelShader", SystemConfiguration.PixelShaderProfile, ShaderFlags.None, EffectFlags.None);
// Create the vertex shader from the buffer.
VertexShader = new VertexShader(device, vertexShaderByteCode);
// Create the pixel shader from the buffer.
PixelShader = new PixelShader(device, pixelShaderByteCode);
// Now setup the layout of the data that goes into the shader.
// This setup needs to match the VertexType structure in the Model and in the shader.
var inputElements = new InputElement[]
{
new InputElement()
{
SemanticName = "POSITION",
SemanticIndex = 0,
Format = Format.R32G32B32A32_Float,
Slot = 0,
AlignedByteOffset = InputElement.AppendAligned,
Classification = InputClassification.PerVertexData,
InstanceDataStepRate = 0
},
new InputElement()
{
SemanticName = "COLOR",
SemanticIndex = 0,
Format = Format.R32G32B32A32_Float,
Slot = 0,
AlignedByteOffset = InputElement.AppendAligned,
Classification = InputClassification.PerVertexData,
InstanceDataStepRate = 0
}
};
// Create the vertex input the layout.
Layout = new InputLayout(device, ShaderSignature.GetInputSignature(vertexShaderByteCode), inputElements);
// Release the vertex and pixel shader buffers, since they are no longer needed.
vertexShaderByteCode.Dispose();
pixelShaderByteCode.Dispose();
// Setup the description of the dynamic matrix constant buffer that is in the vertex shader.
var matrixBufferDesc = new BufferDescription()
{
Usage = ResourceUsage.Dynamic,
SizeInBytes = Utilities.SizeOf <Matrix>(),
BindFlags = BindFlags.ConstantBuffer,
CpuAccessFlags = CpuAccessFlags.Write,
OptionFlags = ResourceOptionFlags.None,
StructureByteStride = 0
};
// Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.
ConstantMatrixBuffer = new Buffer(device, matrixBufferDesc);
return(true);
}
catch (Exception ex)
{
MessageBox.Show("Error initializing shader. Error is " + ex.Message);
return(false);
};
}
public bool Initialize(Device device, IntPtr windowHandler)
{
// Initialize the vertex and pixel shaders.
return(InitializeShader(device, windowHandler, "color.vs", "color.ps"));
}
public MfVideoProcessor(SharpDX.Direct3D11.Device d)
{
this.device = d;
}
private bool InitializeShader(Device device, IntPtr windowHandler, string vsFileName, string psFileName)
{
try
{
// Setup full pathes
vsFileName = SystemConfiguration.ShadersFilePath + vsFileName;
psFileName = SystemConfiguration.ShadersFilePath + psFileName;
#region Initilize Shaders
// Compile the vertex shader code.
var vertexShaderByteCode = ShaderBytecode.CompileFromFile(vsFileName, "ClipPlaneVertexShader", SystemConfiguration.VertexShaderProfile, ShaderFlags.None, EffectFlags.None);
// Compile the pixel shader code.
var pixelShaderByteCode = ShaderBytecode.CompileFromFile(psFileName, "ClipPlanePixelShader", SystemConfiguration.PixelShaderProfile, ShaderFlags.None, EffectFlags.None);
// Create the vertex shader from the buffer.
VertexShader = new VertexShader(device, vertexShaderByteCode);
// Create the pixel shader from the buffer.
PixelShader = new PixelShader(device, pixelShaderByteCode);
#endregion
#region Initialize Input Layouts
// Now setup the layout of the data that goes into the shader.
// This setup needs to match the VertexType structure in the Model and in the shader.
var inputElements = new InputElement[]
{
new InputElement()
{
SemanticName = "POSITION",
SemanticIndex = 0,
Format = Format.R32G32B32_Float,
Slot = 0,
AlignedByteOffset = InputElement.AppendAligned,
Classification = InputClassification.PerVertexData,
InstanceDataStepRate = 0
},
new InputElement()
{
SemanticName = "TEXCOORD",
SemanticIndex = 0,
Format = Format.R32G32_Float,
Slot = 0,
AlignedByteOffset = InputElement.AppendAligned,
Classification = InputClassification.PerVertexData,
InstanceDataStepRate = 0
}
};
// Create the vertex input the layout.
Layout = new InputLayout(device, ShaderSignature.GetInputSignature(vertexShaderByteCode), inputElements);
#endregion
// Release the vertex and pixel shader buffers, since they are no longer needed.
vertexShaderByteCode.Dispose();
pixelShaderByteCode.Dispose();
#region Initialize Matrix Buffer
// Setup the description of the dynamic matrix constant buffer that is in the vertex shader.
var matrixBufferDesc = new BufferDescription()
{
Usage = ResourceUsage.Dynamic,
SizeInBytes = Utilities.SizeOf <MatrixBuffer>(),
BindFlags = BindFlags.ConstantBuffer,
CpuAccessFlags = CpuAccessFlags.Write,
OptionFlags = ResourceOptionFlags.None,
StructureByteStride = 0
};
// Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.
ConstantMatrixBuffer = new Buffer(device, matrixBufferDesc);
#endregion
#region Initialize Sampler
// Create a texture sampler state description.
var samplerDesc = new SamplerStateDescription()
{
Filter = Filter.MinMagMipLinear,
AddressU = TextureAddressMode.Wrap,
AddressV = TextureAddressMode.Wrap,
AddressW = TextureAddressMode.Wrap,
MipLodBias = 0,
MaximumAnisotropy = 1,
ComparisonFunction = Comparison.Always,
BorderColor = new Color4(0, 0, 0, 0),
MinimumLod = 0,
MaximumLod = 0
};
// Create the texture sampler state.
SampleState = new SamplerState(device, samplerDesc);
#endregion
#region Initialize Clip Plane Buffer
// Setup the description of the dynamic matrix constant buffer that is in the vertex shader.
var clipPlaneBufferDesc = new BufferDescription()
{
Usage = ResourceUsage.Dynamic,
SizeInBytes = Utilities.SizeOf <ClipPlaneBuffer>(),
BindFlags = BindFlags.ConstantBuffer,
CpuAccessFlags = CpuAccessFlags.Write,
OptionFlags = ResourceOptionFlags.None,
StructureByteStride = 0
};
// Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.
ConstantClipPlaneBuffer = new Buffer(device, clipPlaneBufferDesc);
#endregion
return(true);
}
catch (Exception ex)
{
MessageBox.Show("Error initializing shader. Error is " + ex.Message);
return(false);
};
}
public ShadowMap(Direct3D11.Device device, SwapChain swapChain, int width, int height)
{
this.device = device;
this.width = width;
this.height = height;
viewport = new Viewport(0, 0, width, height, 0, 1f);
//shadowMap = Texture2D.FromSwapChain<Texture2D>(swapChain, 0);
var depthDesc = new Texture2DDescription
{
Width = this.width,
Height = this.height,
MipLevels = 1,
ArraySize = 1,
//Format = Format.R24G8_Typeless,
Format = SharpDX.DXGI.Format.R32G32B32A32_Float,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
//BindFlags = BindFlags.DepthStencil | BindFlags.ShaderResource,
BindFlags = SharpDX.Direct3D11.BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
};
DepthMap = new Texture2D(device, depthDesc);
RenderTargetViews = new []
{
new RenderTargetView(device, DepthMap)
};
DsvText = new Texture2D(device, new Texture2DDescription()
{
Format = Format.D32_Float_S8X24_UInt,
ArraySize = 1,
MipLevels = 1,
Width = width,
Height = height,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
});
// Create the depth buffer view
DepthMapDsv = new DepthStencilView(device, DsvText);
//var shaderResourseViewDesc = new ShaderResourceViewDescription
//{
// Format = Format.D32_Float,
// Dimension = ShaderResourceViewDimension.Texture2D,
// Texture2D = new ShaderResourceViewDescription.Texture2DResource()
// {
// MipLevels = 1,
// MostDetailedMip = 0,
// }
//};
//shaderResourceView = new ShaderResourceView(GameDevice, DSVText, shaderResourseViewDesc);
//var location = System.Reflection.Assembly.GetExecutingAssembly().Location;
//var path = Path.GetDirectoryName(location) + "\\Shaders\\ShadowMapShaders.hlsl";
//using (var vertexShaderByteCode = ShaderBytecode.CompileFromFile(path, "VS", "vs_5_0", ShaderFlags.PackMatrixRowMajor))
//{
// shadowInputShaderSignature = ShaderSignature.GetInputSignature(vertexShaderByteCode);
// shadowVertexShader = new Direct3D11.VertexShader(device, vertexShaderByteCode);
//}
//using (var pixelShaderByteCode = ShaderBytecode.CompileFromFile(path, "PS", "ps_5_0", ShaderFlags.PackMatrixRowMajor))
//{
// shadowPixelShader = new Direct3D11.PixelShader(device, pixelShaderByteCode);
//}
//shadowInputLayout = new InputLayout(device, shadowInputShaderSignature, inputElements);
}
