mirror of https://github.com/ZDoom/qzdoom.git
SVN r383 (trunk)
This commit is contained in:
Randy Heit
parent
99fe466b57
commit
93b18c3bfa
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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
|
||||
//
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -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
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -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"
|
||||
>
|
||||
|
|
|
|||
Loading…
Reference in New Issue