コード例 #1
0
ファイル: imgui.cs プロジェクト: bobdavies2000/OpenCVB
        public void Run()
        {
            Veldrid.InputSnapshot snapshot = window.PumpEvents();
            if (!window.Exists)
            {
                return;
            }
            controller.Update(1f / 60f, snapshot);

            ImGuiNET.ImGui.Text("Hello World!");
            ImGuiNET.ImGui.SameLine();
            ImGuiNET.ImGui.Checkbox("show another window?", ref showAWindow);
            if (showAWindow)
            {
                ImGuiNET.ImGui.SetNextWindowSize(
                    new System.Numerics.Vector2(128, 128));
                ImGuiNET.ImGui.Begin("Another window", ref showAWindow);
                ImGuiNET.ImGui.Text("Lorem ipsum");
                if (ImGuiNET.ImGui.Button("I got it"))
                {
                    showAWindow = false;
                }
                ImGuiNET.ImGui.End();
            }

            cl.Begin();
            cl.SetFramebuffer(gd.MainSwapchain.Framebuffer);
            cl.ClearColorTarget(0, new Veldrid.RgbaFloat(160f / 255, 160f / 255, 192f / 255, 255f));
            controller.Render(gd, cl);
            cl.End();
            gd.SubmitCommands(cl);
            gd.SwapBuffers(gd.MainSwapchain);
        }
コード例 #2
0
        public CommandList BuildCommandList(GraphicsDevice graphicsDevice, Framebuffer framebuffer)
        {
            Veldrid.CommandList _commandList = null;
            try
            {
                _commandList = graphicsDevice.ResourceFactory.CreateCommandList();
                if (_commandList == null)
                {
                    return(null);
                }

                _commandList.Begin();

                _commandList.SetFramebuffer(framebuffer);
                _commandList.SetFullViewports();

                _commandList.ClearColorTarget(0, RgbaFloat.DarkRed);

                _commandList.End();

                Veldrid.CommandList vret = _commandList;
                _commandList = null;

                return(vret);
            }
            finally
            {
                _commandList?.Dispose();
            }
        }
コード例 #3
0
        public Veldrid.CommandList BuildStandardCommandList()
        {
            if (CommandList == null)
            {
                CommandList = Renderer.VeldridFactory.CreateCommandList();
            }

            CommandList.Begin();
            CommandList.SetFramebuffer(Renderer.GraphicsDevice.SwapchainFramebuffer);

            if (ClearColor.HasValue)
            {
                float[] Floats = ClearColor.Value.GetFloats();
                CommandList.ClearColorTarget(0, new RgbaFloat(Floats[0], Floats[1], Floats[2], Floats[3]));
            }

            if (VertexBuffer != null)
            {
                if (!VertexBuffer.Bound)
                {
                    VertexBuffer.Bind();
                }
                VeldridCamera vCam = Camera as VeldridCamera;
                vCam.Update();

                UpdateModelBuffer();

                VeldridTexture texture = Texture as VeldridTexture;

                CommandList.SetVertexBuffer(0, (VertexBuffer as VeldridVertexBuffer).VertexBuffer);
                CommandList.SetIndexBuffer((VertexBuffer as VeldridVertexBuffer).IndexBuffer, IndexFormat.UInt16);
                if (texture != null)
                {
                    CommandList.SetPipeline((Material as VeldridMaterial).TexturedPipeline);
                }
                else
                {
                    CommandList.SetPipeline((Material as VeldridMaterial).UntexturedPipeline);
                }
                CommandList.SetGraphicsResourceSet(0, vCam.ProjectionViewResourceSet);
                CommandList.SetGraphicsResourceSet(1, ModelResourceSet);

                if (texture != null)
                {
                    CommandList.SetGraphicsResourceSet(2, texture.GetTextureResourceSet());
                }

                CommandList.DrawIndexed((uint)NumIndicies, 1, (uint)StartIndex, 0, 0);
            }

            CommandList.End();

            return(CommandList);
        }
コード例 #4
0
        private void PostImageLoad()
        {
            uint tx = (uint)Size.X;
            uint ty = (uint)Size.Y;

            Texture = Renderer.VeldridFactory.CreateTexture(new Veldrid.TextureDescription(
                                                                tx, ty, 1,
                                                                1, 1,
                                                                Veldrid.PixelFormat.R8_G8_B8_A8_UNorm, Veldrid.TextureUsage.Sampled, Veldrid.TextureType.Texture2D));

            Veldrid.Texture StagingTexture = Renderer.VeldridFactory.CreateTexture(new Veldrid.TextureDescription(
                                                                                       tx, ty, 1,
                                                                                       1, 1,
                                                                                       Veldrid.PixelFormat.R8_G8_B8_A8_UNorm, Veldrid.TextureUsage.Staging, Veldrid.TextureType.Texture2D));

            Span <Rgba32> Pixels;

            InternalTexture.TryGetSinglePixelSpan(out Pixels);

            Span <byte> Bytes = MemoryMarshal.AsBytes(Pixels);


            //TODO: Fix this copy (Bytes.ToArray()) and use the memory directly.  UpdateTexture takes an intptr so get that
            Renderer.GraphicsDevice.UpdateTexture(StagingTexture, Bytes.ToArray(),
                                                  0, 0, 0,
                                                  tx, ty, 1,
                                                  0, 0);

            using (Veldrid.CommandList cl = Renderer.VeldridFactory.CreateCommandList())
            {
                cl.Begin();
                cl.CopyTexture(StagingTexture, Texture);
                cl.End();
                Renderer.GraphicsDevice.SubmitCommands(cl);
                Renderer.GraphicsDevice.WaitForIdle();
            }
        }
コード例 #5
0
        unsafe public CommandList BuildCommandList(GraphicsDevice graphicsDevice, Framebuffer framebuffer)
        {
            ResourceFactory factory       = graphicsDevice.ResourceFactory;
            Shader          _vsShader     = null;
            Shader          _psShader     = null;
            DeviceBuffer    _vertexBuffer = null;
            Pipeline        _pipeline     = null;

            Veldrid.CommandList _commandList = null;
            try
            {
                #region --- try

                #region --- shaders
                {
                    string _vsname = null;
                    string _psname = null;

                    switch (graphicsDevice.BackendType)
                    {
                    case GraphicsBackend.Direct3D11:
                        _vsname = "Test_Colored2DVertices.vs";
                        _psname = "Test_Colored2DVertices.ps";
                        break;

                    case GraphicsBackend.Metal:
                        _vsname = "Test_Colored2DVertices_vs.msl";
                        _psname = "Test_Colored2DVertices_ps.msl";
                        break;

                    case GraphicsBackend.Vulkan:
                        _vsname = "Test_Colored2DVertices_vs.spv";
                        _psname = "Test_Colored2DVertices_ps.spv";
                        break;

                    case GraphicsBackend.OpenGL:
                        _vsname = "Test_Colored2DVertices_vs.glsl";
                        _psname = "Test_Colored2DVertices_ps.glsl";
                        break;

                    case GraphicsBackend.OpenGLES:
                        _vsname = "Test_Colored2DVertices_vs_es.glsl";
                        _psname = "Test_Colored2DVertices_ps_es.glsl";
                        break;
                    }

                    string _vs = loadResourceString(Assembly.GetExecutingAssembly(), _vsname);
                    if (string.IsNullOrEmpty(_vs))
                    {
                        return(null);
                    }
                    string _ps = loadResourceString(Assembly.GetExecutingAssembly(), _psname);
                    if (string.IsNullOrEmpty(_ps))
                    {
                        return(null);
                    }

                    ShaderDescription vertexShaderDesc = new ShaderDescription(
                        ShaderStages.Vertex,
                        Encoding.UTF8.GetBytes(_vs),
                        "_VertexShader");
                    ShaderDescription fragmentShaderDesc = new ShaderDescription(
                        ShaderStages.Fragment,
                        Encoding.UTF8.GetBytes(_ps),
                        "_PixelShader");

                    _vsShader = factory.CreateShader(vertexShaderDesc);
                    _psShader = factory.CreateShader(fragmentShaderDesc);
                }
                #endregion

                VertexLayoutDescription _vertexLayout = new VertexLayoutDescription();
                int _vertexCount;

                #region --- _vertexBuffer + _vertexLayout
                {
                    int    _count = 10;
                    byte[] _data  = Build_2DColoredQuads_16SNorm_8UNorm(_count, _count, out _vertexCount);
                    //
                    Veldrid.BufferDescription vbDescription = new Veldrid.BufferDescription(
                        (uint)_data.Length,
                        BufferUsage.VertexBuffer);
                    _vertexBuffer = factory.CreateBuffer(vbDescription);

                    fixed(byte *_pdata = _data)
                    {
                        graphicsDevice.UpdateBuffer(_vertexBuffer, bufferOffsetInBytes: 0, (IntPtr)_pdata, (uint)_data.Length);
                    }

                    _vertexLayout = new VertexLayoutDescription(
                        new VertexElementDescription("Position",
                                                     VertexElementSemantic.Position,
                                                     VertexElementFormat.Short2_Norm,
                                                     offset: 0),
                        new VertexElementDescription("Color",
                                                     VertexElementSemantic.Color,
                                                     VertexElementFormat.Byte4_Norm,
                                                     offset: 2 * sizeof(short)));
                }
                #endregion

                #region --- pipeline
                {
                    GraphicsPipelineDescription _pipelineDescription = new GraphicsPipelineDescription();

                    _pipelineDescription.BlendState = Veldrid.BlendStateDescription.SingleOverrideBlend;

                    _pipelineDescription.DepthStencilState = new Veldrid.DepthStencilStateDescription(
                        depthTestEnabled: false,
                        depthWriteEnabled: false,
                        comparisonKind: ComparisonKind.LessEqual);

                    _pipelineDescription.RasterizerState = new Veldrid.RasterizerStateDescription(
                        cullMode: FaceCullMode.None,
                        fillMode: PolygonFillMode.Solid,
                        frontFace: FrontFace.Clockwise,
                        depthClipEnabled: true, // Android ?
                        scissorTestEnabled: false);

                    _pipelineDescription.PrimitiveTopology = Veldrid.PrimitiveTopology.TriangleList;
                    _pipelineDescription.ResourceLayouts   = System.Array.Empty <ResourceLayout>();

                    _pipelineDescription.ShaderSet = new ShaderSetDescription(
                        vertexLayouts: new VertexLayoutDescription[] { _vertexLayout },
                        shaders: new Shader[] { _vsShader, _psShader });

                    _pipelineDescription.Outputs = framebuffer.OutputDescription; // _offscreenFB.OutputDescription;

                    _pipeline = factory.CreateGraphicsPipeline(_pipelineDescription);
                }
                #endregion

                #region --- commandList
                {
                    _commandList = factory.CreateCommandList();

                    // Begin() must be called before commands can be issued.
                    _commandList.Begin();

                    _commandList.SetPipeline(_pipeline);

                    // We want to render directly to the output window.
                    _commandList.SetFramebuffer(framebuffer);

                    _commandList.SetFullViewports();
                    _commandList.ClearColorTarget(0, RgbaFloat.DarkRed);

                    // Set all relevant state to draw our quad.
                    _commandList.SetVertexBuffer(0, _vertexBuffer);

                    _commandList.Draw(vertexCount: (uint)_vertexCount);

                    // End() must be called before commands can be submitted for execution.
                    _commandList.End();
                }
                #endregion

                CommandList vret = _commandList;
                _commandList = null;

                return(vret);

                #endregion
            }
            catch (Exception e)
            {
                return(null);
            }
            finally
            {
                _vsShader?.Dispose();
                _psShader?.Dispose();
                _vertexBuffer?.Dispose();
                _pipeline?.Dispose();
                _commandList?.Dispose();
            }
        }
コード例 #6
0
        static void Main(string[] args)
        {
            //AppDomain.CurrentDomain.ProcessExit+= (s,e)=>{}

            var path = Path.GetTempFileName();

            System.IO.File.WriteAllText(path, testVGAOutputProgram);
            var assemblerInst   = new assembler.Assembler(path);
            var assembledResult = assemblerInst.ConvertToBinary();
            var binaryProgram   = assembledResult.Select(x => Convert.ToInt32(x, 16));

            //lets convert our final assembled program back to assembly instructions so we can view it.
            //dissasembly)
            var assembler2 = new assembler.Assembler(path);

            expandedCode = assembler2.ExpandMacros().ToArray();


            simulatorInstance = new simulator.eightChipsSimulator(16, (int)Math.Pow(2, 16));
            simulatorInstance.setUserCode(binaryProgram.ToArray());

            //TODO use cancellation token here.
            simulationThread = Task.Run(() =>
            {
                simulatorInstance.ProgramCounter = (int)assembler.Assembler.MemoryMap[assembler.Assembler.MemoryMapKeys.user_code].AbsoluteStart;
                simulatorInstance.runSimulation();
            });


            // Create window, GraphicsDevice, and all resources necessary for the demo.
            VeldridStartup.CreateWindowAndGraphicsDevice(
                new WindowCreateInfo(50, 50, 1280, 720, WindowState.Normal, "8 chips simulator 2"),
                new GraphicsDeviceOptions(true, null, true),
                out mainWindow,
                out gd);

            mainWindow.Resized += () =>
            {
                gd.MainSwapchain.Resize((uint)mainWindow.Width, (uint)mainWindow.Height);
                controller.WindowResized(mainWindow.Width, mainWindow.Height);
            };
            commandList = gd.ResourceFactory.CreateCommandList();
            controller  = new Veldrid.ImGuiRenderer(gd, gd.MainSwapchain.Framebuffer.OutputDescription, mainWindow.Width, mainWindow.Height);

            var data = simulatorInstance.mainMemory.Select(x => convertShortFormatToFullColor(Convert.ToInt32(x).ToBinary())).ToArray();

            //try creating an texture and binding it to an image which imgui will draw...
            //we'll need to modify this image every frame potentially...

            var texture = gd.ResourceFactory.CreateTexture(TextureDescription.Texture2D(width, height, 1, 1, PixelFormat.R8_G8_B8_A8_UNorm, TextureUsage.Sampled));

            CPUframeBufferTextureId = controller.GetOrCreateImGuiBinding(gd.ResourceFactory, texture);
            gd.UpdateTexture(texture, data, 0, 0, 0, width, height, 1, 0, 0);
            textureMap.Add(CPUframeBufferTextureId, texture);

            /*
             *          var state = new object();
             *          var timer = new System.Threading.Timer((o) =>
             *          {
             *              int[] newdata = simulatorInstance.mainMemory.Select(x => convertShortFormatToFullColor(x)).ToArray();
             *              var currenttexture = textureMap[CPUframeBufferTextureId];
             *              gd.UpdateTexture(currenttexture, newdata, 0, 0, 0, 256, 256, 1, 0, 0);
             *          }, state, 1000, 150);
             *
             */
            // Main application loop
            while (mainWindow.Exists)
            {
                InputSnapshot snapshot = mainWindow.PumpEvents();
                if (!mainWindow.Exists)
                {
                    break;
                }
                controller.Update(1f / 60f, snapshot); // Feed the input events to our ImGui controller, which passes them through to ImGui.

                SubmitUI();

                commandList.Begin();
                commandList.SetFramebuffer(gd.MainSwapchain.Framebuffer);
                commandList.ClearColorTarget(0, new RgbaFloat(.1f, .1f, .1f, .2f));
                controller.Render(gd, commandList);
                commandList.End();
                gd.SubmitCommands(commandList);
                gd.SwapBuffers(gd.MainSwapchain);
            }

            // Clean up Veldrid resources
            gd.WaitForIdle();
            controller.Dispose();
            commandList.Dispose();
            gd.Dispose();
        }