VirtualBox

Changeset 85368 in vbox for trunk/src/VBox/Devices/Graphics


Ignore:
Timestamp:
Jul 17, 2020 9:55:56 AM (5 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
139379
Message:

Devices/Graphics,Main,include: Experimental graphics output. bugref:9695

Location:
trunk/src/VBox/Devices/Graphics
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA.cpp

    r84919 r85368  
    44584458# ifdef VBOX_WITH_VMSVGA3D
    44594459                if (RT_LIKELY(pThis->svga.f3DEnabled))
    4460                     vmsvga3dDefineScreen(pThisCC, pScreen);
     4460                    vmsvga3dDefineScreen(pThis, pThisCC, pScreen);
    44614461# endif
    44624462                break;

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA.h

    r84802 r85368  
    222222    /** True when the guest modifies the GFB mode registers. */
    223223    bool                        fGFBRegisters;
    224     bool                        afPadding[6];
     224    /** SVGA 3D overlay enabled or not. */
     225    bool                        f3DOverlayEnabled;
     226    bool                        afPadding[5];
    225227    uint32_t                    uWidth;
    226228    uint32_t                    uHeight;

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-glLdr.cpp

    r84725 r85368  
    203203    pfn_XSetErrorHandler = 0;
    204204    pfn_XSync = 0;
     205    pfn_XScreenNumberOfScreen = 0;
     206    pfn_XMapWindow = 0;
     207    pfn_XGetWindowAttributes = 0;
    205208    pfn_glXGetFBConfigAttrib = 0;
    206209    pfn_glXGetVisualFromFBConfig = 0;
    … …  
    310313    X11GETPROC_(XSetErrorHandler);
    311314    X11GETPROC_(XSync);
     315    X11GETPROC_(XScreenNumberOfScreen);
     316    X11GETPROC_(XMapWindow);
     317    X11GETPROC_(XGetWindowAttributes);
    312318    GLGETPROC_(glXGetFBConfigAttrib, "");
    313319    GLGETPROC_(glXGetVisualFromFBConfig, "");

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-glLdr.h

    r84727 r85368  
    422422#define XSync pfn_XSync
    423423
     424GLPFN int (* pfn_XScreenNumberOfScreen)(Screen *screen);
     425#define XScreenNumberOfScreen pfn_XScreenNumberOfScreen
     426
     427GLPFN int (* pfn_XMapWindow)(Display *display, Window w);
     428#define XMapWindow pfn_XMapWindow
     429
     430GLPFN Status (* pfn_XGetWindowAttributes)(Display *display, Window w, XWindowAttributes *window_attributes_return);
     431#define XGetWindowAttributes pfn_XGetWindowAttributes
     432
    424433#endif
    425434

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-internal.h

    r84742 r85368  
    11771177    uint32_t u32Reserved0;
    11781178#if defined(RT_OS_LINUX)
    1179     VisualID visualid;
    1180     Pixmap pixmap;
    1181     GLXPixmap glxpixmap;
     1179    /* OpenGL context, which is used for the screen updates. */
    11821180    GLXContext glxctx;
    1183     bool fYInverted;
    1184     bool fMipmap;
     1181
     1182    /* The overlay window. */
     1183    Window xwindow;
     1184
     1185    /* The RGBA texture which hold the screen content. */
     1186    GLuint idScreenTexture;
     1187
     1188    /* Read and draw framebuffer objects for copying a surface to the screen texture. */
     1189    GLuint idReadFramebuffer;
     1190    GLuint idDrawFramebuffer;
    11851191#endif
    11861192} VMSVGAHWSCREEN;
    11871193
    1188 int vmsvga3dBackDefineScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen);
     1194int vmsvga3dBackDefineScreen(PVGASTATE pThis, PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen);
    11891195int vmsvga3dBackDestroyScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen);
    11901196

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-ogl.cpp

    r84914 r85368  
    34683468
    34693469/* Send a notification to the UI. */
     3470#if 0 /* Unused */
    34703471static int vmsvga3dDrvNotifyHwScreen(PVGASTATECC pThisCC, VBOX3D_NOTIFY_TYPE enmNotification,
    34713472                                     uint32_t idScreen, Pixmap pixmap, void *pvData, size_t cbData)
    34723473{
    3473 #if 0
    3474     /* Emulates no support from frontend. */
    3475     RT_NOREF(pThisCC, enmNotification, idScreen, pixmap, pvData, cbData);
    3476     return VERR_NOT_SUPPORTED;
    3477 #else
    34783474    uint8_t au8Buffer[128];
    34793475    AssertLogRelMsgReturn(cbData <= sizeof(au8Buffer) - sizeof(VBOX3DNOTIFY),
    … …  
    34933489    int rc = pThisCC->pDrv->pfn3DNotifyProcess(pThisCC->pDrv, p);
    34943490    return rc;
    3495 #endif
     3491}
     3492#endif /* Unused */
     3493
     3494static void vmsvga3dDrvNotifyHwOverlay(PVGASTATECC pThisCC, VBOX3D_NOTIFY_TYPE enmNotification, uint32_t idScreen)
     3495{
     3496    uint8_t au8Buffer[128];
     3497    VBOX3DNOTIFY *p = (VBOX3DNOTIFY *)&au8Buffer[0];
     3498    p->enmNotification = enmNotification;
     3499    p->iDisplay = idScreen;
     3500    p->u32Reserved = 0;
     3501    p->cbData = sizeof(uint64_t);
     3502    *(uint64_t *)&p->au8Data[0] = 0;
     3503
     3504    pThisCC->pDrv->pfn3DNotifyProcess(pThisCC->pDrv, p);
     3505}
     3506
     3507/* Get X Window handle of the UI Framebuffer window. */
     3508static int vmsvga3dDrvQueryWindow(PVGASTATECC pThisCC, uint32_t idScreen, Window *pWindow)
     3509{
     3510    uint8_t au8Buffer[128];
     3511    VBOX3DNOTIFY *p = (VBOX3DNOTIFY *)&au8Buffer[0];
     3512    p->enmNotification = VBOX3D_NOTIFY_TYPE_HW_OVERLAY_GET_ID;
     3513    p->iDisplay = idScreen;
     3514    p->u32Reserved = 0;
     3515    p->cbData = sizeof(uint64_t);
     3516    *(uint64_t *)&p->au8Data[0] = 0;
     3517
     3518    int rc = pThisCC->pDrv->pfn3DNotifyProcess(pThisCC->pDrv, p);
     3519    if (RT_SUCCESS(rc))
     3520    {
     3521        *pWindow = (Window)*(uint64_t *)&p->au8Data[0];
     3522    }
     3523    return rc;
    34963524}
    34973525
    … …  
    35033531}
    35043532
    3505 /* Create a GLX pixmap as a HW accelerated screen. */
    3506 static int vmsvga3dHwScreenCreate(PVMSVGA3DSTATE pState, unsigned int cWidth, unsigned int cHeight, VMSVGAHWSCREEN *p)
     3533/* Create an overlay X window for the HW accelerated screen. */
     3534static int vmsvga3dHwScreenCreate(PVMSVGA3DSTATE pState, Window parentWindow, unsigned int cWidth, unsigned int cHeight, VMSVGAHWSCREEN *p)
    35073535{
    35083536    int (*oldHandler)(Display*, XErrorEvent*) = XSetErrorHandler(&ctxErrorHandler);
    … …  
    35103538    int rc = VINF_SUCCESS;
    35113539
     3540    XWindowAttributes parentAttr;
     3541    if (XGetWindowAttributes(pState->display, parentWindow, &parentAttr) == 0)
     3542        return VERR_INVALID_PARAMETER;
     3543
     3544    int const idxParentScreen = XScreenNumberOfScreen(parentAttr.screen);
     3545
    35123546    /*
    3513      * Create a new GL context, which will be used for copying to the screen pixmap.
     3547     * Create a new GL context, which will be used for copying to the screen.
    35143548     */
    35153549
    3516     /* FBConfig attributes.
    3517      * Using TEXTURE_2D because Intel Mesa driver does not seem to support TEXTURE_RECTANGLE for GLX pixmaps.
    3518      */
     3550    /* FBConfig attributes for the overlay window. */
    35193551    static int const aConfigAttribList[] =
    35203552    {
    3521         // GLX_RENDER_TYPE,                 GLX_RGBA_BIT,
    3522         // GLX_X_VISUAL_TYPE,               GLX_TRUE_COLOR,
    3523         // GLX_X_RENDERABLE,                True,                   // Render to GLX pixmaps
    3524         GLX_DRAWABLE_TYPE,               GLX_PIXMAP_BIT,         // Must support GLX pixmaps
    3525         GLX_BIND_TO_TEXTURE_RGBA_EXT,    True,                   // Must support GLX_EXT_texture_from_pixmap
    3526         GLX_BIND_TO_TEXTURE_TARGETS_EXT, GLX_TEXTURE_2D_BIT_EXT, // Must support GL_TEXTURE_2D for the frontend code
    3527         GLX_DOUBLEBUFFER,                False,                  // No need for double buffering for a pixmap.
     3553        GLX_DRAWABLE_TYPE,               GLX_WINDOW_BIT,         // Must support GLX windows
     3554        GLX_DOUBLEBUFFER,                False,                  // Double buffering had a much lower performance.
    35283555        GLX_RED_SIZE,                    8,                      // True color RGB with 8 bits per channel.
    35293556        GLX_GREEN_SIZE,                  8,
    … …  
    35323559        GLX_STENCIL_SIZE,                0,                      // No stencil buffer
    35333560        GLX_DEPTH_SIZE,                  0,                      // No depth buffer
    3534         GLX_CONFIG_CAVEAT,               GLX_NONE,
    35353561        None
    35363562    };
    … …  
    35383564    /* Find a suitable FB config. */
    35393565    int cConfigs = 0;
    3540     GLXFBConfig *paConfigs = glXChooseFBConfig(pState->display, 0, aConfigAttribList, &cConfigs);
     3566    GLXFBConfig *paConfigs = glXChooseFBConfig(pState->display, idxParentScreen, aConfigAttribList, &cConfigs);
    35413567    LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: paConfigs %p cConfigs %d\n", (void *)paConfigs, cConfigs));
    35423568    if (paConfigs)
    … …  
    35583584                     vi->red_mask, vi->green_mask, vi->blue_mask, vi->colormap_size, vi->bits_per_rgb));
    35593585
     3586            /* Same screen as the parent window. */
     3587            if (vi->screen != idxParentScreen)
     3588                continue;
     3589
    35603590            /* Search for 32 bits per pixel. */
    35613591            if (vi->depth != 32)
    … …  
    35693599            int value = 0;
    35703600            glXGetFBConfigAttrib(pState->display, paConfigs[i], GLX_DRAWABLE_TYPE, &value);
    3571             if (!(value & GLX_PIXMAP_BIT))
     3601            if (!(value & GLX_WINDOW_BIT))
    35723602                continue;
    35733603
    3574             /* Pixmap will be used as TEXTURE_2D. */
    3575             glXGetFBConfigAttrib(pState->display, paConfigs[i], GLX_BIND_TO_TEXTURE_TARGETS_EXT, &value);
    3576             if (!(value & GLX_TEXTURE_2D_BIT_EXT))
    3577                 continue;
    3578 
    3579             /* Need to bind to a texture using GLX_EXT_texture_from_pixmap. */
    3580             glXGetFBConfigAttrib(pState->display, paConfigs[i], GLX_BIND_TO_TEXTURE_RGBA_EXT, &value);
    3581             if (value == 0)
     3604            /* This FB config can be used. */
     3605            break;
     3606        }
     3607
     3608        if (i < cConfigs)
     3609        {
     3610            /* Found a suitable config with index i. */
     3611
     3612            /* Create an overlay window. */
     3613            XSetWindowAttributes swa;
     3614            RT_ZERO(swa);
     3615
     3616            swa.colormap = XCreateColormap(pState->display, parentWindow, vi->visual, AllocNone);
     3617            AssertLogRelMsg(swa.colormap, ("XCreateColormap failed"));
     3618            swa.border_pixel = 0;
     3619            swa.background_pixel = 0;
     3620            swa.event_mask = StructureNotifyMask;
     3621            swa.override_redirect = 1;
     3622            unsigned long const swaAttrs = CWBorderPixel | CWBackPixel | CWColormap | CWEventMask | CWOverrideRedirect;
     3623            p->xwindow = XCreateWindow(pState->display, parentWindow,
     3624                                       0, 0, cWidth, cHeight, 0, vi->depth, InputOutput,
     3625                                       vi->visual, swaAttrs, &swa);
     3626            LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: p->xwindow %ld\n", p->xwindow));
     3627            if (p->xwindow)
    35823628            {
    3583                 glXGetFBConfigAttrib(pState->display, paConfigs[i], GLX_BIND_TO_TEXTURE_RGB_EXT, &value);
    3584                 if (value == 0)
    3585                     continue;
     3629
     3630                p->glxctx = glXCreateContext(pState->display, vi, pState->SharedCtx.glxContext, GL_TRUE);
     3631                LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: p->glxctx %p\n", (void *)p->glxctx));
     3632                if (p->glxctx)
     3633                {
     3634                    XMapWindow(pState->display, p->xwindow);
     3635                }
     3636                else
     3637                {
     3638                    LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: glXCreateContext failed\n"));
     3639                    rc = VERR_NOT_SUPPORTED;
     3640                }
    35863641            }
    3587 
    3588             glXGetFBConfigAttrib(pState->display, paConfigs[i], GLX_Y_INVERTED_EXT, &value);
    3589             p->fYInverted = (value == 1);
    3590 
    3591             glXGetFBConfigAttrib(pState->display, paConfigs[i], GLX_BIND_TO_MIPMAP_TEXTURE_EXT, &value);
    3592             p->fMipmap = (value > 0);
    3593 
    3594             /* This FB config can be used. */
    3595             break;
    3596         }
    3597 
    3598         if (i < cConfigs)
    3599         {
    3600             /* Found a suitable config with index i. */
    3601             p->visualid = vi->visualid;
    3602 
    3603             Window const rootWindow = RootWindow(pState->display, vi->screen);
    3604             p->pixmap = XCreatePixmap(pState->display, rootWindow, cWidth, cHeight, vi->depth);
    3605             LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: p->pixmap %ld\n", p->pixmap));
    3606 
    3607             static int const aPixmapAttribList[] =
     3642            else
    36083643            {
    3609                 GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
    3610                 GLX_TEXTURE_FORMAT_EXT, GLX_TEXTURE_FORMAT_RGBA_EXT,
    3611                 GLX_MIPMAP_TEXTURE_EXT, p->fMipmap,
    3612                 None
    3613             };
    3614             p->glxpixmap = glXCreatePixmap(pState->display, paConfigs[i], p->pixmap, aPixmapAttribList);
    3615             LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: p->glxpixmap %ld\n", p->glxpixmap));
    3616 
    3617             p->glxctx = glXCreateContext(pState->display, vi, pState->SharedCtx.glxContext, GL_TRUE);
    3618             LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: p->glxctx %p\n", (void *)p->glxctx));
     3644                LogRel4(("VMSVGA: vmsvga3dHwScreenCreate: XCreateWindow failed\n"));
     3645                rc = VERR_NOT_SUPPORTED;
     3646            }
    36193647
    36203648            XSync(pState->display, False);
    … …  
    36483676    if (p)
    36493677    {
    3650         LogRel4(("VMSVGA: vmsvga3dHwScreenDestroy: p->glxpixmap %ld, ctx %p\n", p->glxpixmap, (void *)p->glxctx));
     3678        LogRel4(("VMSVGA: vmsvga3dHwScreenDestroy: p->xwindow %ld, ctx %p\n", p->xwindow, (void *)p->glxctx));
    36513679        if (p->glxctx)
    36523680        {
    36533681            /* GLX context is changed here, so other code has to set the appropriate context again. */
    36543682            VMSVGA3D_CLEAR_CURRENT_CONTEXT(pState);
     3683
     3684            glXMakeCurrent(pState->display, p->xwindow, p->glxctx);
     3685
     3686            /* Clean up OpenGL. */
     3687            if (p->idReadFramebuffer != OPENGL_INVALID_ID)
     3688                pState->ext.glDeleteFramebuffers(1, &p->idReadFramebuffer);
     3689            if (p->idDrawFramebuffer != OPENGL_INVALID_ID)
     3690                pState->ext.glDeleteFramebuffers(1, &p->idDrawFramebuffer);
     3691            if (p->idScreenTexture != OPENGL_INVALID_ID)
     3692                glDeleteTextures(1, &p->idScreenTexture);
     3693
    36553694            glXMakeCurrent(pState->display, None, NULL);
     3695
    36563696            glXDestroyContext(pState->display, p->glxctx);
    36573697        }
    36583698
    3659         if (p->glxpixmap)
    3660             glXDestroyPixmap(pState->display, p->glxpixmap);
    3661 
    3662         if (p->pixmap)
    3663             XFreePixmap(pState->display, p->pixmap);
     3699        if (p->xwindow)
     3700            XDestroyWindow(pState->display, p->xwindow);
    36643701
    36653702        RT_ZERO(*p);
    … …  
    36733710    } while(0)
    36743711
    3675 int vmsvga3dBackDefineScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
     3712int vmsvga3dBackDefineScreen(PVGASTATE pThis, PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
    36763713{
    36773714    LogRel4(("VMSVGA: vmsvga3dBackDefineScreen: screen %u\n", pScreen->idScreen));
    … …  
    36803717    AssertReturn(pState, VERR_NOT_SUPPORTED);
    36813718
     3719    if (!pThis->svga.f3DOverlayEnabled)
     3720        return VERR_NOT_SUPPORTED;
     3721
    36823722    Assert(pScreen->pHwScreen == NULL);
    36833723
    … …  
    36853725    AssertPtrReturn(p, VERR_NO_MEMORY);
    36863726
    3687     int rc = vmsvga3dHwScreenCreate(pState, pScreen->cWidth, pScreen->cHeight, p);
     3727    /* Query the parent window ID from the UI framebuffer.
     3728     * If it is there then
     3729     *    the device will create a texture for the screen content and an overlay window to present the screen content.
     3730     * otherwise
     3731     *    the device will use the guest VRAM system memory for the screen content.
     3732     */
     3733    Window parentWindow;
     3734    int rc = vmsvga3dDrvQueryWindow(pThisCC, pScreen->idScreen, &parentWindow);
    36883735    if (RT_SUCCESS(rc))
    36893736    {
    3690         /*
    3691          * Setup the OpenGL context of the screen.
    3692          */
    3693 
    3694         /* GLX context is changed here, so other code has to set the appropriate context again. */
    3695         VMSVGA3D_CLEAR_CURRENT_CONTEXT(pState);
    3696 
    3697         Bool const fSuccess = glXMakeCurrent(pState->display, p->glxpixmap, p->glxctx);
    3698         if (fSuccess)
    3699         {
    3700             /* Work in screen coordinates. */
    3701             glMatrixMode(GL_MODELVIEW);
    3702             glLoadIdentity();
    3703             glOrtho(0, pScreen->cWidth, 0, pScreen->cHeight, -1, 1);
    3704             glMatrixMode(GL_PROJECTION);
    3705             glLoadIdentity();
    3706 
    3707             /* Set GL state. */
    3708             glClearColor(0, 0, 0, 1);
    3709             glEnable(GL_TEXTURE_2D);
    3710             glDisable(GL_DEPTH_TEST);
    3711             glDisable(GL_CULL_FACE);
    3712 
    3713             /* Clear the pixmap. */
    3714             glClear(GL_COLOR_BUFFER_BIT);
    3715             glFinish();
    3716 
    3717             glXMakeCurrent(pState->display, None, NULL);
    3718 
    3719             rc = vmsvga3dDrvNotifyHwScreen(pThisCC, VBOX3D_NOTIFY_TYPE_HW_SCREEN_CREATED,
    3720                                            pScreen->idScreen, p->pixmap, &p->visualid, sizeof(p->visualid));
    3721         }
    3722         else
    3723         {
    3724             LogRel4(("VMSVGA: vmsvga3dBackDefineScreen: failed to set current context\n"));
    3725             rc = VERR_NOT_SUPPORTED;
    3726         }
     3737        /* Create the hardware accelerated screen. */
     3738        rc = vmsvga3dHwScreenCreate(pState, parentWindow, pScreen->cWidth, pScreen->cHeight, p);
     3739        if (RT_SUCCESS(rc))
     3740        {
     3741            /*
     3742             * Setup the OpenGL context of the screen. The context will be used to draw on the screen.
     3743             */
     3744
     3745            /* GLX context is changed here, so other code has to set the appropriate context again. */
     3746            VMSVGA3D_CLEAR_CURRENT_CONTEXT(pState);
     3747
     3748            Bool const fSuccess = glXMakeCurrent(pState->display, p->xwindow, p->glxctx);
     3749            if (fSuccess)
     3750            {
     3751                /* Set GL state. */
     3752                glClearColor(0, 0, 0, 1);
     3753                glEnable(GL_TEXTURE_2D);
     3754                glDisable(GL_DEPTH_TEST);
     3755                glDisable(GL_CULL_FACE);
     3756
     3757                /* The RGBA texture which hold the screen content. */
     3758                glGenTextures(1, &p->idScreenTexture); GLCHECK();
     3759                glBindTexture(GL_TEXTURE_2D, p->idScreenTexture); GLCHECK();
     3760                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); GLCHECK();
     3761                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); GLCHECK();
     3762                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, pScreen->cWidth, pScreen->cHeight, 0,
     3763                             GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL); GLCHECK();
     3764
     3765                /* Create read and draw framebuffer objects for this screen. */
     3766                pState->ext.glGenFramebuffers(1, &p->idReadFramebuffer); GLCHECK();
     3767                pState->ext.glGenFramebuffers(1, &p->idDrawFramebuffer); GLCHECK();
     3768
     3769                /* Work in screen coordinates. */
     3770                glMatrixMode(GL_MODELVIEW);
     3771                glLoadIdentity();
     3772                glOrtho(0, pScreen->cWidth, 0, pScreen->cHeight, -1, 1);
     3773                glMatrixMode(GL_PROJECTION);
     3774                glLoadIdentity();
     3775
     3776                /* Clear the texture. */
     3777                pState->ext.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, p->idDrawFramebuffer); GLCHECK();
     3778                pState->ext.glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
     3779                                                   p->idScreenTexture, 0); GLCHECK();
     3780
     3781                glClear(GL_COLOR_BUFFER_BIT);
     3782
     3783                pState->ext.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); GLCHECK();
     3784
     3785                glXMakeCurrent(pState->display, None, NULL);
     3786
     3787                XSync(pState->display, False);
     3788
     3789                vmsvga3dDrvNotifyHwOverlay(pThisCC, VBOX3D_NOTIFY_TYPE_HW_OVERLAY_CREATED, pScreen->idScreen);
     3790            }
     3791            else
     3792            {
     3793                LogRel4(("VMSVGA: vmsvga3dBackDefineScreen: failed to set current context\n"));
     3794                rc = VERR_NOT_SUPPORTED;
     3795            }
     3796        }
     3797    }
     3798    else
     3799    {
     3800        LogRel4(("VMSVGA: vmsvga3dBackDefineScreen: no framebuffer\n"));
    37273801    }
    37283802
    37293803    if (RT_SUCCESS(rc))
    37303804    {
     3805        LogRel(("VMSVGA: Using HW accelerated screen %u\n", pScreen->idScreen));
    37313806        pScreen->pHwScreen = p;
    37323807    }
    … …  
    37553830        pScreen->pHwScreen = NULL;
    37563831
    3757         vmsvga3dDrvNotifyHwScreen(pThisCC, VBOX3D_NOTIFY_TYPE_HW_SCREEN_DESTROYED,
    3758                                   pScreen->idScreen, p->pixmap, NULL, 0);
     3832        vmsvga3dDrvNotifyHwOverlay(pThisCC, VBOX3D_NOTIFY_TYPE_HW_OVERLAY_DESTROYED, pScreen->idScreen);
    37593833
    37603834        vmsvga3dHwScreenDestroy(pState, p);
    … …  
    37963870
    37973871    /** @todo Implement. */
    3798     RT_NOREF(destRect, cRects, paRects);
     3872    RT_NOREF(cRects, paRects);
    37993873
    38003874    /* GLX context is changed here, so other code has to set appropriate context again. */
    … …  
    38033877    int (*oldHandler)(Display*, XErrorEvent*) = XSetErrorHandler(&ctxErrorHandler);
    38043878
    3805     vmsvga3dDrvNotifyHwScreen(pThisCC, VBOX3D_NOTIFY_TYPE_HW_SCREEN_UPDATE_BEGIN, pScreen->idScreen, p->pixmap, NULL, 0);
    3806 
    3807     GLint const w = pScreen->cWidth;
    3808     GLint const h = pScreen->cHeight;
    3809 
    3810     GLfloat const wSurf = (GLfloat)pMipLevel->mipmapSize.width;
    3811     GLfloat const hSurf = (GLfloat)pMipLevel->mipmapSize.height;
    3812     GLfloat const x1 = (GLfloat)srcRect.left / wSurf;
    3813     GLfloat const y1 = (GLfloat)srcRect.top / hSurf;
    3814     GLfloat const x2 = (GLfloat)srcRect.right / wSurf;
    3815     GLfloat const y2 = (GLfloat)srcRect.bottom / hSurf;
    3816 
    3817     //printf("blit to screen src %fx%f %u,%u %u,%u (%f,%f %f,%f) dest %dx%d %u,%u %u,%u\n",
    3818     //       wSurf, hSurf, srcRect.left, srcRect.top, srcRect.right, srcRect.bottom, x1, y1, x2, y2,
    3819     //       w, h, destRect.left, destRect.top, destRect.right, destRect.bottom);
    3820 
    3821     Bool fSuccess = glXMakeCurrent(pState->display, p->glxpixmap, p->glxctx);
     3879    Bool fSuccess = glXMakeCurrent(pState->display, p->xwindow, p->glxctx);
    38223880    if (fSuccess)
    38233881    {
     3882        /* Activate the read and draw framebuffer objects. */
     3883        pState->ext.glBindFramebuffer(GL_READ_FRAMEBUFFER, p->idReadFramebuffer); GLCHECK();
     3884        pState->ext.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, p->idDrawFramebuffer); GLCHECK();
     3885
     3886        /* Bind the source and destination objects to the right place. */
     3887        pState->ext.glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
     3888                                           pSurface->oglId.texture, 0); GLCHECK();
     3889        pState->ext.glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
     3890                                           p->idScreenTexture, 0); GLCHECK();
     3891
     3892        pState->ext.glBlitFramebuffer(srcRect.left,
     3893                                      srcRect.top,
     3894                                      srcRect.right,
     3895                                      srcRect.bottom,
     3896                                      destRect.left,
     3897                                      destRect.top,
     3898                                      destRect.right,
     3899                                      destRect.bottom,
     3900                                      GL_COLOR_BUFFER_BIT,
     3901                                      GL_NEAREST); GLCHECK();
     3902
     3903        /* Reset the frame buffer association */
     3904        pState->ext.glBindFramebuffer(GL_FRAMEBUFFER, 0); GLCHECK();
     3905
     3906        /* Update the overlay window. */
    38243907        glClear(GL_COLOR_BUFFER_BIT);
    38253908
    3826         glBindTexture(GL_TEXTURE_2D, pSurface->oglId.texture); GLCHECK();
     3909        glBindTexture(GL_TEXTURE_2D, p->idScreenTexture); GLCHECK();
     3910
     3911        GLint const w = pScreen->cWidth;
     3912        GLint const h = pScreen->cHeight;
    38273913
    38283914        glBegin(GL_QUADS);
    3829         /** @todo Y inversion. */
    3830         glTexCoord2f(x1, y1); glVertex2i(0, h);
    3831         glTexCoord2f(x1, y2); glVertex2i(0, 0);
    3832         glTexCoord2f(x2, y2); glVertex2i(w, 0);
    3833         glTexCoord2f(x2, y1); glVertex2i(w, h);
     3915        glTexCoord2f(0.0f, 0.0f); glVertex2i(0, h);
     3916        glTexCoord2f(0.0f, 1.0f); glVertex2i(0, 0);
     3917        glTexCoord2f(1.0f, 1.0f); glVertex2i(w, 0);
     3918        glTexCoord2f(1.0f, 0.0f); glVertex2i(w, h);
    38343919        glEnd(); GLCHECK();
    38353920
    38363921        glBindTexture(GL_TEXTURE_2D, 0); GLCHECK();
    38373922
    3838         glFinish(); GLCHECK();
    3839 
    38403923        glXMakeCurrent(pState->display, None, NULL);
    3841 
    3842         vmsvga3dDrvNotifyHwScreen(pThisCC, VBOX3D_NOTIFY_TYPE_HW_SCREEN_UPDATE_END,
    3843                                   pScreen->idScreen, p->pixmap, &destRect, sizeof(destRect));
     3924    }
     3925    else
     3926    {
     3927        LogRel4(("VMSVGA: vmsvga3dBackSurfaceBlitToScreen: screen %u, glXMakeCurrent for pixmap failed\n", pScreen->idScreen));
    38443928    }
    38453929
    … …  
    38513935#else /* !RT_OS_LINUX */
    38523936
    3853 int vmsvga3dBackDefineScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
     3937int vmsvga3dBackDefineScreen(PVGASTATE pThis, PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
    38543938{
    38553939    RT_NOREF(pThisCC, pScreen);

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-win.cpp

    r85156 r85368  
    28162816}
    28172817
    2818 int vmsvga3dBackDefineScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
     2818int vmsvga3dBackDefineScreen(PVGASTATE pThis, PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
    28192819{
    28202820    RT_NOREF(pThisCC, pScreen);

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d.cpp

    r84747 r85368  
    980980}
    981981
    982 int vmsvga3dDefineScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
     982int vmsvga3dDefineScreen(PVGASTATE pThis, PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
    983983{
    984984    if (pScreen->pHwScreen)
    … …  
    987987    }
    988988
    989     int rc = vmsvga3dBackDefineScreen(pThisCC, pScreen);
     989    int rc = vmsvga3dBackDefineScreen(pThis, pThisCC, pScreen);
    990990    if (RT_SUCCESS(rc))
    991991    {

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d.h

    r85121 r85368  
    8282int vmsvga3dChangeMode(PVGASTATECC pThisCC);
    8383
    84 int vmsvga3dDefineScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen);
     84int vmsvga3dDefineScreen(PVGASTATE pThis, PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen);
    8585int vmsvga3dDestroyScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen);
    8686

  • trunk/src/VBox/Devices/Graphics/DevVGA.cpp

    r84834 r85368  
    64766476# ifdef VBOX_WITH_VMSVGA3D
    64776477                                            "|VMSVGA3dEnabled"
     6478                                            "|VMSVGA3dOverlayEnabled"
    64786479# endif
    64796480                                            "|SuppressNewYearSplash"
    … …  
    65316532    AssertLogRelRCReturn(rc, rc);
    65326533    Log(("VMSVGA: VMSVGA3dEnabled = %d\n", pThis->svga.f3DEnabled));
     6534
     6535    rc = pHlp->pfnCFGMQueryBoolDef(pCfg, "VMSVGA3dOverlayEnabled", &pThis->svga.f3DOverlayEnabled, false);
     6536    AssertLogRelRCReturn(rc, rc);
     6537    Log(("VMSVGA: VMSVGA3dOverlayEnabled = %d\n", pThis->svga.f3DOverlayEnabled));
    65336538# endif
    65346539
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette