SVN r383 (trunk)

docs/rh-log.txt

@@ -1,3 +1,25 @@
+November 18, 2006
+- Fixed: DFrameBuffer and related classes did not use DECLARE_CLASS macros,
+  so there was no guarantee that they would allocate the proper amount of
+  memory. This tripped me up when I was using D3DFB and it was writing beyond
+  the end of allocated memory.
+- Added a new D3DFB class that should be more compatible with modern systems
+  than the 8-bit paletted DDrawFB.
+  Pros:
+    - Much cleaner code.
+    - No performance penalty when running in a window.
+    - Slightly faster fullscreen performance on Geforce 6 and 7 cards.
+    - Vista ought to love it.
+  Cons:
+    - Requires Pixel Shader 1.4 or better.
+    - Fullscreen on an ATI Mobility x300 is a little slower (but still faster
+      than DirectDraw in a window).
+  Note that this is not hardware accelerated rendering. The screen is still
+  drawn as before by the CPU to an 8-bit paletted surface. The difference is
+  in how that surface makes its way to the visible display. Here, the surface
+  is copied to an 8-bit texture, and a pixel shader converts it to RGB when
+  drawing it.
+
 November 14, 2006 (Changes by Graf Zahl)
 - Made AActor's xscale and yscale properties full precision fixed point
   so now larger scales than 4 can be done.

src/sdl/sdlvideo.cpp

@@ -20,6 +20,7 @@
 
 class SDLFB : public DFrameBuffer
 {
+	DECLARE_CLASS(SDLFB, DFrameBuffer)
 public:
 	SDLFB (int width, int height, bool fullscreen);
 	~SDLFB ();
@@ -56,7 +57,10 @@ private:
 	bool NotPaletted;
 	
 	void UpdateColors ();
+
+	SDLFB () {}
 };
+IMPLEMENT_CLASS(SDLFB, DFrameBuffer)
 
 struct MiniModeInfo
 {

src/v_video.cpp

@@ -88,6 +88,13 @@ CVAR (Int, vid_defbits, 8, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
 CVAR (Bool, vid_fps, false, 0)
 CVAR (Bool, ticker, false, 0)
 CVAR (Int, vid_showpalette, 0, 0)
+CUSTOM_CVAR (Bool, vid_vsync, false, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
+{
+	if (screen != NULL)
+	{
+		screen->SetVSync (*self);
+	}
+}
 
 CUSTOM_CVAR (Float, dimamount, 0.2f, CVAR_ARCHIVE)
 {
@@ -724,6 +731,10 @@ void DFrameBuffer::CopyFromBuff (BYTE *src, int srcPitch, int width, int height,
 	}
 }
 
+void DFrameBuffer::SetVSync (bool vsync)
+{
+}
+
 //
 // V_SetResolution
 //

src/v_video.h

@@ -185,6 +185,8 @@ protected:
 
 	bool ClipBox (int &left, int &top, int &width, int &height, const BYTE *&src, const int srcpitch) const;
 
+	DCanvas() {}
+
 private:
 	// Keep track of canvases, for automatic destruction at exit
 	DCanvas *Next;
@@ -206,6 +208,8 @@ public:
 
 protected:
 	BYTE *MemBuffer;
+
+	DSimpleCanvas() {}
 };
 
 // A canvas that represents the actual display. The video code is responsible
@@ -253,6 +257,9 @@ public:
 	// Returns true if running fullscreen.
 	virtual bool IsFullscreen () = 0;
 
+	// Changes the vsync setting, if supported by the device.
+	virtual void SetVSync (bool vsync);
+
 #ifdef _WIN32
 	virtual void PaletteChanged () = 0;
 	virtual int QueryNewPalette () = 0;
@@ -262,6 +269,8 @@ protected:
 	void DrawRateStuff ();
 	void CopyFromBuff (BYTE *src, int srcPitch, int width, int height, BYTE *dest);
 
+	DFrameBuffer () {}
+
 private:
 	DWORD LastMS, LastSec, FrameCount, LastCount, LastTic;
 };

src/win32/fb_d3d9.cpp

@@ -0,0 +1,722 @@
+/*
+** fb_d3d9.cpp
+** Code to let ZDoom use Direct3D 9 as a simple framebuffer
+**
+**---------------------------------------------------------------------------
+** Copyright 1998-2006 Randy Heit
+** All rights reserved.
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+**
+** 1. Redistributions of source code must retain the above copyright
+**    notice, this list of conditions and the following disclaimer.
+** 2. Redistributions in binary form must reproduce the above copyright
+**    notice, this list of conditions and the following disclaimer in the
+**    documentation and/or other materials provided with the distribution.
+** 3. The name of the author may not be used to endorse or promote products
+**    derived from this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+**---------------------------------------------------------------------------
+**
+** This file does _not_ implement hardware-acclerated rendering. It is just
+** a means of getting the pixel data to the screen in a more reliable
+** method on modern hardware by copying the entire frame to a texture,
+** drawing that to the screen, and presenting.
+*/
+
+// HEADER FILES ------------------------------------------------------------
+
+#ifdef _DEBUG
+#define D3D_DEBUG_INFO
+#endif
+#define DIRECT3D_VERSION 0x0900
+#define WIN32_LEAN_AND_MEAN
+
+#include <windows.h>
+#include <d3d9.h>
+#include <stdio.h>
+
+#define USE_WINDOWS_DWORD
+#include "doomtype.h"
+
+#include "c_dispatch.h"
+#include "templates.h"
+#include "i_system.h"
+#include "i_video.h"
+#include "v_video.h"
+#include "v_pfx.h"
+#include "stats.h"
+#include "doomerrors.h"
+
+#include "win32iface.h"
+
+#include <mmsystem.h>
+
+// MACROS ------------------------------------------------------------------
+
+// TYPES -------------------------------------------------------------------
+
+IMPLEMENT_CLASS(D3DFB)
+
+struct FBVERTEX
+{
+	FLOAT x, y, z, rhw;
+	FLOAT tu, tv;
+};
+#define D3DFVF_FBVERTEX (D3DFVF_XYZRHW|D3DFVF_TEX1)
+
+// PUBLIC FUNCTION PROTOTYPES ----------------------------------------------
+
+void DoBlending (const PalEntry *from, PalEntry *to, int count, int r, int g, int b, int a);
+
+// PRIVATE FUNCTION PROTOTYPES ---------------------------------------------
+
+// EXTERNAL DATA DECLARATIONS ----------------------------------------------
+
+extern HWND Window;
+extern IVideo *Video;
+extern BOOL AppActive;
+extern int SessionState;
+extern bool VidResizing;
+
+EXTERN_CVAR (Bool, fullscreen)
+EXTERN_CVAR (Float, Gamma)
+EXTERN_CVAR (Int, vid_displaybits)
+EXTERN_CVAR (Bool, vid_vsync)
+
+extern IDirect3D9 *D3D;
+
+extern cycle_t BlitCycles;
+
+// PRIVATE DATA DEFINITIONS ------------------------------------------------
+
+#if 0
+// This is the HLSL code:
+
+// Technically, Palette only needs to be a sampler1D, but that
+// produces assembly code to copy index.x to index.y, which is
+// totally unnecessary.
+
+sampler2D Image : register(s0);
+sampler2D Palette : register(s1);
+float4 Flash : register(c0);
+float4 InvFlash : register(c1);
+
+float4 main (float2 texCoord : TEXCOORD0) : COLOR
+{
+	half4 index = tex2D (Image, texCoord);
+
+	// For some reason, this adjustment is needed on NVidia hardware.
+	// If this is not done, then all palette index >=240 look up
+	// palette index + 1. ATI behaves as expacted and does not need
+	// this adjustment. Fortunately, this produces correct results
+	// on both hardware with no perceptible performance impact, so
+	// I only need to use one shader.
+	index.x = clamp(index.x - 7.65931418e-6, 0.0, 1.0);
+
+	float4 rgb = tex2D (Palette, index);
+	return Flash + rgb * InvFlash;
+}
+
+//
+// Generated by Microsoft (R) D3DX9 Shader Compiler 9.15.779.0000
+//
+//   fxc paltex.ps /Tps_1_4 /VnPalTexShaderDef /Fh
+//
+//
+// Parameters:
+//
+//   float4 Flash;
+//   sampler2D Image;
+//   float4 InvFlash;
+//   sampler2D Palette;
+//
+//
+// Registers:
+//
+//   Name         Reg   Size
+//   ------------ ----- ----
+//   Flash        c0       1
+//   InvFlash     c1       1
+//   Image        s0       1
+//   Palette      s1       1
+//
+
+    ps_1_4
+    def c2, -7.65931418e-006, 0, 0, 0
+    texld r0, t0
+    add_sat r0.x, r0.x, c2.x
+    phase
+    texld r1, r0
+    mad r0, r1, c1, c0
+
+// approximately 4 instruction slots used (2 texture, 2 arithmetic)
+#endif
+
+const DWORD PalTexShaderDef[] =
+{
+    0xffff0104, 0x003bfffe, 0x42415443, 0x0000001c, 0x000000b4, 0xffff0104, 
+    0x00000004, 0x0000001c, 0x00000100, 0x000000ad, 0x0000006c, 0x00000002, 
+    0x00020001, 0x00000074, 0x00000000, 0x00000084, 0x00000003, 0x00000001, 
+    0x0000008c, 0x00000000, 0x0000009c, 0x00010002, 0x00020001, 0x00000074, 
+    0x00000000, 0x000000a5, 0x00010003, 0x00000001, 0x0000008c, 0x00000000, 
+    0x73616c46, 0xabab0068, 0x00030001, 0x00040001, 0x00000001, 0x00000000, 
+    0x67616d49, 0xabab0065, 0x000c0004, 0x00010001, 0x00000001, 0x00000000, 
+    0x46766e49, 0x6873616c, 0x6c615000, 0x65747465, 0x5f737000, 0x00345f31, 
+    0x7263694d, 0x666f736f, 0x52282074, 0x33442029, 0x20395844, 0x64616853, 
+    0x43207265, 0x69706d6f, 0x2072656c, 0x35312e39, 0x3937372e, 0x3030302e, 
+    0xabab0030, 0x00000051, 0xa00f0002, 0xb7008081, 0x00000000, 0x00000000, 
+    0x00000000, 0x00000042, 0x800f0000, 0xb0e40000, 0x00000002, 0x80110000, 
+    0x80000000, 0xa0000002, 0x0000fffd, 0x00000042, 0x800f0001, 0x80e40000, 
+    0x00000004, 0x800f0000, 0x80e40001, 0xa0e40001, 0xa0e40000, 0x0000ffff
+};
+
+// PUBLIC DATA DEFINITIONS -------------------------------------------------
+
+// CODE --------------------------------------------------------------------
+
+D3DFB::D3DFB (int width, int height, bool fullscreen)
+	: BaseWinFB (width, height)
+{
+	D3DPRESENT_PARAMETERS d3dpp;
+	int i;
+
+	D3DDevice = NULL;
+	VertexBuffer = NULL;
+	FBTexture = NULL;
+	PaletteTexture = NULL;
+	PalTexShader = NULL;
+	FBFormat = D3DFMT_UNKNOWN;
+	PalFormat = D3DFMT_UNKNOWN;
+	VSync = vid_vsync;
+
+	Gamma = 1.0;
+	memset (FlashConstants, 0, sizeof(FlashConstants));
+	FlashConstants[1][3] = 1.f;		// Always use alpha from palette (which is always 1, so meh)
+	FlashColor = 0;
+	FlashAmount = 0;
+
+	NeedGammaUpdate = false;
+	NeedPalUpdate = false;
+
+	if (MemBuffer == NULL)
+	{
+		return;
+	}
+
+	for (i = 0; i < 256; i++)
+	{
+		GammaTable[i] = i;
+	}
+	memcpy (SourcePalette, GPalette.BaseColors, sizeof(PalEntry)*256);
+
+	Windowed = !(static_cast<Win32Video *>(Video)->GoFullscreen (fullscreen));
+
+	TrueHeight = height;
+	if (fullscreen)
+	{
+		for (Win32Video::ModeInfo *mode = static_cast<Win32Video *>(Video)->m_Modes; mode != NULL; mode = mode->next)
+		{
+			if (mode->width == Width && mode->height == Height)
+			{
+				TrueHeight = mode->realheight;
+				break;
+			}
+		}
+	}
+
+	FillPresentParameters (&d3dpp, fullscreen, VSync);
+
+	HRESULT hr;
+
+	if (FAILED(hr = D3D->CreateDevice (D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, Window,
+		D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &D3DDevice)))
+	{
+		D3DDevice = NULL;
+		if (fullscreen)
+		{
+			d3dpp.BackBufferFormat = D3DFMT_R5G6B5;
+			if (FAILED(D3D->CreateDevice (D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, Window,
+				D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &D3DDevice)))
+			{
+				D3DDevice = NULL;
+			}
+		}
+	}
+	if (D3DDevice != NULL)
+	{
+		CreateResources ();
+		D3DDevice->Clear (0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,0), 1.f, 0);
+		D3DDevice->BeginScene();
+		D3DDevice->EndScene();
+		D3DDevice->Present(NULL, NULL, NULL, NULL);
+	}
+}
+
+D3DFB::~D3DFB ()
+{
+	ReleaseResources ();
+	if (D3DDevice != NULL)
+	{
+		// Do not release the D3DDevice in fullscreen mode.
+		D3DPRESENT_PARAMETERS d3dpp;
+		FillPresentParameters (&d3dpp, false, true);
+		//D3DDevice->Reset (&d3dpp);
+		D3DDevice->Release();
+		//Sleep (1000);
+	}
+}
+
+void D3DFB::FillPresentParameters (D3DPRESENT_PARAMETERS *pp, bool fullscreen, bool vsync)
+{
+	memset (pp, 0, sizeof(*pp));
+	pp->Windowed = !fullscreen;
+	pp->SwapEffect = D3DSWAPEFFECT_DISCARD;
+	pp->BackBufferWidth = Width;
+	pp->BackBufferHeight = TrueHeight;
+	pp->BackBufferFormat = fullscreen ? D3DFMT_X8R8G8B8 : D3DFMT_UNKNOWN;
+	pp->hDeviceWindow = Window;
+	pp->PresentationInterval = vsync ? D3DPRESENT_INTERVAL_ONE : D3DPRESENT_INTERVAL_IMMEDIATE;
+}
+
+bool D3DFB::CreateResources ()
+{
+	if (!Windowed)
+	{
+		ShowWindow (Window, SW_SHOW);
+		// Remove the window border in fullscreen mode
+		SetWindowLongPtr (Window, GWL_STYLE, WS_POPUP|WS_VISIBLE|WS_SYSMENU);
+	}
+	else
+	{
+		// Resize the window to match desired dimensions
+		int sizew = Width + GetSystemMetrics (SM_CXSIZEFRAME)*2;
+		int sizeh = Height + GetSystemMetrics (SM_CYSIZEFRAME) * 2 +
+					 GetSystemMetrics (SM_CYCAPTION);
+		LOG2 ("Resize window to %dx%d\n", sizew, sizeh);
+		VidResizing = true;
+		// Make sure the window has a border in windowed mode
+		SetWindowLongPtr (Window, GWL_STYLE, WS_VISIBLE|WS_OVERLAPPEDWINDOW);
+		if (!SetWindowPos (Window, NULL, 0, 0, sizew, sizeh,
+			SWP_DRAWFRAME | SWP_NOCOPYBITS | SWP_NOMOVE | SWP_NOZORDER))
+		{
+			LOG1 ("SetWindowPos failed because %08lx\n", GetLastError());
+		}
+		VidResizing = false;
+		ShowWindow (Window, SW_SHOWNORMAL);
+	}
+	if (FAILED(D3DDevice->CreatePixelShader (PalTexShaderDef, &PalTexShader)))
+	{
+		return false;
+	}
+	if (!CreateFBTexture() || !CreatePaletteTexture())
+	{
+		return false;
+	}
+	if (!CreateVertexes())
+	{
+		return false;
+	}
+	SetGamma (Gamma);
+	return true;
+}
+
+void D3DFB::ReleaseResources ()
+{
+	if (FBTexture != NULL)
+	{
+		FBTexture->Release();
+		FBTexture = NULL;
+	}
+	if (VertexBuffer != NULL)
+	{
+		VertexBuffer->Release();
+		VertexBuffer = NULL;
+	}
+	if (PaletteTexture != NULL)
+	{
+		PaletteTexture->Release();
+		PaletteTexture = NULL;
+	}
+	if (PalTexShader != NULL)
+	{
+		PalTexShader->Release();
+		PalTexShader = NULL;
+	}
+}
+
+bool D3DFB::Reset ()
+{
+	D3DPRESENT_PARAMETERS d3dpp;
+
+	// Free resources created with D3DPOOL_DEFAULT.
+	if (FBTexture != NULL)
+	{
+		FBTexture->Release();
+		FBTexture = NULL;
+	}
+	if (VertexBuffer != NULL)
+	{
+		VertexBuffer->Release();
+		VertexBuffer = NULL;
+	}
+	FillPresentParameters (&d3dpp, !Windowed, VSync);
+	if (!SUCCEEDED(D3DDevice->Reset (&d3dpp)))
+	{
+		return false;
+	}
+	if (!CreateFBTexture() || !CreateVertexes())
+	{
+		return false;
+	}
+	return true;
+}
+
+bool D3DFB::CreateFBTexture ()
+{
+	if (FAILED(D3DDevice->CreateTexture (Width, Height, 1, D3DUSAGE_DYNAMIC, D3DFMT_L8, D3DPOOL_DEFAULT, &FBTexture, NULL)))
+	{
+		int pow2width, pow2height, i;
+
+		for (i = 1; i < Width; i <<= 1) {} pow2width = i;
+		for (i = 1; i < Height; i <<= 1) {} pow2height = i;
+
+		if (FAILED(D3DDevice->CreateTexture (pow2width, pow2height, 1, D3DUSAGE_DYNAMIC, D3DFMT_L8, D3DPOOL_DEFAULT, &FBTexture, NULL)))
+		{
+			return false;
+		}
+		else
+		{
+			FBWidth = pow2width;
+			FBHeight = pow2height;
+		}
+	}
+	else
+	{
+		FBWidth = Width;
+		FBHeight = Height;
+	}
+	return true;
+}
+
+bool D3DFB::CreatePaletteTexture ()
+{
+	if (FAILED(D3DDevice->CreateTexture (256, 1, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &PaletteTexture, NULL)))
+	{
+		if (FAILED(D3DDevice->CreateTexture (256, 1, 1, 0, D3DFMT_R5G6B5, D3DPOOL_MANAGED, &PaletteTexture, NULL)))
+		{
+			return false;
+		}
+		else
+		{
+			PalFormat = D3DFMT_R5G6B5;
+		}
+	}
+	else
+	{
+		PalFormat = D3DFMT_A8R8G8B8;
+	}
+	return true;
+}
+
+bool D3DFB::CreateVertexes ()
+{
+	float top = (TrueHeight - Height) * 0.5f - 0.5f;
+	float right = float(Width) + 0.5f;
+	float bot = float(Height) + top + 1.f;
+	float texright = float(Width) / float(FBWidth);
+	float texbot = float(Height) / float(FBHeight);
+	FBVERTEX verts[4] =
+	{
+		{ -0.5f, top, 0.5f, 1.f,      0.f,    0.f },
+		{ right, top, 0.5f, 1.f, texright,    0.f },
+		{ right, bot, 0.5f, 1.f, texright, texbot },
+		{ -0.5f, bot, 0.5f, 1.f,      0.f, texbot }
+	};
+	void *pverts;
+
+	if (FAILED(D3DDevice->CreateVertexBuffer (sizeof(verts), D3DUSAGE_WRITEONLY, D3DFVF_FBVERTEX, D3DPOOL_DEFAULT, &VertexBuffer, NULL)) ||
+		FAILED(VertexBuffer->Lock (0, sizeof(verts), &pverts, 0)))
+	{
+		return false;
+	}
+	else
+	{
+		memcpy (pverts, verts, sizeof(verts));
+		VertexBuffer->Unlock();
+	}
+	return true;
+}
+
+int D3DFB::GetPageCount ()
+{
+	return 1;
+}
+
+void D3DFB::PaletteChanged ()
+{
+}
+
+int D3DFB::QueryNewPalette ()
+{
+	return 0;
+}
+
+bool D3DFB::IsValid ()
+{
+	return D3DDevice != NULL;
+}
+
+HRESULT D3DFB::GetHR ()
+{
+	return 0;
+}
+
+bool D3DFB::IsFullscreen ()
+{
+	return !Windowed;
+}
+
+bool D3DFB::Lock ()
+{
+	return Lock(true);
+}
+
+bool D3DFB::Lock (bool buffered)
+{
+	if (LockCount++ > 0)
+	{
+		return false;
+	}
+
+	Buffer = MemBuffer;
+	return false;
+}
+
+void D3DFB::Unlock ()
+{
+	LOG1 ("Unlock     <%d>\n", LockCount);
+
+	if (LockCount == 0)
+	{
+		return;
+	}
+
+	if (UpdatePending && LockCount == 1)
+	{
+		Update ();
+	}
+	else if (--LockCount == 0)
+	{
+		Buffer = NULL;
+	}
+}
+
+void D3DFB::Update ()
+{
+	bool pchanged = false;
+
+	LOG3 ("Update     <%d,%c:%d>\n", LockCount, AppActive?'Y':'N', SessionState);
+
+	if (LockCount != 1)
+	{
+		//I_FatalError ("Framebuffer must have exactly 1 lock to be updated");
+		if (LockCount > 0)
+		{
+			UpdatePending = true;
+			--LockCount;
+		}
+		return;
+	}
+
+	DrawRateStuff ();
+
+	if (NeedGammaUpdate)
+	{
+		NeedGammaUpdate = false;
+		CalcGamma (Gamma, GammaTable);
+		NeedPalUpdate = true;
+	}
+	
+	if (NeedPalUpdate)
+	{
+		UploadPalette();
+	}
+
+	BlitCycles = 0;
+	clock (BlitCycles);
+
+	LockCount = 0;
+	PaintToWindow ();
+
+	unclock (BlitCycles);
+	LOG1 ("cycles = %d\n", BlitCycles);
+
+	Buffer = NULL;
+	UpdatePending = false;
+}
+
+bool D3DFB::PaintToWindow ()
+{
+	D3DLOCKED_RECT lockrect;
+	HRESULT hr;
+
+	if (LockCount != 0)
+	{
+		return false;
+	}
+	hr = D3DDevice->TestCooperativeLevel();
+	if (FAILED(hr))
+	{
+		if (hr != D3DERR_DEVICENOTRESET || !Reset())
+		{
+			Sleep (1);
+			return false;
+		}
+	}
+	if (SUCCEEDED(FBTexture->LockRect (0, &lockrect, NULL, D3DLOCK_DISCARD)))
+	{
+		if (lockrect.Pitch == Pitch)
+		{
+			memcpy (lockrect.pBits, MemBuffer, Width * Height);
+		}
+		else
+		{
+			BYTE *dest = (BYTE *)lockrect.pBits;
+			BYTE *src = MemBuffer;
+			for (int y = 0; y < Height; y++)
+			{
+				memcpy (dest, src, Width);
+				dest += lockrect.Pitch;
+				src += Pitch;
+			}
+		}
+		FBTexture->UnlockRect (0);
+	}
+	if (TrueHeight != Height)
+	{
+		// Letterbox! Draw black top and bottom borders.
+		int topborder = (TrueHeight - Height) / 2;
+		D3DRECT rects[2] = { { 0, 0, Width, topborder }, { 0, Height + topborder, Width, TrueHeight } };
+		D3DDevice->Clear (2, rects, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,0), 1.f, 0);
+	}
+	D3DDevice->BeginScene();
+	D3DDevice->SetTexture (0, FBTexture);
+	D3DDevice->SetTexture (1, PaletteTexture);
+	D3DDevice->SetStreamSource (0, VertexBuffer, 0, sizeof(FBVERTEX));
+	D3DDevice->SetFVF (D3DFVF_FBVERTEX);
+	D3DDevice->SetPixelShader (PalTexShader);
+	D3DDevice->SetPixelShaderConstantF (0, FlashConstants[0], 2);
+	D3DDevice->DrawPrimitive (D3DPT_TRIANGLEFAN, 0, 2);
+	D3DDevice->EndScene();
+	return SUCCEEDED(D3DDevice->Present(NULL, NULL, NULL, NULL));
+}
+
+void D3DFB::UploadPalette ()
+{
+	D3DLOCKED_RECT lockrect;
+
+	if (SUCCEEDED(PaletteTexture->LockRect (0, &lockrect, NULL, 0)))
+	{
+		NeedPalUpdate = false;
+
+		if (PalFormat == D3DFMT_A8R8G8B8)
+		{
+			BYTE *pix = (BYTE *)lockrect.pBits;
+			for (int i = 0; i < 256; ++i, pix += 4)
+			{
+				pix[0] = GammaTable[SourcePalette[i].b];
+				pix[1] = GammaTable[SourcePalette[i].g];
+				pix[2] = GammaTable[SourcePalette[i].r];
+				pix[3] = 255;
+			}
+		}
+		else
+		{
+			WORD *pix = (WORD *)lockrect.pBits;
+			for (int i = 0; i < 256; ++i, ++pix)
+			{
+				*pix = ((GammaTable[SourcePalette[i].r] >> 3) << 11) |
+					   ((GammaTable[SourcePalette[i].g] >> 2) << 5) |
+					    (GammaTable[SourcePalette[i].b] >> 3);
+			}
+		}
+		PaletteTexture->UnlockRect (0);
+	}
+}
+
+PalEntry *D3DFB::GetPalette ()
+{
+	return SourcePalette;
+}
+
+void D3DFB::UpdatePalette ()
+{
+	NeedPalUpdate = true;
+}
+
+bool D3DFB::SetGamma (float gamma)
+{
+	LOG1 ("SetGamma %g\n", gamma);
+	Gamma = gamma;
+	NeedGammaUpdate = true;
+	return true;
+}
+
+bool D3DFB::SetFlash (PalEntry rgb, int amount)
+{
+	FlashColor = rgb;
+	FlashAmount = amount;
+
+	// Fill in the constants for the pixel shader to do linear interpolation between the palette and the flash:
+	float r = rgb.r / 255.f, g = rgb.g / 255.f, b = rgb.b / 255.f, a = amount / 256.f;
+	FlashConstants[0][0] = r * a;
+	FlashConstants[0][1] = g * a;
+	FlashConstants[0][2] = b * a;
+	a = 1 - a;
+	FlashConstants[1][0] = a;
+	FlashConstants[1][1] = a;
+	FlashConstants[1][2] = a;
+	return true;
+}
+
+void D3DFB::GetFlash (PalEntry &rgb, int &amount)
+{
+	rgb = FlashColor;
+	amount = FlashAmount;
+}
+
+void D3DFB::GetFlashedPalette (PalEntry pal[256])
+{
+	memcpy (pal, SourcePalette, 256*sizeof(PalEntry));
+	if (FlashAmount)
+	{
+		DoBlending (pal, pal, 256, FlashColor.r, FlashColor.g, FlashColor.b, FlashAmount);
+	}
+}
+
+void D3DFB::SetVSync (bool vsync)
+{
+	if (VSync != vsync)
+	{
+		VSync = vsync;
+		Reset();
+	}
+}
+
+void D3DFB::Blank ()
+{
+	// Only used by movie player, which isn't working with D3D9 yet.
+}

src/win32/win32iface.h

@@ -31,19 +31,32 @@
 **
 */
 
+#ifndef DIRECTDRAW_VERSION
+#define DIRECTDRAW_VERSION 0x0300
+#endif
+#ifndef DIRECT3D_VERSION
+#define DIRECT3D_VERSION 0x0900
+#endif
+
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #include <ddraw.h>
+#include <d3d9.h>
 
 #include "hardware.h"
 #include "v_video.h"
 
+EXTERN_CVAR (Bool, vid_vsync)
+
 class Win32Video : public IVideo
 {
  public:
 	Win32Video (int parm);
 	~Win32Video ();
 
+	bool InitD3D9();
+	void InitDDraw();
+
 	EDisplayType GetDisplayType () { return DISPLAY_Both; }
 	bool FullscreenChanged (bool fs);
 	void SetWindowedScale (float scale);
@@ -82,20 +95,24 @@ class Win32Video : public IVideo
 	void AddMode (int x, int y, int bits, int baseHeight);
 	void FreeModes ();
 
-	void NewDDMode (int x, int y);
 	static HRESULT WINAPI EnumDDModesCB (LPDDSURFACEDESC desc, void *modes);
+	void AddD3DModes (D3DFORMAT format);
+	void AddLetterboxModes ();
 
 	friend class DDrawFB;
+	friend class D3DFB;
 };
 
 class BaseWinFB : public DFrameBuffer
 {
+	DECLARE_ABSTRACT_CLASS(BaseWinFB, DFrameBuffer)
 public:
 	BaseWinFB (int width, int height) : DFrameBuffer (width, height), Windowed (true) {}
 
 	bool IsFullscreen () { return !Windowed; }
 	virtual void Blank () = 0;
 	virtual bool PaintToWindow () = 0;
+	virtual HRESULT GetHR () = 0;
 
 protected:
 	virtual bool CreateResources () = 0;
@@ -105,10 +122,13 @@ protected:
 
 	friend int I_PlayMovie (const char *name);
 	friend class Win32Video;
+
+	BaseWinFB() {}
 };
 
 class DDrawFB : public BaseWinFB
 {
+	DECLARE_CLASS(DDrawFB, BaseWinFB)
 public:
 	DDrawFB (int width, int height, bool fullscreen);
 	~DDrawFB ();
@@ -128,11 +148,11 @@ public:
 	int GetPageCount ();
 	int QueryNewPalette ();
 	void PaletteChanged ();
-	HRESULT GetHR () { return LastHR; }
+	void SetVSync (bool vsync);
+	HRESULT GetHR ();
 
 	void Blank ();
 	bool PaintToWindow ();
-	void DoSpeedTest ();
 
 private:
 	enum LockSurfRes { NoGood, Good, GoodWasLost };
@@ -152,6 +172,7 @@ private:
 	BYTE GammaTable[3][256];
 	PalEntry SourcePalette[256];
 	PALETTEENTRY PalEntries[256];
+	DWORD FlipFlags;
 
 	LPDIRECTDRAWPALETTE Palette;
 	LPDIRECTDRAWSURFACE PrimarySurf;
@@ -160,7 +181,6 @@ private:
 	LPDIRECTDRAWSURFACE BlitSurf;
 	LPDIRECTDRAWSURFACE LockingSurf;
 	LPDIRECTDRAWCLIPPER Clipper;
-	//IDirectDrawGammaControl *GammaControl;
 	HPALETTE GDIPalette;
 	BYTE *ClipRegion;
 	DWORD ClipSize;
@@ -181,4 +201,88 @@ private:
 	bool UpdatePending;		// On final unlock, call Update()
 	bool UseBlitter;		// Use blitter to copy from sys mem to video mem
 	bool UsePfx;
+
+	DDrawFB() {}
 };
+
+class D3DFB : public BaseWinFB
+{
+	DECLARE_CLASS(D3DFB, BaseWinFB)
+public:
+	D3DFB (int width, int height, bool fullscreen);
+	~D3DFB ();
+
+	bool IsValid ();
+	bool Lock ();
+	bool Lock (bool buffered);
+	void Unlock ();
+	void Update ();
+	PalEntry *GetPalette ();
+	void GetFlashedPalette (PalEntry palette[256]);
+	void UpdatePalette ();
+	bool SetGamma (float gamma);
+	bool SetFlash (PalEntry rgb, int amount);
+	void GetFlash (PalEntry &rgb, int &amount);
+	int GetPageCount ();
+	bool IsFullscreen ();
+	void PaletteChanged ();
+	int QueryNewPalette ();
+	void Blank ();
+	bool PaintToWindow ();
+	void SetVSync (bool vsync);
+	HRESULT GetHR ();
+
+private:
+	bool CreateResources();
+	void ReleaseResources();
+	bool CreateFBTexture();
+	bool CreatePaletteTexture();
+	bool CreateVertexes();
+	void UploadPalette();
+	void FillPresentParameters (D3DPRESENT_PARAMETERS *pp, bool fullscreen, bool vsync);
+	bool Reset();
+
+	BYTE GammaTable[256];
+	PalEntry SourcePalette[256];
+	float FlashConstants[2][4];
+	PalEntry FlashColor;
+	int FlashAmount;
+	int TrueHeight;
+	float Gamma;
+	bool UpdatePending;
+	bool NeedPalUpdate;
+	bool NeedGammaUpdate;
+	D3DFORMAT FBFormat;
+	D3DFORMAT PalFormat;
+	int FBWidth, FBHeight;
+	bool VSync;
+
+	IDirect3DDevice9 *D3DDevice;
+	IDirect3DVertexBuffer9 *VertexBuffer;
+	IDirect3DTexture9 *FBTexture;
+	IDirect3DTexture9 *PaletteTexture;
+	IDirect3DPixelShader9 *PalTexShader;
+
+	D3DFB() {}
+};
+
+#if 0
+#define STARTLOG		do { if (!dbg) dbg = fopen ("k:/vid.log", "w"); } while(0)
+#define STOPLOG			do { if (dbg) { fclose (dbg); dbg=NULL; } } while(0)
+#define LOG(x)			do { if (dbg) { fprintf (dbg, x); fflush (dbg); } } while(0)
+#define LOG1(x,y)		do { if (dbg) { fprintf (dbg, x, y); fflush (dbg); } } while(0)
+#define LOG2(x,y,z)		do { if (dbg) { fprintf (dbg, x, y, z); fflush (dbg); } } while(0)
+#define LOG3(x,y,z,zz)	do { if (dbg) { fprintf (dbg, x, y, z, zz); fflush (dbg); } } while(0)
+#define LOG4(x,y,z,a,b)	do { if (dbg) { fprintf (dbg, x, y, z, a, b); fflush (dbg); } } while(0)
+#define LOG5(x,y,z,a,b,c) do { if (dbg) { fprintf (dbg, x, y, z, a, b, c); fflush (dbg); } } while(0)
+FILE *dbg;
+#else
+#define STARTLOG
+#define STOPLOG
+#define LOG(x)
+#define LOG1(x,y)
+#define LOG2(x,y,z)
+#define LOG3(x,y,z,zz)
+#define LOG4(x,y,z,a,b)
+#define LOG5(x,y,z,a,b,c)
+#endif

zdoom.vcproj

@@ -5040,6 +5040,14 @@
 				RelativePath="src\win32\eaxedit.cpp"
 				>
 			</File>
+			<File
+				RelativePath=".\src\win32\fb_d3d9.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\src\win32\fb_ddraw.cpp"
+				>
+			</File>
 			<File
 				RelativePath=".\src\win32\hardware.cpp"
 				>