bool MFRenderer_ResetDisplay(MFDisplay *pDisplay, const MFDisplaySettings *pSettings)
{
MFDebug_Warn(4, MFStr("MFRenderer_ResetDisplay(%d, %d, %s)", pSettings->width, pSettings->height, pSettings->bFullscreen ? "true" : "false"));
bool bFullscreenChanged = pDisplay->settings.bFullscreen != pSettings->bFullscreen;
// change display mode...
if(bFullscreenChanged || (pSettings->bFullscreen && (pDisplay->settings.width != pSettings->width || pDisplay->settings.height != pSettings->height)))
{
#if MF_DISPLAY == MF_DRIVER_WIN32
if(pSettings->bFullscreen)
{
DEVMODE dmScreenSettings;
memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
dmScreenSettings.dmSize = sizeof(dmScreenSettings);
dmScreenSettings.dmPelsWidth = pSettings->width;
dmScreenSettings.dmPelsHeight = pSettings->height;
dmScreenSettings.dmBitsPerPel = 32;
dmScreenSettings.dmFields = DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
if(ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
{
MFDebug_Warn(2, "The requested fullscreen mode is not supported by your video card.");
return false;
}
if(bFullscreenChanged)
ShowCursor(FALSE);
}
else
{
if(ChangeDisplaySettings(NULL, 0) != DISP_CHANGE_SUCCESSFUL)
{
MFDebug_Warn(2, "Unable to return to windowed mode!");
return false;
}
if(bFullscreenChanged)
ShowCursor(TRUE);
}
#endif
}
gpDeviceColourTarget->imageFormat = ImgFmt_A8R8G8B8;
gpDeviceColourTarget->pSurfaces[0].width = pSettings->width;
gpDeviceColourTarget->pSurfaces[0].height = pSettings->height;
gpDeviceColourTarget->pSurfaces[0].platformData = (uint64)gDefaultRenderTarget;
gpDeviceZTarget->imageFormat = ImgFmt_D24S8;
gpDeviceZTarget->pSurfaces[0].width = pSettings->width;
gpDeviceZTarget->pSurfaces[0].height = pSettings->height;
gpDeviceZTarget->pSurfaces[0].platformData = 0;
gpDeviceRenderTarget->width = pSettings->width;
gpDeviceRenderTarget->height = pSettings->height;
MFRenderer_ResetViewport();
return true;
}
bool MFRenderer_BeginFramePlatformSpecific()
{
if(MFCheckForOpenGLError())
return false;
#if defined(MF_IPHONE)
MFRendererIPhone_MakeCurrent();
#endif
MFRenderer_SetDeviceRenderTarget();
MFRenderer_ResetViewport();
if(MFCheckForOpenGLError())
return false;
return true;
}
int MFMat_Standard_Begin(MFMaterial *pMaterial, MFRendererState &state)
{
MFMat_Standard_Data *pData = (MFMat_Standard_Data*)pMaterial->pInstanceData;
MFEffectTechnique *pTechnique = NULL;
if(pData->pEffect)
pTechnique = MFEffect_GetTechnique(pData->pEffect, state);
MFDebug_Assert(pTechnique, "No technique!");
MFEffectData_OpenGL &techniqueData = *(MFEffectData_OpenGL*)pTechnique->pPlatformData;
if(pTechnique != state.pTechniqueSet)
{
state.pTechniqueSet = pTechnique;
glUseProgram(techniqueData.program);
// need to clear all the cache states
//... or ignore the state caching for now
}
// bools
/* do a bitscan loop over the bool states
uint32 boolState = state.bools & state.rsSet[MFSB_CT_Bool];
uint32 req = pTechnique->renderStateRequirements[MFSB_CT_Bool];
if(req)
{
uint32 vsReq = pVS->renderStateRequirements[MFSB_CT_Bool];
uint32 psReq = pPS->renderStateRequirements[MFSB_CT_Bool];
if((state.boolsSet & req) != (boolState & req))
{
BOOL bools[32];
for(uint32 i=0, b=1; i<MFSCB_Max; ++i, b<<=1)
bools[i] = (boolState & b) != 0;
if((state.boolsSet & vsReq) != (boolState & vsReq))
pd3dDevice->SetVertexShaderConstantB(0, bools, 32);
if((state.boolsSet & psReq) != (boolState & psReq))
pd3dDevice->SetPixelShaderConstantB(0, bools, 32);
}
}
*/
// matrices
uint32 req = pTechnique->renderStateRequirements[MFSB_CT_Matrix];
uint32 i;
while(MFUtil_BitScanReverse(req, &i))
{
uint32 b = MFBIT(i);
req ^= b;
// if(state.pMatrixStatesSet[i] != state.pMatrixStates[i])
{
MFMatrix *pM;
if(i > MFSCM_DerivedStart)
pM = state.getDerivedMatrix((MFStateConstant_Matrix)i);
else
pM = state.pMatrixStates[i];
// state.pMatrixStatesSet[i] = pM;
GLint uniform = techniqueData.uniformLocation[MFSB_CT_Matrix][i];
glUniformMatrix4fv(uniform, 1, GL_TRUE, (float*)pM);
}
}
// vectors
req = pTechnique->renderStateRequirements[MFSB_CT_Vector];
while(MFUtil_BitScanReverse(req, &i))
{
uint32 b = MFBIT(i);
req ^= b;
// if(state.pVectorStatesSet[i] != state.pVectorStates[i])
{
MFVector *pV = state.pVectorStates[i];
// state.pVectorStatesSet[i] = pV;
GLint uniform = techniqueData.uniformLocation[MFSB_CT_Vector][i];
glUniform4fv(uniform, 1, (float*)pV);
}
}
// textures
req = pTechnique->renderStateRequirements[MFSB_CT_Texture];
while(MFUtil_BitScanReverse(req, &i))
{
req ^= MFBIT(i);
MFTexture *pT = state.pTextures[i];
if(state.pTexturesSet[i] != pT)
{
state.pTexturesSet[i] = pT;
glActiveTexture(GL_TEXTURE0 + i);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, (GLuint)(size_t)pT->pInternalData);
}
/*
else
{
glActiveTexture(GL_TEXTURE0 + i);
glDisable(GL_TEXTURE_2D);
}
*/
MFSamplerState *pS = (MFSamplerState*)state.pRenderStates[MFSCRS_DiffuseSamplerState + i];
// if(state.pRenderStatesSet[MFSCRS_DiffuseSamplerState + i] != pS)
{
// state.pRenderStatesSet[MFSCRS_DiffuseSamplerState + i] = pS;
GLint uniform = techniqueData.uniformLocation[MFSB_CT_RenderState][MFSCRS_DiffuseSamplerState + i];
GLint sampler = (GLint)(size_t)pS->pPlatformData;
glUniform1i(uniform, i);
glBindSampler(i, sampler);
}
}
// blend state
MFBlendState *pBlendState = (MFBlendState*)state.pRenderStates[MFSCRS_BlendState];
if(state.pRenderStatesSet[MFSCRS_BlendState] != pBlendState)
{
state.pRenderStatesSet[MFSCRS_BlendState] = pBlendState;
if(pBlendState->stateDesc.bIndependentBlendEnable)
{
for(int j=0; j<8; ++j)
{
MFBlendStateDesc::RenderTargetBlendDesc &target = pBlendState->stateDesc.renderTarget[j];
if(target.bEnable)
{
glEnable(GL_BLEND);
glBlendEquationSeparatei(j, glBlendOp[target.blendOp], glBlendOp[target.blendOpAlpha]);
glBlendFuncSeparatei(j, glBlendArg[target.srcBlend], glBlendArg[target.destBlend], glBlendArg[target.srcBlendAlpha], glBlendArg[target.destBlendAlpha]);
}
else
glDisable(GL_BLEND);
glColorMaski(j, target.writeMask & MFColourWriteEnable_Red, target.writeMask & MFColourWriteEnable_Green, target.writeMask & MFColourWriteEnable_Blue, target.writeMask & MFColourWriteEnable_Alpha);
}
}
else
{
MFBlendStateDesc::RenderTargetBlendDesc &target = pBlendState->stateDesc.renderTarget[0];
if(target.bEnable)
{
glEnable(GL_BLEND);
glBlendEquationSeparate(glBlendOp[target.blendOp], glBlendOp[target.blendOpAlpha]);
glBlendFuncSeparate(glBlendArg[target.srcBlend], glBlendArg[target.destBlend], glBlendArg[target.srcBlendAlpha], glBlendArg[target.destBlendAlpha]);
}
else
glDisable(GL_BLEND);
glColorMask(target.writeMask & MFColourWriteEnable_Red, target.writeMask & MFColourWriteEnable_Green, target.writeMask & MFColourWriteEnable_Blue, target.writeMask & MFColourWriteEnable_Alpha);
}
}
// rasteriser state
MFRasteriserState *pRasteriserState = (MFRasteriserState*)state.pRenderStates[MFSCRS_RasteriserState];
if(state.pRenderStatesSet[MFSCRS_RasteriserState] != pRasteriserState)
{
state.pRenderStatesSet[MFSCRS_RasteriserState] = pRasteriserState;
switch(pRasteriserState->stateDesc.cullMode)
{
case MFCullMode_None:
glDisable(GL_CULL_FACE);
break;
case MFCullMode_CCW:
glEnable(GL_CULL_FACE);
glFrontFace(GL_CW);
glCullFace(GL_BACK);
break;
case MFCullMode_CW:
glEnable(GL_CULL_FACE);
glFrontFace(GL_CCW);
glCullFace(GL_BACK);
break;
default:
MFUNREACHABLE;
}
}
// depth/stencil state
MFDepthStencilState *pDSState = (MFDepthStencilState*)state.pRenderStates[MFSCRS_DepthStencilState];
if(state.pRenderStatesSet[MFSCRS_DepthStencilState] != pDSState)
{
state.pRenderStatesSet[MFSCRS_DepthStencilState] = pDSState;
if(pDSState->stateDesc.bDepthEnable)
{
glEnable(GL_DEPTH_TEST);
glDepthFunc(glCompareFunc[pDSState->stateDesc.depthFunc]);
glDepthMask(pDSState->stateDesc.depthWriteMask == MFDepthWriteMask_Zero ? GL_FALSE : GL_TRUE);
}
else
glDisable(GL_DEPTH_TEST);
}
// setup alpha test
if(state.boolChanged(MFSCB_AlphaTest) || (state.pVectorStatesSet[MFSCV_RenderState] != state.pVectorStates[MFSCV_RenderState] && state.getBool(MFSCB_AlphaTest)))
{
MFVector *pRS = state.pVectorStates[MFSCV_RenderState];
state.pVectorStatesSet[MFSCV_RenderState] = pRS;
state.boolsSet = (state.boolsSet & ~MFBIT(MFSCB_AlphaTest)) | (state.bools & MFBIT(MFSCB_AlphaTest));
#if !defined(MF_OPENGL_ES)
if(state.getBool(MFSCB_AlphaTest))
{
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GEQUAL, pRS->x);
}
else
glDisable(GL_ALPHA_TEST);
#else
// TODO: do something here...
//I guess we need to implement the alpha test in the shader...
#endif
}
/*
// set clour/alpha scales
if(state.pVectorStatesSet[MFSCV_User0] != state.pVectorStates[MFSCV_User0])
{
MFVector *pMask = state.pVectorStates[MFSCV_User0];
state.pVectorStatesSet[MFSCV_User0] = pMask;
// pd3dDevice->SetVertexShaderConstantF(r_colourMask, (float*)pMask, 1);
}
*/
// set animation matrices
if(state.getBool(MFSCB_Animated))
{
MFDebug_Assert(false, "TODO!");
// for(uint32 b=0; b<state.matrixBatch.numMatrices; b++)
// MFRendererPC_SetAnimationMatrix(b, state.animation.pMatrices[state.matrixBatch.pIndices[b]]);
}
// set viewport
if(state.pViewportSet != state.pViewport)
{
if(!state.pViewport)
MFRenderer_ResetViewport();
else
MFRenderer_SetViewport(state.pViewport);
state.pViewportSet = state.pViewport;
}
MFCheckForOpenGLError(true);
// update the bools 'set' state
state.boolsSet = state.bools & state.rsSet[MFSB_CT_Bool];
return 0;
}
void MFRenderer_ResetDisplay()
{
MFRenderer_ResetViewport();
}
int MFDisplay_CreateDisplay(int width, int height, int bpp, int rate, bool vsync, bool triplebuffer, bool wide, bool progressive)
{
MFCALLSTACK;
DWORD avPack = XGetAVPack();
DWORD vidMode = XGetVideoStandard();
DWORD vidFlags = XGetVideoFlags();
// log the AV pack (just an FYI)
switch(avPack)
{
case XC_AV_PACK_SCART: MFDebug_Log(2, "MFDisplay: Video output using Scart AV Pack"); break;
case XC_AV_PACK_HDTV: MFDebug_Log(2, "MFDisplay: Video output using High Def Pack"); break;
case XC_AV_PACK_RFU: MFDebug_Log(2, "MFDisplay: Video output using RF Unit"); break;
case XC_AV_PACK_SVIDEO: MFDebug_Log(2, "MFDisplay: Video output using Advanced AV Pack"); break;
case XC_AV_PACK_STANDARD: MFDebug_Log(2, "MFDisplay: Video output using Standard AV Pack"); break;
default: MFDebug_Log(2, "MFDisplay: Video output using Unknown AV Pack"); break;
}
// calculate the frame buffer size and display mode from the dashboard info
gbWidescreen = !!(vidFlags & (XC_VIDEO_FLAGS_WIDESCREEN));
gbLetterBox = !!(vidFlags & (XC_VIDEO_FLAGS_LETTERBOX));
wide = gbWidescreen;
if(vidMode == XC_VIDEO_STANDARD_PAL_I)
{
// PAL modes (poor PAL users dont get high def) :(
if(vidFlags & XC_VIDEO_FLAGS_PAL_60Hz)
{
width = 720;
height = 480;
rate = 60;
progressive = false;
MFDebug_Log(2, MFStr("MFDisplay: Video Mode set to PAL60%s", wide ? " (Widescreen)" : (gbLetterBox ? " (Letterbox)" : "")));
}
else
{
width = 720;
height = 576;
rate = 50;
progressive = false;
MFDebug_Log(2, MFStr("MFDisplay: Video Mode set to PAL (576i)%s", wide ? " (Widescreen)" : (gbLetterBox ? " (Letterbox)" : "")));
}
}
else
{
// NTSC modes
if(vidFlags & XC_VIDEO_FLAGS_HDTV_1080i)
{
width = 1920;
height = 1080;
rate = 60;
progressive = false;
MFDebug_Log(2, "MFDisplay: Video Mode set to 1080i");
}
else if(vidFlags & XC_VIDEO_FLAGS_HDTV_720p)
{
width = 1280;
height = 720;
rate = 60;
progressive = true;
MFDebug_Log(2, "MFDisplay: Video Mode set to 720p");
}
else if(vidFlags & XC_VIDEO_FLAGS_HDTV_480p)
{
width = 720;
height = 480;
rate = 60;
progressive = true;
MFDebug_Log(2, MFStr("MFDisplay: Video Mode set to 480p%s", wide ? " (Widescreen)" : (gbLetterBox ? " (Letterbox)" : "")));
}
else
{
width = 720;
height = 480;
rate = 60;
progressive = false;
MFDebug_Log(2, MFStr("MFDisplay: Video Mode set to NTSC (480i)%s", wide ? " (Widescreen)" : (gbLetterBox ? " (Letterbox)" : "")));
}
}
// update display parameters
gDisplay.fullscreenWidth = gDisplay.width = width;
gDisplay.fullscreenHeight = gDisplay.height = height;
gDisplay.progressive = progressive;
gDisplay.refreshRate = rate;
gDisplay.wide = wide;
gDisplay.colourDepth = bpp;
gDisplay.windowed = false;
MFRenderer_CreateDisplay();
// setup the initial viewport (letterbox)
MFRenderer_ResetViewport();
return 0;
}
