fix thins hmmm.

void ImGuiInterface::RenderDrawLists(ImDrawData* data)
{
    ImDrawList** const cmd_lists = data->CmdLists;
    int cmd_lists_count = data->CmdListsCount;

    // Engine does not render when window is closed or device is lost
    assert(graphics_ && graphics_->IsInitialized() && !graphics_->IsDeviceLost());

    if (cmd_lists_count == 0)
        return;

    Vector2 invScreenSize(1.0f / (float)graphics_->GetWidth(), 1.0f / (float)graphics_->GetHeight());
    Vector2 scale(2.0f * invScreenSize.x_, -2.0f * invScreenSize.y_);
    Vector2 offset(-1.0f, 1.0f);

    Matrix4 projection(Matrix4::IDENTITY);
    projection.m00_ = scale.x_;
    projection.m03_ = offset.x_;
    projection.m11_ = scale.y_;
    projection.m13_ = offset.y_;
    projection.m22_ = 1.0f;
    projection.m23_ = 0.0f;
    projection.m33_ = 1.0f;


    graphics_->ClearParameterSources();
    graphics_->SetColorWrite(true);
    graphics_->SetCullMode(CULL_NONE);
    graphics_->SetDepthTest(CMP_ALWAYS);
    graphics_->SetDepthWrite(false);
    graphics_->SetFillMode(FILL_SOLID);
    graphics_->SetStencilTest(false);
    graphics_->ResetRenderTargets();
    graphics_->SetBlendMode(BLEND_ALPHA);



    ShaderVariation* noTextureVS = graphics_->GetShader(VS, "IMGUI", "VERTEXCOLOR");
    ShaderVariation* diffTextureVS = graphics_->GetShader(VS, "IMGUI", "DIFFMAP VERTEXCOLOR");
    ShaderVariation* noTexturePS = graphics_->GetShader(PS, "IMGUI", "VERTEXCOLOR");
    ShaderVariation* diffTexturePS = graphics_->GetShader(PS, "IMGUI", "DIFFMAP VERTEXCOLOR");
    ShaderVariation* diffMaskTexturePS = graphics_->GetShader(PS, "IMGUI", "DIFFMAP ALPHAMASK VERTEXCOLOR");
    ShaderVariation* alphaTexturePS = graphics_->GetShader(PS, "IMGUI", "ALPHAMAP VERTEXCOLOR");

    unsigned alphaFormat = Graphics::GetAlphaFormat();

    /// resize buffers
#if defined(URHO3D_D3D11)
    // TODO: for D3D11 : cannot set vertex/index buffer to dynamic. bug ? does it need to be dynamic ?
    if ((int)vertexBuffer_->GetVertexCount() < data->TotalVtxCount || (int)vertexBuffer_->GetVertexCount() > data->TotalVtxCount * 2)
        vertexBuffer_->SetSize(data->TotalVtxCount, MASK_POSITION | MASK_COLOR | MASK_TEXCOORD1, false);

    if ((int)indexBuffer_->GetIndexCount() < data->TotalIdxCount || (int)indexBuffer_->GetIndexCount() > data->TotalIdxCount * 2)
        indexBuffer_->SetSize(data->TotalIdxCount, false, false);
#else
    if ((int)vertexBuffer_->GetVertexCount() < data->TotalVtxCount || (int)vertexBuffer_->GetVertexCount() > data->TotalVtxCount * 2)
        vertexBuffer_->SetSize(data->TotalVtxCount, MASK_POSITION | MASK_COLOR | MASK_TEXCOORD1, true);

    if ((int)indexBuffer_->GetIndexCount() < data->TotalIdxCount || (int)indexBuffer_->GetIndexCount() > data->TotalIdxCount * 2)
        indexBuffer_->SetSize(data->TotalIdxCount, false, true);
#endif

    // Copy and convert all vertices into a single contiguous buffer

    //      int vtx_list_offset = 0;
    //      int idx_list_offset = 0;
    //      for (int n = 0; n < data->CmdListsCount; n++)
    //      {
    //          const ImDrawList* cmd_list = data->CmdLists[n];
    //
    //          vertexBuffer_->SetDataRange(&cmd_list->VtxBuffer[0], vtx_list_offset, cmd_list->VtxBuffer.size());
    //          indexBuffer_->SetDataRange(&cmd_list->IdxBuffer[0], idx_list_offset, cmd_list->IdxBuffer.size());
    //
    //          vtx_list_offset += cmd_list->VtxBuffer.size();
    //          idx_list_offset += cmd_list->IdxBuffer.size();
    //      }

#ifndef GL_ES_VERSION_2_0
    ImDrawVert* vtx_dst = (ImDrawVert*)vertexBuffer_->Lock(0, data->TotalVtxCount);
    ImDrawIdx* idx_dst = (ImDrawIdx*)indexBuffer_->Lock(0, data->TotalIdxCount);
    for (int n = 0; n < data->CmdListsCount; n++)
    {
        const ImDrawList* cmd_list = data->CmdLists[n];
        memcpy(vtx_dst, &cmd_list->VtxBuffer[0], cmd_list->VtxBuffer.size() * sizeof(ImDrawVert));
        memcpy(idx_dst, &cmd_list->IdxBuffer[0], cmd_list->IdxBuffer.size() * sizeof(ImDrawIdx));
        vtx_dst += cmd_list->VtxBuffer.size();
        idx_dst += cmd_list->IdxBuffer.size();
    }
    vertexBuffer_->Unlock();
    indexBuffer_->Unlock();
#endif

    graphics_->SetVertexBuffer(vertexBuffer_);
    graphics_->SetIndexBuffer(indexBuffer_);

    // Render command lists
    int vtx_offset = 0;
    int idx_offset = 0;
    for (int n = 0; n < data->CmdListsCount; n++)
    {
        const ImDrawList* cmd_list = data->CmdLists[n];
#ifdef GL_ES_VERSION_2_0

        vertexBuffer_->SetDataRange(&cmd_list->VtxBuffer[0], 0, cmd_list->VtxBuffer.size());
        indexBuffer_->SetDataRange(&cmd_list->IdxBuffer[0], 0, cmd_list->IdxBuffer.size());

        idx_offset = 0;
#endif

        for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.size(); cmd_i++)
        {
            const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
            if (pcmd->UserCallback)
            {
                pcmd->UserCallback(cmd_list, pcmd);
            }
            else
            {
                Texture* texture = (Urho3D::Texture*)(intptr_t)pcmd->TextureId;
                ShaderVariation* ps;
                ShaderVariation* vs;
                if (!texture)
                {
                    ps = noTexturePS;
                    vs = noTextureVS;
                }
                else
                {
                    vs = diffTextureVS;
                    // If texture contains only an alpha channel, use alpha shader (for fonts)
                    if (texture->GetFormat() == alphaFormat)
                        ps = alphaTexturePS;
                    //                      else if (blendMode_ != BLEND_ALPHA && batch.blendMode_ != BLEND_ADDALPHA && batch.blendMode_ != BLEND_PREMULALPHA)
                    //                                  ps = diffMaskTexturePS;
                    else
                        ps = diffTexturePS;
                }

                graphics_->SetShaders(vs, ps);

                if (graphics_->NeedParameterUpdate(SP_OBJECT, this))
                    graphics_->SetShaderParameter(VSP_MODEL, Matrix3x4::IDENTITY);
                if (graphics_->NeedParameterUpdate(SP_CAMERA, this))
                    graphics_->SetShaderParameter(VSP_VIEWPROJ, projection);
                if (graphics_->NeedParameterUpdate(SP_MATERIAL, this))
                    graphics_->SetShaderParameter(PSP_MATDIFFCOLOR, Color(1.0f, 1.0f, 1.0f, 1.0f));

                graphics_->SetScissorTest(true, IntRect((int)pcmd->ClipRect.x, (int)(pcmd->ClipRect.y),
                                                        (int)(pcmd->ClipRect.z), (int)(pcmd->ClipRect.w)));

                graphics_->SetTexture(0, texture);

#if defined(URHO3D_OPENGL)

#ifdef GL_ES_VERSION_2_0
                graphics_->Draw(TRIANGLE_LIST, idx_offset, pcmd->ElemCount, 0, cmd_list->VtxBuffer.size());
#else
                graphics_->Draw(TRIANGLE_LIST, idx_offset, pcmd->ElemCount, vtx_offset, 0, cmd_list->VtxBuffer.size());

#endif
#else
                graphics_->Draw(TRIANGLE_LIST, idx_offset, pcmd->ElemCount, vtx_offset, 0, cmd_list->VtxBuffer.size());
#endif
            }
            idx_offset += pcmd->ElemCount;
        }
        vtx_offset += cmd_list->VtxBuffer.size();
    }
    ALPHAENGINE_LOGINFO("process");

}