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; }