mirror of https://github.com/PCSX2/pcsx2.git
437 lines
9.1 KiB
C++
437 lines
9.1 KiB
C++
/*
|
|
* 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
|
|
*
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
#include "GSDeviceSW.h"
|
|
|
|
GSDeviceSW::GSDeviceSW()
|
|
{
|
|
}
|
|
|
|
bool GSDeviceSW::Create(GSWnd* wnd)
|
|
{
|
|
if(!GSDevice::Create(wnd))
|
|
return false;
|
|
|
|
Reset(1, 1);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool GSDeviceSW::Reset(int w, int h)
|
|
{
|
|
if(!GSDevice::Reset(w, h))
|
|
return false;
|
|
|
|
// TODO: m_backbuffer should be a window wrapper, or some native bitmap, software-only StretchRect to a full screen window may be too slow
|
|
|
|
m_backbuffer = new GSTextureSW(GSTexture::RenderTarget, w, h);
|
|
|
|
return true;
|
|
}
|
|
|
|
GSTexture* GSDeviceSW::CreateSurface(int type, int w, int h, bool msaa, int format)
|
|
{
|
|
if(format != 0) return false; // there is only one format
|
|
|
|
return new GSTextureSW(type, w, h);
|
|
}
|
|
|
|
void GSDeviceSW::BeginScene()
|
|
{
|
|
// TODO
|
|
}
|
|
|
|
void GSDeviceSW::DrawPrimitive()
|
|
{
|
|
// TODO
|
|
}
|
|
|
|
void GSDeviceSW::EndScene()
|
|
{
|
|
// TODO
|
|
}
|
|
|
|
void GSDeviceSW::ClearRenderTarget(GSTexture* t, const GSVector4& c)
|
|
{
|
|
Clear(t, (c * 255 + 0.5f).rgba32());
|
|
}
|
|
|
|
void GSDeviceSW::ClearRenderTarget(GSTexture* t, uint32 c)
|
|
{
|
|
Clear(t, c);
|
|
}
|
|
|
|
void GSDeviceSW::ClearDepth(GSTexture* t, float c)
|
|
{
|
|
Clear(t, *(uint32*)&c);
|
|
}
|
|
|
|
void GSDeviceSW::ClearStencil(GSTexture* t, uint8 c)
|
|
{
|
|
Clear(t, c);
|
|
}
|
|
|
|
GSTexture* GSDeviceSW::CopyOffscreen(GSTexture* src, const GSVector4& sr, int w, int h, int format)
|
|
{
|
|
GSTexture* dst = CreateOffscreen(w, h, format);
|
|
|
|
if(dst != NULL)
|
|
{
|
|
CopyRect(src, dst, GSVector4i(0, 0, w, h));
|
|
}
|
|
|
|
return dst;
|
|
}
|
|
|
|
void GSDeviceSW::CopyRect(GSTexture* st, GSTexture* dt, const GSVector4i& r)
|
|
{
|
|
GSTexture::GSMap m;
|
|
|
|
if(st->Map(m, &r))
|
|
{
|
|
dt->Update(r, m.bits, m.pitch);
|
|
|
|
st->Unmap();
|
|
}
|
|
}
|
|
|
|
class ShaderBase
|
|
{
|
|
protected:
|
|
GSVector4i Sample(const GSVector4i& c, const GSVector4i& uf, const GSVector4i& vf)
|
|
{
|
|
GSVector4i c0 = c.upl8();
|
|
GSVector4i c1 = c.uph8();
|
|
|
|
c0 = c0.lerp16<0>(c1, vf);
|
|
c0 = c0.lerp16<0>(c0.srl<8>(), uf);
|
|
|
|
return c0;
|
|
}
|
|
|
|
GSVector4i Blend(const GSVector4i& c0, const GSVector4i& c1)
|
|
{
|
|
return c0.lerp16<0>(c1, c1.wwwwl().sll16(7));
|
|
}
|
|
|
|
GSVector4i Blend2x(const GSVector4i& c0, const GSVector4i& c1)
|
|
{
|
|
return c0.lerp16<0>(c1, c1.wwwwl().sll16(1).pu16().uph8().sll16(7)); // .sll16(1).pu16() => 2x, then clamp (...)
|
|
}
|
|
|
|
GSVector4i Blend(const GSVector4i& c0, const GSVector4i& c1, const GSVector4i& f)
|
|
{
|
|
return c0.lerp16<0>(c1, f);
|
|
}
|
|
};
|
|
|
|
class ShaderCopy : public ShaderBase
|
|
{
|
|
public:
|
|
void operator() (uint32* RESTRICT dst, const GSVector4i& c, const GSVector4i& uf, const GSVector4i& vf)
|
|
{
|
|
*dst = Sample(c, uf, vf).pu16().extract32<0>();
|
|
}
|
|
|
|
void operator() (uint32* RESTRICT dst, uint32 c)
|
|
{
|
|
*dst = c;
|
|
}
|
|
};
|
|
|
|
class ShaderAlphaBlend : public ShaderBase
|
|
{
|
|
public:
|
|
void operator() (uint32* RESTRICT dst, const GSVector4i& c, const GSVector4i& uf, const GSVector4i& vf)
|
|
{
|
|
*dst = Blend(Sample(c, uf, vf), GSVector4i(*dst).uph8()).pu16().extract32<0>();
|
|
}
|
|
|
|
void operator() (uint32* RESTRICT dst, uint32 c)
|
|
{
|
|
*dst = Blend(GSVector4i(c), GSVector4i(*dst).uph8()).pu16().extract32<0>();
|
|
}
|
|
};
|
|
|
|
class ShaderAlpha2xBlend : public ShaderBase
|
|
{
|
|
public:
|
|
void operator() (uint32* RESTRICT dst, const GSVector4i& c, const GSVector4i& uf, const GSVector4i& vf)
|
|
{
|
|
*dst = Blend2x(Sample(c, uf, vf), GSVector4i(*dst).uph8()).pu16().extract32<0>();
|
|
}
|
|
|
|
void operator() (uint32* RESTRICT dst, uint32 c)
|
|
{
|
|
*dst = Blend2x(GSVector4i(c), GSVector4i(*dst).uph8()).pu16().extract32<0>();
|
|
}
|
|
};
|
|
|
|
__aligned(class, 16) ShaderFactorBlend : public ShaderBase
|
|
{
|
|
GSVector4i m_f;
|
|
|
|
public:
|
|
ShaderFactorBlend(uint32 f)
|
|
{
|
|
m_f = GSVector4i((f << 16) | f).xxxx().srl16(1);
|
|
}
|
|
|
|
void operator() (uint32* RESTRICT dst, const GSVector4i& c, const GSVector4i& uf, const GSVector4i& vf)
|
|
{
|
|
*dst = Blend(Sample(c, uf, vf), GSVector4i(*dst).uph8(), m_f).pu16().extract32<0>();
|
|
}
|
|
|
|
void operator() (uint32* RESTRICT dst, uint32 c)
|
|
{
|
|
*dst = Blend(GSVector4i(c), GSVector4i(*dst).uph8(), m_f).pu16().extract32<0>();
|
|
}
|
|
};
|
|
|
|
template<class SHADER> static void StretchRect(GSTexture* st, const GSVector4& sr, GSTexture* dt, const GSVector4& dr, SHADER shader, bool linear)
|
|
{
|
|
GSVector4i r(dr.ceil());
|
|
|
|
r = r.rintersect(GSVector4i(dt->GetSize()).zwxy());
|
|
|
|
if(r.rempty()) return;
|
|
|
|
GSTexture::GSMap dm;
|
|
|
|
if(!dt->Map(dm, &r)) return;
|
|
|
|
GSTexture::GSMap sm;
|
|
|
|
if(!st->Map(sm, NULL)) {dt->Unmap(); return;}
|
|
|
|
GSVector2i ssize = st->GetSize();
|
|
|
|
GSVector4 p = dr;
|
|
GSVector4 t = sr * GSVector4(ssize).xyxy() * GSVector4((float)0x10000);
|
|
|
|
GSVector4 tl = p.xyxy(t);
|
|
GSVector4 br = p.zwzw(t);
|
|
GSVector4 tlbr = br - tl;
|
|
|
|
tlbr /= tlbr.xyxy();
|
|
|
|
if(tl.x < (float)r.left) tl.z += tlbr.z * ((float)r.left - tl.x);
|
|
if(tl.y < (float)r.top) tl.w += tlbr.w * ((float)r.top - tl.y);
|
|
|
|
GSVector4i uvdudv(tl.zwzw(tlbr));
|
|
|
|
GSVector4i uv = uvdudv.xxyy() + GSVector4i(0, 0x10000).xyxy();
|
|
GSVector4i du = uvdudv.zzzz().srl<8>();
|
|
GSVector4i dv = uvdudv.wwww().sll<8>();
|
|
|
|
// TODO: clipping may not be that necessary knowing we don't address outside (except the linear filter +1 pixel)
|
|
|
|
GSVector4i uvmax = GSVector4i((ssize.x - 1) << 16, (ssize.y - 1) << 16).xxyy();
|
|
|
|
GSVector4i v = uv;
|
|
|
|
if(linear)
|
|
{
|
|
for(int j = r.height(); j > 0; j--, v += dv, dm.bits += dm.pitch)
|
|
{
|
|
GSVector4i vf = v.zzwwh().zzww().srl16(1);
|
|
GSVector4i vi = v.max_i16(GSVector4i::zero()).min_i16(uvmax);
|
|
|
|
int v0 = vi.extract16<5>();
|
|
int v1 = vi.extract16<7>();
|
|
|
|
uint32* RESTRICT src0 = (uint32*)&sm.bits[v0 * sm.pitch];
|
|
uint32* RESTRICT src1 = (uint32*)&sm.bits[v1 * sm.pitch];
|
|
uint32* RESTRICT dst = (uint32*)dm.bits;
|
|
|
|
GSVector4i u = v;
|
|
|
|
for(int i = r.width(); i > 0; i--, dst++, u += du)
|
|
{
|
|
GSVector4i uf = u.xxyyh().xxyy().srl16(1);
|
|
GSVector4i ui = u.max_i16(GSVector4i::zero()).min_i16(uvmax);
|
|
|
|
int u0 = ui.extract16<1>();
|
|
int u1 = ui.extract16<3>();
|
|
|
|
shader(dst, GSVector4i(src0[u0], src0[u1], src1[u0], src1[u1]), uf, vf);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(int j = r.height(); j > 0; j--, v += dv, dm.bits += dm.pitch)
|
|
{
|
|
GSVector4i vi = v.max_i16(GSVector4i::zero()).min_i16(uvmax);
|
|
|
|
uint32* RESTRICT src = (uint32*)&sm.bits[vi.extract16<5>() * sm.pitch];
|
|
uint32* RESTRICT dst = (uint32*)dm.bits;
|
|
|
|
GSVector4i u = v;
|
|
|
|
for(int i = r.width(); i > 0; i--, dst++, u += du)
|
|
{
|
|
GSVector4i ui = u.max_i16(GSVector4i::zero()).min_i16(uvmax);
|
|
|
|
shader(dst, src[ui.extract16<1>()]);
|
|
}
|
|
}
|
|
}
|
|
|
|
st->Unmap();
|
|
dt->Unmap();
|
|
}
|
|
|
|
void GSDeviceSW::StretchRect(GSTexture* st, const GSVector4& sr, GSTexture* dt, const GSVector4& dr, int shader, bool linear)
|
|
{
|
|
// TODO: if dt == m_backbuffer && m_backbuffer is special
|
|
|
|
if(shader == 0)
|
|
{
|
|
if((sr == GSVector4(0, 0, 1, 1) & dr == GSVector4(dt->GetSize()).zwxy()).alltrue() && st->GetSize() == dt->GetSize())
|
|
{
|
|
// shortcut
|
|
|
|
CopyRect(st, dt, GSVector4i(dt->GetSize()).zwxy());
|
|
|
|
return;
|
|
}
|
|
|
|
ShaderCopy s;
|
|
|
|
::StretchRect(st, sr, dt, dr, s, linear);
|
|
}
|
|
else if(shader == 1)
|
|
{
|
|
ShaderAlphaBlend s;
|
|
|
|
::StretchRect(st, sr, dt, dr, s, linear);
|
|
}
|
|
else
|
|
{
|
|
ASSERT(0);
|
|
}
|
|
}
|
|
|
|
void GSDeviceSW::PSSetShaderResources(GSTexture* sr0, GSTexture* sr1)
|
|
{
|
|
// TODO
|
|
}
|
|
|
|
void GSDeviceSW::PSSetShaderResource(int i, GSTexture* sr)
|
|
{
|
|
// TODO
|
|
}
|
|
|
|
void GSDeviceSW::OMSetRenderTargets(GSTexture* rt, GSTexture* ds, const GSVector4i* scissor)
|
|
{
|
|
// TODO
|
|
}
|
|
|
|
//
|
|
|
|
void GSDeviceSW::DoMerge(GSTexture* st[2], GSVector4* sr, GSTexture* dt, GSVector4* dr, bool slbg, bool mmod, const GSVector4& c)
|
|
{
|
|
ClearRenderTarget(dt, c);
|
|
|
|
if(st[1] && !slbg)
|
|
{
|
|
StretchRect(st[1], sr[1], dt, dr[1]);
|
|
}
|
|
|
|
if(st[0])
|
|
{
|
|
if(mmod == 0)
|
|
{
|
|
// alpha = min(st[0].a * 2, 1)
|
|
|
|
ShaderAlpha2xBlend s;
|
|
|
|
::StretchRect(st[0], sr[0], dt, dr[0], s, true);
|
|
}
|
|
else
|
|
{
|
|
// alpha = c.a
|
|
|
|
ShaderFactorBlend s((uint32)(int)(c.a * 255));
|
|
|
|
::StretchRect(st[0], sr[0], dt, dr[0], s, true);
|
|
}
|
|
}
|
|
|
|
// dt->Save("c:\\1.bmp");
|
|
}
|
|
|
|
void GSDeviceSW::DoInterlace(GSTexture* st, GSTexture* dt, int shader, bool linear, float yoffset)
|
|
{
|
|
GSVector4 s = GSVector4(dt->GetSize());
|
|
|
|
GSVector4 sr(0, 0, 1, 1);
|
|
GSVector4 dr(0.0f, yoffset, s.x, s.y + yoffset);
|
|
|
|
if(shader == 0 || shader == 1)
|
|
{
|
|
// TODO: 0/1 => update even/odd lines of dt
|
|
}
|
|
else if(shader == 2)
|
|
{
|
|
// TODO: blend lines (1:2:1 filter)
|
|
}
|
|
else if(shader == 3)
|
|
{
|
|
StretchRect(st, sr, dt, dr, 0, linear);
|
|
}
|
|
else
|
|
{
|
|
ASSERT(0);
|
|
}
|
|
}
|
|
|
|
void GSDeviceSW::Clear(GSTexture* t, uint32 c)
|
|
{
|
|
int w = t->GetWidth();
|
|
int h = t->GetHeight();
|
|
|
|
GSTexture::GSMap m;
|
|
|
|
if(t->Map(m, NULL))
|
|
{
|
|
GSVector4i v((int)c);
|
|
|
|
w >>= 2;
|
|
|
|
for(int j = 0; j < h; j++, m.bits += m.pitch)
|
|
{
|
|
GSVector4i* RESTRICT dst = (GSVector4i*)m.bits;
|
|
|
|
for(int i = 0; i < w; i += 2)
|
|
{
|
|
dst[i + 0] = v;
|
|
dst[i + 1] = v;
|
|
}
|
|
}
|
|
|
|
t->Unmap();
|
|
}
|
|
}
|
|
|