D3ddrv.cpp

Go to the documentation of this file.

/****************************************************************************************/
/*  D3DDrv.cpp                                                                          */
/*                                                                                      */
/*  Author: John Pollard                                                                */
/*  Description: D3D driver                                                             */
/*                                                                                      */
/*  The contents of this file are subject to the Genesis3D Public License               */
/*  Version 1.01 (the "License"); you may not use this file except in                   */
/*  compliance with the License. You may obtain a copy of the License at                */
/*  http://www.genesis3d.com                                                            */
/*                                                                                      */
/*  Software distributed under the License is distributed on an "AS IS"                 */
/*  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See                */
/*  the License for the specific language governing rights and limitations              */
/*  under the License.                                                                  */
/*                                                                                      */
/*  The Original Code is Genesis3D, released March 25, 1999.                            */
/*Genesis3D Version 1.1 released November 15, 1999                            */
/*  Copyright (C) 1999 WildTangent, Inc. All Rights Reserved           */
/*                                                                                      */
/****************************************************************************************/
#include <Windows.h>
#include <stdio.h>

#include "D3DDrv.h"
#include "DCommon.h"

#include "Scene.h"
#include "Render.h"
#include "D3DCache.h"
#include "D3D_Main.h"
#include "PCache.h"
#include "THandle.h"


DRV_Window                      ClientWindow;
BOOL                            ExitHandlerActive = FALSE;

int32                           LastError;
char                            LastErrorStr[200];

geBoolean       DRIVERCC DrvShutdown(void);
geBoolean       DRIVERCC ScreenShot(const char *Name);

BOOL DRIVERCC DrvInit(DRV_DriverHook *Hook)
{
        RECT    WRect;

        // Start up
        if (!D3DMain_InitD3D(Hook->hWnd, Hook->DriverName+5, Hook->Width, Hook->Height))
        {
                //SetLastDrvError(DRV_ERROR_INIT_ERROR, "D3D_DrvInit: Could not init driver.\n");
                return FALSE;
        }
        
        // If they are asking for a window mode, use there hWnd for the size
        if (Hook->Width ==-1 && Hook->Height == -1)
        {
                GetClientRect(Hook->hWnd, &WRect);
                
                Hook->Width = (WRect.right - WRect.left);
                Hook->Height = (WRect.bottom - WRect.top);
        }

        ClientWindow.Width = Hook->Width;
        ClientWindow.Height = Hook->Height;
        ClientWindow.hWnd = Hook->hWnd;

        return TRUE;
}

//============================================================================================
//============================================================================================
BOOL DRIVERCC DrvShutdown(void)
{
        D3DMain_ShutdownD3D();
        return TRUE;
}

//============================================================================================
//      DrvResetAll
//============================================================================================
geBoolean DRIVERCC DrvResetAll(void)
{
        return D3DMain_Reset();
}

geRDriver_PixelFormat   PixelFormat[10]; 

#define NUM_PIXEL_FORMATS (sizeof(PixelFormats)/sizeof(geRDriver_PixelFormat))

geBoolean DRIVERCC EnumPixelFormats(DRV_ENUM_PFORMAT_CB *Cb, void *Context)
{
        int32                   i;
        gePixelFormat   Format3d, Format2d;
        uint32                  CurrentBpp;

        CurrentBpp = AppInfo.ddsd.ddpfPixelFormat.dwRGBBitCount;

        // Setup the 2d surface format
        if (CurrentBpp == 32 && AppInfo.ddSurfFormat.ddpfPixelFormat.dwRGBAlphaBitMask == 0xff000000)
                Format2d = GE_PIXELFORMAT_32BIT_ARGB;
        else if (CurrentBpp == 32 && AppInfo.ddSurfFormat.ddpfPixelFormat.dwBBitMask == 0xff)
                Format2d = GE_PIXELFORMAT_32BIT_XRGB;
        else if (CurrentBpp == 24 && AppInfo.ddSurfFormat.ddpfPixelFormat.dwBBitMask == 0xff)
                Format2d = GE_PIXELFORMAT_24BIT_RGB;
        else if (AppInfo.ddSurfFormat.ddpfPixelFormat.dwGBitMask == (31<<5))
                Format2d = GE_PIXELFORMAT_16BIT_555_RGB;
        else
                Format2d = GE_PIXELFORMAT_16BIT_565_RGB;

        // Setup the 3d (Texture) format
        if (AppInfo.ddTexFormat.ddpfPixelFormat.dwGBitMask == (31<<5))
                Format3d = GE_PIXELFORMAT_16BIT_555_RGB;
        else
                Format3d = GE_PIXELFORMAT_16BIT_565_RGB;


        // Create the surface formats now
        PixelFormat[0].PixelFormat = Format3d;                                                  // 3d 565/555 surface
        PixelFormat[0].Flags = RDRIVER_PF_3D | RDRIVER_PF_COMBINE_LIGHTMAP;
                
        PixelFormat[1].PixelFormat = GE_PIXELFORMAT_16BIT_4444_ARGB;    // 3d 4444 surface
        PixelFormat[1].Flags = RDRIVER_PF_3D | RDRIVER_PF_COMBINE_LIGHTMAP;

        PixelFormat[2].PixelFormat = Format2d;                                                  // 2d 565/555 surface
        PixelFormat[2].Flags = RDRIVER_PF_2D | RDRIVER_PF_CAN_DO_COLORKEY;

        PixelFormat[3].PixelFormat = Format3d;                                                  // Lightmap 565/555 surface
        PixelFormat[3].Flags = RDRIVER_PF_LIGHTMAP;

        PixelFormat[4].PixelFormat = GE_PIXELFORMAT_16BIT_1555_ARGB;    
        PixelFormat[4].Flags = RDRIVER_PF_3D | RDRIVER_PF_COMBINE_LIGHTMAP;

        // Then hand them off to the caller
        for (i=0; i<5; i++)
        {
                if (!Cb(&PixelFormat[i], Context))
                        return GE_TRUE;
        }

        return TRUE;
}

geBoolean DRIVERCC SetGamma(geFloat Gamma)
{
        return GE_TRUE;
}

geBoolean DRIVERCC GetGamma(geFloat *Gamma)
{
        *Gamma = 1.0f;
                
        return GE_TRUE;
}

BOOL DRIVERCC EnumSubDrivers2(DRV_ENUM_DRV_CB *Cb, void *Context);
BOOL DRIVERCC EnumModes2(int32 Driver, char *DriverName, DRV_ENUM_MODES_CB *Cb, void *Context);

DRV_Driver D3DDRV = 
{
    "D3D driver. v"DRV_VMAJS"."DRV_VMINS". Copyright 1999, WildTangent Inc.; All Rights Reserved.",
        DRV_VERSION_MAJOR,
        DRV_VERSION_MINOR,

        DRV_ERROR_NONE,
        NULL,
        
        EnumSubDrivers2,
        EnumModes2,

        EnumPixelFormats,

        DrvInit,
        DrvShutdown,
        DrvResetAll,
        D3DMain_UpdateWindow,
        D3DMain_SetActive,

        THandle_Create,
        THandle_Destroy,

        THandle_Lock,
        THandle_UnLock,

        NULL,                   // SetPal
        NULL,                   // GetPal

        NULL,                   // SetAlpha
        NULL,                   // GetAlpha

        THandle_GetInfo,

        BeginScene,
        EndScene,
        BeginWorld,
        EndWorld,
        BeginMeshes,
        EndMeshes,
        BeginModels,
        EndModels,

        RenderGouraudPoly,
        RenderWorldPoly,
        RenderMiscTexturePoly,

        DrawDecal,

        0,0,0,
        
        &CacheInfo,

        ScreenShot,

        SetGamma,
        GetGamma,

        D3DMain_SetFogEnable,

        NULL,
        NULL,                                                           // Init to NULL, engine SHOULD set this (SetupLightmap)
        NULL
};

DRV_EngineSettings EngineSettings;

DllExport BOOL DriverHook(DRV_Driver **Driver)
{
        EngineSettings.CanSupportFlags = (DRV_SUPPORT_ALPHA | DRV_SUPPORT_COLORKEY);
        EngineSettings.PreferenceFlags = 0;//DRV_PREFERENCE_NO_MIRRORS;

        D3DDRV.EngineSettings = &EngineSettings;
    
        *Driver = &D3DDRV;

        // Make sure the error string ptr is not null, or invalid!!!
    D3DDRV.LastErrorStr = LastErrorStr;

        SetLastDrvError(DRV_ERROR_NONE, "D3DDrv:  No error.");

        return TRUE;
}

void SetLastDrvError(int32 Error, char *ErrorStr)
{
        LastError = Error;
        
        if (ErrorStr)
        {
                strcpy(LastErrorStr, ErrorStr);
        }
        else
                LastErrorStr[0] = NULL;

    D3DDRV.LastErrorStr = LastErrorStr;
    D3DDRV.LastError = LastError;
}

//      eaa3 05/31/2000 Added Orf's Direct3D screenshot code to the driver
//      ..so we can get SCREENSHOTS out of both Glide and D3d.

BOOL DRIVERCC ScreenShot(const char *Name)
{       
  DDSURFACEDESC2 ddsd;
        BITMAPFILEHEADER bfh;
        BITMAPINFOHEADER bih;
        HRESULT result;
        HDC surfDC = NULL;
        HDC memDC = NULL;
        HBITMAP bitmap = NULL;
        HBITMAP oldbit = NULL;
        FILE *file = NULL;
        void *data= NULL;
        int width, height, bpp;
        int datasize;
        BOOL success = FALSE;
        
        memset(&ddsd,0,sizeof(ddsd));
        ddsd.dwSize = sizeof(ddsd);
        result = AppInfo.lpBackBuffer->GetSurfaceDesc(&ddsd);
        if(FAILED(result))
          goto cleanup;
        
        width = ddsd.dwWidth;
        height= ddsd.dwHeight;
        bpp = ddsd.ddpfPixelFormat.dwRGBBitCount / 8;
        
        if(bpp < 2)
          bpp = 2;
        if(bpp > 3)
          bpp = 3;
        
        datasize = width * bpp * height;
        if(width * bpp % 4)
                datasize += height * (4 - width * bpp % 4);
                        
        memset((void*)&bfh, 0, sizeof(bfh));
        bfh.bfType = 'B'+('M'<<8);
        bfh.bfSize = sizeof(bfh) + sizeof(bih) + datasize;
        bfh.bfOffBits = sizeof(bfh) + sizeof(bih);
        memset((void*)&bih, 0, sizeof(bih));
        bih.biSize = sizeof(bih);
        bih.biWidth = ddsd.dwWidth;
        bih.biHeight = ddsd.dwHeight;
        bih.biPlanes = 1;
        bih.biBitCount = bpp * 8;
        bih.biCompression = BI_RGB;
        result = AppInfo.lpBackBuffer->GetDC(&surfDC);
        
        if(FAILED(result))
          goto cleanup;
                
        bitmap = CreateDIBSection(NULL, (BITMAPINFO *)&bih, DIB_RGB_COLORS, 
                                &data, NULL, 0);
                                
        if(!bitmap)
          goto cleanup;
        if(!data)
          goto cleanup;
                
        memDC = CreateCompatibleDC(surfDC);
        if(!memDC)
          goto cleanup;
                
        oldbit = (HBITMAP)SelectObject(memDC, bitmap);
        if(!oldbit || FAILED(oldbit))
          goto cleanup;
                
        result = BitBlt(memDC, 0, 0, width, height, surfDC, 0, 0, SRCCOPY);
        if(!result)
          goto cleanup;
                
        AppInfo.lpBackBuffer->ReleaseDC(surfDC);
        surfDC = NULL;
        
        file = fopen(Name, "wb");
        
        if(!file)
          goto cleanup;
                
        fwrite((void*)&bfh, sizeof(bfh), 1, file);
        fwrite((void*)&bih, sizeof(bih), 1, file);
        fwrite((void*)data, 1, datasize, file);
        
        success = TRUE;
        
cleanup:

        if(oldbit && !FAILED(oldbit))
          SelectObject(memDC, oldbit);
        
        if(memDC)
          DeleteDC(memDC);
        
        if(surfDC)
          AppInfo.lpBackBuffer->ReleaseDC(surfDC);

        if(bitmap)
          DeleteObject(bitmap);
                
        if(file)
          fclose(file);
                
        return success;
        
} 

---