1140 lines
32 KiB
C++
1140 lines
32 KiB
C++
#include "OGL_Class.h"
|
|
#include "SCENE.h"
|
|
|
|
#define GL_TEXTURE_BASE_LEVEL 0x813C
|
|
#define GL_TEXTURE_MAX_LEVEL 0x813D
|
|
|
|
#define TileSizePo2 8
|
|
static u32 Tile[1<<(TileSizePo2*2)];
|
|
//#pragma optimize("",off)
|
|
void ATI_OptimizerToGL_ConvertRaster(s32 *pSource , u32 *pDest , s32 *pSourceLast)
|
|
{
|
|
while (pSource < pSourceLast)
|
|
{
|
|
((u8*)pDest)[0] = ((u8*)pSource)[2];
|
|
((u8*)pDest)[2] = ((u8*)pSource)[0];
|
|
((u8*)pDest)[0+4] = ((u8*)pSource)[2+4];
|
|
((u8*)pDest)[2+4] = ((u8*)pSource)[0+4];
|
|
((u8*)pDest)[0+8] = ((u8*)pSource)[2+8];
|
|
((u8*)pDest)[2+8] = ((u8*)pSource)[0+8];
|
|
((u8*)pDest)[0+12] = ((u8*)pSource)[2+12];
|
|
((u8*)pDest)[2+12] = ((u8*)pSource)[0+12];
|
|
pDest+=4;
|
|
pSource+=4;
|
|
}
|
|
}
|
|
|
|
u32 ATI_OptimizerGetHash(MAP *pSrc)
|
|
{
|
|
s32 *B1;
|
|
u32 Signature = 0;
|
|
B1 = pSrc->GetBase();
|
|
for (int Y = 0 ; Y < pSrc->SY ; Y ++)
|
|
{
|
|
s32 *B1Last = B1 + pSrc->SX;
|
|
while (B1 < B1Last)
|
|
{
|
|
Signature += *(B1++);
|
|
}
|
|
B1 += pSrc->PITCH - pSrc->SX;
|
|
}
|
|
return Signature;
|
|
}
|
|
void ATI_ComputeMipMap(u32 *pDST,u32 SizeX,u32 SizeY)
|
|
{
|
|
u32 *pDSTSave = pDST;
|
|
/* Y / 2 */
|
|
SizeY += 1;
|
|
SizeY &= ~ 1;
|
|
SizeX += 1;
|
|
SizeX &= ~ 1;
|
|
for (u32 Y = 0 ; Y < SizeY >> 1 ; Y++)
|
|
{
|
|
for (u32 X = 0 ; X < SizeX ; X++)
|
|
{
|
|
*pDST = ((*(pDSTSave+SizeX) & 0xfefefefe)>>1) + ((*(pDSTSave) & 0xfefefefe)>>1);
|
|
pDST ++;
|
|
pDSTSave++;
|
|
}
|
|
pDSTSave += SizeX;
|
|
}
|
|
// X / 2
|
|
pDSTSave -= (SizeX * SizeY);
|
|
pDST = pDSTSave;
|
|
|
|
if (SizeX & 1)
|
|
{
|
|
u32 Counter = (SizeX * SizeY) >> 2;
|
|
while (Counter--)
|
|
{
|
|
*pDST = ((*(pDSTSave+1) & 0xfefefefe)>>1) + ((*(pDSTSave) & 0xfefefefe)>>1);
|
|
pDSTSave += 2;
|
|
pDST ++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
u32 Counter = (SizeX * SizeY) >> 2;
|
|
while (Counter--)
|
|
{
|
|
*pDST = ((*(pDSTSave+1) & 0xfefefefe)>>1) + ((*(pDSTSave) & 0xfefefefe)>>1);
|
|
pDSTSave += 2;
|
|
pDST ++;
|
|
}
|
|
}
|
|
}
|
|
void ATI_OptimizerToGL(MAP *pSrc,u32 ComputeMipMap = 0)
|
|
{
|
|
/* Parse tiles */
|
|
s32 *pBASE = pSrc->GetBase();
|
|
for (int Y = 0 ; Y < pSrc->SY ; Y += 1<<TileSizePo2)
|
|
{
|
|
int W,H;
|
|
H = Y + (1<<TileSizePo2) < pSrc->SY ? (1<<TileSizePo2) : pSrc->SY - Y;
|
|
for (int X = 0 ; X < pSrc->SX ; X += 1<<TileSizePo2)
|
|
{
|
|
W = X + (1<<TileSizePo2) < pSrc->SX ? (1<<TileSizePo2) : pSrc->SX - X;
|
|
u32 *pDest = Tile;
|
|
s32 *pSource,*pSourceLasLine,*pSourceLast;
|
|
|
|
pSource = pBASE + X + Y * pSrc->PITCH;
|
|
pSourceLast = pSource + H * pSrc->PITCH ;
|
|
while (pSource < pSourceLast)
|
|
{
|
|
pSourceLasLine = pSource + (W&(~3));
|
|
memcpy(pDest, pSource ,W*sizeof(s32));
|
|
ATI_OptimizerToGL_ConvertRaster(pSource , pDest , pSourceLasLine);
|
|
pSource += (W&(~3));
|
|
pDest += (W&(~3));
|
|
pSourceLasLine = pSource + (W&3);
|
|
while (pSource < pSourceLasLine)
|
|
{
|
|
u8 swap;
|
|
((u8*)pDest)[0] = ((u8*)pSource)[2];
|
|
((u8*)pDest)[2] = ((u8*)pSource)[0];
|
|
pDest++;
|
|
pSource++;
|
|
}
|
|
pSource -= W;
|
|
pSource += pSrc->PITCH;
|
|
}
|
|
for (u32 Mp = 0 ; W>>Mp > 0 ; Mp ++ )
|
|
{
|
|
glTexSubImage2D(GL_TEXTURE_2D,
|
|
Mp,//level
|
|
X>>Mp,
|
|
Y>>Mp,
|
|
W>>Mp,H>>Mp,
|
|
GL_RGBA/*GL_BGRA_EXT*/,
|
|
GL_UNSIGNED_BYTE,
|
|
Tile);
|
|
ATI_ComputeMipMap(Tile,W >> Mp,H>>Mp);
|
|
if (ComputeMipMap == 0) Mp = 30; // Break loop
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ATI_OptimizerFromGL(int x, int y, int sx, int sy, void *buffer)
|
|
{
|
|
glReadPixels(x, y, sx, sy, GL_BGRA_EXT, GL_UNSIGNED_BYTE, buffer);
|
|
return;
|
|
|
|
glReadPixels(x, y, sx, sy, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
|
|
s32 *pSource,*pSourceLasLine,*pSourceLast;
|
|
|
|
pSource = (s32 *)buffer;
|
|
pSourceLast = pSource + sx * sy;
|
|
for (;pSource < pSourceLast; pSource++)
|
|
{
|
|
u8 swap = ((u8*)pSource)[0];
|
|
((u8*)pSource)[0] = ((u8*)pSource)[2];
|
|
((u8*)pSource)[2] = swap;
|
|
}
|
|
}
|
|
|
|
int SoftCopyTime = 0; // WAITTIME
|
|
void CopyFrameBufferToTexture(int x, int y, int x2, int y2, int textW, int textH)
|
|
{
|
|
if (SoftCopyTime < (int)timeGetTime())
|
|
{
|
|
glCopyTexSubImage2D(GL_TEXTURE_2D, 0 , x , y , x2 , y2, textW , textH);
|
|
return;
|
|
}
|
|
|
|
/* Parse tiles */
|
|
for (int Y = 0 ; Y < textH ; Y += 1<<TileSizePo2)
|
|
{
|
|
int W,H;
|
|
H = Y + (1<<TileSizePo2) < textH ? (1<<TileSizePo2) : textH - Y;
|
|
for (int X = 0 ; X < textW ; X += 1<<TileSizePo2)
|
|
{
|
|
W = X + (1<<TileSizePo2) < textW ? (1<<TileSizePo2) : textW - X;
|
|
glReadPixels(x2+X, y2+Y, W, H, GL_RGBA, GL_UNSIGNED_BYTE, Tile);
|
|
glTexSubImage2D(GL_TEXTURE_2D, 0, x+X, y+Y, W, H, GL_RGBA, GL_UNSIGNED_BYTE, Tile);
|
|
}
|
|
}
|
|
}
|
|
|
|
void OGL_DI::SetFog(u32 OnOff,float NearV , float farV , u32 Color)
|
|
{
|
|
if (OnOff)
|
|
{
|
|
glEnable(GL_FOG);
|
|
glFogi(GL_FOG_MODE,GL_LINEAR);
|
|
glFogf(GL_FOG_START,NearV);
|
|
glFogf(GL_FOG_END,farV);
|
|
float Col[4] = {1,1,1,1};
|
|
glFogfv(GL_FOG_COLOR,Col);
|
|
} else
|
|
{
|
|
glDisable(GL_FOG);
|
|
}
|
|
|
|
}
|
|
|
|
void OGL_DI::SetViewport(s32 X,s32 Y,s32 SX,s32 SY)
|
|
{
|
|
float AreaX,AreaY;
|
|
float fSX,fSW;
|
|
AreaX = CurrentRect.right - CurrentRect.left;
|
|
AreaY = CurrentRect.bottom - CurrentRect.top;
|
|
fSW = SY * AreaX/AreaY;
|
|
CurrentViewport[0] = X;
|
|
CurrentViewport[1] = Y;
|
|
CurrentViewport[2] = SX;
|
|
CurrentViewport[3] = SY;
|
|
|
|
glViewport((float)X - (fSW - (float)SX) / 2.0f, Y, fSW, SY);
|
|
glScissor(X<0 ? 0 : X, Y<0 ? 0 : Y, SX, SY);
|
|
glViewport(X, Y, SX, SY);
|
|
SetClipping(X, Y, SX, SY);
|
|
|
|
ActivRect.left = X;
|
|
ActivRect.top = Y;
|
|
ActivRect.right = X + SX;
|
|
ActivRect.bottom = Y + SY;
|
|
|
|
}
|
|
|
|
void OGL_DI::SetClipping(s32 X,s32 Y,s32 SX,s32 SY)
|
|
{
|
|
ScissorRect.right = X;
|
|
ScissorRect.top = Y;
|
|
ScissorRect.bottom = Y + SY;
|
|
ScissorRect.left = X + SX;
|
|
glScissor(X, Y, SX, SY);
|
|
glEnable(GL_SCISSOR_TEST);
|
|
}
|
|
|
|
void OGL_DI::BeginTextureTarget(u32 TextureIndex,u32 SaveFrontBuffer)
|
|
{
|
|
/* if not used since a long time */
|
|
if ((TextureIndex != -1) && (AllRef[TextureIndex].CacheCounter > 5000))
|
|
{
|
|
/* Then Reload it */
|
|
CreateTexture(TextureIndex,AllRef[TextureIndex].ColorMode);
|
|
}
|
|
|
|
QuadRotation_ON = 0;
|
|
ZBIas = 1.0f;
|
|
memcpy(SavedCurrentViewport,CurrentViewport,sizeof(SavedCurrentViewport));
|
|
RenderTargetState = 1;
|
|
RenderTargetBaseX = CurrentViewport[0];
|
|
RenderTargetBaseY = CurrentViewport[1];
|
|
if (RenderTargetBaseX + AllRef[TextureIndex].pExtRef->SX > FB_SX) RenderTargetBaseX = FB_SX - AllRef[TextureIndex].pExtRef->SX ;
|
|
if (RenderTargetBaseY + AllRef[TextureIndex].pExtRef->SY > FB_SY) RenderTargetBaseY = FB_SY - AllRef[TextureIndex].pExtRef->SY ;
|
|
if (RenderTargetBaseX < 0) RenderTargetBaseX = 0;
|
|
if (RenderTargetBaseY < 0) RenderTargetBaseY = 0;
|
|
|
|
SetViewport(RenderTargetBaseX,RenderTargetBaseY,AllRef[TextureIndex].pExtRef->SX,AllRef[TextureIndex].pExtRef->SY);
|
|
|
|
if (MotherClass) MotherClass->PickReportCurrent.PickFrozed++;
|
|
/* Save front buffer */
|
|
if (SaveFrontBuffer)
|
|
{
|
|
RenderTargetState |= 2;
|
|
ValidateLayer(NUMBER_OF_WORKING_REF - 3);
|
|
CopyFrameBufferToTexture(0, 0, RenderTargetBaseX , RenderTargetBaseY, AllRef[TextureIndex].pExtRef->SX, AllRef[TextureIndex].pExtRef->SY);
|
|
//YTEST glCopyTexSubImage2D(GL_TEXTURE_2D, 0 , 0 , 0 , RenderTargetBaseX , RenderTargetBaseY, AllRef[TextureIndex].pExtRef->SX, AllRef[TextureIndex].pExtRef->SY);
|
|
}
|
|
/* Reload Texture */
|
|
SetBackGround(TextureIndex);
|
|
glViewport(RenderTargetBaseX, RenderTargetBaseY, AllRef[TextureIndex].pExtRef->SX, AllRef[TextureIndex].pExtRef->SY);
|
|
glScissor(RenderTargetBaseX, RenderTargetBaseY, AllRef[TextureIndex].pExtRef->SX, AllRef[TextureIndex].pExtRef->SY);//*/
|
|
ActivRect.left = RenderTargetBaseX;
|
|
ActivRect.top = RenderTargetBaseY;
|
|
ActivRect.right = AllRef[TextureIndex].pExtRef->SX + RenderTargetBaseX;
|
|
ActivRect.bottom = AllRef[TextureIndex].pExtRef->SY + RenderTargetBaseY;
|
|
AllRef[TextureIndex].IsMipMapped = 0;
|
|
/* Save front buffer */
|
|
CurrentRect.left = CurrentRect.top = 0;
|
|
CurrentRect.right = AllRef[TextureIndex].pExtRef->SX;
|
|
CurrentRect.bottom = AllRef[TextureIndex].pExtRef->SY;//*/
|
|
}
|
|
|
|
void OGL_DI::EndTextureTarget(u32 TextureIndex,u32 bUpdateSoftBuffer)
|
|
{
|
|
QuadRotation_ON = 0;
|
|
glBindTexture(GL_TEXTURE_2D, AllRef[TextureIndex].OGLRef);
|
|
AllRef[TextureIndex].IsMipMapped = 0;
|
|
glEnable(GL_TEXTURE_2D);
|
|
CopyFrameBufferToTexture(0, 0, RenderTargetBaseX , RenderTargetBaseY, AllRef[TextureIndex].pExtRef->SX, AllRef[TextureIndex].pExtRef->SY);
|
|
//YTEST glCopyTexSubImage2D(GL_TEXTURE_2D, 0 , 0 , 0 , RenderTargetBaseX , RenderTargetBaseY, AllRef[TextureIndex].pExtRef->SX, AllRef[TextureIndex].pExtRef->SY);
|
|
if (bUpdateSoftBuffer && !(MotherClass && MotherClass->SkipFunctions & SKIP_GLREAD))
|
|
ATI_OptimizerFromGL(RenderTargetBaseX,RenderTargetBaseY,AllRef[TextureIndex].pExtRef->PITCH, AllRef[TextureIndex].pExtRef->SY, AllRef[TextureIndex].pExtRef->GetBase());
|
|
// restore front buffer
|
|
if (RenderTargetState & 2)
|
|
{
|
|
LayerOperation(5,NUMBER_OF_WORKING_REF - 3,0xffffffff,0.0f,0.0f) ;
|
|
}
|
|
CurrentRect = hDCRect;
|
|
SetViewport(SavedCurrentViewport[0],SavedCurrentViewport[1],SavedCurrentViewport[2],SavedCurrentViewport[3]);
|
|
RenderTargetBaseX = RenderTargetBaseY = RenderTargetState = 0;
|
|
if (MotherClass && MotherClass->PickReportCurrent.PickFrozed) MotherClass->PickReportCurrent.PickFrozed--;
|
|
ZBIas = 1.0f;
|
|
}
|
|
|
|
void OGL_DI::ValidateLayer(u32 Index)
|
|
{
|
|
Index %= NUMBER_OF_OGL_WORKING_REF;
|
|
if (OGLWorkingRef[Index] != -1)
|
|
{
|
|
glEnable(GL_TEXTURE_2D);
|
|
glBindTexture(GL_TEXTURE_2D, OGLWorkingRef[Index]);
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
|
|
|
|
/* if (((FrameNumber + Index ) & 8191) == 0)
|
|
{
|
|
GLint param;
|
|
glGetTexParameteriv(GL_TEXTURE_2D ,GL_TEXTURE_RESIDENT,¶m);
|
|
if (!param)
|
|
{
|
|
// ForceReload
|
|
glDeleteTextures(1, &OGLWorkingRef[Index]);
|
|
OGLWorkingRef[Index] = -1;
|
|
}
|
|
}//*/
|
|
}
|
|
if (OGLWorkingRef[Index] == -1)
|
|
{
|
|
glGenTextures(1, &OGLWorkingRef[Index]);
|
|
glBindTexture(GL_TEXTURE_2D, OGLWorkingRef[Index]);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BORDER,0);
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
glEnable(GL_TEXTURE_2D);
|
|
if (Index == NUMBER_OF_OGL_WORKING_REF-1)
|
|
//glCopyTexImage2D(GL_TEXTURE_2D, 0 , GL_LUMINANCE, 0 , 0 , OGLTextureSizeX, OGLTextureSizeY, 0);
|
|
glTexImage2D(GL_TEXTURE_2D, 0 , GL_LUMINANCE , OGLTextureSizeX, OGLTextureSizeY, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
|
|
else
|
|
//glCopyTexImage2D(GL_TEXTURE_2D, 0 , GL_RGBA, 0 , 0 , OGLTextureSizeX, OGLTextureSizeY, 0);
|
|
glTexImage2D(GL_TEXTURE_2D, 0 , GL_RGBA, OGLTextureSizeX, OGLTextureSizeY, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
|
|
}
|
|
}
|
|
u32 OGL_DI::GetTexFreeIndex()
|
|
{
|
|
static u32 Counter = MaxOglTexture;
|
|
while (Counter--)
|
|
{
|
|
if (AllRef[Counter].OGLRef == 0xffffffff) return Counter;
|
|
}
|
|
Counter = MaxOglTexture;
|
|
while (Counter--)
|
|
{
|
|
if (AllRef[Counter].OGLRef == 0xffffffff) return Counter;
|
|
}
|
|
return -1;
|
|
}
|
|
void OGL_DI::DrawLine(u32 Color,Vector *A,Vector *B, int Lenght)
|
|
{
|
|
if (Lenght)
|
|
{
|
|
glLineWidth((float)Lenght);
|
|
glEnable(GL_LINE_SMOOTH);
|
|
glEnable(GL_LINE_WIDTH);
|
|
} else
|
|
glLineWidth(1.0);
|
|
|
|
glBegin(GL_LINE_STRIP);
|
|
glColor4ubv((GLubyte *) &Color);
|
|
glTexCoord2f(0.0f,0.0f);
|
|
glVertex3fv((GLfloat *)A);
|
|
glTexCoord2f(1.0f,1.0f);
|
|
glVertex3fv((GLfloat *)B);
|
|
glEnd( );
|
|
|
|
if (Lenght)
|
|
{
|
|
glDisable(GL_LINE_SMOOTH);
|
|
glDisable(GL_LINE_WIDTH);
|
|
glLineWidth(1.0);
|
|
}
|
|
}
|
|
|
|
void OGL_DI::ReadFrameBuffer(s32 X,s32 Y,s32 SX,s32 SY, MAP *dest)
|
|
{
|
|
if (!(MotherClass && MotherClass->SkipFunctions & SKIP_GLREAD))
|
|
//glReadPixels(X,Y,SX,SY,GL_BGRA_EXT,GL_UNSIGNED_BYTE, dest->GetBase());
|
|
ATI_OptimizerFromGL(X,Y,SX,SY,dest->GetBase());
|
|
}
|
|
|
|
|
|
void OGL_DI::UpdateTexture_BM_2_HW(u32 TextureIndex, bool isDynamic)
|
|
{
|
|
if (MotherClass && MotherClass->SkipFunctions & SKIP_GLWRITE)
|
|
return;
|
|
glBindTexture(GL_TEXTURE_2D, AllRef[TextureIndex].OGLRef);
|
|
glEnable(GL_TEXTURE_2D);
|
|
if (AllRef[TextureIndex].pExtRef->GetBase())
|
|
{
|
|
u32 NewHash = ATI_OptimizerGetHash(AllRef[TextureIndex].pExtRef);
|
|
if (AllRef[TextureIndex].LastHash != NewHash)
|
|
ATI_OptimizerToGL(AllRef[TextureIndex].pExtRef,AllRef[TextureIndex].IsMipMapped);
|
|
AllRef[TextureIndex].LastHash = NewHash;
|
|
|
|
//glTexSubImage2D(GL_TEXTURE_2D,0,0,0,AllRef[TextureIndex].pExtRef->PITCH,AllRef[TextureIndex].pExtRef->SY,GL_RGBA/*GL_BGRA_EXT*/,GL_UNSIGNED_BYTE,AllRef[TextureIndex].pExtRef->GetBase());//*/
|
|
}
|
|
};
|
|
void OGL_DI::UpdateTexture_HW_2_BM(u32 TextureIndex,u32 bUpdateSoftBuffer,s32 X, s32 Y)
|
|
{
|
|
glBindTexture(GL_TEXTURE_2D, AllRef[TextureIndex].OGLRef);
|
|
glEnable(GL_TEXTURE_2D);
|
|
AllRef[TextureIndex].IsMipMapped = 0;
|
|
|
|
CopyFrameBufferToTexture(0, 0, X , Y, AllRef[TextureIndex].pExtRef->SX, AllRef[TextureIndex].pExtRef->SY);
|
|
//YTEST glCopyTexSubImage2D(GL_TEXTURE_2D, 0 , 0 , 0 , X , Y, AllRef[TextureIndex].pExtRef->SX, AllRef[TextureIndex].pExtRef->SY);
|
|
if (bUpdateSoftBuffer && !(MotherClass && MotherClass->SkipFunctions & SKIP_GLREAD))
|
|
//glReadPixels(X,Y,AllRef[TextureIndex].pExtRef->PITCH, AllRef[TextureIndex].pExtRef->SY,GL_BGRA_EXT,GL_UNSIGNED_BYTE,AllRef[TextureIndex].pExtRef->GetBase());
|
|
ATI_OptimizerFromGL(X,Y,AllRef[TextureIndex].pExtRef->PITCH, AllRef[TextureIndex].pExtRef->SY,AllRef[TextureIndex].pExtRef->GetBase());
|
|
};
|
|
|
|
|
|
void OGL_DI::SetTextureColorMode(u32 Index,u32 ColorMode)
|
|
{
|
|
if (Index != -1)
|
|
{
|
|
if (ColorMode != AllRef[Index].ColorMode)
|
|
{
|
|
if (AllRef[Index].pExtRef)
|
|
{
|
|
if (AllRef[Index].OGLRef != -1)
|
|
{
|
|
glDeleteTextures(1, &AllRef[Index].OGLRef);
|
|
AllRef[Index].LastHash = -1;
|
|
CreateTexture(Index,ColorMode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
void OGL_DI::CreateTexture(u32 IndexToCreate,u32 ColorMode)
|
|
{
|
|
glGenTextures(1, &AllRef[IndexToCreate].OGLRef);
|
|
|
|
//GLenum truffe = glGetError();
|
|
//if (truffe != GL_NO_ERROR)
|
|
// MessageBox(NULL, "EEEERRRRR", "YouUp", MB_OK | MB_ICONWARNING);
|
|
//}
|
|
|
|
AllRef[IndexToCreate].ColorMode = ColorMode; // RGBA
|
|
AllRef[IndexToCreate].ClampMode = 0;
|
|
AllRef[IndexToCreate].LayerIndex = -1;
|
|
AllRef[IndexToCreate].CacheCounter = 0;
|
|
AllRef[IndexToCreate].LastHash = -1;
|
|
AllRef[IndexToCreate].IsMipMapped = 1;
|
|
glEnable(GL_TEXTURE_2D);
|
|
glBindTexture(GL_TEXTURE_2D, AllRef[IndexToCreate].OGLRef);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
|
|
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BORDER,0);
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
/* glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);//*/
|
|
|
|
switch (ColorMode)
|
|
{
|
|
case 1://glCopyTexImage2D(GL_TEXTURE_2D, 0 , GL_LUMINANCE, 0 , 0 , GetUpperPO2(AllRef[IndexToCreate].pExtRef->SX), GetUpperPO2(AllRef[IndexToCreate].pExtRef->SY), 0);break;
|
|
for (u32 Clk = 0 ; (GetUpperPO2(AllRef[IndexToCreate].pExtRef->SX)>>Clk > 0) && (GetUpperPO2(AllRef[IndexToCreate].pExtRef->SY)>>Clk > 0); Clk ++)
|
|
glTexImage2D(GL_TEXTURE_2D, Clk , GL_LUMINANCE, GetUpperPO2(AllRef[IndexToCreate].pExtRef->SX), GetUpperPO2(AllRef[IndexToCreate].pExtRef->SY)>>Clk, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
|
|
break;
|
|
default://glCopyTexImage2D(GL_TEXTURE_2D, 0 , GL_RGBA, 0 , 0 , GetUpperPO2(AllRef[IndexToCreate].pExtRef->SX), GetUpperPO2(AllRef[IndexToCreate].pExtRef->SY), 0);break;
|
|
for (u32 Clk = 0 ; (GetUpperPO2(AllRef[IndexToCreate].pExtRef->SX)>>Clk > 0) && (GetUpperPO2(AllRef[IndexToCreate].pExtRef->SY)>>Clk > 0); Clk ++)
|
|
glTexImage2D(GL_TEXTURE_2D, Clk , GL_RGBA, GetUpperPO2(AllRef[IndexToCreate].pExtRef->SX)>>Clk, GetUpperPO2(AllRef[IndexToCreate].pExtRef->SY)>>Clk, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
|
|
break;
|
|
}
|
|
/* Fill in black */
|
|
|
|
if (
|
|
(GetUpperPO2(AllRef[IndexToCreate].pExtRef->SX) > 16) &&
|
|
(GetUpperPO2(AllRef[IndexToCreate].pExtRef->SY) > 16)
|
|
)
|
|
{
|
|
u32 BlackMap[16 * 16];
|
|
memset(BlackMap,0,sizeof(BlackMap));
|
|
for (u32 XC = 0 ; XC < GetUpperPO2(AllRef[IndexToCreate].pExtRef->SX) ; XC += 16)
|
|
for (u32 YC = 0 ; YC < GetUpperPO2(AllRef[IndexToCreate].pExtRef->SY) ; YC += 16)
|
|
for (u32 Mp = 0 ; Mp < 8 ; Mp++)
|
|
glTexSubImage2D(GL_TEXTURE_2D,Mp ,XC>>Mp ,YC>>Mp ,16>>Mp ,16>>Mp ,GL_RGBA,GL_UNSIGNED_BYTE,BlackMap);
|
|
}
|
|
//*/
|
|
UpdateTexture_BM_2_HW(IndexToCreate);
|
|
}
|
|
u32 OGL_DI::CreateTexture(MAP *pExternalReferenceRGBA,u32 ColorMode, bool forceCreation)
|
|
{
|
|
u32 Index = GetTexFreeIndex();
|
|
if (Index == -1) return -1;
|
|
AllRef[Index].pExtRef = pExternalReferenceRGBA;
|
|
|
|
if (forceCreation)
|
|
{
|
|
CreateTexture(Index,ColorMode);
|
|
} else
|
|
{
|
|
AllRef[Index].CacheCounter = 5001;
|
|
AllRef[Index].OGLRef = -2;
|
|
}
|
|
return Index;
|
|
}
|
|
u32 OGL_DI::CreateLayerTexture(MAP *pExternalReferenceRGBA,u32 LayerIndex)
|
|
{
|
|
u32 Index = GetTexFreeIndex();
|
|
if (Index == -1) return -1;
|
|
AllRef[Index].CacheCounter = 0;
|
|
AllRef[Index].pExtRef = pExternalReferenceRGBA;
|
|
AllRef[Index].ColorMode = 0; // RGBA
|
|
ValidateLayer(LayerIndex % NUMBER_OF_OGL_WORKING_REF);
|
|
AllRef[Index].OGLRef = OGLWorkingRef[LayerIndex % NUMBER_OF_OGL_WORKING_REF];
|
|
AllRef[Index].ClampMode = 0;
|
|
AllRef[Index].LayerIndex = LayerIndex;
|
|
AllRef[Index].IsMipMapped = 0;
|
|
return Index;
|
|
}
|
|
void OGL_DI::DestroyLayerTexture(u32 TextureIndex)
|
|
{
|
|
if ((TextureIndex != -1) && (AllRef[TextureIndex].OGLRef != -1))
|
|
{
|
|
AllRef[TextureIndex].OGLRef = -1; // NOT DESTROY IN HARD !!
|
|
}
|
|
};
|
|
void OGL_DI::DestroyTexture(u32 TextureIndex)
|
|
{
|
|
if ((TextureIndex != -1) && (AllRef[TextureIndex].OGLRef != -1))
|
|
{
|
|
glDeleteTextures(1, &AllRef[TextureIndex].OGLRef);
|
|
AllRef[TextureIndex].OGLRef = -1;
|
|
AllRef[TextureIndex].LastHash = -1;
|
|
// AllRef[TextureIndex].pExtRef = NULL;
|
|
}
|
|
};
|
|
|
|
void OGL_DI::Setexture(u32 TextureIndex,float *UVMatrix)
|
|
{
|
|
/* if not used since a long time */
|
|
if ((TextureIndex != -1) && (AllRef[TextureIndex].CacheCounter > 5000))
|
|
{
|
|
/* Then Reload it */
|
|
CreateTexture(TextureIndex,AllRef[TextureIndex].ColorMode);
|
|
}
|
|
if ((TextureIndex == -1) || (AllRef[TextureIndex].OGLRef == -1))
|
|
{
|
|
glDisable(GL_TEXTURE_2D);
|
|
ulCurrentTexture = -1;
|
|
}
|
|
else
|
|
{
|
|
float FakeUVMatrix[] = {1,0,0,1,0,0};
|
|
float BorderCorectionUVMatrix[] = {1,0,0,1,0,0};
|
|
if (UVMatrix == NULL) UVMatrix = (float*)&FakeUVMatrix;
|
|
glEnable(GL_TEXTURE_2D);
|
|
glBindTexture(GL_TEXTURE_2D, AllRef[TextureIndex].OGLRef);
|
|
AllRef[TextureIndex].CacheCounter = 0;
|
|
if (((FrameNumber + TextureIndex ) & 8191) == 0)
|
|
{
|
|
GLint param;
|
|
glGetTexParameteriv(GL_TEXTURE_2D ,GL_TEXTURE_RESIDENT,¶m);
|
|
if (!param)
|
|
{
|
|
// Force Re-create
|
|
glDeleteTextures(1, &AllRef[TextureIndex].OGLRef);
|
|
AllRef[TextureIndex].LastHash = -1;
|
|
|
|
CreateTexture(TextureIndex,0);
|
|
glBindTexture(GL_TEXTURE_2D, AllRef[TextureIndex].OGLRef);
|
|
}
|
|
}//*/
|
|
|
|
ulCurrentTexture = TextureIndex;
|
|
|
|
if (ulCurrentTexture != -1)
|
|
{
|
|
float CX,CY,YC;
|
|
//(float)AllRef[ulCurrentTexture].pExtRef->SX / GetUpperPO2((float)AllRef[ulCurrentTexture].pExtRef->SX)
|
|
CX = (float)AllRef[ulCurrentTexture].pExtRef->SX / GetUpperPO2((float)AllRef[ulCurrentTexture].pExtRef->SX);
|
|
CY = (float)AllRef[ulCurrentTexture].pExtRef->SY / GetUpperPO2((float)AllRef[ulCurrentTexture].pExtRef->SY);
|
|
if ((CX != 1.0f) || (CY != 1.0f))
|
|
{
|
|
float BCX,BCY;
|
|
|
|
memcpy(BorderCorectionUVMatrix,UVMatrix,sizeof(BorderCorectionUVMatrix));
|
|
|
|
if (CX != 1.0f)
|
|
{
|
|
BCX = ((float)(AllRef[ulCurrentTexture].pExtRef->SX - 1) / GetUpperPO2((float)AllRef[ulCurrentTexture].pExtRef->SX)) / CX;
|
|
BorderCorectionUVMatrix[0] *= BCX;
|
|
BorderCorectionUVMatrix[2] *= BCX;
|
|
BorderCorectionUVMatrix[4] *= BCX;
|
|
}
|
|
|
|
if (CY != 1.0f)
|
|
{
|
|
BCY = ((float)(AllRef[ulCurrentTexture].pExtRef->SY - 1) / GetUpperPO2((float)AllRef[ulCurrentTexture].pExtRef->SY)) / CY;
|
|
BorderCorectionUVMatrix[1] *= BCY;
|
|
BorderCorectionUVMatrix[3] *= BCY;
|
|
BorderCorectionUVMatrix[5] *= BCY;
|
|
UVMatrix = (float *)BorderCorectionUVMatrix;
|
|
}
|
|
}
|
|
|
|
|
|
GLfloat Persp2[16]= {
|
|
CX*UVMatrix[0], CY*UVMatrix[1], 0, 0,
|
|
CX*UVMatrix[2], CY*UVMatrix[3], 0, 0,
|
|
0, 0, 1, 0,
|
|
CX*UVMatrix[4], CY*UVMatrix[5], 0, 1,
|
|
};
|
|
SetMatrix(GL_TEXTURE,Persp2);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
void OGL_DI::Perspective(float f)
|
|
{
|
|
float AX,AY;
|
|
AX = ActivRect.right - ActivRect.left;
|
|
AY = ActivRect.bottom - ActivRect.top;
|
|
if (f < 0.0f)
|
|
{
|
|
GLfloat _4x4[16] = {
|
|
-2.0f/f,0, 0, 0,
|
|
0, -2.0f/f*AX/AY, 0, 0,
|
|
0, 0, -0.1, 0,
|
|
0, 0, 0, 1,
|
|
};
|
|
SetMatrix(GL_PROJECTION,_4x4);
|
|
|
|
} else
|
|
{
|
|
GLfloat _4x4[16] = {
|
|
f, 0, 0, 0,
|
|
0,f*AX/AY, 0, 0,
|
|
0, 0, 0, 1,
|
|
0, 0, 0.1, 0,
|
|
};
|
|
SetMatrix(GL_PROJECTION,_4x4);
|
|
}
|
|
fFocUsed = f;
|
|
}
|
|
|
|
void OGL_DI::Holographic(Vector *pUP,float wx)
|
|
{
|
|
float AX,AY;
|
|
float f;
|
|
AX = ActivRect.right - ActivRect.left;
|
|
AY = ActivRect.bottom - ActivRect.top;
|
|
|
|
f = pUP->z / wx ;
|
|
float Xp = (pUP->x );
|
|
float Yp = (pUP->y );
|
|
float Zp = (-pUP->z );
|
|
|
|
GLfloat _4x4[16] =
|
|
{
|
|
-f, 0, 0, 0,
|
|
0, -f*AX/AY, 0, 0,
|
|
Xp/wx, Yp/wx*AX/AY, -pUP->z * 0.025, 1,
|
|
0, 0, 0.1, pUP->z,
|
|
};
|
|
|
|
|
|
SetMatrix(GL_PROJECTION,_4x4);
|
|
|
|
}
|
|
#define MACRO_OrthoMat(l,r,b,t,n,f)\
|
|
{\
|
|
2/(r-l),0, 0, -(r+l)/(r-l),\
|
|
0, 2/(t-b),0, -(t+b)/(t-b),\
|
|
0, 0, -2/(f-n), -(f+n)/(f-n),\
|
|
0, 0, 0, 1,\
|
|
};
|
|
|
|
|
|
void OGL_DI::Ortho() // PIXEL mode ortho (ex Draw point 10,10 mean pixel 10,10)
|
|
{
|
|
float AreaX,AreaY;
|
|
AreaX = CurrentRect.right - CurrentRect.left;
|
|
AreaY = CurrentRect.bottom - CurrentRect.top;
|
|
|
|
GLfloat _4x4[16] =
|
|
MACRO_OrthoMat((-1.0), (1.0f), (AreaY/AreaX), (-AreaY/AreaX), (-1.0), (1.0));
|
|
|
|
SetMatrix(GL_PROJECTION,_4x4);
|
|
|
|
fFocUsed = 0;
|
|
}
|
|
|
|
void OGL_DI::Clear(u32 Color)
|
|
{
|
|
MousePickingCurrentZ = -100000000.0f;
|
|
glDepthMask(GL_TRUE);
|
|
|
|
if (QuadHideColor & 1)
|
|
glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,(QuadHideColor & 2) ? GL_FALSE : GL_TRUE);
|
|
else
|
|
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, (QuadHideColor & 2) ? GL_FALSE : GL_TRUE);
|
|
glClearDepth(0);
|
|
glClearColor((float)((Color>>0)&0xff)/256.0f,(float)((Color>>8)&0xff)/256.0f,(float)((Color>>16)&0xff)/256.0f,(float)((Color>>24)&0xff)/256.0f);
|
|
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
|
|
ZBIas = 1.0f;
|
|
FORCE_RENDER_FLAG |= 4;
|
|
};
|
|
|
|
void OGL_DI::ClearZ()
|
|
{
|
|
MousePickingCurrentZ = -100000000.0f;
|
|
glDepthMask(GL_TRUE);
|
|
glClearDepth(0);
|
|
glClear(GL_DEPTH_BUFFER_BIT);
|
|
ZBIas = 1.0f;
|
|
FORCE_RENDER_FLAG |= 4;
|
|
};
|
|
|
|
|
|
void OGL_DI::Matrix(MATRIX *MatrixToSet)
|
|
{
|
|
if (MatrixToSet)
|
|
{
|
|
GLfloat _4x4[16];
|
|
memset(_4x4,0,sizeof(_4x4));
|
|
*(Vector *)&_4x4[0] = MatrixToSet->I;
|
|
*(Vector *)&_4x4[4] = MatrixToSet->J;
|
|
*(Vector *)&_4x4[8] = MatrixToSet->K;
|
|
*(Vector *)&_4x4[12] = MatrixToSet->T;
|
|
_4x4[15] = 1.0f;
|
|
|
|
SetMatrix(GL_MODELVIEW,_4x4);
|
|
} else
|
|
{
|
|
SetMatrix(GL_MODELVIEW,NULL);
|
|
}
|
|
}
|
|
|
|
#define ENABLE(a,b) { b!=0 ? glEnable(a) : glDisable(a); }
|
|
//#pragma optimize ("",off)
|
|
void OGL_DI::SetRS(RS *RM1,u32 TextureIndex)
|
|
{
|
|
RS LocalRM;
|
|
START_RASTER(SetRenderState);
|
|
|
|
LocalRM = *RM1;
|
|
|
|
if (MotherClass)
|
|
{
|
|
u8 *pBase,*pEnd,*pOr,*pAnd;
|
|
pBase = (u8*)&LocalRM;
|
|
pEnd = pBase + sizeof(RS);
|
|
pOr = (u8*)&(MotherClass->MaterialOr.RenderState);
|
|
pAnd = (u8*)&(MotherClass->MaterialAnd.RenderState);
|
|
while (pBase < pEnd) *(pBase++) = (*(pBase) & *(pAnd++)) | *(pOr++);
|
|
TextureIndex = ( TextureIndex & MotherClass->MaterialAnd.TextureMediaIndex) | MotherClass->MaterialOr.TextureMediaIndex;
|
|
}
|
|
if (FORCE_RENDER_FLAG & (4+8))
|
|
{
|
|
LastRS = LocalRM;
|
|
u8 Xor,*pBase,*pEnd;
|
|
pBase = (u8*)&LastRS;
|
|
pEnd = pBase + sizeof(RS);
|
|
while (pBase < pEnd) *(pBase++) ^= 0xff;
|
|
FORCE_RENDER_FLAG &= ~4;
|
|
}
|
|
if (LastRS.BACKFACE != LocalRM.BACKFACE)
|
|
{
|
|
if (LocalRM.BACKFACE)
|
|
{
|
|
glEnable(GL_CULL_FACE);
|
|
} else
|
|
{
|
|
glDisable(GL_CULL_FACE);
|
|
}
|
|
}
|
|
|
|
if (FORCE_RENDER_FLAG & 2)
|
|
{
|
|
ENABLE(GL_DEPTH_TEST,0);
|
|
}
|
|
else
|
|
{
|
|
if (LastRS.NOZTEST != LocalRM.NOZTEST)
|
|
ENABLE(GL_DEPTH_TEST,(LocalRM.NOZTEST^1));
|
|
}
|
|
|
|
if (LastRS.WIRED != LocalRM.WIRED)
|
|
{
|
|
LocalRM.WIRED == 0 ? glPolygonMode(GL_FRONT_AND_BACK, GL_FILL) : glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
|
|
}
|
|
|
|
if (FORCE_RENDER_FLAG & 1)
|
|
glDepthMask(GL_FALSE);
|
|
else
|
|
{
|
|
if (LastRS.NOZWRITE != LocalRM.NOZWRITE)
|
|
LocalRM.NOZWRITE == 0 ? glDepthMask(GL_TRUE) : glDepthMask(GL_FALSE);
|
|
}
|
|
|
|
|
|
if (LastRS.BACKFACE_INVERT != LocalRM.BACKFACE_INVERT)
|
|
{
|
|
LocalRM.BACKFACE_INVERT == 0 ? glCullFace(GL_FRONT) : glCullFace(GL_BACK);
|
|
}
|
|
|
|
if (LastRS.TEXTURED != LocalRM.TEXTURED)
|
|
ENABLE(GL_TEXTURE_2D,LocalRM.TEXTURED);
|
|
|
|
if (LastRS.BlendingMode != LocalRM.BlendingMode)
|
|
{
|
|
if (LocalRM.BlendingMode)
|
|
{
|
|
glEnable(GL_BLEND);
|
|
switch (LocalRM.BlendingMode)
|
|
{
|
|
case 1://Alpha
|
|
//LocalRM.AlphaThreshold = 5;
|
|
if (LocalRM.INVERTALPHA)
|
|
glBlendFunc(GL_ONE_MINUS_SRC_ALPHA,GL_SRC_ALPHA);
|
|
else
|
|
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
|
|
break;
|
|
case 2://add
|
|
glBlendFunc(GL_ONE,GL_ONE);
|
|
break;
|
|
case 3://Alpha premult
|
|
if (LocalRM.INVERTALPHA)
|
|
glBlendFunc(GL_ONE,GL_SRC_ALPHA);
|
|
else
|
|
glBlendFunc(GL_ONE,GL_ONE_MINUS_SRC_ALPHA);
|
|
break;
|
|
case 4://PREVIOUS ALPHA
|
|
if (LocalRM.INVERTALPHA)
|
|
glBlendFunc(GL_ONE_MINUS_DST_ALPHA,GL_DST_ALPHA);
|
|
else
|
|
glBlendFunc(GL_DST_ALPHA,GL_ONE_MINUS_DST_ALPHA);
|
|
break;
|
|
case 5://Multiply
|
|
glBlendFunc(GL_DST_COLOR,GL_ZERO);
|
|
break;
|
|
case 6://Multiply Invert
|
|
glBlendFunc(GL_ZERO,GL_ONE_MINUS_SRC_COLOR);
|
|
break;
|
|
case 7://Multiply x2
|
|
glBlendFunc(GL_DST_COLOR,GL_SRC_COLOR);
|
|
break;
|
|
}
|
|
}else
|
|
{
|
|
glDisable(GL_BLEND);
|
|
glBlendFunc(GL_ONE,GL_ZERO);
|
|
}
|
|
}
|
|
|
|
if (LastRS.AlphaThreshold != LocalRM.AlphaThreshold)
|
|
{
|
|
if (LocalRM.AlphaThreshold)
|
|
{
|
|
glAlphaFunc(GL_GEQUAL,(float)LocalRM.AlphaThreshold / 255.0f);
|
|
glEnable(GL_ALPHA_TEST);
|
|
} else
|
|
glDisable(GL_ALPHA_TEST);
|
|
}
|
|
|
|
if (/*LocalRM.AnimFPS && */(LocalRM.AnimNbX != 1 || LocalRM.AnimNbY != 1))
|
|
{
|
|
float NewUVMatrix[6];
|
|
u16 TextureIdx, XTextureIdx, YTextureIdx;
|
|
|
|
NewUVMatrix[0] = LocalRM.UVMATRIX[0]/LocalRM.AnimNbX;
|
|
NewUVMatrix[1] = LocalRM.UVMATRIX[1]/LocalRM.AnimNbX;
|
|
NewUVMatrix[2] = LocalRM.UVMATRIX[2]/LocalRM.AnimNbY;
|
|
NewUVMatrix[3] = LocalRM.UVMATRIX[3]/LocalRM.AnimNbY;
|
|
|
|
if (LocalRM.AnimTime)
|
|
{
|
|
TextureIdx = ((int)((double)(timeGetTime() - LocalRM.AnimTime) *LocalRM.AnimFPS / 1000)) % (LocalRM.AnimNbX*LocalRM.AnimNbY);
|
|
XTextureIdx = TextureIdx % LocalRM.AnimNbX;
|
|
YTextureIdx = TextureIdx / LocalRM.AnimNbX;
|
|
YTextureIdx = LocalRM.AnimNbY - YTextureIdx - 1;
|
|
} else
|
|
{
|
|
XTextureIdx = 0;
|
|
YTextureIdx = LocalRM.AnimNbY - 1;
|
|
}
|
|
|
|
NewUVMatrix[4] = (LocalRM.UVMATRIX[0] + LocalRM.UVMATRIX[1])*XTextureIdx/LocalRM.AnimNbX + LocalRM.UVMATRIX[4];
|
|
NewUVMatrix[5] = (LocalRM.UVMATRIX[2] + LocalRM.UVMATRIX[3])*YTextureIdx/LocalRM.AnimNbY + LocalRM.UVMATRIX[5];
|
|
Setexture(TextureIndex, NewUVMatrix);
|
|
} else
|
|
Setexture(TextureIndex,LocalRM.UVMATRIX);
|
|
|
|
if (LocalRM.TEXTUREREPEAT_U)
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
|
else
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
|
|
|
|
if (LocalRM.TEXTUREREPEAT_V)
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
|
|
else
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
|
|
|
|
if (LocalRM.TEXTUREBILINEAR)
|
|
{
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
if ((TextureIndex == -1) || AllRef[TextureIndex].IsMipMapped)
|
|
{
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 4);
|
|
} else
|
|
{
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
if ((TextureIndex == -1) || AllRef[TextureIndex].IsMipMapped)
|
|
{
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 4);
|
|
} else
|
|
{
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
}
|
|
}
|
|
|
|
GLenum ZFonc = GL_GEQUAL;
|
|
u32 ZNeedUpdate = 0;
|
|
|
|
if (LastRS.ZEQUAL != LocalRM.ZEQUAL)
|
|
{
|
|
ZNeedUpdate = 1;
|
|
if (LocalRM.ZEQUAL)
|
|
ZFonc = GL_EQUAL;
|
|
}
|
|
if (LastRS.ZPASS != LocalRM.ZPASS)
|
|
{
|
|
ZNeedUpdate = 1;
|
|
if (LocalRM.ZPASS)
|
|
ZFonc = GL_ALWAYS;
|
|
}
|
|
if (ZNeedUpdate)
|
|
glDepthFunc(ZFonc);
|
|
|
|
|
|
|
|
if (LastRS.HIDECOLOR != LocalRM.HIDECOLOR)
|
|
{
|
|
if (LocalRM.HIDECOLOR)
|
|
glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,LocalRM.HIDEALPHA ? GL_FALSE : GL_TRUE);
|
|
else
|
|
glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,LocalRM.HIDEALPHA ? GL_FALSE : GL_TRUE);
|
|
}
|
|
|
|
|
|
//if (LastRS.MappingMode != LocalRM.MappingMode)
|
|
{
|
|
switch (LocalRM.MappingMode)
|
|
{
|
|
default:
|
|
if (LastRS.MappingMode != 0)
|
|
{
|
|
glDisable(GL_TEXTURE_GEN_S);
|
|
glDisable(GL_TEXTURE_GEN_T);
|
|
glDisable(GL_TEXTURE_GEN_R);
|
|
glDisable(GL_TEXTURE_GEN_Q);
|
|
}
|
|
break;
|
|
case 1: //chrome
|
|
{
|
|
/*GLfloat _4x4_Persp[16];
|
|
GLfloat _4x4_Model[16];
|
|
GLfloat _4x4_Texture[16];
|
|
glGetFloatv(GL_PROJECTION_MATRIX,_4x4_Persp);
|
|
glGetFloatv(GL_MODELVIEW_MATRIX,_4x4_Model);
|
|
glGetFloatv(GL_TEXTURE_MATRIX,_4x4_Texture);
|
|
_4x4_Model[12] = _4x4_Model[13] = _4x4_Model[14] = 0.0f;
|
|
_4x4_Model[14] = 0.0f;
|
|
glMatrixMode(GL_TEXTURE);
|
|
glTranslatef(0.5,0.5,-1 );
|
|
glMultMatrixf( _4x4_Model );
|
|
glScalef(-0.5,-0.5,-0.5);
|
|
/**/
|
|
GLfloat _4x4_Persp[16];
|
|
GLfloat _4x4_Model[16];
|
|
GLfloat _4x4_Texture[16];
|
|
|
|
GetMatrix(GL_PROJECTION_MATRIX,_4x4_Persp);
|
|
GetMatrix(GL_MODELVIEW_MATRIX,_4x4_Model);
|
|
GetMatrix(GL_TEXTURE_MATRIX,_4x4_Texture);
|
|
|
|
_4x4_Model[12] = _4x4_Model[13] = _4x4_Model[14] = 0.0f;
|
|
_4x4_Model[14] = 0.0f;
|
|
glMatrixMode(GL_TEXTURE);
|
|
glTranslatef(0.5,0.5,-1 );
|
|
glMultMatrixf( _4x4_Model );
|
|
glScalef(-0.5,-0.5,-0.5);
|
|
|
|
glDisable(GL_TEXTURE_GEN_S);
|
|
glDisable(GL_TEXTURE_GEN_T);
|
|
glDisable(GL_TEXTURE_GEN_R);
|
|
glDisable(GL_TEXTURE_GEN_Q);//*/
|
|
|
|
}
|
|
break;
|
|
case 2: //Planar Z
|
|
{
|
|
GLfloat P0123_S[] = {1,0,0,0};
|
|
GLfloat P0123_T[] = {0,1,0,0};
|
|
GLfloat P0123_R[] = {0,0,1,0};
|
|
GLfloat P0123_Q[] = {0,0,0,1};
|
|
glTexGeni(GL_S,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);
|
|
glTexGeni(GL_T,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);
|
|
glTexGeni(GL_R,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);
|
|
glTexGeni(GL_Q,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);
|
|
glTexGenfv(GL_S,GL_OBJECT_PLANE,(GLfloat *)P0123_S);
|
|
glTexGenfv(GL_T,GL_OBJECT_PLANE,(GLfloat *)P0123_T);
|
|
glTexGenfv(GL_R,GL_OBJECT_PLANE,(GLfloat *)P0123_R);
|
|
glTexGenfv(GL_Q,GL_OBJECT_PLANE,(GLfloat *)P0123_Q);
|
|
glEnable(GL_TEXTURE_GEN_S);
|
|
glEnable(GL_TEXTURE_GEN_T);
|
|
glEnable(GL_TEXTURE_GEN_R);
|
|
glEnable(GL_TEXTURE_GEN_Q);
|
|
}
|
|
break;
|
|
case 3: //Screen
|
|
{
|
|
GLfloat P0123_S[] = {1,0,0,0};
|
|
GLfloat P0123_T[] = {0,1,0,0};
|
|
GLfloat P0123_R[] = {0,0,1,0};
|
|
GLfloat P0123_Q[] = {0,0,0,1};
|
|
glTexGeni(GL_S,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);
|
|
glTexGeni(GL_T,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);
|
|
glTexGeni(GL_R,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);
|
|
glTexGeni(GL_Q,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);
|
|
glTexGenfv(GL_S,GL_OBJECT_PLANE,(GLfloat *)P0123_S);
|
|
glTexGenfv(GL_T,GL_OBJECT_PLANE,(GLfloat *)P0123_T);
|
|
glTexGenfv(GL_R,GL_OBJECT_PLANE,(GLfloat *)P0123_R);
|
|
glTexGenfv(GL_Q,GL_OBJECT_PLANE,(GLfloat *)P0123_Q);
|
|
glEnable(GL_TEXTURE_GEN_S);
|
|
glEnable(GL_TEXTURE_GEN_T);
|
|
glEnable(GL_TEXTURE_GEN_R);
|
|
glEnable(GL_TEXTURE_GEN_Q);
|
|
|
|
GLfloat _4x4_Persp[16];
|
|
GLfloat _4x4_Model[16];
|
|
GLfloat _4x4_Texture[16];
|
|
|
|
GetMatrix(GL_PROJECTION_MATRIX,_4x4_Persp);
|
|
GetMatrix(GL_MODELVIEW_MATRIX,_4x4_Model);
|
|
GetMatrix(GL_TEXTURE_MATRIX,_4x4_Texture);
|
|
|
|
glMatrixMode(GL_TEXTURE);
|
|
// glLoadIdentity();
|
|
glTranslatef(0.5,0.5,0);
|
|
if (TextureIndex != -1)
|
|
glScalef(0.5f, 0.5f * ((float)FB_SY / (float)FB_SX) * (float)AllRef[TextureIndex].pExtRef->SX/(float)AllRef[TextureIndex].pExtRef->SY,1);
|
|
glMultMatrixf( _4x4_Persp );
|
|
glMultMatrixf( _4x4_Model );
|
|
}
|
|
break;
|
|
}
|
|
}//*/
|
|
|
|
CurrentRS = LocalRM;
|
|
LastRS = LocalRM;
|
|
if (FORCE_RENDER_FLAG & 2)
|
|
{
|
|
LastRS.NOZTEST = 1;
|
|
}
|
|
if (FORCE_RENDER_FLAG & 1)
|
|
{
|
|
LastRS.NOZWRITE = 1;
|
|
}
|
|
STOP_RASTER(SetRenderState);
|
|
}
|
|
|
|
void OGL_DI::GetMatrix(u32 Mode,float *pDest)
|
|
{
|
|
|
|
switch (Mode)
|
|
{
|
|
case 0://Projection
|
|
case GL_PROJECTION:
|
|
case GL_PROJECTION_MATRIX:
|
|
memcpy(pDest,OPTIM_4x4_Persp,sizeof(OPTIM_4x4_Persp));
|
|
break;
|
|
case 1://Model
|
|
case GL_MODELVIEW:
|
|
case GL_MODELVIEW_MATRIX:
|
|
memcpy(pDest,OPTIM_4x4_Model,sizeof(OPTIM_4x4_Model));
|
|
break;
|
|
case 2://Texture
|
|
case GL_TEXTURE:
|
|
case GL_TEXTURE_MATRIX:
|
|
memcpy(pDest,OPTIM_4x4_Texture,sizeof(OPTIM_4x4_Texture));
|
|
break;
|
|
}
|
|
}
|
|
void OGL_DI::SetMatrix(u32 Mode,float *pDest)
|
|
{
|
|
float Identity[16];
|
|
if (pDest == NULL)
|
|
{
|
|
memset(Identity,0,sizeof(Identity));
|
|
Identity[0] = Identity[5] = Identity[10] = Identity[15] = 1.0f;
|
|
pDest = Identity;
|
|
}
|
|
switch (Mode)
|
|
{
|
|
case 0://Projection
|
|
case GL_PROJECTION://
|
|
case GL_PROJECTION_MATRIX:
|
|
memcpy(OPTIM_4x4_Persp,pDest,sizeof(OPTIM_4x4_Persp));
|
|
glMatrixMode(GL_PROJECTION);
|
|
glLoadMatrixf(pDest);
|
|
break;
|
|
case 1://Model
|
|
case GL_MODELVIEW://
|
|
case GL_MODELVIEW_MATRIX:
|
|
memcpy(OPTIM_4x4_Model,pDest,sizeof(OPTIM_4x4_Model));
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glLoadMatrixf(pDest);
|
|
break;
|
|
case 2://Texture
|
|
case GL_TEXTURE://
|
|
case GL_TEXTURE_MATRIX:
|
|
memcpy(OPTIM_4x4_Texture,pDest,sizeof(OPTIM_4x4_Texture));
|
|
glMatrixMode(GL_TEXTURE);
|
|
glLoadMatrixf(pDest);
|
|
break;
|
|
}
|
|
}
|
|
|