halcaps.cpp

来自「老外的一个开源项目」· C++ 代码 · 共 488 行 · 第 1/2 页

CPP
488
字号
{
    memset( lpddhi, 0, sizeof(DDHALINFO) );         // Clear the DDHALINFO structure

    DDHALMODEINFO * ModeTable = NULL;

    SA2Video * pSA2Video = (SA2Video *)g_pGPE;

    ModeTable = new DDHALMODEINFO();
    if (!ModeTable)
    {

        DEBUGMSG( GPE_ZONE_INIT,(TEXT("Unable to allocate mode table!\r\n")) );
        return;
    }

    ModeTable->dwWidth = pSA2Video->m_pMode->width;
    ModeTable->dwHeight = pSA2Video->m_pMode->height;
    ModeTable->lPitch = pSA2Video->m_cbScanLineLength;
    ModeTable->dwBPP = pSA2Video->m_pMode->Bpp;
    if (ModeTable->dwBPP <= 8)
    {
        ModeTable->wFlags = DDMODEINFO_PALETTIZED;
    }
    else
    {
        ModeTable->wFlags = 0;
    }
    ModeTable->wRefreshRate = pSA2Video->m_pMode->frequency;
    switch (ModeTable->dwBPP)
    {
    case  8:
        ModeTable->dwRBitMask = 0;
        ModeTable->dwGBitMask = 0;
        ModeTable->dwBBitMask = 0;
        ModeTable->dwAlphaBitMask = 0;
        break;

    case  16:
        ModeTable->dwRBitMask = 0xF800;
        ModeTable->dwGBitMask = 0x07E0;
        ModeTable->dwBBitMask = 0x001F;
        ModeTable->dwAlphaBitMask = 0;
        break;

    case  24:
        ModeTable->dwRBitMask = 0x00FF0000;
        ModeTable->dwGBitMask = 0x0000FF00;
        ModeTable->dwBBitMask = 0x000000FF;
        ModeTable->dwAlphaBitMask = 0x00000000;
        break;

    case  32:
        ModeTable->dwRBitMask = 0x00FF0000;
        ModeTable->dwGBitMask = 0x0000FF00;
        ModeTable->dwBBitMask = 0x000000FF;
        ModeTable->dwAlphaBitMask = 0x00000000;
        break;
    }

    if ( !g_pVideoMemory )   // in case this is called more than once...
    {
        unsigned long VideoMemoryStart;
        pSA2Video->GetVirtualVideoMemory( &VideoMemoryStart, &g_nVideoMemorySize );
        DEBUGMSG( GPE_ZONE_INIT,(TEXT("GetVirtualVideoMemory returned addr=0x%08x size=%d\r\n"), VideoMemoryStart, g_nVideoMemorySize));

        g_pVideoMemory = (BYTE*)VideoMemoryStart;
        DEBUGMSG( GPE_ZONE_INIT,(TEXT("gpVidMem=%08x\r\n"), g_pVideoMemory ));
    }

    lpddhi->dwSize = sizeof(DDHALINFO);
    lpddhi->lpDDCallbacks = &cbDDCallbacks;
    lpddhi->lpDDSurfaceCallbacks = &cbDDSurfaceCallbacks;
    lpddhi->lpDDPaletteCallbacks = &cbDDPaletteCallbacks;
    lpddhi->lpDDExeBufCallbacks = &cbDDExeBufCallbacks;
    lpddhi->GetDriverInfo = HalGetDriverInfo;

    lpddhi->vmiData.fpPrimary = (unsigned long)(g_pVideoMemory) + g_pDDrawPrimarySurface->OffsetInVideoMemory();

    lpddhi->vmiData.dwFlags = 0;
    lpddhi->vmiData.dwDisplayWidth = SCREEN_WIDTH;
    lpddhi->vmiData.dwDisplayHeight = SCREEN_HEIGHT;
    lpddhi->vmiData.lDisplayPitch = ModeTable->lPitch;
    DEBUGMSG( GPE_ZONE_INIT,(TEXT("stride: %d\r\n"), lpddhi->vmiData.lDisplayPitch ));

    lpddhi->vmiData.ddpfDisplay.dwSize = sizeof(DDPIXELFORMAT);
    lpddhi->vmiData.ddpfDisplay.dwFourCC = 0;   // (FOURCC code)

    if (ModeTable->wFlags & DDMODEINFO_PALETTIZED)
    {

        lpddhi->vmiData.ddpfDisplay.dwFlags = DDPF_RGB | DDPF_PALETTEINDEXED8;
    }
    else
    {

        lpddhi->vmiData.ddpfDisplay.dwFlags = DDPF_RGB;
    }

    lpddhi->vmiData.ddpfDisplay.dwRBitMask = ModeTable->dwRBitMask;
    lpddhi->vmiData.ddpfDisplay.dwGBitMask = ModeTable->dwGBitMask;
    lpddhi->vmiData.ddpfDisplay.dwBBitMask = ModeTable->dwBBitMask;
    lpddhi->vmiData.ddpfDisplay.dwRGBBitCount = ModeTable->dwBPP;

    lpddhi->vmiData.dwOffscreenAlign = 4;               // byte alignment for offscreen surfaces
    lpddhi->vmiData.dwOverlayAlign = 4;                 // byte alignment for overlays
    lpddhi->vmiData.dwTextureAlign = 0;                 // byte alignment for textures
    lpddhi->vmiData.dwZBufferAlign = 0;                 // byte alignment for z buffers
    lpddhi->vmiData.dwAlphaAlign = 4;                   // byte alignment for alpha
    lpddhi->vmiData.dwNumHeaps = 0;                             // number of memory heaps in vmList
    lpddhi->vmiData.pvmList = (LPVIDMEM)NULL;   // array of heaps
    // hw specific caps:
    lpddhi->ddCaps.dwSize = sizeof(DDCAPS);         // size of the DDDRIVERCAPS structure
    lpddhi->ddCaps.dwCaps =                                         // driver specific capabilities
                                                                    // DDCAPS_3D |                          // Display hardware has 3D acceleration
                                                                    DDCAPS_BLT |                                    // Display hardware is capable of blt operations
                                                                    // DDCAPS_BLTQUEUE |                            // Display hardware is capable of asynchronous blt operations
                                                                    // DDCAPS_BLTFOURCC |                   // Display hardware is capable of color space conversions during the blt operation
                                                                    // DDCAPS_BLTSTRETCH |                  // Display hardware is capable of stretching during blt operations
                                                                    // DDCAPS_GDI |                         // Display hardware is shared with GDI
                                                                    // DDCAPS_OVERLAY |                     // Display hardware can overlay
                                                                    // DDCAPS_OVERLAYCANTCLIP |             // Set if display hardware supports overlays but can not clip them
                                                                    // DDCAPS_OVERLAYFOURCC |               // overlay hardware is capable of color space conversions
                                                                    // DDCAPS_OVERLAYSTRETCH |              // Indicates that stretching can be done by the overlay hardware
                                                                    // DDCAPS_PALETTE |                     // unique DirectDrawPalettes can be created for DirectDrawSurfaces
                                                                    // DDCAPS_PALETTEVSYNC |                // palette changes can be syncd with the vertical
                                                                    // DDCAPS_READSCANLINE |                // Display hardware can return the current scan line
                                                                    // DDCAPS_STEREOVIEW |                  // Display hardware has stereo vision capabilities
                                                                    // DDCAPS_VBI |                                 // Display hardware is capable of generating a vertical blank interrupt
                                                                    // DDCAPS_ZBLTS |                               // Supports the use of z buffers with blt operations
                                                                    // DDCAPS_ZOVERLAYS |                           // Supports Z Ordering of overlays
                                                                    // DDCAPS_COLORKEY |                            // Supports color key
                                                                    // DDCAPS_ALPHA |                       // Supports alpha surfaces
                                                                    // DDCAPS_COLORKEYHWASSIST |            // colorkey is hardware assisted
                                                                    // DDCAPS_NOHARDWARE |                  // no hardware support at all
                                                                    DDCAPS_BLTCOLORFILL |                           // Display hardware is capable of color fill with bltter
                                                                    // DDCAPS_BANKSWITCHED |                // Display hardware is bank switched
                                                                    // DDCAPS_BLTDEPTHFILL |                // Display hardware is capable of depth filling Z-buffers with bltter
                                                                    // DDCAPS_CANCLIP |                     // Display hardware is capable of clipping while bltting
                                                                    // DDCAPS_CANCLIPSTRETCHED |            // Display hardware is capable of clipping while stretch bltting
                                                                    DDCAPS_CANBLTSYSMEM |                   // Display hardware is capable of bltting to or from system memory
                                                                    0;

    lpddhi->ddCaps.dwCaps2 =                    // more driver specific capabilities
                                                // DDCAPS2_CERTIFIED                                    // Display hardware is certified
                                                DDCAPS2_NO2DDURING3DSCENE |                             // Driver cannot interleave 2D & 3D operations
                                                // DDCAPS2_VIDEOPORT |                                  // Display hardware contains a video port
                                                // DDCAPS2_AUTOFLIPOVERLAY |                    // automatic doubled buffered display of video port
                                                // DDCAPS2_CANBOBINTERLEAVED |                  // Overlay can display each field of interlaced data
                                                // DDCAPS2_CANBOBNONINTERLEAVED |               // As above but for non-interleaved data
                                                // DDCAPS2_COLORCONTROLOVERLAY |                // The overlay surface contains color controls
                                                // DDCAPS2_COLORCONTROLPRIMARY |                // The primary surface contains color controls
                                                // DDCAPS2_CANDROPZ16BIT |                              // RGBZ -> RGB supported for 16:16 RGB:Z
                                                // DDCAPS2_NONLOCALVIDMEM |                             // Driver supports non-local video memory
                                                // DDCAPS2_NONLOCALVIDMEMCAPS |                 // Dirver supports non-local video memory but has different capabilities
                                                // DDCAPS2_NOPAGELOCKREQUIRED |                 // Driver neither requires nor prefers surfaces to be pagelocked
                                                DDCAPS2_WIDESURFACES |                                  // Driver can create surfaces which are wider than the primary surface
                                                // DDCAPS2_CANFLIPODDEVEN |                             // Driver supports bob without using a video port
                                                // DDCAPS2_CANBOBHARDWARE |                             // Driver supports bob using hardware
                                                // DDCAPS2_COPYFOURCC |                                 // Driver supports bltting any FOURCC surface to another surface of the same FOURCC
                                                0 ;

    lpddhi->ddCaps.dwCKeyCaps =                                     // color key capabilities of the surface
                                                                    // DDCKEYCAPS_SRCBLT |                                  // Hardware can use colorkey (cf source only)
                                                                    //   ..for transparent blts
                                                                    0;
    lpddhi->ddCaps.dwFXCaps=                                        // driver specific stretching and effects capabilites
                                                                    DDFXCAPS_BLTMIRRORUPDOWN |                              // Supports vertical inversion Blts
                                                                    DDFXCAPS_BLTSTRETCHY |                          // Supports stretch blts in the Y-direction
                                                                    DDFXCAPS_BLTSHRINKY |                                   // Supports shrink blts in the Y-direction
                                                                    DDFXCAPS_BLTSTRETCHX |                          // Supports stretch blts in the X-direction
                                                                    DDFXCAPS_BLTSHRINKX |                                   // Supports shrink blts in the X-direction
                                                                    0;

    lpddhi->ddCaps.dwPalCaps=0;                                     // palette capabilities

    if (ModeTable->dwBPP == 8)
    {
        lpddhi->ddCaps.dwPalCaps=                                       // palette capabilities
                                                                        // DDPCAPS_1BIT |                                                       // Simple 1-bit palette
                                                                        // DDPCAPS_2BIT |                                                       // Simple 2-bit palette
                                                                        // DDPCAPS_4BIT |                                                       // Simple 4-bit palette
                                                                        // DDPCAPS_8BITENTRIES |                                // Palette indexes into 8 bit target
                                                                        DDPCAPS_8BIT |                                                  // Simple 8-bit palette
                                                                        DDPCAPS_PRIMARYSURFACE |                                // Palette is attached to primary surface
                                                                        // DDPCAPS_PRIMARYSURFACELEFT |                 // Palette is attached to left-eye primary surface
                                                                        DDPCAPS_ALLOW256 |                                              // All 256 entries may be set
                                                                        0;
    }
    lpddhi->ddCaps.dwSVCaps=0;                                      // Stereo vision capabilities (none)
    lpddhi->ddCaps.dwAlphaBltConstBitDepths = 0;// No Alpha Blt's
    lpddhi->ddCaps.dwAlphaBltPixelBitDepths = 0;
    lpddhi->ddCaps.dwAlphaBltSurfaceBitDepths = 0;
    lpddhi->ddCaps.dwZBufferBitDepths=0;            // No z buffer
    lpddhi->ddCaps.dwVidMemTotal = g_nVideoMemorySize;      // total amount of video memory
    lpddhi->ddCaps.dwVidMemFree = g_nVideoMemorySize;       // amount of free video memory

    // maximum number of visible overlays
    lpddhi->ddCaps.dwCurrVisibleOverlays = 0;       // current number of visible overlays
    lpddhi->ddCaps.dwNumFourCCCodes = 0;            // number of four cc codes
    lpddhi->ddCaps.dwAlignBoundarySrc = 0;          // source rectangle alignment
    lpddhi->ddCaps.dwAlignSizeSrc = 0;                      // source rectangle byte size
    lpddhi->ddCaps.dwAlignStrideAlign = 0;          // stride alignment
    lpddhi->ddCaps.ddsCaps.dwCaps=                          // DDSCAPS structure has all the general capabilities
                                                            // DDSCAPS_ALPHA |                              // Can create alpha-only surfaces
                                                            DDSCAPS_BACKBUFFER |                            // Can create backbuffer surfaces
                                                            // DDSCAPS_COMPLEX |                            // Can create complex surfaces
                                                            // DDSCAPS_FLIP |                               // Can flip between surfaces
                                                            DDSCAPS_FRONTBUFFER |                           // Can create front-buffer surfaces
                                                            DDSCAPS_OFFSCREENPLAIN |                        // Can create off-screen bitmaps
                                                            // DDSCAPS_OVERLAY |                            // Can create overlay surfaces
                                                            DDSCAPS_PALETTE |                               // Has one palette ???
                                                            DDSCAPS_PRIMARYSURFACE |                        // Has a primary surface
                                                            // DDSCAPS_PRIMARYSURFACELEFT |                 // Has a left-eye primary surface
                                                            // DDSCAPS_TEXTURE |                            // Supports texture surrfaces
                                                            DDSCAPS_SYSTEMMEMORY |                          // Surfaces are in system memory
                                                            // DDSCAPS_VIDEOMEMORY |                        // Surfaces are in video memory 
                                                            DDSCAPS_VISIBLE |                               // Changes are instant ???
                                                            // DDSCAPS_ZBUFFER |                            // Can create (pseudo) Z buffer
                                                            // DDSCAPS_EXECUTEBUFFER |                      // Can create execute buffer
                                                            // DDSCAPS_3DDEVICE |                           // Surfaces can be 3d targets
                                                            // DDSCAPS_WRITEONLY |                          // Can create write-only surfaces
                                                            // DDSCAPS_ALLOCONLOAD |                        // Can create alloconload surfaces
                                                            // DDSCAPS_MIPMAP |                             // Can create mipmap
                                                            0;

    SETROPBIT(lpddhi->ddCaps.dwRops,SRCCOPY);                   // Set bits for ROPS supported
    SETROPBIT(lpddhi->ddCaps.dwRops,PATCOPY);
    SETROPBIT(lpddhi->ddCaps.dwRops,BLACKNESS);
    SETROPBIT(lpddhi->ddCaps.dwRops,WHITENESS);
    lpddhi->dwMonitorFrequency = ModeTable->wRefreshRate;       // monitor frequency in current mode
    lpddhi->dwModeIndex = 0;                                    // current mode: index into array
    lpddhi->lpdwFourCC = 0;                                     // fourcc codes supported
    lpddhi->dwNumModes = 1;                                     // number of modes supported
    lpddhi->lpModeInfo = ModeTable;                              // mode information
    lpddhi->dwFlags = DDHALINFO_MODEXILLEGAL |                  // create flags
                      DDHALINFO_GETDRIVERINFOSET |
                      0;
    lpddhi->lpPDevice = (LPVOID)0;                              // physical device ptr
    lpddhi->hInstance = (DWORD)0;                               // instance handle of driver
}

#endif	// DD_ENABLE

⌨️ 快捷键说明

复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?