/* ZeroGS KOSMOS * Copyright (C) 2005-2006 zerofrog@gmail.com * * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */ #ifndef __ZEROGS_TARGETS_H__ #define __ZEROGS_TARGETS_H__ #define TARGET_VIRTUAL_KEY 0x80000000 #include "PS2Edefs.h" inline Vector DefaultOneColor(FRAGMENTSHADER ptr) { Vector v = Vector(1, 1, 1, 1); cgGLSetParameter4fv(ptr.sOneColor, v); return v ; } namespace ZeroGS { inline u32 GetFrameKey(int fbp, int fbw, VB& curvb); // manages render targets class CRenderTargetMngr { public: typedef map MAPTARGETS; enum TargetOptions { TO_DepthBuffer = 1, TO_StrictHeight = 2, // height returned has to be the same as requested TO_Virtual = 4 }; ~CRenderTargetMngr() { Destroy(); } void Destroy(); static MAPTARGETS::iterator GetOldestTarg(MAPTARGETS& m); CRenderTarget* GetTarg(const frameInfo& frame, u32 Options, int maxposheight); inline CRenderTarget* GetTarg(int fbp, int fbw, VB& curvb) { MAPTARGETS::iterator it = mapTargets.find(GetFrameKey(fbp, fbw, curvb)); /* if (fbp == 0x3600 && fbw == 0x100 && it == mapTargets.end()) { printf("%x\n", GetFrameKey(fbp, fbw, curvb)) ; printf("%x %x\n", fbp, fbw); for(MAPTARGETS::iterator it1 = mapTargets.begin(); it1 != mapTargets.end(); ++it1) printf ("\t %x %x %x %x\n", it1->second->fbw, it1->second->fbh, it1->second->psm, it1->second->fbp); }*/ return it != mapTargets.end() ? it->second : NULL; } // gets all targets with a range void GetTargs(int start, int end, list& listTargets) const; // resolves all targets within a range __forceinline void Resolve(int start, int end); __forceinline void ResolveAll() { for (MAPTARGETS::iterator it = mapTargets.begin(); it != mapTargets.end(); ++it) it->second->Resolve(); } void DestroyAllTargs(int start, int end, int fbw); void DestroyIntersecting(CRenderTarget* prndr); // promotes a target from virtual to real inline CRenderTarget* Promote(u32 key) { assert(!(key & TARGET_VIRTUAL_KEY)); // promote to regular targ CRenderTargetMngr::MAPTARGETS::iterator it = mapTargets.find(key | TARGET_VIRTUAL_KEY); assert(it != mapTargets.end()); CRenderTarget* ptarg = it->second; mapTargets.erase(it); DestroyIntersecting(ptarg); it = mapTargets.find(key); if (it != mapTargets.end()) { DestroyTarg(it->second); it->second = ptarg; } else mapTargets[key] = ptarg; if (conf.settings().resolve_promoted) ptarg->status = CRenderTarget::TS_Resolved; else ptarg->status = CRenderTarget::TS_NeedUpdate; return ptarg; } static void DestroyTarg(CRenderTarget* ptarg); void PrintTargets(); MAPTARGETS mapTargets, mapDummyTargs; }; class CMemoryTargetMngr { public: CMemoryTargetMngr() : curstamp(0) {} CMemoryTarget* GetMemoryTarget(const tex0Info& tex0, int forcevalidate); // pcbp is pointer to start of clut CMemoryTarget* MemoryTarget_SearchExistTarget(int start, int end, int nClutOffset, int clutsize, const tex0Info& tex0, int forcevalidate); CMemoryTarget* MemoryTarget_ClearedTargetsSearch(int fmt, int widthmult, int channels, int height); void Destroy(); // destroy all targs void ClearRange(int starty, int endy); // set all targets to cleared void DestroyCleared(); // flush all cleared targes void DestroyOldest(); list listTargets, listClearedTargets; u32 curstamp; private: list::iterator DestroyTargetIter(list::iterator& it); }; class CBitwiseTextureMngr { public: ~CBitwiseTextureMngr() { Destroy(); } void Destroy(); // since GetTex can delete textures to free up mem, it is dangerous if using that texture, so specify at least one other tex to save __forceinline u32 GetTex(u32 bitvalue, u32 ptexDoNotDelete) { map::iterator it = mapTextures.find(bitvalue); if (it != mapTextures.end()) return it->second; return GetTexInt(bitvalue, ptexDoNotDelete); } private: u32 GetTexInt(u32 bitvalue, u32 ptexDoNotDelete); map mapTextures; }; // manages class CRangeManager { public: CRangeManager() { ranges.reserve(16); } // [start, end) struct RANGE { RANGE() {} inline RANGE(int start, int end) : start(start), end(end) {} int start, end; }; // works in semi logN void Insert(int start, int end); void RangeSanityCheck(); inline void Clear() { ranges.resize(0); } vector ranges; // organized in ascending order, non-intersecting }; extern CRenderTargetMngr s_RTs, s_DepthRTs; extern CBitwiseTextureMngr s_BitwiseTextures; extern CMemoryTargetMngr g_MemTargs; extern u8 s_AAx, s_AAy, s_AAz, s_AAw; // Real rendered width, depends on AA and AAneg. inline int RW(int tbw) { if (s_AAx >= s_AAz) return (tbw << (s_AAx - s_AAz)); else return (tbw >> (s_AAz - s_AAx)); } // Real rendered height, depends on AA and AAneg. inline int RH(int tbh) { if (s_AAy >= s_AAw) return (tbh << (s_AAy - s_AAw)); else return (tbh >> (s_AAw - s_AAy)); } /* inline void CreateTargetsList(int start, int end, list& listTargs) { s_DepthRTs.GetTargs(start, end, listTargs); s_RTs.GetTargs(start, end, listTargs); }*/ // This pattern of functions is called 3 times, so I add creating Targets list into one. inline list CreateTargetsList(int start, int end) { list listTargs; s_DepthRTs.GetTargs(start, end, listTargs); s_RTs.GetTargs(start, end, listTargs); return listTargs; } extern Vector g_vdepth; extern int icurctx; extern VERTEXSHADER pvsBitBlt; extern FRAGMENTSHADER ppsBitBlt[2], ppsBitBltDepth, ppsOne; extern FRAGMENTSHADER ppsBaseTexture, ppsConvert16to32, ppsConvert32to16; extern GLuint vboRect; // Unworking #define PSMPOSITION 28 // Code width and height of frame into key, that used in targetmanager // This is 3 variants of one function, Key dependant on fbp and fbw. inline u32 GetFrameKey(const frameInfo& frame) { return (((frame.fbw) << 16) | (frame.fbp)); } inline u32 GetFrameKey(CRenderTarget* frame) { return (((frame->fbw) << 16) | (frame->fbp)); } inline u32 GetFrameKey(int fbp, int fbw, VB& curvb) { return (((fbw) << 16) | (fbp)); } inline u16 ShiftHeight(int fbh, int fbp, int fbhCalc) { return fbh; } //#define FRAME_KEY_BY_FBH //FIXME: this code is for P4 and KH1. It should not be so strange! //Dummy targets was deleted from mapTargets, but not erased. inline u32 GetFrameKeyDummy(int fbp, int fbw, int fbh, int psm) { // if (fbp > 0x2000 && ZZOgl_fbh_Calc(fbp, fbw, psm) < 0x400 && ZZOgl_fbh_Calc(fbp, fbw, psm) != fbh) // ZZLog::Debug_Log("Z %x %x %x %x\n", fbh, fbhCalc, fbp, ZZOgl_fbh_Calc(fbp, fbw, psm)); // height over 1024 would shrink to 1024, so dummy targets with calculated size more than 0x400 should be // distinct by real height. But in FFX there is 3e0 height target, so I put 0x300 as limit. #ifndef FRAME_KEY_BY_FBH int calc = ZZOgl_fbh_Calc(fbp, fbw, psm); if (/*fbp > 0x2000 && */calc < /*0x300*/0x2E0) return ((fbw << 16) | calc); else #endif return ((fbw << 16) | fbh); } inline u32 GetFrameKeyDummy(const frameInfo& frame) { return GetFrameKeyDummy(frame.fbp, frame.fbw, frame.fbh, frame.psm); } inline u32 GetFrameKeyDummy(CRenderTarget* frame) { return GetFrameKeyDummy(frame->fbp, frame->fbw, frame->fbh, frame->psm); } } // End of namespace #include "Mem.h" static __forceinline void DrawTriangleArray() { glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); GL_REPORT_ERRORD(); } static __forceinline void DrawBuffers(GLenum *buffer) { if (glDrawBuffers != NULL) { glDrawBuffers(1, buffer); } GL_REPORT_ERRORD(); } static __forceinline void FBTexture(int attach, int id = 0) { glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT + attach, GL_TEXTURE_RECTANGLE_NV, id, 0); GL_REPORT_ERRORD(); } static __forceinline void Texture2D(GLint iFormat, GLint width, GLint height, GLenum format, GLenum type, const GLvoid* pixels) { glTexImage2D(GL_TEXTURE_2D, 0, iFormat, width, height, 0, format, type, pixels); } static __forceinline void Texture2D(GLint iFormat, GLenum format, GLenum type, const GLvoid* pixels) { glTexImage2D(GL_TEXTURE_2D, 0, iFormat, BLOCK_TEXWIDTH, BLOCK_TEXHEIGHT, 0, format, type, pixels); } static __forceinline void Texture3D(GLint iFormat, GLint width, GLint height, GLint depth, GLenum format, GLenum type, const GLvoid* pixels) { glTexImage3D(GL_TEXTURE_3D, 0, iFormat, width, height, depth, 0, format, type, pixels); } static __forceinline void TextureRect(GLint iFormat, GLint width, GLint height, GLenum format, GLenum type, const GLvoid* pixels) { glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, iFormat, width, height, 0, format, type, pixels); } static __forceinline void TextureRect(GLenum attach, GLuint id = 0) { glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, attach, GL_RENDERBUFFER_EXT, id); } static __forceinline void setTex2DFilters(GLint type) { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, type); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, type); } static __forceinline void setTex2DWrap(GLint type) { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, type); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, type); } static __forceinline void setTex3DFilters(GLint type) { glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, type); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, type); } static __forceinline void setTex3DWrap(GLint type) { glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, type); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, type); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, type); } static __forceinline void setRectFilters(GLint type) { glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, type); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, type); } static __forceinline void setRectWrap(GLint type) { glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, type); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, type); } #endif