pcsx2/plugins/GSdx/GPURenderer.h

400 lines
7.5 KiB
C
Raw Normal View History

/*
* Copyright (C) 2007-2009 Gabest
* http://www.gabest.org
*
* This Program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This Program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Make; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
* http://www.gnu.org/copyleft/gpl.html
*
*/
#pragma once
#include "GPUState.h"
#include "GSVertexList.h"
struct GPURendererSettings
{
int m_filter;
int m_dither;
int m_aspectratio;
bool m_vsync;
CSize m_scale;
};
class GPURendererBase : public GPUState, protected GPURendererSettings
{
protected:
HWND m_hWnd;
WNDPROC m_wndproc;
static CAtlMap<HWND, GPURendererBase*> m_wnd2gpu;
static LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
if(CAtlMap<HWND, GPURendererBase*>::CPair* pair = m_wnd2gpu.Lookup(hWnd))
{
return pair->m_value->OnMessage(message, wParam, lParam);
}
ASSERT(0);
return 0;
}
LRESULT OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
{
if(message == WM_KEYUP)
{
if(wParam == VK_DELETE)
{
m_filter = (m_filter + 1) % 3;
return 0;
}
if(wParam == VK_END)
{
m_dither = m_dither ? 0 : 1;
return 0;
}
if(wParam == VK_NEXT)
{
m_aspectratio = (m_aspectratio + 1) % 3;
return 0;
}
}
return m_wndproc(m_hWnd, message, wParam, lParam);
}
public:
GPURendererBase(const GPURendererSettings& rs)
: GPUState(rs.m_scale)
, m_hWnd(NULL)
, m_wndproc(NULL)
{
m_filter = rs.m_filter;
m_dither = rs.m_dither;
m_aspectratio = rs.m_aspectratio;
m_vsync = rs.m_vsync;
m_scale = m_mem.GetScale();
}
virtual ~GPURendererBase()
{
if(m_wndproc)
{
SetWindowLongPtr(m_hWnd, GWLP_WNDPROC, (LONG_PTR)m_wndproc);
m_wnd2gpu.RemoveKey(m_hWnd);
}
}
virtual bool Create(HWND hWnd)
{
m_hWnd = hWnd;
m_wndproc = (WNDPROC)GetWindowLongPtr(hWnd, GWLP_WNDPROC);
SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR)WndProc);
m_wnd2gpu.SetAt(hWnd, this);
DWORD style = GetWindowLong(hWnd, GWL_STYLE);
style |= WS_OVERLAPPEDWINDOW;
SetWindowLong(hWnd, GWL_STYLE, style);
UpdateWindow(hWnd);
ShowWindow(hWnd, SW_SHOWNORMAL);
return true;
}
virtual void VSync() = 0;
virtual bool MakeSnapshot(LPCTSTR path) = 0;
};
template<class Device, class Vertex>
class GPURenderer : public GPURendererBase
{
protected:
typedef typename Device::Texture Texture;
Vertex* m_vertices;
int m_count;
int m_maxcount;
GSVertexList<Vertex> m_vl;
void Reset()
{
m_count = 0;
m_vl.RemoveAll();
__super::Reset();
}
void VertexKick()
{
if(m_vl.GetCount() < m_env.PRIM.VTX)
{
return;
}
if(m_count > m_maxcount)
{
m_maxcount = max(10000, m_maxcount * 3/2);
m_vertices = (Vertex*)_aligned_realloc(m_vertices, sizeof(Vertex) * m_maxcount, 16);
m_maxcount -= 100;
}
Vertex* v = &m_vertices[m_count];
int count = 0;
switch(m_env.PRIM.TYPE)
{
case GPU_POLYGON:
m_vl.GetAt(0, v[0]);
m_vl.GetAt(1, v[1]);
m_vl.GetAt(2, v[2]);
m_vl.RemoveAll();
count = 3;
break;
case GPU_LINE:
m_vl.GetAt(0, v[0]);
m_vl.GetAt(1, v[1]);
m_vl.RemoveAll();
count = 2;
break;
case GPU_SPRITE:
m_vl.GetAt(0, v[0]);
m_vl.GetAt(1, v[1]);
m_vl.RemoveAll();
count = 2;
break;
default:
ASSERT(0);
m_vl.RemoveAll();
count = 0;
break;
}
(this->*m_fpDrawingKickHandlers[m_env.PRIM.TYPE])(v, count);
m_count += count;
}
typedef void (GPURenderer<Device, Vertex>::*DrawingKickHandler)(Vertex* v, int& count);
DrawingKickHandler m_fpDrawingKickHandlers[4];
void DrawingKickNull(Vertex* v, int& count)
{
ASSERT(0);
}
void ResetPrim()
{
m_vl.RemoveAll();
}
void FlushPrim()
{
if(m_count > 0)
{
/*
Dump(_T("db"));
if(m_env.PRIM.TME)
{
CRect r;
r.left = m_env.STATUS.TX << 6;
r.top = m_env.STATUS.TY << 8;
r.right = r.left + 256;
r.bottom = r.top + 256;
CString str;
str.Format(_T("da_%d_%d_%d_%d_%d"), m_env.STATUS.TP, r);
Dump(str, m_env.STATUS.TP, r, false);
}
*/
Draw();
m_count = 0;
//Dump(_T("dc"), false);
}
}
virtual void ResetDevice() {}
virtual void Draw() = 0;
virtual bool GetOutput(Texture& t) = 0;
bool Merge()
{
Texture st[2];
if(!GetOutput(st[0]))
{
return false;
}
CSize s;
s.cx = st[0].GetWidth();
s.cy = st[0].GetHeight();
GSVector4 sr[2];
sr[0].x = 0;
sr[0].y = 0;
sr[0].z = 1.0f;
sr[0].w = 1.0f;
GSVector4 dr[2];
dr[0].x = 0;
dr[0].y = 0;
dr[0].z = (float)s.cx;
dr[0].w = (float)s.cy;
GSVector4 c(0, 0, 0, 1);
m_dev.Merge(st, sr, dr, s, 1, 1, c);
return true;
}
public:
Device m_dev;
public:
GPURenderer(const GPURendererSettings& rs)
: GPURendererBase(rs)
, m_count(0)
, m_maxcount(10000)
{
m_vertices = (Vertex*)_aligned_malloc(sizeof(Vertex) * m_maxcount, 16);
m_maxcount -= 100;
for(int i = 0; i < countof(m_fpDrawingKickHandlers); i++)
{
m_fpDrawingKickHandlers[i] = &GPURenderer<Device, Vertex>::DrawingKickNull;
}
}
virtual ~GPURenderer()
{
if(m_vertices) _aligned_free(m_vertices);
}
virtual bool Create(HWND hWnd)
{
if(!__super::Create(hWnd))
{
return false;
}
if(!m_dev.Create(hWnd, m_vsync))
{
return false;
}
Reset();
return true;
}
virtual void VSync()
{
GSPerfMonAutoTimer pmat(m_perfmon);
// m_env.STATUS.LCF = ~m_env.STATUS.LCF; // ?
if(!IsWindow(m_hWnd))
{
return;
}
Flush();
m_perfmon.Put(GSPerfMon::Frame);
if(!Merge())
{
return;
}
// osd
static UINT64 s_frame = 0;
static CString s_stats;
if(m_perfmon.GetFrame() - s_frame >= 30)
{
m_perfmon.Update();
s_frame = m_perfmon.GetFrame();
double fps = 1000.0f / m_perfmon.Get(GSPerfMon::Frame);
CRect r = m_env.GetDisplayRect();
int w = r.Width() << m_scale.cx;
int h = r.Height() << m_scale.cy;
s_stats.Format(
_T("%I64d | %d x %d | %.2f fps (%d%%) | %d/%d | %d%% CPU | %.2f | %.2f"),
m_perfmon.GetFrame(), w, h, fps, (int)(100.0 * fps / m_env.GetFPS()),
(int)m_perfmon.Get(GSPerfMon::Prim),
(int)m_perfmon.Get(GSPerfMon::Draw),
m_perfmon.CPU(),
m_perfmon.Get(GSPerfMon::Swizzle) / 1024,
m_perfmon.Get(GSPerfMon::Unswizzle) / 1024
);
double fillrate = m_perfmon.Get(GSPerfMon::Fillrate);
if(fillrate > 0)
{
s_stats.Format(_T("%s | %.2f mpps"), CString(s_stats), fps * fillrate / (1024 * 1024));
}
SetWindowText(m_hWnd, s_stats);
}
if(m_dev.IsLost())
{
ResetDevice();
}
CRect r;
GetClientRect(m_hWnd, &r);
GSUtil::FitRect(r, m_aspectratio);
m_dev.Present(r);
}
virtual bool MakeSnapshot(LPCTSTR path)
{
CString fn;
fn.Format(_T("%s_%s"), path, CTime::GetCurrentTime().Format(_T("%Y%m%d%H%M%S")));
return m_dev.SaveCurrent(fn + _T(".bmp"));
}
};