예제 #1
0
    public void UpdateMesh(ImDrawCmd cmd, ImVector_ushort idxBuffer, ImVector_ImDrawVert vtxBuffer, int startIndex)
    {
        mesh.Clear();

        // recreate arrays only if too small
        if (vertices.Length < vtxBuffer.Size)
        {
            vertices = new Vector3[vtxBuffer.Size];
            uv       = new Vector2[vtxBuffer.Size];
            colors   = new Color32[vtxBuffer.Size];
        }

        // Unity can't hoist Screen.height fetch from the loop
        // Fine, we'll do it ourselves
        int screenHeight = Screen.height;

        // populate mesh from draw data
        for (int i = 0; i < vtxBuffer.Size; i++)
        {
            ImDrawVert vertex = vtxBuffer[i];
            vertices[i].x = vertex.pos.x;
            vertices[i].y = screenHeight - vertex.pos.y;
            vertices[i].z = 0.0f;
            uv[i].x       = vertex.uv.x;
            uv[i].y       = vertex.uv.y;
            colors[i].a   = (byte)((vertex.col >> 24) & 255);
            colors[i].b   = (byte)((vertex.col >> 16) & 255);
            colors[i].g   = (byte)((vertex.col >> 8) & 255);
            colors[i].r   = (byte)((vertex.col) & 255);
        }

        if (triangles.Length != cmd.ElemCount)
        {
            triangles = new int[cmd.ElemCount];
        }
        for (int i = 0; i < cmd.ElemCount; i++)
        {
            triangles[i] = idxBuffer[i + startIndex];
        }

        mesh.vertices  = vertices;
        mesh.uv        = uv;
        mesh.colors32  = colors;
        mesh.triangles = triangles;
    }
예제 #2
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;
            }
        }