VirtualBox

Changeset 54765 in vbox


Ignore:
Timestamp:
Mar 15, 2015 5:15:57 PM (10 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
98943
Message:

VMSVGA3d: Applied patches from trivirt that among other things makes Chrome work on OpenGL hosts.

Location:
trunk/src/VBox/Devices
Files:
8 edited

Legend:

Unmodified
Added
Removed

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

    r54736 r54765  
    2020*   Header Files                                                               *
    2121*******************************************************************************/
     22/* Enable to disassemble defined shaders. (Windows host only) */
     23#if defined(RT_OS_WINDOWS) && defined(DEBUG)
     24# define DUMP_SHADER_DISASSEMBLY
     25#endif
    2226#ifdef DEBUG_bird
    2327# define RTMEM_WRAP_TO_EF_APIS
    … …  
    8185# include <GL/glext.h>
    8286# define VBOX_VMSVGA3D_GL_HACK_LEVEL 0x103
     87#endif
     88#ifdef DUMP_SHADER_DISASSEMBLY
     89# include <d3dx9shader.h>
    8390#endif
    8491#include "vmsvga_glext/glext.h"
    … …  
    14861493
    14871494
    1488     if (vmsvga3dCheckGLExtension(pState, 3.0, " GL_ARB_framebuffer_object "))
     1495    if (vmsvga3dCheckGLExtension(pState, 3.0f, " GL_ARB_framebuffer_object "))
    14891496    {
    14901497        pState->ext.glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)OGLGETPROCADDRESS("glIsRenderbuffer");
    … …  
    15741581#if defined(RT_OS_DARWIN)
    15751582    /** @todo OpenGL version history suggest this, verify...  */
    1576     pState->ext.fEXT_stencil_two_side = vmsvga3dCheckGLExtension(pState, 2.0, " GL_EXT_stencil_two_side ");
     1583    pState->ext.fEXT_stencil_two_side = vmsvga3dCheckGLExtension(pState, 2.0f, " GL_EXT_stencil_two_side ");
    15771584#else
    1578     pState->ext.fEXT_stencil_two_side = vmsvga3dCheckGLExtension(pState, 0.0, " GL_EXT_stencil_two_side ");
     1585    pState->ext.fEXT_stencil_two_side = vmsvga3dCheckGLExtension(pState, 0.0f, " GL_EXT_stencil_two_side ");
    15791586#endif
    15801587
    … …  
    16291636                                                                 &pState->caps.maxVertexShaderInstructions));
    16301637    }
    1631     pState->caps.fS3TCSupported = vmsvga3dCheckGLExtension(pState, 0.0, " GL_EXT_texture_compression_s3tc ");
     1638    pState->caps.fS3TCSupported = vmsvga3dCheckGLExtension(pState, 0.0f, " GL_EXT_texture_compression_s3tc ");
    16321639
    16331640    /* http://http://www.opengl.org/wiki/Detecting_the_Shader_Model
    … …  
    16411648     */
    16421649    /** @todo: distinguish between vertex and pixel shaders??? */
    1643     if (   vmsvga3dCheckGLExtension(pState, 0.0, " GL_NV_gpu_program4 ")
     1650    if (   vmsvga3dCheckGLExtension(pState, 0.0f, " GL_NV_gpu_program4 ")
    16441651        || strstr(pState->pszOtherExtensions, " GL_NV_gpu_program4 "))
    16451652    {
    … …  
    16481655    }
    16491656    else
    1650     if (   vmsvga3dCheckGLExtension(pState, 0.0, " GL_NV_vertex_program3 ")
     1657    if (   vmsvga3dCheckGLExtension(pState, 0.0f, " GL_NV_vertex_program3 ")
    16511658        || strstr(pState->pszOtherExtensions, " GL_NV_vertex_program3 ")
    1652         || vmsvga3dCheckGLExtension(pState, 0.0, " GL_ARB_shader_texture_lod ")  /* Wine claims this suggests SM 3.0 support */
     1659        || vmsvga3dCheckGLExtension(pState, 0.0f, " GL_ARB_shader_texture_lod ")  /* Wine claims this suggests SM 3.0 support */
    16531660        || strstr(pState->pszOtherExtensions, " GL_ARB_shader_texture_lod ")
    16541661        )
    … …  
    16581665    }
    16591666    else
    1660     if (   vmsvga3dCheckGLExtension(pState, 0.0, " GL_ARB_fragment_program ")
     1667    if (   vmsvga3dCheckGLExtension(pState, 0.0f, " GL_ARB_fragment_program ")
    16611668        || strstr(pState->pszOtherExtensions, " GL_ARB_fragment_program "))
    16621669    {
    … …  
    33903397
    33913398    if (pSurface->flags & SVGA3D_SURFACE_HINT_TEXTURE)
    3392         Log(("vmsvga3dSurfaceDMA TEXTURE guestptr gmr=%x offset=%x pitch=%x host sid=%x face=%d mipmap=%d transfer=%x cCopyBoxes=%d\n", guest.ptr.gmrId, guest.ptr.offset, guest.pitch, host.sid, host.face, host.mipmap, transfer, cCopyBoxes));
     3399        Log(("vmsvga3dSurfaceDMA TEXTURE guestptr gmr=%x offset=%x pitch=%x host sid=%x face=%d mipmap=%d transfer=%s cCopyBoxes=%d\n", guest.ptr.gmrId, guest.ptr.offset, guest.pitch, host.sid, host.face, host.mipmap, (transfer == SVGA3D_WRITE_HOST_VRAM) ? "READ" : "WRITE", cCopyBoxes));
    33933400    else
    3394         Log(("vmsvga3dSurfaceDMA guestptr gmr=%x offset=%x pitch=%x host sid=%x face=%d mipmap=%d transfer=%x cCopyBoxes=%d\n", guest.ptr.gmrId, guest.ptr.offset, guest.pitch, host.sid, host.face, host.mipmap, transfer, cCopyBoxes));
     3401        Log(("vmsvga3dSurfaceDMA guestptr gmr=%x offset=%x pitch=%x host sid=%x face=%d mipmap=%d transfer=%s cCopyBoxes=%d\n", guest.ptr.gmrId, guest.ptr.offset, guest.pitch, host.sid, host.face, host.mipmap, (transfer == SVGA3D_WRITE_HOST_VRAM) ? "READ" : "WRITE", cCopyBoxes));
    33953402
    33963403    if (pSurface->oglId.texture == OPENGL_INVALID_ID)
    … …  
    45954602        }
    45964603#ifdef RT_OS_WINDOWS
    4597         wglMakeCurrent(NULL, NULL);
     4604        wglMakeCurrent(pContext->hdc, NULL);
    45984605        wglDeleteContext(pContext->hglrc);
    45994606        ReleaseDC(pContext->hwnd, pContext->hdc);
    … …  
    49304937    {
    49314938        GLenum enableCap = ~0U;
    4932         Log(("vmsvga3dSetRenderState: cid=%d state=%s (%d) val=%x\n", cid, vmsvga3dGetRenderStateName(pRenderState[i].state), pRenderState[i].state, pRenderState[i].uintValue));
     4939        Log(("vmsvga3dSetRenderState: cid=%x state=%s (%d) val=%x\n", cid, vmsvga3dGetRenderStateName(pRenderState[i].state), pRenderState[i].state, pRenderState[i].uintValue));
    49334940        /* Save the render state for vm state saving. */
    49344941        if (pRenderState[i].state < SVGA3D_RS_MAX)
    … …  
    62216228
    62226229        case SVGA3D_TS_MIPFILTER:                   /* SVGA3dTextureFilter */
    6223             //AssertFailed(); /* @todo */
    6224             //samplerType = D3DSAMP_MIPFILTER;
    6225             val = vmsvga3dTextureFilter2OGL((SVGA3dTextureFilter)pTextureState[i].value);
    6226             break;
     6230        case SVGA3D_TS_MINFILTER:                   /* SVGA3dTextureFilter */
     6231        {
     6232            uint32_t mipFilter = pContext->state.aTextureState[currentStage][SVGA3D_TS_MIPFILTER].value;
     6233            uint32_t minFilter = pContext->state.aTextureState[currentStage][SVGA3D_TS_MINFILTER].value;
     6234
     6235            /* If SVGA3D_TS_MIPFILTER is set to NONE, then use SVGA3D_TS_MIPFILTER, otherwise SVGA3D_TS_MIPFILTER enables mipmap minification. */
     6236            textureType = GL_TEXTURE_MIN_FILTER;
     6237            if (mipFilter != SVGA3D_TEX_FILTER_NONE)
     6238            {
     6239                if (minFilter == SVGA3D_TEX_FILTER_NEAREST)
     6240                {
     6241                    if (mipFilter == SVGA3D_TEX_FILTER_LINEAR)
     6242                        val = GL_NEAREST_MIPMAP_LINEAR;
     6243                    else
     6244                        val = GL_NEAREST_MIPMAP_NEAREST;
     6245                }
     6246                else
     6247                {
     6248                    if (mipFilter == SVGA3D_TEX_FILTER_LINEAR)
     6249                        val = GL_LINEAR_MIPMAP_LINEAR;
     6250                    else
     6251                        val = GL_LINEAR_MIPMAP_NEAREST;
     6252                }
     6253            }
     6254            else
     6255                val = vmsvga3dTextureFilter2OGL((SVGA3dTextureFilter)minFilter);
     6256
     6257            break;
     6258        }
    62276259
    62286260        case SVGA3D_TS_MAGFILTER:                   /* SVGA3dTextureFilter */
    … …  
    62326264            break;
    62336265
    6234         case SVGA3D_TS_MINFILTER:                   /* SVGA3dTextureFilter */
    6235             textureType = GL_TEXTURE_MIN_FILTER;
    6236             val = vmsvga3dTextureFilter2OGL((SVGA3dTextureFilter)pTextureState[i].value);
    6237             break;
    6238 
    62396266        case SVGA3D_TS_BORDERCOLOR:                 /* SVGA3dColor */
    62406267        {
    … …  
    62546281
    62556282        case SVGA3D_TS_TEXTURE_MIPMAP_LEVEL:        /* uint32_t */
    6256             textureType = GL_TEXTURE_MAX_LEVEL;
    6257             val = pTextureState[i].value;   /* Identical?? */
     6283            textureType = GL_TEXTURE_BASE_LEVEL;
     6284            val = pTextureState[i].value;
    62586285            break;
    62596286
    … …  
    74397466    memcpy(pShader->pShaderProgram, pShaderData, cbData);
    74407467
     7468#ifdef DUMP_SHADER_DISASSEMBLY
     7469    LPD3DXBUFFER pDisassembly;
     7470
     7471    HRESULT hr = D3DXDisassembleShader((const DWORD *)pShaderData, FALSE, NULL, &pDisassembly);
     7472    if (hr == D3D_OK)
     7473    {
     7474        Log(("Shader disassembly:\n%s\n", pDisassembly->GetBufferPointer()));
     7475        pDisassembly->Release();
     7476    }
     7477#endif
     7478
    74417479    switch (type)
    74427480    {
    … …  
    74517489    default:
    74527490        AssertFailedReturn(VERR_INVALID_PARAMETER);
     7491    }
     7492    if (rc != VINF_SUCCESS)
     7493    {
     7494        RTMemFree(pShader->pShaderProgram);
     7495        memset(pShader, 0, sizeof(*pShader));
     7496        pShader->id = SVGA3D_INVALID_ID;
    74537497    }
    74547498

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

    r53624 r54765  
    329329     */
    330330    case SVGA3D_BUFFER:
     331        return 1;
     332
     333    case SVGA3D_NV12:
    331334        return 1;
    332335

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

    r54661 r54765  
    4848
    4949/* Enable to disassemble defined shaders. */
    50 //#define DUMP_SHADER_DISASSEMBLY
     50#ifdef DEBUG
     51#define DUMP_SHADER_DISASSEMBLY
     52#endif
    5153
    5254#ifdef DUMP_SHADER_DISASSEMBLY
    … …  
    23232325
    23242326    if (pSurface->flags & SVGA3D_SURFACE_HINT_TEXTURE)
    2325         Log(("vmsvga3dSurfaceDMA TEXTURE guestptr gmr=%x offset=%x pitch=%x host sid=%x face=%d mipmap=%d transfer=%x cCopyBoxes=%d\n", guest.ptr.gmrId, guest.ptr.offset, guest.pitch, host.sid, host.face, host.mipmap, transfer, cCopyBoxes));
     2327        Log(("vmsvga3dSurfaceDMA TEXTURE guestptr gmr=%x offset=%x pitch=%x host sid=%x face=%d mipmap=%d transfer=%s cCopyBoxes=%d\n", guest.ptr.gmrId, guest.ptr.offset, guest.pitch, host.sid, host.face, host.mipmap, (transfer == SVGA3D_WRITE_HOST_VRAM) ? "READ" : "WRITE", cCopyBoxes));
    23262328    else
    2327         Log(("vmsvga3dSurfaceDMA guestptr gmr=%x offset=%x pitch=%x host sid=%x face=%d mipmap=%d transfer=%x cCopyBoxes=%d\n", guest.ptr.gmrId, guest.ptr.offset, guest.pitch, host.sid, host.face, host.mipmap, transfer, cCopyBoxes));
     2329        Log(("vmsvga3dSurfaceDMA guestptr gmr=%x offset=%x pitch=%x host sid=%x face=%d mipmap=%d transfer=%s cCopyBoxes=%d\n", guest.ptr.gmrId, guest.ptr.offset, guest.pitch, host.sid, host.face, host.mipmap, (transfer == SVGA3D_WRITE_HOST_VRAM) ? "READ" : "WRITE", cCopyBoxes));
    23282330
    23292331    if (!pSurface->u.pSurface)
    … …  
    35773579    AssertReturn(pState, VERR_NO_MEMORY);
    35783580
    3579     Log(("vmsvga3dSetRenderState %x cRenderStates=%d\n", cid, cRenderStates));
     3581    Log(("vmsvga3dSetRenderState cid=%x cRenderStates=%d\n", cid, cRenderStates));
    35803582
    35813583    if (    cid >= pState->cContexts
    … …  
    45434545        if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_VIEWPORT)
    45444546            vmsvga3dSetViewPort(pThis, cid, &pContext->state.RectViewPort);
     4547        /* Changing the render target also resets the scissor rectangle; restore it as well. */
     4548        if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_SCISSORRECT)
     4549            vmsvga3dSetScissorRect(pThis, cid, &pContext->state.RectScissor);
    45454550
    45464551        break;
    … …  
    53075312            AssertMsgReturn(hr == D3D_OK, ("vmsvga3dDrawPrimitives: CreateVertexBuffer failed with %x\n", hr), VERR_INTERNAL_ERROR);
    53085313
     5314            pVertexSurface->idAssociatedContext = pContext->id;
     5315
    53095316            if (pVertexSurface->fDirty)
    53105317            {
    … …  
    57545761    memcpy(pShader->pShaderProgram, pShaderData, cbData);
    57555762
     5763#ifdef DUMP_SHADER_DISASSEMBLY
     5764    LPD3DXBUFFER pDisassembly;
     5765
     5766    hr = D3DXDisassembleShader((const DWORD *)pShaderData, FALSE, NULL, &pDisassembly);
     5767    if (hr == D3D_OK)
     5768    {
     5769        Log(("Shader disassembly:\n%s\n", pDisassembly->GetBufferPointer()));
     5770        pDisassembly->Release();
     5771    }
     5772#endif
    57565773    switch (type)
    57575774    {
    … …  
    57675784        AssertFailedReturn(VERR_INVALID_PARAMETER);
    57685785    }
    5769 #ifdef DUMP_SHADER_DISASSEMBLY
    5770     LPD3DXBUFFER pDisassembly;
    5771 
    5772     hr = D3DXDisassembleShader((const DWORD *)pShaderData, FALSE, NULL, &pDisassembly);
    5773     if (hr == D3D_OK)
    5774     {
    5775         Log(("Shader disassembly:\n%s\n", pDisassembly->GetBufferPointer()));
    5776         pDisassembly->Release();
    5777     }
    5778 #endif
    57795786    if (hr != D3D_OK)
    57805787    {
    … …  
    62936300        LogRel((" - D3DTEXOPCAPS_LERP\n"));
    62946301
     6302
    62956303    LogRel(("\n"));
    62966304    LogRel(("PixelShaderVersion:  %#x (%u.%u)\n", pCaps->PixelShaderVersion,

  • trunk/src/VBox/Devices/Graphics/shaderlib/glsl_shader.c

    r53740 r54765  
    13181318    shader_addline(buffer, "vec4 tmp0;\n");
    13191319    shader_addline(buffer, "vec4 tmp1;\n");
     1320#ifdef VBOX_WITH_VMSVGA
     1321    shader_addline(buffer, "bool p0[4];\n");
     1322#endif
    13201323
    13211324    /* Local constants use a different name so they can be loaded once at shader link time
    … …  
    16301633            break;
    16311634
     1635#ifdef VBOX_WITH_VMSVGA
     1636        case WINED3DSPR_PREDICATE:
     1637            sprintf(register_name, "p0");
     1638            break;
     1639#endif
     1640
    16321641        default:
    16331642            FIXME("Unhandled register name Type(%d)\n", reg->type);
    … …  
    16591668    else
    16601669    {
     1670#ifdef VBOX_WITH_VMSVGA
     1671        if (param->reg.type == WINED3DSPR_PREDICATE)
     1672        {
     1673            *write_mask++ = '[';
     1674            if (mask & WINED3DSP_WRITEMASK_0) *write_mask++ = '0';
     1675            else
     1676            if (mask & WINED3DSP_WRITEMASK_1) *write_mask++ = '1';
     1677            else
     1678            if (mask & WINED3DSP_WRITEMASK_2) *write_mask++ = '2';
     1679            else
     1680            if (mask & WINED3DSP_WRITEMASK_3) *write_mask++ = '3';
     1681            *write_mask++ = ']';
     1682            *write_mask = '\0';
     1683        }
     1684        else
     1685#endif
    16611686        shader_glsl_write_mask_to_str(mask, write_mask);
    16621687    }
    … …  
    21612186}
    21622187
     2188#ifdef VBOX_WITH_VMSVGA
     2189static void shader_glsl_mov_impl(const struct wined3d_shader_instruction *ins, int p0_idx);
     2190
    21632191/* Process the WINED3DSIO_MOV opcode using GLSL (dst = src) */
    21642192static void shader_glsl_mov(const struct wined3d_shader_instruction *ins)
     2193{
     2194    if (ins->predicate)
     2195    {
     2196        int i;
     2197        DWORD dst_mask = ins->dst[0].write_mask;
     2198        struct wined3d_shader_dst_param *dst = (struct wined3d_shader_dst_param *)&ins->dst[0];
     2199
     2200        for (i = 0; i < 4; i++)
     2201        {
     2202            if (dst_mask & RT_BIT(i))
     2203            {
     2204                dst->write_mask = RT_BIT(i);
     2205
     2206                shader_glsl_mov_impl(ins, i);
     2207            }
     2208        }
     2209        dst->write_mask = dst_mask;
     2210    }
     2211    else
     2212        shader_glsl_mov_impl(ins, 0);
     2213}
     2214
     2215/* Process the WINED3DSIO_MOV opcode using GLSL (dst = src) */
     2216static void shader_glsl_mov_impl(const struct wined3d_shader_instruction *ins, int p0_idx)
     2217
     2218#else
     2219/* Process the WINED3DSIO_MOV opcode using GLSL (dst = src) */
     2220static void shader_glsl_mov(const struct wined3d_shader_instruction *ins)
     2221#endif
    21652222{
    21662223    const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
    … …  
    21682225    glsl_src_param_t src0_param;
    21692226    DWORD write_mask;
     2227
     2228#ifdef VBOX_WITH_VMSVGA
     2229    if (ins->predicate)
     2230    {
     2231        shader_addline(buffer, "if (p0[%d]) {\n", p0_idx);
     2232    }
     2233#endif
    21702234
    21712235    write_mask = shader_glsl_append_dst(buffer, ins);
    … …  
    22122276        shader_addline(buffer, "%s);\n", src0_param.param_str);
    22132277    }
     2278#ifdef VBOX_WITH_VMSVGA
     2279    if (ins->predicate)
     2280    {
     2281        shader_addline(buffer, "}\n");
     2282    }
     2283#endif
    22142284}
    22152285
    … …  
    24682538    }
    24692539}
     2540
     2541#ifdef VBOX_WITH_VMSVGA
     2542static void shader_glsl_setp(const struct wined3d_shader_instruction *ins)
     2543{
     2544    struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
     2545    glsl_src_param_t src_param1, src_param2;
     2546    DWORD write_mask;
     2547
     2548    int i;
     2549    DWORD dst_mask = ins->dst[0].write_mask;
     2550    struct wined3d_shader_dst_param dst = ins->dst[0];
     2551
     2552    /* Cycle through all source0 channels */
     2553    for (i=0; i<4; i++) {
     2554        if (dst_mask & RT_BIT(i))
     2555        {
     2556            write_mask = WINED3DSP_WRITEMASK_0 << i;
     2557            dst.write_mask = dst_mask & write_mask;
     2558
     2559            write_mask = shader_glsl_append_dst_ext(ins->ctx->buffer, ins, &dst);
     2560            Assert(write_mask);
     2561
     2562            shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src_param1);
     2563            shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src_param2);
     2564
     2565            shader_addline(buffer, "%s %s %s);\n",
     2566                    src_param1.param_str, shader_get_comp_op(ins->flags), src_param2.param_str);
     2567        }
     2568    }
     2569}
     2570#endif
    24702571
    24712572/** Process signed comparison opcodes in GLSL. */
    … …  
    53145415    /* WINED3DSIH_RET           */ shader_glsl_ret,
    53155416    /* WINED3DSIH_RSQ           */ shader_glsl_rsq,
     5417#ifdef VBOX_WITH_VMSVGA
     5418    /* WINED3DSIH_SETP          */ shader_glsl_setp,
     5419#else
    53165420    /* WINED3DSIH_SETP          */ NULL,
     5421#endif
    53175422    /* WINED3DSIH_SGE           */ shader_glsl_compare,
    53185423    /* WINED3DSIH_SGN           */ shader_glsl_sgn,

  • trunk/src/VBox/Devices/Graphics/shaderlib/shader.c

    r53724 r54765  
    11631163        if (ins.predicate)
    11641164        {
     1165#ifndef VBOX_WITH_VMSVGA
    11651166            FIXME("Predicates not implemented.\n");
     1167#endif
    11661168            ins.predicate = *ptr++;
    11671169        }

  • trunk/src/VBox/Devices/Graphics/shaderlib/shader_sm1.c

    r53201 r54765  
    246246    {WINED3D_SM1_OP_POW,      1, 3, WINED3DSIH_POW,          0,                           0                          },
    247247    {WINED3D_SM1_OP_CRS,      1, 3, WINED3DSIH_CRS,          0,                           0                          },
     248#ifdef VBOX_WITH_VMSVGA /* appears incorrect */
     249    {WINED3D_SM1_OP_SGN,      1, 4, WINED3DSIH_SGN,          0,                           0                          },
     250#else
    248251    {WINED3D_SM1_OP_SGN,      1, 4, WINED3DSIH_SGN,          WINED3D_SHADER_VERSION(2,0), WINED3D_SHADER_VERSION(2,1)},
    249252    {WINED3D_SM1_OP_SGN,      1, 2, WINED3DSIH_SGN,          WINED3D_SHADER_VERSION(3,0), -1                         },
     253#endif
    250254    {WINED3D_SM1_OP_NRM,      1, 2, WINED3DSIH_NRM,          0,                           0                          },
    251255    {WINED3D_SM1_OP_SINCOS,   1, 4, WINED3DSIH_SINCOS,       WINED3D_SHADER_VERSION(2,0), WINED3D_SHADER_VERSION(2,1)},

  • trunk/src/VBox/Devices/Graphics/shaderlib/wined3d_private.h

    r53755 r54765  
    31973197        case WINED3DSPR_CONSTBOOL:  /* b# */
    31983198        case WINED3DSPR_LOOP:       /* aL */
     3199#ifndef VBOX_WITH_VMSVGA
    31993200        case WINED3DSPR_PREDICATE:  /* p0 */
    32003201            return TRUE;
     3202#else
     3203            return TRUE;
     3204        case WINED3DSPR_PREDICATE:  /* p0 */
     3205            return FALSE;
     3206#endif
    32013207
    32023208        case WINED3DSPR_MISCTYPE:

  • trunk/src/VBox/Devices/Makefile.kmk

    r54273 r54765  
    257257  ifeq ($(KBUILD_TARGET),win) # (Disable this to work with OpenGL on Windows.)
    258258   VBoxDD_SOURCES       += Graphics/DevVGA-SVGA3d-win.cpp
    259    VBoxDD_LIBS.win      += d3d9.lib $(PATH_TOOL_$(VBOX_VCC_TOOL)_LIB)/delayimp.lib
     259   VBoxDD_LIBS.win      += d3d9.lib d3dx9.lib $(PATH_TOOL_$(VBOX_VCC_TOOL)_LIB)/delayimp.lib
    260260   VBoxDD_LDFLAGS.win   += /DELAYLOAD:d3d9.dll
    261261  else
    … …  
    276276
    277277   VBoxDD_LIBS.linux    += GL X11
    278    VBoxDD_LIBS.win      += $(PATH_SDK_$(VBOX_WINPSDK)_LIB)/Opengl32.lib
     278   VBoxDD_LIBS.win      += d3dx9.lib $(PATH_SDK_$(VBOX_WINPSDK)_LIB)/Opengl32.lib
    279279   VBoxDD_LDFLAGS.darwin += -framework OpenGL
    280280   VBoxDD_DEFS.darwin    += VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
Note: See TracChangeset for help on using the changeset viewer.

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