pcsx2/plugins/zzogl-pg/opengl/ZZoglVB.cpp

/*  ZZ Open GL graphics plugin
 *  Copyright (c)2009 zeydlitz@gmail.com
 *  Based on Zerofrog's ZeroGS KOSMOS (c)2005-2006
 *
 *  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 of the License, 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 this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

// Zerogs:VB implementation.
// VB stands for Visual Buffer, as I think

//------------------- Includes
#include "zerogs.h"
#include "targets.h"
#include "GS.h"
#include "Mem.h"

using namespace ZeroGS;
// ----------------- Defines
#define MINMAX_SHIFT	3

//------------------ Constants

// ----------------- Global Variables
int maxmin = 608;
// ----------------- Code

// Constructor. Set width and height to 1
ZeroGS::VB::VB()
{
	memset(this, 0, sizeof(ZeroGS::VB));
	tex0.tw = 1;
	tex0.th = 1;
}

// Destructor
ZeroGS::VB::~VB()
{
	Destroy();
}

void ZeroGS::VB::Destroy()
{
	_aligned_free(pBufferData);
	pBufferData = NULL;
	nNumVertices = 0;

	prndr = NULL;
	pdepth = NULL;
}

int ConstraintReason;

// Return number of 64-pixels block, that guaranted could be hold in memory
// from gsfb.fbp and tbp (textrure pase), zbuf.zbp (Z-buffer), frame.fbp
// (previous frame).
inline int ZeroGS::VB::FindMinimalMemoryConstrain(int tbp, int maxpos)
{
	int MinConstraint = maxpos;

	// make sure texture is far away from tbp
	{
		int Constraint = tbp - gsfb.fbp;

		if ((0 < Constraint) && (Constraint < MinConstraint))
		{
			MinConstraint = Constraint;
			ConstraintReason = 1;
		}
	}

	// offroad uses 0x80 fbp which messes up targets
	// special case when double buffering (hamsterball)
	// Suikoden 3 require e00 have this issue too. P3 - 0x1000.

	if (prndr != NULL)
	{
		int Constraint = frame.fbp - gsfb.fbp;

		if ((0x0 < Constraint) && (Constraint < MinConstraint))
		{
			MinConstraint = Constraint;
			ConstraintReason = 2;
		}
	}

	// old caching method
	// zmsk necessary for KH movie
	if (!zbuf.zmsk)
	{
		int Constraint = zbuf.zbp - gsfb.fbp;

		if ((0 < Constraint) && (Constraint < MinConstraint))
		{
			MinConstraint = Constraint;
			ConstraintReason = 3;
		}
	}

	// In 16Bit mode in one Word frame stored 2 pixels
	if (PSMT_ISHALF(gsfb.psm)) MinConstraint *= 2;

	return MinConstraint ;
}

// Return number of 64 pizel words that could be placed in Z-Buffer
// If no Z-buffer present return old constraint
inline int ZeroGS::VB::FindZbufferMemoryConstrain(int tbp, int maxpos)
{
	int MinConstraint = maxpos;

	// Check tbp / zbuffer constraint
	if (!zbuf.zmsk)
	{
		int Constraint = (tbp - zbuf.zbp) * (PSMT_ISHALF(zbuf.psm) ? 2 : 1);

		if ((0 < Constraint) && (Constraint < MinConstraint))
		{
			MinConstraint = Constraint;
			ConstraintReason = 4;
		}
	}

	return MinConstraint;
}

// Return heights limiter from scissor...
inline int GetScissorY(int y)
{
	int fbh = (y >> MINMAX_SHIFT) + 1;

	if (fbh > 2 && (fbh & 1)) fbh -= 1;

	return fbh;
}

//There is several reasons to limit a height of frame: maximum buffer size, calculated size
//from fbw and fbh and scissoring.
inline int ZeroGS::VB::FindMinimalHeightConstrain(int maxpos)
{
	int MinConstraint = maxpos;

	if (maxmin < MinConstraint)
	{
		MinConstraint = maxmin;
		ConstraintReason = 5;
	}

	if (gsfb.fbh < MinConstraint)
	{
		MinConstraint = gsfb.fbh;
		ConstraintReason = 6;
	}

	int ScissorConstraint = GetScissorY(scissor.y1) ;

	if (ScissorConstraint < MinConstraint)
	{
		MinConstraint = ScissorConstraint;
		ConstraintReason = 7;
	}

	return MinConstraint;
}

// 32 bit frames have additional constraints to frame
// maxpos was maximum length of frame at normal constraints
inline void ZeroGS::VB::CheckFrame32bitRes(int maxpos)
{
	int fbh = frame.fbh;

	if (frame.fbh >= 512)
	{
		// neopets hack
		maxmin = min(maxmin, frame.fbh);
		frame.fbh = maxmin;
		ConstraintReason = 8;
	}

	// ffxii hack to stop resolving
	if (frame.fbp >= 0x3000 && fbh >= 0x1a0)
	{
		int endfbp = frame.fbp + frame.fbw * fbh / (PSMT_ISHALF(gsfb.psm) ? 128 : 64);

		// see if there is a previous render target in the way, reduce

		for (CRenderTargetMngr::MAPTARGETS::iterator itnew = s_RTs.mapTargets.begin(); itnew != s_RTs.mapTargets.end(); ++itnew)
		{
			if (itnew->second->fbp > frame.fbp && endfbp > itnew->second->fbp)
			{
				endfbp = itnew->second->fbp;
			}
		}

		frame.fbh = (endfbp - frame.fbp) * (PSMT_ISHALF(gsfb.psm) ? 128 :  64) / frame.fbw;

		if (frame.fbh < fbh) ConstraintReason = 9;
	}

}

// This is the main code for frame resizing.
// It checks for several reasons to resize and resizes if it needs to.
// 4Mb memory in 64 bit (4 bytes) words.
// |------------------------|---------------------|----------|----------|---------------------|
// 0                     gsfb.fbp               zbuff.zpb   tbp    frame.fbp              2^20/64
inline int ZeroGS::VB::CheckFrameAddConstraints(int tbp)
{
	if (gsfb.fbw <= 0)
	{
		ERROR_LOG_SPAM("render target null, no constraints. Ignoring\n");
		return -1;
	}

	// Memory region after fbp
	int maxmemorypos = 0x4000 - gsfb.fbp;

	ConstraintReason = 0;

	maxmemorypos = FindMinimalMemoryConstrain(tbp, maxmemorypos);
	maxmemorypos = FindZbufferMemoryConstrain(tbp, maxmemorypos);

	int maxpos = 64 * maxmemorypos ;

	maxpos /= gsfb.fbw;

	//? atelier iris crashes without it
	if (maxpos > 256) maxpos &= ~0x1f;

#ifdef DEVBUILD
	int noscissorpos = maxpos;
	int ConstrainR1 = ConstraintReason;
#endif

	maxpos = FindMinimalHeightConstrain(maxpos);

	frame = gsfb;
	frame.fbh = maxpos;

	if (!PSMT_ISHALF(frame.psm) || !(conf.settings().full_16_bit_res)) CheckFrame32bitRes(maxpos);

#ifdef DEVBUILD
	if (frame.fbh == 0xe2)
		ZZLog::Debug_Log("Const: %x %x %d| %x %d %x %x", frame.fbh, frame.fbw, ConstraintReason, noscissorpos, ConstrainR1, tbp, frame.fbp);
#endif

// 	Fixme: Reserved psm for framebuffers
//	gsfb.psm &= 0xf; // shadow tower

	return 0;
}

// Check if after resizing new depth target is needed to be used.
// it returns 2 if a new depth target is used. 
inline int ZeroGS::VB::CheckFrameResolveDepth(int tbp)
{
	int result = 0;
	CDepthTarget* pprevdepth = pdepth;
	pdepth = NULL;

	// just z changed
	frameInfo f = CreateFrame(zbuf.zbp, prndr->fbw, prndr->fbh, zbuf.psm, (zbuf.psm == 0x31) ? 0xff000000 : 0);

	CDepthTarget* pnewdepth = (CDepthTarget*)s_DepthRTs.GetTarg(f, CRenderTargetMngr::TO_DepthBuffer | CRenderTargetMngr::TO_StrictHeight |
							  (zbuf.zmsk ? CRenderTargetMngr::TO_Virtual : 0), get_maxheight(zbuf.zbp, gsfb.fbw, 0));

	assert(pnewdepth != NULL && prndr != NULL);
	if (pnewdepth->fbh != prndr->fbh) ZZLog::Debug_Log("pnewdepth->fbh(0x%x) != prndr->fbh(0x%x)", pnewdepth->fbh, prndr->fbh);
	//assert(pnewdepth->fbh == prndr->fbh);

	if ((pprevdepth != pnewdepth) || (pprevdepth != NULL && (pprevdepth->status & CRenderTarget::TS_NeedUpdate)))
		result = 2;

	pdepth = pnewdepth;

	return result;
}

// Check if after resizing, a new render target is needed to be used. Also perform deptarget check.
// Returns 1 if only 1 render target is changed and 3 -- if both.
inline int ZeroGS::VB::CheckFrameResolveRender(int tbp)
{
	int result = 0;

	CRenderTarget* pprevrndr = prndr;
	prndr = NULL;
	CDepthTarget* pprevdepth = pdepth;
	pdepth = NULL;
	// Set renderes to NULL to prevent Flushing.

	CRenderTarget* pnewtarg = s_RTs.GetTarg(frame, 0, maxmin);
	assert(pnewtarg != NULL);

	// pnewtarg->fbh >= 0x1c0 needed for ffx

	if ((pnewtarg->fbh >= 0x1c0) && pnewtarg->fbh > frame.fbh && zbuf.zbp < tbp && !zbuf.zmsk)
	{
		// check if zbuf is in the way of the texture (suikoden5)
		int maxallowedfbh = (tbp - zbuf.zbp) * (PSMT_ISHALF(zbuf.psm) ? 128 : 64) / gsfb.fbw;

		if (PSMT_ISHALF(gsfb.psm)) maxallowedfbh *= 2;

		if (pnewtarg->fbh > maxallowedfbh + 32)   // +32 needed for ffx2
		{
			// destroy and recreate
			s_RTs.DestroyAllTargs(0, 0x100, pnewtarg->fbw);
			pnewtarg = s_RTs.GetTarg(frame, 0, maxmin);
			assert(pnewtarg != NULL);
		}
	}

	ZZLog::Prim_Log("frame_%d: fbp=0x%x fbw=%d fbh=%d(%d) psm=0x%x fbm=0x%x\n", ictx, gsfb.fbp, gsfb.fbw, gsfb.fbh, pnewtarg->fbh, gsfb.psm, gsfb.fbm);

	if ((pprevrndr != pnewtarg) || (pprevrndr != NULL && (pprevrndr->status & CRenderTarget::TS_NeedUpdate)))
		result = 1;

	prndr = pnewtarg;

	pdepth = pprevdepth;

	result |= CheckFrameResolveDepth(tbp);

	return result;
}

// After frame resetting, it is possible that 16 to 32 or 32 to 16 (color bits) conversion should be made.
inline void ZeroGS::VB::CheckFrame16vs32Conversion()
{
	if (prndr->status & CRenderTarget::TS_NeedConvert32)
	{
		if (pdepth->pdepth != 0) pdepth->SetDepthStencilSurface();

		prndr->fbh *= 2;
		prndr->ConvertTo32();
		prndr->status &= ~CRenderTarget::TS_NeedConvert32;
	}
	else if (prndr->status & CRenderTarget::TS_NeedConvert16)
	{
		if (pdepth->pdepth != 0) pdepth->SetDepthStencilSurface();

		prndr->fbh /= 2;
		prndr->ConvertTo16();
		prndr->status &= ~CRenderTarget::TS_NeedConvert16;
	}
}

// A lot of times, the target is too big and overwrites the texture.
// If tbp != 0, use it to bound.
void ZeroGS::VB::CheckFrame(int tbp)
{
	GL_REPORT_ERRORD();
	
	static int bChanged;

	if (bNeedZCheck)
	{
		ZZLog::Prim_Log("zbuf_%d: zbp=0x%x psm=0x%x, zmsk=%d\n", ictx, zbuf.zbp, zbuf.psm, zbuf.zmsk);
		//zbuf = *zb;
	}

	if (m_Blocks[gsfb.psm].bpp == 0)
	{
		ZZLog::Error_Log("CheckFrame invalid bpp %d.", gsfb.psm);
		return;
	}

	bChanged = 0;

	if (bNeedFrameCheck)
	{
		// important to set before calling GetTarg
		bNeedFrameCheck = 0;
		bNeedZCheck = 0;

		if (CheckFrameAddConstraints(tbp) == -1) return;

		if ((prndr != NULL) && (prndr->psm != gsfb.psm))
		{
			// behavior for dest alpha varies
			ResetAlphaVariables();
		}

		bChanged = CheckFrameResolveRender(tbp);

		CheckFrame16vs32Conversion();
	}
	else if (bNeedZCheck)
	{
		bNeedZCheck = 0;

		if (prndr != NULL && gsfb.fbw > 0) CheckFrameResolveDepth(tbp);
	}

	if (prndr != NULL) SetContextTarget(ictx);
	GL_REPORT_ERRORD();
}

// This is the case, most easy to perform, when nothing was changed
inline void ZeroGS::VB::FlushTexUnchangedClutDontUpdate()
{
	if (ZZOglGet_cld_TexBits(uNextTex0Data[1]))
	{
		ZeroGS::texClutWrite(ictx);
		// invalidate to make sure target didn't change!
		bVarsTexSync = false;
	}
}

// The second of easy branch. We does not change storage model, so we don't need to
// update anything except texture itself
inline void ZeroGS::VB::FlushTexClutDontUpdate()
{
	if (!ZZOglClutStorageUnchanged(uCurTex0Data, uNextTex0Data)) ZeroGS::Flush(ictx);

	// clut memory isn't going to be loaded so can ignore, but at least update CSA and CPSM!
	uCurTex0Data[1] = (uCurTex0Data[1] & CPSM_CSA_NOTMASK) | (uNextTex0Data[1] & CPSM_CSA_BITMASK);

	tex0.csa  = ZZOglGet_csa_TexBits(uNextTex0Data[1]);
	tex0.cpsm = ZZOglGet_cpsm_TexBits(uNextTex0Data[1]);

	ZeroGS::texClutWrite(ictx);

	bVarsTexSync = false;
}


// Set texture variables after big change
inline void ZeroGS::VB::FlushTexSetNewVars(u32 psm)
{
	tex0.tbp0 = ZZOglGet_tbp0_TexBits(uNextTex0Data[0]);
	tex0.tbw  = ZZOglGet_tbw_TexBitsMult(uNextTex0Data[0]);
	tex0.psm  = psm;
	tex0.tw   = ZZOglGet_tw_TexBitsExp(uNextTex0Data[0]);
	tex0.th   = ZZOglGet_th_TexBitsExp(uNextTex0Data[0], uNextTex0Data[1]);

	tex0.tcc  = ZZOglGet_tcc_TexBits(uNextTex0Data[1]);
	tex0.tfx  = ZZOglGet_tfx_TexBits(uNextTex0Data[1]);

	ZeroGS::fiTexWidth[ictx] = (1 / 16.0f) / tex0.tw;
	ZeroGS::fiTexHeight[ictx] = (1 / 16.0f) / tex0.th;
}

// Flush == draw on screen
// This function made VB state consistant before real Flush.
void ZeroGS::VB::FlushTexData()
{
	GL_REPORT_ERRORD();
	
	assert(bNeedTexCheck);
	bNeedTexCheck = 0;

	u32 psm = ZZOglGet_psm_TexBitsFix(uNextTex0Data[0]);

	// don't update unless necessary

	if (ZZOglAllExceptClutIsSame(uCurTex0Data, uNextTex0Data))
	{
		// Don't need to do anything if there is no clutting and VB tex data was not changed
		if (!PSMT_ISCLUT(psm)) return;

		// have to write the CLUT again if only CLD was changed
		if (ZZOglClutMinusCLDunchanged(uCurTex0Data, uNextTex0Data))
		{
			FlushTexUnchangedClutDontUpdate();
			return;
		}

		// Cld bit is 0 means that clut buffer stay unchanged
		if (ZZOglGet_cld_TexBits(uNextTex0Data[1]) == 0)
		{
			FlushTexClutDontUpdate();
			return;
		}
	}

	// Made the full update
	ZeroGS::Flush(ictx);

	bVarsTexSync = false;
	bTexConstsSync = false;

	uCurTex0Data[0] = uNextTex0Data[0];
	uCurTex0Data[1] = uNextTex0Data[1];

	FlushTexSetNewVars(psm);

	if (PSMT_ISCLUT(psm)) ZeroGS::CluttingForFlushedTex(&tex0, uNextTex0Data[1], ictx) ;
	GL_REPORT_ERRORD();
}