public int Compile(MgGraphicsPipelineCreateInfo info) { var modules = new List <int>(); foreach (var stage in info.Stages) { //var shaderType = ShaderType.VertexShader; //if (stage.Stage == MgShaderStageFlagBits.FRAGMENT_BIT) //{ // shaderType = ShaderType.FragmentShader; //} //else if (stage.Stage == MgShaderStageFlagBits.VERTEX_BIT) //{ // shaderType = ShaderType.VertexShader; //} //else if (stage.Stage == MgShaderStageFlagBits.COMPUTE_BIT) //{ // shaderType = ShaderType.ComputeShader; //} //else if (stage.Stage == MgShaderStageFlagBits.GEOMETRY_BIT) //{ // shaderType = ShaderType.GeometryShader; //} var module = (GLShaderModule)stage.Module; Debug.Assert(module != null); if (module.ShaderId.HasValue) { modules.Add(module.ShaderId.Value); } else { using (var ms = new MemoryStream()) { module.Info.Code.CopyTo(ms, (int)module.Info.CodeSize.ToUInt32()); ms.Seek(0, SeekOrigin.Begin); // FIXME : Encoding type using (var sr = new StreamReader(ms)) { string fileContents = sr.ReadToEnd(); module.ShaderId = CompileShader(mShaderModuleEntrypoint, stage.Stage, fileContents, string.Empty, stage.Name); modules.Add(module.ShaderId.Value); } } } } return(LinkShaders(mProgramEntrypoint, mErrHandler, modules.ToArray())); }
public GLGraphicsPipeline( IGLGraphicsPipelineEntrypoint entrypoint, int programId, MgGraphicsPipelineCreateInfo info, GLInternalCache internalCache, IGLPipelineLayout layout ) { mEntrypoint = entrypoint; if (info.VertexInputState == null) { throw new ArgumentNullException("info.VertexInputState"); } if (info.InputAssemblyState == null) { throw new ArgumentNullException("info.InputAssemblyState"); } if (info.RasterizationState == null) { throw new ArgumentNullException("info.RasterizationState"); } ProgramID = programId; InternalCache = internalCache; Layout = layout; PopulateVertexDefinition(info.VertexInputState); PopulatePipelineConstants(info.RasterizationState); PopulateCmdFallbacks(info.RasterizationState); PopulateInputAssembly(info.InputAssemblyState); PopulateDepthStencilState(info.DepthStencilState); PopulateDynamicStates(info.DynamicState); PopulateColorBlend(info.ColorBlendState); PopulateViewports(info.ViewportState); }
void preparePipelines() { Debug.Assert(mManager.Configuration != null); var device = mManager.Configuration.Device; using (var vertFs = System.IO.File.OpenRead("Shaders/texture1.vert.spv")) using (var fragFs = System.IO.File.OpenRead("Shaders/texture1.frag.spv")) { // Load shaders IMgShaderModule vertSM; { var vsCreateInfo = new MgShaderModuleCreateInfo { Code = vertFs, CodeSize = new UIntPtr((ulong)vertFs.Length), }; // shaderStages[0] = loadShader(getAssetPath() + "shaders/texture/texture.vert.spv", IMg_SHADER_STAGE_VERTEX_BIT); var localErr = device.CreateShaderModule(vsCreateInfo, null, out vertSM); Debug.Assert(localErr == Result.SUCCESS); } IMgShaderModule fragSM; { var fsCreateInfo = new MgShaderModuleCreateInfo { Code = fragFs, CodeSize = new UIntPtr((ulong)fragFs.Length), }; //shaderStages[1] = loadShader(getAssetPath() + "shaders/texture/texture.frag.spv", IMg_SHADER_STAGE_FRAGMENT_BIT); var localErr = device.CreateShaderModule(fsCreateInfo, null, out fragSM); Debug.Assert(localErr == Result.SUCCESS); } var pipelineCreateInfo = new MgGraphicsPipelineCreateInfo { Stages = new MgPipelineShaderStageCreateInfo[] { new MgPipelineShaderStageCreateInfo { Module = vertSM, Stage = MgShaderStageFlagBits.VERTEX_BIT, Name = "vertFunc", }, new MgPipelineShaderStageCreateInfo { Module = fragSM, Stage = MgShaderStageFlagBits.FRAGMENT_BIT, Name = "fragFunc", } }, Layout = mPipelineLayout, RenderPass = mManager.Graphics.Renderpass, VertexInputState = vertices.inputState, InputAssemblyState = new MgPipelineInputAssemblyStateCreateInfo { Topology = MgPrimitiveTopology.TRIANGLE_LIST, PrimitiveRestartEnable = false, }, RasterizationState = new MgPipelineRasterizationStateCreateInfo { PolygonMode = MgPolygonMode.FILL, CullMode = MgCullModeFlagBits.NONE, FrontFace = MgFrontFace.COUNTER_CLOCKWISE, }, ColorBlendState = new MgPipelineColorBlendStateCreateInfo { Attachments = new MgPipelineColorBlendAttachmentState[] { new MgPipelineColorBlendAttachmentState { ColorWriteMask = MgColorComponentFlagBits.R_BIT | MgColorComponentFlagBits.G_BIT | MgColorComponentFlagBits.B_BIT | MgColorComponentFlagBits.A_BIT, BlendEnable = false, }, } }, MultisampleState = new MgPipelineMultisampleStateCreateInfo { RasterizationSamples = MgSampleCountFlagBits.COUNT_1_BIT, }, // pipelineCreateInfo.pViewportState = &viewportState; // MgPipelineViewportStateCreateInfo viewportState = // IMgTools::initializers::pipelineViewportStateCreateInfo(1, 1, 0); //ViewportState = new MgPipelineViewportStateCreateInfo //{ // Scissors = new [] // { // mManager.Graphics.Scissor, // }, // Viewports = new [] // { // mManager.Graphics.CurrentViewport, // } //}, DepthStencilState = new MgPipelineDepthStencilStateCreateInfo { DepthTestEnable = true, DepthWriteEnable = true, DepthCompareOp = MgCompareOp.LESS_OR_EQUAL, DepthBoundsTestEnable = false, Back = new MgStencilOpState { FailOp = MgStencilOp.KEEP, PassOp = MgStencilOp.KEEP, CompareOp = MgCompareOp.ALWAYS, }, StencilTestEnable = false, Front = new MgStencilOpState { FailOp = MgStencilOp.KEEP, PassOp = MgStencilOp.KEEP, CompareOp = MgCompareOp.ALWAYS, }, }, DynamicState = new MgPipelineDynamicStateCreateInfo { DynamicStates = new[] { MgDynamicState.VIEWPORT, MgDynamicState.SCISSOR }, } }; IMgPipeline[] pipelines; var err = device.CreateGraphicsPipelines(null, new[] { pipelineCreateInfo }, null, out pipelines); Debug.Assert(err == Result.SUCCESS); mSolidPipeline = pipelines[0]; } }
public void Preamble() { // PRIVATE IMPLEMENTATION UNIT TESTING mContainer = new Container(); mContainer.Register <IMgQueue, GLCmdQueue>(Reuse.Singleton); mContainer.Register <IGLCmdStateRenderer, GLCmdStateRenderer>(Reuse.Singleton); mContainer.Register <IGLCmdBlendEntrypoint, MockGLCmdBlendEntrypoint>(Reuse.Singleton); mContainer.Register <IGLCmdStencilEntrypoint, MockGLCmdStencilEntrypoint>(Reuse.Singleton); mContainer.Register <IGLCmdRasterizationEntrypoint, MockGLCmdRasterizationEntrypoint>(Reuse.Singleton); mContainer.Register <IGLCmdDepthEntrypoint, MockGLCmdDepthEntrypoint>(Reuse.Singleton); mContainer.Register <IGLCmdScissorsEntrypoint, MockGLCmdScissorsEntrypoint>(Reuse.Singleton); mContainer.Register <IGLCmdDrawEntrypoint, MockGLCmdDrawEntrypoint>(Reuse.Singleton); mContainer.Register <IGLCmdClearEntrypoint, MockGLCmdClearEntrypoint>(Reuse.Singleton); mContainer.Register <IGLErrorHandler, MockGLErrorHandler>(Reuse.Singleton); mContainer.Register <IGLNextCmdShaderProgramCache, GLNextCmdShaderProgramCache>(Reuse.Singleton); mContainer.Register <IGLCmdShaderProgramEntrypoint, MockGLCmdShaderProgramEntrypoint>(Reuse.Singleton); mContainer.Register <IGLBlitOperationEntrypoint, MockGLBlitOperationEntrypoint>(Reuse.Singleton); mContainer.Register <IGLSemaphoreEntrypoint, MockGLSemaphoreEntrypoint>(Reuse.Singleton); mContainer.Register <IGLCmdImageEntrypoint, MockGLCmdImageEntrypoint>(Reuse.Singleton); mContainer.Register <IGLCmdBlitEncoder, GLCmdBlitEncoder>(Reuse.Singleton); mContainer.Register <GLCmdBlitBag>(Reuse.Singleton); mContainer.Register <IGLCmdComputeEncoder, GLCmdComputeEncoder>(Reuse.Singleton); mContainer.Register <IGLCmdGraphicsEncoder, GLCmdGraphicsEncoder>(Reuse.Singleton); mContainer.Register <GLCmdGraphicsBag>(Reuse.Singleton); mContainer.Register <IGLCmdVBOEntrypoint, MockGLCmdVBOEntrypoint>(Reuse.Singleton); mContainer.Register <IGLDescriptorSetBinder, GLNextDescriptorSetBinder>(Reuse.Singleton); mContainer.Register <IGLCmdEncoderContextSorter, GLCmdIncrementalContextSorter>(Reuse.Singleton); mContainer.Register <GLCmdCommandEncoder>(Reuse.Singleton); mContainer.Register <GLInternalCache>(Reuse.Singleton); mContainer.Register <IMgPipeline, GLGraphicsPipeline>(Reuse.Singleton); mContainer.Register <IGLGraphicsPipelineCompiler, MockGLGraphicsPipelineCompiler>(Reuse.Singleton); mContainer.Register <IGLGraphicsPipelineEntrypoint, MockGLGraphicsPipelineEntrypoint>(Reuse.Singleton); queue = mContainer.Resolve <IMgQueue>(); var cmdEncoder = mContainer.Resolve <GLCmdCommandEncoder>(); cmdBuf = new Magnesium.OpenGL.Internals.GLCmdCommandBuffer(true, cmdEncoder); framebuffer = new Magnesium.OpenGL.Internals.GLFramebuffer(); renderpass = new GLRenderPass(new MgAttachmentDescription[] { }); vertexBuffer = new MockGLBuffer { BufferId = 1, Usage = MgBufferUsageFlagBits.VERTEX_BUFFER_BIT, }; indexBuffer = new MockGLBuffer { BufferId = 2, Usage = MgBufferUsageFlagBits.INDEX_BUFFER_BIT, }; var layout = new MockGLPipelineLayout { }; mContainer.RegisterInstance <IGLPipelineLayout>(layout, Reuse.Singleton); var blockEntries = new GLUniformBlockEntry[] { }; var arrayMapper = new Magnesium.OpenGL.Internals.GLInternalCacheArrayMapper(layout, blockEntries); mContainer.RegisterInstance <GLInternalCacheArrayMapper>(arrayMapper, Reuse.Singleton); var entrypoint = mContainer.Resolve <IGLGraphicsPipelineEntrypoint>(); var internalCache = mContainer.Resolve <GLInternalCache>(); var info = new MgGraphicsPipelineCreateInfo { VertexInputState = new MgPipelineVertexInputStateCreateInfo { VertexAttributeDescriptions = new[] { new MgVertexInputAttributeDescription { Binding = 0, Location = 0, Format = MgFormat.R8G8B8A8_SNORM, } }, VertexBindingDescriptions = new[] { new MgVertexInputBindingDescription { Binding = 0, InputRate = MgVertexInputRate.VERTEX, Stride = 32, } } }, RasterizationState = new MgPipelineRasterizationStateCreateInfo { PolygonMode = MgPolygonMode.FILL, }, InputAssemblyState = new MgPipelineInputAssemblyStateCreateInfo { Topology = MgPrimitiveTopology.TRIANGLE_LIST, } }; pipeline = new Magnesium.OpenGL.Internals.GLGraphicsPipeline(entrypoint, 1, info, internalCache, layout); var stateRenderer = mContainer.Resolve <IGLCmdStateRenderer>(); stateRenderer.Initialize(); }
public int Compile(MgGraphicsPipelineCreateInfo info) { throw new NotImplementedException(); }
public AmtGraphicsPipeline(IAmtMetalLibraryLoader generator, IMTLDevice device, MgGraphicsPipelineCreateInfo info) { var layout = (AmtPipelineLayout)info.Layout; if (layout == null) { throw new ArgumentException(nameof(info.Layout)); } Layout = layout; if (info.VertexInputState == null) { throw new ArgumentNullException(nameof(info.VertexInputState)); } if (info.InputAssemblyState == null) { throw new ArgumentNullException(nameof(info.InputAssemblyState)); } if (info.RasterizationState == null) { throw new ArgumentNullException(nameof(info.RasterizationState)); } // TODO : WHY DO I NEED RENDERPASS HERE if (info.RenderPass == null) { throw new ArgumentNullException(nameof(info.RenderPass)); } RenderPass = (AmtRenderPass)info.RenderPass; CompatibilityProfile = RenderPass.Profile; InitializeShaderFunctions(generator, device, info.Stages); InitializeVertexDescriptor(info.VertexInputState); InitiailizeDepthStateDescriptor(info.DepthStencilState); InitializeRasterization(info.RasterizationState); InitializationInputAssembly(info.InputAssemblyState); InitializeColorBlending(info.ColorBlendState); InitializeDynamicStates(info.DynamicState); InitializeResources(info.VertexInputState); InitializeViewportAndScissor(info.ViewportState); InitializeMultisampleInfo(info.MultisampleState); GeneratePipelineStates(device); }
void PreparePipelines() { using (var vertFs = mTrianglePath.OpenVertexShader()) using (var fragFs = mTrianglePath.OpenFragmentShader()) { IMgShaderModule vsModule; { var vsCreateInfo = new MgShaderModuleCreateInfo { Code = vertFs, CodeSize = new UIntPtr((ulong)vertFs.Length), }; mConfiguration.Device.CreateShaderModule(vsCreateInfo, null, out vsModule); } IMgShaderModule fsModule; { var fsCreateInfo = new MgShaderModuleCreateInfo { Code = fragFs, CodeSize = new UIntPtr((ulong)fragFs.Length), }; mConfiguration.Device.CreateShaderModule(fsCreateInfo, null, out fsModule); } var pipelineCreateInfo = new MgGraphicsPipelineCreateInfo { Stages = new [] { new MgPipelineShaderStageCreateInfo { Stage = MgShaderStageFlagBits.VERTEX_BIT, Module = vsModule, Name = "vertFunc", }, new MgPipelineShaderStageCreateInfo { Stage = MgShaderStageFlagBits.FRAGMENT_BIT, Module = fsModule, Name = "fragFunc", }, }, VertexInputState = vertices.inputState, InputAssemblyState = new MgPipelineInputAssemblyStateCreateInfo { // GL002 - TRIANGLE STRIP TEST Topology = MgPrimitiveTopology.TRIANGLE_STRIP, }, RasterizationState = new MgPipelineRasterizationStateCreateInfo { PolygonMode = MgPolygonMode.FILL, CullMode = MgCullModeFlagBits.NONE, FrontFace = MgFrontFace.COUNTER_CLOCKWISE, DepthClampEnable = false, RasterizerDiscardEnable = false, DepthBiasEnable = false, LineWidth = 1.0f, }, ColorBlendState = new MgPipelineColorBlendStateCreateInfo { Attachments = new [] { new MgPipelineColorBlendAttachmentState { ColorWriteMask = MgColorComponentFlagBits.R_BIT | MgColorComponentFlagBits.G_BIT | MgColorComponentFlagBits.B_BIT | MgColorComponentFlagBits.A_BIT, BlendEnable = false, } }, }, MultisampleState = new MgPipelineMultisampleStateCreateInfo { RasterizationSamples = MgSampleCountFlagBits.COUNT_1_BIT, SampleMask = null, }, Layout = mPipelineLayout, RenderPass = mGraphicsDevice.Renderpass, ViewportState = null, DepthStencilState = new MgPipelineDepthStencilStateCreateInfo { DepthTestEnable = true, DepthWriteEnable = true, DepthCompareOp = MgCompareOp.LESS_OR_EQUAL, DepthBoundsTestEnable = false, Back = new MgStencilOpState { FailOp = MgStencilOp.KEEP, PassOp = MgStencilOp.KEEP, CompareOp = MgCompareOp.ALWAYS, }, StencilTestEnable = false, Front = new MgStencilOpState { FailOp = MgStencilOp.KEEP, PassOp = MgStencilOp.KEEP, CompareOp = MgCompareOp.ALWAYS, }, }, DynamicState = new MgPipelineDynamicStateCreateInfo { DynamicStates = new[] { MgDynamicState.VIEWPORT, MgDynamicState.SCISSOR, } }, }; var err = mConfiguration.Device.CreateGraphicsPipelines(null, new[] { pipelineCreateInfo }, null, out IMgPipeline[] pipelines); Debug.Assert(err == Result.SUCCESS); vsModule.DestroyShaderModule(mConfiguration.Device, null); fsModule.DestroyShaderModule(mConfiguration.Device, null); mPipeline = pipelines[0]; } }
public EffectVariant Initialize( IMgDevice device, IMgPipelineLayout layout, IMgRenderPass renderPass, PerVertexInputPipelineState vertexInput, EffectVariantOptions options ) { using (var vertFs = mPath.OpenVertexShader()) using (var fragFs = mPath.OpenFragmentShader()) { var vsCreateInfo = new MgShaderModuleCreateInfo { Code = vertFs, CodeSize = new UIntPtr((ulong)vertFs.Length), }; device.CreateShaderModule(vsCreateInfo, null, out IMgShaderModule vsModule); var fsCreateInfo = new MgShaderModuleCreateInfo { Code = fragFs, CodeSize = new UIntPtr((ulong)fragFs.Length), }; device.CreateShaderModule(fsCreateInfo, null, out IMgShaderModule fsModule); var createInfo = new MgGraphicsPipelineCreateInfo { Stages = new MgPipelineShaderStageCreateInfo[] { new MgPipelineShaderStageCreateInfo { Stage = MgShaderStageFlagBits.VERTEX_BIT, Module = vsModule, Name = "vertFunc", }, new MgPipelineShaderStageCreateInfo { Stage = MgShaderStageFlagBits.FRAGMENT_BIT, Module = fsModule, Name = "fragFunc", }, }, ColorBlendState = new MgPipelineColorBlendStateCreateInfo { Attachments = new[] { new MgPipelineColorBlendAttachmentState { ColorWriteMask = MgColorComponentFlagBits.ALL_BITS, BlendEnable = false, } }, }, DepthStencilState = new MgPipelineDepthStencilStateCreateInfo { DepthTestEnable = true, DepthWriteEnable = true, DepthCompareOp = MgCompareOp.LESS_OR_EQUAL, DepthBoundsTestEnable = false, Back = new MgStencilOpState { FailOp = MgStencilOp.KEEP, PassOp = MgStencilOp.KEEP, CompareOp = MgCompareOp.ALWAYS, }, StencilTestEnable = false, Front = new MgStencilOpState { FailOp = MgStencilOp.KEEP, PassOp = MgStencilOp.KEEP, CompareOp = MgCompareOp.ALWAYS, }, }, DynamicState = new MgPipelineDynamicStateCreateInfo { DynamicStates = new[] { MgDynamicState.VIEWPORT, MgDynamicState.SCISSOR, } }, InputAssemblyState = new MgPipelineInputAssemblyStateCreateInfo { Topology = options.Topology, }, Layout = layout, MultisampleState = new MgPipelineMultisampleStateCreateInfo { RasterizationSamples = MgSampleCountFlagBits.COUNT_1_BIT, SampleMask = null, }, RasterizationState = new MgPipelineRasterizationStateCreateInfo { PolygonMode = MgPolygonMode.FILL, FrontFace = options.FrontFace, CullMode = options.CullMode, DepthClampEnable = false, RasterizerDiscardEnable = false, DepthBiasEnable = false, LineWidth = 1.0f, }, RenderPass = renderPass, VertexInputState = vertexInput.VertexInputState, ViewportState = null, }; var err = device.CreateGraphicsPipelines(null, new[] { createInfo }, null, out IMgPipeline[] pPipelines); Debug.Assert(err == Result.SUCCESS); vsModule.DestroyShaderModule(device, null); fsModule.DestroyShaderModule(device, null); return(new EffectVariant { Key = new EffectVariantKey { Definition = vertexInput.VertexMask, Options = EffectVariantEncoder.Encode(options), }, Pipeline = pPipelines[0], }); } }
void InitializeGraphicsPipeline() { using (var shaderSrc = System.IO.File.OpenRead("Fragment.metal")) using (var fragMemory = new System.IO.MemoryStream()) using (var vertMemory = new System.IO.MemoryStream()) { shaderSrc.CopyTo(fragMemory); // Magnesium uses like open files i.e. open the stream and let it process the data fragMemory.Seek(0, System.IO.SeekOrigin.Begin); // Load the fragment program into the library IMgShaderModule fragmentProgram = null; //IMTLFunction fragmentProgram = defaultLibrary.CreateFunction("lighting_fragment"); MgShaderModuleCreateInfo fragCreateInfo = new MgShaderModuleCreateInfo { Code = fragMemory, CodeSize = new UIntPtr((ulong)fragMemory.Length), }; var err = mConfiguration.Device.CreateShaderModule(fragCreateInfo, null, out fragmentProgram); Debug.Assert(err == Result.SUCCESS); // REWIND AFTER USE shaderSrc.Seek(0, System.IO.SeekOrigin.Begin); shaderSrc.CopyTo(vertMemory); vertMemory.Seek(0, System.IO.SeekOrigin.Begin); // Load the vertex program into the library //IMTLFunction vertexProgram = defaultLibrary.CreateFunction("lighting_vertex"); MgShaderModuleCreateInfo vertCreateInfo = new MgShaderModuleCreateInfo { Code = vertMemory, CodeSize = new UIntPtr((ulong)vertMemory.Length), }; IMgShaderModule vertexProgram = null; err = mConfiguration.Device.CreateShaderModule(vertCreateInfo, null, out vertexProgram); Debug.Assert(err == Result.SUCCESS); IMgPipelineLayout pipelineLayout; MgPipelineLayoutCreateInfo plCreateInfo = new MgPipelineLayoutCreateInfo { SetLayouts = new IMgDescriptorSetLayout[] { mSetLayout, }, }; err = mConfiguration.Device.CreatePipelineLayout(plCreateInfo, null, out pipelineLayout); mPipelineLayout = pipelineLayout; var vertexStride = Marshal.SizeOf <Vector3>(); IMgPipeline[] pipelines; var pCreateInfos = new MgGraphicsPipelineCreateInfo[] { new MgGraphicsPipelineCreateInfo { Stages = new MgPipelineShaderStageCreateInfo[] { new MgPipelineShaderStageCreateInfo { Module = fragmentProgram, Stage = MgShaderStageFlagBits.FRAGMENT_BIT, Name = "lighting_fragment", }, new MgPipelineShaderStageCreateInfo { Module = vertexProgram, Stage = MgShaderStageFlagBits.VERTEX_BIT, Name = "lighting_vertex", }, }, InputAssemblyState = new MgPipelineInputAssemblyStateCreateInfo { Topology = MgPrimitiveTopology.TRIANGLE_LIST, }, DepthStencilState = new MgPipelineDepthStencilStateCreateInfo { DepthCompareOp = MgCompareOp.LESS, DepthWriteEnable = true, DepthTestEnable = true, }, MultisampleState = new MgPipelineMultisampleStateCreateInfo { // TODO : METALSample uses 4 bits, have to investigated multisampling in // Vulkan ( => Magnesium) for correct code RasterizationSamples = MgSampleCountFlagBits.COUNT_1_BIT, }, RasterizationState = new MgPipelineRasterizationStateCreateInfo { FrontFace = MgFrontFace.COUNTER_CLOCKWISE, PolygonMode = MgPolygonMode.FILL, CullMode = MgCullModeFlagBits.BACK_BIT, }, VertexInputState = new MgPipelineVertexInputStateCreateInfo { VertexBindingDescriptions = new MgVertexInputBindingDescription[] { new MgVertexInputBindingDescription { Binding = 0, InputRate = MgVertexInputRate.VERTEX, Stride = (uint)(2 * vertexStride), }, }, VertexAttributeDescriptions = new MgVertexInputAttributeDescription[] { new MgVertexInputAttributeDescription { Binding = 0, Location = 0, Format = MgFormat.R32G32B32_SFLOAT, Offset = 0, }, new MgVertexInputAttributeDescription { Binding = 0, Location = 1, Format = MgFormat.R32G32B32_SFLOAT, Offset = (uint)vertexStride, }, }, }, ViewportState = new MgPipelineViewportStateCreateInfo { Viewports = new MgViewport[] { mGraphicsDevice.CurrentViewport, }, Scissors = new MgRect2D[] { mGraphicsDevice.Scissor, } }, //DynamicState = new MgPipelineDynamicStateCreateInfo //{ // DynamicStates = new MgDynamicState[] // { // MgDynamicState.VIEWPORT, // MgDynamicState.SCISSOR, // } //}, RenderPass = mGraphicsDevice.Renderpass, Layout = pipelineLayout, }, }; err = mConfiguration.Device.CreateGraphicsPipelines( null, pCreateInfos, null, out pipelines); Debug.Assert(err == Result.SUCCESS); fragmentProgram.DestroyShaderModule(mConfiguration.Device, null); vertexProgram.DestroyShaderModule(mConfiguration.Device, null); mPipelineState = pipelines[0]; } GenerateRenderingCommandBuffers(); }