Пример #1
0
        // Draw the imgui triangle data
        void DrawTriangles(uint count, ImVector <ushort> idxBuffer, ImPtrVector <ImDrawVertPtr> idxVert, int idxOffset, int vtxOffset, IntPtr textureId)
        {
            uint          texId = (uint)textureId;
            ushort        index;
            ImDrawVertPtr vertex;

            if (Rlgl.rlCheckBufferLimit((int)count * 3))
            {
                Rlgl.rlglDraw();
            }

            Rlgl.rlPushMatrix();
            Rlgl.rlBegin(Rlgl.RL_TRIANGLES);
            Rlgl.rlEnableTexture(texId);

            for (int i = 0; i <= (count - 3); i += 3)
            {
                index  = idxBuffer[idxOffset + i];
                vertex = idxVert[vtxOffset + index];
                DrawTriangleVertex(vertex);

                index  = idxBuffer[idxOffset + i + 2];
                vertex = idxVert[vtxOffset + index];
                DrawTriangleVertex(vertex);

                index  = idxBuffer[idxOffset + i + 1];
                vertex = idxVert[vtxOffset + index];
                DrawTriangleVertex(vertex);
            }

            Rlgl.rlDisableTexture();
            Rlgl.rlEnd();
            Rlgl.rlPopMatrix();
        }
Пример #2
0
        unsafe void RenderCommandLists(ImDrawDataPtr drawData)
        {
            // Scale coordinates for retina displays (screen coordinates != framebuffer coordinates)
            int fbWidth  = (int)(drawData.DisplaySize.X * drawData.FramebufferScale.X);
            int fbHeight = (int)(drawData.DisplaySize.Y * drawData.FramebufferScale.Y);

            // Avoid rendering if display is minimized or if the command list is empty
            if (fbWidth <= 0 || fbHeight <= 0 || drawData.CmdListsCount == 0)
            {
                return;
            }

            drawData.ScaleClipRects(ImGui.GetIO().DisplayFramebufferScale);
            Rlgl.rlDisableBackfaceCulling();

            for (int n = 0; n < drawData.CmdListsCount; n++)
            {
                ImDrawListPtr cmdList = drawData.CmdListsRange[n];

                // Vertex buffer and index buffer generated by Dear ImGui
                ImPtrVector <ImDrawVertPtr> vtxBuffer = cmdList.VtxBuffer;
                ImVector <ushort>           idxBuffer = cmdList.IdxBuffer;

                for (int cmdi = 0; cmdi < cmdList.CmdBuffer.Size; cmdi++)
                {
                    ImDrawCmdPtr pcmd = cmdList.CmdBuffer[cmdi];
                    if (pcmd.UserCallback != IntPtr.Zero)
                    {
                        // pcmd.UserCallback(cmdList, pcmd);
                    }
                    else
                    {
                        Vector2 pos   = drawData.DisplayPos;
                        int     rectX = (int)((pcmd.ClipRect.X - pos.X) * drawData.FramebufferScale.X);
                        int     rectY = (int)((pcmd.ClipRect.Y - pos.Y) * drawData.FramebufferScale.Y);
                        int     rectW = (int)((pcmd.ClipRect.Z - rectX) * drawData.FramebufferScale.X);
                        int     rectH = (int)((pcmd.ClipRect.W - rectY) * drawData.FramebufferScale.Y);

                        if (rectX < fbWidth && rectY < fbHeight && rectW >= 0.0f && rectH >= 0.0f)
                        {
                            Raylib.BeginScissorMode(rectX, rectY, rectW, rectH);
                            DrawTriangles(pcmd.ElemCount, idxBuffer, vtxBuffer, (int)pcmd.IdxOffset, (int)pcmd.VtxOffset, pcmd.TextureId);
                        }
                    }
                }
            }

            Raylib.EndScissorMode();
            Rlgl.rlEnableBackfaceCulling();
        }
Пример #3
0
        public void SubmitImGuiToRenderer()
        {
            ImDrawDataPtr test;

            test = ImGui.GetDrawData();
            ImDrawListPtr test3;

            if (test.CmdListsCount > 0)
            {
                test3 = test.CmdListsRange[0];

                ImVector <ushort>           ptr = test3.IdxBuffer;
                ImPtrVector <ImDrawVertPtr> t1  = test3.VtxBuffer;
                ImDrawVertPtr pp;

                ImDrawVert[] vertbuf = new ImDrawVert[t1.Size];

                unsafe
                {
                    for (int i = 0; i < t1.Size; i++)
                    {
                        pp = t1[i];
                        ImDrawVert ff = new ImDrawVert();

                        // Console.WriteLine("vertex x:{0} y:{1}, u:{2} v:{3} color:{4}", ff.pos.X, ff.pos.Y, ff.uv.X, ff.uv.Y, ff.col);
                        ff.pos     = pp.pos;
                        ff.uv      = pp.uv;
                        ff.col     = pp.col;
                        vertbuf[i] = ff;
                    }
                }
                ushort[] indexbuf = new ushort[ptr.Size];

                for (int i = 0; i < ptr.Size; i++)
                {
                    indexbuf[i] = (ushort)ptr[i];
                }

                // indexbuf хранит индекс координаты в vertbuf, рисует полигоны, поэтому уходит по три индекса. индекс составлен так, что координаты
                // перечисляются против часовой стрелки.
                int   y;
                Color c;
                Dictionary <int, Vertex[]> imgvelist = new Dictionary <int, Vertex[]>();
                int idxoffsettemp = 0;
                int nv            = 0;

                for (int i = 0; i < test3.CmdBuffer.Size; i++)
                {
                    ImDrawCmdPtr dc = test3.CmdBuffer[i];
                    if (dc.TextureId != IntPtr.Zero && dc.TextureId.ToInt32() != 1)
                    {
                        List <SpriteRenderable> sr = BufferSpriteRenderable[dc.TextureId.ToInt32()];

                        idxoffsettemp = (int)dc.IdxOffset;

                        // для этих спрайтов в sr,  UV координаты даны относительно текстуры 2048 на 2048 пикселей.
                        y = indexbuf[idxoffsettemp];
                        Vertex[] tempve = new Vertex[6 * sr.Count];
                        nv = 0;

                        foreach (SpriteRenderable sre in sr)
                        {
                            PaletteReference pr = sre.Palette;

                            // берем XY в мире, и превращаем в координаты . Потом отнимаем смещение окна Imgui
                            // float3 worldtoIGposl = sre.ScreenPosition(Game.worldRenderer);

                            // потом в шейдере отнимется смещение от ViewPort
                            // worldtoIGposl = worldtoIGposl - new float3(Game.worldRenderer.Viewport.TopLeft.X, Game.worldRenderer.Viewport.TopLeft.Y, 0);
                            // worldtoIGposl = worldtoIGposl - new float3(worldtoIGposl.X, worldtoIGposl.Y,0);
                            // worldtoIGposl = worldtoIGposl + new float3(this.Bounds.X+100, this.Bounds.Y+100, 0) ;
                            // var xy = wr.ScreenPxPosition(pos) + wr.ScreenPxOffset(offset) - (0.5f * scale * sprite.Size.XY).ToInt2();
                            // Console.WriteLine("x: " + xy.X + " y: " + xy.Y + " | offX:" + sre.sprite.Offset.X + " offY:" + sre.sprite.Offset.Y +" |SpriteRenderable " + this.Actor.Info.Name + " owner:" + this.Actor.Owner);
                            SamplerPointer spritelocation = Game.Renderer.ImguiSpriteRenderer.SetRenderStateForSprite(sre.sprite);
                            // OpenRA.Graphics.Util.FastCreateQuadImGui(tempve, new float3(this.Bounds.X+ 16 * sre.Offset.X / 1024  + sre.sprite.Offset.X, this.Bounds.Y + 16 * sre.Offset.Y  / 1024  + sre.sprite.Offset.Y, 0) + sre.sprite.FractionalOffset * sre.sprite.Size, sre.sprite, new int2(4, 0), pr.TextureIndex, nv, sre.sprite.Size);

                            OpenRA.Graphics.Util.FastCreateQuadImGui(tempve, new float3(16 + vertbuf[y].pos.X + 16 * sre.Offset.X / 1024 + sre.sprite.Offset.X, 16 + vertbuf[y].pos.Y + 16 * sre.Offset.Y / 1024 + sre.sprite.Offset.Y, 0), sre.sprite, spritelocation, pr.TextureIndex, nv, sre.sprite.Size);

                            nv += 6;
                        }

                        nv          -= 6;
                        imgvelist[y] = tempve;

                        // new Vertex(vertbuf[idxoffsettemp].pos.X, vertbuf[idxoffsettemp].pos.Y, 0, vertbuf[idxoffsettemp].uv.X, vertbuf[idxoffsettemp].uv.Y, 0f, 0f, 0f, 5f, 255f / 255f, 255f / 255f, 255f / 255f, 255f / 255f)
                        // sr.Render(null);
                    }
                }
                ve = new Vertex[indexbuf.Length + nv];

                for (int i = 0; i < indexbuf.Length; i++)
                {
                    y = indexbuf[i];                     // индекс для vertbuf хранится в ячейке indexbuf.
                    c = Color.FromArgb(vertbuf[y].col);

                    // если совпал y с imgvelist ключом, то запускаем for на 6 циклов и потом увеличиваем i на 6 позиций.
                    if (imgvelist.ContainsKey(y))
                    {
                        for (int f = 0; f < imgvelist[y].Length; f++)
                        {
                            ve[i] = imgvelist[y][f];
                            i++;
                        }
                        i--;
                    }
                    else
                    {
                        imguifonttextureLocation = Game.Renderer.ImguiSpriteRenderer.SetRenderStateForSprite(sp);
                        ve[i] = new Vertex(vertbuf[y].pos.X, vertbuf[y].pos.Y, 0, vertbuf[y].uv.X, vertbuf[y].uv.Y, 0f, 0f, imguifonttextureLocation.num1, 0f, 4f, 0, c.R / 255f, c.G / 255f, c.B / 255f, c.A / 255f, 0, 0);
                    }
                }

                // теперь нужно создать спрайт, чтобы вызывать Renderer.DrawSprite для занесения данных в VAO
                // типа строчка в VBO появляется как желание нарисовать спрайт. В данном случае спрайт это должна быть буква.
                // Но нет. Тут просто линия цветные
                Game.Renderer.ImguiSpriteRenderer.DrawRGBAVertices(ve);
                //Game.Renderer.ImguiSpriteRenderer.ns = 1;
            }
        }
Пример #4
0
        public static void RenderDrawData(ImDrawDataPtr drawData, int displayW, int displayH)
        {
            // We are using the OpenGL fixed pipeline to make the example code simpler to read!
            // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, vertex/texcoord/color pointers.
            int  lastTexture; GL.GetIntegerv(GL.Enum.GL_TEXTURE_BINDING_2D, out lastTexture);
            Int4 lastViewport; GL.GetIntegerv4(GL.Enum.GL_VIEWPORT, out lastViewport);
            Int4 lastScissorBox; GL.GetIntegerv4(GL.Enum.GL_SCISSOR_BOX, out lastScissorBox);

            GL.PushAttrib(GL.Enum.GL_ENABLE_BIT | GL.Enum.GL_COLOR_BUFFER_BIT | GL.Enum.GL_TRANSFORM_BIT);
            GL.Enable(GL.Enum.GL_BLEND);
            GL.BlendFunc(GL.Enum.GL_SRC_ALPHA, GL.Enum.GL_ONE_MINUS_SRC_ALPHA);
            GL.Disable(GL.Enum.GL_CULL_FACE);
            GL.Disable(GL.Enum.GL_DEPTH_TEST);
            GL.Enable(GL.Enum.GL_SCISSOR_TEST);
            GL.EnableClientState(GL.Enum.GL_VERTEX_ARRAY);
            GL.EnableClientState(GL.Enum.GL_TEXTURE_COORD_ARRAY);
            GL.EnableClientState(GL.Enum.GL_COLOR_ARRAY);
            GL.Enable(GL.Enum.GL_TEXTURE_2D);

            GL.UseProgram(0);

            // Handle cases of screen coordinates != from framebuffer coordinates (e.g. retina displays)
            ImGuiIOPtr io = ImGui.GetIO();

            //ImGui.ScaleClipRects(drawData, io.DisplayFramebufferScale); imgui.net doesn't apear to have this

            // Setup orthographic projection matrix
            GL.Viewport(0, 0, displayW, displayH);
            GL.MatrixMode(GL.Enum.GL_PROJECTION);
            GL.PushMatrix();
            GL.LoadIdentity();
            GL.Ortho(
                0.0f,
                io.DisplaySize.X / io.DisplayFramebufferScale.X,
                io.DisplaySize.Y / io.DisplayFramebufferScale.Y,
                0.0f,
                -1.0f,
                1.0f
                );
            GL.MatrixMode(GL.Enum.GL_MODELVIEW);
            GL.PushMatrix();
            GL.LoadIdentity();

            // Render command lists

            for (int n = 0; n < drawData.CmdListsCount; n++)
            {
                ImDrawListPtr cmdList = drawData.CmdListsRange[n];
                //ImDrawList cmdList = drawData[n];
                ImPtrVector <ImDrawVertPtr> vtxBuffer = cmdList.VtxBuffer;
                ImVector <ushort>           idxBuffer = cmdList.IdxBuffer;
                int posOffset = 0;
                int uvOffset  = 8;
                int colOffset = 16;
                //GL.VertexPointer(
                GL.VertexPointer(2, GL.Enum.GL_FLOAT, Unsafe.SizeOf <ImDrawVert>(), new IntPtr((long)vtxBuffer.Data + posOffset));
                GL.TexCoordPointer(2, GL.Enum.GL_FLOAT, Unsafe.SizeOf <ImDrawVert>(), new IntPtr((long)vtxBuffer.Data + uvOffset));
                GL.ColorPointer(4, GL.Enum.GL_UNSIGNED_BYTE, Unsafe.SizeOf <ImDrawVert>(), new IntPtr((long)vtxBuffer.Data + colOffset));

                long idxBufferOffset = 0;
                for (int cmdi = 0; cmdi < cmdList.CmdBuffer.Size; cmdi++)
                {
                    ImDrawCmdPtr pcmd = cmdList.CmdBuffer[cmdi];

                    if (pcmd.UserCallback != IntPtr.Zero)
                    {
                        throw new NotImplementedException();
                        //pcmd.InvokeUserCallback(ref cmdList, ref pcmd);
                    }
                    else if (FontTextureID == pcmd.TextureId)
                    {
                        GL.BindTexture(GL.Enum.GL_TEXTURE_2D, (int)pcmd.TextureId);
                        GL.Scissor(
                            (int)pcmd.ClipRect.X,
                            (int)(io.DisplaySize.Y - pcmd.ClipRect.W),
                            (int)(pcmd.ClipRect.Z - pcmd.ClipRect.X),
                            (int)(pcmd.ClipRect.W - pcmd.ClipRect.Y)
                            );
                        GL.DrawElements(GL.Enum.GL_TRIANGLES, (int)pcmd.ElemCount, GL.Enum.GL_UNSIGNED_SHORT, new IntPtr((long)idxBuffer.Data + idxBufferOffset));
                    }
                    else
                    {
                        float w, h;
                        var   txid  = pcmd.TextureId;
                        var   sdlid = SDL.SDL_GL_BindTexture(pcmd.TextureId, out w, out h);

                        string errstr = SDL.SDL_GetError();
                        GL.Scissor(
                            (int)pcmd.ClipRect.X,
                            (int)(io.DisplaySize.Y - pcmd.ClipRect.W),
                            (int)(pcmd.ClipRect.Z - pcmd.ClipRect.X),
                            (int)(pcmd.ClipRect.W - pcmd.ClipRect.Y)
                            );

                        GL.DrawElements(GL.Enum.GL_TRIANGLES, (int)pcmd.ElemCount, GL.Enum.GL_UNSIGNED_SHORT, new IntPtr((long)idxBuffer.Data + idxBufferOffset));
                    }
                    idxBufferOffset += pcmd.ElemCount * 2 /*sizeof(ushort)*/;
                }
            }

            // Restore modified state
            GL.DisableClientState(GL.Enum.GL_COLOR_ARRAY);
            GL.DisableClientState(GL.Enum.GL_TEXTURE_COORD_ARRAY);
            GL.DisableClientState(GL.Enum.GL_VERTEX_ARRAY);
            GL.BindTexture(GL.Enum.GL_TEXTURE_2D, lastTexture);
            GL.MatrixMode(GL.Enum.GL_MODELVIEW);
            GL.PopMatrix();
            GL.MatrixMode(GL.Enum.GL_PROJECTION);
            GL.PopMatrix();
            GL.PopAttrib();
            GL.Viewport(lastViewport.X, lastViewport.Y, lastViewport.Z, lastViewport.W);
            GL.Scissor(lastScissorBox.X, lastScissorBox.Y, lastScissorBox.Z, lastScissorBox.W);
        }