private EffectProgram(GraphicsDevice device, EffectBytecode bytecode)
: base(device)
{
effectBytecode = bytecode;
Reflection = effectBytecode.Reflection;
CreateShaders();
}
private DepthStencilState(GraphicsDevice device, DepthStencilStateDescription depthStencilStateDescription)
: base(device)
{
Description = depthStencilStateDescription;
depthFunction = Description.DepthBufferFunction.ToOpenGLDepthFunction();
}
/// <summary>
/// Compiles or recompiles the effect if necesssary.
/// </summary>
/// <param name="graphicsDevice"></param>
/// <returns>True if the effect was recompiled, false otherwise.</returns>
public bool UpdateEffect(GraphicsDevice graphicsDevice)
{
if (permutationCounter != Parameters.PermutationCounter || (effect != null && effect.SourceChanged))
{
permutationCounter = Parameters.PermutationCounter;
var oldEffect = effect;
ChooseEffect(graphicsDevice);
// Early exit: same effect, and already initialized
if (oldEffect == effect && descriptorReflection != null)
return false;
// Update reflection and rearrange buffers/resources
var layoutNames = effect.Bytecode.Reflection.ResourceBindings.Select(x => x.ResourceGroup ?? "Globals").Distinct().ToList();
descriptorReflection = EffectDescriptorSetReflection.New(graphicsDevice, effect.Bytecode, layoutNames, "Globals");
RootSignature = RootSignature.New(graphicsDevice, descriptorReflection);
bufferUploader.Compile(graphicsDevice, descriptorReflection, effect.Bytecode);
// Create parameter updater
var layouts = new DescriptorSetLayoutBuilder[descriptorReflection.Layouts.Count];
for (int i = 0; i < descriptorReflection.Layouts.Count; ++i)
layouts[i] = descriptorReflection.Layouts[i].Layout;
var parameterUpdaterLayout = new EffectParameterUpdaterLayout(graphicsDevice, effect, layouts);
parameterUpdater = new EffectParameterUpdater(parameterUpdaterLayout, Parameters);
descriptorSets = new DescriptorSet[parameterUpdater.ResourceGroups.Length];
return true;
}
return false;
}
/// <summary>
/// Creates a texture from an image file data (png, dds, ...).
/// </summary>
/// <param name="graphicsDevice">The graphics device in which to create the texture</param>
/// <param name="data">The image file data</param>
/// <returns>The texture</returns>
public static Texture FromFileData(GraphicsDevice graphicsDevice, byte[] data)
{
Texture result;
var loadAsSRgb = graphicsDevice.ColorSpace == ColorSpace.Linear;
using (var imageStream = new MemoryStream(data))
{
using (var image = Image.Load(imageStream, loadAsSRgb))
{
result = Texture.New(graphicsDevice, image);
}
}
result.Reload = graphicsResource =>
{
using (var imageStream = new MemoryStream(data))
{
using (var image = Image.Load(imageStream, loadAsSRgb))
{
((Texture)graphicsResource).Recreate(image.ToDataBox());
}
}
};
return result;
}
private DescriptorPool(GraphicsDevice graphicsDevice, DescriptorTypeCount[] counts) : base(graphicsDevice)
{
// For now, we put everything together so let's compute total count
foreach (var count in counts)
{
if (count.Type == EffectParameterClass.Sampler)
SamplerCount += count.Count;
else
SrvCount += count.Count;
}
if (SrvCount > 0)
{
SrvHeap = graphicsDevice.NativeDevice.CreateDescriptorHeap(new DescriptorHeapDescription
{
DescriptorCount = SrvCount,
Flags = DescriptorHeapFlags.None,
Type = DescriptorHeapType.ConstantBufferViewShaderResourceViewUnorderedAccessView,
});
}
if (SamplerCount > 0)
{
SamplerHeap = graphicsDevice.NativeDevice.CreateDescriptorHeap(new DescriptorHeapDescription
{
DescriptorCount = SamplerCount,
Flags = DescriptorHeapFlags.None,
Type = DescriptorHeapType.Sampler,
});
}
}
public LightShadowProcessorDefaultBudget(GraphicsDevice device, bool manageShadows)
: base(device, manageShadows)
{
// Fixed budget of textures
AddShadowMapTexture(new ShadowMapTexture(GraphicsDevice, LightShadowMapFilterType.Nearest, 2048), LightShadowMapFilterType.Nearest);
AddShadowMapTexture(new ShadowMapTexture(GraphicsDevice, LightShadowMapFilterType.Variance, 2048), LightShadowMapFilterType.Variance);
}
private Shader(GraphicsDevice device, ShaderStage shaderStage, byte[] shaderStageBytecode)
: base(device)
{
this.stage = shaderStage;
var shaderStageGl = ConvertShaderStage(shaderStage);
// Decode shader StageBytecode
var binarySerializationReader = new BinarySerializationReader(new MemoryStream(shaderStageBytecode));
var shaderBytecodeData = new OpenGLShaderBytecodeData();
shaderBytecodeData.Serialize(binarySerializationReader, ArchiveMode.Deserialize);
using (GraphicsDevice.UseOpenGLCreationContext())
{
resourceId = GL.CreateShader(shaderStageGl);
if (shaderBytecodeData.IsBinary)
{
GL.ShaderBinary(1, ref resourceId, (BinaryFormat)shaderBytecodeData.BinaryFormat, shaderBytecodeData.Binary, shaderBytecodeData.Binary.Length);
}
else
{
GL.ShaderSource(resourceId, shaderBytecodeData.Source);
GL.CompileShader(resourceId);
var log = GL.GetShaderInfoLog(resourceId);
int compileStatus;
GL.GetShader(resourceId, ShaderParameter.CompileStatus, out compileStatus);
if (compileStatus != 1)
throw new InvalidOperationException(string.Format("Error while compiling GLSL shader: {0}", log));
}
}
}
public void Compile(GraphicsDevice graphicsDevice, EffectDescriptorSetReflection descriptorSetLayouts, EffectBytecode effectBytecode)
{
resourceGroupBindings = new ResourceGroupBinding[descriptorSetLayouts.Layouts.Count];
for (int setIndex = 0; setIndex < descriptorSetLayouts.Layouts.Count; setIndex++)
{
var layout = descriptorSetLayouts.Layouts[setIndex].Layout;
if (layout == null)
{
resourceGroupBindings[setIndex] = new ResourceGroupBinding { ConstantBufferSlot = -1 };
continue;
}
var resourceGroupBinding = new ResourceGroupBinding();
for (int resourceIndex = 0; resourceIndex < layout.Entries.Count; resourceIndex++)
{
var layoutEntry = layout.Entries[resourceIndex];
if (layoutEntry.Class == EffectParameterClass.ConstantBuffer)
{
var constantBuffer = effectBytecode.Reflection.ConstantBuffers.First(x => x.Name == layoutEntry.Key.Name);
resourceGroupBinding.ConstantBufferSlot = resourceIndex;
resourceGroupBinding.ConstantBufferPreallocated = Buffer.Constant.New(graphicsDevice, constantBuffer.Size);
}
}
resourceGroupBindings[setIndex] = resourceGroupBinding;
}
}
internal BlendState(GraphicsDevice device, BlendStateDescription blendStateDescription) : base(device)
{
Description = blendStateDescription;
for (int i = 1; i < Description.RenderTargets.Length; ++i)
{
if (Description.RenderTargets[i].BlendEnable || Description.RenderTargets[i].ColorWriteChannels != ColorWriteChannels.All)
throw new NotSupportedException();
}
blendEnable = Description.RenderTargets[0].BlendEnable;
blendEquationModeColor = ToOpenGL(Description.RenderTargets[0].ColorBlendFunction);
blendEquationModeAlpha = ToOpenGL(Description.RenderTargets[0].AlphaBlendFunction);
blendFactorSrcColor = ToOpenGL(Description.RenderTargets[0].ColorSourceBlend);
blendFactorSrcAlpha = ToOpenGL(Description.RenderTargets[0].AlphaSourceBlend);
blendFactorDestColor = (BlendingFactorDest)ToOpenGL(Description.RenderTargets[0].ColorDestinationBlend);
blendFactorDestAlpha = (BlendingFactorDest)ToOpenGL(Description.RenderTargets[0].AlphaDestinationBlend);
EnabledColors[0] = (Description.RenderTargets[0].ColorWriteChannels & ColorWriteChannels.Red ) != 0;
EnabledColors[1] = (Description.RenderTargets[0].ColorWriteChannels & ColorWriteChannels.Green) != 0;
EnabledColors[2] = (Description.RenderTargets[0].ColorWriteChannels & ColorWriteChannels.Blue ) != 0;
EnabledColors[3] = (Description.RenderTargets[0].ColorWriteChannels & ColorWriteChannels.Alpha) != 0;
blendEquationHash = (uint)Description.RenderTargets[0].ColorBlendFunction
| ((uint)Description.RenderTargets[0].AlphaBlendFunction << 8);
blendFuncHash = (uint)Description.RenderTargets[0].ColorSourceBlend
| ((uint)Description.RenderTargets[0].AlphaSourceBlend << 8)
| ((uint)Description.RenderTargets[0].ColorDestinationBlend << 16)
| ((uint)Description.RenderTargets[0].AlphaDestinationBlend << 24);
}
public SceneRenderer(GameSettingsAsset gameSettings)
{
if (gameSettings == null) throw new ArgumentNullException(nameof(gameSettings));
// Initialize services
Services = new ServiceRegistry();
ContentManager = new ContentManager(Services);
var renderingSettings = gameSettings.Get<RenderingSettings>();
GraphicsDevice = GraphicsDevice.New(DeviceCreationFlags.None, new[] { renderingSettings.DefaultGraphicsProfile });
var graphicsDeviceService = new GraphicsDeviceServiceLocal(Services, GraphicsDevice);
EffectSystem = new EffectSystem(Services);
GraphicsContext = new GraphicsContext(GraphicsDevice);
Services.AddService(typeof(GraphicsContext), GraphicsContext);
SceneSystem = new SceneSystem(Services);
// Create game systems
GameSystems = new GameSystemCollection(Services);
GameSystems.Add(new GameFontSystem(Services));
GameSystems.Add(new UISystem(Services));
GameSystems.Add(EffectSystem);
GameSystems.Add(SceneSystem);
GameSystems.Initialize();
// Fake presenter
// TODO GRAPHICS REFACTOR: This is needed be for render stage setup
GraphicsDevice.Presenter = new RenderTargetGraphicsPresenter(GraphicsDevice,
Texture.New2D(GraphicsDevice, renderingSettings.DefaultBackBufferWidth, renderingSettings.DefaultBackBufferHeight,
renderingSettings.ColorSpace == ColorSpace.Linear ? PixelFormat.R8G8B8A8_UNorm_SRgb : PixelFormat.R8G8B8A8_UNorm, TextureFlags.ShaderResource | TextureFlags.RenderTarget),
PixelFormat.D24_UNorm_S8_UInt);
SceneSystem.MainRenderFrame = RenderFrame.FromTexture(GraphicsDevice.Presenter.BackBuffer, GraphicsDevice.Presenter.DepthStencilBuffer);
}
public SwapChainGraphicsPresenter(GraphicsDevice device, PresentationParameters presentationParameters) : base(device, presentationParameters)
{
gameWindow = (iPhoneOSGameView)Description.DeviceWindowHandle.NativeHandle;
device.InitDefaultRenderTarget(presentationParameters);
backBuffer = Texture.New2D(device, Description.BackBufferWidth, Description.BackBufferHeight, presentationParameters.BackBufferFormat, TextureFlags.RenderTarget | TextureFlags.ShaderResource);
}
internal DepthStencilBuffer(GraphicsDevice device, Texture2D depthTexture, bool isReadOnly) : base(device)
{
DescriptionInternal = depthTexture.Description;
depthTexture.AddReferenceInternal();
Texture = depthTexture;
resourceId = Texture.ResourceId;
if (Description.Format == PixelFormat.D24_UNorm_S8_UInt ||
Description.Format == PixelFormat.D32_Float_S8X24_UInt)
{
IsDepthBuffer = true;
IsStencilBuffer = true;
}
else if (Description.Format == PixelFormat.D32_Float ||
Description.Format == PixelFormat.D16_UNorm)
{
IsDepthBuffer = true;
IsStencilBuffer = false;
}
else
throw new NotSupportedException("The provided depth stencil format is currently not supported"); // implement composition for other formats
#if !SILICONSTUDIO_XENKO_GRAPHICS_API_OPENGLES
if (isReadOnly)
{
if (device.versionMajor < 4)
{
needReadOnlySynchronization = true;
throw new NotImplementedException();
}
}
#endif
}
private Shader(GraphicsDevice device, ShaderStage shaderStage, byte[] shaderBytecode)
: base(device)
{
this.stage = shaderStage;
switch (shaderStage)
{
case ShaderStage.Vertex:
NativeDeviceChild = new VertexShader(device.NativeDevice, shaderBytecode);
NativeInputSignature = shaderBytecode;
break;
case ShaderStage.Hull:
NativeDeviceChild = new HullShader(device.NativeDevice, shaderBytecode);
break;
case ShaderStage.Domain:
NativeDeviceChild = new DomainShader(device.NativeDevice, shaderBytecode);
break;
case ShaderStage.Geometry:
NativeDeviceChild = new GeometryShader(device.NativeDevice, shaderBytecode);
break;
case ShaderStage.Pixel:
NativeDeviceChild = new PixelShader(device.NativeDevice, shaderBytecode);
break;
case ShaderStage.Compute:
NativeDeviceChild = new ComputeShader(device.NativeDevice, shaderBytecode);
break;
default:
throw new ArgumentOutOfRangeException("shaderStage");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BlendStateFactory"/> class.
/// </summary>
/// <param name="device">The device.</param>
internal BlendStateFactory(GraphicsDevice device)
{
var blendDescription = new BlendStateDescription(Blend.One, Blend.Zero);
blendDescription.SetDefaults();
Default = BlendState.New(device, blendDescription).DisposeBy(device);
Default.Name = "Default";
Additive = BlendState.New(device, new BlendStateDescription(Blend.SourceAlpha, Blend.One)).DisposeBy(device);
Additive.Name = "Additive";
AlphaBlend = BlendState.New(device, new BlendStateDescription(Blend.One, Blend.InverseSourceAlpha)).DisposeBy(device);
AlphaBlend.Name = "AlphaBlend";
NonPremultiplied = BlendState.New(device, new BlendStateDescription(Blend.SourceAlpha, Blend.InverseSourceAlpha)).DisposeBy(device);
NonPremultiplied.Name = "NonPremultiplied";
Opaque = BlendState.New(device, new BlendStateDescription(Blend.One, Blend.Zero)).DisposeBy(device);
Opaque.Name = "Opaque";
var colorDisabledDescription = new BlendStateDescription();
colorDisabledDescription.SetDefaults();
colorDisabledDescription.RenderTargets[0].ColorWriteChannels = ColorWriteChannels.None;
ColorDisabled = BlendState.New(device, colorDisabledDescription).DisposeBy(device);
ColorDisabled.Name = "ColorDisabled";
}
/// <summary>
/// Initializes a new instance of the <see cref="DepthStencilState"/> class.
/// </summary>
/// <param name="depthEnable">if set to <c>true</c> [depth enable].</param>
/// <param name="depthWriteEnable">if set to <c>true</c> [depth write enable].</param>
/// <param name="name">The name.</param>
private DepthStencilState(GraphicsDevice device, DepthStencilStateDescription depthStencilStateDescription)
: base(device)
{
Description = depthStencilStateDescription;
CreateNativeDeviceChild();
}
public static EffectDescriptorSetReflection New(GraphicsDevice graphicsDevice, EffectBytecode effectBytecode, List<string> effectDescriptorSetSlots, string defaultSetSlot)
{
// Find resource groups
// TODO: We should precompute most of that at compile time in BytecodeReflection
// just waiting for format to be more stable
var descriptorSetLayouts = new EffectDescriptorSetReflection { DefaultSetSlot = defaultSetSlot };
foreach (var effectDescriptorSetSlot in effectDescriptorSetSlots)
{
// Find all resources related to this slot name
// NOTE: Ordering is mirrored by GLSL layout in Vulkan
var descriptorSetLayoutBuilder = new DescriptorSetLayoutBuilder();
bool hasBindings = false;
foreach (var resourceBinding in effectBytecode.Reflection.ResourceBindings
.Where(x => x.ResourceGroup == effectDescriptorSetSlot || (effectDescriptorSetSlot == defaultSetSlot && (x.ResourceGroup == null || x.ResourceGroup == "Globals")))
.GroupBy(x => new { Key = x.KeyInfo.Key, Class = x.Class, Type = x.Type, SlotCount = x.SlotCount, LogicalGroup = x.LogicalGroup })
.OrderBy(x => x.Key.Class == EffectParameterClass.ConstantBuffer ? 0 : 1)) // Note: Putting cbuffer first for now
{
SamplerState samplerState = null;
if (resourceBinding.Key.Class == EffectParameterClass.Sampler)
{
var matchingSamplerState = effectBytecode.Reflection.SamplerStates.FirstOrDefault(x => x.Key == resourceBinding.Key.Key);
if (matchingSamplerState != null)
samplerState = SamplerState.New(graphicsDevice, matchingSamplerState.Description);
}
hasBindings = true;
descriptorSetLayoutBuilder.AddBinding(resourceBinding.Key.Key, resourceBinding.Key.LogicalGroup, resourceBinding.Key.Class, resourceBinding.Key.Type, resourceBinding.Key.SlotCount, samplerState);
}
descriptorSetLayouts.AddLayout(effectDescriptorSetSlot, hasBindings ? descriptorSetLayoutBuilder : null);
}
return descriptorSetLayouts;
}
private DescriptorSet(GraphicsDevice graphicsDevice, DescriptorPool pool, DescriptorSetLayout desc)
{
if (pool.SrvOffset + desc.SrvCount > pool.SrvCount || pool.SamplerOffset + desc.SamplerCount > pool.SamplerCount)
{
// Eearly exit if OOM, IsValid should return false (TODO: different mechanism?)
Device = null;
BindingOffsets = null;
Description = null;
SrvStart = new CpuDescriptorHandle();
SamplerStart = new CpuDescriptorHandle();
return;
}
Device = graphicsDevice;
BindingOffsets = desc.BindingOffsets;
Description = desc;
// Store start CpuDescriptorHandle
SrvStart = desc.SrvCount > 0 ? (pool.SrvStart + graphicsDevice.SrvHandleIncrementSize * pool.SrvOffset) : new CpuDescriptorHandle();
SamplerStart = desc.SamplerCount > 0 ? (pool.SamplerStart + graphicsDevice.SamplerHandleIncrementSize * pool.SamplerOffset) : new CpuDescriptorHandle();
// Allocation is done, bump offsets
// TODO D3D12 thread safety?
pool.SrvOffset += desc.SrvCount;
pool.SamplerOffset += desc.SamplerCount;
}
public override MeshDraw CreateDebugPrimitive(GraphicsDevice device)
{
if (cachedDebugPrimitive != null) return cachedDebugPrimitive;
var verts = new VertexPositionNormalTexture[pointsList.Count];
for (var i = 0; i < pointsList.Count; i++)
{
verts[i].Position = pointsList[i];
verts[i].TextureCoordinate = Vector2.Zero;
verts[i].Normal = Vector3.Zero;
}
var intIndices = indicesList.Select(x => (int)x).ToArray();
////calculate basic normals
////todo verify, winding order might be wrong?
for (var i = 0; i < indicesList.Count; i += 3)
{
var i1 = intIndices[i];
var i2 = intIndices[i + 1];
var i3 = intIndices[i + 2];
var a = verts[i1];
var b = verts[i2];
var c = verts[i3];
var n = Vector3.Cross((b.Position - a.Position), (c.Position - a.Position));
n.Normalize();
verts[i1].Normal = verts[i2].Normal = verts[i3].Normal = n;
}
var meshData = new GeometricMeshData<VertexPositionNormalTexture>(verts, intIndices, false);
cachedDebugPrimitive = new GeometricPrimitive(device, meshData).ToMeshDraw();
return cachedDebugPrimitive;
}
public EffectParameterUpdaterLayout(GraphicsDevice graphicsDevice, Effect effect, DescriptorSetLayoutBuilder[] layouts)
{
Layouts = layouts;
// Process constant buffers
ResourceGroupLayouts = new ResourceGroupLayout[layouts.Length];
for (int layoutIndex = 0; layoutIndex < layouts.Length; layoutIndex++)
{
var layout = layouts[layoutIndex];
if (layout == null)
continue;
ParameterCollectionLayout.ProcessResources(layout);
EffectConstantBufferDescription cbuffer = null;
for (int entryIndex = 0; entryIndex < layout.Entries.Count; ++entryIndex)
{
var layoutEntry = layout.Entries[entryIndex];
if (layoutEntry.Class == EffectParameterClass.ConstantBuffer)
{
// For now we assume first cbuffer will be the main one
if (cbuffer == null)
{
cbuffer = effect.Bytecode.Reflection.ConstantBuffers.First(x => x.Name == layoutEntry.Key.Name);
ParameterCollectionLayout.ProcessConstantBuffer(cbuffer);
}
}
}
var resourceGroupDescription = new ResourceGroupDescription(layout, cbuffer);
ResourceGroupLayouts[layoutIndex] = ResourceGroupLayout.New(graphicsDevice, resourceGroupDescription, effect.Bytecode);
}
}
/// <summary>
/// Polls the shader generator if the shader code has changed and has to be reloaded
/// </summary>
/// <param name="graphicsDevice">The current <see cref="GraphicsDevice"/></param>
private void UpdateShaders(GraphicsDevice graphicsDevice)
{
// TODO Part of the graphics improvement XK-3052
// Don't do this every frame, we have to propagate changes better
if (--shadersUpdateCounter > 0)
return;
shadersUpdateCounter = 10;
if (ComputeColor != null)
{
if (ComputeColor.HasChanged)
{
var shaderGeneratorContext = new ShaderGeneratorContext(graphicsDevice)
{
Parameters = Parameters,
ColorSpace = graphicsDevice.ColorSpace
};
shaderSource = ComputeColor.GenerateShaderSource(shaderGeneratorContext, new MaterialComputeColorKeys(ParticleBaseKeys.EmissiveMap, ParticleBaseKeys.EmissiveValue, Color.White));
if (Parameters.Get(ParticleBaseKeys.BaseColor)?.Equals(shaderSource) ?? false)
{
shaderSource = Parameters.Get(ParticleBaseKeys.BaseColor);
}
else
{
Parameters.Set(ParticleBaseKeys.BaseColor, shaderSource);
}
HasVertexLayoutChanged = true;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="GraphicsDeviceServiceLocal"/> class.
/// </summary>
/// <param name="registry">The registry.</param>
/// <param name="graphicsDevice">The graphics device.</param>
public GraphicsDeviceServiceLocal(IServiceRegistry registry, GraphicsDevice graphicsDevice)
{
if (registry != null)
{
registry.AddService(typeof(IGraphicsDeviceService), this);
}
GraphicsDevice = graphicsDevice;
}
public ResourceGroupAllocator(GraphicsResourceAllocator allocator, CommandList commandList)
{
this.allocator = allocator;
this.commandList = commandList;
this.graphicsDevice = commandList.GraphicsDevice;
SetupNextDescriptorPool();
}
protected internal Texture3D(GraphicsDevice device, Texture3D texture) : base(device, texture, ViewType.Full, 0, 0)
{
#if SILICONSTUDIO_XENKO_GRAPHICS_API_OPENGLES
throw new NotImplementedException();
#else
Target = TextureTarget.Texture3D;
#endif
}
protected internal Texture3D(GraphicsDevice device, TextureDescription description3D, DataBox[] dataBoxes = null) : base(device, description3D, ViewType.Full, 0, 0)
{
#if SILICONSTUDIO_XENKO_GRAPHICS_API_OPENGLES
throw new NotImplementedException();
#else
Target = TextureTarget.Texture3D;
#endif
}
public ShaderGeneratorContext(GraphicsDevice graphicsDevice = null)
{
this.graphicsDevice = graphicsDevice;
Parameters = new ParameterCollection();
parameterKeyIndices = new Dictionary<ParameterKey, int>();
declaredSamplerStates = new Dictionary<SamplerStateDescription, ObjectParameterKey<SamplerState>>();
currentOverrides = new MaterialOverrides();
}
public SwapChainGraphicsPresenter(GraphicsDevice device, PresentationParameters presentationParameters) : base(device, presentationParameters)
{
device.Begin();
device.InitDefaultRenderTarget(presentationParameters);
device.End();
backBuffer = device.DefaultRenderTarget;
DepthStencilBuffer = device.windowProvidedDepthTexture;
}
/// <summary>
/// Initializes a new instance of the <see cref="Buffer" /> class.
/// </summary>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="description">The description.</param>
/// <param name="bufferFlags">Type of the buffer.</param>
/// <param name="viewFormat">The view format.</param>
/// <param name="dataPointer">The data pointer.</param>
protected Buffer(GraphicsDevice device, BufferDescription description, BufferFlags bufferFlags, PixelFormat viewFormat, IntPtr dataPointer) : base(device)
{
Description = description;
BufferFlags = bufferFlags;
ViewFormat = viewFormat;
//InitCountAndViewFormat(out this.elementCount, ref ViewFormat);
//Initialize(device.RootDevice, null);
}
public CommandList(GraphicsDevice device) : base(device)
{
nativeCommandAllocator = device.CommandAllocators.GetObject();
NativeCommandList = device.NativeDevice.CreateCommandList(CommandListType.Direct, nativeCommandAllocator, null);
ResetSrvHeap(true);
ResetSamplerHeap(true);
}
public CommandList(GraphicsDevice device) : base(device)
{
nativeDeviceContext = device.NativeDeviceContext;
nativeDeviceProfiler = device.IsDebugMode ? SharpDX.ComObject.QueryInterfaceOrNull<SharpDX.Direct3D11.UserDefinedAnnotation>(nativeDeviceContext.NativePointer) : null;
InitializeStages();
ClearState();
}
public PhysicsDebugEffect(GraphicsDevice graphicsDevice)
: base(graphicsDevice, bytecode ?? (bytecode = EffectBytecode.FromBytesSafe(binaryBytecode)))
{
parameters = new ParameterCollection();
Color = new Color4(1.0f);
WorldViewProj = Matrix.Identity;
UseUv = true;
}
public CommandAllocatorPool(GraphicsDevice graphicsDevice) : base(graphicsDevice)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="Buffer" /> class.
/// </summary>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
protected Buffer(GraphicsDevice device)
: base(device)
{
}
/// <summary>
/// Explicitly recreate buffer with given data. Usually called after a <see cref="GraphicsDevice"/> reset.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dataPointer"></param>
public void Recreate(IntPtr dataPointer)
{
// TODO D3D12 where should that go longer term? should it be precomputed for future use? (cost would likely be additional check on SetDescriptorSets/Draw)
NativeResourceState = ResourceStates.Common;
var bufferFlags = bufferDescription.BufferFlags;
if ((bufferFlags & BufferFlags.ConstantBuffer) != 0)
{
NativeResourceState |= ResourceStates.VertexAndConstantBuffer;
}
if ((bufferFlags & BufferFlags.IndexBuffer) != 0)
{
NativeResourceState |= ResourceStates.IndexBuffer;
}
if ((bufferFlags & BufferFlags.VertexBuffer) != 0)
{
NativeResourceState |= ResourceStates.VertexAndConstantBuffer;
}
if ((bufferFlags & BufferFlags.ShaderResource) != 0)
{
NativeResourceState |= ResourceStates.PixelShaderResource | ResourceStates.NonPixelShaderResource;
}
if ((bufferFlags & BufferFlags.UnorderedAccess) != 0)
{
NativeResourceState |= ResourceStates.UnorderedAccess;
}
if ((bufferFlags & BufferFlags.StructuredBuffer) != 0)
{
throw new NotImplementedException();
if (bufferDescription.StructureByteStride == 0)
{
throw new ArgumentException("Element size cannot be set to 0 for structured buffer");
}
}
if ((bufferFlags & BufferFlags.RawBuffer) == BufferFlags.RawBuffer)
{
throw new NotImplementedException();
}
if ((bufferFlags & BufferFlags.ArgumentBuffer) == BufferFlags.ArgumentBuffer)
{
NativeResourceState |= ResourceStates.IndirectArgument;
}
// TODO D3D12 move that to a global allocator in bigger committed resources
NativeDeviceChild = GraphicsDevice.NativeDevice.CreateCommittedResource(new HeapProperties(HeapType.Default), HeapFlags.None, nativeDescription, dataPointer != IntPtr.Zero ? ResourceStates.CopyDestination : NativeResourceState);
if (dataPointer != IntPtr.Zero)
{
// Copy data in upload heap for later copy
// TODO D3D12 move that to a shared upload heap
SharpDX.Direct3D12.Resource uploadResource;
int uploadOffset;
var uploadMemory = GraphicsDevice.AllocateUploadBuffer(SizeInBytes, out uploadResource, out uploadOffset);
Utilities.CopyMemory(uploadMemory, dataPointer, SizeInBytes);
// TODO D3D12 lock NativeCopyCommandList usages
var commandList = GraphicsDevice.NativeCopyCommandList;
commandList.Reset(GraphicsDevice.NativeCopyCommandAllocator, null);
// Copy from upload heap to actual resource
commandList.CopyBufferRegion(NativeResource, 0, uploadResource, uploadOffset, SizeInBytes);
// Switch resource to proper read state
commandList.ResourceBarrierTransition(NativeResource, 0, ResourceStates.CopyDestination, NativeResourceState);
commandList.Close();
GraphicsDevice.NativeCommandQueue.ExecuteCommandList(commandList);
// TODO D3D12 release uploadResource (using a fence to know when copy is done)
}
}
public override unsafe void Present()
{
try
{
var swapChainCopy = swapChain;
var currentBufferIndexCopy = currentBufferIndex;
var presentInfo = new PresentInfo
{
StructureType = StructureType.PresentInfo,
SwapchainCount = 1,
Swapchains = new IntPtr(&swapChainCopy),
ImageIndices = new IntPtr(¤tBufferIndexCopy),
};
// Present
GraphicsDevice.NativeCommandQueue.Present(ref presentInfo);
// Get next image
currentBufferIndex = GraphicsDevice.NativeDevice.AcquireNextImage(swapChain, ulong.MaxValue, GraphicsDevice.GetNextPresentSemaphore(), Fence.Null);
// Flip render targets
backbuffer.SetNativeHandles(swapchainImages[currentBufferIndex].NativeImage, swapchainImages[currentBufferIndex].NativeColorAttachmentView);
}
catch (SharpVulkanException e) when(e.Result == Result.ErrorOutOfDate)
{
// TODO VULKAN
}
}
private unsafe void CreateBackBuffers()
{
// Create the texture object
var backBufferDescription = new TextureDescription
{
ArraySize = 1,
Dimension = TextureDimension.Texture2D,
Height = Description.BackBufferHeight,
Width = Description.BackBufferWidth,
Depth = 1,
Flags = TextureFlags.RenderTarget,
Format = Description.BackBufferFormat,
MipLevels = 1,
MultiSampleLevel = MSAALevel.None,
Usage = GraphicsResourceUsage.Default
};
backbuffer.InitializeWithoutResources(backBufferDescription);
var createInfo = new ImageViewCreateInfo
{
StructureType = StructureType.ImageViewCreateInfo,
SubresourceRange = new ImageSubresourceRange(ImageAspectFlags.Color, 0, 1, 0, 1),
Format = backbuffer.NativeFormat,
};
// We initialize swapchain images to PresentSource, since we swap them out while in this layout.
backbuffer.NativeAccessMask = AccessFlags.MemoryRead;
backbuffer.NativeLayout = ImageLayout.PresentSource;
var imageMemoryBarrier = new ImageMemoryBarrier
{
StructureType = StructureType.ImageMemoryBarrier,
SubresourceRange = new ImageSubresourceRange(ImageAspectFlags.Color, 0, 1, 0, 1),
OldLayout = ImageLayout.Undefined,
NewLayout = ImageLayout.PresentSource,
SourceAccessMask = AccessFlags.None,
DestinationAccessMask = AccessFlags.MemoryRead
};
var commandBuffer = GraphicsDevice.NativeCopyCommandBuffer;
var beginInfo = new CommandBufferBeginInfo {
StructureType = StructureType.CommandBufferBeginInfo
};
commandBuffer.Begin(ref beginInfo);
var buffers = GraphicsDevice.NativeDevice.GetSwapchainImages(swapChain);
swapchainImages = new SwapChainImageInfo[buffers.Length];
for (int i = 0; i < buffers.Length; i++)
{
// Create image views
swapchainImages[i].NativeImage = createInfo.Image = buffers[i];
swapchainImages[i].NativeColorAttachmentView = GraphicsDevice.NativeDevice.CreateImageView(ref createInfo);
// Transition to default layout
imageMemoryBarrier.Image = buffers[i];
commandBuffer.PipelineBarrier(PipelineStageFlags.AllCommands, PipelineStageFlags.AllCommands, DependencyFlags.None, 0, null, 0, null, 1, &imageMemoryBarrier);
}
// Close and submit
commandBuffer.End();
var submitInfo = new SubmitInfo
{
StructureType = StructureType.SubmitInfo,
CommandBufferCount = 1,
CommandBuffers = new IntPtr(&commandBuffer),
};
GraphicsDevice.NativeCommandQueue.Submit(1, &submitInfo, Fence.Null);
GraphicsDevice.NativeCommandQueue.WaitIdle();
commandBuffer.Reset(CommandBufferResetFlags.None);
// Get next image
currentBufferIndex = GraphicsDevice.NativeDevice.AcquireNextImage(swapChain, ulong.MaxValue, GraphicsDevice.GetNextPresentSemaphore(), Fence.Null);
// Apply the first swap chain image to the texture
backbuffer.SetNativeHandles(swapchainImages[currentBufferIndex].NativeImage, swapchainImages[currentBufferIndex].NativeColorAttachmentView);
}
public static DescriptorPool New(GraphicsDevice graphicsDevice, DescriptorTypeCount[] counts)
{
return(new DescriptorPool(graphicsDevice, counts));
}
public static void ConvertPixelFormat(GraphicsDevice graphicsDevice, ref PixelFormat inputFormat, out PixelInternalFormat internalFormat, out PixelFormatGl format, out PixelType type, out int pixelSize, out bool compressed)
{
compressed = false;
#if SILICONSTUDIO_XENKO_GRAPHICS_API_OPENGLES
// check formats is the device is initialized with OpenGL ES 2
if (graphicsDevice.IsOpenGLES2)
{
switch (inputFormat)
{
case PixelFormat.R32_UInt:
case PixelFormat.R32_Float:
case PixelFormat.R32G32_Float:
case PixelFormat.R32G32B32_Float:
case PixelFormat.R16G16B16A16_Float:
case PixelFormat.R32G32B32A32_Float:
case PixelFormat.D32_Float:
throw new NotSupportedException(String.Format("Texture format {0} not supported", inputFormat));
case PixelFormat.D24_UNorm_S8_UInt:
if (!(graphicsDevice.HasDepth24 && graphicsDevice.HasPackedDepthStencilExtension))
{
throw new NotSupportedException(String.Format("Texture format {0} not supported", inputFormat));
}
break;
}
}
#endif
// If the Device doesn't support SRGB, we remap automatically the format to non-srgb
if (!graphicsDevice.Features.HasSRgb)
{
switch (inputFormat)
{
case PixelFormat.PVRTC_2bpp_RGB_SRgb:
inputFormat = PixelFormat.PVRTC_2bpp_RGB;
break;
case PixelFormat.PVRTC_2bpp_RGBA_SRgb:
inputFormat = PixelFormat.PVRTC_2bpp_RGBA;
break;
case PixelFormat.PVRTC_4bpp_RGB_SRgb:
inputFormat = PixelFormat.PVRTC_4bpp_RGB;
break;
case PixelFormat.PVRTC_4bpp_RGBA_SRgb:
inputFormat = PixelFormat.PVRTC_4bpp_RGBA;
break;
case PixelFormat.ETC2_RGB_SRgb:
inputFormat = PixelFormat.ETC2_RGB;
break;
case PixelFormat.ETC2_RGBA_SRgb:
inputFormat = PixelFormat.ETC2_RGBA;
break;
case PixelFormat.R8G8B8A8_UNorm_SRgb:
inputFormat = PixelFormat.R8G8B8A8_UNorm;
break;
case PixelFormat.B8G8R8A8_UNorm_SRgb:
inputFormat = PixelFormat.B8G8R8A8_UNorm;
break;
}
}
switch (inputFormat)
{
case PixelFormat.A8_UNorm:
internalFormat = PixelInternalFormat.Alpha;
format = PixelFormatGl.Alpha;
type = PixelType.UnsignedByte;
pixelSize = 1;
break;
case PixelFormat.R8_UNorm:
#if SILICONSTUDIO_XENKO_GRAPHICS_API_OPENGLES
if (!graphicsDevice.HasTextureRG && graphicsDevice.IsOpenGLES2)
{
internalFormat = PixelInternalFormat.Luminance;
format = PixelFormatGl.Luminance;
}
else
#endif
{
#if SILICONSTUDIO_PLATFORM_IOS
internalFormat = PixelInternalFormat.Luminance;
format = PixelFormatGl.Luminance;
#else
internalFormat = R8;
format = PixelFormatGl.Red;
#endif
}
type = PixelType.UnsignedByte;
pixelSize = 1;
break;
case PixelFormat.R8G8B8A8_UNorm:
internalFormat = PixelInternalFormat.Rgba;
format = PixelFormatGl.Rgba;
type = PixelType.UnsignedByte;
pixelSize = 4;
break;
case PixelFormat.B8G8R8A8_UNorm:
#if SILICONSTUDIO_XENKO_GRAPHICS_API_OPENGLES
if (!graphicsDevice.HasExtTextureFormatBGRA8888)
{
throw new NotSupportedException();
}
// It seems iOS and Android expects different things
#if SILICONSTUDIO_PLATFORM_IOS
internalFormat = PixelInternalFormat.Rgba;
#else
internalFormat = (PixelInternalFormat)ExtTextureFormatBgra8888.BgraExt;
#endif
format = (PixelFormatGl)ExtTextureFormatBgra8888.BgraExt;
#else
internalFormat = PixelInternalFormat.Rgba;
format = PixelFormatGl.Bgra;
#endif
type = PixelType.UnsignedByte;
pixelSize = 4;
break;
case PixelFormat.R8G8B8A8_UNorm_SRgb:
internalFormat = graphicsDevice.currentVersionMajor < 3 ? SrgbAlpha : Srgb8Alpha8;
format = graphicsDevice.currentVersionMajor < 3 ? (PixelFormatGl)SrgbAlpha : PixelFormatGl.Rgba;
type = PixelType.UnsignedByte;
pixelSize = 4;
break;
#if SILICONSTUDIO_XENKO_GRAPHICS_API_OPENGLCORE
case PixelFormat.B8G8R8A8_UNorm_SRgb:
// TODO: Check on iOS/Android and OpenGL 3
internalFormat = graphicsDevice.currentVersionMajor < 3 ? SrgbAlpha : Srgb8Alpha8;
format = graphicsDevice.currentVersionMajor < 3 ? (PixelFormatGl)SrgbAlpha : PixelFormatGl.Bgra;
type = PixelType.UnsignedByte;
pixelSize = 4;
break;
#endif
case PixelFormat.R16_Float:
internalFormat = R16f;
format = PixelFormatGl.Red;
type = PixelType.HalfFloat;
pixelSize = 2;
break;
case PixelFormat.R16G16_Float:
internalFormat = Rg16f;
format = PixelFormatGl.Rg;
type = PixelType.HalfFloat;
pixelSize = 4;
break;
case PixelFormat.R16G16B16A16_Float:
internalFormat = Rgba16f;
format = PixelFormatGl.Rgba;
type = PixelType.HalfFloat;
pixelSize = 8;
break;
case PixelFormat.R32_UInt:
internalFormat = R32ui;
format = PixelFormatGl.RedInteger;
type = PixelType.UnsignedInt;
pixelSize = 4;
break;
case PixelFormat.R32_Float:
internalFormat = R32f;
format = PixelFormatGl.Red;
type = PixelType.Float;
pixelSize = 4;
break;
case PixelFormat.R32G32_Float:
internalFormat = Rg32f;
format = PixelFormatGl.Rg;
type = PixelType.Float;
pixelSize = 8;
break;
case PixelFormat.R32G32B32_Float:
internalFormat = Rgb32f;
format = PixelFormatGl.Rgb;
type = PixelType.Float;
pixelSize = 12;
break;
case PixelFormat.R32G32B32A32_Float:
internalFormat = Rgba32f;
format = PixelFormatGl.Rgba;
type = PixelType.Float;
pixelSize = 16;
break;
case PixelFormat.D16_UNorm:
internalFormat = DepthComponent16;
format = PixelFormatGl.DepthComponent;
type = PixelType.UnsignedShort;
pixelSize = 2;
break;
case PixelFormat.D24_UNorm_S8_UInt:
internalFormat = Depth24Stencil8;
format = PixelFormatGl.DepthStencil;
type = PixelType.UnsignedInt248;
pixelSize = 4;
break;
// TODO: Temporary depth format (need to decide relation between RenderTarget1D and Texture)
case PixelFormat.D32_Float:
internalFormat = DepthComponent32f;
format = PixelFormatGl.DepthComponent;
type = PixelType.Float;
pixelSize = 4;
break;
#if SILICONSTUDIO_PLATFORM_IOS
case PixelFormat.PVRTC_4bpp_RGB:
internalFormat = (PixelInternalFormat)ImgTextureCompressionPvrtc.CompressedRgbPvrtc4Bppv1Img;
format = (PixelFormatGl)ImgTextureCompressionPvrtc.CompressedRgbPvrtc4Bppv1Img;
compressed = true;
pixelSize = 4;
type = PixelType.UnsignedByte;
break;
case PixelFormat.PVRTC_2bpp_RGB:
internalFormat = (PixelInternalFormat)ImgTextureCompressionPvrtc.CompressedRgbPvrtc2Bppv1Img;
format = (PixelFormatGl)ImgTextureCompressionPvrtc.CompressedRgbPvrtc2Bppv1Img;
compressed = true;
pixelSize = 2;
type = PixelType.UnsignedByte;
break;
case PixelFormat.PVRTC_4bpp_RGBA:
internalFormat = (PixelInternalFormat)ImgTextureCompressionPvrtc.CompressedRgbaPvrtc4Bppv1Img;
format = (PixelFormatGl)ImgTextureCompressionPvrtc.CompressedRgbaPvrtc4Bppv1Img;
compressed = true;
pixelSize = 4;
type = PixelType.UnsignedByte;
break;
case PixelFormat.PVRTC_2bpp_RGBA:
internalFormat = (PixelInternalFormat)ImgTextureCompressionPvrtc.CompressedRgbaPvrtc2Bppv1Img;
format = (PixelFormatGl)ImgTextureCompressionPvrtc.CompressedRgbaPvrtc2Bppv1Img;
compressed = true;
pixelSize = 2;
type = PixelType.UnsignedByte;
break;
case PixelFormat.PVRTC_4bpp_RGB_SRgb:
internalFormat = (PixelInternalFormat)ImgTextureCompressionPvrtc.CompressedSrgbPvrtc4Bppv1Ext;
format = (PixelFormatGl)ImgTextureCompressionPvrtc.CompressedSrgbPvrtc4Bppv1Ext;
compressed = true;
pixelSize = 4;
type = PixelType.UnsignedByte;
break;
case PixelFormat.PVRTC_2bpp_RGB_SRgb:
internalFormat = (PixelInternalFormat)ImgTextureCompressionPvrtc.CompressedSrgbPvrtc2Bppv1Ext;
format = (PixelFormatGl)ImgTextureCompressionPvrtc.CompressedSrgbPvrtc2Bppv1Ext;
compressed = true;
pixelSize = 2;
type = PixelType.UnsignedByte;
break;
case PixelFormat.PVRTC_4bpp_RGBA_SRgb:
internalFormat = (PixelInternalFormat)ImgTextureCompressionPvrtc.CompressedSrgbAlphaPvrtc4Bppv1Ext;
format = (PixelFormatGl)ImgTextureCompressionPvrtc.CompressedSrgbAlphaPvrtc4Bppv1Ext;
compressed = true;
pixelSize = 4;
type = PixelType.UnsignedByte;
break;
case PixelFormat.PVRTC_2bpp_RGBA_SRgb:
internalFormat = (PixelInternalFormat)ImgTextureCompressionPvrtc.CompressedSrgbAlphaPvrtc2Bppv1Ext;
format = (PixelFormatGl)ImgTextureCompressionPvrtc.CompressedSrgbAlphaPvrtc2Bppv1Ext;
compressed = true;
pixelSize = 2;
type = PixelType.UnsignedByte;
break;
#elif SILICONSTUDIO_PLATFORM_ANDROID || !SILICONSTUDIO_PLATFORM_MONO_MOBILE && SILICONSTUDIO_XENKO_GRAPHICS_API_OPENGLES
// Desktop OpenGLES
case PixelFormat.ETC1:
// TODO: Runtime check for extension?
internalFormat = (PixelInternalFormat)OesCompressedEtc1Rgb8Texture.Etc1Rgb8Oes;
format = (PixelFormatGl)OesCompressedEtc1Rgb8Texture.Etc1Rgb8Oes;
compressed = true;
pixelSize = 2;
type = PixelType.UnsignedByte;
break;
case PixelFormat.ETC2_RGBA:
internalFormat = (PixelInternalFormat)CompressedInternalFormat.CompressedRgba8Etc2Eac;
format = (PixelFormatGl)CompressedInternalFormat.CompressedRgba8Etc2Eac;
compressed = true;
pixelSize = 2;
type = PixelType.UnsignedByte;
break;
case PixelFormat.ETC2_RGBA_SRgb:
internalFormat = (PixelInternalFormat)CompressedInternalFormat.CompressedSrgb8Alpha8Etc2Eac;
format = (PixelFormatGl)CompressedInternalFormat.CompressedSrgb8Alpha8Etc2Eac;
compressed = true;
pixelSize = 2;
type = PixelType.UnsignedByte;
break;
#endif
case PixelFormat.None: // TODO: remove this - this is only for buffers used in compute shaders
internalFormat = PixelInternalFormat.Rgba;
format = PixelFormatGl.Red;
type = PixelType.UnsignedByte;
pixelSize = 1;
break;
default:
throw new InvalidOperationException("Unsupported texture format");
}
}
public static VertexArrayObject New(GraphicsDevice graphicsDevice, IndexBufferBinding indexBufferBinding, params VertexBufferBinding[] vertexBufferBindings)
{
return(New(graphicsDevice, null, indexBufferBinding, vertexBufferBindings));
}
public static VertexArrayObject New(GraphicsDevice graphicsDevice, EffectInputSignature shaderSignature, params VertexBufferBinding[] vertexBufferBindings)
{
return(New(graphicsDevice, shaderSignature, null, vertexBufferBindings));
}
public DescriptorAllocator(GraphicsDevice device, DescriptorHeapType descriptorHeapType)
{
this.device = device;
this.descriptorHeapType = descriptorHeapType;
this.descriptorSize = device.NativeDevice.GetDescriptorHandleIncrementSize(descriptorHeapType);
}
protected ResourcePool(GraphicsDevice graphicsDevice)
{
GraphicsDevice = graphicsDevice;
}
public HeapPool(GraphicsDevice graphicsDevice, int heapSize, DescriptorHeapType heapType) : base(graphicsDevice)
{
this.heapSize = heapSize;
this.heapType = heapType;
}