unused/win95/direct3d.c

   1 /*
   2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   3 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   6 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   8 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
   9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  11 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12 */
  13
  14
  15 #pragma off (unreferenced)
  16 static char rcsid[] = "$Id: direct3d.c,v 1.1.1.1 2001-01-19 03:30:15 bradleyb Exp $";
  17 #pragma on (unreferenced)
  18
  19
  20
  21
  22 #define _WIN32
  23 #define WIN95
  24 #define WIN32_LEAN_AND_MEAN
  25 #define INITGUID
  26
  27 #include <windows.h>
  28 #include <windowsx.h>
  29
  30 #include <stdio.h>
  31
  32 #include "ddraw.h"
  33 #include "d3d.h"
  34
  35 #include "pstypes.h"
  36 #include "mono.h"
  37 #include "args.h"
  38 #include "error.h"
  39 #include "winapp.h"
  40
  41 #include "dd.h"
  42 #include "direct3d.h"
  43
  44
  45
  46 //      Globals
  47 //      ----------------------------------------------------------------------------
  48
  49 static LPDIRECT3D                       _lpD3D = NULL;          // D3D Object
  50 static LPDIRECT3DDEVICE         _lpD3DDev = NULL;       // D3D Device
  51 static GUID                                             _3DGUID;                                // Device GUID
  52
  53 static d3d_caps                         d3dCaps;                                // Direct 3d Device Caps
  54 static BOOL                                             d3d_initialized=0;// D3D flag
  55 static FILE                                     *LogFile=NULL;          // Log File!
  56
  57
  58
  59 //      Function prototypes
  60 //      ----------------------------------------------------------------------------
  61
  62 #ifdef NDEBUG
  63 #define WRITELOG(t)
  64 #define LOGINIT(n)
  65 #define LOGCLOSE
  66 #else
  67 #define WRITELOG(t) if (LogFile) { fprintf t; fflush(LogFile); }
  68 #define LOGINIT(n) LogFile = fopen(n, "wt");
  69 #define LOGCLOSE if (LogFile) fclose(LogFile);
  70 #endif
  71
  72 HRESULT FAR PASCAL d3d_enum_callback(LPGUID pguid, LPSTR lpDeviceDesc,
  73                                                                     LPSTR lpDeviceName, LPD3DDEVICEDESC lpHWDevDesc,
  74                                                                     LPD3DDEVICEDESC lpHELDevDesc, LPVOID lpUserArg);
  75
  76 int d3d_close();
  77 int d3d_device_close();
  78 int d3d_enum_devices(GUID *pguid);
  79 int d3d_enum_texformats();
  80 int d3d_init_device(GUID guid);
  81 int d3d_handle_error(HRESULT err);
  82
  83
  84
  85
  86 /* d3d_init
  87                 Direct 3D Initialization of Immediate Mode
  88
  89                 We need to do a few things, first get the D3D interface from our
  90                 DirectDraw Object
  91
  92                 Then we need to find an active device.
  93
  94                 Then we need to query the caps of such a device, and tell our GFX system
  95                 about the available video modes (15-bit color)
  96 */
  97
  98
  99 BOOL d3d_init(void)
 100 {
 101         HRESULT         res;
 102         GUID            guid;
 103
 104         Assert(d3d_initialized == FALSE);
 105
 106         LOGINIT("d3d.log");
 107
 108         atexit(d3d_close);
 109
 110 //      initialize Direct3d interface
 111         res = IDirectDraw_QueryInterface(_lpDD, &IID_IDirect3D, &_lpD3D);
 112         if (res != DD_OK)
 113                 return d3d_handle_error(res);
 114
 115 //      enumerate all 3d devices useable by Direct3d
 116         if (d3d_enum_devices(&guid)) return FALSE;
 117
 118         memcpy(&_3DGUID, &guid, sizeof(GUID));
 119
 120         d3d_initialized = TRUE;
 121
 122         return TRUE;
 123 }
 124
 125
 126 int d3d_close(void)
 127 {
 128         if (d3d_initialized) {
 129                 IDirect3D_Release(_lpD3D);
 130                 _lpD3D = NULL;
 131                 d3d_initialized = FALSE;
 132         }
 133         return 0;
 134 }
 135
 136
 137 int d3d_enum_devices(GUID *pguid)
 138 {
 139         HRESULT res;
 140         GUID guid;
 141
 142         res = IDirect3D_EnumDevices(_lpD3D, d3d_enum_callback, (LPVOID)&guid);
 143         if (res != DD_OK) {
 144                 WRITELOG((LogFile, "Unable to find a proper 3D hardware device.\n"));
 145                 return d3d_handle_error(res);
 146         }
 147
 148         WRITELOG((LogFile, "Found 3D Device (%s)\n", d3dCaps.devname));
 149
 150         memcpy(pguid, &guid, sizeof(GUID));
 151         return 0;
 152 }
 153
 154
 155
 156 /* d3d_device functions
 157
 158                 these functions are used once we really need to use the 3d system.
 159                 When done with it, we call device_close.
 160 */
 161
 162 int d3d_init_device(GUID guid)
 163 {
 164         HRESULT res;
 165         DDSURFACEDESC ddsd;
 166
 167         if (!d3d_initialized) return -1;
 168
 169 //      Grab back buffer.
 170         res = IDirectDrawSurface_QueryInterface(_lpDDSBack, &_3DGUID, &_lpD3DDev);
 171         if (res != DD_OK) {
 172                 WRITELOG((LogFile, "Unable to retrieve device from back buffer. %x\n",res));
 173                 return d3d_handle_error(res);
 174         }
 175
 176 //      Enumerate texture formats
 177         Assert(d3dCaps.tmap_acc == TRUE);
 178         d3dCaps.tmap_formats = 0;
 179         if (d3d_enum_texformats()) return -1;
 180
 181         return 0;
 182 }
 183
 184
 185 int d3d_device_close()
 186 {
 187         if (_lpD3DDev) {
 188                 IDirect3DDevice_Release(_lpD3DDev);
 189                 _lpD3DDev = NULL;
 190         }
 191         return 0;
 192 }
 193
 194
 195 int d3d_enum_texformats()
 196 {
 197
 198         return 0;
 199 }
 200
 201
 202
 203 /* Miscellaneous Utilities */
 204
 205 int d3d_handle_error(HRESULT err)
 206 {
 207         if (err != DD_OK) return err;
 208         else return 0;
 209 }
 210
 211
 212
 213 /* Direct 3D callbacks
 214
 215                 enum_callback:   enumerates all 3D devices attached to system.
 216
 217
 218 */
 219
 220 HRESULT FAR PASCAL d3d_enum_callback(LPGUID pguid, LPSTR lpDeviceDesc,
 221                                                                    LPSTR lpDeviceName,
 222                                                                         LPD3DDEVICEDESC lpHWDevDesc,
 223                                                                    LPD3DDEVICEDESC lpHELDevDesc,
 224                                                                         LPVOID lpUserArg)
 225 {
 226
 227 /* Ignore emulated devices (we can use our own stuff then) */
 228         if (lpHWDevDesc->dcmColorModel) {
 229                 d3dCaps.hw_acc = TRUE;
 230         }
 231         else {
 232                 d3dCaps.hw_acc = FALSE;
 233                 return D3DENUMRET_OK;
 234         }
 235
 236 /* Test hardware caps
 237                 texture = MUST HAVE
 238 */
 239         if (lpHWDevDesc->dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_PERSPECTIVE) {
 240                 d3dCaps.tmap_acc = TRUE;
 241         }
 242         else {
 243                 d3dCaps.tmap_acc = FALSE;
 244                 return D3DENUMRET_OK;
 245         }
 246
 247         memcpy(lpUserArg, pguid, sizeof(GUID));
 248         lstrcpy(d3dCaps.devname, lpDeviceName);
 249
 250         return D3DENUMRET_CANCEL;
 251 }
 252