mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2025-07-24 14:49:42 -06:00
Aligned all vertex components to 4 byte boundaries - maybe ATI likes that? Renamed and reorganized misc things.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@981 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
hrydgard
@ -52,13 +52,17 @@ static const GLenum glSrcFactors[8] =
|
||||
|
||||
static const GLenum glDestFactors[8] = {
|
||||
GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR,
|
||||
GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA };
|
||||
GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA
|
||||
};
|
||||
|
||||
static const GLenum glCmpFuncs[8] = { GL_NEVER, GL_LESS, GL_EQUAL, GL_LEQUAL, GL_GREATER, GL_NOTEQUAL, GL_GEQUAL, GL_ALWAYS };
|
||||
static const GLenum glCmpFuncs[8] = {
|
||||
GL_NEVER, GL_LESS, GL_EQUAL, GL_LEQUAL, GL_GREATER, GL_NOTEQUAL, GL_GEQUAL, GL_ALWAYS
|
||||
};
|
||||
|
||||
static const GLenum glLogicOpCodes[16] = {
|
||||
GL_CLEAR, GL_SET, GL_COPY, GL_COPY_INVERTED, GL_NOOP, GL_INVERT, GL_AND, GL_NAND,
|
||||
GL_OR, GL_NOR, GL_XOR, GL_EQUIV, GL_AND_REVERSE, GL_AND_INVERTED, GL_OR_REVERSE, GL_OR_INVERTED };
|
||||
GL_OR, GL_NOR, GL_XOR, GL_EQUIV, GL_AND_REVERSE, GL_AND_INVERTED, GL_OR_REVERSE, GL_OR_INVERTED
|
||||
};
|
||||
|
||||
void BPInit()
|
||||
{
|
||||
@ -88,7 +92,7 @@ void BPWritten(int addr, int changes, int newval)
|
||||
// none, ccw, cw, ccw
|
||||
if (bpmem.genMode.cullmode>0) {
|
||||
glEnable(GL_CULL_FACE);
|
||||
glFrontFace(bpmem.genMode.cullmode==2?GL_CCW:GL_CW);
|
||||
glFrontFace(bpmem.genMode.cullmode == 2 ? GL_CCW : GL_CW);
|
||||
}
|
||||
else glDisable(GL_CULL_FACE);
|
||||
|
||||
@ -256,7 +260,7 @@ void BPWritten(int addr, int changes, int newval)
|
||||
glBlendFunc(glSrcFactors[bpmem.blendmode.srcfactor], glDestFactors[bpmem.blendmode.dstfactor]);
|
||||
}
|
||||
if (changes & 0x800) {
|
||||
glBlendEquation(bpmem.blendmode.subtract?GL_FUNC_REVERSE_SUBTRACT:GL_FUNC_ADD);
|
||||
glBlendEquation(bpmem.blendmode.subtract ? GL_FUNC_REVERSE_SUBTRACT : GL_FUNC_ADD);
|
||||
if (bpmem.blendmode.subtract)
|
||||
glBlendFunc(GL_ONE, GL_ONE);
|
||||
else
|
||||
@ -269,7 +273,7 @@ void BPWritten(int addr, int changes, int newval)
|
||||
break;
|
||||
|
||||
case BPMEM_FOGRANGE:
|
||||
if(changes) {
|
||||
if (changes) {
|
||||
// TODO(XK): Fog range format
|
||||
//glFogi(GL_FOG_START, ...
|
||||
//glFogi(GL_FOG_END, ...
|
||||
@ -474,25 +478,25 @@ void BPWritten(int addr, int changes, int newval)
|
||||
|
||||
VertexShaderMngr::SetViewportChanged();
|
||||
|
||||
// since clear operations use the source rectangle, have to do regular renders (glClear clears the entire buffer)
|
||||
if (bpmem.blendmode.colorupdate || bpmem.blendmode.alphaupdate || bpmem.zmode.updateenable) {
|
||||
|
||||
// Since clear operations use the source rectangle, we have to do
|
||||
// regular renders (glClear clears the entire buffer)
|
||||
if (bpmem.blendmode.colorupdate || bpmem.blendmode.alphaupdate || bpmem.zmode.updateenable)
|
||||
{
|
||||
GLbitfield bits = 0;
|
||||
if (bpmem.blendmode.colorupdate || bpmem.blendmode.alphaupdate) {
|
||||
u32 clearColor = (bpmem.clearcolorAR<<16)|bpmem.clearcolorGB;
|
||||
glClearColor(((clearColor>>16)&0xff)*(1/255.0f),((clearColor>>8)&0xff)*(1/255.0f),
|
||||
((clearColor>>0)&0xff)*(1/255.0f),((clearColor>>24)&0xff)*(1/255.0f));
|
||||
u32 clearColor = (bpmem.clearcolorAR << 16) | bpmem.clearcolorGB;
|
||||
glClearColor(((clearColor>>16) & 0xff)*(1/255.0f),
|
||||
((clearColor>>8 ) & 0xff)*(1/255.0f),
|
||||
((clearColor>>0 ) & 0xff)*(1/255.0f),
|
||||
((clearColor>>24) & 0xff)*(1/255.0f));
|
||||
bits |= GL_COLOR_BUFFER_BIT;
|
||||
}
|
||||
|
||||
if (bpmem.zmode.updateenable) {
|
||||
glClearDepth((float)(bpmem.clearZValue&0xFFFFFF) / float(0xFFFFFF));
|
||||
bits |= GL_DEPTH_BUFFER_BIT;
|
||||
}
|
||||
|
||||
if (nRestoreZBufferTarget )
|
||||
glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT); // don't clear ztarget here
|
||||
|
||||
glClear(bits);
|
||||
}
|
||||
|
||||
@ -500,12 +504,12 @@ void BPWritten(int addr, int changes, int newval)
|
||||
|
||||
glDrawBuffer(GL_COLOR_ATTACHMENT1_EXT);
|
||||
GL_REPORT_ERRORD();
|
||||
|
||||
glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
|
||||
|
||||
// red should probably be the LSB
|
||||
glClearColor(((bpmem.clearZValue>>0)&0xff)*(1/255.0f),((bpmem.clearZValue>>8)&0xff)*(1/255.0f),
|
||||
((bpmem.clearZValue>>16)&0xff)*(1/255.0f), 0);
|
||||
glClearColor(((bpmem.clearZValue>>0)&0xff)*(1/255.0f),
|
||||
((bpmem.clearZValue>>8)&0xff)*(1/255.0f),
|
||||
((bpmem.clearZValue>>16)&0xff)*(1/255.0f), 0);
|
||||
glClear(GL_COLOR_BUFFER_BIT);
|
||||
SetColorMask();
|
||||
GL_REPORT_ERRORD();
|
||||
@ -547,7 +551,7 @@ void BPWritten(int addr, int changes, int newval)
|
||||
{
|
||||
VertexManager::Flush();
|
||||
((u32*)&bpmem)[addr] = newval;
|
||||
PixelShaderMngr::SetTevOrderChanged(addr-0x28);
|
||||
PixelShaderMngr::SetTevOrderChanged(addr - 0x28);
|
||||
}
|
||||
break;
|
||||
|
||||
|
||||
@ -75,9 +75,8 @@ void NativeVertexFormat::Initialize(const TVtxDesc &vtx_desc, const TVtxAttr &vt
|
||||
DVSTARTPROFILE();
|
||||
|
||||
if (m_VBVertexStride & 3) {
|
||||
// make sure all strides are at least divisible by 4 (some gfx cards experience a 3x speed boost)
|
||||
m_VBStridePad = 4 - (m_VBVertexStride & 3);
|
||||
m_VBVertexStride += m_VBStridePad;
|
||||
// We will not allow vertex components causing uneven strides.
|
||||
PanicAlert("Uneven vertex stride: %i", m_VBVertexStride);
|
||||
}
|
||||
|
||||
// compile the pointer set function - why?
|
||||
@ -86,9 +85,9 @@ void NativeVertexFormat::Initialize(const TVtxDesc &vtx_desc, const TVtxAttr &vt
|
||||
Util::EmitPrologue(6);
|
||||
int offset = 0;
|
||||
|
||||
// Position
|
||||
// Position, part 1
|
||||
if (vtx_desc.Position != NOT_PRESENT) { // TODO: Why the check? Always present, AFAIK!
|
||||
CallCdeclFunction4_I(glVertexPointer, 3, GL_FLOAT, m_VBVertexStride, offset);
|
||||
CallCdeclFunction4_I(glVertexPointer, 3, GL_FLOAT, m_VBVertexStride, 0);
|
||||
offset += 12;
|
||||
}
|
||||
|
||||
@ -97,18 +96,18 @@ void NativeVertexFormat::Initialize(const TVtxDesc &vtx_desc, const TVtxAttr &vt
|
||||
switch (vtx_attr.NormalFormat) {
|
||||
case FORMAT_UBYTE:
|
||||
case FORMAT_BYTE:
|
||||
CallCdeclFunction3_I(glNormalPointer, GL_BYTE, m_VBVertexStride, offset); offset += 3;
|
||||
CallCdeclFunction3_I(glNormalPointer, GL_BYTE, m_VBVertexStride, offset); offset += 4;
|
||||
if (vtx_attr.NormalElements) {
|
||||
CallCdeclFunction6((void *)glVertexAttribPointer, SHADER_NORM1_ATTRIB, 3, GL_BYTE, GL_TRUE, m_VBVertexStride, offset); offset += 3;
|
||||
CallCdeclFunction6((void *)glVertexAttribPointer, SHADER_NORM2_ATTRIB, 3, GL_BYTE, GL_TRUE, m_VBVertexStride, offset); offset += 3;
|
||||
CallCdeclFunction6((void *)glVertexAttribPointer, SHADER_NORM1_ATTRIB, 4, GL_BYTE, GL_TRUE, m_VBVertexStride, offset); offset += 4;
|
||||
CallCdeclFunction6((void *)glVertexAttribPointer, SHADER_NORM2_ATTRIB, 4, GL_BYTE, GL_TRUE, m_VBVertexStride, offset); offset += 4;
|
||||
}
|
||||
break;
|
||||
case FORMAT_USHORT:
|
||||
case FORMAT_SHORT:
|
||||
CallCdeclFunction3_I(glNormalPointer, GL_SHORT, m_VBVertexStride, offset); offset += 6;
|
||||
CallCdeclFunction3_I(glNormalPointer, GL_SHORT, m_VBVertexStride, offset); offset += 8;
|
||||
if (vtx_attr.NormalElements) {
|
||||
CallCdeclFunction6((void *)glVertexAttribPointer, SHADER_NORM1_ATTRIB, 3, GL_SHORT, GL_TRUE, m_VBVertexStride, offset); offset += 6;
|
||||
CallCdeclFunction6((void *)glVertexAttribPointer, SHADER_NORM2_ATTRIB, 3, GL_SHORT, GL_TRUE, m_VBVertexStride, offset); offset += 6;
|
||||
CallCdeclFunction6((void *)glVertexAttribPointer, SHADER_NORM1_ATTRIB, 4, GL_SHORT, GL_TRUE, m_VBVertexStride, offset); offset += 8;
|
||||
CallCdeclFunction6((void *)glVertexAttribPointer, SHADER_NORM2_ATTRIB, 4, GL_SHORT, GL_TRUE, m_VBVertexStride, offset); offset += 8;
|
||||
}
|
||||
break;
|
||||
case FORMAT_FLOAT:
|
||||
@ -164,19 +163,19 @@ void NativeVertexFormat::Initialize(const TVtxDesc &vtx_desc, const TVtxAttr &vt
|
||||
}
|
||||
else {
|
||||
CallCdeclFunction4_I(glTexCoordPointer, 3, GL_SHORT, m_VBVertexStride, offset);
|
||||
offset += 6;
|
||||
offset += 8;
|
||||
}
|
||||
}
|
||||
else {
|
||||
CallCdeclFunction4_I(glTexCoordPointer, vtx_attr.texCoord[i].Elements ? 2 : 1, GL_FLOAT, m_VBVertexStride, offset);
|
||||
offset += 4 * (vtx_attr.texCoord[i].Elements?2:1);
|
||||
offset += 4 * (vtx_attr.texCoord[i].Elements ? 2 : 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (vtx_desc.PosMatIdx) {
|
||||
CallCdeclFunction6((void *)glVertexAttribPointer, SHADER_POSMTX_ATTRIB, 1, GL_UNSIGNED_BYTE, GL_FALSE, m_VBVertexStride, offset);
|
||||
offset += 1;
|
||||
CallCdeclFunction6((void *)glVertexAttribPointer, SHADER_POSMTX_ATTRIB, 4, GL_UNSIGNED_BYTE, GL_FALSE, m_VBVertexStride, offset);
|
||||
offset += 4;
|
||||
}
|
||||
|
||||
_assert_(offset + m_VBStridePad == m_VBVertexStride);
|
||||
|
||||
@ -224,22 +224,22 @@ static void Decode()
|
||||
static u32 pData[16];
|
||||
for (int i = 0; i < dwTransferSize; i++)
|
||||
pData[i] = DataReadU32();
|
||||
VertexShaderMngr::LoadXFReg(dwTransferSize, dwAddress, pData);
|
||||
LoadXFReg(dwTransferSize, dwAddress, pData);
|
||||
INCSTAT(stats.thisFrame.numXFLoads);
|
||||
}
|
||||
break;
|
||||
|
||||
case GX_LOAD_INDX_A: //used for position matrices
|
||||
VertexShaderMngr::LoadIndexedXF(DataReadU32(), 0xC);
|
||||
LoadIndexedXF(DataReadU32(), 0xC);
|
||||
break;
|
||||
case GX_LOAD_INDX_B: //used for normal matrices
|
||||
VertexShaderMngr::LoadIndexedXF(DataReadU32(), 0xD);
|
||||
LoadIndexedXF(DataReadU32(), 0xD);
|
||||
break;
|
||||
case GX_LOAD_INDX_C: //used for postmatrices
|
||||
VertexShaderMngr::LoadIndexedXF(DataReadU32(), 0xE);
|
||||
LoadIndexedXF(DataReadU32(), 0xE);
|
||||
break;
|
||||
case GX_LOAD_INDX_D: //used for lights
|
||||
VertexShaderMngr::LoadIndexedXF(DataReadU32(), 0xF);
|
||||
LoadIndexedXF(DataReadU32(), 0xF);
|
||||
break;
|
||||
|
||||
case GX_CMD_CALL_DL:
|
||||
|
||||
@ -67,28 +67,32 @@ const GLint c_MinLinearFilter[8] = {
|
||||
|
||||
const GLint c_WrapSettings[4] = { GL_CLAMP_TO_EDGE, GL_REPEAT, GL_MIRRORED_REPEAT, GL_REPEAT };
|
||||
|
||||
void TextureMngr::TCacheEntry::SetTextureParameters(TexMode0& newmode)
|
||||
void TextureMngr::TCacheEntry::SetTextureParameters(TexMode0 &newmode)
|
||||
{
|
||||
mode = newmode;
|
||||
if( isNonPow2 ) {
|
||||
if (isNonPow2) {
|
||||
// very limited!
|
||||
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, (newmode.mag_filter||g_Config.bForceFiltering)?GL_LINEAR:GL_NEAREST);
|
||||
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, (g_Config.bForceFiltering||newmode.min_filter>=4)?GL_LINEAR:GL_NEAREST);
|
||||
if( newmode.wrap_s == 2 || newmode.wrap_t == 2 ) {
|
||||
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
|
||||
(newmode.mag_filter || g_Config.bForceFiltering) ? GL_LINEAR : GL_NEAREST);
|
||||
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
|
||||
(g_Config.bForceFiltering || newmode.min_filter >= 4) ? GL_LINEAR : GL_NEAREST);
|
||||
if (newmode.wrap_s == 2 || newmode.wrap_t == 2) {
|
||||
DEBUG_LOG("cannot support mirrorred repeat mode\n");
|
||||
}
|
||||
}
|
||||
else {
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, (newmode.mag_filter||g_Config.bForceFiltering)?GL_LINEAR:GL_NEAREST);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
|
||||
(newmode.mag_filter || g_Config.bForceFiltering) ? GL_LINEAR : GL_NEAREST);
|
||||
|
||||
if( bHaveMipMaps ) {
|
||||
if (bHaveMipMaps) {
|
||||
int filt = newmode.min_filter;
|
||||
if( g_Config.bForceFiltering && newmode.min_filter < 4 )
|
||||
if (g_Config.bForceFiltering && newmode.min_filter < 4)
|
||||
newmode.min_filter += 4; // take equivalent forced linear
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, c_MinLinearFilter[filt]);
|
||||
}
|
||||
else
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, (g_Config.bForceFiltering||newmode.min_filter>=4)?GL_LINEAR:GL_NEAREST);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
|
||||
(g_Config.bForceFiltering || newmode.min_filter >= 4) ? GL_LINEAR : GL_NEAREST);
|
||||
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, c_WrapSettings[newmode.wrap_s]);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, c_WrapSettings[newmode.wrap_t]);
|
||||
@ -195,7 +199,7 @@ TextureMngr::TCacheEntry* TextureMngr::Load(int texstage, u32 address, int width
|
||||
return NULL;
|
||||
|
||||
TexCache::iterator iter = textures.find(address);
|
||||
TexMode0 &tm0 = bpmem.tex[texstage>3].texMode0[texstage&3];
|
||||
TexMode0 &tm0 = bpmem.tex[texstage > 3].texMode0[texstage & 3];
|
||||
u8 *ptr = g_VideoInitialize.pGetMemoryPointer(address);
|
||||
|
||||
int palSize = TexDecoder_GetPaletteSize(format);
|
||||
@ -248,9 +252,9 @@ TextureMngr::TCacheEntry* TextureMngr::Load(int texstage, u32 address, int width
|
||||
}
|
||||
}
|
||||
|
||||
int bs = TexDecoder_GetBlockWidthInTexels(format)-1; //TexelSizeInNibbles(format)*width*height/16;
|
||||
int expandedWidth = (width+bs) & (~bs);
|
||||
PC_TexFormat dfmt = TexDecoder_Decode(temp,ptr,expandedWidth,height,format, tlutaddr, tlutfmt);
|
||||
int bs = TexDecoder_GetBlockWidthInTexels(format) - 1; //TexelSizeInNibbles(format)*width*height/16;
|
||||
int expandedWidth = (width + bs) & (~bs);
|
||||
PC_TexFormat dfmt = TexDecoder_Decode(temp, ptr, expandedWidth, height, format, tlutaddr, tlutfmt);
|
||||
|
||||
//Make an entry in the table
|
||||
TCacheEntry& entry = textures[address];
|
||||
@ -283,7 +287,7 @@ TextureMngr::TCacheEntry* TextureMngr::Load(int texstage, u32 address, int width
|
||||
gl_type = GL_UNSIGNED_BYTE;
|
||||
break;
|
||||
}
|
||||
if( !entry.isNonPow2 && ((tm0.min_filter&3)==1||(tm0.min_filter&3)==2) ) {
|
||||
if (!entry.isNonPow2 && ((tm0.min_filter & 3) == 1 || (tm0.min_filter & 3) == 2)) {
|
||||
gluBuild2DMipmaps(GL_TEXTURE_2D, 4, width, height, gl_format, gl_type, temp);
|
||||
entry.bHaveMipMaps = true;
|
||||
}
|
||||
@ -294,9 +298,9 @@ TextureMngr::TCacheEntry* TextureMngr::Load(int texstage, u32 address, int width
|
||||
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
|
||||
|
||||
entry.frameCount = frameCount;
|
||||
entry.w=width;
|
||||
entry.h=height;
|
||||
entry.fmt=format;
|
||||
entry.w = width;
|
||||
entry.h = height;
|
||||
entry.fmt = format;
|
||||
entry.SetTextureParameters(tm0);
|
||||
|
||||
if (g_Config.bDumpTextures) { // dump texture to file
|
||||
@ -346,7 +350,7 @@ void TextureMngr::CopyRenderTargetToTexture(u32 address, bool bFromZBuffer, bool
|
||||
|
||||
GL_REPORT_ERRORD();
|
||||
|
||||
if( !bIsInit ) {
|
||||
if (!bIsInit) {
|
||||
glGenTextures(1, (GLuint *)&entry.texture);
|
||||
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, entry.texture);
|
||||
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, 4, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
|
||||
@ -356,16 +360,16 @@ void TextureMngr::CopyRenderTargetToTexture(u32 address, bool bFromZBuffer, bool
|
||||
_assert_(entry.texture);
|
||||
bool bReInit = true;
|
||||
|
||||
if( entry.w == w && entry.h == h ) {
|
||||
if (entry.w == w && entry.h == h) {
|
||||
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, entry.texture);
|
||||
// for some reason mario sunshine errors here...
|
||||
GLenum err = GL_NO_ERROR;
|
||||
GL_REPORT_ERROR();
|
||||
if( err == GL_NO_ERROR )
|
||||
if (err == GL_NO_ERROR )
|
||||
bReInit = false;
|
||||
}
|
||||
|
||||
if( bReInit ) {
|
||||
if (bReInit) {
|
||||
// necessary, for some reason opengl gives errors when texture isn't deleted
|
||||
glDeleteTextures(1,(GLuint *)&entry.texture);
|
||||
glGenTextures(1, (GLuint *)&entry.texture);
|
||||
@ -375,13 +379,13 @@ void TextureMngr::CopyRenderTargetToTexture(u32 address, bool bFromZBuffer, bool
|
||||
}
|
||||
}
|
||||
|
||||
if( !bIsInit || !entry.isRenderTarget ) {
|
||||
if (!bIsInit || !entry.isRenderTarget) {
|
||||
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
||||
|
||||
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||||
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||||
if( glGetError() != GL_NO_ERROR) {
|
||||
if (glGetError() != GL_NO_ERROR) {
|
||||
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP);
|
||||
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP);
|
||||
GL_REPORT_ERRORD();
|
||||
@ -390,14 +394,14 @@ void TextureMngr::CopyRenderTargetToTexture(u32 address, bool bFromZBuffer, bool
|
||||
|
||||
entry.w = w;
|
||||
entry.h = h;
|
||||
entry.isRenderTarget=true;
|
||||
entry.isRenderTarget = true;
|
||||
entry.fmt = copyfmt;
|
||||
|
||||
float colmat[16];
|
||||
float fConstAdd[4] = {0};
|
||||
memset(colmat, 0, sizeof(colmat));
|
||||
|
||||
if( bFromZBuffer ) {
|
||||
if (bFromZBuffer) {
|
||||
switch(copyfmt) {
|
||||
case 0: // Z4
|
||||
case 1: // Z8
|
||||
@ -428,18 +432,19 @@ void TextureMngr::CopyRenderTargetToTexture(u32 address, bool bFromZBuffer, bool
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if( bIsIntensityFmt ) {
|
||||
else if (bIsIntensityFmt) {
|
||||
fConstAdd[0] = fConstAdd[1] = fConstAdd[2] = 16.0f/255.0f;
|
||||
switch(copyfmt) {
|
||||
case 0: // I4
|
||||
case 1: // I8
|
||||
case 2: // IA4
|
||||
case 3: // IA8
|
||||
// TODO - verify these coefficients
|
||||
colmat[0] = 0.257f; colmat[1] = 0.504f; colmat[2] = 0.098f;
|
||||
colmat[4] = 0.257f; colmat[5] = 0.504f; colmat[6] = 0.098f;
|
||||
colmat[8] = 0.257f; colmat[9] = 0.504f; colmat[10] = 0.098f;
|
||||
if( copyfmt < 2 ) {
|
||||
fConstAdd[3] = 16.0f/255.0f;
|
||||
if (copyfmt < 2) {
|
||||
fConstAdd[3] = 16.0f / 255.0f;
|
||||
colmat[12] = 0.257f; colmat[13] = 0.504f; colmat[14] = 0.098f;
|
||||
}
|
||||
else { // alpha
|
||||
@ -453,7 +458,7 @@ void TextureMngr::CopyRenderTargetToTexture(u32 address, bool bFromZBuffer, bool
|
||||
}
|
||||
}
|
||||
else {
|
||||
switch(copyfmt) {
|
||||
switch (copyfmt) {
|
||||
case 0: // R4
|
||||
case 8: // R8
|
||||
colmat[0] = colmat[4] = colmat[8] = colmat[12] = 1;
|
||||
@ -495,7 +500,7 @@ void TextureMngr::CopyRenderTargetToTexture(u32 address, bool bFromZBuffer, bool
|
||||
}
|
||||
}
|
||||
|
||||
// if( bCopyToTarget ) {
|
||||
// if (bCopyToTarget) {
|
||||
// _assert_( glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) == GL_FRAMEBUFFER_COMPLETE_EXT );
|
||||
// glReadBuffer(GL_COLOR_ATTACHMENT0_EXT);
|
||||
// GL_REPORT_ERRORD();
|
||||
@ -512,7 +517,7 @@ void TextureMngr::CopyRenderTargetToTexture(u32 address, bool bFromZBuffer, bool
|
||||
|
||||
Renderer::ResetGLState(); // reset any game specific settings
|
||||
|
||||
if( s_TempFramebuffer == 0 )
|
||||
if (s_TempFramebuffer == 0 )
|
||||
glGenFramebuffersEXT( 1, (GLuint *)&s_TempFramebuffer);
|
||||
|
||||
Renderer::SetFramebuffer(s_TempFramebuffer);
|
||||
@ -525,7 +530,7 @@ void TextureMngr::CopyRenderTargetToTexture(u32 address, bool bFromZBuffer, bool
|
||||
if (itdepth == mapDepthTargets.end()) {
|
||||
DEPTHTARGET& depth = mapDepthTargets[(h << 16) | w];
|
||||
depth.framecount = frameCount;
|
||||
glGenRenderbuffersEXT( 1, &depth.targ);
|
||||
glGenRenderbuffersEXT(1, &depth.targ);
|
||||
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth.targ);
|
||||
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT/*GL_DEPTH24_STENCIL8_EXT*/, w, h);
|
||||
GL_REPORT_ERRORD();
|
||||
@ -565,7 +570,7 @@ void TextureMngr::CopyRenderTargetToTexture(u32 address, bool bFromZBuffer, bool
|
||||
|
||||
TextureMngr::DisableStage(0);
|
||||
|
||||
if( bFromZBuffer )
|
||||
if (bFromZBuffer )
|
||||
Renderer::SetZBufferRender(); // notify for future settings
|
||||
|
||||
GL_REPORT_ERRORD();
|
||||
@ -575,11 +580,11 @@ void TextureMngr::CopyRenderTargetToTexture(u32 address, bool bFromZBuffer, bool
|
||||
|
||||
void TextureMngr::EnableTex2D(int stage)
|
||||
{
|
||||
if( !(nTex2DEnabled & (1<<stage)) ) {
|
||||
if (!(nTex2DEnabled & (1<<stage))) {
|
||||
nTex2DEnabled |= (1<<stage);
|
||||
glEnable(GL_TEXTURE_2D);
|
||||
}
|
||||
if( nTexRECTEnabled & (1<<stage) ) {
|
||||
if (nTexRECTEnabled & (1<<stage)) {
|
||||
nTexRECTEnabled &= ~(1<<stage);
|
||||
glDisable(GL_TEXTURE_RECTANGLE_ARB);
|
||||
}
|
||||
@ -587,12 +592,12 @@ void TextureMngr::EnableTex2D(int stage)
|
||||
|
||||
void TextureMngr::EnableTexRECT(int stage)
|
||||
{
|
||||
if( (nTex2DEnabled & (1<<stage)) ) {
|
||||
nTex2DEnabled &= ~(1<<stage);
|
||||
if ((nTex2DEnabled & (1 << stage))) {
|
||||
nTex2DEnabled &= ~(1 << stage);
|
||||
glDisable(GL_TEXTURE_2D);
|
||||
}
|
||||
if( !(nTexRECTEnabled & (1<<stage)) ) {
|
||||
nTexRECTEnabled |= (1<<stage);
|
||||
if (!(nTexRECTEnabled & (1 << stage))) {
|
||||
nTexRECTEnabled |= (1 << stage);
|
||||
glEnable(GL_TEXTURE_RECTANGLE_ARB);
|
||||
}
|
||||
}
|
||||
@ -600,15 +605,16 @@ void TextureMngr::EnableTexRECT(int stage)
|
||||
void TextureMngr::DisableStage(int stage)
|
||||
{
|
||||
bool bset = false;
|
||||
if( nTex2DEnabled & (1<<stage) ) {
|
||||
nTex2DEnabled &= ~(1<<stage);
|
||||
glActiveTexture(GL_TEXTURE0+stage);
|
||||
if (nTex2DEnabled & (1 << stage)) {
|
||||
nTex2DEnabled &= ~(1 << stage);
|
||||
glActiveTexture(GL_TEXTURE0 + stage);
|
||||
glDisable(GL_TEXTURE_2D);
|
||||
bset = true;
|
||||
}
|
||||
if( nTexRECTEnabled & (1<<stage) ) {
|
||||
nTexRECTEnabled &= ~(1<<stage);
|
||||
if( !bset ) glActiveTexture(GL_TEXTURE0+stage);
|
||||
if (nTexRECTEnabled & (1<<stage)) {
|
||||
nTexRECTEnabled &= ~(1 << stage);
|
||||
if (!bset)
|
||||
glActiveTexture(GL_TEXTURE0 + stage);
|
||||
glDisable(GL_TEXTURE_RECTANGLE_ARB);
|
||||
}
|
||||
}
|
||||
|
||||
@ -59,9 +59,9 @@ void LOADERDECL PosMtx_ReadDirect_UByte(const void *_p)
|
||||
void LOADERDECL PosMtx_Write(const void *_p)
|
||||
{
|
||||
*VertexManager::s_pCurBufferPointer++ = s_curposmtx;
|
||||
//*VertexManager::s_pCurBufferPointer++ = 0;
|
||||
//*VertexManager::s_pCurBufferPointer++ = 0;
|
||||
//*VertexManager::s_pCurBufferPointer++ = 0;
|
||||
*VertexManager::s_pCurBufferPointer++ = 0;
|
||||
*VertexManager::s_pCurBufferPointer++ = 0;
|
||||
*VertexManager::s_pCurBufferPointer++ = 0;
|
||||
}
|
||||
|
||||
void LOADERDECL TexMtx_ReadDirect_UByte(const void *_p)
|
||||
@ -89,7 +89,7 @@ void LOADERDECL TexMtx_Write_Short3(const void *_p)
|
||||
((s16*)VertexManager::s_pCurBufferPointer)[0] = 0;
|
||||
((s16*)VertexManager::s_pCurBufferPointer)[1] = 0;
|
||||
((s16*)VertexManager::s_pCurBufferPointer)[2] = s_curtexmtx[s_texmtxwrite++];
|
||||
VertexManager::s_pCurBufferPointer += 6;
|
||||
VertexManager::s_pCurBufferPointer += 8;
|
||||
}
|
||||
|
||||
#include "VertexLoader_Position.h"
|
||||
@ -101,6 +101,7 @@ VertexLoader::VertexLoader(const TVtxDesc &vtx_desc, const VAT &vtx_attr)
|
||||
{
|
||||
m_VertexSize = 0;
|
||||
m_numPipelineStages = 0;
|
||||
m_NativeFmt = new NativeVertexFormat();
|
||||
VertexLoader_Normal::Init();
|
||||
|
||||
m_VtxDesc = vtx_desc;
|
||||
@ -112,6 +113,7 @@ VertexLoader::VertexLoader(const TVtxDesc &vtx_desc, const VAT &vtx_attr)
|
||||
|
||||
VertexLoader::~VertexLoader()
|
||||
{
|
||||
delete m_NativeFmt;
|
||||
}
|
||||
|
||||
int VertexLoader::ComputeVertexSize()
|
||||
@ -227,30 +229,29 @@ void VertexLoader::CompileVertexTranslator()
|
||||
m_numPipelineStages = 0;
|
||||
|
||||
// It's a bit ugly that we poke inside m_NativeFmt in this function. Planning to fix this.
|
||||
m_NativeFmt.m_VBStridePad = 0;
|
||||
m_NativeFmt.m_VBVertexStride = 0;
|
||||
m_NativeFmt.m_components = 0;
|
||||
m_NativeFmt->m_VBVertexStride = 0;
|
||||
m_NativeFmt->m_components = 0;
|
||||
|
||||
// m_VBVertexStride for texmtx and posmtx is computed later when writing.
|
||||
|
||||
// Position Matrix Index
|
||||
if (m_VtxDesc.PosMatIdx) {
|
||||
m_PipelineStages[m_numPipelineStages++] = PosMtx_ReadDirect_UByte;
|
||||
m_NativeFmt.m_components |= VB_HAS_POSMTXIDX;
|
||||
m_NativeFmt->m_components |= VB_HAS_POSMTXIDX;
|
||||
}
|
||||
|
||||
if (m_VtxDesc.Tex0MatIdx) {m_NativeFmt.m_components |= VB_HAS_TEXMTXIDX0; WriteCall(TexMtx_ReadDirect_UByte); }
|
||||
if (m_VtxDesc.Tex1MatIdx) {m_NativeFmt.m_components |= VB_HAS_TEXMTXIDX1; WriteCall(TexMtx_ReadDirect_UByte); }
|
||||
if (m_VtxDesc.Tex2MatIdx) {m_NativeFmt.m_components |= VB_HAS_TEXMTXIDX2; WriteCall(TexMtx_ReadDirect_UByte); }
|
||||
if (m_VtxDesc.Tex3MatIdx) {m_NativeFmt.m_components |= VB_HAS_TEXMTXIDX3; WriteCall(TexMtx_ReadDirect_UByte); }
|
||||
if (m_VtxDesc.Tex4MatIdx) {m_NativeFmt.m_components |= VB_HAS_TEXMTXIDX4; WriteCall(TexMtx_ReadDirect_UByte); }
|
||||
if (m_VtxDesc.Tex5MatIdx) {m_NativeFmt.m_components |= VB_HAS_TEXMTXIDX5; WriteCall(TexMtx_ReadDirect_UByte); }
|
||||
if (m_VtxDesc.Tex6MatIdx) {m_NativeFmt.m_components |= VB_HAS_TEXMTXIDX6; WriteCall(TexMtx_ReadDirect_UByte); }
|
||||
if (m_VtxDesc.Tex7MatIdx) {m_NativeFmt.m_components |= VB_HAS_TEXMTXIDX7; WriteCall(TexMtx_ReadDirect_UByte); }
|
||||
if (m_VtxDesc.Tex0MatIdx) {m_NativeFmt->m_components |= VB_HAS_TEXMTXIDX0; WriteCall(TexMtx_ReadDirect_UByte); }
|
||||
if (m_VtxDesc.Tex1MatIdx) {m_NativeFmt->m_components |= VB_HAS_TEXMTXIDX1; WriteCall(TexMtx_ReadDirect_UByte); }
|
||||
if (m_VtxDesc.Tex2MatIdx) {m_NativeFmt->m_components |= VB_HAS_TEXMTXIDX2; WriteCall(TexMtx_ReadDirect_UByte); }
|
||||
if (m_VtxDesc.Tex3MatIdx) {m_NativeFmt->m_components |= VB_HAS_TEXMTXIDX3; WriteCall(TexMtx_ReadDirect_UByte); }
|
||||
if (m_VtxDesc.Tex4MatIdx) {m_NativeFmt->m_components |= VB_HAS_TEXMTXIDX4; WriteCall(TexMtx_ReadDirect_UByte); }
|
||||
if (m_VtxDesc.Tex5MatIdx) {m_NativeFmt->m_components |= VB_HAS_TEXMTXIDX5; WriteCall(TexMtx_ReadDirect_UByte); }
|
||||
if (m_VtxDesc.Tex6MatIdx) {m_NativeFmt->m_components |= VB_HAS_TEXMTXIDX6; WriteCall(TexMtx_ReadDirect_UByte); }
|
||||
if (m_VtxDesc.Tex7MatIdx) {m_NativeFmt->m_components |= VB_HAS_TEXMTXIDX7; WriteCall(TexMtx_ReadDirect_UByte); }
|
||||
|
||||
// Position
|
||||
if (m_VtxDesc.Position != NOT_PRESENT)
|
||||
m_NativeFmt.m_VBVertexStride += 12;
|
||||
m_NativeFmt->m_VBVertexStride += 12;
|
||||
|
||||
switch (m_VtxDesc.Position) {
|
||||
case NOT_PRESENT: {_assert_msg_(0, "Vertex descriptor without position!", "WTF?");} break;
|
||||
@ -303,19 +304,19 @@ void VertexLoader::CompileVertexTranslator()
|
||||
int sizePro = 0;
|
||||
switch (m_VtxAttr.NormalFormat)
|
||||
{
|
||||
case FORMAT_UBYTE: sizePro=1; break;
|
||||
case FORMAT_BYTE: sizePro=1; break;
|
||||
case FORMAT_USHORT: sizePro=2; break;
|
||||
case FORMAT_SHORT: sizePro=2; break;
|
||||
case FORMAT_FLOAT: sizePro=4; break;
|
||||
case FORMAT_UBYTE: sizePro = 1*4; break;
|
||||
case FORMAT_BYTE: sizePro = 1*4; break;
|
||||
case FORMAT_USHORT: sizePro = 2*4; break;
|
||||
case FORMAT_SHORT: sizePro = 2*4; break;
|
||||
case FORMAT_FLOAT: sizePro = 4*3; break;
|
||||
default: _assert_(0); break;
|
||||
}
|
||||
m_NativeFmt.m_VBVertexStride += sizePro * 3 * (m_VtxAttr.NormalElements?3:1);
|
||||
m_NativeFmt->m_VBVertexStride += sizePro * (m_VtxAttr.NormalElements?3:1);
|
||||
|
||||
int numNormals = (m_VtxAttr.NormalElements == 1) ? NRM_THREE : NRM_ONE;
|
||||
m_NativeFmt.m_components |= VB_HAS_NRM0;
|
||||
m_NativeFmt->m_components |= VB_HAS_NRM0;
|
||||
if (numNormals == NRM_THREE)
|
||||
m_NativeFmt.m_components |= VB_HAS_NRM1 | VB_HAS_NRM2;
|
||||
m_NativeFmt->m_components |= VB_HAS_NRM1 | VB_HAS_NRM2;
|
||||
}
|
||||
|
||||
// Colors
|
||||
@ -324,7 +325,7 @@ void VertexLoader::CompileVertexTranslator()
|
||||
SetupColor(i, col[i], m_VtxAttr.color[i].Comp, m_VtxAttr.color[i].Elements);
|
||||
|
||||
if (col[i] != NOT_PRESENT)
|
||||
m_NativeFmt.m_VBVertexStride += 4;
|
||||
m_NativeFmt->m_VBVertexStride += 4;
|
||||
}
|
||||
|
||||
// TextureCoord
|
||||
@ -336,21 +337,21 @@ void VertexLoader::CompileVertexTranslator()
|
||||
// Texture matrix indices (remove if corresponding texture coordinate isn't enabled)
|
||||
for (int i = 0; i < 8; i++) {
|
||||
SetupTexCoord(i, tc[i], m_VtxAttr.texCoord[i].Format, m_VtxAttr.texCoord[i].Elements, m_VtxAttr.texCoord[i].Frac);
|
||||
if (m_NativeFmt.m_components & (VB_HAS_TEXMTXIDX0 << i)) {
|
||||
if (m_NativeFmt->m_components & (VB_HAS_TEXMTXIDX0 << i)) {
|
||||
if (tc[i] != NOT_PRESENT) {
|
||||
// if texmtx is included, texcoord will always be 3 floats, z will be the texmtx index
|
||||
WriteCall(m_VtxAttr.texCoord[i].Elements ? TexMtx_Write_Float : TexMtx_Write_Float2);
|
||||
m_NativeFmt.m_VBVertexStride += 12;
|
||||
m_NativeFmt->m_VBVertexStride += 12;
|
||||
}
|
||||
else {
|
||||
WriteCall(TexMtx_Write_Short3);
|
||||
m_NativeFmt.m_VBVertexStride += 6; // still include the texture coordinate, but this time as 6 bytes
|
||||
m_NativeFmt.m_components |= VB_HAS_UV0 << i; // have to include since using now
|
||||
m_NativeFmt->m_VBVertexStride += 8; // still include the texture coordinate, but this time as 6 bytes
|
||||
m_NativeFmt->m_components |= VB_HAS_UV0 << i; // have to include since using now
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (tc[i] != NOT_PRESENT)
|
||||
m_NativeFmt.m_VBVertexStride += 4 * (m_VtxAttr.texCoord[i].Elements ? 2 : 1);
|
||||
m_NativeFmt->m_VBVertexStride += 4 * (m_VtxAttr.texCoord[i].Elements ? 2 : 1);
|
||||
}
|
||||
|
||||
if (tc[i] == NOT_PRESENT) {
|
||||
@ -362,30 +363,30 @@ void VertexLoader::CompileVertexTranslator()
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (j == 8 && !((m_NativeFmt.m_components&VB_HAS_TEXMTXIDXALL) & (VB_HAS_TEXMTXIDXALL<<(i+1)))) // no more tex coords and tex matrices, so exit loop
|
||||
if (j == 8 && !((m_NativeFmt->m_components&VB_HAS_TEXMTXIDXALL) & (VB_HAS_TEXMTXIDXALL<<(i+1)))) // no more tex coords and tex matrices, so exit loop
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (m_VtxDesc.PosMatIdx) {
|
||||
WriteCall(PosMtx_Write);
|
||||
m_NativeFmt.m_VBVertexStride += 1;
|
||||
m_NativeFmt->m_VBVertexStride += 4;
|
||||
}
|
||||
|
||||
m_NativeFmt.Initialize(m_VtxDesc, m_VtxAttr);
|
||||
m_NativeFmt->Initialize(m_VtxDesc, m_VtxAttr);
|
||||
}
|
||||
|
||||
void VertexLoader::SetupColor(int num, int mode, int format, int elements)
|
||||
{
|
||||
// if COL0 not present, then embed COL1 into COL0
|
||||
if (num == 1 && !(m_NativeFmt.m_components & VB_HAS_COL0))
|
||||
if (num == 1 && !(m_NativeFmt->m_components & VB_HAS_COL0))
|
||||
num = 0;
|
||||
|
||||
m_NativeFmt.m_components |= VB_HAS_COL0 << num;
|
||||
m_NativeFmt->m_components |= VB_HAS_COL0 << num;
|
||||
switch (mode)
|
||||
{
|
||||
case NOT_PRESENT:
|
||||
m_NativeFmt.m_components &= ~(VB_HAS_COL0 << num);
|
||||
m_NativeFmt->m_components &= ~(VB_HAS_COL0 << num);
|
||||
break;
|
||||
case DIRECT:
|
||||
switch (format)
|
||||
@ -428,12 +429,12 @@ void VertexLoader::SetupColor(int num, int mode, int format, int elements)
|
||||
|
||||
void VertexLoader::SetupTexCoord(int num, int mode, int format, int elements, int _iFrac)
|
||||
{
|
||||
m_NativeFmt.m_components |= VB_HAS_UV0 << num;
|
||||
m_NativeFmt->m_components |= VB_HAS_UV0 << num;
|
||||
|
||||
switch (mode)
|
||||
{
|
||||
case NOT_PRESENT:
|
||||
m_NativeFmt.m_components &= ~(VB_HAS_UV0 << num);
|
||||
m_NativeFmt->m_components &= ~(VB_HAS_UV0 << num);
|
||||
break;
|
||||
case DIRECT:
|
||||
switch (format)
|
||||
@ -481,12 +482,12 @@ void VertexLoader::RunVertices(int vtx_attr_group, int primitive, int count)
|
||||
DVSTARTPROFILE();
|
||||
|
||||
// Flush if our vertex format is different from the currently set.
|
||||
if (g_nativeVertexFmt != NULL && g_nativeVertexFmt != &m_NativeFmt)
|
||||
if (g_nativeVertexFmt != NULL && g_nativeVertexFmt != m_NativeFmt)
|
||||
{
|
||||
VertexManager::Flush();
|
||||
// Also move the Set() here?
|
||||
}
|
||||
g_nativeVertexFmt = &m_NativeFmt;
|
||||
g_nativeVertexFmt = m_NativeFmt;
|
||||
|
||||
if (bpmem.genMode.cullmode == 3 && primitive < 5)
|
||||
{
|
||||
@ -495,7 +496,7 @@ void VertexLoader::RunVertices(int vtx_attr_group, int primitive, int count)
|
||||
return;
|
||||
}
|
||||
|
||||
VertexManager::EnableComponents(m_NativeFmt.m_components);
|
||||
VertexManager::EnableComponents(m_NativeFmt->m_components);
|
||||
|
||||
// Load position and texcoord scale factors.
|
||||
// TODO - figure out if we should leave these independent, or compile them into
|
||||
@ -511,7 +512,7 @@ void VertexLoader::RunVertices(int vtx_attr_group, int primitive, int count)
|
||||
m_VtxAttr.texCoord[7].Frac = g_VtxAttr[vtx_attr_group].g2.Tex7Frac;
|
||||
|
||||
posScale = shiftLookup[m_VtxAttr.PosFrac];
|
||||
if (m_NativeFmt.m_components & VB_HAS_UVALL) {
|
||||
if (m_NativeFmt->m_components & VB_HAS_UVALL) {
|
||||
for (int i = 0; i < 8; i++) {
|
||||
tcScaleU[i] = shiftLookup[m_VtxAttr.texCoord[i].Frac];
|
||||
tcScaleV[i] = shiftLookup[m_VtxAttr.texCoord[i].Frac];
|
||||
@ -525,11 +526,11 @@ void VertexLoader::RunVertices(int vtx_attr_group, int primitive, int count)
|
||||
switch (primitive) {
|
||||
case 3: // strip
|
||||
case 4: // fan
|
||||
if (VertexManager::GetRemainingSize() < 3 * m_NativeFmt.m_VBVertexStride)
|
||||
if (VertexManager::GetRemainingSize() < 3 * m_NativeFmt->m_VBVertexStride)
|
||||
VertexManager::Flush();
|
||||
break;
|
||||
case 6: // line strip
|
||||
if (VertexManager::GetRemainingSize() < 2 * m_NativeFmt.m_VBVertexStride)
|
||||
if (VertexManager::GetRemainingSize() < 2 * m_NativeFmt->m_VBVertexStride)
|
||||
VertexManager::Flush();
|
||||
break;
|
||||
case 0: // quads
|
||||
@ -544,11 +545,12 @@ void VertexLoader::RunVertices(int vtx_attr_group, int primitive, int count)
|
||||
}
|
||||
|
||||
int startv = 0, extraverts = 0;
|
||||
|
||||
for (int v = 0; v < count; v++)
|
||||
{
|
||||
if ((v % granularity) == 0)
|
||||
{
|
||||
if (VertexManager::GetRemainingSize() < granularity*m_NativeFmt.m_VBVertexStride) {
|
||||
if (VertexManager::GetRemainingSize() < granularity*m_NativeFmt->m_VBVertexStride) {
|
||||
// This buffer full - break current primitive and flush, to switch to the next buffer.
|
||||
u8* plastptr = VertexManager::s_pCurBufferPointer;
|
||||
if (v - startv > 0)
|
||||
@ -559,27 +561,27 @@ void VertexLoader::RunVertices(int vtx_attr_group, int primitive, int count)
|
||||
case 3: // triangle strip, copy last two vertices
|
||||
// a little trick since we have to keep track of signs
|
||||
if (v & 1) {
|
||||
memcpy_gc(VertexManager::s_pCurBufferPointer, plastptr-2*m_NativeFmt.m_VBVertexStride, m_NativeFmt.m_VBVertexStride);
|
||||
memcpy_gc(VertexManager::s_pCurBufferPointer+m_NativeFmt.m_VBVertexStride, plastptr-m_NativeFmt.m_VBVertexStride*2, 2*m_NativeFmt.m_VBVertexStride);
|
||||
VertexManager::s_pCurBufferPointer += m_NativeFmt.m_VBVertexStride*3;
|
||||
memcpy_gc(VertexManager::s_pCurBufferPointer, plastptr-2*m_NativeFmt->m_VBVertexStride, m_NativeFmt->m_VBVertexStride);
|
||||
memcpy_gc(VertexManager::s_pCurBufferPointer+m_NativeFmt->m_VBVertexStride, plastptr-m_NativeFmt->m_VBVertexStride*2, 2*m_NativeFmt->m_VBVertexStride);
|
||||
VertexManager::s_pCurBufferPointer += m_NativeFmt->m_VBVertexStride*3;
|
||||
extraverts = 3;
|
||||
}
|
||||
else {
|
||||
memcpy_gc(VertexManager::s_pCurBufferPointer, plastptr-m_NativeFmt.m_VBVertexStride*2, m_NativeFmt.m_VBVertexStride*2);
|
||||
VertexManager::s_pCurBufferPointer += m_NativeFmt.m_VBVertexStride*2;
|
||||
memcpy_gc(VertexManager::s_pCurBufferPointer, plastptr-m_NativeFmt->m_VBVertexStride*2, m_NativeFmt->m_VBVertexStride*2);
|
||||
VertexManager::s_pCurBufferPointer += m_NativeFmt->m_VBVertexStride*2;
|
||||
extraverts = 2;
|
||||
}
|
||||
break;
|
||||
case 4: // tri fan, copy first and last vert
|
||||
memcpy_gc(VertexManager::s_pCurBufferPointer, plastptr-m_NativeFmt.m_VBVertexStride*(v-startv+extraverts), m_NativeFmt.m_VBVertexStride);
|
||||
VertexManager::s_pCurBufferPointer += m_NativeFmt.m_VBVertexStride;
|
||||
memcpy_gc(VertexManager::s_pCurBufferPointer, plastptr-m_NativeFmt.m_VBVertexStride, m_NativeFmt.m_VBVertexStride);
|
||||
VertexManager::s_pCurBufferPointer += m_NativeFmt.m_VBVertexStride;
|
||||
memcpy_gc(VertexManager::s_pCurBufferPointer, plastptr-m_NativeFmt->m_VBVertexStride*(v-startv+extraverts), m_NativeFmt->m_VBVertexStride);
|
||||
VertexManager::s_pCurBufferPointer += m_NativeFmt->m_VBVertexStride;
|
||||
memcpy_gc(VertexManager::s_pCurBufferPointer, plastptr-m_NativeFmt->m_VBVertexStride, m_NativeFmt->m_VBVertexStride);
|
||||
VertexManager::s_pCurBufferPointer += m_NativeFmt->m_VBVertexStride;
|
||||
extraverts = 2;
|
||||
break;
|
||||
case 6: // line strip
|
||||
memcpy_gc(VertexManager::s_pCurBufferPointer, plastptr-m_NativeFmt.m_VBVertexStride, m_NativeFmt.m_VBVertexStride);
|
||||
VertexManager::s_pCurBufferPointer += m_NativeFmt.m_VBVertexStride;
|
||||
memcpy_gc(VertexManager::s_pCurBufferPointer, plastptr-m_NativeFmt->m_VBVertexStride, m_NativeFmt->m_VBVertexStride);
|
||||
VertexManager::s_pCurBufferPointer += m_NativeFmt->m_VBVertexStride;
|
||||
extraverts = 1;
|
||||
break;
|
||||
default:
|
||||
@ -596,7 +598,6 @@ void VertexLoader::RunVertices(int vtx_attr_group, int primitive, int count)
|
||||
for (int i = 0; i < m_numPipelineStages; i++)
|
||||
m_PipelineStages[i](&m_VtxAttr);
|
||||
|
||||
VertexManager::s_pCurBufferPointer += m_NativeFmt.m_VBStridePad;
|
||||
PRIM_LOG("\n");
|
||||
}
|
||||
|
||||
|
||||
@ -74,7 +74,7 @@ private:
|
||||
TVtxDesc m_VtxDesc; // Not really used currently - or well it is, but could be easily avoided.
|
||||
|
||||
// PC vertex format
|
||||
NativeVertexFormat m_NativeFmt;
|
||||
NativeVertexFormat *m_NativeFmt;
|
||||
|
||||
// Pipeline. To be JIT compiled in the future.
|
||||
TPipelineFunction m_PipelineStages[32]; // TODO - figure out real max. it's lower.
|
||||
|
||||
@ -37,6 +37,8 @@ static VertexLoaderMap g_VertexLoaderMap;
|
||||
void Init()
|
||||
{
|
||||
MarkAllDirty();
|
||||
for (int i = 0; i < 8; i++)
|
||||
g_VertexLoaders[i] = NULL;
|
||||
}
|
||||
|
||||
void Shutdown()
|
||||
@ -53,9 +55,9 @@ void MarkAllDirty()
|
||||
s_attr_dirty = 0xff;
|
||||
}
|
||||
|
||||
void RefreshLoader(int vtx_attr_group)
|
||||
static void RefreshLoader(int vtx_attr_group)
|
||||
{
|
||||
if (((s_attr_dirty >> vtx_attr_group) & 1) || !g_VertexLoaders[vtx_attr_group])
|
||||
if ((s_attr_dirty >> vtx_attr_group) & 1)
|
||||
{
|
||||
VertexLoaderUID uid;
|
||||
uid.InitFromCurrentState(vtx_attr_group);
|
||||
|
||||
@ -123,7 +123,8 @@ void LOADERDECL VertexLoader_Normal::Normal_DirectByte(const void *_p)
|
||||
*VertexManager::s_pCurBufferPointer++ = DataReadU8();
|
||||
*VertexManager::s_pCurBufferPointer++ = DataReadU8();
|
||||
*VertexManager::s_pCurBufferPointer++ = DataReadU8();
|
||||
LOG_NORM8();
|
||||
VertexManager::s_pCurBufferPointer++;
|
||||
LOG_NORM8();
|
||||
// ((float*)VertexManager::s_pCurBufferPointer)[0] = ((float)(signed char)DataReadU8()+0.5f) / 127.5f;
|
||||
}
|
||||
|
||||
@ -132,7 +133,7 @@ void LOADERDECL VertexLoader_Normal::Normal_DirectShort(const void *_p)
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[0] = DataReadU16();
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[1] = DataReadU16();
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[2] = DataReadU16();
|
||||
VertexManager::s_pCurBufferPointer += 6;
|
||||
VertexManager::s_pCurBufferPointer += 8;
|
||||
LOG_NORM16()
|
||||
// ((float*)VertexManager::s_pCurBufferPointer)[0] = ((float)(signed short)DataReadU16()+0.5f) / 32767.5f;
|
||||
// ((float*)VertexManager::s_pCurBufferPointer)[1] = ((float)(signed short)DataReadU16()+0.5f) / 32767.5f;
|
||||
@ -150,30 +151,31 @@ void LOADERDECL VertexLoader_Normal::Normal_DirectFloat(const void *_p)
|
||||
|
||||
void LOADERDECL VertexLoader_Normal::Normal_DirectByte3(const void *_p)
|
||||
{
|
||||
for (int i=0; i<3; i++)
|
||||
for (int i = 0; i < 3; i++)
|
||||
{
|
||||
*VertexManager::s_pCurBufferPointer++ = DataReadU8();
|
||||
*VertexManager::s_pCurBufferPointer++ = DataReadU8();
|
||||
*VertexManager::s_pCurBufferPointer++ = DataReadU8();
|
||||
VertexManager::s_pCurBufferPointer++;
|
||||
LOG_NORM8();
|
||||
}
|
||||
}
|
||||
|
||||
void LOADERDECL VertexLoader_Normal::Normal_DirectShort3(const void *_p)
|
||||
{
|
||||
for (int i=0; i<3; i++)
|
||||
for (int i = 0; i < 3; i++)
|
||||
{
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[0] = DataReadU16();
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[1] = DataReadU16();
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[2] = DataReadU16();
|
||||
VertexManager::s_pCurBufferPointer += 6;
|
||||
VertexManager::s_pCurBufferPointer += 8;
|
||||
LOG_NORM16();
|
||||
}
|
||||
}
|
||||
|
||||
void LOADERDECL VertexLoader_Normal::Normal_DirectFloat3(const void *_p)
|
||||
{
|
||||
for (int i=0; i<3; i++)
|
||||
for (int i = 0; i < 3; i++)
|
||||
{
|
||||
((float*)VertexManager::s_pCurBufferPointer)[0] = DataReadF32();
|
||||
((float*)VertexManager::s_pCurBufferPointer)[1] = DataReadF32();
|
||||
@ -193,6 +195,7 @@ void LOADERDECL VertexLoader_Normal::Normal_Index8_Byte(const void *_p)
|
||||
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress);
|
||||
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+1);
|
||||
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+2);
|
||||
VertexManager::s_pCurBufferPointer++;
|
||||
// ((float*)VertexManager::s_pCurBufferPointer)[0] = ((float)(signed char)Memory_Read_U8(iAddress)+0.5f) / 127.5f;
|
||||
// ((float*)VertexManager::s_pCurBufferPointer)[1] = ((float)(signed char)Memory_Read_U8(iAddress+1)+0.5f) / 127.5f;
|
||||
// ((float*)VertexManager::s_pCurBufferPointer)[2] = ((float)(signed char)Memory_Read_U8(iAddress+2)+0.5f) / 127.5f;
|
||||
@ -207,7 +210,7 @@ void LOADERDECL VertexLoader_Normal::Normal_Index8_Short(const void *_p)
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[0] = Memory_Read_U16(iAddress);
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[1] = Memory_Read_U16(iAddress+2);
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[2] = Memory_Read_U16(iAddress+4);
|
||||
VertexManager::s_pCurBufferPointer += 6;
|
||||
VertexManager::s_pCurBufferPointer += 8;
|
||||
LOG_NORM16();
|
||||
}
|
||||
|
||||
@ -225,22 +228,24 @@ void LOADERDECL VertexLoader_Normal::Normal_Index8_Float(const void *_p)
|
||||
void LOADERDECL VertexLoader_Normal::Normal_Index8_Byte3(const void *_p)
|
||||
{
|
||||
if (index3) {
|
||||
for (int i=0; i<3; i++) {
|
||||
for (int i = 0; i < 3; i++) {
|
||||
u8 Index = DataReadU8();
|
||||
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 1*3*i;
|
||||
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress);
|
||||
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+1);
|
||||
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+2);
|
||||
*VertexManager::s_pCurBufferPointer++;
|
||||
LOG_NORM8();
|
||||
}
|
||||
}
|
||||
else {
|
||||
u8 Index = DataReadU8();
|
||||
for (int i=0; i<3; i++) {
|
||||
for (int i = 0; i < 3; i++) {
|
||||
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 1*3*i;
|
||||
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress);
|
||||
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+1);
|
||||
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+2);
|
||||
VertexManager::s_pCurBufferPointer++;
|
||||
LOG_NORM8();
|
||||
}
|
||||
}
|
||||
@ -249,24 +254,24 @@ void LOADERDECL VertexLoader_Normal::Normal_Index8_Byte3(const void *_p)
|
||||
void LOADERDECL VertexLoader_Normal::Normal_Index8_Short3(const void *_p)
|
||||
{
|
||||
if (index3) {
|
||||
for (int i=0; i<3; i++) {
|
||||
for (int i = 0; i < 3; i++) {
|
||||
u8 Index = DataReadU8();
|
||||
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 2*3*i;
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[0] = Memory_Read_U16(iAddress);
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[1] = Memory_Read_U16(iAddress+2);
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[2] = Memory_Read_U16(iAddress+4);
|
||||
VertexManager::s_pCurBufferPointer += 6;
|
||||
VertexManager::s_pCurBufferPointer += 8;
|
||||
LOG_NORM16();
|
||||
}
|
||||
}
|
||||
else {
|
||||
u8 Index = DataReadU8();
|
||||
for (int i=0; i<3; i++) {
|
||||
for (int i = 0; i < 3; i++) {
|
||||
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 2*3*i;
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[0] = Memory_Read_U16(iAddress);
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[1] = Memory_Read_U16(iAddress+2);
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[2] = Memory_Read_U16(iAddress+4);
|
||||
VertexManager::s_pCurBufferPointer += 6;
|
||||
VertexManager::s_pCurBufferPointer += 8;
|
||||
LOG_NORM16();
|
||||
}
|
||||
}
|
||||
@ -275,7 +280,7 @@ void LOADERDECL VertexLoader_Normal::Normal_Index8_Short3(const void *_p)
|
||||
void LOADERDECL VertexLoader_Normal::Normal_Index8_Float3(const void *_p)
|
||||
{
|
||||
if (index3) {
|
||||
for (int i=0; i<3; i++) {
|
||||
for (int i = 0; i < 3; i++) {
|
||||
u8 Index = DataReadU8();
|
||||
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 4*3*i;
|
||||
((float*)VertexManager::s_pCurBufferPointer)[0] = Memory_Read_Float(iAddress);
|
||||
@ -287,7 +292,7 @@ void LOADERDECL VertexLoader_Normal::Normal_Index8_Float3(const void *_p)
|
||||
}
|
||||
else {
|
||||
u8 Index = DataReadU8();
|
||||
for (int i=0; i<3; i++) {
|
||||
for (int i = 0; i < 3; i++) {
|
||||
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 4*3*i;
|
||||
((float*)VertexManager::s_pCurBufferPointer)[0] = Memory_Read_Float(iAddress);
|
||||
((float*)VertexManager::s_pCurBufferPointer)[1] = Memory_Read_Float(iAddress+4);
|
||||
@ -309,6 +314,7 @@ void LOADERDECL VertexLoader_Normal::Normal_Index16_Byte(const void *_p)
|
||||
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress);
|
||||
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+1);
|
||||
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+2);
|
||||
VertexManager::s_pCurBufferPointer++;
|
||||
LOG_NORM8();
|
||||
}
|
||||
|
||||
@ -319,7 +325,7 @@ void LOADERDECL VertexLoader_Normal::Normal_Index16_Short(const void *_p)
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[0] = Memory_Read_U16(iAddress);
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[1] = Memory_Read_U16(iAddress+2);
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[2] = Memory_Read_U16(iAddress+4);
|
||||
VertexManager::s_pCurBufferPointer += 6;
|
||||
VertexManager::s_pCurBufferPointer += 8;
|
||||
LOG_NORM16();
|
||||
}
|
||||
|
||||
@ -337,22 +343,24 @@ void LOADERDECL VertexLoader_Normal::Normal_Index16_Float(const void *_p)
|
||||
void LOADERDECL VertexLoader_Normal::Normal_Index16_Byte3(const void *_p)
|
||||
{
|
||||
if (index3) {
|
||||
for (int i=0; i<3; i++) {
|
||||
for (int i = 0; i < 3; i++) {
|
||||
u16 Index = DataReadU16();
|
||||
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 1*3*i;
|
||||
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress);
|
||||
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+1);
|
||||
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+2);
|
||||
VertexManager::s_pCurBufferPointer++;
|
||||
LOG_NORM8();
|
||||
}
|
||||
}
|
||||
else {
|
||||
u16 Index = DataReadU16();
|
||||
for (int i=0; i<3; i++) {
|
||||
for (int i = 0; i < 3; i++) {
|
||||
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 1*3*i;
|
||||
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress);
|
||||
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+1);
|
||||
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+2);
|
||||
VertexManager::s_pCurBufferPointer++;
|
||||
LOG_NORM8();
|
||||
}
|
||||
}
|
||||
@ -362,27 +370,27 @@ void LOADERDECL VertexLoader_Normal::Normal_Index16_Short3(const void *_p)
|
||||
{
|
||||
if (index3)
|
||||
{
|
||||
for (int i=0; i<3; i++)
|
||||
for (int i = 0; i < 3; i++)
|
||||
{
|
||||
u16 Index = DataReadU16();
|
||||
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 2*3*i;
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[0] = Memory_Read_U16(iAddress);
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[1] = Memory_Read_U16(iAddress+2);
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[2] = Memory_Read_U16(iAddress+4);
|
||||
VertexManager::s_pCurBufferPointer += 6;
|
||||
VertexManager::s_pCurBufferPointer += 8;
|
||||
LOG_NORM16();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
u16 Index = DataReadU16();
|
||||
for (int i=0; i<3; i++)
|
||||
for (int i = 0; i < 3; i++)
|
||||
{
|
||||
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 2*3*i;
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[0] = Memory_Read_U16(iAddress);
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[1] = Memory_Read_U16(iAddress+2);
|
||||
((u16*)VertexManager::s_pCurBufferPointer)[2] = Memory_Read_U16(iAddress+4);
|
||||
VertexManager::s_pCurBufferPointer += 6;
|
||||
VertexManager::s_pCurBufferPointer += 8;
|
||||
LOG_NORM16();
|
||||
}
|
||||
}
|
||||
@ -392,7 +400,7 @@ void LOADERDECL VertexLoader_Normal::Normal_Index16_Float3(const void *_p)
|
||||
{
|
||||
if (index3)
|
||||
{
|
||||
for (int i=0; i<3; i++)
|
||||
for (int i = 0; i < 3; i++)
|
||||
{
|
||||
u16 Index = DataReadU16();
|
||||
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 4*3*i;
|
||||
@ -406,7 +414,7 @@ void LOADERDECL VertexLoader_Normal::Normal_Index16_Float3(const void *_p)
|
||||
else
|
||||
{
|
||||
u16 Index = DataReadU16();
|
||||
for (int i=0; i<3; i++)
|
||||
for (int i = 0; i < 3; i++)
|
||||
{
|
||||
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 4*3*i;
|
||||
((float*)VertexManager::s_pCurBufferPointer)[0] = Memory_Read_Float(iAddress);
|
||||
|
||||
@ -48,8 +48,6 @@ static const GLenum c_primitiveType[8] =
|
||||
|
||||
bool Init()
|
||||
{
|
||||
Destroy();
|
||||
|
||||
s_prevcomponents = 0;
|
||||
s_pBaseBufferPointer = (u8*)AllocateMemoryPages(MAX_BUFFER_SIZE);
|
||||
s_pCurBufferPointer = s_pBaseBufferPointer;
|
||||
@ -69,7 +67,7 @@ bool Init()
|
||||
return true;
|
||||
}
|
||||
|
||||
void Destroy()
|
||||
void Shutdown()
|
||||
{
|
||||
FreeMemoryPages(s_pBaseBufferPointer, MAX_BUFFER_SIZE); s_pBaseBufferPointer = s_pCurBufferPointer = NULL;
|
||||
glDeleteBuffers(ARRAYSIZE(s_vboBuffers), s_vboBuffers);
|
||||
|
||||
@ -25,21 +25,23 @@
|
||||
// Other functionality is moving out.
|
||||
namespace VertexManager
|
||||
{
|
||||
bool Init();
|
||||
void Destroy();
|
||||
|
||||
void ResetBuffer();
|
||||
void ResetComponents();
|
||||
bool Init();
|
||||
void Shutdown();
|
||||
|
||||
void AddVertices(int primitive, int numvertices);
|
||||
void Flush(); // flushes the current buffer
|
||||
void ResetBuffer();
|
||||
void ResetComponents();
|
||||
|
||||
int GetRemainingSize(); // remaining space in the current buffer.
|
||||
void AddVertices(int primitive, int numvertices);
|
||||
void Flush(); // flushes the current buffer
|
||||
|
||||
void EnableComponents(u32 components); // very implementation specific - D3D9 won't need this one.
|
||||
int GetRemainingSize(); // remaining space in the current buffer.
|
||||
|
||||
void EnableComponents(u32 components); // very implementation specific - D3D9 won't need this one.
|
||||
|
||||
// TODO: move, rename.
|
||||
extern u8* s_pCurBufferPointer;
|
||||
|
||||
// TODO: move, rename.
|
||||
extern u8* s_pCurBufferPointer;
|
||||
};
|
||||
|
||||
#endif // _VERTEXMANAGER_H
|
||||
|
||||
@ -49,8 +49,6 @@ extern int nBackbufferWidth, nBackbufferHeight;
|
||||
static int s_nMaxVertexInstructions;
|
||||
|
||||
static float s_fMaterials[16];
|
||||
static float rawViewport[6] = {0};
|
||||
static float rawProjection[7] = {0};
|
||||
|
||||
// track changes
|
||||
static bool bTexMatricesChanged[2], bPosNormalMatrixChanged, bProjectionChanged, bViewportChanged;
|
||||
@ -92,7 +90,7 @@ void VertexShaderMngr::Shutdown()
|
||||
}
|
||||
|
||||
float VertexShaderMngr::GetPixelAspectRatio() {
|
||||
return rawViewport[0] != 0 ? (float)Renderer::GetTargetWidth() / 640.0f : 1.0f;
|
||||
return xfregs.rawViewport[0] != 0 ? (float)Renderer::GetTargetWidth() / 640.0f : 1.0f;
|
||||
}
|
||||
|
||||
VERTEXSHADER* VertexShaderMngr::GetShader(u32 components)
|
||||
@ -378,8 +376,8 @@ void VertexShaderMngr::SetConstants()
|
||||
wAdj = ratio;
|
||||
hAdj = 1;
|
||||
|
||||
wid = ceil(fabs(2 * rawViewport[0]) / wAdj);
|
||||
hei = ceil(fabs(2 * rawViewport[1]) / hAdj);
|
||||
wid = ceil(fabs(2 * xfregs.rawViewport[0]) / wAdj);
|
||||
hei = ceil(fabs(2 * xfregs.rawViewport[1]) / hAdj);
|
||||
|
||||
actualWid = ceil((float)winw / ratio);
|
||||
actualRatiow = (float)actualWid / (float)wid; // the picture versus the screen
|
||||
@ -393,8 +391,8 @@ void VertexShaderMngr::SetConstants()
|
||||
wAdj = 1;
|
||||
hAdj = ratio;
|
||||
|
||||
wid = ceil(fabs(2 * rawViewport[0]) / wAdj);
|
||||
hei = ceil(fabs(2 * rawViewport[1]) / hAdj);
|
||||
wid = ceil(fabs(2 * xfregs.rawViewport[0]) / wAdj);
|
||||
hei = ceil(fabs(2 * xfregs.rawViewport[1]) / hAdj);
|
||||
|
||||
actualHei = ceil((float)winh / ratio);
|
||||
actualRatioh = (float)actualHei / (float)hei; // the picture versus the screen
|
||||
@ -404,52 +402,56 @@ void VertexShaderMngr::SetConstants()
|
||||
}
|
||||
else
|
||||
{
|
||||
wid = ceil(fabs(2 * rawViewport[0]));
|
||||
hei = ceil(fabs(2 * rawViewport[1]));
|
||||
wid = ceil(fabs(2 * xfregs.rawViewport[0]));
|
||||
hei = ceil(fabs(2 * xfregs.rawViewport[1]));
|
||||
}
|
||||
|
||||
if (g_Config.bStretchToFit)
|
||||
{
|
||||
glViewport(
|
||||
(int)(rawViewport[3]-rawViewport[0]-342-scissorXOff) + xoffs,
|
||||
Renderer::GetTargetHeight() - ((int)(rawViewport[4]-rawViewport[1]-342-scissorYOff)) + yoffs,
|
||||
(int)(xfregs.rawViewport[3]-xfregs.rawViewport[0]-342-scissorXOff) + xoffs,
|
||||
Renderer::GetTargetHeight() - ((int)(xfregs.rawViewport[4]-xfregs.rawViewport[1]-342-scissorYOff)) + yoffs,
|
||||
wid, // width
|
||||
hei // height
|
||||
);
|
||||
}
|
||||
else
|
||||
{
|
||||
glViewport((int)(rawViewport[3]-rawViewport[0]-342-scissorXOff) * MValueX,
|
||||
Renderer::GetTargetHeight()-((int)(rawViewport[4]-rawViewport[1]-342-scissorYOff)) * MValueY,
|
||||
abs((int)(2 * rawViewport[0])) * MValueX, abs((int)(2 * rawViewport[1])) * MValueY);
|
||||
glViewport((int)(xfregs.rawViewport[3]-xfregs.rawViewport[0]-342-scissorXOff) * MValueX,
|
||||
Renderer::GetTargetHeight()-((int)(xfregs.rawViewport[4]-xfregs.rawViewport[1]-342-scissorYOff)) * MValueY,
|
||||
abs((int)(2 * xfregs.rawViewport[0])) * MValueX, abs((int)(2 * xfregs.rawViewport[1])) * MValueY);
|
||||
}
|
||||
|
||||
// Standard depth range
|
||||
//glDepthRange(-(0.0f - (xfregs.rawViewport[5]-xfregs.rawViewport[2])/-16777215.0f), xfregs.rawViewport[5]/16777215.0f);
|
||||
|
||||
// Metroid Prime 1 & 2 likes this
|
||||
glDepthRange((g_Config.bInvertDepth ? -1 : 1) * -(0.0f - (rawViewport[5]-rawViewport[2])/16777215.0f), rawViewport[5]/16777215.0f);
|
||||
//glDepthRange(-(0.0f - (xfregs.rawViewport[5]-xfregs.rawViewport[2])/16777215.0f), xfregs.rawViewport[5]/16777215.0f);
|
||||
glDepthRange((g_Config.bInvertDepth ? -1 : 1) * -(0.0f - (xfregs.rawViewport[5]-xfregs.rawViewport[2])/16777215.0f), xfregs.rawViewport[5]/16777215.0f);
|
||||
|
||||
// FZero stage likes this (a sonic hack)
|
||||
// glDepthRange(-(0.0f - (rawViewport[5]-rawViewport[2])/-16777215.0f), rawViewport[5]/16777215.0f);
|
||||
// glDepthRange(-(0.0f - (xfregs.rawViewport[5]-xfregs.rawViewport[2])/-16777215.0f), xfregs.rawViewport[5]/16777215.0f);
|
||||
}
|
||||
|
||||
if (bProjectionChanged) {
|
||||
bProjectionChanged = false;
|
||||
|
||||
if (rawProjection[6] == 0) {
|
||||
g_fProjectionMatrix[0] = rawProjection[0];
|
||||
if (xfregs.rawProjection[6] == 0) {
|
||||
g_fProjectionMatrix[0] = xfregs.rawProjection[0];
|
||||
g_fProjectionMatrix[1] = 0.0f;
|
||||
g_fProjectionMatrix[2] = rawProjection[1];
|
||||
g_fProjectionMatrix[2] = xfregs.rawProjection[1];
|
||||
g_fProjectionMatrix[3] = 0;
|
||||
|
||||
g_fProjectionMatrix[4] = 0.0f;
|
||||
g_fProjectionMatrix[5] = rawProjection[2];
|
||||
g_fProjectionMatrix[6] = rawProjection[3];
|
||||
g_fProjectionMatrix[5] = xfregs.rawProjection[2];
|
||||
g_fProjectionMatrix[6] = xfregs.rawProjection[3];
|
||||
g_fProjectionMatrix[7] = 0;
|
||||
|
||||
g_fProjectionMatrix[8] = 0.0f;
|
||||
g_fProjectionMatrix[9] = 0.0f;
|
||||
g_fProjectionMatrix[10] = rawProjection[4];
|
||||
g_fProjectionMatrix[10] = xfregs.rawProjection[4];
|
||||
// Working bloom in ZTP
|
||||
g_fProjectionMatrix[11] = -(0.0f - rawProjection[5]); // Yes, it's important that it's done this way.
|
||||
g_fProjectionMatrix[11] = -(0.0f - xfregs.rawProjection[5]); // Yes, it's important that it's done this way.
|
||||
// Working projection in PSO
|
||||
// g_fProjectionMatrix[11] = -(1.0f - rawProjection[5]);
|
||||
|
||||
@ -459,23 +461,23 @@ void VertexShaderMngr::SetConstants()
|
||||
g_fProjectionMatrix[15] = 0.0f;
|
||||
}
|
||||
else {
|
||||
g_fProjectionMatrix[0] = rawProjection[0];
|
||||
g_fProjectionMatrix[0] = xfregs.rawProjection[0];
|
||||
g_fProjectionMatrix[1] = 0.0f;
|
||||
g_fProjectionMatrix[2] = 0.0f;
|
||||
g_fProjectionMatrix[3] = rawProjection[1];
|
||||
g_fProjectionMatrix[3] = xfregs.rawProjection[1];
|
||||
|
||||
g_fProjectionMatrix[4] = 0.0f;
|
||||
g_fProjectionMatrix[5] = rawProjection[2];
|
||||
g_fProjectionMatrix[5] = xfregs.rawProjection[2];
|
||||
g_fProjectionMatrix[6] = 0.0f;
|
||||
g_fProjectionMatrix[7] = rawProjection[3];
|
||||
g_fProjectionMatrix[7] = xfregs.rawProjection[3];
|
||||
|
||||
g_fProjectionMatrix[8] = 0.0f;
|
||||
g_fProjectionMatrix[9] = 0.0f;
|
||||
g_fProjectionMatrix[10] = rawProjection[4];
|
||||
g_fProjectionMatrix[10] = xfregs.rawProjection[4];
|
||||
// Working bloom in ZTP
|
||||
g_fProjectionMatrix[11] = -(-1.0f - rawProjection[5]); // Yes, it's important that it's done this way.
|
||||
// Working projection in PSO
|
||||
// g_fProjectionMatrix[11] = -(0.0f - rawProjection[5]);
|
||||
//g_fProjectionMatrix[11] = -(-1.0f - rawProjection[5]); // Yes, it's important that it's done this way.
|
||||
// Working projection in PSO, working Super Monkey Ball
|
||||
g_fProjectionMatrix[11] = -(0.0f - xfregs.rawProjection[5]);
|
||||
|
||||
g_fProjectionMatrix[12] = 0;
|
||||
g_fProjectionMatrix[13] = 0;
|
||||
@ -483,7 +485,7 @@ void VertexShaderMngr::SetConstants()
|
||||
g_fProjectionMatrix[15] = 1.0f;
|
||||
}
|
||||
|
||||
PRIM_LOG("Projection: %f %f %f %f %f %f\n", rawProjection[0], rawProjection[1], rawProjection[2], rawProjection[3], rawProjection[4], rawProjection[5]);
|
||||
PRIM_LOG("Projection: %f %f %f %f %f %f\n", xfregs.rawProjection[0], xfregs.rawProjection[1], xfregs.rawProjection[2], xfregs.rawProjection[3], xfregs.rawProjection[4], xfregs.rawProjection[5]);
|
||||
SetVSConstant4fv(C_PROJECTION, &g_fProjectionMatrix[0]);
|
||||
SetVSConstant4fv(C_PROJECTION+1, &g_fProjectionMatrix[4]);
|
||||
SetVSConstant4fv(C_PROJECTION+2, &g_fProjectionMatrix[8]);
|
||||
@ -591,11 +593,11 @@ void VertexShaderMngr::SetTexMatrixChangedB(u32 Value)
|
||||
void VertexShaderMngr::SetViewport(float* _Viewport)
|
||||
{
|
||||
// Workaround for paper mario, yep this is bizarre.
|
||||
for (size_t i = 0; i < ARRAYSIZE(rawViewport); ++i) {
|
||||
for (size_t i = 0; i < ARRAYSIZE(xfregs.rawViewport); ++i) {
|
||||
if (*(u32*)(_Viewport + i) == 0x7f800000) // invalid fp number
|
||||
return;
|
||||
}
|
||||
memcpy(rawViewport, _Viewport, sizeof(rawViewport));
|
||||
memcpy(xfregs.rawViewport, _Viewport, sizeof(xfregs.rawViewport));
|
||||
bViewportChanged = true;
|
||||
}
|
||||
|
||||
@ -606,12 +608,65 @@ void VertexShaderMngr::SetViewportChanged()
|
||||
|
||||
void VertexShaderMngr::SetProjection(float* _pProjection, int constantIndex)
|
||||
{
|
||||
memcpy(rawProjection, _pProjection, sizeof(rawProjection));
|
||||
memcpy(xfregs.rawProjection, _pProjection, sizeof(xfregs.rawProjection));
|
||||
bProjectionChanged = true;
|
||||
}
|
||||
|
||||
float* VertexShaderMngr::GetPosNormalMat()
|
||||
{
|
||||
return (float*)xfmem + MatrixIndexA.PosNormalMtxIdx * 4;
|
||||
}
|
||||
|
||||
// Mash together all the inputs that contribute to the code of a generated vertex shader into
|
||||
// a unique identifier, basically containing all the bits. Yup, it's a lot ....
|
||||
void VertexShaderMngr::GetVertexShaderId(VERTEXSHADERUID& vid, u32 components)
|
||||
{
|
||||
u32 zbufrender = (bpmem.ztex2.op == ZTEXTURE_ADD) || Renderer::GetZBufferTarget() != 0;
|
||||
vid.values[0] = components |
|
||||
(xfregs.numTexGens << 23) |
|
||||
(xfregs.nNumChans << 27) |
|
||||
((u32)xfregs.bEnableDualTexTransform << 29) |
|
||||
(zbufrender << 30);
|
||||
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
vid.values[1+i] = xfregs.colChans[i].color.enablelighting ?
|
||||
(u32)xfregs.colChans[i].color.hex :
|
||||
(u32)xfregs.colChans[i].color.matsource;
|
||||
vid.values[1+i] |= (xfregs.colChans[i].alpha.enablelighting ?
|
||||
(u32)xfregs.colChans[i].alpha.hex :
|
||||
(u32)xfregs.colChans[i].alpha.matsource) << 15;
|
||||
}
|
||||
|
||||
// fog
|
||||
vid.values[1] |= (((u32)bpmem.fog.c_proj_fsel.fsel & 3) << 30);
|
||||
vid.values[2] |= (((u32)bpmem.fog.c_proj_fsel.fsel >> 2) << 30);
|
||||
|
||||
u32* pcurvalue = &vid.values[3];
|
||||
for (int i = 0; i < xfregs.numTexGens; ++i) {
|
||||
TexMtxInfo tinfo = xfregs.texcoords[i].texmtxinfo;
|
||||
if (tinfo.texgentype != XF_TEXGEN_EMBOSS_MAP)
|
||||
tinfo.hex &= 0x7ff;
|
||||
if (tinfo.texgentype != XF_TEXGEN_REGULAR)
|
||||
tinfo.projection = 0;
|
||||
|
||||
u32 val = ((tinfo.hex >> 1) & 0x1ffff);
|
||||
if (xfregs.bEnableDualTexTransform && tinfo.texgentype == XF_TEXGEN_REGULAR) {
|
||||
// rewrite normalization and post index
|
||||
val |= ((u32)xfregs.texcoords[i].postmtxinfo.index << 17) | ((u32)xfregs.texcoords[i].postmtxinfo.normalize << 23);
|
||||
}
|
||||
|
||||
switch (i & 3) {
|
||||
case 0: pcurvalue[0] |= val; break;
|
||||
case 1: pcurvalue[0] |= val << 24; pcurvalue[1] = val >> 8; ++pcurvalue; break;
|
||||
case 2: pcurvalue[0] |= val << 16; pcurvalue[1] = val >> 16; ++pcurvalue; break;
|
||||
case 3: pcurvalue[0] |= val << 8; ++pcurvalue; break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// LoadXFReg 0x10
|
||||
void VertexShaderMngr::LoadXFReg(u32 transferSize, u32 baseAddress, u32 *pData)
|
||||
void LoadXFReg(u32 transferSize, u32 baseAddress, u32 *pData)
|
||||
{
|
||||
u32 address = baseAddress;
|
||||
for (int i = 0; i < (int)transferSize; i++)
|
||||
@ -622,7 +677,7 @@ void VertexShaderMngr::LoadXFReg(u32 transferSize, u32 baseAddress, u32 *pData)
|
||||
if (address < 0x1000)
|
||||
{
|
||||
VertexManager::Flush();
|
||||
InvalidateXFRange(address, address+transferSize);
|
||||
VertexShaderMngr::InvalidateXFRange(address, address + transferSize);
|
||||
//PRIM_LOG("xfmem write: 0x%x-0x%x\n", address, address+transferSize);
|
||||
|
||||
u32* p1 = &xfmem[address];
|
||||
@ -748,16 +803,16 @@ void VertexShaderMngr::LoadXFReg(u32 transferSize, u32 baseAddress, u32 *pData)
|
||||
break;
|
||||
case 0x1018:
|
||||
//_assert_msg_(GX_XF, 0, "XF matrixindex0");
|
||||
SetTexMatrixChangedA(data); //?
|
||||
VertexShaderMngr::SetTexMatrixChangedA(data); //?
|
||||
break;
|
||||
case 0x1019:
|
||||
//_assert_msg_(GX_XF, 0, "XF matrixindex1");
|
||||
SetTexMatrixChangedB(data); //?
|
||||
VertexShaderMngr::SetTexMatrixChangedB(data); //?
|
||||
break;
|
||||
|
||||
case 0x101a:
|
||||
VertexManager::Flush();
|
||||
SetViewport((float*)&pData[i]);
|
||||
VertexShaderMngr::SetViewport((float*)&pData[i]);
|
||||
i += 6;
|
||||
break;
|
||||
|
||||
@ -812,7 +867,7 @@ void VertexShaderMngr::LoadXFReg(u32 transferSize, u32 baseAddress, u32 *pData)
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (address>=0x4000)
|
||||
else if (address >= 0x4000)
|
||||
{
|
||||
// MessageBox(NULL, "1", "1", MB_OK);
|
||||
//4010 __GXSetGenMode
|
||||
@ -821,7 +876,7 @@ void VertexShaderMngr::LoadXFReg(u32 transferSize, u32 baseAddress, u32 *pData)
|
||||
}
|
||||
|
||||
// TODO - verify that it is correct. Seems to work, though.
|
||||
void VertexShaderMngr::LoadIndexedXF(u32 val, int array)
|
||||
void LoadIndexedXF(u32 val, int array)
|
||||
{
|
||||
int index = val >> 16;
|
||||
int address = val & 0xFFF; //check mask
|
||||
@ -829,61 +884,9 @@ void VertexShaderMngr::LoadIndexedXF(u32 val, int array)
|
||||
//load stuff from array to address in xf mem
|
||||
|
||||
VertexManager::Flush();
|
||||
InvalidateXFRange(address, address+size);
|
||||
VertexShaderMngr::InvalidateXFRange(address, address+size);
|
||||
//PRIM_LOG("xfmem iwrite: 0x%x-0x%x\n", address, address+size);
|
||||
|
||||
for (int i = 0; i < size; i++)
|
||||
xfmem[address + i] = Memory_Read_U32(arraybases[array] + arraystrides[array]*index + i*4);
|
||||
}
|
||||
|
||||
float* VertexShaderMngr::GetPosNormalMat()
|
||||
{
|
||||
return (float*)xfmem + MatrixIndexA.PosNormalMtxIdx * 4;
|
||||
}
|
||||
|
||||
// Mash together all the inputs that contribute to the code of a generated vertex shader into
|
||||
// a unique identifier, basically containing all the bits. Yup, it's a lot ....
|
||||
void VertexShaderMngr::GetVertexShaderId(VERTEXSHADERUID& vid, u32 components)
|
||||
{
|
||||
u32 zbufrender = (bpmem.ztex2.op == ZTEXTURE_ADD) || Renderer::GetZBufferTarget() != 0;
|
||||
vid.values[0] = components |
|
||||
(xfregs.numTexGens << 23) |
|
||||
(xfregs.nNumChans << 27) |
|
||||
((u32)xfregs.bEnableDualTexTransform << 29) |
|
||||
(zbufrender << 30);
|
||||
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
vid.values[1+i] = xfregs.colChans[i].color.enablelighting ?
|
||||
(u32)xfregs.colChans[i].color.hex :
|
||||
(u32)xfregs.colChans[i].color.matsource;
|
||||
vid.values[1+i] |= (xfregs.colChans[i].alpha.enablelighting ?
|
||||
(u32)xfregs.colChans[i].alpha.hex :
|
||||
(u32)xfregs.colChans[i].alpha.matsource) << 15;
|
||||
}
|
||||
|
||||
// fog
|
||||
vid.values[1] |= (((u32)bpmem.fog.c_proj_fsel.fsel & 3) << 30);
|
||||
vid.values[2] |= (((u32)bpmem.fog.c_proj_fsel.fsel >> 2) << 30);
|
||||
|
||||
u32* pcurvalue = &vid.values[3];
|
||||
for (int i = 0; i < xfregs.numTexGens; ++i) {
|
||||
TexMtxInfo tinfo = xfregs.texcoords[i].texmtxinfo;
|
||||
if (tinfo.texgentype != XF_TEXGEN_EMBOSS_MAP)
|
||||
tinfo.hex &= 0x7ff;
|
||||
if (tinfo.texgentype != XF_TEXGEN_REGULAR)
|
||||
tinfo.projection = 0;
|
||||
|
||||
u32 val = ((tinfo.hex >> 1) & 0x1ffff);
|
||||
if (xfregs.bEnableDualTexTransform && tinfo.texgentype == XF_TEXGEN_REGULAR) {
|
||||
// rewrite normalization and post index
|
||||
val |= ((u32)xfregs.texcoords[i].postmtxinfo.index << 17) | ((u32)xfregs.texcoords[i].postmtxinfo.normalize << 23);
|
||||
}
|
||||
|
||||
switch (i & 3) {
|
||||
case 0: pcurvalue[0] |= val; break;
|
||||
case 1: pcurvalue[0] |= val << 24; pcurvalue[1] = val >> 8; ++pcurvalue; break;
|
||||
case 2: pcurvalue[0] |= val << 16; pcurvalue[1] = val >> 16; ++pcurvalue; break;
|
||||
case 3: pcurvalue[0] |= val << 8; ++pcurvalue; break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -121,12 +121,11 @@ public:
|
||||
static void SetTexMatrixChangedA(u32 Value);
|
||||
static void SetTexMatrixChangedB(u32 Value);
|
||||
|
||||
static void LoadXFReg(u32 transferSize, u32 address, u32 *pData);
|
||||
static void LoadIndexedXF(u32 val, int array);
|
||||
|
||||
static float* GetPosNormalMat();
|
||||
static float GetPixelAspectRatio();
|
||||
};
|
||||
|
||||
void LoadXFReg(u32 transferSize, u32 address, u32 *pData);
|
||||
void LoadIndexedXF(u32 val, int array);
|
||||
|
||||
#endif
|
||||
|
||||
@ -116,27 +116,12 @@ void XFB_Write(u8 *xfb_in_ram, const TRectangle& sourceRc, u32 dstWd, u32 dstHt,
|
||||
Renderer::RestoreGLState();
|
||||
GL_REPORT_ERRORD();
|
||||
|
||||
// TODO - verify that XFB pixel order. probably reverse of GL pixel order
|
||||
// TODO - use shader for conversion
|
||||
ConvertToXFB((u32 *)xfb_in_ram, efb_buffer, dstWd, dstHt);
|
||||
|
||||
// old way
|
||||
/*glActiveTexture(GL_TEXTURE0);
|
||||
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, Renderer::GetRenderTarget());
|
||||
TextureMngr::EnableTexRECT(0);
|
||||
|
||||
glGetTexImage(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, GL_UNSIGNED_BYTE, efb_buffer);
|
||||
|
||||
static u8 *efbEndAddress = efb_buffer + ((nBackbufferWidth * nBackbufferHeight) - 1) * 4;
|
||||
ConvertToXFBReverse((u32 *)xfb_in_ram, efbEndAddress, dstWd, dstHt);*/
|
||||
|
||||
}
|
||||
|
||||
void XFB_Draw(u8 *xfb_in_ram, u32 width, u32 height, s32 yOffset)
|
||||
{
|
||||
if(width == 0 || height == 0)
|
||||
return;
|
||||
|
||||
OpenGL_Update(); // just updates the render window position and the backbuffer size
|
||||
|
||||
Renderer::SetRenderMode(Renderer::RM_Normal);
|
||||
|
||||
@ -246,7 +246,7 @@ void Video_Shutdown(void)
|
||||
VertexShaderMngr::Shutdown();
|
||||
PixelShaderMngr::Shutdown();
|
||||
Fifo_Shutdown();
|
||||
VertexManager::Destroy();
|
||||
VertexManager::Shutdown();
|
||||
TextureMngr::Shutdown();
|
||||
OpcodeDecoder_Shutdown();
|
||||
Renderer::Shutdown();
|
||||
|
||||
Reference in New Issue
Block a user